All Classes and Interfaces
Class
Description
An annotated entity.
A declared annotation.
An annotation property.
Property value struct.
Java annotation data.
Any array load or store instruction.
Loads a value from an array onto the stack.
State implementing the behavior of an array class.
Store a value from the stack into an array.
In bytecode attributes are used to represent anything that is not
part of the class structure.
Abstract superclass for all bytecode entities that hold attributes.
The BCClass represents a class object in the bytecode framework, in many
ways mirroring the
Class class of Java reflection.Class loader that will attempt to find requested classes in a given
Project.Interface implemented by all bytecode entities.
A field of a class.
A member field or method of a class.
A method of a class.
Base class for visitors on a bytecode entity.
Pseudo-instruction used to place
Class objects onto the stack.A constant pool entry describing a class.
An instruction that takes as an argument a class to operate
on.
An instruction comparing two stack values.
Representation of a code block of a class.
An entry in a code block.
Base class for field, method, and interface method constant pool
entries.
Interface implemented by entries representing constant values.
An instruction that that loads a constant onto the stack.
A bytecode constant pool, containing entries for all strings,
constants, classes, etc referenced in the class structure and method
opcodes.
Key for class entries.
Base class key for entries with two ptr to other entries.
Key for field entries.
Key for interface method entries.
Key for method entries.
Key for method entries.
Key for name and type entries.
Base class key for entries with one ptr to another entry.
Key for string entries.
Efficient representation of the constant pool as a table.
Interface to track constants used in bytecode.
A constant value for a member field.
A conversion opcode such as
i2l, f2i, etc.Attribute signifying that a method or class is deprecated.
A constant double value in the constant pool.
Base type for all constant pool entries.
Represents a
try {} catch() {} statement in bytecode.Attribute declaring the checked exceptions a method can throw.
A reference to a class field.
Instruction that takes as an argument a field to operate
on.
A constant float value in the constant pool.
Loads a value from a field onto the stack.
An instruction that specifies a position in the code block to jump to.
An if instruction such as
ifnull, ifeq, etc.The
iinc instruction.Any referenced class that is not a package member is represented by
this structure.
Attribute describing all referenced classes that are not package
members.
An opcode in a method of a class.
An entity that maintains ptrs to instructions in a code block.
InstructionPtrStrategy handles the different strategies for finding the
Instructions that InstructionPtrs point to.
A constant int value in the constant pool.
A reference to an interface method.
InvokeDynamic
u1 tag
u2 bootstrap_method_attr_index // References entry in Bootstrap Methods table
u2 name_and_type_index // References NameAndTypeEntry representing method name and descriptor
An instruction that specifies a position in the code block to jump to.
A line number corresponds to a sequence of opcodes that map logically
to a line of source code.
Code blocks compiled from source have line number tables mapping
opcodes to source lines.
Loads a value from the locals table to the stack.
A local variable or local variable type.
Code blocks compiled from source have local tables mapping
locals used in opcodes to their names and descriptions.
A local variable contains the name, description, index and scope
of a local used in opcodes.
An instruction that has an argument of an index into the
local variable table of the current frame.
Code blocks compiled from source have local variable tables mapping
locals used in opcodes to their names and descriptions.
A local variable type contains the name, signature, index and scope
of a generics-using local used in opcodes.
Code blocks compiled from source have local variable type tables mapping
generics-using locals used in opcodes to their names and signatures.
A long constant in the constant pool.
The
lookupswitch instruction.One of the math operations defined in the
Constants interface.A reference to a class method.
MethodHandle
u1 tag
u1 reference_kind
u2 reference_index
An instruction that invokes a method.
MethodType
u1 tag
u2 descriptor_index
The
monitorenter instruction.The
monitorexit instruction.A synchronization instruction.
The
multianewarray instruction, which creates a new
multi-dimensional array.Entry containing indexes referencing a name and a descriptor.
Caching and conversion of names in both internal and external form.
The
newarray instruction, which is used to create new
arrays of primitive types.Number utilities.
State implementing the behavior of an object type.
Visitor type that outputs a detailed, formatted document of the
visited entity; similar to the javap -c command but more detailed.
State implementing the behavior of a primitive class.
The Project represents a working set of classes.
Stores a value from the stack into a field.
The
ret instruction is used in the implementation of finally.Returns a value (or void) from a method.
Attribute naming the source file for this class.
Represents an instruction that manipulates the stack of the current
frame.
The State type is extended by various concrete types to change
the behavior of a
BCClass.An instruction to store a value from a local variable onto the stack.
A String constant in the constant pool.
String utiltity methods.
Contains functionality common to the different switch types
(TableSwitch and LookupSwitch).
Attribute marking a member as synthetic, or not present in the class
source code.
The
tableswitch instruction.Any typed instruction.
An unrecognized attribute; class files are allowed to contain
attributes that are not recognized, and the JVM must ignore them.
A unicode string value in the constant pool.
Interface denoting an entity that can accept a
BCVisitor and
provide its internal state to it.The
wide instruction, which is used to allow other
instructions to index values beyond what they can normally index baed
on the length of their arguments.