CodeAttr

java.lang.Object
- gnu.bytecode.Attribute
- - gnu.bytecode.CodeAttr

All Implemented Interfaces:

AttrContainer
```
public class CodeAttr
extends Attribute
implements AttrContainer
```
Represents the contents of a standard "Code" attribute.
Most of the actual methods that generate bytecode operation are in this class (typically with names starting with emit), though there are also some in Method.
Note that a CodeAttr is an Attribute of a Method, and can in turn contain other Attributes, such as a LineNumbersAttr.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DONT_USE_JSR`
`static int`	`GENERATE_STACK_MAP_TABLE`
`static boolean`	`instructionLineMode` If true we get a line number entry for each instruction.
`LocalVarsAttr`	`locals`
`Type[]`	`stack_types`
`StackMapTableAttr`	`stackMap`

Constructor Summary

Constructors
Constructor and Description

CodeAttr(Method meth)

Constructors
Constructor and Description
`CodeAttr(Method meth)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addHandler(int start_pc, int end_pc, int handler_pc, int catch_type)` Add an exception handler.
`void`	`addHandler(Label start_try, Label end_try, ClassType catch_type)` Add an exception handler.
`Variable`	`addLocal(Type type)` Add a new local variable (in the current scope).
`Variable`	`addLocal(Type type, java.lang.String name)` Add a new local variable (in the current scope).
`void`	`addParamLocals()` Call addLocal for parameters (as implied by method type).
`void`	`assignConstants(ClassType cl)` Add any needed constant pool entries for this Attribute.
`int`	`beginFragment(Label after)`
`int`	`beginFragment(Label start, Label after)`
`static java.lang.String`	`calculateSplit(java.lang.String str)` Calculate how many CONSTANT_String constants we need for a string.
`static boolean`	`castNeeded(Type top, Type required)`
`void`	`disAssemble(ClassTypeWriter dst, int start, int limit)`
`void`	`emitAdd()` Deprecated.
`void`	`emitAdd(char sig)`
`void`	`emitAdd(PrimType type)`
`void`	`emitAnd()`
`void`	`emitAndThen()` Convenience for compiling `if P1 && P2 then S1 else S2`.
`void`	`emitArrayLength()`
`void`	`emitArrayLoad()` Load an element from an array.
`void`	`emitArrayLoad(Type element_type)` Load an element from an array.
`void`	`emitArrayStore()` Store into an element of an array.
`void`	`emitArrayStore(Type element_type)` Store into an element of an array.
`void`	`emitBinop(int base_code, Type type)`
`void`	`emitCatchEnd()`
`void`	`emitCatchStart(ClassType type)`
`void`	`emitCatchStart(Variable var)`
`void`	`emitCheckcast(Type type)`
`void`	`emitConvert(PrimType from, PrimType to)`
`void`	`emitDiv()`
`void`	`emitDup()` Emit code to duplicate the top element of the stack.
`void`	`emitDup(int size)` Compile code to duplicate the top 1 or 2 words.
`void`	`emitDup(int size, int offset)` Compile code to duplicate with offset.
`void`	`emitDup(Type type)`
`void`	`emitDupX()` Emit code to duplicate the top element of the stack and place the copy before the previous element.
`void`	`emitElse()` Compile start of else clause.
`void`	`emitFi()` Compile end of conditional.
`void`	`emitFinallyEnd()`
`void`	`emitFinallyStart()`
`void`	`emitGetField(Field field)` Compile code to get a non-static field value.
`void`	`emitGetStatic(Field field)` Compile code to get a static field value.
`void`	`emitGoto(Label label)` Compile an unconditional branch (goto).
`void`	`emitGotoIfCompare1(Label label, int opcode)`
`void`	`emitGotoIfCompare2(Label label, int logop)`
`void`	`emitGotoIfEq(Label label)` Compile a conditional transfer if 2 top stack elements are equal.
`void`	`emitGotoIfEq(Label label, boolean invert)` Deprecated.
`void`	`emitGotoIfGe(Label label)`
`void`	`emitGotoIfGt(Label label)`
`void`	`emitGotoIfIntEqZero(Label label)`
`void`	`emitGotoIfIntGeZero(Label label)`
`void`	`emitGotoIfIntGtZero(Label label)`
`void`	`emitGotoIfIntLeZero(Label label)`
`void`	`emitGotoIfIntLtZero(Label label)`
`void`	`emitGotoIfIntNeZero(Label label)`
`void`	`emitGotoIfLe(Label label)`
`void`	`emitGotoIfLt(Label label)`
`void`	`emitGotoIfNE(Label label)` Compile conditional transfer if 2 top stack elements are not equal.
`void`	`emitGotoIfNonNull(Label label)`
`void`	`emitGotoIfNull(Label label)`
`void`	`emitIfCompare1(int opcode)` Compile start of a conditional: `if (!(x opcode 0)) ...`.
`void`	`emitIfEq()` Compile start of a conditional: `if (x == y) ...` The values of x and y must already have been pushed.
`void`	`emitIfGe()` Compile start of a conditional: `if (x >= y) ...` The values of x and y must already have been pushed.
`void`	`emitIfGt()` Compile start of a conditional: `if (x > y) ...` The values of x and y must already have been pushed.
`void`	`emitIfIntCompare(int opcode)` Compile start of a conditional: `if (!(x OPCODE y)) ...` The value of x and y must already have been pushed.
`void`	`emitIfIntEqZero()` Compile start of conditional: `if (x == 0) ...`.
`void`	`emitIfIntGEq()`
`void`	`emitIfIntGEqZero()` Compile start of conditional: `if (x >= 0)`.
`void`	`emitIfIntLEqZero()` Compile start of conditional: `if (x <= 0)`.
`void`	`emitIfIntLt()`
`void`	`emitIfIntNotZero()` Compile start of conditional: `if (x != 0) ...`.
`void`	`emitIfLe()` Compile start of a conditional: `if (x <= y) ...` The values of x and y must already have been pushed.
`void`	`emitIfLt()` Compile start of a conditional: `if (x < y) ...` The values of x and y must already have been pushed.
`void`	`emitIfNEq()` Compile start of a conditional: if (x != y) ...
`void`	`emitIfNotNull()` Compile start of conditional: `if (x != null) ...`.
`void`	`emitIfNull()` Compile start of conditional: `if (x == null) ...`
`void`	`emitIfRefCompare1(int opcode)` Compile start of a conditional: `if (!(x opcode null)) ...`.
`void`	`emitIfThen()`
`void`	`emitInc(Variable var, short inc)` Emit an instruction to increment a variable by some amount.
`void`	`emitInstanceof(Type type)`
`void`	`emitInvoke(Method method)`
`void`	`emitInvokeInterface(Method method)`
`void`	`emitInvokeMethod(Method method, int opcode)`
`void`	`emitInvokeSpecial(Method method)`
`void`	`emitInvokeStatic(Method method)` Compile a static method call.
`void`	`emitInvokeVirtual(Method method)` Compile a virtual method call.
`void`	`emitIOr()`
`void`	`emitJsr(Label label)`
`void`	`emitLoad(Variable var)` Compile code to push the contents of a local variable onto the statck.
`void`	`emitMonitorEnter()`
`void`	`emitMonitorExit()`
`void`	`emitMul()`
`void`	`emitNew(ClassType type)` Invoke new on a class type.
`void`	`emitNewArray(Type element_type)`
`void`	`emitNewArray(Type element_type, int dims)` Compile code to allocate a new array.
`void`	`emitNot(Type type)` Compile 'not', assuming 0 or 1 is on the JVM stack.
`void`	`emitPop(int nvalues)` Compile code to pop values off the stack (and ignore them).
`void`	`emitPrimop(int opcode, int arg_count, Type retType)`
`void`	`emitPushClass(ObjectType ctype)` Push a class constant pool entry.
`void`	`emitPushConstant(CpoolEntry cnst)`
`void`	`emitPushConstant(int val, Type type)`
`void`	`emitPushDefaultValue(Type type)` Push zero or null as appropriate for the given type.
`void`	`emitPushDouble(double x)`
`void`	`emitPushFloat(float x)`
`void`	`emitPushInt(int i)`
`void`	`emitPushLong(long i)`
`void`	`emitPushMethodHandle(Method method)` Push a MethodHandle, using an appropriate constant pool entry.
`void`	`emitPushNull()`
`void`	`emitPushNull(ObjectType type)`
`void`	`emitPushPrimArray(java.lang.Object value, ArrayType arrayType)` Emit code to push a constant primitive array.
`void`	`emitPushString(java.lang.String str)` Emit code to push the value of a constant String.
`void`	`emitPushThis()`
`void`	`emitPutField(Field field)` Compile code to put a non-static field value.
`void`	`emitPutStatic(Field field)` Compile code to put a static field value.
`void`	`emitRem()`
`void`	`emitRet(Variable var)` Emit a 'ret' instruction.
`void`	`emitReturn()` Compile a method return.
`void`	`emitShl()`
`void`	`emitShr()`
`void`	`emitStore(Variable var)`
`void`	`emitStoreDefaultValue(Variable var)` Initialize a variable to zero or null, as appropriate.
`void`	`emitSub()` Deprecated.
`void`	`emitSub(char sig)`
`void`	`emitSub(PrimType type)`
`void`	`emitSwap()`
`void`	`emitTailCall(boolean pop_args, Label start)` Compile a tail-call to position 0 of the current procedure.
`void`	`emitTailCall(boolean pop_args, Scope scope)` Compile a tail-call to position 0 of the current procedure.
`void`	`emitThen()`
`void`	`emitThrow()`
`void`	`emitTryCatchEnd()`
`void`	`emitTryEnd()` Deprecated.
`void`	`emitTryStart(boolean has_finally, Type result_type)`
`void`	`emitUshr()`
`void`	`emitWithCleanupCatch(Variable catchVar)` Called after a `body` that has a `cleanup` clause.
`void`	`emitWithCleanupDone()` Called after generating a `cleanup` handler.
`void`	`emitWithCleanupStart()` Beginning of code that has a cleanup handler.
`void`	`emitXOr()`
`void`	`endExitableBlock()` End a block entered by a previous startExitableBlock.
`void`	`endFragment(int cookie)` End a fragment.
`void`	`enterScope(Scope scope)`
`void`	`fixUnsigned(Type stackType)`
`void`	`fixupAdd(int kind, Label label)` Add a fixup at this location.
`void`	`fixupChain(Label here, Label target)` This causes a later processFixup to rearrange the code.
`Variable`	`getArg(int index)` Get the index'th parameter.
`Attribute`	`getAttributes()` Get the (first) Attribute of this container.
`byte[]`	`getCode()` Get the code (instruction bytes) of this method.
`int`	`getCodeLength()` Set the current lengthof the code (instruction bytes) of this method.
`ConstantPool`	`getConstants()`
`Scope`	`getCurrentScope()`
`TryState`	`getCurrentTry()`
`Label`	`getLabel()` Get a new Label for the current location.
`int`	`getLength()` Return the length of the attribute in bytes.
`int`	`getMaxLocals()` Get the maximum number of local variable words in this method.
`int`	`getMaxStack()` Get the maximum number of words on the operand stack in this method.
`Method`	`getMethod()`
`int`	`getPC()`
`int`	`getSP()`
`boolean`	`isInTry()`
`Variable`	`lookup(java.lang.String name)` Search by name for a Variable
`void`	`noteVarType(int offset, Type type)`
`Scope`	`popScope()`
`Type`	`popType()`
`void`	`print(ClassTypeWriter dst)`
`void`	`processFixups()`
`Scope`	`pushAutoPoppableScope()` Create a Scope that is automatically popped.
`Scope`	`pushScope()`
`void`	`pushType(Type type)`
`void`	`put1(int i)` Write an 8-bit byte to the current code-stream.
`void`	`put2(int i)` Write a 16-bit short to the current code-stream
`void`	`put4(int i)` Write a 32-bit int to the current code-stream
`void`	`putIndex2(CpoolEntry cnst)`
`void`	`putLineNumber(int linenumber)`
`void`	`putLineNumber(java.lang.String filename, int linenumber)`
`boolean`	`reachableHere()` True if control could reach here.
`void`	`reserve(int bytes)`
`void`	`setAttributes(Attribute attributes)` Set the (list of) Attributes of this container.
`void`	`setCode(byte[] code)` Set the code (instruction bytes) of this method.
`void`	`setCodeLength(int len)` Set the length the the code (instruction bytes) of this method.
`void`	`setMaxLocals(int n)` Set the maximum number of local variable words in this method.
`void`	`setMaxStack(int n)` Set the maximum number of words on the operand stack in this method.
`void`	`setReachable(boolean val)`
`void`	`setTypes(Label label)` Set the current type state from a label.
`void`	`setTypes(Type[] labelLocals, Type[] labelStack)` Set the current type state from a label.
`void`	`setUnreachable()`
`ExitableBlock`	`startExitableBlock(Type resultType, boolean runFinallyBlocks)` Enter a block which can be exited.
`SwitchState`	`startSwitch()` Start a new switch statment or expression.
`Type`	`topType()`
`void`	`write(java.io.DataOutputStream dstr)` Write out the contents of the Attribute.

Methods inherited from class gnu.bytecode.Attribute
addToFrontOf, assignConstants, count, get, getContainer, getLengthAll, getName, getNameIndex, getNext, isSkipped, setContainer, setName, setNameIndex, setNext, setSkipped, setSkipped, writeAll

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - locals
```
public LocalVarsAttr locals
```
  - stackMap
```
public StackMapTableAttr stackMap
```
  - GENERATE_STACK_MAP_TABLE
```
public static final int GENERATE_STACK_MAP_TABLE
```
    See Also:
    Constant Field Values
  - DONT_USE_JSR
```
public static final int DONT_USE_JSR
```
    See Also:
    Constant Field Values
  - stack_types
```
public Type[] stack_types
```
  - instructionLineMode
```
public static boolean instructionLineMode
```
    If true we get a line number entry for each instruction. Normally false, but can be a convenient hack to allow instruction-level stepping/debugging and stacktraces. In this case LINE==PC.
- Constructor Detail
  - CodeAttr
```
public CodeAttr(Method meth)
```
- Method Detail
  - getAttributes
```
public final Attribute getAttributes()
```
    Description copied from interface: AttrContainer
    
    Get the (first) Attribute of this container.
    
    Specified by:
    
    getAttributes in interface AttrContainer
  - setAttributes
```
public final void setAttributes(Attribute attributes)
```
    Description copied from interface: AttrContainer
    
    Set the (list of) Attributes of this container.
    
    Specified by:
    
    setAttributes in interface AttrContainer
  - fixupChain
```
public final void fixupChain(Label here,
              Label target)
