# Uses of Interface
org.apache.bcel.generic.StackProducer

Packages that use StackProducer
Package
Description
org.apache.bcel.generic
Generic part of the Apache Byte Code Engineering Library (BCEL), classes to dynamically modify class objects and byte code instructions.
org.apache.bcel.verifier.structurals
A PassVerifier class mostly used internally by JustIce, yielding a control flow graph for public use as a nice side effect.

- ## Uses of StackProducer in org.apache.bcel.generic

  Subinterfaces of StackProducer in org.apache.bcel.generic
  Modifier and Type
  Interface
  Description
  `interface`
  `ConstantPushInstruction`
  Denotes a push instruction that produces a literal on the stack such as SIPUSH, BIPUSH, ICONST, etc.
  `interface`
  `PushInstruction`
  Denotes an unparameterized instruction to produce a value on top of the stack, such as ILOAD, LDC, SIPUSH, DUP, ICONST, etc.
  Classes in org.apache.bcel.generic that implement StackProducer
  Modifier and Type
  Class
  Description
  `class`
  `AALOAD`
  AALOAD - Load reference from array
  `class`
  `ACONST_NULL`
  ACONST_NULL - Push null reference
  `class`
  `ALOAD`
  ALOAD - Load reference from local variable
  `class`
  `ANEWARRAY`
  ANEWARRAY - Create new array of references
  `class`
  `ArithmeticInstruction`
  Super class for the family of arithmetic instructions.
  `class`
  `ARRAYLENGTH`
  ARRAYLENGTH - Get length of array
  `class`
  `BALOAD`
  BALOAD - Load byte or boolean from array
  `class`
  `BIPUSH`
  BIPUSH - Push byte on stack
  `class`
  `CALOAD`
  CALOAD - Load char from array
  `class`
  `CHECKCAST`
  CHECKCAST - Check whether object is of given type
  `class`
  `ConversionInstruction`
  Super class for the x2y family of instructions.
  `class`
  `D2F`
  D2F - Convert double to float
  `class`
  `D2I`
  D2I - Convert double to int
  `class`
  `D2L`
  D2L - Convert double to long
  `class`
  `DADD`
  DADD - Add doubles
  `class`
  `DALOAD`
  DALOAD - Load double from array
  `class`
  `DCMPG`
  DCMPG - Compare doubles: value1 > value2
  `class`
  `DCMPL`
  DCMPL - Compare doubles: value1 < value2
  `class`
  `DCONST`
  DCONST - Push 0.0 or 1.0, other values cause an exception
  `class`
  `DDIV`
  DDIV - Divide doubles
  `class`
  `DLOAD`
  DLOAD - Load double from local variable
  `class`
  `DMUL`
  DMUL - Multiply doubles
  `class`
  `DNEG`
  DNEG - Negate double
  `class`
  `DREM`
  DREM - Remainder of doubles
  `class`
  `DSUB`
  DSUB - Substract doubles
  `class`
  `DUP`
  DUP - Duplicate top operand stack word
  `class`
  `DUP2`
  DUP2 - Duplicate two top operand stack words
  `class`
  `F2D`
  F2D - Convert float to double
  `class`
  `F2I`
  F2I - Convert float to int
  `class`
  `F2L`
  F2L - Convert float to long
  `class`
  `FADD`
  FADD - Add floats
  `class`
  `FALOAD`
  FALOAD - Load float from array
  `class`
  `FCMPG`
  FCMPG - Compare floats: value1 > value2
  `class`
  `FCMPL`
  FCMPL - Compare floats: value1 < value2
  `class`
  `FCONST`
  FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
  `class`
  `FDIV`
  FDIV - Divide floats
  `class`
  `FLOAD`
  FLOAD - Load float from local variable
  `class`
  `FMUL`
  FMUL - Multiply floats
  `class`
  `FNEG`
  FNEG - Negate float
  `class`
  `FREM`
  FREM - Remainder of floats
  `class`
  `FSUB`
  FSUB - Substract floats
  `class`
  `GETFIELD`
  GETFIELD - Fetch field from object
  `class`
  `GETSTATIC`
  GETSTATIC - Fetch static field from class
  `class`
  `I2B`
  I2B - Convert int to byte
  `class`
  `I2C`
  I2C - Convert int to char
  `class`
  `I2D`
  I2D - Convert int to double
  `class`
  `I2F`
  I2F - Convert int to float
  `class`
  `I2L`
  I2L - Convert int to long
  `class`
  `I2S`
  I2S - Convert int to short
  `class`
  `IADD`
  IADD - Add ints
  `class`
  `IALOAD`
  IALOAD - Load int from array
  `class`
  `IAND`
  IAND - Bitwise AND int
  `class`
  `ICONST`
  ICONST - Push value between -1, ..., 5, other values cause an exception
  `class`
  `IDIV`
  IDIV - Divide ints
  `class`
  `ILOAD`
  ILOAD - Load int from local variable onto stack
  `class`
  `IMUL`
  IMUL - Multiply ints
  `class`
  `INEG`
  INEG - Negate int
  `class`
  `INSTANCEOF`
  INSTANCEOF - Determine if object is of given type
  `class`
  `INVOKEDYNAMIC`
  Class for INVOKEDYNAMIC.
  `class`
  `InvokeInstruction`
  Super class for the INVOKExxx family of instructions.
  `final class`
  `INVOKEINTERFACE`
  INVOKEINTERFACE - Invoke interface method
  `class`
  `INVOKESPECIAL`
  INVOKESPECIAL - Invoke instance method; special handling for superclass, private and instance initialization method invocations
  `class`
  `INVOKESTATIC`
  INVOKESTATIC - Invoke a class (static) method
  `class`
  `INVOKEVIRTUAL`
  INVOKEVIRTUAL - Invoke instance method; dispatch based on class
  `class`
  `IOR`
  IOR - Bitwise OR int
  `class`
  `IREM`
  IREM - Remainder of int
  `class`
  `ISHL`
  ISHL - Arithmetic shift left int
  `class`
  `ISHR`
  ISHR - Arithmetic shift right int
  `class`
  `ISUB`
  ISUB - Substract ints
  `class`
  `IUSHR`
  IUSHR - Logical shift right int
  `class`
  `IXOR`
  IXOR - Bitwise XOR int
  `class`
  `JSR`
  JSR - Jump to subroutine
  `class`
  `JSR_W`
  JSR_W - Jump to subroutine
  `class`
  `JsrInstruction`
  Super class for JSR - Jump to subroutine
  `class`
  `L2D`
  L2D - Convert long to double
  `class`
  `L2F`
  L2F - Convert long to float
  `class`
  `L2I`
  L2I - Convert long to int
  `class`
  `LADD`
  LADD - Add longs
  `class`
  `LALOAD`
  LALOAD - Load long from array
  `class`
  `LAND`
  LAND - Bitwise AND longs
  `class`
  `LCMP`
  LCMP - Compare longs:
  `class`
  `LCONST`
  LCONST - Push 0 or 1, other values cause an exception
  `class`
  `LDC`
  LDC - Push item from constant pool.
  `class`
  `LDC_W`
  LDC_W - Push item from constant pool (wide index)
  `class`
  `LDC2_W`
  LDC2_W - Push long or double from constant pool
  `class`
  `LDIV`
  LDIV - Divide longs
  `class`
  `LLOAD`
  LLOAD - Load long from local variable
  `class`
  `LMUL`
  LMUL - Multiply longs
  `class`
  `LNEG`
  LNEG - Negate long
  `class`
  `LoadInstruction`
  Denotes an unparameterized instruction to load a value from a local variable, for example ILOAD.
  `class`
  `LOOKUPSWITCH`
  LOOKUPSWITCH - Switch with unordered set of values
  `class`
  `LOR`
  LOR - Bitwise OR long
  `class`
  `LREM`
  LREM - Remainder of long
  `class`
  `LSHL`
  LSHL - Arithmetic shift left long
  `class`
  `LSHR`
  LSHR - Arithmetic shift right long
  `class`
  `LSUB`
  LSUB - Substract longs
  `class`
  `LUSHR`
  LUSHR - Logical shift right long
  `class`
  `LXOR`
  LXOR - Bitwise XOR long
  `class`
  `NEW`
  NEW - Create new object
  `class`
  `NEWARRAY`
  NEWARRAY - Create new array of basic type (int, short, ...)
  `class`
  `SALOAD`
  SALOAD - Load short from array
  `class`
  `Select`
  Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
  `class`
  `SIPUSH`
  SIPUSH - Push short
  `class`
  `SWAP`
  SWAP - Swa top operand stack word
  `class`
  `TABLESWITCH`
  TABLESWITCH - Switch within given range of values, i.e., low..high
  Methods in org.apache.bcel.generic with parameters of type StackProducer
  Modifier and Type
  Method
  Description
  `void`
  EmptyVisitor.`visitStackProducer(StackProducer obj)`
  `void`
  Visitor.`visitStackProducer(StackProducer obj)`

- ## Uses of StackProducer in org.apache.bcel.verifier.structurals

  Methods in org.apache.bcel.verifier.structurals with parameters of type StackProducer
  Modifier and Type
  Method
  Description
  `void`
  InstConstraintVisitor.`visitStackProducer(StackProducer o)`
  Ensures the general preconditions of a StackProducer instance.