IRScope (JRuby Core 1.7.10 API)

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

Direct Known Subclasses:

IRClosure, IRMethod, IRModuleBody, IRScriptBody
```
public abstract class IRScope
extends Object
```
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 ...

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class IRScope.LocalVariableAllocator

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`IRScope.LocalVariableAllocator`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`canReceiveBreaks` Can this scope receive breaks
`boolean`	`canReceiveNonlocalReturns` Can this scope receive a non-local return?
`protected boolean`	`hasBreakInstrs` Does this scope have a break instr?
`protected boolean`	`hasNonlocalReturns` Does this scope have a non-local return instr?
`protected int`	`temporaryVariableIndex`

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 c)`
`void`	`addInstr(Instr i)`
`void`	`addInstrAtBeginning(Instr i)`
`protected int`	`allocateNextPrefixedName(String prefix)`
`boolean`	`bindingHasEscaped()`
`CFG`	`buildCFG()`
`void`	`buildCFG(List<Instr> instrList)`
`List<BasicBlock>`	`buildLinearization()`
`boolean`	`canCaptureCallersBinding()`
`boolean`	`canReceiveNonlocalReturns()`
`CFG`	`cfg()`
`void`	`checkRelinearization()`
`void`	`computeScopeFlags()`
`boolean`	`definesLocalVariable(Variable v)`
`protected void`	`depends(Object obj)`
`boolean`	`equals(Object other)`
`LocalVariable`	`findExistingLocalVariable(String name, int depth)`
`CFG`	`getCFG()`
`List<IRClosure>`	`getClosures()`
`RubyModule`	`getContainerModule()`
`Variable`	`getCurrentModuleVariable()`
`Variable`	`getCurrentScopeVariable()`
`DataFlowProblem`	`getDataFlowSolution(String name)`
`int`	`getEnsurerPC(Instr excInstr)`
`String`	`getFileName()`
`abstract LocalVariable`	`getImplicitBlockArg()`
`List<Instr>`	`getInstrs()`
`Instr[]`	`getInstrsForInterpretation()`
`Instr`	`getLastInstr()`
`IRScope`	`getLexicalParent()` Returns the lexical scope that contains this scope definition
`List<IRScope>`	`getLexicalScopes()`
`int`	`getLineNumber()`
`LocalVariable`	`getLocalVariable(String name, int scopeDepth)` Find or create a local variable.
`int`	`getLocalVariablesCount()`
`IRManager`	`getManager()`
`String`	`getName()`
`IRScope`	`getNearestFlipVariableScope()`
`IRMethod`	`getNearestMethod()`
`IRScope`	`getNearestModuleReferencingScope()` 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 depth)`
`TemporaryVariable`	`getNewTemporaryVariable()`
`TemporaryVariable`	`getNewTemporaryVariable(String name)`
`int`	`getNextClosureId()`
`protected int`	`getPrefixCountSize(String prefix)`
`int`	`getRescuerPC(Instr excInstr)`
`int`	`getScopeId()`
`abstract String`	`getScopeName()`
`LocalVariable`	`getSelf()` --------------------------------------- SSS FIXME: What is this method for?
`StaticScope`	`getStaticScope()`
`int`	`getTemporaryVariableSize()`
`int`	`getThreadPollInstrsCount()`
`IRScope`	`getTopLevelScope()` Returns the top level scope
`int`	`getUsedVariablesCount()`
`boolean`	`hasExplicitCallProtocol()`
`int`	`hashCode()`
`boolean`	`hasLoops()`
`protected void`	`initEvalScopeVariableAllocator(boolean reset)`
`void`	`initFlipStateVariable(Variable v, Operand initState)`
`void`	`inlineMethod(IRScope method, RubyModule implClass, int classToken, BasicBlock basicBlock, CallBase call)`
`boolean`	`isFlipScope()`
`boolean`	`isForLoopBody()`
`boolean`	`isModuleBody()` Does this scope represent a module body? (SSS FIXME: what about script or eval script bodies?)
`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()`
`List<BasicBlock>`	`linearization()`
`void`	`markUnusedImplicitBlockArg()`
`boolean`	`modifiesCode()`
`Tuple<Instr[],Map<Integer,Label[]>>`	`prepareForCompilation()` Run any necessary passes to get the IR ready for compilation
`Instr[]`	`prepareForInterpretation(boolean isLambda)` Run any necessary passes to get the IR ready for interpretation
`boolean`	`receivesKeywordArgs()`
`void`	`recordBeginBlock(IRClosure beginBlockClosure)`
`void`	`recordEndBlock(IRClosure endBlockClosure)`
`void`	`resetCFG()`
`void`	`resetDFProblemsState()`
`void`	`resetLinearizationData()`
`void`	`resetState()`
`void`	`resetTemporaryVariables()`
`protected void`	`resetVariableCounter(String prefix)`
`protected void`	`setCFG(CFG cfg)`
`void`	`setCodeModificationFlag(boolean f)`
`void`	`setDataFlowSolution(String name, DataFlowProblem p)`
`void`	`setExplicitCallProtocolFlag(boolean flag)`
`void`	`setHasLoopsFlag(boolean f)`
`void`	`setName(String name)`
`void`	`setUpUseDefLocalVarMaps()`
`void`	`splitCalls()`
`String`	`toPersistableString()`
`String`	`toString()`
`String`	`toStringInstrs()`
`String`	`toStringVariables()`
`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
- temporaryVariableIndex
```
protected int temporaryVariableIndex
```
- hasBreakInstrs
```
protected boolean hasBreakInstrs
```
  Does this scope have a break instr?
- canReceiveBreaks
```
protected boolean canReceiveBreaks
```
  Can this scope receive breaks
- hasNonlocalReturns
```
protected boolean hasNonlocalReturns
```
  Does this scope have a non-local return instr?
- canReceiveNonlocalReturns
```
public boolean canReceiveNonlocalReturns
```
  Can this scope receive a non-local return?

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

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 c)
```