```
    This causes a later processFixup to rearrange the code. The code at target comes here, instead of the following instructions. Fuctionally equivalent to: goto target; here:, but implemented by code re-arranging. Therefore there should be at some later point a goto here; target:.
  - fixupAdd
```
public final void fixupAdd(int kind,
            Label label)
```
    Add a fixup at this location.
    
    Parameters:
    kind - one of the FIXUP_xxx codes.
    label - varies - typically the target of jump.
  - getMethod
```
public final Method getMethod()
```
  - getPC
```
public final int getPC()
```
  - getSP
```
public final int getSP()
```
  - getConstants
```
public final ConstantPool getConstants()
```
    Specified by:
    
    getConstants in interface AttrContainer
    
    Overrides:
    
    getConstants in class Attribute
  - reachableHere
```
public final boolean reachableHere()
```
    True if control could reach here.
  - setReachable
```
public final void setReachable(boolean val)
```
  - setUnreachable
```
public final void setUnreachable()
```
  - getMaxStack
```
public int getMaxStack()
```
    Get the maximum number of words on the operand stack in this method.
  - getMaxLocals
```
public int getMaxLocals()
```
    Get the maximum number of local variable words in this method.
  - setMaxStack
```
public void setMaxStack(int n)
```
    Set the maximum number of words on the operand stack in this method.
  - setMaxLocals
```
public void setMaxLocals(int n)
```
    Set the maximum number of local variable words in this method.
  - getCode
```
public byte[] getCode()
```
    Get the code (instruction bytes) of this method. Does not make a copy.
  - setCode
```
public void setCode(byte[] code)
```
    Set the code (instruction bytes) of this method.
    
    Parameters:
    code - the code bytes (which are not copied). Implicitly calls setCodeLength(code.length).
  - setCodeLength
```
public void setCodeLength(int len)
```
    Set the length the the code (instruction bytes) of this method. That is the number of current used bytes in getCode(). (Any remaing bytes provide for future growth.)
  - getCodeLength
```
public int getCodeLength()
```
    Set the current lengthof the code (instruction bytes) of this method.
  - reserve
```
public final void reserve(int bytes)
```
  - put1
```
public final void put1(int i)
```
    Write an 8-bit byte to the current code-stream.
    
    Parameters:
    i - the byte to write
  - put2
```
public final void put2(int i)
```
    Write a 16-bit short to the current code-stream
    
    Parameters:
    i - the value to write
  - put4
```
public final void put4(int i)
```
    Write a 32-bit int to the current code-stream
    
    Parameters:
    i - the value to write
  - putIndex2
```
public final void putIndex2(CpoolEntry cnst)
```
  - putLineNumber
```
public final void putLineNumber(java.lang.String filename,
                 int linenumber)
