Uses of Class
org.jruby.ir.IRScope

Packages that use IRScope

Package	Description
org.jruby.ast.util
org.jruby.internal.runtime.methods
org.jruby.ir
org.jruby.ir.dataflow
org.jruby.ir.dataflow.analyses
org.jruby.ir.instructions
org.jruby.ir.interpreter
org.jruby.ir.listeners
org.jruby.ir.passes
org.jruby.ir.persistence
org.jruby.ir.representations
org.jruby.ir.runtime
org.jruby.ir.targets
org.jruby.ir.transformations.inlining
org.jruby.parser
org.jruby.runtime

Uses of IRScope in org.jruby.ast.util

Methods in org.jruby.ast.util with parameters of type IRScope

Modifier and Type	Method and Description
static String	SexpMaker.sha1(IRScope scope)

Uses of IRScope in org.jruby.internal.runtime.methods

Fields in org.jruby.internal.runtime.methods declared as IRScope

Modifier and Type	Field and Description
protected IRScope	InterpretedIRMethod.method
protected IRScope	CompiledIRMethod.method

Methods in org.jruby.internal.runtime.methods that return IRScope

Modifier and Type	Method and Description
IRScope	InterpretedIRMethod.getIRMethod()
IRScope	CompiledIRMethod.getIRMethod()

Constructors in org.jruby.internal.runtime.methods with parameters of type IRScope

Constructor and Description
CompiledIRMetaClassBody(java.lang.invoke.MethodHandle handle, IRScope scope, RubyModule implementationClass)
CompiledIRMethod(java.lang.invoke.MethodHandle variable, IRScope method, Visibility visibility, RubyModule implementationClass)
CompiledIRMethod(java.lang.invoke.MethodHandle variable, java.lang.invoke.MethodHandle specific, int specificArity, IRScope method, Visibility visibility, RubyModule implementationClass)
InterpretedIRMetaClassBody(IRScope metaClassBody, RubyModule implementationClass)
InterpretedIRMethod(IRScope method, Visibility visibility, RubyModule implementationClass)

Uses of IRScope in org.jruby.ir

Subclasses of IRScope in org.jruby.ir

Modifier and Type	Class and Description
class	IRBindingEvalScript Explicit Binding Evals must allow preserving values between evals.
class	IRClassBody
class	IRClosure
class	IREvalScript
class	IRFor Represents a 'for' loop
class	IRMetaClassBody
class	IRMethod
class	IRModuleBody
class	IRScriptBody

Methods in org.jruby.ir that return IRScope

Modifier and Type	Method and Description
IRScope	IRScope.getLexicalParent() Returns the lexical scope that contains this scope definition
IRScope	IRScope.getNearestFlipVariableScope()
IRScope	IRScope.getNearestTopLocalVariableScope()
IRScope	IRScope.getTopLevelScope() Returns the top level scope

Methods in org.jruby.ir that return types with arguments of type IRScope

Modifier and Type	Method and Description
List<IRScope>	IRScope.getLexicalScopes()

Methods in org.jruby.ir with parameters of type IRScope