getLastInstr
```
public Instr getLastInstr()
```

addInstrAtBeginning

public void addInstrAtBeginning(Instr i)

addInstr
```
public void addInstr(Instr i)
```

getNewFlipStateVariable

public LocalVariable getNewFlipStateVariable()

initFlipStateVariable

public void initFlipStateVariable(Variable v,
                         Operand initState)

isForLoopBody
```
public boolean isForLoopBody()
```

getNewLabel

public Label getNewLabel(String prefix)

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

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

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

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

getNearestModuleReferencingScope
```
public IRScope getNearestModuleReferencingScope()
```
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(boolean f)

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

hasExplicitCallProtocol

public boolean hasExplicitCallProtocol()

setExplicitCallProtocolFlag

public void setExplicitCallProtocolFlag(boolean flag)

setCodeModificationFlag

public void setCodeModificationFlag(boolean f)

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

modifiesCode
```
public boolean modifiesCode()
```

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

usesBackrefOrLastline

public boolean usesBackrefOrLastline()

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

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

canCaptureCallersBinding

public boolean canCaptureCallersBinding()

canReceiveNonlocalReturns

public boolean canReceiveNonlocalReturns()

buildCFG
```
public CFG buildCFG()
```

setCFG
```
protected void setCFG(CFG cfg)
```

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

prepareForInterpretation
```
public Instr[] prepareForInterpretation(boolean isLambda)
```
Run any necessary passes to get the IR ready for interpretation

prepareForCompilation
```
public Tuple<Instr[],Map<Integer,Label[]>> prepareForCompilation()
```
Run any necessary passes to get the IR ready for compilation

computeScopeFlags
```
public void computeScopeFlags()
```

getScopeName
```
public abstract String getScopeName()
```

toString
```
public String toString()
```
Overrides:

toString in class Object

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

toPersistableString
```
public String toPersistableString()
```

toStringVariables
```
public String toStringVariables()
```

getSelf
```
public LocalVariable getSelf()
```
--------------------------------------- SSS FIXME: What is this method for?

