org.jruby.ir.operands

Class ImmutableLiteral

java.lang.Object

org.jruby.ir.operands.Operand

org.jruby.ir.operands.ImmutableLiteral

Direct Known Subclasses:

Bignum, BooleanLiteral, Fixnum, Float, Nil

public abstract class ImmutableLiteral
extends Operand

Operands extending this type can make a reasonable assumption of immutability. In Ruby, almost nothing is truly immutable (set_instance_var) but for the sake of our compiler we can assume the basic behavior will continue to work unchanged (the value of an instance of fixnum 3 will remain 3). Knowing that we have a literal which will not change can be used for optimizations like constant propagation. ENEBO: This cachedObject thing obviously cannot be used from multiple threads without some safety being added. This probably also is not the fastest code, but it is very simple. It would be really nice to make this side-effect free as well, but this is difficult without adding a level of indirection or pre-caching each value we encounter during construction.

Field Summary

Fields

Modifier and Type	Field and Description
private java.lang.Object	cachedObject

Fields inherited from class org.jruby.ir.operands.Operand

EMPTY_ARRAY

Constructor Summary

Constructors

Constructor and Description
ImmutableLiteral()

Method Summary

Modifier and Type	Method and Description
void	addUsedVariables(java.util.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.
java.lang.Object	cachedObject(ThreadContext context) Returns the cached object.
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.
Operand	cloneForInlining(InlinerInfo ii)
abstract java.lang.Object	createCacheObject(ThreadContext context) Implementing class is responsible for constructing the cached value.
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).
boolean	isCached() Has this object already been cached?
java.lang.Object	retrieve(ThreadContext context, IRubyObject self, DynamicScope currDynScope, java.lang.Object[] temp) retrieve the live value represented by this immutable literal.

Methods inherited from class org.jruby.ir.operands.Operand

fetchCompileTimeArrayElement, getSimplifiedOperand, getValue, visit

Methods inherited from class java.lang.Object

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

Field Detail

cachedObject

private java.lang.Object cachedObject

Constructor Detail

ImmutableLiteral

public ImmutableLiteral()

Method Detail

hasKnownValue

public boolean hasKnownValue()

Description copied from class: Operand

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).

Overrides:

hasKnownValue in class Operand

Returns:

true if a known compile-time value.

canCopyPropagate

public boolean canCopyPropagate()

Description copied from class: Operand

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.

Overrides:

canCopyPropagate in class Operand

Returns:

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

addUsedVariables

public void addUsedVariables(java.util.List<Variable> l)

Description copied from class: Operand

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.

Specified by:

addUsedVariables in class Operand

cloneForInlining

public Operand cloneForInlining(InlinerInfo ii)

Specified by:

cloneForInlining in class Operand

createCacheObject

public abstract java.lang.Object createCacheObject(ThreadContext context)

Implementing class is responsible for constructing the cached value.

cachedObject

public java.lang.Object cachedObject(ThreadContext context)

Returns the cached object. If not then it asks class to create an object to cache.

isCached

public boolean isCached()

Has this object already been cached?

retrieve

public java.lang.Object retrieve(ThreadContext context,
                                 IRubyObject self,
                                 DynamicScope currDynScope,
                                 java.lang.Object[] temp)

retrieve the live value represented by this immutable literal. An interesting property of knowing something cannot change at compile time is that all information neccesary to construct it is also known at compile time. We don't pre-create these since we don't want to assume the cost of constructing literals which may never be used.

Overrides:

retrieve in class Operand