Modifier and Type	Method and Description
protected void	IRScope.addChildScope(IRScope scope)
void	IRBuilder.addInstr(IRScope s, Instr i)
void	IRBuilder.addInstrAtBeginning(IRScope s, Instr i)
Operand	IRBuilder.build(Node node, IRScope s)
Operand	IRBuilder.buildAlias(AliasNode alias, IRScope s)
Operand	IRBuilder.buildAnd(AndNode andNode, IRScope s)
Operand	IRBuilder.buildArgsCat(ArgsCatNode argsCatNode, IRScope s)
void	IRBuilder.buildArgsMasgn(Node node, IRScope s, Operand argsArray, boolean isMasgnRoot, int preArgsCount, int postArgsCount, int index, boolean isSplat)
Operand	IRBuilder.buildArgsPush(ArgsPushNode node, IRScope s)
Operand	IRBuilder.buildArray(Node node, IRScope s)
void	IRBuilder.buildAssignment(Node node, IRScope s, Variable rhsVal)
Operand	IRBuilder.buildAttrAssignAssignment(Node node, IRScope s, Operand value)
protected Operand	IRBuilder.buildAttrAssignCallArgs(List<Operand> argsList, Node args, IRScope s)
Operand	IRBuilder.buildBackref(BackRefNode node, IRScope s)
Operand	IRBuilder.buildBegin(BeginNode beginNode, IRScope s)
Operand	IRBuilder.buildBlock(BlockNode node, IRScope s)
void	IRBuilder.buildBlockArgsAssignment(Node node, IRScope s, Operand argsArray, int argIndex, boolean isSplat)
Operand	IRBuilder.buildBreak(BreakNode breakNode, IRScope s)
Operand	IRBuilder.buildCall(CallNode callNode, IRScope s)
protected Operand[]	IRBuilder.buildCallArgs(Node args, IRScope s)
Operand	IRBuilder.buildCase(CaseNode caseNode, IRScope s)
Operand	IRBuilder.buildClass(ClassNode classNode, IRScope s) Build a new class and add it to the current scope (s).
Operand	IRBuilder.buildClassVar(ClassVarNode node, IRScope s)
Operand	IRBuilder.buildClassVarAsgn(ClassVarAsgnNode classVarAsgnNode, IRScope s)
Operand	IRBuilder.buildClassVarDecl(ClassVarDeclNode classVarDeclNode, IRScope s)
Operand	IRBuilder.buildColon2(Colon2Node iVisited, IRScope s)
Operand	IRBuilder.buildColon3(Colon3Node node, IRScope s)
Operand	IRBuilder.buildComplex(ComplexNode node, IRScope s)
Operand	IRBuilder.buildConstDecl(ConstDeclNode node, IRScope s)
Operand	IRBuilder.buildConstDeclAssignment(ConstDeclNode constDeclNode, IRScope s, Operand val)
Operand	IRBuilder.buildDAsgn(DAsgnNode dasgnNode, IRScope s)
protected Variable	IRBuilder.buildDefinitionCheck(IRScope s, ResultInstr definedInstr, String definedReturnValue)
Operand	IRBuilder.buildDefn(MethodDefNode node, IRScope s)
protected Variable	IRBuilder.buildDefnCheckIfThenPaths(IRScope s, Label undefLabel, Operand defVal)
Operand	IRBuilder.buildDefs(DefsNode node, IRScope s)
Operand	IRBuilder.buildDot(DotNode dotNode, IRScope s)
Operand	IRBuilder.buildDRegexp(DRegexpNode node, IRScope s)
Operand	IRBuilder.buildDStr(DStrNode node, IRScope s)
Operand	IRBuilder.buildDSymbol(DSymbolNode node, IRScope s)
Operand	IRBuilder.buildDVar(DVarNode node, IRScope s)
Operand	IRBuilder.buildDXStr(DXStrNode dstrNode, IRScope s)
Operand	IRBuilder.buildEncoding(EncodingNode node, IRScope s)
Operand	IRBuilder.buildEnsureNode(EnsureNode ensureNode, IRScope s)
IREvalScript	IRBuilder.buildEvalRoot(StaticScope staticScope, IRScope containingScope, String file, int lineNumber, RootNode rootNode, EvalType evalType)
Operand	IRBuilder.buildEvStr(EvStrNode node, IRScope s)
Operand	IRBuilder.buildFCall(FCallNode fcallNode, IRScope s)
Operand	IRBuilder.buildFlip(FlipNode flipNode, IRScope s)
Operand	IRBuilder.buildFor(ForNode forNode, IRScope s)
Operand	IRBuilder.buildForIter(ForNode forNode, IRScope s)
Operand	IRBuilder.buildGetArgumentDefinition(Node node, IRScope s, String type)
Operand	IRBuilder.buildGetDefinition(Node node, IRScope scope)
Operand	IRBuilder.buildGlobalAsgn(GlobalAsgnNode globalAsgnNode, IRScope s)
Operand	IRBuilder.buildGlobalVar(GlobalVarNode node, IRScope s)
Operand	IRBuilder.buildHash(HashNode hashNode, IRScope s)
Operand	IRBuilder.buildIf(IfNode ifNode, IRScope s)
Operand	IRBuilder.buildInstAsgn(InstAsgnNode instAsgnNode, IRScope s)
Operand	IRBuilder.buildInstVar(InstVarNode node, IRScope s)
Operand	IRBuilder.buildIter(IterNode iterNode, IRScope s)
Operand	IRBuilder.buildLambda(LambdaNode node, IRScope s)
Operand	IRBuilder.buildLiteral(LiteralNode literalNode, IRScope s)
Operand	IRBuilder.buildLocalAsgn(LocalAsgnNode localAsgnNode, IRScope s)
Operand	IRBuilder.buildLocalVar(LocalVarNode node, IRScope s)
Operand	IRBuilder.buildMatch(MatchNode matchNode, IRScope s)
Operand	IRBuilder.buildMatch2(Match2Node matchNode, IRScope s)
Operand	IRBuilder.buildMatch3(Match3Node matchNode, IRScope s)
Operand	IRBuilder.buildModule(ModuleNode moduleNode, IRScope s)
Operand	IRBuilder.buildMultipleAsgn(MultipleAsgnNode multipleAsgnNode, IRScope s)
Operand	IRBuilder.buildMultipleAsgn19(MultipleAsgn19Node multipleAsgnNode, IRScope s)
void	IRBuilder.buildMultipleAsgn19Assignment(MultipleAsgn19Node multipleAsgnNode, IRScope s, Operand argsArray, Operand values)
void	IRBuilder.buildMultipleAsgnAssignment(MultipleAsgnNode multipleAsgnNode, IRScope s, Operand argsArray, Operand values)
Operand	IRBuilder.buildNewline(NewlineNode node, IRScope s)
Operand	IRBuilder.buildNext(NextNode nextNode, IRScope s)
Operand	IRBuilder.buildNthRef(NthRefNode nthRefNode, IRScope s)
Operand	IRBuilder.buildOpAsgn(OpAsgnNode opAsgnNode, IRScope s)
Operand	IRBuilder.buildOpAsgnAnd(OpAsgnAndNode andNode, IRScope s)
Operand	IRBuilder.buildOpAsgnOr(OpAsgnOrNode orNode, IRScope s)
Operand	IRBuilder.buildOpElementAsgn(OpElementAsgnNode node, IRScope s)
Operand	IRBuilder.buildOpElementAsgnWithAnd(OpElementAsgnNode opElementAsgnNode, IRScope s)
Operand	IRBuilder.buildOpElementAsgnWithMethod(OpElementAsgnNode opElementAsgnNode, IRScope s)
Operand	IRBuilder.buildOpElementAsgnWithOr(OpElementAsgnNode opElementAsgnNode, IRScope s)
Operand	IRBuilder.buildOr(OrNode orNode, IRScope s)
Operand	IRBuilder.buildPostExe(PostExeNode postExeNode, IRScope s)
Operand	IRBuilder.buildPreExe(PreExeNode preExeNode, IRScope s)
Operand	IRBuilder.buildRedo(IRScope s)
Operand	IRBuilder.buildRegexp(RegexpNode reNode, IRScope s)
Operand	IRBuilder.buildRescue(RescueNode node, IRScope s)
Operand	IRBuilder.buildRetry(IRScope s)
Operand	IRBuilder.buildReturn(ReturnNode returnNode, IRScope s)
Operand	IRBuilder.buildSClass(SClassNode sclassNode, IRScope s)
Operand	IRBuilder.buildSelf(IRScope s)
Operand	IRBuilder.buildSplat(SplatNode splatNode, IRScope s)
Operand	IRBuilder.buildStr(StrNode strNode, IRScope s)
Operand	IRBuilder.buildSuper(SuperNode superNode, IRScope s)
Operand	IRBuilder.buildSValue(SValueNode node, IRScope s)
Operand	IRBuilder.buildUndef(Node node, IRScope s)
Operand	IRBuilder.buildUntil(UntilNode untilNode, IRScope s)
Operand	IRBuilder.buildVAlias(VAliasNode valiasNode, IRScope s)
Operand	IRBuilder.buildVCall(VCallNode node, IRScope s)
void	IRBuilder.buildVersionSpecificAssignment(Node node, IRScope s, Variable v)
void	IRBuilder.buildVersionSpecificBlockArgsAssignment(Node node, IRScope s)
Operand	IRBuilder.buildWhile(WhileNode whileNode, IRScope s)
Operand	IRBuilder.buildXStr(XStrNode node, IRScope s)
Operand	IRBuilder.buildYield(YieldNode node, IRScope s)
Operand	IRBuilder.buildZArray(IRScope s)
Operand	IRBuilder.buildZSuper(ZSuperNode zsuperNode, IRScope s)
Operand	IRBuilder.classVarContainer(IRScope s, boolean declContext)
Operand	IRBuilder.classVarDeclarationContainer(IRScope s)
Operand	IRBuilder.classVarDefinitionContainer(IRScope s)
protected Variable	IRBuilder.copyAndReturnValue(IRScope s, Operand val)
protected IRMethod	IRBuilder.defineMethodInner(MethodDefNode defNode, IRMethod method, IRScope parent)
protected LocalVariable	IRBuilder.getArgVariable(IRScope s, String name, int depth)
protected LocalVariable	IRBuilder.getBlockArgVariable(IRScope s, String name, int depth)
List<CompilerPass>	IRManager.getCompilerPasses(IRScope scope)
List<CompilerPass>	IRManager.getInliningCompilerPasses(IRScope scope)
List<CompilerPass>	IRManager.getJITPasses(IRScope scope)
List<CompilerPass>	IRManager.getSafePasses(IRScope scope)
protected Variable	IRBuilder.getValueInTemporaryVariable(IRScope s, Operand val)
void	IRScope.inlineMethod(IRScope method, RubyModule implClass, int classToken, BasicBlock basicBlock, CallBase call, boolean cloneHost)
void	IRBuilder.receiveArgs(ArgsNode argsNode, IRScope s) Process all arguments specified for this scope.
protected void	IRBuilder.receiveBlockArg(ArgsNode argsNode, IRScope s) Reify the implicit incoming block into a full Proc, for use as "block arg", but only if a block arg is specified in this scope's arguments.
protected void	IRBuilder.receiveBlockArg(IRScope s, Variable v, Operand argsArray, int argIndex, boolean isSplat)
void	IRBuilder.receiveBlockArgs(IterNode node, IRScope s)
protected void	IRBuilder.receiveNonBlockArgs(ArgsNode argsNode, IRScope s)
void	IRBuilder.receiveRequiredArg(Node node, IRScope s, int argIndex, boolean post, int numPreReqd, int numPostRead)
Operand[]	IRBuilder.setupCallArgs(Node args, IRScope s)
Node	IRBuilder.skipOverNewlines(IRScope s, Node n)

