Uses of Class
org.jikesrvm.compilers.opt.ir.operand.Operand

Packages that use Operand

Package	Description
org.jikesrvm.adaptive.measurements.instrumentation
org.jikesrvm.compilers.opt
org.jikesrvm.compilers.opt.bc2ir	Provides classes that implement the transformation from bytecode to the high-level intermediate representation (HIR).
org.jikesrvm.compilers.opt.controlflow
org.jikesrvm.compilers.opt.depgraph	Provides classes that implement a dependence graph.
org.jikesrvm.compilers.opt.escape
org.jikesrvm.compilers.opt.hir2lir
org.jikesrvm.compilers.opt.ir
org.jikesrvm.compilers.opt.ir.ia32
org.jikesrvm.compilers.opt.ir.operand
org.jikesrvm.compilers.opt.ir.operand.ia32
org.jikesrvm.compilers.opt.ir.ppc
org.jikesrvm.compilers.opt.lir2mir	Provides classes that implement the transition from low-level IR to machine-specific IR.
org.jikesrvm.compilers.opt.lir2mir.ia32	Provides classes that implement the IA32-specific parts of the transition from low-level IR to machine-specific IR.
org.jikesrvm.compilers.opt.mir2mc.ia32
org.jikesrvm.compilers.opt.regalloc.ia32
org.jikesrvm.compilers.opt.ssa	SSA implementation (disabled because of bugs, see entry in issue tracker).
org.jikesrvm.osr

Uses of Operand in org.jikesrvm.adaptive.measurements.instrumentation

Methods in org.jikesrvm.adaptive.measurements.instrumentation with parameters of type Operand

Modifier and Type	Method and Description
(package private) static RegisterOperand	CounterArrayManager.InsertALoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, int offset) Insert array load off before s in the instruction stream.

Uses of Operand in org.jikesrvm.compilers.opt

Fields in org.jikesrvm.compilers.opt declared as Operand

Modifier and Type	Field and Description
(package private) Operand[]	LocalCSE.AvailableExpression.ops operands

Methods in org.jikesrvm.compilers.opt that return Operand

Modifier and Type	Method and Description
(package private) static Operand	Simple.equivalentValforPHI(Instruction phi) Try to find an operand that is equivalent to the result of a given phi instruction.

Methods in org.jikesrvm.compilers.opt with parameters of type Operand

Modifier and Type	Method and Description
private boolean	NullCheckCombining.canFold(Instruction s, Operand activeGuard, boolean isStore)
private static Address	Simplifier.getAddressValue(Operand op) Turns the given operand encoding an address constant into an Address.
private static Address	ExpressionFolding.getAddressValue(Operand op)
private static double	ExpressionFolding.getDoubleValue(Operand op)
private static float	ExpressionFolding.getFloatValue(Operand op)
private static int	ExpressionFolding.getIntValue(Operand op)
private static long	ExpressionFolding.getLongValue(Operand op)
private static Simplifier.DefUseEffect	Simplifier.multiplyByConstant(AbstractRegisterPool regpool, Instruction s, Operand op1, Operand op2, OptOptions opts)

Constructors in org.jikesrvm.compilers.opt with parameters of type Operand

Constructor and Description
AvailableExpression(Instruction i, Operator op, Operand[] ops, LocationOperand loc, Register t)

Uses of Operand in org.jikesrvm.compilers.opt.bc2ir

Subclasses of Operand in org.jikesrvm.compilers.opt.bc2ir

Modifier and Type	Class and Description
private static class	BC2IR.DummyStackSlot Dummy stack slot
class	ReturnAddressOperand ReturnAddress operand.

Fields in org.jikesrvm.compilers.opt.bc2ir declared as Operand

Modifier and Type	Field and Description
private Operand[]	BC2IR._localState Current state of local variables.
private Operand[]	GenerationContext.arguments The parameters which BC2IR should use to seed the local state for the entry basic block.
private Operand	BC2IR.currentGuard
(package private) Operand[]	BasicBlockLE.localState State of the local variables at the start of this basic block.
private Operand	GenerationContext.result Used to communicate the meet of the return values back to the caller Mainly useful when BC2IR is doing inlining....allows the caller BC2IR object to exploit knowledge the callee BC2IR object had about the result.
private Operand[]	OperandStack.stack

Methods in org.jikesrvm.compilers.opt.bc2ir that return Operand

Modifier and Type	Method and Description
private Operand	BC2IR._loadLocalForOSR(Operand op) make a temporary register, and create a move instruction
private Operand	BC2IR._prepareDoubleConstant(Operand op) special process for long/double constants
private Operand	BC2IR._prepareLongConstant(Operand op) special process for long/double constants
Operand	BC2IR.DummyStackSlot.copy()
Operand	ReturnAddressOperand.copy()
static Operand	BC2IR.copyGuardFromOperand(Operand op)
(package private) Operand[]	BasicBlockLE.copyLocalState()
(package private) Operand[]	GenerationContext.getArguments()
Operand	BC2IR.getConstantOperand(int index) Fetch the value of the next operand, a constant, from the bytecode stream.
Operand	BC2IR.getCurrentGuard()
(package private) Operand	OperandStack.getFromBottom(int pos)
(package private) Operand	OperandStack.getFromTop(int n)
private Operand	BC2IR.getLocal(int i) Gets the specified local variable.
private Operand	BC2IR.getLocalDual(int i) Gets the specified local variable (long, double).
private Operand	GenerationContext.getLockObject() Get the object for locking for synchronized methods.
Operand	GenerationContext.getResult()
(package private) Operand	OperandStack.pop()
(package private) Operand	BC2IR.pop() Pops an operand from the stack.
(package private) Operand	BC2IR.pop(TypeReference type) Pops an operand of the given type from the stack.
Operand	BC2IR.popAddress() Pops an address operand from the stack.
(package private) Operand	BC2IR.popDouble() Pops a double operand from the stack.
(package private) Operand	BC2IR.popFloat() Pops a float operand from the stack.
Operand	BC2IR.popInt() Pops an int operand from the stack.
(package private) Operand	BC2IR.popLong() Pops a long operand from the stack.
Operand	BC2IR.popRef() Pops a ref operand from the stack.
private Operand	BC2IR.popShiftInt(boolean longShift) Pop an int from the stack to be used in a shift.

Methods in org.jikesrvm.compilers.opt.bc2ir with parameters of type Operand

Modifier and Type	Method and Description
Instruction	BC2IR._aloadHelper(Operator operator, Operand ref, Operand index, TypeReference type)
private Instruction	BC2IR._binaryDualHelper(Operator operator, Operand op1, Operand op2, TypeReference type)
Instruction	BC2IR._binaryHelper(Operator operator, Operand op1, Operand op2, TypeReference type)
private static Instruction	GenerateMagic._cmpHelper(BC2IR bc2ir, GenerationContext gc, ConditionOperand cond, Operand given_o2)
private BasicBlockLE	BBSet._createBBLE(int bcIndex, Operand[] simLocals, BasicBlockLE parent, boolean left) Allocate a new BBLE at the given bcIndex.
private Instruction	BC2IR._guardedBinaryDualHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)
private Instruction	BC2IR._guardedBinaryHelper(Operator operator, Operand op1, Operand op2, Operand guard, TypeReference type)
private Operand	BC2IR._loadLocalForOSR(Operand op) make a temporary register, and create a move instruction
private Instruction	BC2IR._moveDualHelper(Operator operator, Operand val, TypeReference type)
(package private) Instruction	BC2IR._moveHelper(Operator operator, Operand val, TypeReference type)
private Operand	BC2IR._prepareDoubleConstant(Operand op) special process for long/double constants
private Operand	BC2IR._prepareLongConstant(Operand op) special process for long/double constants
private void	BC2IR._returnHelper(Operator operator, Operand val)
(package private) Instruction	BC2IR._unaryDualHelper(Operator operator, Operand val, TypeReference type)
(package private) Instruction	BC2IR._unaryHelper(Operator operator, Operand val, TypeReference type)
void	BC2IR.assertIsType(Operand op, TypeReference type) Assert that the given operand is of the given type, or of a subclass of the given type.
private BasicBlockLE	BBSet.condCreateAndInit(BasicBlockLE x, boolean shouldCreate, int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals, boolean left) Conditionally create a block at the specified target as a child of x.
static Operand	BC2IR.copyGuardFromOperand(Operand op)
(package private) void	BasicBlockLE.copyIntoLocalState(Operand[] _localState) Save a shallow copy of the given local variable state into this.
boolean	BC2IR.do_BoundsCheck(Operand ref, Operand index) Generates a boundscheck instruction for the given operand and index.
private boolean	BC2IR.do_CheckStore(Operand ref, Operand elem, TypeReference elemType) Generate a storecheck for the given array and elem
private boolean	BC2IR.do_IntZeroCheck(Operand div) Generates a check for 0 for the given operand
private boolean	BC2IR.do_LongZeroCheck(Operand div) Generates a checks for 0 for the given operand
boolean	BC2IR.do_NullCheck(Operand ref) Generates a null-check instruction for the given operand.
private Instruction	BC2IR.do_store(int index, Operand op1) Simulates a store into a given local variable of an int/long/double/float
TypeReference	BC2IR.getArrayTypeOf(Operand op) Returns the data type of the given operand, assuming that the operand is an array reference.
private BasicBlockLE	BBSet.getOrCreateBlock(BasicBlockLE x, boolean shouldCreate, int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals) Get or create a block at the specified target.
(package private) BasicBlockLE	BBSet.getOrCreateBlock(int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals) Get or create a block at the specified target.
private BasicBlockLE	BC2IR.getOrCreateBlock(int target, BasicBlockLE from, OperandStack simStack, Operand[] simLocals) Get or create a block at the specified target.
private TypeReference	BC2IR.getRefTypeOf(Operand op) Returns the data type of the given operand, assuming that the operand is a reference.
private void	BBSet.initializeExceptionHandlers(BasicBlockLE bble, Operand[] simLocals) Initialize bble's handlers array based on startPCs/endPCs.
private void	BBSet.injectMove(BasicBlock block, RegisterOperand res, Operand val)
(package private) boolean	GenerationContext.isLocal(Operand op, int i, TypeReference type) Is the operand a particular bytecode local?
static boolean	BC2IR.isNonNull(Operand op)
private static LocationOperand	GenerateMagic.mapToMetadata(Operand metadata)
private boolean	BBSet.matchingJSRcontext(OperandStack simStack, Operand[] simLocals, BasicBlockLE candBBLE) We specialize basic blocks with respect to the return addresses they have on their expression stack and/or in their local variables on entry to the block.
(package private) void	OperandStack.push(Operand val)
void	BC2IR.push(Operand r) Push a single width operand (int, float, ref, ...) on the simulated stack.
(package private) void	BC2IR.push(Operand r, TypeReference type) Push an operand of the specified type on the simulated stack.
private Instruction	BC2IR.pushCopy(Operand op1) Pushes a copy of the given operand onto simulated stack.
(package private) void	BC2IR.pushDual(Operand r) Push a double width operand (long, double) on the simulated stack.
(package private) void	BBSet.rectifyLocals(Operand[] localState, BasicBlockLE p) Rectify the given local variable state with the local variable state stored in the given BBLE.
(package private) void	OperandStack.replaceFromTop(int n, Operand op)
private void	BC2IR.setCurrentGuard(Operand guard)
static void	BC2IR.setGuardForRegOp(RegisterOperand rop, Operand guard)
private void	BC2IR.setLocal(int i, Operand op) Set the specified local variable
private void	BC2IR.setLocalDual(int i, Operand op) Set the specified local variable
void	GenerationContext.setResult(Operand result)
boolean	BC2IR.DummyStackSlot.similar(Operand op)
boolean	ReturnAddressOperand.similar(Operand op)

Constructors in org.jikesrvm.compilers.opt.bc2ir with parameters of type Operand

Constructor and Description
BBSet(GenerationContext gc, BytecodeStream bcodes, Operand[] localState) Initialize the BBSet to handle basic block generation for the argument generation context and bytecode info.

Uses of Operand in org.jikesrvm.compilers.opt.controlflow

Fields in org.jikesrvm.compilers.opt.controlflow declared as Operand

Modifier and Type	Field and Description
private Operand	AnnotatedLSTNode.carriedLoopIterator The iterator that is used to loop within the exit block
Operand	AnnotatedLSTNode.initialIteratorValue The the initial iterator that comes into the phi node in the header
private Operand	AnnotatedLSTNode.phiLoopIterator The the phi iterator that gets modified by the stride to produce the carried iterator
Operand	AnnotatedLSTNode.strideValue The stride operand to the iterator instruction
Operand	AnnotatedLSTNode.terminalIteratorValue The value that ends the loop
private Operand	LoopUnrolling.RealDefs.use

Methods in org.jikesrvm.compilers.opt.controlflow that return Operand

