Implement a Minimal JVM That Runs Hello World

Topic Overview

A Minimal JVM

Running \`Hello World\` on a toy JVM requires class parsing, constant pool resolution, and a bytecode interpreter for a handful of opcodes. Real HotSpot adds tiers, GC, and intrinsics; the core loop is the same fetch-decode-execute pattern as your bytecode VM.

Subset for Hello World

Minimum capabilities:

• Parse \`.class\` header and constant pool
• Resolve \`#main\` ([Ljava/lang/String;)V
• Execute \`ldc\`, \`invokevirtual\`, \`return\` for \`println\`

Native methods (\`System.out\`) can be stubbed: when bytecode hits \`getstatic\` on \`out\`, return a handle your runtime recognizes.

For example, \`getstatic java/lang/System.out\` followed by \`ldc "Hello"\` and \`invokevirtual println\` is the entire program path.

Frame setup mirrors the JVM spec: local array sized from \`max_locals\`, operand stack from \`max_stack\`.

Design Notes

Stub native methods with logging first so you know which host calls fire during Hello World. Real JVMs map hundreds of natives; a toy runtime can fake `println` with a single special case.

For This Exercise

This exercise asks you to implement a minimal JVM that loads one class and runs \`main\`. You will parse enough of the class file and interpret enough opcodes to print Hello World.

You will use the same mental model here when reading production interpreter source later in the track. Sketch one concrete input on paper, predict the outcome, then confirm with code. That discipline catches logic errors early and makes debugging far faster when you extend the implementation in follow-on tasks.

Your Task

Build a minimal JVM interpreter that runs real bytecode:

• frames with local variable arrays and operand stacks;
• a fetch-decode-execute loop;
• static calls and returns;
• System.out.println for ints and strings;
• Java's exception behaviour for division by zero, missing methods and deep recursion, with a stack trace.

Methods are given the same way as in the javap task.

Input

// starts a comment.

cCopy
Loading…

Supported instructions

The same opcodes as the javap task, executed with Java semantics:

• Constants: iconst_*, bipush, sipush, ldc (an Integer or String constant).
• Locals: iload*/aload*, istore*/astore*, iinc.
• Stack: pop, dup.
• Arithmetic: iadd isub imul idiv irem ineg, wrapping at 32 bits. MIN_VALUE / -1 is MIN_VALUE, and % -1 is 0.
• Branches: if*, if_icmp*, goto. Offsets are relative to the branch instruction.
• Calls: getstatic java/lang/System.out:Ljava/io/PrintStream;, invokevirtual java/io/PrintStream.println:(I)V or …(Ljava/lang/String;)V (prints a line), and invokestatic of a method of this class. Arguments are popped into the callee's locals 0, 1, …
• Returns: ireturn/return, which must match the descriptor's return type.

Rules

• Exceptions: print Exception in thread "main" TYPE, then one \tat CLASS.METHOD(pc P) line per frame, innermost first. A tab starts each line, and P is the frame's current instruction (for callers, the invokestatic). Print at most 6 frames, then \t... N more.
  • java.lang.ArithmeticException: / by zero for idiv/irem by 0;
  • java.lang.NoSuchMethodError: CLASS.NAMEDESC for an invokestatic that resolves to nothing;
  • java.lang.StackOverflowError for a call made when 200 frames exist.
• VerifyErrors stop the run with one line:
  • VerifyError: stack underflow at METHOD PC (OP)
  • VerifyError: ireturn in NAMEDESC (or return)
  • VerifyError: unknown opcode 0xXX in METHOD at PC
  • VerifyError: METHOD falls off the end of its code
  • VerifyError: only System.out is supported by getstatic
  • VerifyError: operand stack overflow in METHOD
• Success: NAME returned [V] after N instructions, max depth D. Only the entry method's return prints this line.
• trace on prints METHOD PC: OPNAME [stack] before each instruction (the opname padded to 14). The stack shows ints, "strings", System.out and null.
• Errors:
  • run: no method NAMEDESC
  • run: NAMEDESC needs N int argument(s)
  • run: NAME DESCRIPTOR [INT ARGS]
  • method: [FLAGS] NAME DESCRIPTOR
  • bad byte: X
  • bad pool entry: LINE
  • unexpected line: LINE

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Give each call its own frame, holding its method, pc, locals and operand stack. Return pops the frame and pushes the value onto the caller's stack.
2. Build stack traces by walking the frames. Never keep a separate call log.

Hidden tests cover recursion (fib), a loop printing a sum, division by zero two frames deep, runaway recursion, a missing method, MIN_VALUE edge cases, and the VerifyErrors for underflow, return mismatch, unknown opcodes, falling off the end and an unsupported getstatic.