Constructors in org.jruby.ir with parameters of type IRScope

Constructor and Description
IRBindingEvalScript(IRManager manager, IRScope lexicalParent, String fileName, int lineNumber, StaticScope staticScope, EvalType evalType)
IRClassBody(IRManager manager, IRScope lexicalParent, String name, int lineNumber, StaticScope scope)
IRClassBody(IRManager manager, IRScope lexicalParent, String name, String fileName, int lineNumber, StaticScope scope)
IRClosure(IRClosure c, IRScope lexicalParent, int closureId, String fullName) Used by cloning code
IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, int argumentType)
IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, int argumentType, String prefix)
IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, int argumentType, String prefix, boolean isBeginEndBlock)
IRClosure(IRManager manager, IRScope lexicalParent, String fileName, int lineNumber, StaticScope staticScope, String prefix)
IREvalScript(IRManager manager, IRScope lexicalParent, String fileName, int lineNumber, StaticScope staticScope, EvalType evalType)
IRFor(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, int argumentType)
IRFor(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, int argumentType, String labelPrefix)
IRMetaClassBody(IRManager manager, IRScope lexicalParent, String name, int lineNumber, StaticScope scope)
IRMetaClassBody(IRManager manager, IRScope lexicalParent, String name, String fileName, int lineNumber, StaticScope scope)
IRMethod(IRManager manager, IRScope lexicalParent, MethodDefNode defn, String name, boolean isInstanceMethod, int lineNumber, StaticScope staticScope)
IRModuleBody(IRManager manager, IRScope lexicalParent, String name, int lineNumber, StaticScope scope)
IRModuleBody(IRManager manager, IRScope lexicalParent, String name, String fileName, int lineNumber, StaticScope staticScope)
IRScope(IRManager manager, IRScope lexicalParent, String name, String fileName, int lineNumber, StaticScope staticScope)
IRScope(IRScope s, IRScope lexicalParent)