Modifier and Type	Method and Description
private Operand	LoopUnrolling._follow(Operand use)
private Operand	LoopUnrolling.follow(Operand use)
static Operand	AnnotatedLSTNode.follow(Operand use) Follow the operand's definition filtering out moves This code is taken and modified from an old LoopUnrolling
Operand	AnnotatedLSTNode.generateLoopInvariantOperand(BasicBlock block, Operand op) Loop invariants may not be accessible before a loop, so generate the instructions so they are
Operand	AnnotatedLSTNode.getCarriedLoopIterator() Get the carried loop iterator
Operand	LoopUnrolling.RealDefs.nextClear()
Operand	LoopUnrolling.RealDefs.nextElement()

Methods in org.jikesrvm.compilers.opt.controlflow with parameters of type Operand

Modifier and Type	Method and Description
private Operand	LoopUnrolling._follow(Operand use)
private void	LoopUnrolling._printDefs(Operand op)
private void	BranchOptimizations.booleanCompareHelper(Instruction cb, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond) Generate a boolean operation opcode 1) IF br !
private static Instruction	LoopUnrolling.definingInstruction(Operand op)
static Instruction	AnnotatedLSTNode.definingInstruction(Operand op) Find the instruction that defines an operand.
private Operand	LoopUnrolling.follow(Operand use)
static Operand	AnnotatedLSTNode.follow(Operand use) Follow the operand's definition filtering out moves This code is taken and modified from an old LoopUnrolling
Operand	AnnotatedLSTNode.generateLoopInvariantOperand(BasicBlock block, Operand op) Loop invariants may not be accessible before a loop, so generate the instructions so they are
int	AnnotatedLSTNode.getFixedDistanceFromPhiIterator(Operand op) Get fixed distance from the phi iterator
private void	LoopUnrolling.RealDefs.init(Operand use)
boolean	AnnotatedLSTNode.isCarriedLoopIterator(Operand op) Is this operand related to the carried iterator of this loop?
(package private) static boolean	AnnotatedLSTNode.isConstant(Operand op) Test whether the operand is constant
(package private) boolean	AnnotatedLSTNode.isFixedDistanceFromPhiIterator(Operand op) Is this operand a fixed distance from the phi iterator?
boolean	AnnotatedLSTNode.isInvariant(Operand op) Is this value modified by the loop?
private static boolean	AnnotatedLSTNode.isLoopInvariant(Operand op, BitVector loop, BasicBlock header) Test whether operand value will be invariant in a loop by tracing back earlier definitions.
boolean	AnnotatedLSTNode.isPhiLoopIterator(Operand op) Is this operand related to the phi iterator of this loop?
boolean	AnnotatedLSTNode.isRelatedToIterator(Operand op) Is this operand related to the iterator of this loop?
private static boolean	LoopUnrolling.loopInvariant(Operand op, BitVector nloop, int depth)
private static boolean	LoopUnrolling.printDefs(Operand op, BitVector nloop, int depth)

Constructors in org.jikesrvm.compilers.opt.controlflow with parameters of type Operand

Constructor and Description
RealDefs(Operand use)
RealDefs(Operand use, int visit)

Uses of Operand in org.jikesrvm.compilers.opt.depgraph

Methods in org.jikesrvm.compilers.opt.depgraph with parameters of type Operand

Modifier and Type	Method and Description
private void	DepGraph.computeBackwardDependencesDef(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode) Compute backward dependences from a given def to a given node.
private void	DepGraph.computeBackwardDependencesUse(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode) Compute backward dependences from a given use to a given node.
private void	DepGraph.computeForwardDependencesDef(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode) Compute forward dependences from a given def to a given node.
private void	DepGraph.computeForwardDependencesUse(Operand op, DepGraphNode destNode, DepGraphNode lastExceptionNode) Compute forward dependences from a given use to a given node.
static DepGraphEdge	DepGraphEdge.findInputEdge(DepGraphNode n, Operand op) Return the input edge for a given node that corresponds to a given operand.

Uses of Operand in org.jikesrvm.compilers.opt.escape

Methods in org.jikesrvm.compilers.opt.escape that return types with arguments of type Operand

Modifier and Type	Method and Description
private static Iterator<Operand>	SimpleEscape.iterateReturnValues(IR ir) TODO: Move this utility elsewhere

Methods in org.jikesrvm.compilers.opt.escape with parameters of type Operand

Modifier and Type	Method and Description
private static int	SimpleEscape.getParameterIndex(Operand op, Instruction s) Which parameter to a call instruction corresponds to op?

Uses of Operand in org.jikesrvm.compilers.opt.hir2lir

Methods in org.jikesrvm.compilers.opt.hir2lir that return Operand

Modifier and Type	Method and Description
(package private) static Operand	ConvertToLowLevelIR.getTIB(Instruction s, IR ir, Operand obj, Operand guard)
(package private) static Operand	ConvertToLowLevelIR.getTIB(Instruction s, IR ir, RVMType type)
(package private) static Operand	ConvertToLowLevelIR.getTIB(Instruction s, IR ir, TypeOperand type)

Methods in org.jikesrvm.compilers.opt.hir2lir with parameters of type Operand

Modifier and Type	Method and Description
private static Instruction	DynamicTypeCheckExpansion.convertToBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result) Generate wrapper around branching type check to get a value producing type check.
private static Instruction	DynamicTypeCheckExpansion.generateBranchingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, BasicBlock trueBlock, BasicBlock falseBlock, RegisterOperand oldGuard, BranchProfileOperand falseProb) Generate a branching dynamic type check.
private static Instruction	DynamicTypeCheckExpansion.generateValueProducingTypeCheck(Instruction s, IR ir, Operand RHSobj, TypeReference LHStype, Operand RHStib, RegisterOperand result) Generate a value-producing dynamic type check.
(package private) static RegisterOperand	ConvertToLowLevelIR.getField(Instruction s, IR ir, RegisterOperand obj, RVMField field, Operand guard)
(package private) static RegisterOperand	ConvertToLowLevelIR.getInstanceMethod(Instruction s, IR ir, Operand tib, RVMMethod method)
(package private) static Operand	ConvertToLowLevelIR.getTIB(Instruction s, IR ir, Operand obj, Operand guard)
static RegisterOperand	ConvertToLowLevelIR.insertBinary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand o2) Insert a binary instruction before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertGuardedUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1, Operand guard) Insert a guarded unary instruction before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset) Insert a load off before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, LocationOperand loc, Operand guard) Insert a load off before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Offset offset, Operand guard) Insert a load off before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertLoadOffset(Instruction s, IR ir, Operator operator, TypeReference type, Operand reg2, Operand offset, LocationOperand loc, Operand guard) Insert a load off before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertLoadOffsetJTOC(Instruction s, IR ir, Operator operator, TypeReference type, Operand offset) Insert a load off the JTOC before s in the instruction stream.
(package private) static RegisterOperand	ConvertToLowLevelIR.InsertUnary(Instruction s, IR ir, Operator operator, TypeReference type, Operand o1) Insert a unary instruction before s in the instruction stream.

Uses of Operand in org.jikesrvm.compilers.opt.ir

Fields in org.jikesrvm.compilers.opt.ir declared as Operand

Modifier and Type	Field and Description
private Operand	Instruction.OE.deferredMOReg
protected Operand	Instruction.BASE_OE.nextElem
private Operand[]	Instruction.ops The operands of this instruction.

Fields in org.jikesrvm.compilers.opt.ir with type parameters of type Operand

Modifier and Type	Field and Description
private Enumeration<Operand>	IREnumeration.AllDefsEnum.instructionOperands Enumeration of non-heap operands defined by the instruction
private Enumeration<Operand>	IREnumeration.AllUsesEnum.instructionOperands Enumeration of non-heap operands defined by the instruction

Methods in org.jikesrvm.compilers.opt.ir that return Operand

Modifier and Type	Method and Description
static Operand	Prepare.getAddress(Instruction i) Get the operand called Address from the argument instruction.
static Operand	Attempt.getAddress(Instruction i) Get the operand called Address from the argument instruction.
static Operand	Store.getAddress(Instruction i) Get the operand called Address from the argument instruction.
static Operand	Load.getAddress(Instruction i) Get the operand called Address from the argument instruction.
static Operand	Call.getAddress(Instruction i) Get the operand called Address from the argument instruction.
static Operand	ALoad.getArray(Instruction i) Get the operand called Array from the argument instruction.
static Operand	AStore.getArray(Instruction i) Get the operand called Array from the argument instruction.
static Operand	Prepare.getClearAddress(Instruction i) Get the operand called Address from the argument instruction clearing its instruction pointer.
static Operand	Attempt.getClearAddress(Instruction i) Get the operand called Address from the argument instruction clearing its instruction pointer.
static Operand	Store.getClearAddress(Instruction i) Get the operand called Address from the argument instruction clearing its instruction pointer.
static Operand	Load.getClearAddress(Instruction i) Get the operand called Address from the argument instruction clearing its instruction pointer.
static Operand	Call.getClearAddress(Instruction i) Get the operand called Address from the argument instruction clearing its instruction pointer.
static Operand	ALoad.getClearArray(Instruction i) Get the operand called Array from the argument instruction clearing its instruction pointer.
static Operand	AStore.getClearArray(Instruction i) Get the operand called Array from the argument instruction clearing its instruction pointer.
static Operand	Multianewarray.getClearDimension(Instruction i, int k) Get the k'th operand called Dimension from the argument instruction clearing its instruction pointer.
static Operand	OsrBarrier.getClearElement(Instruction i, int k) Get the k'th operand called Element from the argument instruction clearing its instruction pointer.
static Operand	OsrPoint.getClearElement(Instruction i, int k) Get the k'th operand called Element from the argument instruction clearing its instruction pointer.
static Operand	CondMove.getClearFalseValue(Instruction i) Get the operand called FalseValue from the argument instruction clearing its instruction pointer.
static Operand	InlineGuard.getClearGoal(Instruction i) Get the operand called Goal from the argument instruction clearing its instruction pointer.
static Operand	GuardedSet.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	Prepare.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	ALoad.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	StoreCheck.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	Attempt.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	GuardedBinary.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	Store.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	InstanceOf.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	GuardCarrier.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	MonitorOp.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	PutField.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	Load.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	TypeCheck.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	BoundsCheck.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	InlineGuard.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	Call.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	AStore.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	GuardedUnary.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	GetField.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	InstrumentedCounter.getClearIncrement(Instruction i) Get the operand called Increment from the argument instruction clearing its instruction pointer.
static Operand	ALoad.getClearIndex(Instruction i) Get the operand called Index from the argument instruction clearing its instruction pointer.
static Operand	BoundsCheck.getClearIndex(Instruction i) Get the operand called Index from the argument instruction clearing its instruction pointer.
static Operand	AStore.getClearIndex(Instruction i) Get the operand called Index from the argument instruction clearing its instruction pointer.
static Operand	Attempt.getClearNewValue(Instruction i) Get the operand called NewValue from the argument instruction clearing its instruction pointer.
static Operand	PutStatic.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	Prepare.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	Attempt.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	Store.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	PutField.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	Load.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	GetField.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	GetStatic.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	Attempt.getClearOldValue(Instruction i) Get the operand called OldValue from the argument instruction clearing its instruction pointer.
Operand	Instruction.getClearOperand(int i) NOTE: It is incorrect to use getClearOperand with a constant argument outside of the automatically generated code in Operators.
static Operand	Call.getClearParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction clearing its instruction pointer.
static Operand	GuardedSet.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	CacheOp.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	StoreCheck.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	InstanceOf.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	MonitorOp.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	PutField.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	TypeCheck.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	NullCheck.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	BoundsCheck.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	GetField.getClearRef(Instruction i) Get the operand called Ref from the argument instruction clearing its instruction pointer.
static Operand	Phi.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	NewArray.getClearSize(Instruction i) Get the operand called Size from the argument instruction clearing its instruction pointer.
static Operand	CondMove.getClearTrueValue(Instruction i) Get the operand called TrueValue from the argument instruction clearing its instruction pointer.
static Operand	TableSwitch.getClearUnknown1(Instruction i) Get the operand called Unknown1 from the argument instruction clearing its instruction pointer.
static Operand	LookupSwitch.getClearUnknown1(Instruction i) Get the operand called Unknown1 from the argument instruction clearing its instruction pointer.
static Operand	TableSwitch.getClearUnknown2(Instruction i) Get the operand called Unknown2 from the argument instruction clearing its instruction pointer.
static Operand	LookupSwitch.getClearUnknown2(Instruction i) Get the operand called Unknown2 from the argument instruction clearing its instruction pointer.
static Operand	GuardedSet.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	StoreCheck.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	Unary.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	Return.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	GuardedUnary.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	Move.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	TrapIf.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	Binary.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	GuardedBinary.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	CondMove.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	IfCmp2.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	BooleanCmp.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	IfCmp.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	TrapIf.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	Binary.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	GuardedBinary.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	CondMove.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	IfCmp2.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	BooleanCmp.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	IfCmp.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	PutStatic.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	Store.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	PutField.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	ZeroCheck.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	Athrow.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	InlineGuard.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	TableSwitch.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	AStore.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	LookupSwitch.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	Phi.getClearValue(Instruction i, int k) Get the k'th operand called Value from the argument instruction clearing its instruction pointer.
static Operand	IRTools.getDefaultOperand(TypeReference type) Returns a constant operand with a default value for a given type
static Operand	Multianewarray.getDimension(Instruction i, int k) Get the k'th operand called Dimension from the argument instruction.
static Operand	OsrBarrier.getElement(Instruction i, int k) Get the k'th operand called Element from the argument instruction.
static Operand	OsrPoint.getElement(Instruction i, int k) Get the k'th operand called Element from the argument instruction.
static Operand	CondMove.getFalseValue(Instruction i) Get the operand called FalseValue from the argument instruction.
static Operand	InlineGuard.getGoal(Instruction i) Get the operand called Goal from the argument instruction.
static Operand	GuardedSet.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	Prepare.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	ALoad.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	StoreCheck.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	Attempt.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	GuardedBinary.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	Store.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	InstanceOf.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	GuardCarrier.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	MonitorOp.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	PutField.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	Load.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	TypeCheck.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	BoundsCheck.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	InlineGuard.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	Call.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	AStore.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	GuardedUnary.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	GetField.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	InstrumentedCounter.getIncrement(Instruction i) Get the operand called Increment from the argument instruction.
static Operand	ALoad.getIndex(Instruction i) Get the operand called Index from the argument instruction.
static Operand	BoundsCheck.getIndex(Instruction i) Get the operand called Index from the argument instruction.
static Operand	AStore.getIndex(Instruction i) Get the operand called Index from the argument instruction.
static Operand	Attempt.getNewValue(Instruction i) Get the operand called NewValue from the argument instruction.
static Operand	PutStatic.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	Prepare.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	Attempt.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	Store.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	PutField.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	Load.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	GetField.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	GetStatic.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	Attempt.getOldValue(Instruction i) Get the operand called OldValue from the argument instruction.
Operand	Instruction.getOperand(int i) NOTE: It is incorrect to use getOperand with a constant argument outside of the automatically generated code in Operators.
static Operand	Call.getParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction.
static Operand	GuardedSet.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	CacheOp.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	StoreCheck.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	InstanceOf.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	MonitorOp.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	PutField.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	TypeCheck.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	NullCheck.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	BoundsCheck.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	GetField.getRef(Instruction i) Get the operand called Ref from the argument instruction.
static Operand	Phi.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	NewArray.getSize(Instruction i) Get the operand called Size from the argument instruction.
static Operand	CondMove.getTrueValue(Instruction i) Get the operand called TrueValue from the argument instruction.
static Operand	TableSwitch.getUnknown1(Instruction i) Get the operand called Unknown1 from the argument instruction.
static Operand	LookupSwitch.getUnknown1(Instruction i) Get the operand called Unknown1 from the argument instruction.
static Operand	TableSwitch.getUnknown2(Instruction i) Get the operand called Unknown2 from the argument instruction.
static Operand	LookupSwitch.getUnknown2(Instruction i) Get the operand called Unknown2 from the argument instruction.
static Operand	GuardedSet.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	StoreCheck.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	Unary.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	Return.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	GuardedUnary.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	Move.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	TrapIf.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	Binary.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	GuardedBinary.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	CondMove.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	IfCmp2.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	BooleanCmp.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	IfCmp.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	TrapIf.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	Binary.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	GuardedBinary.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	CondMove.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	IfCmp2.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	BooleanCmp.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	IfCmp.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	PutStatic.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	Store.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	PutField.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	ZeroCheck.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	Athrow.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	InlineGuard.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	TableSwitch.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	AStore.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	LookupSwitch.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	Phi.getValue(Instruction i, int k) Get the k'th operand called Value from the argument instruction.
abstract Operand	GenericRegisterPool.makeJTOCOp()
abstract Operand	GenericRegisterPool.makeTocOp()
Operand	IREnumeration.AllDefsEnum.nextElement()
Operand	IREnumeration.AllUsesEnum.nextElement()
Operand	Instruction.BASE_OE.nextElement()
static Operand	IRTools.offsetOperand(Offset o) Generates appropriately sized constant operand for a given Offset.
private Operand	Instruction.outOfLineCopy(Operand op)