```
  - putLineNumber
```
public final void putLineNumber(int linenumber)
```
  - noteVarType
```
public void noteVarType(int offset,
               Type type)
```
  - setTypes
```
public final void setTypes(Label label)
```
    Set the current type state from a label.
  - setTypes
```
public final void setTypes(Type[] labelLocals,
            Type[] labelStack)
```
    Set the current type state from a label.
  - pushType
```
public final void pushType(Type type)
```
  - popType
```
public final Type popType()
```
  - topType
```
public final Type topType()
```
  - emitPop
```
public void emitPop(int nvalues)
```
    Compile code to pop values off the stack (and ignore them).
    
    Parameters:
    nvalues - the number of values (not words) to pop
  - getLabel
```
public Label getLabel()
```
    Get a new Label for the current location. Unlike Label.define, does not change reachableHere().
  - emitSwap
```
public void emitSwap()
```
  - emitDup
```
public void emitDup()
```
    Emit code to duplicate the top element of the stack.
  - emitDupX
```
public void emitDupX()
```
    Emit code to duplicate the top element of the stack and place the copy before the previous element.
  - emitDup
```
public void emitDup(int size,
           int offset)
```
    Compile code to duplicate with offset.
    
    Parameters:
    size - the size of the stack item to duplicate (1 or 2)
    offset - where to insert the result (must be 0, 1, or 2) The new words get inserted at stack[SP-size-offset]
  - emitDup
```
public void emitDup(int size)
```
    Compile code to duplicate the top 1 or 2 words.
    
    Parameters:
    size - number of words to duplicate
  - emitDup
```
public void emitDup(Type type)
```
  - enterScope
```
public void enterScope(Scope scope)
```
  - pushScope
```
public Scope pushScope()
```
  - pushAutoPoppableScope
```
public Scope pushAutoPoppableScope()
```
    Create a Scope that is automatically popped. I.e. the next popScope will keep popping autoPop scopes until it gets to a non-autoPop scope. An autoPop Scope is useful for variables that are assigned and set in the middle of a managed Scope.
  - getCurrentScope
```
public Scope getCurrentScope()
```
  - popScope
```
public Scope popScope()
```
  - getArg
```
public Variable getArg(int index)
```
    Get the index'th parameter.
  - lookup
```
public Variable lookup(java.lang.String name)
```
    Search by name for a Variable
    
    Parameters:
    name - name to search for
    
    Returns:
    the Variable, or null if not found (in any scope of this Method).
  - addLocal
```
public Variable addLocal(Type type)
```
    Add a new local variable (in the current scope).
    
    Parameters:
    type - type of the new Variable.
    
    Returns:
    the new Variable.
  - addLocal
```
public Variable addLocal(Type type,
                java.lang.String name)