Uses of IRScope in org.jruby.ir.dataflow

Fields in org.jruby.ir.dataflow declared as IRScope

Modifier and Type	Field and Description
protected IRScope	DataFlowProblem.scope

Methods in org.jruby.ir.dataflow that return IRScope

Modifier and Type	Method and Description
IRScope	DataFlowProblem.getScope()

Methods in org.jruby.ir.dataflow with parameters of type IRScope

Modifier and Type	Method and Description
void	DataFlowProblem.setup(IRScope scope)

Uses of IRScope in org.jruby.ir.dataflow.analyses

Methods in org.jruby.ir.dataflow.analyses with parameters of type IRScope

Modifier and Type	Method and Description
void	LiveVariablesProblem.setup(IRScope scope, Collection<LocalVariable> allVars) Initialize the problem with all vars from the surrounding scope variables.

Constructors in org.jruby.ir.dataflow.analyses with parameters of type IRScope

Constructor and Description
LiveVariablesProblem(IRScope scope)

Uses of IRScope in org.jruby.ir.instructions

Methods in org.jruby.ir.instructions that return IRScope

Modifier and Type	Method and Description
IRScope	RecordEndBlockInstr.getDeclaringScope()
IRScope	StoreLocalVarInstr.getScope()
IRScope	LoadLocalVarInstr.getScope()
IRScope	InlinedLineNumberInstr.getScope()