Methods in org.jikesrvm.compilers.opt.ir that return types with arguments of type Operand

Modifier and Type	Method and Description
Enumeration<Operand>	Instruction.getDefs() Enumerate all defs (both pure defs and def/uses) of an instruction.
Enumeration<Operand>	Instruction.getDefUses() Enumerate all the def/uses of an instruction.
Enumeration<Operand>	Instruction.getMemoryOperands() Enumerate all memory operands of an instruction
Enumeration<Operand>	Instruction.getOperands() Enumerate all "leaf" operands of an instruction.
Enumeration<Operand>	IR.getParameters() Return an enumeration of the parameters to the IR Warning: Only valid before register allocation (see CallingConvention)
Enumeration<Operand>	Instruction.getPureDefs() Enumerate all the pure defs (ie not including def/uses) of an instruction.
Enumeration<Operand>	Instruction.getPureUses() Enumerate all the pure uses (ie not including def/uses) of an instruction.
Enumeration<Operand>	Instruction.getRootOperands() Enumerate all the root operands of an instruction (DOES NOT ENUMERATE CONTAINED OPERANDS OF MEMORY OPERANDS).
Enumeration<Operand>	Instruction.getRootUses() Enumerate all root uses of an instruction.
Enumeration<Operand>	Instruction.getUses() Enumerate all uses of an instruction (includes def/use).

Methods in org.jikesrvm.compilers.opt.ir with parameters of type Operand