```
    Add a new local variable (in the current scope).
    
    Parameters:
    type - type of the new Variable.
    name - name of the new Variable.
    
    Returns:
    the new Variable.
  - addParamLocals
```
public void addParamLocals()
```
    Call addLocal for parameters (as implied by method type).
  - emitPushConstant
```
public final void emitPushConstant(int val,
                    Type type)
```
  - emitPushConstant
```
public final void emitPushConstant(CpoolEntry cnst)
```
  - emitPushInt
```
public final void emitPushInt(int i)
```
  - emitPushLong
```
public void emitPushLong(long i)
```
  - emitPushFloat
```
public void emitPushFloat(float x)
```
  - emitPushDouble
```
public void emitPushDouble(double x)
```
  - calculateSplit
```
public static final java.lang.String calculateSplit(java.lang.String str)
```
    Calculate how many CONSTANT_String constants we need for a string. Each CONSTANT_String can be at most 0xFFFF bytes (as a UTF8 string). Returns a String, where each char, coerced to an int, is the length of a substring of the input that is at most 0xFFFF bytes.
  - emitPushString
```
public final void emitPushString(java.lang.String str)
```
    Emit code to push the value of a constant String. Uses CONSTANT_String and CONSTANT_Utf8 constant pool entries as needed. Can handle Strings whose UTF8 length is greates than 0xFFFF bytes (the limit of a CONSTANT_Utf8) by generating String concatenation.
  - emitPushClass
```
public final void emitPushClass(ObjectType ctype)
```
    Push a class constant pool entry. This is only supported by JDK 1.5 and later.
  - emitPushMethodHandle
```
public final void emitPushMethodHandle(Method method)
```
    Push a MethodHandle, using an appropriate constant pool entry. This is only supported by JDK 1.6 and later.
  - emitPushNull
```
public void emitPushNull()
```
  - emitPushNull
```
public void emitPushNull(ObjectType type)
```
  - emitPushDefaultValue
```
public void emitPushDefaultValue(Type type)
```
    Push zero or null as appropriate for the given type.
  - emitStoreDefaultValue
```
public void emitStoreDefaultValue(Variable var)
```
    Initialize a variable to zero or null, as appropriate.
  - emitPushThis
```
public final void emitPushThis()
```
  - emitPushPrimArray
```
public final void emitPushPrimArray(java.lang.Object value,
                     ArrayType arrayType)
