What is bytecode verification, and what specific categories of invalid or unsafe bytecode does the JVM's verifier reject before allowing a class to run?

Bytecode verification is a mandatory JVM safety check performed during the linking phase, ensuring loaded bytecode (whether from a trusted compiler or a potentially malicious/corrupted source) cannot violate the JVM's fundamental safety guarantees -- it checks for type safety (no operation is performed on operands of an incompatible type at any program point, verified through data-flow analysis rather than actual execution), correct stack usage (no stack underflow/overflow, consistent stack depth at branch merge points), valid control flow (jumps only to valid instruction boundaries, not into the middle of another instruction), and proper access control enforcement -- rejecting any class failing these checks with a VerifyError, providing a critical security boundary since verification happens independent of whatever produced the bytecode (an attacker could hand-craft malicious bytecode bypassing javac entirely).

// Conceptually, the verifier catches things like this at the bytecode level
// (this specific example wouldn't compile via javac, but illustrates what verification guards against
// if bytecode were maliciously hand-crafted to bypass the compiler)

// Pseudocode of an invalid bytecode sequence the verifier would reject:
// push an int onto the operand stack
// attempt to invoke a method expecting a String argument -- TYPE MISMATCH, rejected