Modifier and Type	Method and Description
static Instruction	InstrumentedCounter.create(Operator o, IntConstantOperand Data, IntConstantOperand Index, Operand Increment) Create an instruction of the InstrumentedCounter instruction format.
static Instruction	CacheOp.create(Operator o, Operand Ref) Create an instruction of the CacheOp instruction format.
static Instruction	Return.create(Operator o, Operand Val) Create an instruction of the Return instruction format.
static Instruction	Athrow.create(Operator o, Operand Value) Create an instruction of the Athrow instruction format.
static Instruction	Phi.create(Operator o, Operand Result, int numVarOps) Create an instruction of the Phi instruction format.
static Instruction	MonitorOp.create(Operator o, Operand Ref, Operand Guard) Create an instruction of the MonitorOp instruction format.
static Instruction	PutStatic.create(Operator o, Operand Value, Operand Offset, LocationOperand Location) Create an instruction of the PutStatic instruction format.
static Instruction	GuardedSet.create(Operator o, Operand Ref, Operand Val, Operand Guard) Create an instruction of the GuardedSet instruction format.
static Instruction	InlineGuard.create(Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile) Create an instruction of the InlineGuard instruction format.
static Instruction	LookupSwitch.create(Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps) Create an instruction of the LookupSwitch instruction format.
static Instruction	TableSwitch.create(Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps) Create an instruction of the TableSwitch instruction format.
static Instruction	Store.create(Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location) Create an instruction of the Store instruction format.
static Instruction	Store.create(Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the Store instruction format.
static Instruction	PutField.create(Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the PutField instruction format.
static Instruction	AStore.create(Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard) Create an instruction of the AStore instruction format.
static Instruction	Unary.create(Operator o, RegisterOperand Result, Operand Val) Create an instruction of the Unary instruction format.
static Instruction	NullCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref) Create an instruction of the NullCheck instruction format.
static Instruction	ZeroCheck.create(Operator o, RegisterOperand GuardResult, Operand Value) Create an instruction of the ZeroCheck instruction format.
static Instruction	Move.create(Operator o, RegisterOperand Result, Operand Val) Create an instruction of the Move instruction format.
static Instruction	GetStatic.create(Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location) Create an instruction of the GetStatic instruction format.
static Instruction	Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps) Create an instruction of the Call instruction format.
static Instruction	Call.create(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps) Create an instruction of the Call instruction format.
static Instruction	Binary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2) Create an instruction of the Binary instruction format.
static Instruction	GuardedUnary.create(Operator o, RegisterOperand Result, Operand Val, Operand Guard) Create an instruction of the GuardedUnary instruction format.
static Instruction	IfCmp.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile) Create an instruction of the IfCmp instruction format.
static Instruction	IfCmp2.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2) Create an instruction of the IfCmp2 instruction format.
static Instruction	BooleanCmp.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile) Create an instruction of the BooleanCmp instruction format.
static Instruction	CondMove.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue) Create an instruction of the CondMove instruction format.
static Instruction	TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode) Create an instruction of the TrapIf instruction format.
static Instruction	Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location) Create an instruction of the Prepare instruction format.
static Instruction	Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location) Create an instruction of the Load instruction format.
static Instruction	Prepare.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the Prepare instruction format.
static Instruction	ALoad.create(Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard) Create an instruction of the ALoad instruction format.
static Instruction	Load.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the Load instruction format.
static Instruction	GetField.create(Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the GetField instruction format.
static Instruction	StoreCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard) Create an instruction of the StoreCheck instruction format.
static Instruction	GuardedBinary.create(Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard) Create an instruction of the GuardedBinary instruction format.
static Instruction	BoundsCheck.create(Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard) Create an instruction of the BoundsCheck instruction format.
static Instruction	Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location) Create an instruction of the Attempt instruction format.
static Instruction	Attempt.create(Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard) Create an instruction of the Attempt instruction format.
static Instruction	TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type) Create an instruction of the TypeCheck instruction format.
static Instruction	TypeCheck.create(Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard) Create an instruction of the TypeCheck instruction format.
static Instruction	NewArray.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Size) Create an instruction of the NewArray instruction format.
static Instruction	InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref) Create an instruction of the InstanceOf instruction format.
static Instruction	InstanceOf.create(Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard) Create an instruction of the InstanceOf instruction format.
static Instruction	Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method) Create an instruction of the Call instruction format with 0 variable arguments.
static Instruction	Call.create0(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard) Create an instruction of the Call instruction format with 0 variable arguments.
static Instruction	Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1) Create an instruction of the Call instruction format with 1 variable arguments.
static Instruction	Call.create1(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1) Create an instruction of the Call instruction format with 1 variable arguments.
static Instruction	Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2) Create an instruction of the Call instruction format with 2 variable arguments.
static Instruction	Call.create2(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2) Create an instruction of the Call instruction format with 2 variable arguments.
static Instruction	Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3) Create an instruction of the Call instruction format with 3 variable arguments.
static Instruction	Call.create3(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3) Create an instruction of the Call instruction format with 3 variable arguments.
static Instruction	Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4) Create an instruction of the Call instruction format with 4 variable arguments.
static Instruction	Call.create4(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4) Create an instruction of the Call instruction format with 4 variable arguments.
static Instruction	Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5) Create an instruction of the Call instruction format with 5 variable arguments.
static Instruction	Call.create5(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5) Create an instruction of the Call instruction format with 5 variable arguments.
static Instruction	Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6) Create an instruction of the Call instruction format with 6 variable arguments.
static Instruction	Call.create6(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6) Create an instruction of the Call instruction format with 6 variable arguments.
static Instruction	Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7) Create an instruction of the Call instruction format with 7 variable arguments.
static Instruction	Call.create7(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7) Create an instruction of the Call instruction format with 7 variable arguments.
static Instruction	Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8) Create an instruction of the Call instruction format with 8 variable arguments.
static Instruction	Call.create8(Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8) Create an instruction of the Call instruction format with 8 variable arguments.
static boolean	IRTools.defDoublesAsUse(Operand d, Instruction s) Is the operand d, which is a def in instruction s, also a use in instruction s?
int	MachineSpecificIR.getBURSManagedFPRValue(Operand operand)
private Object	IR.getVariableDef(String where, Operand operand) Get the variable defined by this operand
private Object	IR.getVariableUse(String where, Operand operand) Get the variable used by this operand
boolean	MachineSpecificIR.isBURSManagedFPROperand(Operand operand)
abstract boolean	MachineSpecificIR.isConditionOperand(Operand operand)
boolean	IR.isParameter(Operand op) Is the operand a parameter of the IR?
boolean	MachineSpecificIR.isPowerPCTrapOperand(Operand operand)
RegisterOperand	AbstractRegisterPool.makeTemp(Operand op) Make a temporary register operand that can hold the values implied by the passed operand.
static RegisterOperand	IRTools.moveIntoRegister(GenericRegisterPool pool, Instruction s, Operand op) Generates an instruction to move the given operand into a register, and inserts it before the given instruction.
static RegisterOperand	IRTools.moveIntoRegister(TypeReference type, Operator move_op, GenericRegisterPool pool, Instruction s, Operand op) Generates an instruction to move the given operand into a register, and inserts it before the given instruction.
static Instruction	InstrumentedCounter.mutate(Instruction i, Operator o, IntConstantOperand Data, IntConstantOperand Index, Operand Increment) Mutate the argument instruction into an instruction of the InstrumentedCounter instruction format having the specified operator and operands.
static Instruction	CacheOp.mutate(Instruction i, Operator o, Operand Ref) Mutate the argument instruction into an instruction of the CacheOp instruction format having the specified operator and operands.
static Instruction	Return.mutate(Instruction i, Operator o, Operand Val) Mutate the argument instruction into an instruction of the Return instruction format having the specified operator and operands.
static Instruction	Athrow.mutate(Instruction i, Operator o, Operand Value) Mutate the argument instruction into an instruction of the Athrow instruction format having the specified operator and operands.
static Instruction	Phi.mutate(Instruction i, Operator o, Operand Result, int numVarOps) Mutate the argument instruction into an instruction of the Phi instruction format having the specified operator and operands.
static Instruction	MonitorOp.mutate(Instruction i, Operator o, Operand Ref, Operand Guard) Mutate the argument instruction into an instruction of the MonitorOp instruction format having the specified operator and operands.
static Instruction	PutStatic.mutate(Instruction i, Operator o, Operand Value, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the PutStatic instruction format having the specified operator and operands.
static Instruction	GuardedSet.mutate(Instruction i, Operator o, Operand Ref, Operand Val, Operand Guard) Mutate the argument instruction into an instruction of the GuardedSet instruction format having the specified operator and operands.
static Instruction	InlineGuard.mutate(Instruction i, Operator o, Operand Value, Operand Guard, Operand Goal, BranchOperand Target, BranchProfileOperand BranchProfile) Mutate the argument instruction into an instruction of the InlineGuard instruction format having the specified operator and operands.
static Instruction	LookupSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps) Mutate the argument instruction into an instruction of the LookupSwitch instruction format having the specified operator and operands.
static Instruction	TableSwitch.mutate(Instruction i, Operator o, Operand Value, Operand Unknown1, Operand Unknown2, IntConstantOperand Low, IntConstantOperand High, BranchOperand Default, BranchProfileOperand DefaultBranchProfile, int numVarOps) Mutate the argument instruction into an instruction of the TableSwitch instruction format having the specified operator and operands.
static Instruction	Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
static Instruction	Store.mutate(Instruction i, Operator o, Operand Value, Operand Address, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the Store instruction format having the specified operator and operands.
static Instruction	PutField.mutate(Instruction i, Operator o, Operand Value, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the PutField instruction format having the specified operator and operands.
static Instruction	AStore.mutate(Instruction i, Operator o, Operand Value, Operand Array, Operand Index, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the AStore instruction format having the specified operator and operands.
static Instruction	Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val) Mutate the argument instruction into an instruction of the Unary instruction format having the specified operator and operands.
static Instruction	NullCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref) Mutate the argument instruction into an instruction of the NullCheck instruction format having the specified operator and operands.
static Instruction	ZeroCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Value) Mutate the argument instruction into an instruction of the ZeroCheck instruction format having the specified operator and operands.
static Instruction	Move.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val) Mutate the argument instruction into an instruction of the Move instruction format having the specified operator and operands.
static Instruction	GetStatic.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the GetStatic instruction format having the specified operator and operands.
static Instruction	Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, int numVarOps) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
static Instruction	Call.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, int numVarOps) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator and operands.
static Instruction	Binary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2) Mutate the argument instruction into an instruction of the Binary instruction format having the specified operator and operands.
static Instruction	GuardedUnary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val, Operand Guard) Mutate the argument instruction into an instruction of the GuardedUnary instruction format having the specified operator and operands.
static Instruction	IfCmp.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, BranchOperand Target, BranchProfileOperand BranchProfile) Mutate the argument instruction into an instruction of the IfCmp instruction format having the specified operator and operands.
static Instruction	IfCmp2.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond1, BranchOperand Target1, BranchProfileOperand BranchProfile1, ConditionOperand Cond2, BranchOperand Target2, BranchProfileOperand BranchProfile2) Mutate the argument instruction into an instruction of the IfCmp2 instruction format having the specified operator and operands.
static Instruction	BooleanCmp.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, BranchProfileOperand BranchProfile) Mutate the argument instruction into an instruction of the BooleanCmp instruction format having the specified operator and operands.
static Instruction	CondMove.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, ConditionOperand Cond, Operand TrueValue, Operand FalseValue) Mutate the argument instruction into an instruction of the CondMove instruction format having the specified operator and operands.
static Instruction	TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, ConditionOperand Cond, TrapCodeOperand TCode) Mutate the argument instruction into an instruction of the TrapIf instruction format having the specified operator and operands.
static Instruction	Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
static Instruction	Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
static Instruction	Prepare.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the Prepare instruction format having the specified operator and operands.
static Instruction	ALoad.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Array, Operand Index, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the ALoad instruction format having the specified operator and operands.
static Instruction	Load.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the Load instruction format having the specified operator and operands.
static Instruction	GetField.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the GetField instruction format having the specified operator and operands.
static Instruction	StoreCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Val, Operand Guard) Mutate the argument instruction into an instruction of the StoreCheck instruction format having the specified operator and operands.
static Instruction	GuardedBinary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Val1, Operand Val2, Operand Guard) Mutate the argument instruction into an instruction of the GuardedBinary instruction format having the specified operator and operands.
static Instruction	BoundsCheck.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Ref, Operand Index, Operand Guard) Mutate the argument instruction into an instruction of the BoundsCheck instruction format having the specified operator and operands.
static Instruction	Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location) Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
static Instruction	Attempt.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Address, Operand Offset, Operand OldValue, Operand NewValue, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the Attempt instruction format having the specified operator and operands.
static Instruction	TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type) Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
static Instruction	TypeCheck.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Ref, TypeOperand Type, Operand Guard) Mutate the argument instruction into an instruction of the TypeCheck instruction format having the specified operator and operands.
static Instruction	NewArray.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Size) Mutate the argument instruction into an instruction of the NewArray instruction format having the specified operator and operands.
static Instruction	InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref) Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
static Instruction	InstanceOf.mutate(Instruction i, Operator o, RegisterOperand Result, TypeOperand Type, Operand Ref, Operand Guard) Mutate the argument instruction into an instruction of the InstanceOf instruction format having the specified operator and operands.
static Instruction	Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate0(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate1(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate2(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate3(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate4(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate5(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate6(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate7(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	Call.mutate8(Instruction i, Operator o, RegisterOperand Result, Operand Address, MethodOperand Method, Operand Guard, Operand Param_1, Operand Param_2, Operand Param_3, Operand Param_4, Operand Param_5, Operand Param_6, Operand Param_7, Operand Param_8) Mutate the argument instruction into an instruction of the Call instruction format having the specified operator, operands, and number of variable-length operands.
private Operand	Instruction.outOfLineCopy(Operand op)
void	Instruction.putOperand(int i, Operand op) NOTE: It is incorrect to use putOperand with a constant argument outside of the automatically generated code in Operators.
void	Instruction.replaceOperand(Operand oldOp, Operand newOp) Replace all occurances of the first operand with the second.
void	Instruction.replaceSimilarOperands(Operand oldOp, Operand newOp) Replace any operands that are similar to the first operand with a copy of the second operand.
static void	Prepare.setAddress(Instruction i, Operand Address) Set the operand called Address in the argument instruction to the argument operand.
static void	Attempt.setAddress(Instruction i, Operand Address) Set the operand called Address in the argument instruction to the argument operand.
static void	Store.setAddress(Instruction i, Operand Address) Set the operand called Address in the argument instruction to the argument operand.
static void	Load.setAddress(Instruction i, Operand Address) Set the operand called Address in the argument instruction to the argument operand.
static void	Call.setAddress(Instruction i, Operand Address) Set the operand called Address in the argument instruction to the argument operand.
static void	ALoad.setArray(Instruction i, Operand Array) Set the operand called Array in the argument instruction to the argument operand.
static void	AStore.setArray(Instruction i, Operand Array) Set the operand called Array in the argument instruction to the argument operand.
static void	Multianewarray.setDimension(Instruction i, int k, Operand o) Set the k'th operand called Dimension in the argument instruction to the argument operand.
static void	OsrBarrier.setElement(Instruction i, int k, Operand o) Set the k'th operand called Element in the argument instruction to the argument operand.
static void	OsrPoint.setElement(Instruction i, int k, Operand o) Set the k'th operand called Element in the argument instruction to the argument operand.
static void	CondMove.setFalseValue(Instruction i, Operand FalseValue) Set the operand called FalseValue in the argument instruction to the argument operand.
static void	InlineGuard.setGoal(Instruction i, Operand Goal) Set the operand called Goal in the argument instruction to the argument operand.
static void	GuardedSet.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	Prepare.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	ALoad.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	StoreCheck.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	Attempt.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	GuardedBinary.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	Store.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	InstanceOf.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	GuardCarrier.setGuard(Instruction i, Operand op) Set the operand called Guard in the argument instruction to the argument operand.
static void	MonitorOp.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	PutField.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	Load.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	TypeCheck.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	BoundsCheck.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	InlineGuard.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	Call.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	AStore.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	GuardedUnary.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	GetField.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	InstrumentedCounter.setIncrement(Instruction i, Operand Increment) Set the operand called Increment in the argument instruction to the argument operand.
static void	ALoad.setIndex(Instruction i, Operand Index) Set the operand called Index in the argument instruction to the argument operand.
static void	BoundsCheck.setIndex(Instruction i, Operand Index) Set the operand called Index in the argument instruction to the argument operand.
static void	AStore.setIndex(Instruction i, Operand Index) Set the operand called Index in the argument instruction to the argument operand.
static void	Attempt.setNewValue(Instruction i, Operand NewValue) Set the operand called NewValue in the argument instruction to the argument operand.
static void	PutStatic.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	Prepare.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	Attempt.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	Store.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	PutField.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	Load.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	GetField.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	GetStatic.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	Attempt.setOldValue(Instruction i, Operand OldValue) Set the operand called OldValue in the argument instruction to the argument operand.
static void	Call.setParam(Instruction i, int k, Operand o) Set the k'th operand called Param in the argument instruction to the argument operand.
static void	GuardedSet.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	CacheOp.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	StoreCheck.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	InstanceOf.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	MonitorOp.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	PutField.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	TypeCheck.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	NullCheck.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	BoundsCheck.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	GetField.setRef(Instruction i, Operand Ref) Set the operand called Ref in the argument instruction to the argument operand.
static void	Phi.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	NewArray.setSize(Instruction i, Operand Size) Set the operand called Size in the argument instruction to the argument operand.
static void	CondMove.setTrueValue(Instruction i, Operand TrueValue) Set the operand called TrueValue in the argument instruction to the argument operand.
static void	TableSwitch.setUnknown1(Instruction i, Operand Unknown1) Set the operand called Unknown1 in the argument instruction to the argument operand.
static void	LookupSwitch.setUnknown1(Instruction i, Operand Unknown1) Set the operand called Unknown1 in the argument instruction to the argument operand.
static void	TableSwitch.setUnknown2(Instruction i, Operand Unknown2) Set the operand called Unknown2 in the argument instruction to the argument operand.
static void	LookupSwitch.setUnknown2(Instruction i, Operand Unknown2) Set the operand called Unknown2 in the argument instruction to the argument operand.
static void	GuardedSet.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	StoreCheck.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	Unary.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	Return.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	GuardedUnary.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	Move.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	TrapIf.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	Binary.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	GuardedBinary.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	CondMove.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	IfCmp2.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	BooleanCmp.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	IfCmp.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	TrapIf.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	Binary.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	GuardedBinary.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	CondMove.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	IfCmp2.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	BooleanCmp.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	IfCmp.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	Phi.setValue(Instruction i, int k, Operand o) Set the k'th operand called Value in the argument instruction to the argument operand.
static void	PutStatic.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	Store.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	PutField.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	ZeroCheck.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	Athrow.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	InlineGuard.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	TableSwitch.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	AStore.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	LookupSwitch.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static boolean	IRTools.useDoublesAsDef(Operand u, Instruction s) Is the operand u, which is a use in instruction s, also a def in instruction s?

Uses of Operand in org.jikesrvm.compilers.opt.ir.ia32

Methods in org.jikesrvm.compilers.opt.ir.ia32 that return Operand

Modifier and Type	Method and Description
static Operand	MIR_CacheOp.getAddress(Instruction i) Get the operand called Address from the argument instruction.
static Operand	MIR_DoubleShift.getBitsToShift(Instruction i) Get the operand called BitsToShift from the argument instruction.
static Operand	MIR_CacheOp.getClearAddress(Instruction i) Get the operand called Address from the argument instruction clearing its instruction pointer.
static Operand	MIR_DoubleShift.getClearBitsToShift(Instruction i) Get the operand called BitsToShift from the argument instruction clearing its instruction pointer.
static Operand	MIR_FSave.getClearDestination(Instruction i) Get the operand called Destination from the argument instruction clearing its instruction pointer.
static Operand	MIR_Divide.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	MIR_Call.getClearParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction clearing its instruction pointer.
static Operand	MIR_Unary.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_CondMove.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_DoubleShift.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_Move.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_BinaryAcc.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_UnaryAcc.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_Nullary.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_Set.getClearResult(Instruction i) Get the operand called Result from the argument instruction clearing its instruction pointer.
static Operand	MIR_Multiply.getClearResult1(Instruction i) Get the operand called Result1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_ConvertDW2QW.getClearResult1(Instruction i) Get the operand called Result1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Divide.getClearResult1(Instruction i) Get the operand called Result1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Multiply.getClearResult2(Instruction i) Get the operand called Result2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_ConvertDW2QW.getClearResult2(Instruction i) Get the operand called Result2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Divide.getClearResult2(Instruction i) Get the operand called Result2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Call.getClearTarget(Instruction i) Get the operand called Target from the argument instruction clearing its instruction pointer.
static Operand	MIR_CaseLabel.getClearTarget(Instruction i) Get the operand called Target from the argument instruction clearing its instruction pointer.
static Operand	MIR_Unary.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	MIR_Return.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	MIR_UnaryNoRes.getClearVal(Instruction i) Get the operand called Val from the argument instruction clearing its instruction pointer.
static Operand	MIR_Test.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Compare.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_TrapIf.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_XChng.getClearVal1(Instruction i) Get the operand called Val1 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Test.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Return.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Compare.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_TrapIf.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_XChng.getClearVal2(Instruction i) Get the operand called Val2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_CondMove.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	MIR_Multiply.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	MIR_Move.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	MIR_BinaryAcc.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	MIR_Divide.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	MIR_FSave.getDestination(Instruction i) Get the operand called Destination from the argument instruction.
static Operand	MIR_Divide.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	MIR_Call.getParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction.
static Operand	MIR_Unary.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_CondMove.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_DoubleShift.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_Move.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_BinaryAcc.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_UnaryAcc.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_Nullary.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_Set.getResult(Instruction i) Get the operand called Result from the argument instruction.
static Operand	MIR_Multiply.getResult1(Instruction i) Get the operand called Result1 from the argument instruction.
static Operand	MIR_ConvertDW2QW.getResult1(Instruction i) Get the operand called Result1 from the argument instruction.
static Operand	MIR_Divide.getResult1(Instruction i) Get the operand called Result1 from the argument instruction.
static Operand	MIR_Multiply.getResult2(Instruction i) Get the operand called Result2 from the argument instruction.
static Operand	MIR_ConvertDW2QW.getResult2(Instruction i) Get the operand called Result2 from the argument instruction.
static Operand	MIR_Divide.getResult2(Instruction i) Get the operand called Result2 from the argument instruction.
static Operand	MIR_Call.getTarget(Instruction i) Get the operand called Target from the argument instruction.
static Operand	MIR_CaseLabel.getTarget(Instruction i) Get the operand called Target from the argument instruction.
static Operand	MIR_Unary.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	MIR_Return.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	MIR_UnaryNoRes.getVal(Instruction i) Get the operand called Val from the argument instruction.
static Operand	MIR_Test.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	MIR_Compare.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	MIR_TrapIf.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	MIR_XChng.getVal1(Instruction i) Get the operand called Val1 from the argument instruction.
static Operand	MIR_Test.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	MIR_Return.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	MIR_Compare.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	MIR_TrapIf.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	MIR_XChng.getVal2(Instruction i) Get the operand called Val2 from the argument instruction.
static Operand	MIR_CondMove.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	MIR_Multiply.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	MIR_Move.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	MIR_BinaryAcc.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	MIR_Divide.getValue(Instruction i) Get the operand called Value from the argument instruction.
Operand	RegisterPool.makeJTOCOp() Return a constant operand that is the base address of the JTOC.
Operand	RegisterPool.makeTocOp()

Methods in org.jikesrvm.compilers.opt.ir.ia32 with parameters of type Operand

Modifier and Type	Method and Description
static Instruction	MIR_CaseLabel.create(Operator o, IntConstantOperand Index, Operand Target) Create an instruction of the MIR_CaseLabel instruction format.
static Instruction	MIR_Return.create(Operator o, IntConstantOperand PopBytes, Operand Val, Operand Val2) Create an instruction of the MIR_Return instruction format.
static Instruction	MIR_UnaryNoRes.create(Operator o, Operand Val) Create an instruction of the MIR_UnaryNoRes instruction format.
static Instruction	MIR_UnaryAcc.create(Operator o, Operand Result) Create an instruction of the MIR_UnaryAcc instruction format.
static Instruction	MIR_Nullary.create(Operator o, Operand Result) Create an instruction of the MIR_Nullary instruction format.
static Instruction	MIR_CacheOp.create(Operator o, Operand Address) Create an instruction of the MIR_CacheOp instruction format.
static Instruction	MIR_FSave.create(Operator o, Operand Destination) Create an instruction of the MIR_FSave instruction format.
static Instruction	MIR_Set.create(Operator o, Operand Result, IA32ConditionOperand Cond) Create an instruction of the MIR_Set instruction format.
static Instruction	MIR_Test.create(Operator o, Operand Val1, Operand Val2) Create an instruction of the MIR_Test instruction format.
static Instruction	MIR_Unary.create(Operator o, Operand Result, Operand Val) Create an instruction of the MIR_Unary instruction format.
static Instruction	MIR_Move.create(Operator o, Operand Result, Operand Value) Create an instruction of the MIR_Move instruction format.
static Instruction	MIR_BinaryAcc.create(Operator o, Operand Result, Operand Value) Create an instruction of the MIR_BinaryAcc instruction format.
static Instruction	MIR_Compare.create(Operator o, Operand Val1, Operand Val2) Create an instruction of the MIR_Compare instruction format.
static Instruction	MIR_ConvertDW2QW.create(Operator o, Operand Result1, Operand Result2) Create an instruction of the MIR_ConvertDW2QW instruction format.
static Instruction	MIR_XChng.create(Operator o, Operand Val1, Operand Val2) Create an instruction of the MIR_XChng instruction format.
static Instruction	MIR_CondMove.create(Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond) Create an instruction of the MIR_CondMove instruction format.
static Instruction	MIR_Multiply.create(Operator o, Operand Result1, Operand Result2, Operand Value) Create an instruction of the MIR_Multiply instruction format.
static Instruction	MIR_Divide.create(Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard) Create an instruction of the MIR_Divide instruction format.
static Instruction	MIR_DoubleShift.create(Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift) Create an instruction of the MIR_DoubleShift instruction format.
static Instruction	MIR_TrapIf.create(Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode) Create an instruction of the MIR_TrapIf instruction format.
static Instruction	MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps) Create an instruction of the MIR_Call instruction format.
static Instruction	MIR_Call.create(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps) Create an instruction of the MIR_Call instruction format.
static Instruction	MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target) Create an instruction of the MIR_Call instruction format with 0 variable arguments.
static Instruction	MIR_Call.create0(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method) Create an instruction of the MIR_Call instruction format with 0 variable arguments.
static Instruction	MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1) Create an instruction of the MIR_Call instruction format with 1 variable arguments.
static Instruction	MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1) Create an instruction of the MIR_Call instruction format with 1 variable arguments.
static Instruction	MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1) Create an instruction of the MIR_Call instruction format with 1 variable arguments.
static Instruction	MIR_Call.create1(Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1) Create an instruction of the MIR_Call instruction format with 1 variable arguments.
static Instruction	MIR_CaseLabel.mutate(Instruction i, Operator o, IntConstantOperand Index, Operand Target) Mutate the argument instruction into an instruction of the MIR_CaseLabel instruction format having the specified operator and operands.
static Instruction	MIR_Return.mutate(Instruction i, Operator o, IntConstantOperand PopBytes, Operand Val, Operand Val2) Mutate the argument instruction into an instruction of the MIR_Return instruction format having the specified operator and operands.
static Instruction	MIR_UnaryNoRes.mutate(Instruction i, Operator o, Operand Val) Mutate the argument instruction into an instruction of the MIR_UnaryNoRes instruction format having the specified operator and operands.
static Instruction	MIR_UnaryAcc.mutate(Instruction i, Operator o, Operand Result) Mutate the argument instruction into an instruction of the MIR_UnaryAcc instruction format having the specified operator and operands.
static Instruction	MIR_Nullary.mutate(Instruction i, Operator o, Operand Result) Mutate the argument instruction into an instruction of the MIR_Nullary instruction format having the specified operator and operands.
static Instruction	MIR_CacheOp.mutate(Instruction i, Operator o, Operand Address) Mutate the argument instruction into an instruction of the MIR_CacheOp instruction format having the specified operator and operands.
static Instruction	MIR_FSave.mutate(Instruction i, Operator o, Operand Destination) Mutate the argument instruction into an instruction of the MIR_FSave instruction format having the specified operator and operands.
static Instruction	MIR_Set.mutate(Instruction i, Operator o, Operand Result, IA32ConditionOperand Cond) Mutate the argument instruction into an instruction of the MIR_Set instruction format having the specified operator and operands.
static Instruction	MIR_Test.mutate(Instruction i, Operator o, Operand Val1, Operand Val2) Mutate the argument instruction into an instruction of the MIR_Test instruction format having the specified operator and operands.
static Instruction	MIR_Unary.mutate(Instruction i, Operator o, Operand Result, Operand Val) Mutate the argument instruction into an instruction of the MIR_Unary instruction format having the specified operator and operands.
static Instruction	MIR_Move.mutate(Instruction i, Operator o, Operand Result, Operand Value) Mutate the argument instruction into an instruction of the MIR_Move instruction format having the specified operator and operands.
static Instruction	MIR_BinaryAcc.mutate(Instruction i, Operator o, Operand Result, Operand Value) Mutate the argument instruction into an instruction of the MIR_BinaryAcc instruction format having the specified operator and operands.
static Instruction	MIR_Compare.mutate(Instruction i, Operator o, Operand Val1, Operand Val2) Mutate the argument instruction into an instruction of the MIR_Compare instruction format having the specified operator and operands.
static Instruction	MIR_ConvertDW2QW.mutate(Instruction i, Operator o, Operand Result1, Operand Result2) Mutate the argument instruction into an instruction of the MIR_ConvertDW2QW instruction format having the specified operator and operands.
static Instruction	MIR_XChng.mutate(Instruction i, Operator o, Operand Val1, Operand Val2) Mutate the argument instruction into an instruction of the MIR_XChng instruction format having the specified operator and operands.
static Instruction	MIR_CondMove.mutate(Instruction i, Operator o, Operand Result, Operand Value, IA32ConditionOperand Cond) Mutate the argument instruction into an instruction of the MIR_CondMove instruction format having the specified operator and operands.
static Instruction	MIR_Multiply.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value) Mutate the argument instruction into an instruction of the MIR_Multiply instruction format having the specified operator and operands.
static Instruction	MIR_Divide.mutate(Instruction i, Operator o, Operand Result1, Operand Result2, Operand Value, Operand Guard) Mutate the argument instruction into an instruction of the MIR_Divide instruction format having the specified operator and operands.
static Instruction	MIR_DoubleShift.mutate(Instruction i, Operator o, Operand Result, RegisterOperand Source, Operand BitsToShift) Mutate the argument instruction into an instruction of the MIR_DoubleShift instruction format having the specified operator and operands.
static Instruction	MIR_TrapIf.mutate(Instruction i, Operator o, RegisterOperand GuardResult, Operand Val1, Operand Val2, IA32ConditionOperand Cond, TrapCodeOperand TrapCode) Mutate the argument instruction into an instruction of the MIR_TrapIf instruction format having the specified operator and operands.
static Instruction	MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, int numVarOps) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
static Instruction	MIR_Call.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, int numVarOps) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator and operands.
static Instruction	MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	MIR_Call.mutate0(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, MethodOperand Method, Operand Param_1) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Param_1) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, MethodOperand Method, Operand Param_1) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
static Instruction	MIR_Call.mutate1(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Result2, Operand Target, Operand Param_1) Mutate the argument instruction into an instruction of the MIR_Call instruction format having the specified operator, operands, and number of variable-length operands.
static void	MIR_CacheOp.setAddress(Instruction i, Operand Address) Set the operand called Address in the argument instruction to the argument operand.
static void	MIR_DoubleShift.setBitsToShift(Instruction i, Operand BitsToShift) Set the operand called BitsToShift in the argument instruction to the argument operand.
static void	MIR_FSave.setDestination(Instruction i, Operand Destination) Set the operand called Destination in the argument instruction to the argument operand.
static void	MIR_Divide.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	MIR_Call.setParam(Instruction i, int k, Operand o) Set the k'th operand called Param in the argument instruction to the argument operand.
static void	MIR_Unary.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_CondMove.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_DoubleShift.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_Move.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_BinaryAcc.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_UnaryAcc.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_Nullary.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_Set.setResult(Instruction i, Operand Result) Set the operand called Result in the argument instruction to the argument operand.
static void	MIR_Multiply.setResult1(Instruction i, Operand Result1) Set the operand called Result1 in the argument instruction to the argument operand.
static void	MIR_ConvertDW2QW.setResult1(Instruction i, Operand Result1) Set the operand called Result1 in the argument instruction to the argument operand.
static void	MIR_Divide.setResult1(Instruction i, Operand Result1) Set the operand called Result1 in the argument instruction to the argument operand.
static void	MIR_Multiply.setResult2(Instruction i, Operand Result2) Set the operand called Result2 in the argument instruction to the argument operand.
static void	MIR_ConvertDW2QW.setResult2(Instruction i, Operand Result2) Set the operand called Result2 in the argument instruction to the argument operand.
static void	MIR_Divide.setResult2(Instruction i, Operand Result2) Set the operand called Result2 in the argument instruction to the argument operand.
static void	MIR_Call.setTarget(Instruction i, Operand Target) Set the operand called Target in the argument instruction to the argument operand.
static void	MIR_CaseLabel.setTarget(Instruction i, Operand Target) Set the operand called Target in the argument instruction to the argument operand.
static void	MIR_Unary.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	MIR_Return.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	MIR_UnaryNoRes.setVal(Instruction i, Operand Val) Set the operand called Val in the argument instruction to the argument operand.
static void	MIR_Test.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	MIR_Compare.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	MIR_TrapIf.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	MIR_XChng.setVal1(Instruction i, Operand Val1) Set the operand called Val1 in the argument instruction to the argument operand.
static void	MIR_Test.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	MIR_Return.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	MIR_Compare.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	MIR_TrapIf.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	MIR_XChng.setVal2(Instruction i, Operand Val2) Set the operand called Val2 in the argument instruction to the argument operand.
static void	MIR_CondMove.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	MIR_Multiply.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	MIR_Move.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	MIR_BinaryAcc.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	MIR_Divide.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.

