IRScope (JRuby Core 9.0.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 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 ArgumentDescriptor[]`	`argDesc`
`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, String name, String fileName, int lineNumber, StaticScope staticScope)`
`protected`	`IRScope(IRScope s, IRScope lexicalParent)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addChildScope(IRScope scope)`
`void`	`addClosure(IRClosure closure)`
`InterpreterContext`	`allocateInterpreterContext(List<Instr> instructions)` Make version specific to scope which needs it (e.g.
`protected int`	`allocateNextPrefixedName(String prefix)`
`boolean`	`bindingHasEscaped()`
`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(List<Instr> instructions)` This is called when building an IRMethod before it has completed the build and made an IC yet.
`TemporaryLocalVariable`	`createTemporaryVariable()`
`String`	`debugOutput()`
`boolean`	`definesLocalVariable(Variable v)`
`protected void`	`depends(Object obj)`
`boolean`	`equals(Object other)`
`protected LocalVariable`	`findExistingLocalVariable(String name, int depth)`
`ArgumentDescriptor[]`	`getArgumentDescriptors()`
`List<IRClosure>`	`getBeginBlocks()`
`int`	`getBooleanVariablesCount()`
`CFG`	`getCFG()`
`Collection<IRClosure>`	`getClosures()`
`Variable`	`getCurrentModuleVariable()`
`Variable`	`getCurrentScopeVariable()`
`List<IRClosure>`	`getEndBlocks()`
`List<CompilerPass>`	`getExecutedPasses()`
`String`	`getFileName()`
`int`	`getFixnumVariablesCount()`
`EnumSet<IRFlags>`	`getFlags()`
`int`	`getFloatVariablesCount()`
`FullInterpreterContext`	`getFullInterpreterContext()`
`InterpreterContext`	`getInterpreterContext()`
`IRScope`	`getLexicalParent()` Returns the lexical scope that contains this scope definition
`List<IRScope>`	`getLexicalScopes()`
`int`	`getLineNumber()`
`LiveVariablesProblem`	`getLiveVariablesProblem()`
`LocalVariable`	`getLocalVariable(String name, int scopeDepth)` Find or create a local variable.
`Map<String,LocalVariable>`	`getLocalVariables()` Get the local variables for this scope.
`int`	`getLocalVariablesCount()`
`IRManager`	`getManager()`
`String`	`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(String inlinePrefix, Variable v)`
`Label`	`getNewLabel()`
`Label`	`getNewLabel(String prefix)`
`LocalVariable`	`getNewLocalVariable(String name, int scopeDepth)`
`TemporaryLocalVariable`	`getNewTemporaryVariable(TemporaryVariableType type)`
`TemporaryLocalVariable`	`getNewTemporaryVariableFor(LocalVariable var)`
`TemporaryLocalVariable`	`getNewUnboxedVariable(Class type)`
`int`	`getNextClosureId()`
`protected int`	`getPrefixCountSize(String prefix)`
`int`	`getScopeId()`
`abstract IRScopeType`	`getScopeType()`
`LocalVariable`	`getSelf()`
`StaticScope`	`getStaticScope()`
`StoreLocalVarPlacementProblem`	`getStoreLocalVarPlacementProblem()`
`int`	`getTemporaryVariablesCount()`
`int`	`getThreadPollInstrsCount()`
`IRScope`	`getTopLevelScope()` Returns the top level scope
`UnboxableOpsAnalysisProblem`	`getUnboxableOpsAnalysisProblem()`
`int`	`getUsedVariablesCount()`
`Map<String,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(String name)`
`boolean`	`maybeUsingRefinements()`
`boolean`	`parentMaybeUsingRefinements()`
`BasicBlock[]`	`prepareForInitialCompilation()` Run any necessary passes to get the IR ready for compilation
`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`	`prepareFullBuildCommon()`
`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(String prefix)`
`void`	`setArgumentDescriptors(ArgumentDescriptor[] argDesc)` Set upon completion of IRBuild of this IRMethod.
`void`	`setExplicitCallProtocolFlag()`
`void`	`setHasLoopsFlag()`
`void`	`setInterpreterContext(InterpreterContext interpreterContext)`
`void`	`setIsMaybeUsingRefinements()`
`void`	`setLabelIndices(Map<String,Integer> indices)`
`void`	`setLocalVariables(Map<String,LocalVariable> variables)` Set the local variables for this scope.
`void`	`setName(String name)`
`void`	`setTemporaryVariableCount(int count)`
`void`	`setUpUseDefLocalVarMaps()`
`String`	`toString()`
`String`	`toStringInstrs()`
`boolean`	`usesBackrefOrLastline()`
`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
```

argDesc
```
protected ArgumentDescriptor[] argDesc
```

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,
       String name,
       String fileName,
       int lineNumber,
       StaticScope staticScope)

Method Detail

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

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

hashCode in class Object

setInterpreterContext

public void setInterpreterContext(InterpreterContext interpreterContext)

equals
```
public boolean equals(Object other)
```
Overrides:

equals in class Object

addChildScope

protected void addChildScope(IRScope scope)

getLexicalScopes

public List<IRScope> getLexicalScopes()

addClosure

public void addClosure(IRClosure closure)

removeClosure

public void removeClosure(IRClosure closure)

getNewFlipStateVariable

public LocalVariable getNewFlipStateVariable()

getNewLabel

public Label getNewLabel(String prefix)

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

getClosures

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

getName
```
public String getName()
```

setName
```
public void setName(String name)
```

getFileName
```
public String getFileName()
```

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

getTopLevelScope
```
public IRScope getTopLevelScope()
```
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()
```

