org.jruby.ir.operands

Class Operand

java.lang.Object

org.jruby.ir.operands.Operand

Direct Known Subclasses:

Array, AsString, CurrentScope, DynamicSymbol, Hash, ImmutableLiteral, IRException, Label, ObjectClass, Reference, ScopeModule, Splat, StandardError, StringLiteral, SValue, UndefinedValue, Variable, WrappedIRClosure

public abstract class Operand
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
static Operand[]	EMPTY_ARRAY

Constructor Summary

Constructors

Constructor and Description
Operand()

Method Summary

Methods

Modifier and Type	Method and Description
abstract void	addUsedVariables(List<Variable> l) Append the list of variables used in this operand to the input list -- force every operand to implement this because a missing implementation can cause bad failures.
boolean	canCopyPropagate() Can we replace every use of a variable 'v' that contains the value of this operand with the operand itself? This takes importance when there are at least two uses of 'v' within this scope.
abstract Operand	cloneForInlining(CloneInfo ii)
void	encode(IRWriterEncoder e)
abstract OperandType	getOperandType()
Operand	getSimplifiedOperand(Map<Operand,Operand> valueMap, boolean force)
Operand	getValue(Map<Operand,Operand> valueMap)
boolean	hasKnownValue() Do we know the value of this operand at compile-time? If we do then it may be possible to constant propagate (one case: We also know it is also an ImmutableLiteral).
Object	retrieve(ThreadContext context, IRubyObject self, StaticScope currScope, DynamicScope currDynScope, Object[] temp)
void	visit(IRVisitor visitor)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

EMPTY_ARRAY

public static final Operand[] EMPTY_ARRAY

Constructor Detail

Operand

public Operand()

Method Detail

getOperandType

public abstract OperandType getOperandType()

hasKnownValue

public boolean hasKnownValue()

Do we know the value of this operand at compile-time? If we do then it may be possible to constant propagate (one case: We also know it is also an ImmutableLiteral).

Returns:

true if a known compile-time value.

canCopyPropagate

public boolean canCopyPropagate()

Can we replace every use of a variable 'v' that contains the value of this operand with the operand itself? This takes importance when there are at least two uses of 'v' within this scope. Ex: v = [1,2,3]; x = v; y = v In this case, we cannot replace the occurences of 'v' because we would then get x = [1,2,3]; y = [1,2,3] which would then result in two different array objects being constructed instead of a single one.

Returns:

true if it is safe to copy-propagate the operand.

getSimplifiedOperand

public Operand getSimplifiedOperand(Map<Operand,Operand> valueMap,
                           boolean force)

getValue

public Operand getValue(Map<Operand,Operand> valueMap)

addUsedVariables

public abstract void addUsedVariables(List<Variable> l)

Append the list of variables used in this operand to the input list -- force every operand to implement this because a missing implementation can cause bad failures.

cloneForInlining

public abstract Operand cloneForInlining(CloneInfo ii)

encode

public void encode(IRWriterEncoder e)

retrieve

public Object retrieve(ThreadContext context,
              IRubyObject self,
              StaticScope currScope,
              DynamicScope currDynScope,
              Object[] temp)

visit

public void visit(IRVisitor visitor)