All Classes and Interfaces

Class	Description
AccessFlags	Constants used as "access flags" in various places in classes, and related utilities.
AddressMap	Map from addresses to addresses, where addresses are all ints.
AnnotatedOutput	Interface for a binary output destination that may be augmented with textual annotations.
Annotation	An annotation.
Annotation	An annotation on an element of a class.
AnnotationItem	Single annotation, which consists of a type and a set of name-value element pairs.
AnnotationParser	Parser for annotations.
Annotations	List of Annotation instances.
AnnotationsDirectoryItem	Per-class directory of annotations.
AnnotationSetItem	Set of annotations, where no annotation type appears more than once.
AnnotationSetRefItem	Indirect reference to an AnnotationSetItem.
AnnotationsList	List of Annotations instances.
AnnotationUtils	Utility class for dealing with annotations.
AnnotationVisibility	Visibility scope of an annotation.
ArrayData	Pseudo-instruction which holds fill array data.
AttAnnotationDefault	Attribute class for AnnotationDefault attributes.
AttBootstrapMethods	Attribute class for standard AttBootstrapMethods attributes.
AttCode	Attribute class for standard Code attributes.
AttConstantValue	Attribute class for standard ConstantValue attributes.
AttDeprecated	Attribute class for standard Deprecated attributes.
AttEnclosingMethod	Attribute class for standards-track EnclosingMethod attributes.
AttExceptions	Attribute class for standard Exceptions attributes.
AttInnerClasses	Attribute class for standard InnerClasses attributes.
AttLineNumberTable	Attribute class for standard LineNumberTable attributes.
AttLocalVariableTable	Attribute class for standard LocalVariableTable attributes.
AttLocalVariableTypeTable	Attribute class for standard LocalVariableTypeTable attributes.
Attribute	Interface representing attributes of class files (directly or indirectly).
AttributeFactory	Factory capable of instantiating various Attribute subclasses depending on the context and name.
AttributeList	Interface for lists of attributes.
AttRuntimeInvisibleAnnotations	Attribute class for standard RuntimeInvisibleAnnotations attributes.
AttRuntimeInvisibleParameterAnnotations	Attribute class for standard RuntimeInvisibleParameterAnnotations attributes.
AttRuntimeVisibleAnnotations	Attribute class for standard RuntimeVisibleAnnotations attributes.
AttRuntimeVisibleParameterAnnotations	Attribute class for standard RuntimeVisibleParameterAnnotations attributes.
AttSignature	Attribute class for standards-track Signature attributes.
AttSourceDebugExtension	Attribute class for standard SourceDebugExtension attributes.
AttSourceFile	Attribute class for standard SourceFile attributes.
AttSynthetic	Attribute class for standard Synthetic attributes.
BaseAnnotations	Base class for annotations attributes.
BaseAttribute	Base implementation of Attribute, which directly stores the attribute name but leaves the rest up to subclasses.
BaseCodeCursor	Base implementation of CodeCursor.
BaseDumper	Base class for the various human-friendly dumpers.
BaseLocalVariables	Base attribute class for standard LocalVariableTable and LocalVariableTypeTable attributes.
BaseMachine	Base implementation of Machine.
BaseParameterAnnotations	Base class for parameter annotation list attributes.
BasicBlock	Basic block of register-based instructions.
BasicBlock.Visitor	BasicBlock visitor interface
BasicBlocker	Utility that identifies basic blocks in bytecode.
BasicBlockList	List of BasicBlock instances.
BasicRegisterMapper	This class maps one register space into another, with each mapping built up individually and added via addMapping()
BitIntSet	A set of integers, represented by a bit set
Bits	Utilities for treating int[]s as bit sets.
BlockAddresses	Container for the set of CodeAddress instances associated with the blocks of a particular method.
BlockDumper	Utility to dump basic block info from methods in a human-friendly form.
BootstrapMethodArgumentsList	List of bootstrap method arguments, which are part of the contents of BootstrapMethods attributes.
BootstrapMethodsList	List of bootstrap method entries, which are the contents of BootstrapMethods attributes.
BootstrapMethodsList.Item
ByteArray	Wrapper for a byte[], which provides read-only access and can "reveal" a partial slice of the underlying array.
ByteArray.GetCursor	Helper interface that allows one to get the cursor (of a stream).
ByteArray.MyDataInputStream	Helper class for ByteArray.makeDataInputStream().
ByteArrayAnnotatedOutput	Implementation of AnnotatedOutput which stores the written data into a byte[].
ByteArrayByteInput
ByteBlock	Representation of a basic block in a bytecode array.
ByteBlockList	List of ByteBlock instances.
ByteCatchList	List of catch entries, that is, the elements of an "exception table," which is part of a standard Code attribute.
ByteCatchList.Item	Item in an exception handler list.
BytecodeArray	Bytecode array, which is part of a standard Code attribute.
BytecodeArray.BaseVisitor	Base implementation of BytecodeArray.Visitor, which has empty method bodies for all methods.
BytecodeArray.Visitor	Instruction visitor interface.
ByteInput	A byte source.
ByteOps	Constants and utility methods for dealing with bytecode arrays at an opcode level.
ByteOutput	A byte sink.
CallSiteId	A call_site_id_item: https://source.android.com/devices/tech/dalvik/dex-format#call-site-id-item
CallSiteIdItem	Representation of a call site reference in a DEX file.
CallSiteIdsSection	A section in the DEX file for call site identifiers.
CallSiteItem	Representation of a call site in a DEX file.
CatchBuilder	Interface for the construction of CatchTable instances.
CatchHandlerList	Ordered list of (exception type, handler address) entries.
CatchHandlerList.Entry	Entry in the list.
CatchStructs	List of exception handlers (tuples of covered range, catch type, handler address) for a particular piece of code.
CatchTable	Table of catch entries.
CatchTable.Entry	Entry in a catch list.
CfOptions	A class to contain options passed into dex.cf
CfTranslator	Static method that turns byte[]s containing Java classfiles into ClassDefItem instances.
ClassData
ClassData.Field
ClassData.Method
ClassDataItem	Representation of all the parts of a Dalvik class that are generally "inflated" into an in-memory representation at runtime.
ClassDef	A type definition.
ClassDefItem	Representation of a Dalvik class, which is basically a set of members (fields or methods) along with a few more pieces of information.
ClassDefsSection	Class definitions list section of a .dex file.
ClassDumper	Utility to dump the contents of class files in a human-friendly form.
ClassFile	Interface for things which purport to be class files or reasonable facsimiles thereof.
ClassPathOpener	Opens all the class files found in a class path element.
ClassPathOpener.Consumer	Callback interface for ClassOpener.
ClassPathOpener.FileNameFilter	Filter interface for ClassOpener.
ClassReferenceListBuilder	Tool to find direct class references to other classes.
Code
Code.CatchHandler
Code.Try
CodeAddress	Pseudo-instruction which is used to track an address within a code array.
CodeCursor	Cursor over code units, for reading or writing out Dalvik bytecode.
CodeInput	Input stream of code units, for reading in Dalvik bytecode.
CodeItem	Representation of all the parts needed for concrete methods in a dex file.
CodeObserver	Bytecode visitor to use when "observing" bytecode getting parsed.
CodeOutput	Output stream of code units, for writing out Dalvik bytecode.
CodeReader	Walks through a block of code and calls visitor call backs.
CodeReader.Visitor
CodeStatistics	Static methods and variables for collecting statistics on generated code.
CollisionPolicy	What to do when two dex files define the same class.
ConcreteMethod	Container for all the giblets that make up a concrete Java bytecode method.
ConservativeTranslationAdvice	Implementation of TranslationAdvice which conservatively answers false to all methods.
Constant	Base class for constants of all sorts.
ConstantPool	Interface for constant pools, which are, more or less, just lists of Constant objects.
ConstantPoolParser	Parser for a constant pool embedded in a class file.
ConstantTags	Tags for constant pool constants.
ConstCollector	Collects constants that are used more than once at the top of the method block.
CstAnnotation	Constant type that represents an annotation.
CstArray	Constant type to represent a fixed array of other constants.
CstArray.List	List of Constant instances.
CstBaseMethodRef	Base class for constants of "methodish" type.
CstBoolean	Constants of type boolean.
CstByte	Constants of type byte.
CstCallSite	Constant type to represent a call site.
CstCallSiteRef	Reference to a call site.
CstChar	Constants of type char.
CstDouble	Constants of type CONSTANT_Double_info.
CstEnumRef	Constant type to represent a reference to a particular constant value of an enumerated type.
CstFieldRef	Constants of type CONSTANT_Fieldref_info.
CstFloat	Constants of type CONSTANT_Float_info.
CstInsn	Instruction which has a single constant argument in addition to all the normal instruction information.
CstInsn	Instruction which contains an explicit reference to a constant.
CstInteger	Constants of type CONSTANT_Integer_info.
CstInterfaceMethodRef	Constants of type CONSTANT_InterfaceMethodref_info.
CstInvokeDynamic	Constants of type InvokeDynamic.
CstKnownNull	Constant type to represent a known-null value.
CstLiteral32	Constants which are literal 32-bit values of some sort.
CstLiteral64	Constants which are literal 64-bit values of some sort.
CstLiteralBits	Constants which are literal bitwise values of some sort.
CstLong	Constants of type CONSTANT_Long_info.
CstMemberRef	Constants of type CONSTANT_*ref_info.
CstMethodHandle	Constants of type MethodHandle.
CstMethodRef	Constants of type CONSTANT_Methodref_info.
CstNat	Constants of type CONSTANT_NameAndType_info.
CstProtoRef	Prototype reference.
CstShort	Constants of type short.
CstString	Constants of type CONSTANT_Utf8_info or CONSTANT_String_info.
CstType	Constants that represent an arbitrary type (reference or primitive).
DalvCode	Container for all the pieces of a concrete method.
DalvCode.AssignIndicesCallback	Class used as a callback for DalvCode.assignIndices(com.android.dx.dex.code.DalvCode.AssignIndicesCallback).
DalvInsn	Base class for Dalvik instructions.
DalvInsnList	List of DalvInsn instances.
DeadCodeRemover	A variation on Appel Algorithm 19.12 "Dead code elimination in SSA form".
DebugInfoConstants	Constants for the dex debug info state machine format.
DebugInfoDecoder	A decoder for the dex debug info state machine format.
DebugInfoEncoder	An encoder for the dex debug info state machine format.
DebugInfoItem
DecodedInstruction	A decoded Dalvik instruction.
Dex	The bytes of a dex file in memory for reading and writing.
DexException	Thrown when there's a format problem reading, writing, or generally processing a dex file.
DexFile	Representation of an entire .dex (Dalvik EXecutable) file, which itself consists of a set of Dalvik classes.
DexFile.Storage	Holder for a byte[] that can grow on demand.
DexFormat	Constants that show up in and are otherwise related to .dex files, and helper methods for same.
DexIndexOverflowException	Thrown when there's an index overflow writing a dex file.
DexIndexPrinter	Executable that prints all indices of a dex file.
DexMerger	Combine two dex files into one.
DexOptions	Container for options used to control details of dex file generation.
DexTranslationAdvice	Implementation of TranslationAdvice which represents what the dex format will be able to represent.
DirectClassFile	Class file with info taken from a byte[] or slice thereof.
DomFront	Calculates the dominance-frontiers of a method's basic blocks.
DomFront.DomInfo	Dominance-frontier information for a single basic block.
Dominators	This class computes dominator and post-dominator information using the Lengauer-Tarjan method.
Dop	Representation of an opcode.
Dops	Standard instances of Dop and utility methods for getting them.
DotDumper	Dumps the pred/succ graph of methods into a format compatible with the popular graph utility "dot".
DxContext	State used by a single invocation of Main.
EncodedArrayItem	Encoded array of constant values.
EncodedField	Representation of a field of a class, of any sort.
EncodedMember	Representation of a member (field or method) of a class, for the purposes of encoding it inside a ClassDataItem.
EncodedMethod	Class that representats a method of a class.
EncodedValue	An encoded value or array.
EncodedValueCodec	Read and write encoded_value primitives.
EncodedValueReader	Pull parser for encoded values.
EscapeAnalysis	Simple intraprocedural escape analysis.
EscapeAnalysis.EscapeState	Lattice values used to indicate escape state for an object.
Exceptions	Common exception types.
ExceptionWithContext	Exception which carries around structured context.
ExecutionStack	Representation of a Java method execution stack.
Field	Interface representing fields of class files.
FieldAnnotationStruct	Association of a field and its annotations.
FieldId
FieldIdItem	Representation of a field reference inside a Dalvik file.
FieldIdsSection	Field refs list section of a .dex file.
FieldList	Interface for lists of fields.
FileUtils	File I/O utilities.
FillArrayDataInsn	Instruction which fills a newly created array with a predefined list of constant values.
FillArrayDataPayloadDecodedInstruction	A decoded Dalvik instruction which contains the payload for a packed-switch instruction.
FindUsages
FirstFitAllocator	Allocates registers via a naive n^2 register allocator.
FirstFitLocalCombiningAllocator	Allocates registers in a first-fit fashion, with the bottom reserved for method parameters and all SSAregisters representing the same local variable kept together if possible.
FiveRegisterDecodedInstruction	A decoded Dalvik instruction which has five register arguments.
FixedSizeInsn	Base class for instructions which are of a fixed code size and which use InsnFormat methods to write themselves.
FixedSizeList	Simple (mostly) fixed-size list of objects, which may be made immutable.
Form10t	Instruction format 10t.
Form10x	Instruction format 10x.
Form11n	Instruction format 11n.
Form11x	Instruction format 11x.
Form12x	Instruction format 12x.
Form20t	Instruction format 20t.
Form21c	Instruction format 21c.
Form21h	Instruction format 21h.
Form21s	Instruction format 21s.
Form21t	Instruction format 21t.
Form22b	Instruction format 22b.
Form22c	Instruction format 22c.
Form22s	Instruction format 22s.
Form22t	Instruction format 22t.
Form22x	Instruction format 22x.
Form23x	Instruction format 23x.
Form30t	Instruction format 30t.
Form31c	Instruction format 31c.
Form31i	Instruction format 31i.
Form31t	Instruction format 31t.
Form32x	Instruction format 32x.
Form35c	Instruction format 35c.
Form3rc	Instruction format 3rc.
Form45cc	Instruction format 45cc.
Form4rcc	Instruction format 4rcc.
Form51l	Instruction format 51l.
FourRegisterDecodedInstruction	A decoded Dalvik instruction which has five register arguments.
Frame	Representation of a Java method execution frame.
Grep
HasAttribute	An element that can have Attribute
HeaderItem	File header section of a .dex file.
HeaderSection	File header section of a .dex file.
Hex	Utilities for formatting numbers as hexadecimal.
HexParser	Utilities for parsing hexadecimal text.
HighRegisterPrefix	Combination instruction which turns into a variable number of move* instructions to move a set of registers into registers starting at 0 sequentially.
IdenticalBlockCombiner	Searches for basic blocks that all have the same successor and insns but different predecessors.
IdItem	Representation of a reference to an item inside a Dalvik file.
IndentingWriter	Writer that wraps another writer and passes width-limited and optionally-prefixed output to its subordinate.
IndexedItem	An item in a Dalvik file which is referenced by index.
IndexMap	Maps the index offsets from one dex file to those in another.
IndexType	The various types that an index in a Dalvik instruction might refer to.
InnerClassList	List of "inner class" entries, which are the contents of InnerClasses attributes.
InnerClassList.Item	Item in an inner classes list.
Insn	A register-based instruction.
Insn.BaseVisitor	Base implementation of Insn.Visitor, which has empty method bodies for all methods.
Insn.Visitor	Visitor interface for this (outer) class.
InsnFormat	Base class for all instruction format handlers.
InsnList	List of Insn instances.
InstructionCodec	Representation of an instruction format, which knows how to decode into and encode from instances of DecodedInstruction.
InterferenceGraph	A register interference graph
InterferenceRegisterMapper	A register mapper that keeps track of the accumulated interference information for the registers in the new namespace.
IntIterator	An iterator for a list of ints.
IntList	Simple list of ints.
IntSet	A set of integers
InvokePolymorphicDecodedInstruction	A decoded invoke-polymorphic instruction.
InvokePolymorphicInsn	An invoke-polymorphic instruction.
InvokePolymorphicRangeDecodedInstruction	A decoded invoke-polymorphic/range instruction.
Item	Base class for any structurally-significant and (potentially) repeated piece of a Dalvik file.
ItemType	Enumeration of all the top-level item types.
LabeledItem	An item that has an integer label.
LabeledList	A list of labeled items, allowing easy lookup by label.
Leb128	Reads and writes DWARFv3 LEB 128 signed and unsigned integers.
LineNumberList	List of "line number" entries, which are the contents of LineNumberTable attributes.
LineNumberList.Item	Item in a line number table.
ListIntSet	A set of integers, represented by a list
LiteralOpUpgrader	Upgrades insn to their literal (constant-immediate) equivalent if possible.
LivenessAnalyzer	From Appel "Modern Compiler Implementation in Java" algorithm 19.17 Calculate the live ranges for register reg.
LocalItem	A local variable item: either a name or a signature or both.
LocalList	List of local variables.
LocalList.Disposition	Disposition of a local entry.
LocalList.Entry	Entry in a local list.
LocalList.MakeState	Intermediate state when constructing a local list.
LocalsArray	Representation of an array of local variables, with Java semantics.
LocalsArraySet	Representation of a set of local variable arrays, with Java semantics.
LocalSnapshot	Pseudo-instruction which is used to hold a snapshot of the state of local variable name mappings that exists immediately after the instance in an instruction array.
LocalStart	Pseudo-instruction which is used to introduce a new local variable.
LocalVariableExtractor	Code to figure out which local variables are active at which points in a method.
LocalVariableExtractor	Code to figure out which local variables are active at which points in a method.
LocalVariableInfo	Container for local variable information for a particular RopMethod.
LocalVariableInfo	Container for local variable information for a particular SsaMethod.
LocalVariableList	List of "local variable" entries, which are the contents of LocalVariableTable and LocalVariableTypeTable attributes, as well as combinations of the two.
LocalVariableList.Item	Item in a local variable table.
Machine	Interface for machines capable of executing bytecode by acting upon a Frame.
Main
Main	Main class for the class file translator.
Main	Main class for the class file dumper.
Main
Main
Main	Main class for dx.
Main.Arguments	Command-line argument parser and access.
MainDexListBuilder	This is a command line tool used by mainDexClasses script to build a main dex classes list.
MapItem	Class that represents a map item.
Member	Interface representing members of class files (that is, fields and methods).
MemberIdItem	Representation of a member (field or method) reference inside a Dalvik file.
MemberIdsSection	Member (field or method) refs list section of a .dex file.
Merger	Utility methods to merge various frame information.
Method	Interface representing methods of class files.
MethodAnnotationStruct	Association of a method and its annotations.
MethodHandle	A method_handle_item: https://source.android.com/devices/tech/dalvik/dex-format#method-handle-item
MethodHandle.MethodHandleType	A method handle type code: https://source.android.com/devices/tech/dalvik/dex-format#method-handle-type-codes
MethodHandleItem	Representation of a method handle in a DEX file.
MethodHandleKind	Method Handle kinds for CONSTANT_MethodHandle_info constants.
MethodHandlesSection
MethodId
MethodIdItem	Representation of a method reference inside a Dalvik file.
MethodIdsSection	Method refs list section of a .dex file.
MethodList	Interface for lists of methods.
MixedItemSection	A section of a .dex file which consists of a sequence of OffsettedItem objects, which may each be of a different concrete class and/or size.
MoveParamCombiner	Combine identical move-param insns, which may result from Ropper's handling of synchronized methods.
MultiCstInsn	An instruction with multiple constant arguments in addition to all the normal instruction information.
MutabilityControl	Very simple base class that implements a flag to control the mutability of instances.
MutabilityException	Exception due to a mutability problem.
Mutf8	Modified UTF-8 as described in the dex file format spec.
NameValuePair	A (name, value) pair.
NormalSsaInsn	A "normal" (non-phi) instruction in SSA form.
NullRegisterAllocator	A register allocator that maps SSA register n to Rop register 2*n, essentially preserving the original mapping and remaining agnostic about normal or wide categories.
OddSpacer	Pseudo-instruction which either turns into a nop or nothingness, in order to make the subsequent instruction have an even address.
OffsettedItem	An item in a Dalvik file which is referenced by absolute offset.
OneLocalsArray	Representation of an array of local variables, with Java semantics.
OneRegisterDecodedInstruction	A decoded Dalvik instruction which has one register argument.
OpcodeInfo	Information about each Dalvik opcode.
OpcodeInfo.Info	Information about an opcode.
Opcodes	All the Dalvik opcode value constants.
Optimizer	Runs a method through the SSA form conversion, any optimization algorithms, and returns it to rop form.
Optimizer.OptionalStep	optional optimizer steps
OptimizerOptions	Settings for optimization of code.
Output	Interface for a sink for binary output.
OutputCollector	Destination for DalvInsn instances being output.
OutputFinisher	Processor for instruction lists, which takes a "first cut" of instruction selection as a basis and produces a "final cut" in the form of a DalvInsnList instance.
PackedSwitchPayloadDecodedInstruction	A decoded Dalvik instruction which contains the payload for a packed-switch instruction.
ParameterAnnotationStruct	Association of a method and its parameter annotations.
ParseException	Exception from parsing.
ParseObserver	Observer of parsing in action.
PhiInsn	A Phi instruction (magical post-control-flow-merge) instruction in SSA form.
PhiInsn.Visitor	Visitor interface for instances of this (outer) class.
PhiTypeResolver	Resolves the result types of phi instructions.
PlainCstInsn	Instruction which contains an explicit reference to a constant but which cannot throw an exception.
PlainInsn	Plain instruction, which has no embedded data and which cannot possibly throw an exception.
PositionList	List of source position entries.
PositionList.Entry	Entry in a position list.
ProtoId
ProtoIdItem	Representation of a method prototype reference inside a Dalvik file.
ProtoIdsSection	Proto (method prototype) identifiers list section of a .dex file.
Prototype	Representation of a method descriptor.
RawAttribute	Raw attribute, for holding onto attributes that are unrecognized.
RegisterAllocator	Base class of all register allocators.
RegisterMapper	Represents a mapping between two register numbering schemes.
RegisterRangeDecodedInstruction	A decoded Dalvik instruction which has register range arguments (an "A" start register and a register count).
RegisterSpec	Combination of a register number and a type, used as the sources and destinations of register-based operations.
RegisterSpecList	List of RegisterSpec instances.
RegisterSpecSet	Set of RegisterSpec instances, where a given register number may appear only once in the set.
RegOps	All the register-based opcodes, and related utilities.
ReturnAddress	Representation of a subroutine return address.
Rop	Class that describes all the immutable parts of register-based operations.
RopMethod	All of the parts that make up a method at the rop layer.
Ropper	Utility that converts a basic block list into a list of register-oriented blocks.
Rops	Standard instances of Rop.
RopToDop	Translator from rop-level Insn instances to corresponding Dop instances.
RopTranslator	Translator from RopMethod to DalvCode.
SCCP	A small variant of Wegman and Zadeck's Sparse Conditional Constant Propagation algorithm.
Section	A section of a .dex file.
SetFactory	Makes int sets for various parts of the optimizer.
ShortArrayCodeInput	Implementation of CodeInput that reads from a short[].
ShortArrayCodeOutput	Implementation of CodeOutput that writes to a short[].
SimException	Exception from simulation.
SimpleInsn	Instruction which has no extra info beyond the basics provided for in the base class.
Simulator	Class which knows how to simulate the effects of executing bytecode.
SizeOf
SourcePosition	Information about a source position for code, which includes both a line number and original bytecode address.
SparseSwitchPayloadDecodedInstruction	A decoded Dalvik instruction which contains the payload for a packed-switch instruction.
SpecialFormat	Instruction format for nonstandard format instructions, which aren't generally real instructions but do end up appearing in instruction lists.
SsaBasicBlock	An SSA representation of a basic block.
SsaBasicBlock.LabelComparator	Label comparator.
SsaBasicBlock.Visitor	Visitor interface for basic blocks.
SsaConverter	Converts ROP methods to SSA Methods
SsaDumper	Dumper for the SSA-translated blocks of a method.
SsaInsn	An instruction in SSA form
SsaInsn.Visitor	Visitor interface for this class.
SsaMethod	A method in SSA form.
SsaRenamer	Complete transformation to SSA form by renaming all registers accessed.
SsaToRop	Converts a method in SSA form to ROP form.
Statistics	Statistics about the contents of a file.
StdAttributeFactory	Standard subclass of AttributeFactory, which knows how to parse all the standard attribute types.
StdAttributeList	Standard implementation of AttributeList, which directly stores an array of Attribute objects and can be made immutable.
StdCatchBuilder	Constructor of CatchTable instances from RopMethod and associated data.
StdConstantPool	Standard implementation of ConstantPool, which directly stores an array of Constant objects and can be made immutable.
StdField	Standard implementation of Field, which directly stores all the associated data.
StdFieldList	Standard implementation of FieldList, which directly stores an array of Field objects and can be made immutable.
StdMember	Standard implementation of Member, which directly stores all the associated data.
StdMethod	Standard implementation of Method, which directly stores all the associated data.
StdMethodList	Standard implementation of MethodList, which directly stores an array of Method objects and can be made immutable.
StdTypeList	Standard implementation of TypeList.
StringDataItem	Representation of string data for a particular string, in a Dalvik file.
StringIdItem	Representation of a string inside a Dalvik file.
StringIdsSection	Strings list section of a .dex file.
SwitchData	Pseudo-instruction which holds switch data.
SwitchInsn	Instruction which contains switch cases.
SwitchList	List of (value, target) mappings representing the choices of a tableswitch or lookupswitch instruction.
TableOfContents	The file header and map.
TableOfContents.Section
TargetInsn	Instruction which has a single branch target.
ThreeRegisterDecodedInstruction	A decoded Dalvik instruction which has three register arguments.
ThrowingCstInsn	Instruction which contains an explicit reference to a constant and which might throw an exception.
ThrowingInsn	Instruction which possibly throws.
ToHuman	Simple interface for objects that can return a "human" (as opposed to a complete but often hard to read) string form.
TranslationAdvice	Interface for "advice" passed from the late stage of translation back to the early stage.
TwoColumnOutput	Class that takes a combined output destination and provides two output writers, one of which ends up writing to the left column and one which goes on the right.
TwoRegisterDecodedInstruction	A decoded Dalvik instruction which has two register arguments.
Type	Representation of a value type, such as may appear in a field, in a local, on a stack, or in a method descriptor.
TypeBearer	Object which has an associated type, possibly itself.
TypedConstant	Base class for constants which implement TypeBearer.
TypeIdItem	Representation of a type reference inside a Dalvik file.
TypeIdsSection	Type identifiers list section of a .dex file.
TypeList
TypeList	List of Type instances (or of things that contain types).
TypeListItem	Representation of a list of class references.
UniformItemSection	A section of a .dex file which consists of a sequence of Item objects.
UniformListItem<T>	Class that represents a contiguous list of uniform items.
Unsigned	Unsigned arithmetic over Java's signed types.
UsageException	Simple exception class used to communicate that the command-line tool should print the usage message.
ValueAwareMachine	Machine which keeps track of known values but does not do smart/realistic reference type calculations.
ValueEncoder	Handler for writing out encoded_values and parts thereof.
VariableSizeInsn	Pseudo-instruction base class for variable-sized instructions.
Version	Version number for dx.
Warning	Exception which is meant to indicate a non-fatal warning.
Writers	Utilities for dealing with Writers.
Zeroes	Utility for turning types into zeroes.
ZeroRegisterDecodedInstruction	A decoded Dalvik instruction which has no register arguments.
ZeroSizeInsn	Pseudo-instruction base class for zero-size (no code emitted) instructions, which are generally used for tracking metainformation about the code they are adjacent to.