All Classes and Interfaces
Class
Description
AALOAD - Load reference from array
AASTORE - Store into reference array
Super class for all objects that have modifiers like private, final, ...
ACONST_NULL - Push null reference
Denote family of instructions that allocates space in the heap.
ALOAD - Load reference from local variable
ANEWARRAY - Create new array of references
Represents the default value of a annotation for a method info.
Represents one annotation in the annotation table
base class for annotations
ARETURN - Return reference from method
Argument validation.
Super class for the family of arithmetic instructions.
Super class for instructions dealing with array access such as IALOAD.
ARRAYLENGTH - Get length of array
Denotes array type, such as int[][]
Instances of this class should never be thrown.
ASTORE - Store reference into local variable
ATHROW - Throw exception
Abstract super class for Attribute objects.
Convert found attributes into HTML file.
Deprecated.
Use UnknownAttributeReader instead
BALOAD - Load byte or boolean from array
Denotes basic type such as int.
BASTORE - Store into byte or boolean array
Used for BCEL comparison strategy
Factory creates il.append() statements, and sets instruction targets.
This class takes a given JavaClass object and converts it to a Java program that creates that very class using BCEL.
Enum corresponding to flag source.
BIPUSH - Push byte on stack
This class represents a bootstrap method attribute, i.e., the bootstrap method ref, the number of bootstrap arguments
and an array of the bootstrap arguments.
This class represents a BootstrapMethods attribute.
BranchHandle is returned by specialized InstructionList.append() whenever a BranchInstruction is appended.
Abstract super class for branching instructions like GOTO, IFEQ, etc..
BREAKPOINT, JVM dependent, ignored by default
Utility class that implements a sequence of bytes which can be read via the 'readByte()' method.
CALOAD - Load char from array
CASTORE - Store into char array
CHECKCAST - Check whether object is of given type
Read class file(s) and convert them into HTML files.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
the verification pass 2 as described in the Java Virtual Machine specification, 2nd edition.
Thrown when the BCEL attempts to read a class file and determines that a class is malformed or otherwise cannot be interpreted as a class file.
Template class for building up a java class.
Thrown on internal exceptions.
Deprecated.
6.0 Do not use - does not work
The repository maintains information about which classes have been loaded.
Implement this interface if you're interested in changes to a ClassGen object and register yourself with
addObserver().
Wrapper class that parses a given Java .class file.
Loads class files from the CLASSPATH.
Contains information about file/ZIP entry of the Java class.
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
Utility class implementing a (typesafe) queue of JavaClass objects.
Utility class implementing a (type-safe) set of JavaClass objects.
Utility class implementing a (typesafe) stack of JavaClass objects.
Deprecated.
as of 5.1.1 - 7/17/2005
This class represents a chunk of Java byte code contained in a method.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file does not pass the
verification pass 3.
This class represents an entry in the exception table of the Code attribute and is used only there.
This class represents an exception handler, i.e., specifies the region where a handler is active and an instruction
where the actual handling is done.
Convert code into HTML file.
Wrapper class for 'compound' operations, virtual instructions that don't exist as byte code, but give a useful
meaning.
Constants for the project, mostly defined in the JVM specification.
Abstract superclass for classes to represent the different constant types in the constant pool of a class file.
This class is derived from the abstract
Constant and represents a reference to a (external) class.Abstract super class for Fieldref, Methodref, InterfaceMethodref and InvokeDynamic constants.
This class is derived from the abstract
Constant and represents a reference to a Double object.This class is derived from the abstract
Constant and represents a reference to a dynamically computed
constant.This class represents a constant pool reference to a field.
This class is derived from the abstract
Constant and represents a reference to a float object.Convert constant pool into HTML file.
This class is derived from the abstract
Constant and represents a reference to an int object.This class represents a constant pool reference to an interface method.
This class is derived from the abstract
Constant and represents a reference to a invoke dynamic.This class is derived from the abstract
Constant and represents a reference to a long object.This class is derived from the abstract
Constant and represents a reference to a method handle.This class represents a constant pool reference to a method.
This class is derived from the abstract
Constant and represents a reference to a method type.This class is derived from the abstract
Constant and represents a reference to a module.This class is derived from the abstract
Constant and represents a reference to the name and signature of a
field or method.This interface denotes those constants that have a "natural" value, such as ConstantLong, ConstantString, etc..
This class is derived from the abstract
Constant and represents a reference to a package.This class represents the constant pool, i.e., a table of constants, of a parsed classfile.
This class is used to build up a constant pool.
Denotes a push instruction that produces a literal on the stack such as SIPUSH, BIPUSH, ICONST, etc.
Deprecated.
(since 6.0) DO NOT USE - use
Const instead.This class is derived from the abstract
Constant and represents a reference to a String object.Extends the abstract
Constant to represent a reference to a UTF-8 encoded string.This class is derived from Attribute and represents a constant value, i.e., a default value for initializing
a class field.
This class represents a control flow graph of a method.
Super class for the x2y family of instructions.
Abstract super class for instructions that use an index into the constant pool such as LDC, INVOKEVIRTUAL, etc.
D2F - Convert double to float
D2I - Convert double to int
D2L - Convert double to long
DADD - Add doubles
DALOAD - Load double from array
DASTORE - Store into double array
DCMPG - Compare doubles: value1 > value2
DCMPL - Compare doubles: value1 < value2
DCONST - Push 0.0 or 1.0, other values cause an exception
DDIV - Divide doubles
This class is derived from Attribute and denotes that this is a deprecated method.
Traverses a JavaClass with another Visitor object 'piggy-backed' that is applied to all components of a JavaClass
object.
DLOAD - Load double from local variable
DMUL - Multiply doubles
DNEG - Negate double
This class represents the upper half of a DOUBLE variable.
DREM - Remainder of doubles
DRETURN - Return double from method
DSTORE - Store double into local variable
DSUB - Substract doubles
DUP - Duplicate top operand stack word
DUP_X1 - Duplicate top operand stack word and put two down
DUP_X2 - Duplicate top operand stack word and put three down
DUP2 - Duplicate two top operand stack words
DUP2_X1 - Duplicate two top operand stack words and put three down
DUP2_X2 - Duplicate two top operand stack words and put four down
The element_value structure is documented at https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.16.1
An annotation's element value pair.
Visitor with empty method bodies, can be extended and used in conjunction with the DescendingVisitor class, e.g.
Supplies empty method bodies to be overridden by subclasses.
This attribute exists for local or anonymous classes and ...
Exception constants.
Enum corresponding to the various Exception Class arrays, used by
ExceptionConst.createExceptions(EXCS, Class...)Deprecated.
(since 6.0) DO NOT USE - use ExceptionConst instead
This class represents an exception handler; that is, an ObjectType representing a subclass of java.lang.Throwable and
the instruction the handler starts off (represented by an InstructionContext).
This class allows easy access to ExceptionHandler objects.
This class represents the table of exceptions that are thrown by a method.
Denote an instruction that may throw a run-time or a linking exception (or both) during execution.
This Visitor class may be used for a type-based Java Virtual Machine simulation.
F2D - Convert float to double
F2I - Convert float to int
F2L - Convert float to long
FADD - Add floats
FALOAD - Load float from array
FASTORE - Store into float array
FCMPG - Compare floats: value1 > value2
FCMPL - Compare floats: value1 < value2
FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
FDIV - Divide floats
This class represents the field info structure, i.e., the representation for a variable in the class.
Template class for building up a field.
Super class for FieldGen and MethodGen objects, since they have some methods in common!
Super class for the GET/PUTxxx family of instructions.
Imnplement this interface if you're interested in changes to a FieldGen object and register yourself with
addObserver().
Abstract super class for fields and methods.
Super class for InvokeInstruction and FieldInstruction, since they have some methods in common!
FLOAD - Load float from local variable
FMUL - Multiply floats
FNEG - Negate float
This class represents a JVM execution frame; that means, a local variable array and an operand stack.
FREM - Remainder of floats
FRETURN - Return float from method
FSTORE - Store float into local variable
FSUB - Substract floats
A placeholder class that can be used to create an ObjectType of which has some of the properties arrays have.
GETFIELD - Fetch field from object
GETSTATIC - Fetch static field from class
GOTO - Branch always (to relative offset, not absolute address)
GOTO_W - Branch always (to relative offset, not absolute address)
Super class for GOTO
A graphical user interface application demonstrating JustIce.
I2B - Convert int to byte
I2C - Convert int to char
I2D - Convert int to double
I2F - Convert int to float
I2L - Convert int to long
I2S - Convert int to short
IADD - Add ints
IALOAD - Load int from array
IAND - Bitwise AND int
IASTORE - Store into int array
ICONST - Push value between -1, ..., 5, other values cause an exception
IDIV - Divide ints
IF_ACMPEQ - Branch if reference comparison succeeds
IF_ACMPNE - Branch if reference comparison doesn't succeed
IF_ICMPEQ - Branch if int comparison succeeds
IF_ICMPGE - Branch if int comparison succeeds
IF_ICMPGT - Branch if int comparison succeeds
IF_ICMPLE - Branch if int comparison succeeds
IF_ICMPLT - Branch if int comparison succeeds
IF_ICMPNE - Branch if int comparison doesn't succeed
IFEQ - Branch if int comparison with zero succeeds
IFGE - Branch if int comparison with zero succeeds
IFGT - Branch if int comparison with zero succeeds
Super class for the IFxxx family of instructions.
IFLE - Branch if int comparison with zero succeeds
IFLT - Branch if int comparison with zero succeeds
IFNE - Branch if int comparison with zero succeeds
IFNONNULL - Branch if reference is not null
IFNULL - Branch if reference is not null
IINC - Increment local variable by constant
ILOAD - Load int from local variable onto stack
IMPDEP1 - Implementation dependent
IMPDEP2 - Implementation dependent
IMUL - Multiply ints
Denote entity that refers to an index, e.g.
INEG - Negate int
This class represents a inner class attribute, i.e., the class indices of the inner and outer classes, the name and
the attributes of the inner class.
This class is derived from Attribute and denotes that this class is an Inner class of another.
INSTANCEOF - Determine if object is of given type
A Visitor class testing for valid preconditions of JVM instructions.
Abstract super class for all Java byte codes.
Equality of instructions isn't clearly to be defined.
Contains shareable instruction objects.
Deprecated.
(since 6.0) Do not use.
Deprecated, consider private and ignore.
An InstructionContext offers convenient access to information like control flow successors and such.
Instances of this class may be used, e.g., to generate typed versions of instructions.
InstructionFinder is a tool to search for given instructions patterns, i.e., match sequences of instructions in an
instruction list via regular expressions.
Code patterns found may be checked using an additional user-defined constraint object whether they really match the
needed criterion.
Instances of this class give users a handle to the instructions contained in an InstructionList.
This class is a container for a list of Instruction objects.
Implement this interface if you're interested in changes to an InstructionList object and register yourself with
addObserver().
Denote that a class targets InstructionHandles within an InstructionList.
A small utility class representing a set of basic int values.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when the verification of a method is
requested that does not exist.
Class for INVOKEDYNAMIC.
Super class for the INVOKExxx family of instructions.
INVOKEINTERFACE - Invoke interface method
INVOKESPECIAL - Invoke instance method; special handling for superclass, private and instance initialization method
invocations
INVOKESTATIC - Invoke a class (static) method
INVOKEVIRTUAL - Invoke instance method; dispatch based on class
IOR - Bitwise OR int
IREM - Remainder of int
IRETURN - Return int from method
ISHL - Arithmetic shift left int
ISHR - Arithmetic shift right int
ISTORE - Store int from stack into local variable
ISUB - Substract ints
IUSHR - Logical shift right int
IXOR - Bitwise XOR int
Represents a Java class, i.e., the data structures, constant pool, fields, methods and commands contained in a Java
.class file.
Java interpreter replacement, i.e., wrapper that uses its own ClassLoader to modify/generate classes as they're
requested.
JSR - Jump to subroutine
JSR_W - Jump to subroutine
Super class for JSR - Jump to subroutine
L2D - Convert long to double
L2F - Convert long to float
L2I - Convert long to int
LADD - Add longs
LALOAD - Load long from array
LAND - Bitwise AND longs
LASTORE - Store into long array
LCMP - Compare longs:
LCONST - Push 0 or 1, other values cause an exception
LDC - Push item from constant pool.
LDC_W - Push item from constant pool (wide index)
LDC2_W - Push long or double from constant pool
LDIV - Divide longs
This class represents a (PC offset, line number) pair, i.e., a line number in the source that corresponds to a
relative address in the byte code.
This class represents a line number within a method, i.e., give an instruction a line number corresponding to the
source code line.
This class represents a table of line numbers for debugging purposes.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
the verification pass 3 because of a violation of a constraint that is usually only verified at run-time (pass 4).
LLOAD - Load long from local variable
LMUL - Multiply longs
LNEG - Negate long
Denotes that an instruction may start the process of loading and resolving the referenced class in the Virtual Machine.
When loading a class file, BCEL will throw an instance of LoadingException if the class file is malformed; so it is
not conforming to the "Pass 1" verification process as described in the Java Virtual Machine specification, 2nd.
Denotes an unparameterized instruction to load a value from a local variable, e.g.
This class represents a local variable within a method.
Represents a local variable within a method.
A utility class holding the information about the name and the type of a local variable in a given slot (== index).
A LocalVariableInfoInconsistentException instance is thrown by the LocalVariableInfo class when it detects that the
information it holds is inconsistent; this is normally due to inconsistent LocalVariableTable entries in the Code
attribute of a certain Method object.
Abstract super class for instructions dealing with local variables.
This class implements an array of local variables used for symbolic JVM simulation.
A utility class holding the information about the names and the types of the local variables in a given method.
This class represents colection of local variables in a method.
This class represents the upper half of a LONG variable.
LOOKUPSWITCH - Switch with unordered set of values
LOR - Bitwise OR long
LREM - Remainder of long
LRETURN - Return long from method
Maintains a least-recently-used (LRU) cache of
JavaClass with maximum size cacheSize.LSHL - Arithmetic shift left long
LSHR - Arithmetic shift right long
LSTORE - Store long into local variable
LSUB - Substract longs
LUSHR - Logical shift right long
LXOR - Bitwise XOR long
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
This class represents the method info structure, i.e., the representation for a method in the class.
Template class for building up a method.
Convert methods and fields into HTML file.
Implement this interface if you're interested in changes to a MethodGen object and register yourself with
addObserver().
Entry of the parameters table.
This class represents a MethodParameters attribute.
Wraps a Java 9 JEP 220 modular runtime image.
This class is derived from Attribute and represents the list of modules required, exported, opened or
provided by a module.
This class represents an entry in the exports table of the Module attribute.
This class is derived from Attribute and indicates the main class of a module.
This class represents an entry in the opens table of the Module attribute.
This class is derived from Attribute and represents the list of packages that are exported or opened by the
Module attribute.
This class represents an entry in the provides table of the Module attribute.
This class represents an entry in the requires table of the Module attribute.
MONITORENTER - Enter monitor for object
MONITOREXIT - Exit monitor for object
MULTIANEWARRAY - Create new mutidimensional array of references
Denote entity that has both name and type.
Super class for FieldOrMethod and INVOKEDYNAMIC, since they both have names and signatures
The NativeVerifier class implements a main(String[] args) method that's roughly compatible to the one in the Verifier
class, but that uses the JVM's internal verifier for its class file verification.
This class is derived from Attribute and records the nest host of the nest to which the current class or
interface claims to belong.
This class is derived from Attribute and records the classes and interfaces that are authorized to claim
membership in the nest hosted by the current class or interface.
NEW - Create new object
NEWARRAY - Create new array of basic type (int, short, ...)
Denote class to have an accept method();
NOP - Do nothing
Denotes reference such as java.lang.String.
This class implements a stack used for symbolic JVM stack simulation.
represents one parameter annotation in the parameter annotation table
base class for parameter annotations
This PassVerifier verifies a class file according to pass 1 as described in The Java Virtual Machine Specification,
2nd edition.
This PassVerifier verifies a class file according to pass 2 as described in The Java Virtual Machine Specification,
2nd edition.
This class serves for finding out if a given JavaClass' ConstantPool references an Inner Class.
This PassVerifier verifies a class file according to pass 3, static part as described in The Java Virtual Machine
Specification, 2nd edition.
This PassVerifier verifies a method of class file according to pass 3, so-called structural verification as described
in The Java Virtual Machine Specification, 2nd edition.
An InstructionContextQueue is a utility class that holds (InstructionContext, ArrayList) pairs in a Queue data
structure.
A PassVerifier actually verifies a class file; it is instantiated by a Verifier.
This class is derived from Attribute and represents a reference to a PMG attribute.
POP - Pop top operand stack word
POP2 - Pop two top operand stack words
Denotes an unparameterized instruction to pop a value on top from the stack, such as ISTORE, POP, PUTSTATIC.
Wrapper class for push operations, which are implemented either as BIPUSH, LDC or xCONST_n instructions.
Denotes an unparameterized instruction to produce a value on top of the stack, such as ILOAD, LDC, SIPUSH, DUP,
ICONST, etc.
PUTFIELD - Put field in object
PUTSTATIC - Put static field in class
Super class for object and array types.
The repository maintains informations about class interdependencies, e.g., whether a class is a sub-class of another.
Abstract definition of a class repository.
RET - Return from subroutine
RETURN - Return from void method
Returnaddress, the type JSR or JSR_W instructions push upon the stack.
Super class for the xRETURN family of instructions.
represents an annotation that is represented in the class file but is not provided to the JVM.
Represents a parameter annotation that is represented in the class file but is not provided to the JVM.
represents an annotation that is represented in the class file and is provided to the JVM.
Represents a parameter annotation that is represented in the class file and is provided to the JVM.
SALOAD - Load short from array
SASTORE - Store into short array
Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
This class is derived from Attribute and represents a reference to a GJ attribute.
Extends ByteArrayInputStream to make 'unreading' chars possible.
SIPUSH - Push short
This class is derived from Attribute and represents a reference to the source file of this class.
Denote an instruction that may consume a value from the stack.
Super class for stack operations like DUP and POP.
This class represents a stack map attribute used for preverification of Java classes for the
Java 2 Micro Edition (J2ME).
This class represents a stack map entry recording the types of local variables and the of stack items at a given
byte code offset.
This class represents the type of a local variable or item on stack used in the StackMap entries.
Denotes an instruction that may produce a value on top of the stack (this excludes DUP_X1, e.g.)
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
the verification pass 3 because of a violation of a static constraint as described in the Java Virtual Machine
Specification, 2nd edition, 4.8.1, pages 133-137.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
the verification pass 3 because of a violation of a static constraint as described in the Java Virtual Machine
Specification, Second edition, 4.8.1, pages 133-137.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
the verification pass 3 because of a violation of a static constraint as described in the Java Virtual Machine
Specification, Second edition, 4.8.1, pages 133-137.
Denotes an unparameterized instruction to store a value into a local variable, e.g.
BCEL's Node classes (those from the classfile API that accept() Visitor instances) have toString()
methods that were not designed to be robust, this gap is closed by this class.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
the verification pass 3 because of a violation of a structural constraint as described in the Java Virtual Machine
Specification, 2nd edition, 4.8.2, pages 137-139.
This interface defines properties of JVM bytecode subroutines.
Instances of this class contain information about the subroutines found in a code array of a method.
SWAP - Swa top operand stack word
SWITCH - Branch depending on int value, generates either LOOKUPSWITCH or TABLESWITCH instruction, depending on
whether the match values (int[]) can be sorted with no gaps between the numbers.
This class is derived from Attribute and declares this class as 'synthetic', i.e., it needs special
handling.
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
TABLESWITCH - Switch within given range of values, i.e., low..high
Thrown by InstructionList.remove() when one or multiple disposed instructions are still being referenced by an
InstructionTargeter object.
This class has a main method implementing a demonstration program of how to use the VerifierFactoryObserver.
Abstract super class for all possible java types, namely basic types such as int, object types like String and array
types, e.g.
Get the type associated with an instruction, int for ILOAD, or the type of the field of a PUTFIELD instruction, e.g..
Denotes an instruction to perform an unconditional branch, i.e., GOTO, JSR.
This class represents an uninitialized object type; see The Java Virtual Machine Specification, Second Edition, page
147: 4.9.4 for more details.
This class represents a reference to an unknown (i.e., application-specific) attribute of a class.
Unknown (non-standard) attributes may be read via user-defined factory objects that can be registered with the
Attribute.addAttributeReader method.
Utility functions that do not really belong to any class in particular.
A utility class providing convenience methods concerning Throwable instances.
Decode characters into bytes.
Encode bytes into valid java identifier characters.
Denotes an instruction to be a variable length instruction, such as GOTO, JSR, LOOKUPSWITCH and TABLESWITCH.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file to verify does not pass
one of the verification passes 2 or 3.
A VerificationResult is what a PassVerifier returns after verifying.
A Verifier instance is there to verify a class file according to The Java Virtual Machine Specification, 2nd Edition.
This class implements a machine-generated frame for use with the GraphicalVerfifier.
Instances of this class are thrown by BCEL's class file verifier "JustIce" whenever verification proves that some
constraint of a class file (as stated in the Java Virtual Machine Specification, Edition 2) is violated.
This class produces instances of the Verifier class.
This class implements an adapter; it implements both a Swing ListModel and a VerifierFactoryObserver.
VerifierFactoryObserver instances are notified when new Verifier instances are created.
A class for simple graphical class file verification.
Interface to make use of the Visitor pattern programming style.
Interface implementing the Visitor pattern programming style.