```
    Emit code to push a constant primitive array.
    
    Parameters:
    value - The array value that we want the emitted code to re-create.
    arrayType - The ArrayType that matches value.
  - emitArrayLength
```
public final void emitArrayLength()
```
  - emitArrayStore
```
public void emitArrayStore(Type element_type)
```
    Store into an element of an array. Must already have pushed the array reference, the index, and the new value (in that order). Stack: ..., array, index, value => ...
  - emitArrayStore
```
public void emitArrayStore()
```
    Store into an element of an array. Must already have pushed the array reference, the index, and the new value (in that order). Stack: ..., array, index, value => ...
  - emitArrayLoad
```
public void emitArrayLoad(Type element_type)
```
    Load an element from an array. Must already have pushed the array and the index (in that order): Stack: ..., array, index => ..., value
  - emitArrayLoad
```
public void emitArrayLoad()
```
    Load an element from an array. Equivalent to emitArrayLoad(Type), but element_type is implied. Must already have pushed the array and the index (in that order): Stack: ..., array, index => ..., value
  - emitNew
```
public void emitNew(ClassType type)
```
    Invoke new on a class type. Does not call the constructor!
    
    Parameters:
    type - the desired new object type
  - emitNewArray
```
public void emitNewArray(Type element_type,
                int dims)
```
    Compile code to allocate a new array. The size should have been already pushed on the stack.
    
    Parameters:
    element_type - type of the array elements
    dims - number of dimensions - more than 1 is untested
  - emitNewArray
```
public void emitNewArray(Type element_type)
```
  - emitBinop
```
public void emitBinop(int base_code,
             Type type)
