IRScope (JRuby Core 9.2.0.0 API)

java.lang.Object
- org.jruby.ir.IRScope

All Implemented Interfaces:

ParseResult

Direct Known Subclasses:

IRClosure, IRMethod, IRModuleBody, IRScriptBody
```
public abstract class IRScope
extends java.lang.Object
implements ParseResult
```
Right now, this class abstracts the following execution scopes: Method, Closure, Module, Class, MetaClass Top-level Script, and Eval Script In the compiler-land, IR versions of these scopes encapsulate only as much information as is required to convert Ruby code into equivalent Java code. But, in the non-compiler land, there will be a corresponding java object for some of these scopes which encapsulates the runtime semantics and data needed for implementing them. In the case of Module, Class, MetaClass, and Method, they also happen to be instances of the corresponding Ruby classes -- so, in addition to providing code that help with this specific ruby implementation, they also have code that let them behave as ruby instances of their corresponding classes. Examples: - the runtime class object might have refs. to the runtime method objects. - the runtime method object might have a slot for a heap frame (for when it has closures that need access to the method's local variables), it might have version information, it might have references to other methods that were optimized with the current version number, etc. - the runtime closure object will have a slot for a heap frame (for when it has closures within) and might get reified as a method in the java land (but inaccessible in ruby land). So, passing closures in Java land might be equivalent to passing around the method handles. and so on ...

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`booleanVariableIndex`
`protected int`	`fixnumVariableIndex`
`protected int`	`floatVariableIndex`
`protected FullInterpreterContext`	`fullInterpreterContext` -X-C full interpretation OR JIT depends on this
`protected InterpreterContext`	`interpreterContext` Startup interpretation depends on this
`static Logger`	`LOG`
`protected int`	`temporaryVariableIndex`
`protected int`	`threadPollInstrsCount` # of thread poll instrs added to this scope

Constructor Summary

Constructors
Modifier	Constructor and Description
	`IRScope(IRManager manager, IRScope lexicalParent, RubySymbol name, int lineNumber, StaticScope staticScope)`
`protected`	`IRScope(IRScope s, IRScope lexicalParent)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addChildScope(IRScope scope)`
`void`	`addClosure(IRClosure closure)`
`InterpreterContext`	`allocateInterpreterContext(java.util.concurrent.Callable<java.util.List<Instr>> instructions)` Make version specific to scope which needs it (e.g.
`InterpreterContext`	`allocateInterpreterContext(java.util.List<Instr> instructions)` Make version specific to scope which needs it (e.g.
`protected int`	`allocateNextPrefixedName(java.lang.String prefix)`
`boolean`	`bindingHasEscaped()`
`java.util.Map<BasicBlock,Label>`	`buildJVMExceptionTable()`
`boolean`	`canReceiveNonlocalReturns()`
`void`	`computeScopeFlags()` Calculate scope flags used by various passes to know things like whether a binding has escaped.
`void`	`computeScopeFlagsEarly(java.util.List<Instr> instructions)` This is called when building an IRMethod before it has completed the build and made an IC yet.
`TemporaryLocalVariable`	`createTemporaryVariable()`
`java.lang.String`	`debugOutput()`
`boolean`	`definesLocalVariable(Variable v)`
`protected void`	`depends(java.lang.Object obj)`
`IGVDumper`	`dumpToIGV()`
`boolean`	`equals(java.lang.Object other)`
`protected LocalVariable`	`findExistingLocalVariable(RubySymbol name, int depth)`
`java.util.List<IRClosure>`	`getBeginBlocks()`
`int`	`getBooleanVariablesCount()`
`CFG`	`getCFG()`
`java.util.Collection<IRClosure>`	`getClosures()`
`Variable`	`getCurrentModuleVariable()`
`Variable`	`getCurrentScopeVariable()`
`java.util.List<IRClosure>`	`getEndBlocks()`
`java.util.List<CompilerPass>`	`getExecutedPasses()`
`FullInterpreterContext`	`getExecutionContext()`
`java.lang.String`	`getFileName()`
`int`	`getFixnumVariablesCount()`
`java.util.EnumSet<IRFlags>`	`getFlags()`
`int`	`getFloatVariablesCount()`
`FullInterpreterContext`	`getFullInterpreterContext()`
`java.lang.String`	`getFullyQualifiedName()`
`java.lang.String`	`getId()`
`InterpreterContext`	`getInterpreterContext()`
`IRScope`	`getLexicalParent()` Returns the lexical scope that contains this scope definition
`java.util.List<IRScope>`	`getLexicalScopes()`
`int`	`getLineNumber()`
`LiveVariablesProblem`	`getLiveVariablesProblem()`
`LocalVariable`	`getLocalVariable(RubySymbol name, int scopeDepth)` Find or create a local variable.
`java.util.Map<RubySymbol,LocalVariable>`	`getLocalVariables()` Get the local variables for this scope.
`int`	`getLocalVariablesCount()`
`IRManager`	`getManager()`
`RubySymbol`	`getName()`
`IRScope`	`getNearestFlipVariableScope()`
`IRMethod`	`getNearestMethod()`
`int`	`getNearestModuleReferencingScopeDepth()` Returns the nearest scope which we can extract a live module from.
`IRScope`	`getNearestTopLocalVariableScope()`
`LocalVariable`	`getNewFlipStateVariable()`
`Variable`	`getNewInlineVariable(org.jruby.util.ByteList inlinePrefix, Variable v)`
`Label`	`getNewLabel()`
`Label`	`getNewLabel(java.lang.String prefix)`
`LocalVariable`	`getNewLocalVariable(RubySymbol name, int scopeDepth)`
`TemporaryLocalVariable`	`getNewTemporaryVariable(TemporaryVariableType type)`
`TemporaryLocalVariable`	`getNewTemporaryVariableFor(LocalVariable var)`
`TemporaryLocalVariable`	`getNewUnboxedVariable(java.lang.Class type)`
`int`	`getNextClosureId()`
`protected int`	`getPrefixCountSize(java.lang.String prefix)`
`IRScope`	`getRootLexicalScope()` Returns the top level scope
`int`	`getScopeId()`
`abstract IRScopeType`	`getScopeType()`
`Variable`	`getSelf()`
`StaticScope`	`getStaticScope()`
`StoreLocalVarPlacementProblem`	`getStoreLocalVarPlacementProblem()`
`int`	`getTemporaryVariablesCount()`
`int`	`getThreadPollInstrsCount()`
`UnboxableOpsAnalysisProblem`	`getUnboxableOpsAnalysisProblem()`
`java.util.Set<LocalVariable>`	`getUsedLocalVariables()` Get all variables referenced by this scope.
`int`	`getUsedVariablesCount()`
`java.util.Map<java.lang.String,java.lang.Integer>`	`getVarIndices()`
`TemporaryVariable`	`getYieldClosureVariable()` Get the variable for accessing the "yieldable" closure in this scope.
`boolean`	`hasBeenBuilt()` For lazy scopes which IRBuild on demand we can ask this method whether it has been built yet...
`boolean`	`hasExplicitCallProtocol()`
`int`	`hashCode()`
`boolean`	`hasLoops()`
`void`	`inlineMethod(IRScope method, RubyModule implClass, int classToken, BasicBlock basicBlock, CallBase call, boolean cloneHost)`
`boolean`	`isBeginEndBlock()`
`boolean`	`isFlipScope()`
`boolean`	`isModuleBody()` Does this scope represent a module body?
`boolean`	`isNestedInClosure(IRClosure closure)`
`boolean`	`isNonSingletonClassBody()` Is this IRClassBody but not IRMetaClassBody?
`boolean`	`isScriptScope()` Is this an eval script or a regular file script?
`boolean`	`isTopLocalVariableScope()`
`protected boolean`	`isUnsafeScope()`
`LocalVariable`	`lookupExistingLVar(RubySymbol name)`
`boolean`	`maybeUsingRefinements()`
`boolean`	`needsBinding()`
`boolean`	`needsFrame()`
`boolean`	`needsOnlyBackref()`
`boolean`	`parentMaybeUsingRefinements()`
`BasicBlock[]`	`prepareForCompilation()` Run any necessary passes to get the IR ready for compilation (AOT and/or JIT)
`FullInterpreterContext`	`prepareFullBuild()` This initializes a more complete(full) InterpreterContext which if used in mixed mode will be used by the JIT and if used in pure-interpreted mode it will be used by an interpreter engine.
`void`	`putLiveVariablesProblem(LiveVariablesProblem problem)`
`void`	`putStoreLocalVarPlacementProblem(StoreLocalVarPlacementProblem problem)`
`void`	`putUnboxableOpsAnalysisProblem(UnboxableOpsAnalysisProblem problem)`
`boolean`	`receivesKeywordArgs()`
`void`	`recordBeginBlock(IRClosure beginBlockClosure)` Record a begin block.
`void`	`removeClosure(IRClosure closure)`
`void`	`resetState()`
`void`	`resetTemporaryVariables()`
`protected void`	`resetVariableCounter(java.lang.String prefix)`
`boolean`	`reuseParentScope()`
`void`	`setExplicitCallProtocolFlag()`
`void`	`setFileName(java.lang.String filename)`
`void`	`setHasLoopsFlag()`
`void`	`setInterpreterContext(InterpreterContext interpreterContext)`
`void`	`setIsMaybeUsingRefinements()`
`void`	`setLabelIndices(java.util.Map<java.lang.String,java.lang.Integer> indices)`
`void`	`setLocalVariables(java.util.Map<RubySymbol,LocalVariable> variables)` Set the local variables for this scope.
`void`	`setName(RubySymbol name)`
`void`	`setTemporaryVariableCount(int count)`
`void`	`setUpUseDefLocalVarMaps()`
`java.lang.String`	`toString()`
`java.lang.String`	`toStringInstrs()`
`boolean`	`usesEval()`
`boolean`	`usesLocalVariable(Variable v)`
`boolean`	`usesZSuper()`

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

Field Detail

LOG
```
public static final Logger LOG
```

interpreterContext
```
protected InterpreterContext interpreterContext
```
Startup interpretation depends on this

fullInterpreterContext
```
protected FullInterpreterContext fullInterpreterContext
```
-X-C full interpretation OR JIT depends on this

temporaryVariableIndex
```
protected int temporaryVariableIndex
```

floatVariableIndex
```
protected int floatVariableIndex
```

fixnumVariableIndex
```
protected int fixnumVariableIndex
```

booleanVariableIndex
```
protected int booleanVariableIndex
```

threadPollInstrsCount
```
protected int threadPollInstrsCount
```
# of thread poll instrs added to this scope

Constructor Detail

IRScope

protected IRScope(IRScope s,
                  IRScope lexicalParent)

IRScope

public IRScope(IRManager manager,
               IRScope lexicalParent,
               RubySymbol name,
               int lineNumber,
               StaticScope staticScope)

Method Detail

getScopeId
```
public int getScopeId()
```

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

setInterpreterContext

public void setInterpreterContext(InterpreterContext interpreterContext)

equals

public boolean equals(java.lang.Object other)

Overrides:: equals in class java.lang.Object

addChildScope

protected void addChildScope(IRScope scope)

getLexicalScopes

public java.util.List<IRScope> getLexicalScopes()

addClosure

public void addClosure(IRClosure closure)

removeClosure

public void removeClosure(IRClosure closure)

getNewFlipStateVariable

public LocalVariable getNewFlipStateVariable()

getNewLabel

public Label getNewLabel(java.lang.String prefix)

getNewLabel
```
public Label getNewLabel()
```

getClosures

public java.util.Collection<IRClosure> getClosures()

getManager
```
public IRManager getManager()
```

setIsMaybeUsingRefinements

public void setIsMaybeUsingRefinements()

parentMaybeUsingRefinements

public boolean parentMaybeUsingRefinements()

maybeUsingRefinements

public boolean maybeUsingRefinements()

getLexicalParent
```
public IRScope getLexicalParent()
```
Returns the lexical scope that contains this scope definition

getStaticScope
```
public StaticScope getStaticScope()
```

getNearestMethod
```
public IRMethod getNearestMethod()
```

getNearestFlipVariableScope

public IRScope getNearestFlipVariableScope()

getNearestTopLocalVariableScope

public IRScope getNearestTopLocalVariableScope()

getNearestModuleReferencingScopeDepth
```
public int getNearestModuleReferencingScopeDepth()
```
Returns the nearest scope which we can extract a live module from. If this returns null (like for evals), then it means it cannot be statically determined.

getId
```
public java.lang.String getId()
```

getName
```
public RubySymbol getName()
```

setName
```
public void setName(RubySymbol name)
```

setFileName

public void setFileName(java.lang.String filename)

getFileName
```
public java.lang.String getFileName()
```

getLineNumber
```
public int getLineNumber()
```

getRootLexicalScope
```
public IRScope getRootLexicalScope()
```
Returns the top level scope

isNestedInClosure

public boolean isNestedInClosure(IRClosure closure)

setHasLoopsFlag
```
public void setHasLoopsFlag()
```

hasLoops
```
public boolean hasLoops()
```

hasExplicitCallProtocol

public boolean hasExplicitCallProtocol()

setExplicitCallProtocolFlag

public void setExplicitCallProtocolFlag()

receivesKeywordArgs
```
public boolean receivesKeywordArgs()
```

bindingHasEscaped
```
public boolean bindingHasEscaped()
```

usesEval
```
public boolean usesEval()
```

usesZSuper
```
public boolean usesZSuper()
```

canReceiveNonlocalReturns

public boolean canReceiveNonlocalReturns()

putLiveVariablesProblem

public void putLiveVariablesProblem(LiveVariablesProblem problem)

getLiveVariablesProblem

public LiveVariablesProblem getLiveVariablesProblem()

putStoreLocalVarPlacementProblem

public void putStoreLocalVarPlacementProblem(StoreLocalVarPlacementProblem problem)

getStoreLocalVarPlacementProblem

public StoreLocalVarPlacementProblem getStoreLocalVarPlacementProblem()

putUnboxableOpsAnalysisProblem

public void putUnboxableOpsAnalysisProblem(UnboxableOpsAnalysisProblem problem)

getUnboxableOpsAnalysisProblem

public UnboxableOpsAnalysisProblem getUnboxableOpsAnalysisProblem()

getCFG
```
public CFG getCFG()
```

isUnsafeScope
```
protected boolean isUnsafeScope()
```

getExecutedPasses

public java.util.List<CompilerPass> getExecutedPasses()

allocateInterpreterContext
```
public InterpreterContext allocateInterpreterContext(java.util.List<Instr> instructions)
```
Make version specific to scope which needs it (e.g. Closure vs non-closure).

allocateInterpreterContext

public InterpreterContext allocateInterpreterContext(java.util.concurrent.Callable<java.util.List<Instr>> instructions)

Make version specific to scope which needs it (e.g. Closure vs non-closure).

prepareFullBuild
```
public FullInterpreterContext prepareFullBuild()
```
This initializes a more complete(full) InterpreterContext which if used in mixed mode will be used by the JIT and if used in pure-interpreted mode it will be used by an interpreter engine.

getFullyQualifiedName

public java.lang.String getFullyQualifiedName()

dumpToIGV
```
public IGVDumper dumpToIGV()
```

prepareForCompilation
```
public BasicBlock[] prepareForCompilation()
```
Run any necessary passes to get the IR ready for compilation (AOT and/or JIT)

buildJVMExceptionTable

public java.util.Map<BasicBlock,Label> buildJVMExceptionTable()

getFlags

public java.util.EnumSet<IRFlags> getFlags()

computeScopeFlagsEarly
```
public void computeScopeFlagsEarly(java.util.List<Instr> instructions)
```
This is called when building an IRMethod before it has completed the build and made an IC yet.

computeScopeFlags
```
public void computeScopeFlags()
```
Calculate scope flags used by various passes to know things like whether a binding has escaped. We may recalculate flags in a few scenarios: - once after IR generation and local optimizations propagates constants locally - also potentially at later times after other opt passes

getScopeType

public abstract IRScopeType getScopeType()

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

debugOutput
```
public java.lang.String debugOutput()
```

toStringInstrs

public java.lang.String toStringInstrs()

getSelf
```
public Variable getSelf()
```

getCurrentModuleVariable

public Variable getCurrentModuleVariable()

getCurrentScopeVariable

public Variable getCurrentScopeVariable()

getLocalVariables
```
public java.util.Map<RubySymbol,LocalVariable> getLocalVariables()
```
Get the local variables for this scope. This should only be used by persistence layer.

getUsedLocalVariables
```
public java.util.Set<LocalVariable> getUsedLocalVariables()
```
Get all variables referenced by this scope.

setLocalVariables
```
public void setLocalVariables(java.util.Map<RubySymbol,LocalVariable> variables)
```
Set the local variables for this scope. This should only be used by persistence layer.

setLabelIndices

public void setLabelIndices(java.util.Map<java.lang.String,java.lang.Integer> indices)

lookupExistingLVar

public LocalVariable lookupExistingLVar(RubySymbol name)

findExistingLocalVariable

protected LocalVariable findExistingLocalVariable(RubySymbol name,
                                                  int depth)

getLocalVariable
```
public LocalVariable getLocalVariable(RubySymbol name,
                                      int scopeDepth)
```
Find or create a local variable. By default, scopes are assumed to only check current depth. Blocks/Closures override this because they have special nesting rules.

getNewLocalVariable

public LocalVariable getNewLocalVariable(RubySymbol name,
                                         int scopeDepth)

createTemporaryVariable

public TemporaryLocalVariable createTemporaryVariable()

getNewTemporaryVariableFor

public TemporaryLocalVariable getNewTemporaryVariableFor(LocalVariable var)

getNewTemporaryVariable

public TemporaryLocalVariable getNewTemporaryVariable(TemporaryVariableType type)

setTemporaryVariableCount

public void setTemporaryVariableCount(int count)

getYieldClosureVariable
```
public TemporaryVariable getYieldClosureVariable()
```
Get the variable for accessing the "yieldable" closure in this scope.

getNewUnboxedVariable

public TemporaryLocalVariable getNewUnboxedVariable(java.lang.Class type)

resetTemporaryVariables
```
public void resetTemporaryVariables()
```

getTemporaryVariablesCount

public int getTemporaryVariablesCount()

getFloatVariablesCount
```
public int getFloatVariablesCount()
```

getFixnumVariablesCount
```
public int getFixnumVariablesCount()
```

getBooleanVariablesCount
```
public int getBooleanVariablesCount()
```

getNewInlineVariable

public Variable getNewInlineVariable(org.jruby.util.ByteList inlinePrefix,
                                     Variable v)

getThreadPollInstrsCount
```
public int getThreadPollInstrsCount()
```

getLocalVariablesCount
```
public int getLocalVariablesCount()
```

getUsedVariablesCount
```
public int getUsedVariablesCount()
```

setUpUseDefLocalVarMaps
```
public void setUpUseDefLocalVarMaps()
```

usesLocalVariable

public boolean usesLocalVariable(Variable v)

definesLocalVariable

public boolean definesLocalVariable(Variable v)

hasBeenBuilt
```
public boolean hasBeenBuilt()
```
For lazy scopes which IRBuild on demand we can ask this method whether it has been built yet...

getExecutionContext

public FullInterpreterContext getExecutionContext()

getInterpreterContext

public InterpreterContext getInterpreterContext()

getFullInterpreterContext

public FullInterpreterContext getFullInterpreterContext()

depends

protected void depends(java.lang.Object obj)

resetState
```
public void resetState()
```

inlineMethod

public void inlineMethod(IRScope method,
                         RubyModule implClass,
                         int classToken,
                         BasicBlock basicBlock,
                         CallBase call,
                         boolean cloneHost)

recordBeginBlock
```
public void recordBeginBlock(IRClosure beginBlockClosure)
```
Record a begin block. Only eval and script body scopes support this

getBeginBlocks

public java.util.List<IRClosure> getBeginBlocks()

getEndBlocks

public java.util.List<IRClosure> getEndBlocks()

allocateNextPrefixedName

protected int allocateNextPrefixedName(java.lang.String prefix)

resetVariableCounter

protected void resetVariableCounter(java.lang.String prefix)

getVarIndices

public java.util.Map<java.lang.String,java.lang.Integer> getVarIndices()

getPrefixCountSize

protected int getPrefixCountSize(java.lang.String prefix)

getNextClosureId
```
public int getNextClosureId()
```

isBeginEndBlock
```
public boolean isBeginEndBlock()
```

isModuleBody
```
public boolean isModuleBody()
```
Does this scope represent a module body?

isNonSingletonClassBody
```
public boolean isNonSingletonClassBody()
```
Is this IRClassBody but not IRMetaClassBody?

isFlipScope
```
public boolean isFlipScope()
```

isTopLocalVariableScope

public boolean isTopLocalVariableScope()

isScriptScope
```
public boolean isScriptScope()
```
Is this an eval script or a regular file script?

needsFrame
```
public boolean needsFrame()
```

needsOnlyBackref
```
public boolean needsOnlyBackref()
```

reuseParentScope
```
public boolean reuseParentScope()
```

needsBinding
```
public boolean needsBinding()
```

Class IRScope

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

interpreterContext

fullInterpreterContext

temporaryVariableIndex

floatVariableIndex

fixnumVariableIndex

booleanVariableIndex

threadPollInstrsCount

Constructor Detail

IRScope

IRScope

Method Detail

getScopeId

hashCode

setInterpreterContext

equals

addChildScope

getLexicalScopes

addClosure

removeClosure

getNewFlipStateVariable

getNewLabel

getNewLabel

getClosures

getManager

setIsMaybeUsingRefinements

parentMaybeUsingRefinements

maybeUsingRefinements

getLexicalParent

getStaticScope

getNearestMethod

getNearestFlipVariableScope

getNearestTopLocalVariableScope

getNearestModuleReferencingScopeDepth

getId

getName

setName

setFileName

getFileName

getLineNumber

getRootLexicalScope

isNestedInClosure

setHasLoopsFlag

hasLoops

hasExplicitCallProtocol

setExplicitCallProtocolFlag

receivesKeywordArgs

bindingHasEscaped

usesEval

usesZSuper

canReceiveNonlocalReturns

putLiveVariablesProblem

getLiveVariablesProblem

putStoreLocalVarPlacementProblem

getStoreLocalVarPlacementProblem

putUnboxableOpsAnalysisProblem

getUnboxableOpsAnalysisProblem

getCFG

isUnsafeScope

getExecutedPasses

allocateInterpreterContext

allocateInterpreterContext

prepareFullBuild

getFullyQualifiedName

dumpToIGV

prepareForCompilation

buildJVMExceptionTable

getFlags

computeScopeFlagsEarly

computeScopeFlags

getScopeType

toString

debugOutput

toStringInstrs