Summary

Provide a standard API for parsing, generating, and transforming Java class files. This is a preview API.

Problem

Class-file generation, parsing, and instrumentation is ubiquitous in the Java ecosystem. Many tools and libraries process class files, and frameworks often perform on-the-fly bytecode instrumentation, transformation, and generation.

The Java ecosystem has many different libraries for class-file parsing and generation, each with different design goals, strengths and weaknesses. In the last decade the JDK has made extensive use of the [ASM] library in its implementation, for tasks such as lambda proxy generation. However, there are a number of reasons why it makes sense for the JDK to include its own authoritative class-file library.

• JVM evolution — The JVM and the class-file format are evolving much faster now than in the early years of the platform. While some evolutions are simple, for example adding new attributes such as NestMembers, others are more complex. Project Valhalla, for example, will bring new bytecodes and field descriptors. At some point it may become prohibitively expensive to evolve existing libraries to support these new features. A JDK class-file library can evolve with the class-file format, reducing the friction of implementing and testing new class-file features.

• JDK consolidation — The JDK itself is a significant dealer in class files. For historical reasons it contains four distinct internal class-file libraries:

  • A custom library in the jdk.compiler module, used by the javac compiler and the javadoc tool;

  • Another custom library in the jdk.jdeps module, used by the javap, jdeps, jdeprscan, and jlink tools;

  • A fork of BCEL in the java.xml module, used in a fork of Xalan; and

  • A fork of [ASM] in the java.base module, used in the implementation of lambdas, method handles, modules, dynamic proxies, JFR, and the jar, jimage, jlink, and jshell tools.

  In the case of ASM, using it to implement fundamental elements of the platform imposes a delay on the use of new class-file features. The ASM version for JDK N cannot finalize until JDK N finalizes, hence JDK tools such as jlink cannot process class-file features that are new in JDK N, hence javac cannot generate class-file features that are new in JDK N until JDK N+1. JDK developers need a class-file library that is kept up-to-date with the JVM.

• Version skew between frameworks and the running JDK — Applications which use frameworks that process class files generally bundle a class-file library. But new class-file features can appear in any JDK release, and the rate of JDK releases accelerated substantially after JDK 9, so applications are more frequently encountering class files that are newer than the library that they bundle. This results in runtime errors or, worse, frameworks trying to parse class files from the future and engaging in leaps of faith that nothing too serious has changed. Application and framework developers need a class-file library that they can count on to be up-to-date with the running JDK.

• Language improvements — An obvious idea is to "just" merge ASM into the JDK and take on responsibility for its ongoing maintenance, but this is not the right choice. ASM is an old code base with a lot of legacy baggage, it is difficult to evolve, and the design priorities that informed its architecture are likely not what we would choose today. Moreover, the Java language has improved substantially since ASM was created, so what might have been the best API idioms in 2002 may not be ideal two decades later.

Solution

Class-file API as an integral part of java.base module aims to address the issues. We have adopted the following design goals and principles for the API.

• Class-file entities are represented by immutable objects — All class-file entities, such as methods, fields, attributes, instructions, annotations, etc., are represented by immutable objects. This facilitates reliable sharing when a class file is being transformed.

• Tree-structured representation — A class file has a tree structure. A class has some metadata (name, supertype, etc.), and a variable number of fields, methods, and attributes. Fields and methods themselves have metadata and further contain attributes, including the Code attribute. The Code attribute further contains instructions, exception handlers, and so forth. The API for navigating and building class files should reflect this structure.

• User-driven navigation — The path we take through the class-file tree is driven by user choices. If the user cares only about annotations on fields then we should only have to parse as far down as the annotation attributes inside the field_info structure; we should not have to look into any of the class attributes or the bodies of methods, or at other attributes of the field. Users should be able to deal with compound entities, such as methods, either as single units or broken into streams of their constituent parts, as desired.

• Laziness — User-driven navigation enables significant efficiencies, such as not parsing any more of the class file than is required to satisfy the user's needs. If the user is not going to dive into the contents of a method then we need not parse any more of the method_info structure than is needed to figure out where the next class-file element starts. We can lazily inflate, and cache, the full representation when the user asks for it.