Uses of Operand in org.jikesrvm.compilers.opt.ir.operand

Subclasses of Operand in org.jikesrvm.compilers.opt.ir.operand

Modifier and Type	Class and Description
class	AddressConstantOperand Represents an address constant operand.
class	BasicBlockOperand Represents a basic block (used in LABEL and BBEND instructions)
class	BranchOperand Represents a branch target.
class	BranchProfileOperand
class	ClassConstantOperand Represents a constant class operand.
class	CodeConstantOperand Represents a constant code operand, found for example, from an TIBConstantOperand.
class	ConditionOperand Encodes the condition codes for branches.
class	ConstantOperand Common superclass for all constant operands
class	DoubleConstantOperand Represents a constant double operand.
class	FloatConstantOperand Represents a constant float operand.
class	HeapOperand<T> Represents a heap variable for instructions in Heap Array SSA form.
class	InlinedOsrTypeInfoOperand An InlinedOsrTypeInfoOperand object keeps necessary information to recover non-inlined status for an inlined method.
class	IntConstantOperand Represents a constant int operand.
class	LocationOperand Represents a location in memory.
class	LongConstantOperand Represents a constant long operand.
class	MemoryOperand A memory operand.
class	MethodOperand Refers to a method.
class	NullConstantOperand This operand represents the null constant.
class	ObjectConstantOperand Represents a constant object operand (for example, from an initialized static final).
class	OsrTypeInfoOperand An OsrTypeInfoOperand object keeps type information of locals and stacks at a byte code index.
class	RegisterOperand A symbolic or physical register.
class	StackLocationOperand Represents a symbolic name for a stack location.
class	StringConstantOperand Represents a constant string operand.
class	TIBConstantOperand Represents a constant TIB operand, found for example, from an ObjectConstantOperand.
class	TrapCodeOperand Encode the semantic reason for a trap instruction.
class	TrueGuardOperand This operand represents a "true" guard, e.g. non-nullness of the result of an allocation or boundcheck eliminated via analysis of the loop induction variables.
class	TypeOperand A TypeOperand represents a type.
class	UnreachableOperand This operand represents, in a phi function, a control-flow path that is actually unreachable.