```
  - emitAdd
```
public final void emitAdd(char sig)
```
  - emitAdd
```
public final void emitAdd(PrimType type)
```
  - emitAdd
```
public final void emitAdd()
```
    Deprecated.
  - emitSub
```
public final void emitSub(char sig)
```
  - emitSub
```
public final void emitSub(PrimType type)
```
  - emitSub
```
public final void emitSub()
```
    Deprecated.
  - emitMul
```
public final void emitMul()
```
  - emitDiv
```
public final void emitDiv()
```
  - emitRem
```
public final void emitRem()
```
  - emitAnd
```
public final void emitAnd()
```
  - emitIOr
```
public final void emitIOr()
```
  - emitXOr
```
public final void emitXOr()
```
  - emitShl
```
public final void emitShl()
```
  - emitShr
```
public final void emitShr()
```
  - emitUshr
```
public final void emitUshr()
```
  - emitNot
```
public final void emitNot(Type type)
```
    Compile 'not', assuming 0 or 1 is on the JVM stack.
  - emitPrimop
```
public void emitPrimop(int opcode,
              int arg_count,
              Type retType)
```
  - emitLoad
```
public final void emitLoad(Variable var)
```
    Compile code to push the contents of a local variable onto the statck.
    
    Parameters:
    var - The variable whose contents we want to push.
  - emitStore
```
public void emitStore(Variable var)
```
  - emitInc
```
public void emitInc(Variable var,
           short inc)
```
    Emit an instruction to increment a variable by some amount. If the increment is zero, do nothing. The variable must contain an integral value - except if increment is zero.
  - emitGetStatic
```
public final void emitGetStatic(Field field)
```
    Compile code to get a static field value. Stack: ... => ..., value
  - emitGetField
```
public final void emitGetField(Field field)
```
    Compile code to get a non-static field value. Stack: ..., objectref => ..., value
  - emitPutStatic
```
public final void emitPutStatic(Field field)
```
    Compile code to put a static field value. Stack: ..., value => ...
  - emitPutField
```
public final void emitPutField(Field field)
```
    Compile code to put a non-static field value. Stack: ..., objectref, value => ...
  - emitInvokeMethod
```
public void emitInvokeMethod(Method method,
                    int opcode)
```
  - emitInvoke
```
public void emitInvoke(Method method)
```
  - emitInvokeVirtual
```
public void emitInvokeVirtual(Method method)
```
    Compile a virtual method call. The stack contains the 'this' object, followed by the arguments in order.
    
    Parameters:
    method - the method to invoke virtually
  - emitInvokeSpecial
```
public void emitInvokeSpecial(Method method)
```
  - emitInvokeStatic
```
public void emitInvokeStatic(Method method)
```
    Compile a static method call. The stack contains the the arguments in order.
    
    Parameters:
    method - the static method to invoke
  - emitInvokeInterface
```
public void emitInvokeInterface(Method method)
```
  - emitGoto
```
public final void emitGoto(Label label)
```
    Compile an unconditional branch (goto).
    
    Parameters:
    label - target of the branch (must be in this method).
  - emitJsr
```
public final void emitJsr(Label label)
```
  - startExitableBlock
```
public ExitableBlock startExitableBlock(Type resultType,
                               boolean runFinallyBlocks)
```
    Enter a block which can be exited. Used to make sure finally-blocks are executed when exiting a block, loop, or method.
  - endExitableBlock
```
public void endExitableBlock()
```
    End a block entered by a previous startExitableBlock.
  - emitGotoIfCompare1
```
public final void emitGotoIfCompare1(Label label,
                      int opcode)
```
  - emitGotoIfIntEqZero
```
public final void emitGotoIfIntEqZero(Label label)
```
  - emitGotoIfIntNeZero
```
public final void emitGotoIfIntNeZero(Label label)
```
  - emitGotoIfIntLtZero
```
public final void emitGotoIfIntLtZero(Label label)
```
  - emitGotoIfIntGeZero
```
public final void emitGotoIfIntGeZero(Label label)
```
  - emitGotoIfIntGtZero
```
public final void emitGotoIfIntGtZero(Label label)
```
  - emitGotoIfIntLeZero
```
public final void emitGotoIfIntLeZero(Label label)
```
  - emitGotoIfNull
```
public final void emitGotoIfNull(Label label)
```
  - emitGotoIfNonNull
```
public final void emitGotoIfNonNull(Label label)
```
  - emitGotoIfCompare2
```
public final void emitGotoIfCompare2(Label label,
                      int logop)
```
  - emitGotoIfEq
```
public final void emitGotoIfEq(Label label,
                boolean invert)