• Unified streaming and materialized views — Like ASM, we want to support both a streaming and a materialized view of a class file. The streaming view is suitable for the majority of use cases, while the materialized view is more general since it allows random access. We can provide a materialized view far less expensively than ASM through laziness, as enabled by immutability. We can, further, align the streaming and materialized views so that they use a common vocabulary and can be used in coordination, as is convenient for each use case.

• Emergent transformation — If the class-file reading and writing APIs are sufficiently aligned then transformation can be an emergent property that does not require its own special mode or significant new API surface. (ASM achieves this by using a common visitor structure for readers and writers.) If classes, methods, fields, and code bodies are readable and writable as streams of elements then a transformation can be viewed as a flat-map operation on this stream, defined by lambdas.

• Detail hiding — Many parts of a class file (constant pool, bootstrap method table, stack maps, etc.) are derived from other parts of the class file. It makes no sense to ask the user to construct these directly; this is extra work for the user and increases the chance of error. The library will automatically generate entities that are tightly coupled to other entities based on the methods, fields, and instructions added to the class file.

• Lean into the language — In 2002, the visitor approach used by ASM seemed clever, and was surely more pleasant to use than what came before. However, the Java programming language has improved tremendously since then — with the introduction of lambdas, records, sealed classes, and pattern matching — and the platform now has a standard API for describing class-file constants (java.lang.constant). We can use these to design an API that is more flexible and pleasant to use, less verbose, and less error-prone.

Specification

The javadoc for the packages with the implementation as of November 20, 2023 is at https://cr.openjdk.org/~asotona/JDK-8308753-preview/api/java.base/java/lang/classfile/package-summary.html

More details can be found in the JEP issue https://bugs.openjdk.org/browse/JDK-8280389

The implementation of Class-file API exports the following packages, defined in module java.base.

Package java.lang.classfile

Interfaces

AccessFlags

Models the access flags for a class, method, or field.

Annotation

Models an annotation on a declaration.

AnnotationElement

Models a key-value pair of an annotation.

AnnotationValue

Models the value of a key-value pair of an annotation.

AnnotationValue.OfAnnotation

Models an annotation-valued element

AnnotationValue.OfArray

Models an array-valued element

AnnotationValue.OfBoolean

Models a constant-valued element

AnnotationValue.OfByte

Models a constant-valued element

AnnotationValue.OfCharacter

Models a constant-valued element

AnnotationValue.OfClass

Models a class-valued element

AnnotationValue.OfConstant

Models a constant-valued element

AnnotationValue.OfDouble

Models a constant-valued element

AnnotationValue.OfEnum

Models an enum-valued element

AnnotationValue.OfFloat

Models a constant-valued element

AnnotationValue.OfInteger

Models a constant-valued element

AnnotationValue.OfLong

Models a constant-valued element

AnnotationValue.OfShort

Models a constant-valued element

AnnotationValue.OfString

Models a constant-valued element

Attribute<A extends Attribute<A>>

Models a classfile attribute 4.7.

AttributedElement

A ClassFileElement describing an entity that has attributes, such as a class, field, method, code attribute, or record component.

AttributeMapper<A>

Bidirectional mapper between the classfile representation of an attribute and how that attribute is modeled in the API.

BootstrapMethodEntry

Models an entry in the bootstrap method table.

BufWriter

Supports writing portions of a classfile to a growable buffer.

ClassBuilder

A builder for classfiles.

ClassElement

A ClassFileElement that can appear when traversing the elements of a ClassModel or be presented to a ClassBuilder.

ClassFile

Represents a context for parsing, transforming, and generating classfiles.

ClassFile.AttributeMapperOption

Option describing attribute mappers for custom attributes.

ClassFile.ClassHierarchyResolverOption

Option describing the class hierarchy resolver to use when generating stack maps.

ClassFile.Option

An option that affects the writing of classfiles.

ClassFileBuilder<E extends ClassFileElement,B extends ClassFileBuilder<E,B>>