Fields in org.jikesrvm.compilers.opt.ir.operand declared as Operand

Modifier and Type	Field and Description
Operand	MemoryOperand.guard The guard operand that validates this memory access
private Operand	RegisterOperand.guard The guard associated with a RegisterOperand.

Methods in org.jikesrvm.compilers.opt.ir.operand that return Operand

Modifier and Type	Method and Description
Operand	NullConstantOperand.copy()
abstract Operand	Operand.copy() Return a new operand that is semantically equivalent to this.
Operand	StringConstantOperand.copy()
Operand	ClassConstantOperand.copy()
Operand	TIBConstantOperand.copy()
Operand	BranchProfileOperand.copy() Returns a copy of this branch operand.
Operand	MemoryOperand.copy()
Operand	AddressConstantOperand.copy()
Operand	IntConstantOperand.copy()
Operand	TypeOperand.copy()
Operand	ObjectConstantOperand.copy()
Operand	InlinedOsrTypeInfoOperand.copy()
Operand	LongConstantOperand.copy()
Operand	BasicBlockOperand.copy()
Operand	TrueGuardOperand.copy()
Operand	UnreachableOperand.copy()
Operand	FloatConstantOperand.copy()
Operand	LocationOperand.copy()
Operand	CodeConstantOperand.copy()
Operand	RegisterOperand.copy() Returns a copy of this register operand as an operand
Operand	BranchOperand.copy() Returns a copy of this branch operand.
Operand	ConditionOperand.copy()
Operand	DoubleConstantOperand.copy()
Operand	MethodOperand.copy()
Operand	TrapCodeOperand.copy()
Operand	StackLocationOperand.copy()
Operand	OsrTypeInfoOperand.copy()
Operand	RegisterOperand.getGuard()
static Operand	Operand.meet(Operand op1, Operand op2, Register reg) Meet two operands based on their positions in the operand lattice.

Methods in org.jikesrvm.compilers.opt.ir.operand with parameters of type Operand

Modifier and Type	Method and Description
static MemoryOperand	MemoryOperand.B(RegisterOperand base, byte size, LocationOperand loc, Operand guard)
static MemoryOperand	MemoryOperand.BD(RegisterOperand base, Offset disp, byte size, LocationOperand loc, Operand guard)
static MemoryOperand	MemoryOperand.BI(RegisterOperand base, RegisterOperand index, byte size, LocationOperand loc, Operand guard)
static MemoryOperand	MemoryOperand.BID(RegisterOperand base, RegisterOperand index, Offset disp, byte size, LocationOperand loc, Operand guard)
static MemoryOperand	MemoryOperand.BIS(RegisterOperand base, RegisterOperand index, byte scale, byte size, LocationOperand loc, Operand guard)
static boolean	Operand.conservativelyApproximates(Operand op1, Operand op2) Compare two operands based on their positions in the operand lattice.
static MemoryOperand	MemoryOperand.D(Address disp, byte size, LocationOperand loc, Operand guard)
int	ConditionOperand.evaluate(Operand v1, Operand v2) Given two operands, evaluate the condition on them.
static MemoryOperand	MemoryOperand.I(RegisterOperand base, byte size, LocationOperand loc, Operand guard)
static Operand	Operand.meet(Operand op1, Operand op2, Register reg) Meet two operands based on their positions in the operand lattice.
void	RegisterOperand.setGuard(Operand guard)
boolean	NullConstantOperand.similar(Operand op)
abstract boolean	Operand.similar(Operand op) Are two operands semantically equivalent?
boolean	TIBConstantOperand.similar(Operand op)
boolean	BranchProfileOperand.similar(Operand op)
boolean	MemoryOperand.similar(Operand op)
boolean	AddressConstantOperand.similar(Operand op)
boolean	IntConstantOperand.similar(Operand op)
boolean	TypeOperand.similar(Operand op)
boolean	ObjectConstantOperand.similar(Operand op)
boolean	InlinedOsrTypeInfoOperand.similar(Operand op)
boolean	LongConstantOperand.similar(Operand op)
boolean	BasicBlockOperand.similar(Operand op)
boolean	TrueGuardOperand.similar(Operand op)
boolean	HeapOperand.similar(Operand op) Does this operand correspond to the same heap variable as another heap operand?
boolean	UnreachableOperand.similar(Operand op)
boolean	FloatConstantOperand.similar(Operand op)
boolean	LocationOperand.similar(Operand op)
boolean	CodeConstantOperand.similar(Operand op)
boolean	RegisterOperand.similar(Operand op)
boolean	BranchOperand.similar(Operand op)
boolean	ConditionOperand.similar(Operand op)
boolean	DoubleConstantOperand.similar(Operand op)
boolean	MethodOperand.similar(Operand op)
boolean	TrapCodeOperand.similar(Operand op)
boolean	StackLocationOperand.similar(Operand op)
boolean	OsrTypeInfoOperand.similar(Operand op)

Constructors in org.jikesrvm.compilers.opt.ir.operand with parameters of type Operand

Constructor and Description
MemoryOperand(RegisterOperand base, RegisterOperand index, byte scale, Offset disp, byte size, LocationOperand loc, Operand guard)

Uses of Operand in org.jikesrvm.compilers.opt.ir.operand.ia32

Subclasses of Operand in org.jikesrvm.compilers.opt.ir.operand.ia32

Modifier and Type	Class and Description
class	BURSManagedFPROperand An FPR register that BURS is managing.
class	IA32ConditionOperand An IA32 condition operand

Methods in org.jikesrvm.compilers.opt.ir.operand.ia32 that return Operand

Modifier and Type	Method and Description
Operand	IA32ConditionOperand.copy()
Operand	BURSManagedFPROperand.copy()

Methods in org.jikesrvm.compilers.opt.ir.operand.ia32 with parameters of type Operand

Modifier and Type	Method and Description
boolean	IA32ConditionOperand.similar(Operand op)
boolean	BURSManagedFPROperand.similar(Operand op)

Uses of Operand in org.jikesrvm.compilers.opt.ir.ppc

Methods in org.jikesrvm.compilers.opt.ir.ppc that return Operand

Modifier and Type	Method and Description
static Operand	MIR_StoreUpdate.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	MIR_Load.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	MIR_Store.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	MIR_LoadUpdate.getClearGuard(Instruction i) Get the operand called Guard from the argument instruction clearing its instruction pointer.
static Operand	MIR_StoreUpdate.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	MIR_Load.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	MIR_Store.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	MIR_LoadUpdate.getClearOffset(Instruction i) Get the operand called Offset from the argument instruction clearing its instruction pointer.
static Operand	MIR_CondCall.getClearParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction clearing its instruction pointer.
static Operand	MIR_Call.getClearParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction clearing its instruction pointer.
static Operand	MIR_RotateAndMask.getClearShift(Instruction i) Get the operand called Shift from the argument instruction clearing its instruction pointer.
static Operand	MIR_Unary.getClearValue(Instruction i) Get the operand called Value from the argument instruction clearing its instruction pointer.
static Operand	MIR_Trap.getClearValue2(Instruction i) Get the operand called Value2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_Binary.getClearValue2(Instruction i) Get the operand called Value2 from the argument instruction clearing its instruction pointer.
static Operand	MIR_StoreUpdate.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	MIR_Load.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	MIR_Store.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	MIR_LoadUpdate.getGuard(Instruction i) Get the operand called Guard from the argument instruction.
static Operand	MIR_StoreUpdate.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	MIR_Load.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	MIR_Store.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	MIR_LoadUpdate.getOffset(Instruction i) Get the operand called Offset from the argument instruction.
static Operand	MIR_CondCall.getParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction.
static Operand	MIR_Call.getParam(Instruction i, int k) Get the k'th operand called Param from the argument instruction.
static Operand	MIR_RotateAndMask.getShift(Instruction i) Get the operand called Shift from the argument instruction.
static Operand	MIR_Unary.getValue(Instruction i) Get the operand called Value from the argument instruction.
static Operand	MIR_Trap.getValue2(Instruction i) Get the operand called Value2 from the argument instruction.
static Operand	MIR_Binary.getValue2(Instruction i) Get the operand called Value2 from the argument instruction.
Operand	RegisterPool.makeJTOCOp()
Operand	RegisterPool.makeTocOp()

Methods in org.jikesrvm.compilers.opt.ir.ppc with parameters of type Operand