usesBackrefOrLastline

public boolean usesBackrefOrLastline()

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 List<CompilerPass> getExecutedPasses()

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

prepareFullBuildCommon
```
public void prepareFullBuildCommon()
```

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.

prepareForInitialCompilation
```
public BasicBlock[] prepareForInitialCompilation()
```
Run any necessary passes to get the IR ready for compilation

buildJVMExceptionTable

public Map<BasicBlock,Label> buildJVMExceptionTable()

getFlags
```
public EnumSet<IRFlags> getFlags()
```

computeScopeFlagsEarly
```
public void computeScopeFlagsEarly(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 String toString()
```
Overrides:

toString in class Object

debugOutput
```
public String debugOutput()
```

toStringInstrs
```
public String toStringInstrs()
```

getSelf
```
public LocalVariable getSelf()
```

getCurrentModuleVariable

public Variable getCurrentModuleVariable()

getCurrentScopeVariable

public Variable getCurrentScopeVariable()

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

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

setLabelIndices

public void setLabelIndices(Map<String,Integer> indices)

lookupExistingLVar

public LocalVariable lookupExistingLVar(String name)

getArgumentDescriptors

public ArgumentDescriptor[] getArgumentDescriptors()

setArgumentDescriptors
```
public void setArgumentDescriptors(ArgumentDescriptor[] argDesc)
```
Set upon completion of IRBuild of this IRMethod.

findExistingLocalVariable

protected LocalVariable findExistingLocalVariable(String name,
                                      int depth)

getLocalVariable
```
public LocalVariable getLocalVariable(String 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(String 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(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(String 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...

getInterpreterContext

public InterpreterContext getInterpreterContext()

getFullInterpreterContext

public FullInterpreterContext getFullInterpreterContext()

depends
```
protected void depends(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 List<IRClosure> getBeginBlocks()

getEndBlocks
```
public List<IRClosure> getEndBlocks()
```

allocateNextPrefixedName

protected int allocateNextPrefixedName(String prefix)

resetVariableCounter

protected void resetVariableCounter(String prefix)

getVarIndices

public Map<String,Integer> getVarIndices()

getPrefixCountSize

protected int getPrefixCountSize(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?

Class IRScope

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

argDesc

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

getName

setName

getFileName

getLineNumber

getTopLevelScope

isNestedInClosure

setHasLoopsFlag

hasLoops

hasExplicitCallProtocol

setExplicitCallProtocolFlag

receivesKeywordArgs

bindingHasEscaped

usesBackrefOrLastline

usesEval

usesZSuper

canReceiveNonlocalReturns

putLiveVariablesProblem

getLiveVariablesProblem

putStoreLocalVarPlacementProblem

getStoreLocalVarPlacementProblem

putUnboxableOpsAnalysisProblem

getUnboxableOpsAnalysisProblem

getCFG

isUnsafeScope

getExecutedPasses

allocateInterpreterContext

prepareFullBuildCommon

prepareFullBuild

prepareForInitialCompilation

buildJVMExceptionTable

getFlags

computeScopeFlagsEarly

computeScopeFlags

getScopeType

toString

debugOutput

toStringInstrs

getSelf

getCurrentModuleVariable