A builder for a classfile or portion of a classfile.

ClassFileElement

Immutable model for a portion of (or the entirety of) a classfile.

ClassFileTransform<C extends ClassFileTransform<C,E,B>,E extends ClassFileElement,B extends ClassFileBuilder<E,B>>

A transformation on streams of elements.

ClassFileTransform.ResolvedTransform<E extends ClassFileElement>

The result of binding a transform to a builder.

ClassFileVersion

Models the classfile version information for a class.

ClassHierarchyResolver

Provides class hierarchy information for generating correct stack maps during code building.

ClassModel

Models a classfile.

ClassReader

Supports reading from a classfile.

ClassSignature

Models the generic signature of a class file, as defined by 4.7.9.

ClassTransform

A transformation on streams of ClassElement.

CodeBuilder

A builder for code attributes (method bodies).

CodeBuilder.BlockCodeBuilder

A builder for blocks of code.

CodeBuilder.CatchBuilder

A builder to add catch blocks.

CodeElement

A ClassFileElement that can appear when traversing the elements of a CodeModel or be presented to a CodeBuilder.

CodeModel

Models the body of a method (the Code attribute).

CodeTransform

A transformation on streams of CodeElement.

CompoundElement<E extends ClassFileElement>

A ClassFileElement that has complex structure defined in terms of other classfile elements, such as a method, field, method body, or entire class.

FieldBuilder

A builder for fields.

FieldElement

A ClassFileElement that can appear when traversing the elements of a FieldModel or be presented to a FieldBuilder.

FieldModel

Models a field.

FieldTransform

A transformation on streams of FieldElement.

Instruction

Models an executable instruction in a method body.

Interfaces

Models the interfaces of a class.

Label

A marker for a position within the instructions of a method body.

MethodBuilder

A builder for methods.

MethodElement

A ClassFileElement that can appear when traversing the elements of a MethodModel or be presented to a MethodBuilder.

MethodModel

Models a method.

MethodSignature

Models the generic signature of a method, as defined by 4.7.9.

MethodTransform

A transformation on streams of MethodElement.

PseudoInstruction

Models metadata about a CodeAttribute, such as entries in the exception table, line number table, local variable table, or the mapping between instructions and labels.

Signature

Models generic Java type signatures, as defined in 4.7.9.1.

Signature.ArrayTypeSig

Models the signature of an array type.

Signature.BaseTypeSig

Models the signature of a primitive type or void

Signature.ClassTypeSig

Models the signature of a possibly-parameterized class or interface type.

Signature.RefTypeSig

Models the signature of a reference type, which may be a class, interface, type variable, or array type.

Signature.ThrowableSig

Models a signature for a throwable type.

Signature.TypeArg

Models the type argument.

Signature.TypeParam

Models a signature for a type parameter of a generic class or method.

Signature.TypeVarSig

Models the signature of a type variable.

Superclass

Models the superclass of a class.

TypeAnnotation

Models an annotation on a type use.

TypeAnnotation.CatchTarget

Indicates that an annotation appears on the i'th type in an exception parameter declaration.

TypeAnnotation.EmptyTarget

Indicates that an annotation appears on either the type in a field declaration, the return type of a method, the type of a newly constructed object, or the receiver type of a method or constructor.

TypeAnnotation.FormalParameterTarget

Indicates that an annotation appears on the type in a formal parameter declaration of a method, constructor, or lambda expression.

TypeAnnotation.LocalVarTarget

Indicates that an annotation appears on the type in a local variable declaration, including a variable declared as a resource in a try-with-resources statement.

TypeAnnotation.LocalVarTargetInfo

Indicates a range of code array offsets within which a local variable has a value, and the index into the local variable array of the current frame at which that local variable can be found.

TypeAnnotation.OffsetTarget

Indicates that an annotation appears on either the type in an instanceof expression or a new expression, or the type before the :: in a method reference expression.

TypeAnnotation.SupertypeTarget

Indicates that an annotation appears on a type in the extends or implements clause of a class or interface declaration.

TypeAnnotation.TargetInfo

Specifies which type in a declaration or expression is being annotated.