Modifier and Type	Method and Description
static Instruction	MIR_Trap.create(Operator o, org.jikesrvm.compilers.opt.ir.operand.ppc.PowerPCTrapOperand Cond, RegisterOperand Value1, Operand Value2, TrapCodeOperand TCode) Create an instruction of the MIR_Trap instruction format.
static Instruction	MIR_Unary.create(Operator o, RegisterOperand Result, Operand Value) Create an instruction of the MIR_Unary instruction format.
static Instruction	MIR_Trap.create(Operator o, RegisterOperand GuardResult, org.jikesrvm.compilers.opt.ir.operand.ppc.PowerPCTrapOperand Cond, RegisterOperand Value1, Operand Value2, TrapCodeOperand TCode) Create an instruction of the MIR_Trap instruction format.
static Instruction	MIR_StoreUpdate.create(Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset) Create an instruction of the MIR_StoreUpdate instruction format.
static Instruction	MIR_Load.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset) Create an instruction of the MIR_Load instruction format.
static Instruction	MIR_Store.create(Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset) Create an instruction of the MIR_Store instruction format.
static Instruction	MIR_LoadUpdate.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset) Create an instruction of the MIR_LoadUpdate instruction format.
static Instruction	MIR_Binary.create(Operator o, RegisterOperand Result, RegisterOperand Value1, Operand Value2) Create an instruction of the MIR_Binary instruction format.
static Instruction	MIR_RotateAndMask.create(Operator o, RegisterOperand Result, RegisterOperand Value, Operand Shift, IntConstantOperand MaskBegin, IntConstantOperand MaskEnd) Create an instruction of the MIR_RotateAndMask instruction format.
static Instruction	MIR_StoreUpdate.create(Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset, LocationOperand Location) Create an instruction of the MIR_StoreUpdate instruction format.
static Instruction	MIR_Load.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location) Create an instruction of the MIR_Load instruction format.
static Instruction	MIR_Store.create(Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset, LocationOperand Location) Create an instruction of the MIR_Store instruction format.
static Instruction	MIR_LoadUpdate.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location) Create an instruction of the MIR_LoadUpdate instruction format.
static Instruction	MIR_StoreUpdate.create(Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the MIR_StoreUpdate instruction format.
static Instruction	MIR_Load.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the MIR_Load instruction format.
static Instruction	MIR_Store.create(Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the MIR_Store instruction format.
static Instruction	MIR_LoadUpdate.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location, Operand Guard) Create an instruction of the MIR_LoadUpdate instruction format.
static Instruction	MIR_StoreUpdate.create(Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset, Operand Guard) Create an instruction of the MIR_StoreUpdate instruction format.
static Instruction	MIR_Load.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, Operand Guard) Create an instruction of the MIR_Load instruction format.
static Instruction	MIR_Store.create(Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset, Operand Guard) Create an instruction of the MIR_Store instruction format.
static Instruction	MIR_LoadUpdate.create(Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, Operand Guard) Create an instruction of the MIR_LoadUpdate instruction format.
static Instruction	MIR_RotateAndMask.create(Operator o, RegisterOperand Result, RegisterOperand Source, RegisterOperand Value, Operand Shift, IntConstantOperand MaskBegin, IntConstantOperand MaskEnd) Create an instruction of the MIR_RotateAndMask instruction format.
static Instruction	MIR_Trap.mutate(Instruction i, Operator o, org.jikesrvm.compilers.opt.ir.operand.ppc.PowerPCTrapOperand Cond, RegisterOperand Value1, Operand Value2, TrapCodeOperand TCode) Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
static Instruction	MIR_Unary.mutate(Instruction i, Operator o, RegisterOperand Result, Operand Value) Mutate the argument instruction into an instruction of the MIR_Unary instruction format having the specified operator and operands.
static Instruction	MIR_Trap.mutate(Instruction i, Operator o, RegisterOperand GuardResult, org.jikesrvm.compilers.opt.ir.operand.ppc.PowerPCTrapOperand Cond, RegisterOperand Value1, Operand Value2, TrapCodeOperand TCode) Mutate the argument instruction into an instruction of the MIR_Trap instruction format having the specified operator and operands.
static Instruction	MIR_StoreUpdate.mutate(Instruction i, Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset) Mutate the argument instruction into an instruction of the MIR_StoreUpdate instruction format having the specified operator and operands.
static Instruction	MIR_Load.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset) Mutate the argument instruction into an instruction of the MIR_Load instruction format having the specified operator and operands.
static Instruction	MIR_Store.mutate(Instruction i, Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset) Mutate the argument instruction into an instruction of the MIR_Store instruction format having the specified operator and operands.
static Instruction	MIR_LoadUpdate.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset) Mutate the argument instruction into an instruction of the MIR_LoadUpdate instruction format having the specified operator and operands.
static Instruction	MIR_Binary.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Value1, Operand Value2) Mutate the argument instruction into an instruction of the MIR_Binary instruction format having the specified operator and operands.
static Instruction	MIR_RotateAndMask.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Value, Operand Shift, IntConstantOperand MaskBegin, IntConstantOperand MaskEnd) Mutate the argument instruction into an instruction of the MIR_RotateAndMask instruction format having the specified operator and operands.
static Instruction	MIR_StoreUpdate.mutate(Instruction i, Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the MIR_StoreUpdate instruction format having the specified operator and operands.
static Instruction	MIR_Load.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the MIR_Load instruction format having the specified operator and operands.
static Instruction	MIR_Store.mutate(Instruction i, Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the MIR_Store instruction format having the specified operator and operands.
static Instruction	MIR_LoadUpdate.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location) Mutate the argument instruction into an instruction of the MIR_LoadUpdate instruction format having the specified operator and operands.
static Instruction	MIR_StoreUpdate.mutate(Instruction i, Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the MIR_StoreUpdate instruction format having the specified operator and operands.
static Instruction	MIR_Load.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the MIR_Load instruction format having the specified operator and operands.
static Instruction	MIR_Store.mutate(Instruction i, Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the MIR_Store instruction format having the specified operator and operands.
static Instruction	MIR_LoadUpdate.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, LocationOperand Location, Operand Guard) Mutate the argument instruction into an instruction of the MIR_LoadUpdate instruction format having the specified operator and operands.
static Instruction	MIR_StoreUpdate.mutate(Instruction i, Operator o, RegisterOperand Address, RegisterOperand Value, Operand Offset, Operand Guard) Mutate the argument instruction into an instruction of the MIR_StoreUpdate instruction format having the specified operator and operands.
static Instruction	MIR_Load.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, Operand Guard) Mutate the argument instruction into an instruction of the MIR_Load instruction format having the specified operator and operands.
static Instruction	MIR_Store.mutate(Instruction i, Operator o, RegisterOperand Value, RegisterOperand Address, Operand Offset, Operand Guard) Mutate the argument instruction into an instruction of the MIR_Store instruction format having the specified operator and operands.
static Instruction	MIR_LoadUpdate.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Address, Operand Offset, Operand Guard) Mutate the argument instruction into an instruction of the MIR_LoadUpdate instruction format having the specified operator and operands.
static Instruction	MIR_RotateAndMask.mutate(Instruction i, Operator o, RegisterOperand Result, RegisterOperand Source, RegisterOperand Value, Operand Shift, IntConstantOperand MaskBegin, IntConstantOperand MaskEnd) Mutate the argument instruction into an instruction of the MIR_RotateAndMask instruction format having the specified operator and operands.
static void	MIR_StoreUpdate.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	MIR_Load.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	MIR_Store.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	MIR_LoadUpdate.setGuard(Instruction i, Operand Guard) Set the operand called Guard in the argument instruction to the argument operand.
static void	MIR_StoreUpdate.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	MIR_Load.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	MIR_Store.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	MIR_LoadUpdate.setOffset(Instruction i, Operand Offset) Set the operand called Offset in the argument instruction to the argument operand.
static void	MIR_CondCall.setParam(Instruction i, int k, Operand o) Set the k'th operand called Param in the argument instruction to the argument operand.
static void	MIR_Call.setParam(Instruction i, int k, Operand o) Set the k'th operand called Param in the argument instruction to the argument operand.
static void	MIR_RotateAndMask.setShift(Instruction i, Operand Shift) Set the operand called Shift in the argument instruction to the argument operand.
static void	MIR_Unary.setValue(Instruction i, Operand Value) Set the operand called Value in the argument instruction to the argument operand.
static void	MIR_Trap.setValue2(Instruction i, Operand Value2) Set the operand called Value2 in the argument instruction to the argument operand.
static void	MIR_Binary.setValue2(Instruction i, Operand Value2) Set the operand called Value2 in the argument instruction to the argument operand.

Uses of Operand in org.jikesrvm.compilers.opt.lir2mir

Methods in org.jikesrvm.compilers.opt.lir2mir with parameters of type Operand