```
    Deprecated.
  - emitGotoIfEq
```
public final void emitGotoIfEq(Label label)
```
    Compile a conditional transfer if 2 top stack elements are equal.
  - emitGotoIfNE
```
public final void emitGotoIfNE(Label label)
```
    Compile conditional transfer if 2 top stack elements are not equal.
  - emitGotoIfLt
```
public final void emitGotoIfLt(Label label)
```
  - emitGotoIfGe
```
public final void emitGotoIfGe(Label label)
```
  - emitGotoIfGt
```
public final void emitGotoIfGt(Label label)
```
  - emitGotoIfLe
```
public final void emitGotoIfLe(Label label)
```
  - emitIfCompare1
```
public final void emitIfCompare1(int opcode)
```
    Compile start of a conditional: if (!(x opcode 0)) .... The value of x must already have been pushed.
  - emitIfIntNotZero
```
public final void emitIfIntNotZero()
```
    Compile start of conditional: if (x != 0) .... Also use this if you have pushed a boolean value: if (b) ...
  - emitIfIntEqZero
```
public final void emitIfIntEqZero()
```
    Compile start of conditional: if (x == 0) .... Also use this if you have pushed a boolean value: if (!b) ...
  - emitIfIntLEqZero
```
public final void emitIfIntLEqZero()
```
    Compile start of conditional: if (x <= 0).
  - emitIfIntGEqZero
```
public final void emitIfIntGEqZero()
```
    Compile start of conditional: if (x >= 0).
  - emitIfRefCompare1
```
public final void emitIfRefCompare1(int opcode)
```
    Compile start of a conditional: if (!(x opcode null)) .... The value of x must already have been pushed and must be of reference type.
  - emitIfNotNull
```
public final void emitIfNotNull()
```
    Compile start of conditional: if (x != null) ....
  - emitIfNull
```
public final void emitIfNull()
```
    Compile start of conditional: if (x == null) ...
  - emitIfIntCompare
```
public final void emitIfIntCompare(int opcode)
```
    Compile start of a conditional: if (!(x OPCODE y)) ... The value of x and y must already have been pushed.
  - emitIfIntLt
```
public final void emitIfIntLt()
```
  - emitIfIntGEq
```
public final void emitIfIntGEq()
```
  - emitIfNEq
```
public final void emitIfNEq()
```
    Compile start of a conditional: if (x != y) ... The values of x and y must already have been pushed.
  - emitIfEq
```
public final void emitIfEq()
```
    Compile start of a conditional: if (x == y) ... The values of x and y must already have been pushed.
  - emitIfLt
```
public final void emitIfLt()
```
    Compile start of a conditional: if (x < y) ... The values of x and y must already have been pushed.
  - emitIfGe
```
public final void emitIfGe()
```
    Compile start of a conditional: if (x >= y) ... The values of x and y must already have been pushed.
  - emitIfGt
```
public final void emitIfGt()
```
    Compile start of a conditional: if (x > y) ... The values of x and y must already have been pushed.
  - emitIfLe
```
public final void emitIfLe()
```
    Compile start of a conditional: if (x <= y) ... The values of x and y must already have been pushed.
  - emitRet
```
public void emitRet(Variable var)
```
    Emit a 'ret' instruction.
    
    Parameters:
    var - the variable containing the return address
  - emitThen
```
public final void emitThen()
```
  - emitIfThen
```
public final void emitIfThen()
```
  - emitElse
```
public final void emitElse()
```
    Compile start of else clause.
  - emitFi
```
public final void emitFi()
```
    Compile end of conditional.
  - emitAndThen
```
public void emitAndThen()
```
    Convenience for compiling if P1 && P2 then S1 else S2. Compile that as:
```
 compile P1, including an appropriate emitIfXxx
 emitAndThen()
 compile P2, including an appropriate emitIfXxx
 compile S1
 emitElse
 compile S2
 emitFi
 
```
  - fixUnsigned
```
public final void fixUnsigned(Type stackType)
```
  - emitConvert
```
public final void emitConvert(PrimType from,
               PrimType to)
```
  - castNeeded
```
public static boolean castNeeded(Type top,
                 Type required)
```
  - emitCheckcast
```
public void emitCheckcast(Type type)
```
  - emitInstanceof
```
public void emitInstanceof(Type type)
```
  - emitThrow
```
public final void emitThrow()
```
  - emitMonitorEnter
```
public final void emitMonitorEnter()
```
  - emitMonitorExit
```
public final void emitMonitorExit()
```
  - emitReturn
```
public final void emitReturn()
```
    Compile a method return. If inside a 'catch' clause, first call 'finally' clauses. The return value (unless the return type is void) must be on the stack, and have the correct type.
  - addHandler
```
public void addHandler(int start_pc,
              int end_pc,
              int handler_pc,
              int catch_type)
```
    Add an exception handler. Low-level routine; #emitCatchStart is preferred.
  - addHandler
```
public void addHandler(Label start_try,
              Label end_try,
              ClassType catch_type)