TypeAnnotation.ThrowsTarget

Indicates that an annotation appears on the i'th type in the throws clause of a method or constructor declaration.

TypeAnnotation.TypeArgumentTarget

Indicates that an annotation appears either on the i'th type in a cast expression, or on the i'th type argument in the explicit type argument list for any of the following: a new expression, an explicit constructor invocation statement, a method invocation expression, or a method reference expression.

TypeAnnotation.TypeParameterBoundTarget

Indicates that an annotation appears on the i'th bound of the j'th type parameter declaration of a generic class, interface, method, or constructor.

TypeAnnotation.TypeParameterTarget

Indicates that an annotation appears on the declaration of the i'th type parameter of a generic class, generic interface, generic method, or generic constructor.

TypeAnnotation.TypePathComponent

JVMS: Wherever a type is used in a declaration or expression, the type_path structure identifies which part of the type is annotated.

WritableElement<T>

A classfile element that can encode itself as a stream of bytes in the encoding expected by the classfile format.

Classes

Attributes

Attribute mappers for standard classfile attributes.

CustomAttribute<T extends CustomAttribute<T>>

Models a non-standard attribute of a classfile.

Enum Classes

ClassFile.ConstantPoolSharingOption

Option describing whether to preserve the original constant pool when transforming a classfile.

ClassFile.DeadCodeOption

Option describing whether or not to patch out unreachable code.

ClassFile.DeadLabelsOption

Option describing whether or not to filter unresolved labels.

ClassFile.DebugElementsOption

Option describing whether to process or discard debug elements.

ClassFile.LineNumbersOption

Option describing whether to process or discard line numbers.

ClassFile.ShortJumpsOption

Option describing whether or not to automatically rewrite short jumps to long when necessary.

ClassFile.StackMapsOption

Option describing whether or not to generate stackmaps.

ClassFile.UnknownAttributesOption

Option describing whether to process or discard unrecognized attributes.

Opcode

Describes the opcodes of the JVM instruction set, as well as a number of pseudo-instructions that may be encountered when traversing the instructions of a method.

Opcode.Kind

Kinds of opcodes.

Signature.TypeArg.WildcardIndicator

Indicator for whether a wildcard has default bound, no bound, an upper bound, or a lower bound

TypeAnnotation.TargetType

The kind of target on which the annotation appears.

TypeAnnotation.TypePathComponent.Kind

 

TypeKind

Describes the types that can be part of a field or method descriptor.

Record Class

ClassHierarchyResolver.ClassHierarchyInfo

Information about a resolved class.

Package java.lang.classfile.attribute

Interfaces

AnnotationDefaultAttribute

Models the AnnotationDefault attribute 4.7.22, which can appear on methods of annotation types, and records the default value 9.6.2 for the element corresponding to this method.

BootstrapMethodsAttribute

Models the BootstrapMethods attribute 4.7.23, which serves as an extension to the constant pool of a classfile.

CharacterRangeInfo

Models a single character range in the CharacterRangeTableAttribute.

CharacterRangeTableAttribute

The CharacterRangeTable attribute is an optional variable-length attribute in the attributes table of a Code attribute.

CodeAttribute

Models the Code attribute 4.7.3, appears on non-native, non-abstract methods and contains the bytecode of the method body.

CompilationIDAttribute

Models the CompilationID attribute (@@@ need reference), which can appear on classes and records the compilation time of the class.

ConstantValueAttribute

Models the ConstantValue attribute 4.7.2, which can appear on fields and indicates that the field's value is a constant.

DeprecatedAttribute

Models the Deprecated attribute 4.7.15, which can appear on classes, methods, and fields.

EnclosingMethodAttribute

Models the EnclosingMethod attribute 4.7.7, which can appear on classes, and indicates that the class is a local or anonymous class.

ExceptionsAttribute

Models the Exceptions attribute 4.7.5, which can appear on methods, and records the exceptions declared to be thrown by this method.

InnerClassesAttribute

Models the InnerClasses attribute 4.7.6, which can appear on classes, and records which classes referenced by this classfile are inner classes.