getCurrentModuleVariable

public Variable getCurrentModuleVariable()

getCurrentScopeVariable

public Variable getCurrentScopeVariable()

getImplicitBlockArg

public abstract LocalVariable getImplicitBlockArg()

markUnusedImplicitBlockArg

public void markUnusedImplicitBlockArg()

findExistingLocalVariable

public 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 depth)

initEvalScopeVariableAllocator

protected void initEvalScopeVariableAllocator(boolean reset)

getNewTemporaryVariable

public TemporaryVariable getNewTemporaryVariable()

getNewTemporaryVariable

public TemporaryVariable getNewTemporaryVariable(String name)

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

getTemporaryVariableSize
```
public int getTemporaryVariableSize()
```

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)

setDataFlowSolution

public void setDataFlowSolution(String name,
                       DataFlowProblem p)

getDataFlowSolution

public DataFlowProblem getDataFlowSolution(String name)

getInstrs
```
public List<Instr> getInstrs()
```

getInstrsForInterpretation

public Instr[] getInstrsForInterpretation()

resetLinearizationData
```
public void resetLinearizationData()
```

checkRelinearization
```
public void checkRelinearization()
```

buildLinearization

public List<BasicBlock> buildLinearization()

getRescuerPC

public int getRescuerPC(Instr excInstr)

getEnsurerPC

public int getEnsurerPC(Instr excInstr)

linearization

public List<BasicBlock> linearization()

depends
```
protected void depends(Object obj)
```

cfg
```
public CFG cfg()
```

splitCalls
```
public void splitCalls()
```

resetDFProblemsState
```
public void resetDFProblemsState()
```

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

inlineMethod

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

buildCFG

public void buildCFG(List<Instr> instrList)

resetCFG
```
public void resetCFG()
```

recordBeginBlock

public void recordBeginBlock(IRClosure beginBlockClosure)

recordEndBlock

public void recordEndBlock(IRClosure endBlockClosure)

allocateNextPrefixedName

protected int allocateNextPrefixedName(String prefix)

resetVariableCounter

protected void resetVariableCounter(String prefix)

getPrefixCountSize

protected int getPrefixCountSize(String prefix)

getContainerModule

public RubyModule getContainerModule()

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

isModuleBody
```
public boolean isModuleBody()
```
Does this scope represent a module body? (SSS FIXME: what about script or eval script bodies?)

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

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

temporaryVariableIndex

hasBreakInstrs

canReceiveBreaks

hasNonlocalReturns

canReceiveNonlocalReturns

Constructor Detail

IRScope

IRScope

Method Detail

getScopeId

hashCode

equals

addChildScope

getLexicalScopes

addClosure

getLastInstr

addInstrAtBeginning

addInstr

getNewFlipStateVariable

initFlipStateVariable

isForLoopBody

getNewLabel

getNewLabel

getClosures

getManager

getLexicalParent

getStaticScope

getNearestMethod

getNearestFlipVariableScope

getNearestTopLocalVariableScope

getNearestModuleReferencingScope

getName

setName

getFileName

getLineNumber

getTopLevelScope

isNestedInClosure

setHasLoopsFlag

hasLoops

hasExplicitCallProtocol

setExplicitCallProtocolFlag

setCodeModificationFlag

receivesKeywordArgs

modifiesCode

bindingHasEscaped

usesBackrefOrLastline

usesEval

usesZSuper

canCaptureCallersBinding

canReceiveNonlocalReturns

buildCFG

setCFG

getCFG

prepareForInterpretation

prepareForCompilation

computeScopeFlags

getScopeName

toString

toStringInstrs

toPersistableString

toStringVariables

getSelf

getCurrentModuleVariable

getCurrentScopeVariable

getImplicitBlockArg

markUnusedImplicitBlockArg

findExistingLocalVariable

getLocalVariable

getNewLocalVariable

initEvalScopeVariableAllocator

getNewTemporaryVariable

getNewTemporaryVariable

resetTemporaryVariables