```
    Add an exception handler. Low-level routine; emitCatchStart(gnu.bytecode.Variable) is preferred.
  - emitWithCleanupStart
```
public void emitWithCleanupStart()
```
    Beginning of code that has a cleanup handler. This is similar to a try-finally, but the cleanup is only done in the case of an exception. Alternatively, the try clause has to manually do the cleanup with code duplication. Equivalent to: try body catch (Throwable ex) { cleanup; throw ex; } Call emitWithCleanupStart before the body.
  - emitWithCleanupCatch
```
public void emitWithCleanupCatch(Variable catchVar)
```
    Called after a body that has a cleanup clause. Followed by the cleanup code.
  - emitWithCleanupDone
```
public void emitWithCleanupDone()
```
    Called after generating a cleanup handler.
  - emitTryStart
```
public void emitTryStart(boolean has_finally,
                Type result_type)
```
  - emitTryEnd
```
@Deprecated
public void emitTryEnd()
```
    Deprecated.
  - emitCatchStart
```
public void emitCatchStart(Variable var)
```
  - emitCatchStart
```
public void emitCatchStart(ClassType type)
```
  - emitCatchEnd
```
public void emitCatchEnd()
```
  - emitFinallyStart
```
public void emitFinallyStart()
```
  - emitFinallyEnd
```
public void emitFinallyEnd()
```
  - emitTryCatchEnd
```
public void emitTryCatchEnd()
```
  - getCurrentTry
```
public final TryState getCurrentTry()
```
  - isInTry
```
public final boolean isInTry()
```
  - startSwitch
```
public SwitchState startSwitch()
```
    Start a new switch statment or expression. The switch value must have been calculated and left on the stack.
  - emitTailCall
```
public void emitTailCall(boolean pop_args,
                Label start)
```
    Compile a tail-call to position 0 of the current procedure.
    
    Parameters:
    pop_args - if true, copy argument registers (except this) from stack.
    start - the Label to jump back to.
  - emitTailCall
```
public void emitTailCall(boolean pop_args,
                Scope scope)
```
    Compile a tail-call to position 0 of the current procedure.
    
    Parameters:
    pop_args - if true, copy argument registers (except this) from stack.
    scope - Scope whose start we jump back to.
  - processFixups
```
public void processFixups()
```
  - assignConstants
```
public void assignConstants(ClassType cl)
```
    Description copied from class: Attribute
    
    Add any needed constant pool entries for this Attribute. Overridden by sub-classes. Do any other cleanup needed before writing out a .class file.
    
    Overrides:
    
    assignConstants in class Attribute
  - getLength
```
public final int getLength()
```
    Description copied from class: Attribute
    
    Return the length of the attribute in bytes. Does not include the 6-byte header (for the name_index and the length).
    
    Specified by:
    
    getLength in class Attribute
  - write
```
public void write(java.io.DataOutputStream dstr)
           throws java.io.IOException
```
    Description copied from class: Attribute
    
    Write out the contents of the Attribute. Does not write the 6-byte attribute header.
    
    Specified by:
    
    write in class Attribute
    
    Throws:
    
    java.io.IOException
  - print
```
public void print(ClassTypeWriter dst)
```
    Overrides:
    
    print in class Attribute
  - disAssemble
```
public void disAssemble(ClassTypeWriter dst,
               int start,
               int limit)
```
  - beginFragment
```
public int beginFragment(Label after)
```
  - beginFragment
```
public int beginFragment(Label start,
                Label after)
```
  - endFragment
```
public void endFragment(int cookie)
```
    End a fragment.
    
    Parameters:
    cookie - the return value from the previous beginFragment.

Class CodeAttr

Field Summary

Constructor Summary

Method Summary

Methods inherited from class gnu.bytecode.Attribute

Methods inherited from class java.lang.Object

Field Detail

locals

stackMap

GENERATE_STACK_MAP_TABLE

DONT_USE_JSR

stack_types

instructionLineMode

Constructor Detail

CodeAttr

Method Detail

getAttributes

setAttributes

fixupChain

fixupAdd

getMethod

getPC

getSP

getConstants

reachableHere

setReachable

setUnreachable

getMaxStack

getMaxLocals

setMaxStack

setMaxLocals

getCode

setCode

setCodeLength

getCodeLength

reserve

put1

put2

put4

putIndex2

putLineNumber

putLineNumber

noteVarType

setTypes

setTypes

pushType

popType

topType

emitPop

getLabel

emitSwap

emitDup

emitDupX

emitDup

emitDup

emitDup

enterScope

pushScope

pushAutoPoppableScope

getCurrentScope

popScope

getArg

lookup

addLocal

addLocal

addParamLocals

emitPushConstant

emitPushConstant

emitPushInt

emitPushLong

emitPushFloat

emitPushDouble

calculateSplit

emitPushString

emitPushClass

emitPushMethodHandle

emitPushNull

emitPushNull

emitPushDefaultValue

emitStoreDefaultValue