Methods in org.jruby.ir.instructions with parameters of type IRScope

Modifier and Type	Method and Description
boolean	ToAryInstr.canBeDeleted(IRScope s)
boolean	Instr.canBeDeleted(IRScope s) Can this instruction be deleted? LVA will preserve instructions based on whether operands (variables) are living but even if there are no living variables then the instruction itself may not be able to be removed during DCE for other reasons (like if it unconditionally has a side-effect or it happens to be living in a scope where a binding can escape and one of its operands is a local variable).
boolean	ZSuperInstr.computeScopeFlags(IRScope scope)
boolean	UnresolvedSuperInstr.computeScopeFlags(IRScope scope)
boolean	UndefMethodInstr.computeScopeFlags(IRScope scope)
boolean	RuntimeHelperCall.computeScopeFlags(IRScope scope) Does this instruction do anything the scope is interested in?
boolean	ReifyClosureInstr.computeScopeFlags(IRScope scope)
boolean	RecordEndBlockInstr.computeScopeFlags(IRScope scope)
boolean	ReceiveKeywordRestArgInstr.computeScopeFlags(IRScope scope)
boolean	ReceiveKeywordArgInstr.computeScopeFlags(IRScope scope)
boolean	PutGlobalVarInstr.computeScopeFlags(IRScope scope)
boolean	NonlocalReturnInstr.computeScopeFlags(IRScope scope)
boolean	MatchInstr.computeScopeFlags(IRScope scope)
boolean	Match3Instr.computeScopeFlags(IRScope scope)
boolean	Match2Instr.computeScopeFlags(IRScope scope)
boolean	Instr.computeScopeFlags(IRScope scope) Does this instruction do anything the scope is interested in?
boolean	GetGlobalVariableInstr.computeScopeFlags(IRScope scope)
boolean	DefineMetaClassInstr.computeScopeFlags(IRScope scope)
boolean	DefineInstanceMethodInstr.computeScopeFlags(IRScope scope)
boolean	CallBase.computeScopeFlags(IRScope scope)
boolean	BuildLambdaInstr.computeScopeFlags(IRScope scope)
boolean	BreakInstr.computeScopeFlags(IRScope scope)
boolean	AttrAssignInstr.computeScopeFlags(IRScope scope)
boolean	AliasInstr.computeScopeFlags(IRScope scope)
Operand	ToAryInstr.simplifyAndGetResult(IRScope scope, Map<Operand,Operand> valueMap)
Operand	ReqdArgMultipleAsgnInstr.simplifyAndGetResult(IRScope scope, Map<Operand,Operand> valueMap)
Operand	Instr.simplifyAndGetResult(IRScope scope, Map<Operand,Operand> valueMap) This method takes as input a map of operands to their values, and outputs the result of this instruction.
Operand	CopyInstr.simplifyAndGetResult(IRScope scope, Map<Operand,Operand> valueMap)

Constructors in org.jruby.ir.instructions with parameters of type IRScope

Constructor and Description
InlinedLineNumberInstr(IRScope scope, int lineNumber)
LoadLocalVarInstr(IRScope scope, TemporaryLocalVariable result, LocalVariable lvar)
RecordEndBlockInstr(IRScope declaringScope, WrappedIRClosure endBlockClosure)
StoreLocalVarInstr(Operand value, IRScope scope, LocalVariable lvar)

Uses of IRScope in org.jruby.ir.interpreter

Methods in org.jruby.ir.interpreter with parameters of type IRScope

Modifier and Type	Method and Description
static Integer	Profiler.initProfiling(IRScope scope)
static void	Profiler.updateCallSite(Instr instr, IRScope scope, Integer scopeVersion)

Constructors in org.jruby.ir.interpreter with parameters of type IRScope

Constructor and Description
BeginEndInterpreterContext(IRScope scope, Instr[] instructions)
InterpreterContext(IRScope scope, Instr[] instructions)

Uses of IRScope in org.jruby.ir.listeners

Methods in org.jruby.ir.listeners with parameters of type IRScope

Modifier and Type	Method and Description
void	IRScopeListener.addedInstr(IRScope scope, Instr instr, int index)
void	IRScopeListener.endBuildOperand(Node node, IRScope scope, Operand operand)
void	IRScopeListener.startBuildOperand(Node node, IRScope scope)