InnerClassInfo

Models a single inner class in the InnerClassesAttribute.

LineNumberInfo

Models a single line number in the LineNumberTableAttribute.

LineNumberTableAttribute

Models the LineNumberTable attribute 4.7.12, which can appear on a Code attribute, and records the mapping between indexes into the code table and line numbers in the source file.

LocalVariableInfo

Models a single local variable in the LocalVariableTableAttribute.

LocalVariableTableAttribute

Models the LocalVariableTable attribute 4.7.13, which can appear on a Code attribute, and records debug information about local variables.

LocalVariableTypeInfo

Models a single local variable in the LocalVariableTypeTableAttribute.

LocalVariableTypeTableAttribute

Models the LocalVariableTypeTable attribute 4.7.14, which can appear on a Code attribute, and records debug information about local variables.

MethodParameterInfo

Models a single method parameter in the MethodParametersAttribute.

MethodParametersAttribute

Models the MethodParameters attribute 4.7.24, which can appear on methods, and records optional information about the method's parameters.

ModuleAttribute

Models the Module attribute 4.7.25, which can appear on classes that represent module descriptors.

ModuleAttribute.ModuleAttributeBuilder

 

ModuleExportInfo

Models a single "exports" declaration in the ModuleAttribute.

ModuleHashesAttribute

Models the ModuleHashes attribute, which can appear on classes that represent module descriptors.

ModuleHashInfo

Models hash information for a single module in the ModuleHashesAttribute.

ModuleMainClassAttribute

Models the ModuleMainClass attribute 4.7.27, which can appear on classes that represent module descriptors.

ModuleOpenInfo

Models a single "opens" declaration in the ModuleAttribute.

ModulePackagesAttribute

Models the ModulePackages attribute 4.7.26, which can appear on classes that represent module descriptors.

ModuleProvideInfo

Models a single "provides" declaration in the ModuleAttribute.

ModuleRequireInfo

Models a single "requires" declaration in the ModuleAttribute.

ModuleResolutionAttribute

Models the ModuleResolution attribute, which can appear on classes that represent module descriptors.

ModuleTargetAttribute

Models the ModuleTarget attribute, which can appear on classes that represent module descriptors.

NestHostAttribute

Models the NestHost attribute 4.7.28, which can appear on classes to indicate that this class is a member of a nest.

NestMembersAttribute

Models the NestMembers attribute 4.7.29, which can appear on classes to indicate that this class is the host of a nest.

PermittedSubclassesAttribute

Models the PermittedSubclasses attribute 4.7.31, which can appear on classes to indicate which classes may extend this class.

RecordAttribute

Models the Record attribute 4.7.30, which can appear on classes to indicate that this class is a record class.

RecordComponentInfo

Models a single record component in the RecordAttribute.

RuntimeInvisibleAnnotationsAttribute

Models the RuntimeInvisibleAnnotations attribute 4.7.17, which can appear on classes, methods, and fields.

RuntimeInvisibleParameterAnnotationsAttribute

Models the RuntimeInvisibleParameterAnnotations attribute 4.7.19, which can appear on methods.

RuntimeInvisibleTypeAnnotationsAttribute

Models the RuntimeInvisibleTypeAnnotations attribute 4.7.21, which can appear on classes, methods, fields, and code attributes.

RuntimeVisibleAnnotationsAttribute

Models the RuntimeVisibleAnnotations attribute 4.7.16, which can appear on classes, methods, and fields.

RuntimeVisibleParameterAnnotationsAttribute

Models the RuntimeVisibleParameterAnnotations attribute 4.7.18, which can appear on methods.

RuntimeVisibleTypeAnnotationsAttribute

Models the RuntimeVisibleTypeAnnotations attribute 4.7.20, which can appear on classes, methods, fields, and code attributes.

SignatureAttribute

Models the Signature attribute 4.7.9, which can appear on classes, methods, or fields.

SourceDebugExtensionAttribute

SourceDebugExtensionAttribute.

SourceFileAttribute

Models the SourceFile attribute 4.7.10, which can appear on classes.

