Virtual Machines & RuntimesJVM InternalsHard

Parse a .class File Format Manually

Master the fundamental concepts of jvm internals through this focused micro-challenge.

~90 minutes JVM Internals Ready to learn

Topic Overview

The .class File Format

Java bytecode lives in a structured binary format specified in the JVM spec chapter 4. Parsing it manually teaches you what \`javap\` reads under the hood.

Major Sections

After the magic \`0xCAFEBABE\` and version fields:

Constant pool: UTF-8 strings, class names, method refs, numeric constants
Access flags, this/super class, interfaces
Fields and methods with \`Code\` attributes holding bytecode
Attributes: \`LineNumberTable\`, \`StackMapTable\`, etc.

The constant pool is the spine. Opcodes like \`ldc #5\` index into it; \`invokevirtual\` references a method ref entry pairing class and name.

For example, \`Hello.class\` might pool \`"Hello"\`, \`"java/lang/Object"\`, and \`Code\` bytes for \`main\`.

\`\`\` magic: CA FE BA BE version: minor, major constant_pool_count: ... \`\`\`

Design Notes

Constant pool indices are one-based in the spec but easy to mishandle in parsers. Validate every index against pool length before dereferencing or you will read garbage UTF-8 strings silently.

For This Exercise

This exercise asks you to parse or document \`.class\` layout field by field. You will read magic, version, and constant pool entries from raw bytes the way a minimal class loader would.

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.

Implementation Task

Your Task

Parse a Java .class file from its raw bytes, as javap -v does:

the magic and version;
the constant pool, with every symbolic reference resolved to text;
the access flags and this/super class;
the interfaces;
the fields and methods, with their attributes.

All multi-byte values are big-endian.

Input

Hex bytes (2 digits each, whitespace-separated). A token starting with # comments out the rest of its line. The token next separates several class files, whose outputs are separated by a line ---.

Layout

c
Loading…

Constant pool tags:

1 Utf8 (u2 length + bytes)
3 Integer (u4)
5 Long (u8; it occupies two slots, so the next index is unused)
7 Class (name index)
8 String (utf8 index)
9 Fieldref, 10 Methodref, 11 InterfaceMethodref (class index, name-and-type index)
12 NameAndType (name index, descriptor index)

Output

c
Loading…

Version: major ≥ 49 is Java (major - 44), and 45-48 is Java 1.(major - 44).
Pool lines: %5s = %-18s with #N and the tag name, then the value.
- Utf8 prints its text; Integer its value; Long its value with an l suffix.
- Class and String print #i. NameAndType prints #n:#d. The refs print #c.#nt.
- Resolved entries pad that field to 14 and append // TEXT: the class or string text, name:desc (a name starting with < is quoted, as in "<init>":()V), or class.name:desc.
Class flags, in this order: PUBLIC 0x1, FINAL 0x10, SUPER 0x20, INTERFACE 0x200, ABSTRACT 0x400, SYNTHETIC 0x1000, ANNOTATION 0x2000, ENUM 0x4000.
Member flags: PUBLIC, PRIVATE 0x2, PROTECTED 0x4, STATIC 0x8, FINAL 0x10, SYNCHRONIZED 0x20, VOLATILE 0x40, NATIVE 0x100, ABSTRACT 0x400.
interfaces lists the names in parentheses when there are any. super_class 0 prints none.
Member lines: NAME DESC FLAGS, plus attributes: Name(len), … if there are any.
End: warning: N trailing bytes if bytes remain after the class attributes, then parsed N bytes.

Errors

Parsing stops with one line (what was printed before it stays):

error: bad magic XXXXXXXX (expected CAFEBABE)
error: truncated at offset N (the offset of the read that ran out)
error: unknown constant tag T at #i (offset N)
error: constant #i refers to #j, which is not Utf8|a Class|a NameAndType
error: empty input
bad byte: X (the whole file is rejected)

Pool references are checked while printing the pool. Member references report #0 as the referrer.

Example

Input:

c
Loading…

Output:

c
Loading…

Requirements

Read through a cursor with bounds-checked u1/u2/u4 helpers, so a malformed file can never read out of bounds.
Store the pool first, then resolve the references in a second pass. Entries may refer forward.

Hidden tests cover an interface with an abstract method, Java 1.4 and Java 21 versions, trailing bytes, an unknown tag, a dangling reference, truncation inside a method, bad magic, empty input and a bad byte.