Modifier and Type	Method and Description
protected static AddressConstantOperand	BURS_Common_Helpers.AC(Operand op)
protected void	BURS_MemOp_Helpers.augmentAddress(Operand op)
protected static Address	BURS_Common_Helpers.AV(Operand op)
protected MemoryOperand	BURS_MemOp_Helpers.consumeAddress(byte size, LocationOperand loc, Operand guard)
protected static int	BURS_Common_Helpers.FITS(Operand op, int numBits, int trueCost)
protected static int	BURS_Common_Helpers.FITS(Operand op, int numBits, int trueCost, int falseCost)
protected static IntConstantOperand	BURS_Common_Helpers.IC(Operand op)
protected static int	BURS_Common_Helpers.IV(Operand op)
protected static LongConstantOperand	BURS_Common_Helpers.LC(Operand op)
protected static long	BURS_Common_Helpers.LV(Operand op)
protected static boolean	BURS_Common_Helpers.MINUSONE(Operand a)
private MemoryOperand	BURS_MemOp_Helpers.MO_ARRAY(Operand base, Operand index, byte scale, byte size, Offset disp, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO_B(Operand base, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO_BD(Operand base, Offset disp, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO_BI(Operand base, Operand index, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO_BID(Operand base, Operand index, Offset disp, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO_BIS(Operand base, Operand index, byte scale, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO_D(Offset disp, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO(Operand base, Operand offset, byte size, LocationOperand loc, Operand guard)
protected MemoryOperand	BURS_MemOp_Helpers.MO(Operand base, Operand offset, byte size, LocationOperand loc, Operand guard, int disp)
protected MemoryOperand	BURS_MemOp_Helpers.MO(Operand base, Operand offset, byte size, Offset disp, LocationOperand loc, Operand guard)
protected static boolean	BURS_Common_Helpers.ONE(Operand a)
protected static RegisterOperand	BURS_Common_Helpers.R(Operand op)
protected static boolean	BURS_Common_Helpers.ZERO(Operand a)

Uses of Operand in org.jikesrvm.compilers.opt.lir2mir.ia32

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 that return Operand

Modifier and Type	Method and Description
private Operand	BURS_Helpers.asReg(Instruction s, Operator movop, Operand op) Emits code to move the operand into a register operand if it isn't one already.
protected static Operand	BURS_Helpers.follow(Operand use) Follow a chain of Move operations filtering back to a def
protected Operand	BURS_Helpers.MO_CONV(byte size) Create a slot on the stack in memory for a conversion
protected Operand	BURS_Helpers.myFP0()
protected Operand	BURS_Helpers.myFP1()
private static Operand	NormalizeConstants.wordOperandForReference(Word w)

Methods in org.jikesrvm.compilers.opt.lir2mir.ia32 with parameters of type Operand

Modifier and Type	Method and Description
private Operand	BURS_Helpers.asReg(Instruction s, Operator movop, Operand op) Emits code to move the operand into a register operand if it isn't one already.
protected void	BURS_Helpers.ATTEMPT_IFCMP(MemoryOperand mo, Operand oldValue, Operand newValue, ConditionOperand cond, BranchOperand target, BranchProfileOperand bp) This routine expands the compound pattern IFCMP(ATTEMPT, ZERO) into an atomic compare/exchange followed by a branch on success/failure of the attempted atomic compare/exchange.
protected void	BURS_Helpers.ATTEMPT_LONG(RegisterOperand result, MemoryOperand mo, Operand oldValue, Operand newValue) This routine expands an ATTEMPT instruction into an atomic compare exchange.
protected void	BURS_Helpers.ATTEMPT(RegisterOperand result, MemoryOperand mo, Operand oldValue, Operand newValue) This routine expands an ATTEMPT instruction into an atomic compare exchange.
private static void	ComplexLIR2MIRExpansion.basic_long_ifcmp(Instruction s, IR ir, ConditionOperand cond, Register xh, Register xl, Operand yh, Operand yl)
protected void	BURS_Helpers.BOOLEAN_CMP_DOUBLE(Instruction s, RegisterOperand res, ConditionOperand cond, Operand val1, Operand val2) Expansion of BOOLEAN_CMP_DOUBLE
protected void	BURS_Helpers.BOOLEAN_CMP_INT(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond) Expansion of BOOLEAN_CMP_INT
protected void	BURS_Helpers.BOOLEAN_CMP_LONG(Instruction s, RegisterOperand res, Operand val1, Operand val2, ConditionOperand cond) Expansion of BOOLEAN_CMP_LONG
protected void	BURS_Helpers.CALL(Instruction s, Operand address) Expansion of CALL.
protected void	BURS_Helpers.CMOV_FMOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue) Generate a floating point move portion of a conditional move.
protected void	BURS_Helpers.CMOV_MOV(Instruction s, RegisterOperand result, ConditionOperand cond, Operand trueValue, Operand falseValue) Generate an integer move portion of a conditional move.
protected void	BURS_Helpers.EMIT_Commutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2) Create the MIR instruction given by operator from the Binary LIR operands
protected void	BURS_Helpers.EMIT_Compare(Instruction s, ConditionOperand cond, Operand val1, Operand val2) Gives the MIR condition operator appropriate for the given condition
protected void	BURS_Helpers.EMIT_LongBinary(Operator operator1, Operator operator2, Instruction s, Operand result, Operand value1, Operand value2, boolean commutative) Creates the MIR instruction given by the operators from the Binary LIR operands
protected void	BURS_Helpers.EMIT_LongUnary(Instruction s, Operand result, Operand value1, boolean negOrNot) Creates the MIR instruction for LONG_NEG or LONG_NOT
protected void	BURS_Helpers.EMIT_NonCommutative(Operator operator, Instruction s, Operand result, Operand val1, Operand val2) Create the MIR instruction given by operator from the Binary LIR operands
protected void	BURS_Helpers.EMIT_Unary(Operator operator, Instruction s, Operand result, Operand value) Create the MIR instruction given by operator from the Binary LIR operands
protected static Operand	BURS_Helpers.follow(Operand use) Follow a chain of Move operations filtering back to a def
protected void	BURS_Helpers.FP_MOV_OP_MOV(Instruction s, Operator op, Operand result, Operand val1, Operand val2) Expansion of FP_ADD_ACC, FP_MUL_ACC, FP_SUB_ACC, and FP_DIV_ACC.
protected void	BURS_Helpers.FP_REM(Instruction s, Operand val1, Operand val2) Expansion of FP_REM
protected void	BURS_Helpers.FPR_2INT(Instruction s, RegisterOperand result, Operand value) Expansion of FLOAT_2INT and DOUBLE_2INT, using the FIST instruction.
protected void	BURS_Helpers.IFCMP(Instruction s, RegisterOperand guardResult, Operand val1, Operand val2, ConditionOperand cond) Generate a compare and branch sequence.
protected void	BURS_Helpers.INT_2LONG(Instruction s, RegisterOperand result, Operand value, boolean signExtend) Expansion of INT_2LONG
protected void	BURS_Helpers.INT_DIVIDES(Instruction s, RegisterOperand result, Operand val1, Operand val2, boolean isDiv, boolean signed) Expansion of INT_DIV, SIGNED_DIV_64_32, UNSIGNED_DIV_64_32 and INT_REM
protected void	BURS_Helpers.INT_TO_LONG_MUL(Instruction s, RegisterOperand result, Operand value1, Operand value2, boolean signed) Expansion of LONG_MULs whose operands are ints
protected void	BURS_Helpers.LCMP_CMOV(Instruction s, RegisterOperand result, Operand val1, Operand val2, ConditionOperand cond, Operand trueValue, Operand falseValue) Generate a long compare and cmov
protected byte	BURS_Helpers.LEA_SHIFT(Operand op)
protected static int	BURS_Helpers.LEA_SHIFT(Operand op, int trueCost) Can an IV be the scale in a LEA instruction?
protected static int	BURS_Helpers.LEA_SHIFT(Operand op, int trueCost, int falseCost) Can an IV be the scale in a LEA instruction?
protected void	BURS_Helpers.LONG_CMP(Instruction s, RegisterOperand res, Operand val1, Operand val2) Expansion of LONG_CMP: compare to values and set result to -1, 0, 1 for <, =, >, respectively
protected void	BURS_Helpers.LONG_DIVIDES(Instruction s, RegisterOperand result, Operand val1, Operand val2, boolean isDiv, boolean signed) Expansion of LONG_DIV and LONG_REM
protected void	BURS_Helpers.LONG_MUL(Instruction s, RegisterOperand result, Operand value1, Operand value2) Expansion of LONG_MUL
protected void	BURS_Helpers.LONG_SHL(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f) Expansion of LONG_SHL
protected void	BURS_Helpers.LONG_SHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f) Expansion of LONG_SHR
protected void	BURS_Helpers.LONG_USHR(Instruction s, Operand result, Operand val1, Operand val2, boolean maskWith3f) Expansion of LONG_USHR
protected static boolean	BURS_Helpers.SIMILAR_REGISTERS(Operand... ops)
protected void	BURS_Helpers.SSE2_ABS(boolean single, Instruction s, Operand result, Operand value)
protected void	BURS_Helpers.SSE2_CONV(Operator op, Instruction s, Operand result, Operand value) Expansion of SSE2 conversions double <-> float
protected void	BURS_Helpers.SSE2_COP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2) BURS expansion of a commutative SSE2 operation.
protected void	BURS_Helpers.SSE2_FCMP_FCMOV(Instruction s, RegisterOperand result, Operand lhsCmp, Operand rhsCmp, ConditionOperand cond, Operand trueValue, Operand falseValue)
protected void	BURS_Helpers.SSE2_IFCMP(Operator op, Instruction s, Operand val1, Operand val2) Expansion of SSE2 comparison operations
protected Operator	BURS_Helpers.SSE2_MOVE(Operand o) Returns the appropriate move operator based on the type of operand.
protected void	BURS_Helpers.SSE2_NCOP(Operator operator, Instruction s, Operand result, Operand val1, Operand val2) BURS expansion of a non commutative SSE2 operation.
protected void	BURS_Helpers.SSE2_NEG(boolean single, Instruction s, Operand result, Operand value) Expansion of SSE2 negation ops.
protected byte	BURS_Helpers.SSE2_SIZE(Operand o) Returns the size based on the type of operand.
protected void	BURS_Helpers.STORE_LONG_FOR_CONV(Operand op) Creates a 64bit slot on the stack in memory for a conversion and stores the given long.
protected void	BURS_Helpers.SYSCALL(Instruction s, Operand address) Expansion of SYSCALL.

Uses of Operand in org.jikesrvm.compilers.opt.mir2mc.ia32

Methods in org.jikesrvm.compilers.opt.mir2mc.ia32 with parameters of type Operand

Modifier and Type	Method and Description
(package private) RegisterConstants.GPR	AssemblerBase.getBase(Operand op) Given a memory operand, return the 3 bit IA32 ISA encoding of its base regsiter.
(package private) byte	AssemblerBase.getCond(Operand op) Return the condition bits of a given optimizing compiler condition operand.
(package private) Offset	AssemblerBase.getDisp(Operand op) Given a memory operand, return the 2 bit IA32 ISA encoding of its scale, suitable for passing to the Assembler to mask into a SIB byte.
(package private) RegisterConstants.FPR	AssemblerBase.getFPR_Reg(Operand op)
(package private) RegisterConstants.GPR	AssemblerBase.getGPR_Reg(Operand op)
(package private) int	AssemblerBase.getImm(Operand op) Return the IA32 ISA encoding of the immediate value represented by the the given operand.
(package private) long	AssemblerBase.getImmQuad(Operand op) Return the IA32 ISA encoding of the immediate value represented by the the given operand.
(package private) RegisterConstants.GPR	AssemblerBase.getIndex(Operand op) Given a memory operand, return the 3 bit IA32 ISA encoding of its index register.
(package private) int	AssemblerBase.getLabel(Operand op) Return the label representing the target of the given branch operand.
(package private) RegisterConstants.MM	AssemblerBase.getMM_Reg(Operand op)
(package private) MachineRegister	AssemblerBase.getReg(Operand op) Given a register operand, return the 3 bit IA32 ISA encoding of that register.
(package private) short	AssemblerBase.getScale(Operand op) Given a memory operand, return the 2 bit IA32 ISA encoding of its scale, suitable for passing to the Assembler to mask into a SIB byte.
(package private) RegisterConstants.XMM	AssemblerBase.getXMM_Reg(Operand op)
(package private) boolean	AssemblerBase.isAbs(Operand op) Determine if a given operand is a memory operand representing absolute mode addressing.
(package private) boolean	AssemblerBase.isCond(Operand op) Is the given operand an IA32 condition operand?
(package private) boolean	AssemblerBase.isFPR_Reg(Operand op)
(package private) boolean	AssemblerBase.isGPR_Reg(Operand op)
(package private) boolean	AssemblerBase.isImm(Operand op) Is the given operand an immediate?
(package private) boolean	AssemblerBase.isImmOrLabel(Operand op) Is the given operand a branch target?
(package private) boolean	AssemblerBase.isLabel(Operand op) Is the given operand a branch target that requires a label?
(package private) boolean	AssemblerBase.isMM_Reg(Operand op)
(package private) boolean	AssemblerBase.isReg(Operand op) Is the given operand a register operand?
(package private) boolean	AssemblerBase.isRegDisp(Operand op) Determine if a given operand is a memory operand representing register-displacement mode addressing.
(package private) boolean	AssemblerBase.isRegIdx(Operand op) Determine if a given operand is a memory operand representing the full glory of scaled-index-base addressing.
(package private) boolean	AssemblerBase.isRegInd(Operand op) Determine if a given operand is a memory operand representing register-indirect mode addressing.
(package private) boolean	AssemblerBase.isRegOff(Operand op) Determine if a given operand is a memory operand representing register-offset mode addressing.
(package private) boolean	AssemblerBase.isXMM_Reg(Operand op)
private int	AssemblerBase.operandCost(Operand op, boolean shortFormImmediate)

Uses of Operand in org.jikesrvm.compilers.opt.regalloc.ia32

Methods in org.jikesrvm.compilers.opt.regalloc.ia32 with parameters of type Operand

Modifier and Type	Method and Description
private static boolean	CallingConvention.paramIsNativeLongOn64Bit(Operand param)

Uses of Operand in org.jikesrvm.compilers.opt.ssa

Fields in org.jikesrvm.compilers.opt.ssa declared as Operand

Modifier and Type	Field and Description
(package private) Operand	LeaveSSA.Copy.source The right-hand side of the copy instruction

Methods in org.jikesrvm.compilers.opt.ssa that return Operand

Modifier and Type	Method and Description
private Operand	ValueGraph.bypassMoves(Operand op) Bypass MOVE instructions that def an operand: return the first def in the chain that is not the result of a MOVE instruction.
private Operand	LoopVersioning.getConstantAdjustedArrayLengthRef(Operand op) Gets the array length reference ignoring instructions that adjust its result by a fixed amount.
(package private) Operand	LICM.getResult(Instruction inst)
(package private) Operand	LeaveSSA.VariableStacks.peek(Register s) Get the name at the top of the stack for a particular register
(package private) Operand	LeaveSSA.VariableStacks.pop(Register s) Pop the name at the top of the stack for a particular register

Methods in org.jikesrvm.compilers.opt.ssa with parameters of type Operand

Modifier and Type	Method and Description
(package private) static void	LoadElimination.appendMove(Register r, Operand src, Instruction store) Append a move instruction after a store instruction that caches value in register r.
private Operand	ValueGraph.bypassMoves(Operand op) Bypass MOVE instructions that def an operand: return the first def in the chain that is not the result of a MOVE instruction.
(package private) Instruction	LICM.definingInstruction(Operand op)
private BasicBlock	LoopVersioning.generateExplicitBoundCheck(Instruction boundCheckInstr, Operand minIndexValue, Operand maxIndexValue, HashMap<Register,Register> optimalRegMap, BasicBlock block, BasicBlock unoptimizedLoopEntry) Generate bound check branch blocks
private int	LoopVersioning.getConstantAdjustedArrayLengthDistance(Operand op) Get the distance from an array length by addding up instructions that adjust the array length result by a constant amount
private Operand	LoopVersioning.getConstantAdjustedArrayLengthRef(Operand op) Gets the array length reference ignoring instructions that adjust its result by a fixed amount.
(package private) void	LeaveSSA.VariableStacks.push(Register s, Operand name) Push a name at the top of the stack for a particular register
(package private) BasicBlock	LICM.useBlock(Instruction use, Operand op)
private boolean	LICM.useDominates(Operand op, BasicBlock block)

Method parameters in org.jikesrvm.compilers.opt.ssa with type arguments of type Operand

Modifier and Type	Method and Description
private Instruction	LICM.scheduleScalarDefsEarly(Enumeration<Operand> e, Instruction earlyPos, Instruction inst) Schedules an instruction as early as possible, but behind the definitions in e and behind earlyPos

Uses of Operand in org.jikesrvm.osr

Fields in org.jikesrvm.osr declared as Operand

Modifier and Type	Field and Description
Operand	LocalRegPair.operand What's the register operand, from which we can get the symbolic register.

Constructors in org.jikesrvm.osr with parameters of type Operand

Constructor and Description
LocalRegPair(boolean kind, int num, byte type, Operand op)