Uses of IRScope in org.jruby.ir.passes

Methods in org.jruby.ir.passes with parameters of type IRScope

Modifier and Type	Method and Description
void	CompilerPassListener.alreadyExecuted(CompilerPass passClass, IRScope scope, Object data, boolean childScope) This dependent pass has been determined to already be satisfied and is not going to call execute().
void	BasicCompilerPassListener.alreadyExecuted(CompilerPass passClass, IRScope scope, Object data, boolean childScope)
void	OptimizeDynScopesPass.eliminateLocalVars(IRScope s)
void	CompilerPassListener.endExecute(CompilerPass pass, IRScope scope, Object data, boolean childScope) This pass has just finished execute'ing.
void	BasicCompilerPassListener.endExecute(CompilerPass pass, IRScope scope, Object data, boolean childScope)
Object	UnboxingPass.execute(IRScope scope, Object... data)
Object	OptimizeTempVarsPass.execute(IRScope s, Object... data)
Object	OptimizeDynScopesPass.execute(IRScope scope, Object... data)
Object	LocalOptimizationPass.execute(IRScope s, Object... data)
Object	LiveVariableAnalysis.execute(IRScope scope, Object... data)
Object	LinearizeCFG.execute(IRScope scope, Object... data)
Object	EnsureTempsAssigned.execute(IRScope scope, Object... data)
Object	DominatorTreeBuilder.execute(IRScope scope, Object... data)
Object	DeadCodeElimination.execute(IRScope scope, Object... data)
abstract Object	CompilerPass.execute(IRScope scope, Object... dependencyData) Meat of an individual pass.
Object	CFGBuilder.execute(IRScope scope, Object... data)
Object	AddLocalVarLoadStoreInstructions.execute(IRScope s, Object... data)
Object	AddCallProtocolInstructions.execute(IRScope scope, Object... data)
boolean	UnboxingPass.invalidate(IRScope scope)
boolean	OptimizeTempVarsPass.invalidate(IRScope s)
boolean	OptimizeDynScopesPass.invalidate(IRScope scope)
boolean	LiveVariableAnalysis.invalidate(IRScope scope)
boolean	LinearizeCFG.invalidate(IRScope scope)
boolean	DominatorTreeBuilder.invalidate(IRScope scope)
boolean	CompilerPass.invalidate(IRScope scope) The data that this pass is responsible for will get invalidated so that if this pass is then executed it will generate new pass data.
boolean	CFGBuilder.invalidate(IRScope scope)
boolean	AddLocalVarLoadStoreInstructions.invalidate(IRScope scope)
boolean	AddCallProtocolInstructions.invalidate(IRScope scope)
Object	UnboxingPass.previouslyRun(IRScope scope)
Object	LiveVariableAnalysis.previouslyRun(IRScope scope)
Object	CompilerPass.previouslyRun(IRScope scope) If this pass has been previous run, then return the data from that last run.
Object	CFGBuilder.previouslyRun(IRScope scope)
Object	AddLocalVarLoadStoreInstructions.previouslyRun(IRScope scope)
Object	CompilerPass.run(IRScope scope)
Object	CompilerPass.run(IRScope scope, boolean force)
protected Object	CompilerPass.run(IRScope scope, boolean force, boolean childScope)
static void	LocalOptimizationPass.runLocalOptsOnInstrList(IRScope s, ListIterator<Instr> instrs, boolean preCFG)
void	CompilerPassListener.startExecute(CompilerPass pass, IRScope scope, boolean childScope) This pass is about to begin execute'ing.
void	BasicCompilerPassListener.startExecute(CompilerPass pass, IRScope scope, boolean childScope)

Uses of IRScope in org.jruby.ir.persistence

Methods in org.jruby.ir.persistence that return IRScope

Modifier and Type	Method and Description
static IRScope	IRReader.createScope(IRManager manager, IRScopeType type, String name, int line, IRScope lexicalParent, Signature signature, int argumentType, StaticScope staticScope)
IRScope	IRReaderFile.decodeScope()
IRScope	IRReaderDecoder.decodeScope()
IRScope	IRReaderFile.getCurrentScope()
IRScope	IRReaderDecoder.getCurrentScope()
static IRScope	IRReader.load(IRManager manager, IRReaderDecoder file)

Methods in org.jruby.ir.persistence with parameters of type IRScope