SourceIDAttribute

Models the SourceFile attribute (@@@ reference needed), which can appear on classes.

StackMapFrameInfo

Models stack map frame of StackMapTable attribute 4.7.4.

StackMapFrameInfo.ObjectVerificationTypeInfo

A stack value for an object type.

StackMapFrameInfo.UninitializedVerificationTypeInfo

An uninitialized stack value.

StackMapFrameInfo.VerificationTypeInfo

The type of a stack value.

StackMapTableAttribute

Models the StackMapTable attribute 4.7.4, which can appear on a Code attribute.

SyntheticAttribute

Models the Synthetic attribute 4.7.8, which can appear on classes, methods, and fields.

UnknownAttribute

Models an unknown attribute on a class, method, or field.

Enum Class

StackMapFrameInfo.SimpleVerificationTypeInfo

A simple stack value.

Package java.lang.classfile.components

Interfaces

ClassPrinter.LeafNode

A leaf node holding single printable value.

ClassPrinter.ListNode

A tree node holding List of nested nodes.

ClassPrinter.MapNode

A tree node holding Map of nested nodes.

ClassPrinter.Node

Named, traversable, and printable node parent.

ClassRemapper

ClassRemapper is a ClassTransform, FieldTransform, MethodTransform and CodeTransform deeply re-mapping all class references in any form, according to given map or map function.

CodeLocalsShifter

CodeLocalsShifter is a CodeTransform shifting locals to newly allocated positions to avoid conflicts during code injection.

CodeRelabeler

A code relabeler is a CodeTransform replacing all occurrences of Label in the transformed code with new instances.

CodeStackTracker

CodeStackTracker is a CodeTransform tracking stack content and calculating max stack size.

Class

ClassPrinter

A printer of classfiles and its elements.

Enum Class

ClassPrinter.Verbosity

Level of detail to print or export.

Package java.lang.classfile.constantpool

Interfaces

AnnotationConstantValueEntry

A constant pool entry that may be used as an annotation constant, which includes the four kinds of primitive constants, and UTF8 constants.

ClassEntry

Models a CONSTANT_Class_info constant in the constant pool of a classfile.

ConstantDynamicEntry

Models a CONSTANT_Dynamic_info constant in the constant pool of a classfile.

ConstantPool

Provides read access to the constant pool and bootstrap method table of a classfile.

ConstantPoolBuilder

Builder for the constant pool of a classfile.

ConstantValueEntry

Models a constant pool entry that can be used as the constant in a ConstantValue attribute; this includes the four primitive constant types and String constants.

DoubleEntry

Models a CONSTANT_Double_info constant in the constant pool of a classfile.

DynamicConstantPoolEntry

Models a dynamic constant pool entry, which is either ConstantDynamicEntry or InvokeDynamicEntry.

FieldRefEntry

Models a CONSTANT_Fieldref_info constant in the constant pool of a classfile.

FloatEntry

Models a CONSTANT_Float_info constant in the constant pool of a classfile.

IntegerEntry

Models a CONSTANT_Integer_info constant in the constant pool of a classfile.

InterfaceMethodRefEntry

Models a CONSTANT_InterfaceMethodRef_info constant in the constant pool of a classfile.

InvokeDynamicEntry

Models a constant pool entry for a dynamic call site.

LoadableConstantEntry

Marker interface for constant pool entries suitable for loading via the LDC instructions.

LongEntry

Models a CONSTANT_Long_info constant in the constant pool of a classfile.

MemberRefEntry

Models a member reference constant in the constant pool of a classfile, which includes references to fields, methods, and interface methods.

MethodHandleEntry

Models a CONSTANT_MethodHandle_info constant in the constant pool of a classfile.

MethodRefEntry

Models a CONSTANT_MethodRef_info constant in the constant pool of a classfile.

MethodTypeEntry

Models a CONSTANT_MethodType_info constant in the constant pool of a classfile.

ModuleEntry

Models a CONSTANT_Module_info constant in the constant pool of a classfile.

NameAndTypeEntry

Models a CONSTANT_NameAndType_info constant in the constant pool of a classfile.