Modifier and Type	Method and Description
void	IRReaderFile.addScope(IRScope scope)
void	IRReaderDecoder.addScope(IRScope scope)
void	IRWriterFile.addScopeInstructionOffset(IRScope scope) Record current offset as the beginning of specified scopes list of instructions.
static IRScope	IRReader.createScope(IRManager manager, IRScopeType type, String name, int line, IRScope lexicalParent, Signature signature, int argumentType, StaticScope staticScope)
List<Instr>	IRReaderFile.decodeInstructionsAt(IRScope scope, int offset)
List<Instr>	IRReaderDecoder.decodeInstructionsAt(IRScope scope, int offset)
void	IRWriterFile.encode(IRScope value)
void	IRWriterEncoder.encode(IRScope scope)
void	IRWriterAnalzer.encode(IRScope value)
void	IRWriterFile.endEncoding(IRScope script)
void	IRWriterEncoder.endEncoding(IRScope script)
void	IRWriterAnalzer.endEncoding(IRScope script)
void	IRWriterFile.endEncodingScopeHeader(IRScope scope)
void	IRWriterEncoder.endEncodingScopeHeader(IRScope scope)
void	IRWriterAnalzer.endEncodingScopeHeader(IRScope scope)
void	IRWriterFile.endEncodingScopeHeaders(IRScope script)
void	IRWriterEncoder.endEncodingScopeHeaders(IRScope script)
void	IRWriterAnalzer.endEncodingScopeHeaders(IRScope script)
void	IRWriterFile.endEncodingScopeInstrs(IRScope scope)
void	IRWriterEncoder.endEncodingScopeInstrs(IRScope scope)
void	IRWriterAnalzer.endEncodingScopeInstrs(IRScope scope)
int	IRWriterAnalzer.getScopeID(IRScope value)
int	IRWriterFile.getScopeInstructionOffset(IRScope scope) Get recorded offset for this scropes instruction list.
static void	IRWriter.persist(IRWriterEncoder file, IRScope script)
void	IRWriterFile.startEncoding(IRScope script)
void	IRWriterEncoder.startEncoding(IRScope script)
void	IRWriterAnalzer.startEncoding(IRScope script)
void	IRWriterFile.startEncodingScopeHeader(IRScope scope)
void	IRWriterEncoder.startEncodingScopeHeader(IRScope scope)
void	IRWriterAnalzer.startEncodingScopeHeader(IRScope scope)
void	IRWriterFile.startEncodingScopeHeaders(IRScope script)
void	IRWriterEncoder.startEncodingScopeHeaders(IRScope script)
void	IRWriterAnalzer.startEncodingScopeHeaders(IRScope script)
void	IRWriterFile.startEncodingScopeInstrs(IRScope scope)
void	IRWriterEncoder.startEncodingScopeInstrs(IRScope scope)
void	IRWriterAnalzer.startEncodingScopeInstrs(IRScope scope)

Uses of IRScope in org.jruby.ir.representations

Methods in org.jruby.ir.representations that return IRScope

Modifier and Type	Method and Description
IRScope	CFG.getScope()

Methods in org.jruby.ir.representations with parameters of type IRScope

Modifier and Type	Method and Description
CFG	CFG.clone(CloneInfo info, IRScope clonedScope) Clone this CFG and return a new one.

Constructors in org.jruby.ir.representations with parameters of type IRScope

Constructor and Description
CFG(IRScope scope)

Uses of IRScope in org.jruby.ir.runtime

Methods in org.jruby.ir.runtime with parameters of type IRScope

Modifier and Type	Method and Description
static void	IRRuntimeHelpers.defCompiledClassMethod(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope method, IRubyObject obj)
static void	IRRuntimeHelpers.defCompiledClassMethod(ThreadContext context, java.lang.invoke.MethodHandle variable, java.lang.invoke.MethodHandle specific, int specificArity, IRScope method, IRubyObject obj)
static void	IRRuntimeHelpers.defCompiledInstanceMethod(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope method, DynamicScope currDynScope, IRubyObject self)
static void	IRRuntimeHelpers.defCompiledInstanceMethod(ThreadContext context, java.lang.invoke.MethodHandle variable, java.lang.invoke.MethodHandle specific, int specificArity, IRScope method, DynamicScope currDynScope, IRubyObject self)
static void	IRRuntimeHelpers.defCompiledIRClassMethod(ThreadContext context, IRubyObject obj, java.lang.invoke.MethodHandle handle, String rubyName, IRScope irScope)
static void	IRRuntimeHelpers.defCompiledIRMethod(ThreadContext context, java.lang.invoke.MethodHandle handle, String rubyName, DynamicScope currDynScope, IRubyObject self, IRScope irScope)
static void	IRRuntimeHelpers.defInterpretedClassMethod(ThreadContext context, IRScope method, IRubyObject obj)
static void	IRRuntimeHelpers.defInterpretedInstanceMethod(ThreadContext context, IRScope method, DynamicScope currDynScope, IRubyObject self)
static DynamicMethod	IRRuntimeHelpers.newCompiledClassBody(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope irClassBody, Object container, Object superClass)
static DynamicMethod	IRRuntimeHelpers.newCompiledMetaClass(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope metaClassBody, IRubyObject obj) Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
static DynamicMethod	IRRuntimeHelpers.newCompiledModuleBody(ThreadContext context, java.lang.invoke.MethodHandle handle, IRScope irModule, Object rubyContainer)
static DynamicMethod	IRRuntimeHelpers.newInterpretedClassBody(ThreadContext context, IRScope irClassBody, Object container, Object superClass)
static DynamicMethod	IRRuntimeHelpers.newInterpretedMetaClass(Ruby runtime, IRScope metaClassBody, IRubyObject obj) Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
static DynamicMethod	IRRuntimeHelpers.newInterpretedModuleBody(ThreadContext context, IRScope irModule, Object rubyContainer) Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
static RubyModule	IRRuntimeHelpers.newRubyClassFromIR(Ruby runtime, IRScope irClassBody, Object superClass, Object container)

Uses of IRScope in org.jruby.ir.targets

Fields in org.jruby.ir.targets declared as IRScope

Modifier and Type	Field and Description
IRScope	MethodData.scope

Methods in org.jruby.ir.targets with parameters of type IRScope

Modifier and Type	Method and Description
void	JVMVisitor.codegenScope(IRScope scope)
Class	JVMVisitor.compile(IRScope scope, ClassDefiningClassLoader jrubyClassLoader)
byte[]	JVMVisitor.compileToBytecode(IRScope scope)
Class	JVMVisitor.defineFromBytecode(IRScope scope, byte[] code, ClassDefiningClassLoader jrubyClassLoader)
void	JVMVisitor.emitScope(IRScope scope, String name, com.headius.invokebinder.Signature signature, boolean specificArity)
void	JVM.pushmethod(String name, IRScope scope, com.headius.invokebinder.Signature signature, boolean specificArity)
static com.headius.invokebinder.Signature	JVMVisitor.signatureFor(IRScope method, boolean aritySplit)

Constructors in org.jruby.ir.targets with parameters of type IRScope

Constructor and Description
MethodData(IRBytecodeAdapter method, IRScope scope, com.headius.invokebinder.Signature signature, int specificArity)

Uses of IRScope in org.jruby.ir.transformations.inlining

Fields in org.jruby.ir.transformations.inlining declared as IRScope

Modifier and Type	Field and Description
protected IRScope	CloneInfo.scope

Methods in org.jruby.ir.transformations.inlining that return IRScope

Modifier and Type	Method and Description
IRScope	InlineCloneInfo.getHostScope()
IRScope	CloneInfo.getScope()
IRScope	InlineCloneInfo.getScopeBeingInlined()

Methods in org.jruby.ir.transformations.inlining with parameters of type IRScope

Modifier and Type	Method and Description
InlineCloneInfo	InlineCloneInfo.cloneForInliningClosure(IRScope scopeBeingInlined)
void	CFGInliner.inlineMethod(IRScope scope, RubyModule implClass, int classToken, BasicBlock callBB, CallBase call, boolean cloneHost)

Constructors in org.jruby.ir.transformations.inlining with parameters of type IRScope

Constructor and Description
CloneInfo(IRScope scope)
InlineCloneInfo(CallBase call, CFG c, Variable callReceiver, IRScope scopeBeingInlined)
InlineCloneInfo(CFG cfg, IRScope scope, IRScope scopeBeingInlined)
SimpleCloneInfo(IRScope scope, boolean isEnsureBlock)

Uses of IRScope in org.jruby.parser

Methods in org.jruby.parser that return IRScope

Modifier and Type	Method and Description
IRScope	StaticScope.getIRScope()

Methods in org.jruby.parser with parameters of type IRScope

Modifier and Type	Method and Description
void	StaticScope.setIRScope(IRScope irScope)
void	StaticScope.setIRScope(IRScope irScope, boolean isForLoopBody)

Uses of IRScope in org.jruby.runtime

Constructors in org.jruby.runtime with parameters of type IRScope

Constructor and Description
CompiledIRBlockBody(java.lang.invoke.MethodHandle handle, IRScope closure, long encodedSignature)