PackageEntry

Models a CONSTANT_Package_info constant in the constant pool of a classfile.

PoolEntry

Models an entry in the constant pool of a classfile.

StringEntry

Models a CONSTANT_String_info constant in the constant pool of a classfile.

Utf8Entry

Models a CONSTANT_UTF8_info constant in the constant pool of a classfile.

Package java.lang.classfile.instruction

Interfaces

ArrayLoadInstruction

Models an array load instruction in the code array of a Code attribute.

ArrayStoreInstruction

Models an array store instruction in the code array of a Code attribute.

BranchInstruction

Models a branching instruction (conditional or unconditional) in the code array of a Code attribute.

CharacterRange

A pseudo-instruction which models a single entry in the CharacterRangeTableAttribute.

ConstantInstruction

Models a constant-load instruction in the code array of a Code attribute, including "intrinsic constant" instructions (e.g., iconst_0), "argument constant" instructions (e.g., bipush), and "load constant" instructions (e.g., LDC).

ConstantInstruction.ArgumentConstantInstruction

Models an "argument constant" instruction (e.g., bipush).

ConstantInstruction.IntrinsicConstantInstruction

Models an "intrinsic constant" instruction (e.g., iconst_0).

ConstantInstruction.LoadConstantInstruction

Models a "load constant" instruction (e.g., ldc).

ConvertInstruction

Models a primitive conversion instruction in the code array of a Code attribute, such as i2l.

DiscontinuedInstruction

Models instruction discontinued from the code array of a Code attribute.

DiscontinuedInstruction.JsrInstruction

Models JSR and JSR_W instructions discontinued from the code array of a Code attribute since class file version 51.0.

DiscontinuedInstruction.RetInstruction

Models RET and RET_W instructions discontinued from the code array of a Code attribute since class file version 51.0.

ExceptionCatch

A pseudo-instruction modeling an entry in the exception table of a code attribute.

FieldInstruction

Models a field access instruction in the code array of a Code attribute.

IncrementInstruction

Models a local variable increment instruction in the code array of a Code attribute.

InvokeDynamicInstruction

Models an invokedynamic instruction in the code array of a Code attribute.

InvokeInstruction

Models a method invocation instruction in the code array of a Code attribute, other than invokedynamic.

LabelTarget

A pseudo-instruction which indicates that the specified label corresponds to the current position in the Code attribute.

LineNumber

A pseudo-instruction which models a single entry in the LineNumberTableAttribute.

LoadInstruction

Models a local variable load instruction in the code array of a Code attribute.

LocalVariable

A pseudo-instruction which models a single entry in the LocalVariableTableAttribute.

LocalVariableType

A pseudo-instruction which models a single entry in the LocalVariableTypeTableAttribute.

LookupSwitchInstruction

Models a lookupswitch instruction in the code array of a Code attribute.

MonitorInstruction

Models a monitorenter or monitorexit instruction in the code array of a Code attribute.

NewMultiArrayInstruction

Models a multianewarray invocation instruction in the code array of a Code attribute.

NewObjectInstruction

Models a new instruction in the code array of a Code attribute.

NewPrimitiveArrayInstruction

Models a newarray invocation instruction in the code array of a Code attribute.

NewReferenceArrayInstruction

Models a anewarray invocation instruction in the code array of a Code attribute.

NopInstruction

Models a nop invocation instruction in the code array of a Code attribute.

OperatorInstruction

Models an arithmetic operator instruction in the code array of a Code attribute.

ReturnInstruction

Models a return-from-method instruction in the code array of a Code attribute.

StackInstruction

Models a stack manipulation instruction in the code array of a Code attribute.

StoreInstruction

Models a local variable store instruction in the code array of a Code attribute.

SwitchCase

Models a single case in a lookupswitch or tableswitch instruction.

TableSwitchInstruction

Models a tableswitch instruction in the code array of a Code attribute.

ThrowInstruction

Models an athrow instruction in the code array of a Code attribute.

TypeCheckInstruction

Models an instanceof or checkcast instruction in the code array of a Code attribute.