Uses of Class
org.jruby.ir.IRScope

Packages that use IRScope

Package	Description
org.jruby
org.jruby.ast.util
org.jruby.compiler
org.jruby.internal.runtime
org.jruby.internal.runtime.methods
org.jruby.ir
org.jruby.ir.instructions
org.jruby.ir.instructions.specialized
org.jruby.ir.interpreter
org.jruby.ir.listeners
org.jruby.ir.operands
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
org.jruby.runtime.callsite
org.jruby.runtime.load
org.jruby.util

Uses of IRScope in org.jruby

Methods in org.jruby with parameters of type IRScope

Modifier and Type	Method	Description
void	Ruby.loadScope(IRScope scope, boolean wrap)

Uses of IRScope in org.jruby.ast.util

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

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

Uses of IRScope in org.jruby.compiler

Methods in org.jruby.compiler that return IRScope

Modifier and Type	Method	Description
IRScope	Compilable.getIRScope()

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

Modifier and Type	Method	Description
protected Class<?>	JITCompiler.Task.defineClass(JITClassGenerator generator, JVMVisitor visitor, IRScope scope, InterpreterContext interpreterContext)

Uses of IRScope in org.jruby.internal.runtime

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

Modifier and Type	Field	Description
protected IRScope	AbstractIRMethod.method

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

Modifier and Type	Method	Description
IRScope	AbstractIRMethod.getIRScope()

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

Modifier	Constructor	Description
	AbstractIRMethod(IRScope method, Visibility visibility, RubyModule implementationClass)

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

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

Modifier	Constructor	Description
	CompiledIRMethod(MethodHandle variable, MethodHandle specific, int specificArity, IRScope method, Visibility visibility, RubyModule implementationClass, String encodedArgumentDescriptors)
	CompiledIRMethod(MethodHandle variable, IRScope method, Visibility visibility, RubyModule implementationClass, String encodedArgumentDescriptors)
	DefineMethodMethod(IRScope method, Visibility visibility, RubyModule implementationClass, Block capturedBlock)
	InterpretedIRBodyMethod(IRScope method, RubyModule implementationClass)
	InterpretedIRMetaClassBody(IRScope metaClassBody, RubyModule implementationClass)
	InterpretedIRMethod(IRScope method, Visibility visibility, RubyModule implementationClass)
	MixedModeIRMethod(IRScope method, Visibility visibility, RubyModule implementationClass)

Uses of IRScope in org.jruby.ir

Subclasses of IRScope in org.jruby.ir

Modifier and Type	Class	Description
class	IRClassBody
class	IRClosure
class	IREvalScript
class	IRFor	Represents a 'for' loop
class	IRMetaClassBody
class	IRMethod
class	IRModuleBody
class	IRScriptBody

Fields in org.jruby.ir declared as IRScope

Modifier and Type	Field	Description
final IRScope	IRBuilder.IRLoop.container
private final IRScope	IRScope.lexicalParent	Lexical parent scope
protected final IRScope	IRBuilder.scope

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

Modifier and Type	Field	Description
private final List<IRScope>	IRScope.lexicalChildren

Methods in org.jruby.ir that return IRScope

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

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

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

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

Modifier and Type	Method	Description
protected void	IRScope.addChildScope(IRScope scope)
static EnumSet<IRFlags>	IRScope.allocateInitialFlags(IRScope scope)
protected InterpreterContext	IRBuilder.defineMethodInner(DefNode defNode, IRScope parent, int coverageMode)
static Operand[]	IRBuilder.getCallArgs(IRScope scope, IRBuilder builder)	Extract all call arguments from the specified scope (only useful for Closures and Methods) so that we can convert zsupers to supers with explicit arguments.
private static Operand[]	IRBuilder.getCallOperands(IRScope scope, List<Operand> callArgs, List<KeyValuePair<Operand,Operand>> keywordArgs)
List<CompilerPass>	IRManager.getCompilerPasses(IRScope scope)
List<CompilerPass>	IRManager.getInliningCompilerPasses(IRScope scope)
List<CompilerPass>	IRManager.getJITPasses(IRScope scope)
List<CompilerPass>	IRManager.getSafePasses(IRScope scope)
private String	IRBuilder.getVarNameFromScopeTree(IRScope scope, int depth, int offset)
boolean	IRScope.isScopeContainedBy(IRScope parentScope)	returns whether this scope is contained by the parentScope parameter.
IRBuilder	IRBuilder.newIRBuilder(IRManager manager, IRScope newScope)
static IRBuilder	IRBuilder.topIRBuilder(IRManager manager, IRScope newScope)

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

Modifier	Constructor	Description
	EnsureBlockInfo(IRScope s, RescueNode n, IRBuilder.IRLoop l, Label bodyRescuer)
	IRBuilder(IRManager manager, IRScope scope, IRBuilder parent)
	IRBuilder(IRManager manager, IRScope scope, IRBuilder parent, IRBuilder variableBuilder)
	IRClassBody(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope scope, boolean executesOnce)
protected	IRClosure(IRClosure c, IRScope lexicalParent, int closureId, ByteList fullName)	Used by cloning code for inlining
protected	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, int closureId, ByteList fullName)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, int coverageMode)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix, boolean isBeginEndBlock)
	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList prefix, boolean isBeginEndBlock, int coverageMode)
protected	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, ByteList prefix)
protected	IRClosure(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, ByteList prefix, int coverageMode)
	IREvalScript(IRManager manager, IRScope lexicalParent, String fileName, int lineNumber, StaticScope staticScope, EvalType evalType)
private	IRFor(IRClosure c, IRScope lexicalParent, int id, ByteList fullName)	Used by cloning code for inlining
	IRFor(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature)
	IRFor(IRManager manager, IRScope lexicalParent, int lineNumber, StaticScope staticScope, Signature signature, ByteList labelPrefix)
	IRLoop(IRScope s, IRBuilder.IRLoop outerLoop, Variable result)
	IRMetaClassBody(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope scope)
	IRMethod(IRManager manager, IRScope lexicalParent, DefNode defn, ByteList name, boolean isInstanceMethod, int lineNumber, StaticScope staticScope, int coverageMode)
	IRModuleBody(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope staticScope, boolean executesOnce)
	IRScope(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope staticScope)
	IRScope(IRManager manager, IRScope lexicalParent, ByteList name, int lineNumber, StaticScope staticScope, int coverageMode)
protected	IRScope(IRScope s, IRScope lexicalParent)

Uses of IRScope in org.jruby.ir.instructions

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

Modifier and Type	Field	Description
private final IRScope	RecordEndBlockInstr.declaringScope
private final IRScope	InlinedLineNumberInstr.scope
private final IRScope	LoadLocalVarInstr.scope
private final IRScope	StoreLocalVarInstr.scope

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

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

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

Modifier and Type	Method	Description
boolean	AliasInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	BreakInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	BuildBackrefInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	BuildLambdaInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	CallBase.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	CheckForLJEInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	ClassSuperInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	DefineInstanceMethodInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	DefineMetaClassInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	InstanceSuperInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	Instr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)	Does this instruction do anything the scope is interested in?
boolean	LoadBlockImplicitClosureInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	LoadFrameClosureInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	MatchInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	NonlocalReturnInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	PutGlobalVarInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	ReceiveKeywordArgInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	ReceiveKeywordRestArgInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	RecordEndBlockInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	ReifyClosureInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	RuntimeHelperCall.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)	Does this instruction do anything the scope is interested in?
boolean	TraceInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	UndefMethodInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	UnresolvedSuperInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
boolean	ZSuperInstr.computeScopeFlags(IRScope scope, EnumSet<IRFlags> flags)
static ArrayDerefInstr	ArrayDerefInstr.create(IRScope scope, Variable result, Operand obj, FrozenString arg0)
static AttrAssignInstr	AttrAssignInstr.create(IRScope scope, Operand obj, RubySymbol attr, Operand[] args, boolean isPotentiallyRefined)
static AttrAssignInstr	AttrAssignInstr.create(IRScope scope, Operand obj, RubySymbol attr, Operand[] args, Operand block, boolean isPotentiallyRefined)
static CallInstr	CallInstr.create(IRScope scope, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure)
static CallInstr	CallInstr.create(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure)
static NoResultCallInstr	NoResultCallInstr.create(IRScope scope, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
static CallInstr	CallInstr.createWithKwargs(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure, List<KeyValuePair<Operand,Operand>> kwargs)
protected static CallSite	CallBase.getCallSiteFor(IRScope scope, CallType callType, String name, long callsiteId, boolean hasLiteralClosure, boolean potentiallyRefined)
Operand	CopyInstr.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	ReqdArgMultipleAsgnInstr.simplifyAndGetResult(IRScope scope, Map<Operand,Operand> valueMap)
Operand	ToAryInstr.simplifyAndGetResult(IRScope scope, Map<Operand,Operand> valueMap)

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

Modifier	Constructor	Description
	ArrayDerefInstr(IRScope scope, Variable result, Operand obj, FrozenString arg0)
	ArrayDerefInstr(IRScope scope, Variable result, Operand obj, FrozenString arg0, CallSite callSite, long callSiteId)
	AsStringInstr(IRScope scope, Variable result, Operand source, boolean isPotentiallyRefined)
private	AsStringInstr(IRScope scope, Variable result, Operand source, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
	AttrAssignInstr(IRScope scope, Operand obj, RubySymbol attr, Operand[] args, Operand block, boolean isPotentiallyRefined)
protected	AttrAssignInstr(IRScope scope, CallType callType, RubySymbol name, Operand receiver, Operand[] args, boolean potentiallyRefined, CallSite callSite, long callSiteId)
protected	CallBase(IRScope scope, Operation op, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined)
protected	CallBase(IRScope scope, Operation op, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined, CallSite callSite, long callSiteId)
protected	CallInstr(IRScope scope, Operation op, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined)
protected	CallInstr(IRScope scope, Operation op, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	CallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined)
	ClassSuperInstr(IRScope scope, Variable result, Operand definingModule, RubySymbol name, Operand[] args, Operand closure, boolean isPotentiallyRefined)
protected	ClassSuperInstr(IRScope scope, Variable result, Operand receiver, RubySymbol name, Operand[] args, Operand closure, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	EQQInstr(IRScope scope, Variable result, Operand v1, Operand v2, boolean splattedValue, boolean isPotentiallyRefined)
protected	EQQInstr(IRScope scope, Variable result, Operand v1, Operand v2, boolean splattedValue, boolean isPotentiallyRefined, CallSite callSite, long callSiteID)
	InlinedLineNumberInstr(IRScope scope, int lineNumber)
	InstanceSuperInstr(IRScope scope, Variable result, Operand definingModule, RubySymbol name, Operand[] args, Operand closure, boolean isPotentiallyRefined)
protected	InstanceSuperInstr(IRScope scope, Variable result, Operand definingModule, RubySymbol name, Operand[] args, Operand closure, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
	LoadLocalVarInstr(IRScope scope, TemporaryLocalVariable result, LocalVariable lvar)
	MatchInstr(IRScope scope, Variable result, Operand receiver, Operand arg)
protected	MatchInstr(IRScope scope, Variable result, Operand receiver, Operand arg, CallSite callSite, long callSiteId)
	NoResultCallInstr(IRScope scope, Operation op, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
protected	NoResultCallInstr(IRScope scope, Operation op, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	RecordEndBlockInstr(IRScope declaringScope, WrappedIRClosure endBlockClosure)
	StoreLocalVarInstr(IRScope scope, Operand value, LocalVariable lvar)
	UnresolvedSuperInstr(IRScope scope, Variable result, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
	UnresolvedSuperInstr(IRScope scope, Operation op, Variable result, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
	UnresolvedSuperInstr(IRScope scope, Operation op, Variable result, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
	ZSuperInstr(IRScope scope, Variable result, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
	ZSuperInstr(IRScope scope, Variable result, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)

Uses of IRScope in org.jruby.ir.instructions.specialized

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

Modifier	Constructor	Description
	OneArgOperandAttrAssignInstr(IRScope scope, Operand obj, RubySymbol attr, Operand[] args, boolean isPotentiallyRefined)
protected	OneArgOperandAttrAssignInstr(IRScope scope, CallType callType, RubySymbol name, Operand receiver, Operand[] args, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	OneFixnumArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean potentiallyRefined)
protected	OneFixnumArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	OneFloatArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean potentiallyRefined)
protected	OneFloatArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	OneOperandArgBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
	OneOperandArgBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
	OneOperandArgNoBlockCallInstr(IRScope scope, Operation op, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined)
	OneOperandArgNoBlockCallInstr(IRScope scope, Operation op, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
	OneOperandArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined)
	OneOperandArgNoBlockNoResultCallInstr(IRScope scope, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean isPotentiallyRefined)
protected	OneOperandArgNoBlockNoResultCallInstr(IRScope scope, CallType callType, RubySymbol name, Operand receiver, Operand[] args, Operand closure, boolean potentiallyRefined, CallSite callSite, long callSiteId)
	TwoOperandArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined)
protected	TwoOperandArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
protected	ZeroOperandArgNoBlockCallInstr(IRScope scope, Operation op, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined)
	ZeroOperandArgNoBlockCallInstr(IRScope scope, Operation op, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined, CallSite callSite, long callSiteId)
	ZeroOperandArgNoBlockCallInstr(IRScope scope, CallType callType, Variable result, RubySymbol name, Operand receiver, Operand[] args, boolean isPotentiallyRefined)

Uses of IRScope in org.jruby.ir.interpreter

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

Modifier and Type	Field	Description
(package private) IRScope	Profiler.IRCallSite.s
private final IRScope	InterpreterContext.scope

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

Modifier and Type	Field	Description
(package private) final HashMap<IRScope,Counter>	Profiler.CallSiteProfile.counters
private static HashMap<IRScope,Counter>	Profiler.scopeThreadPollCounts
private static final HashMap<IRScope,Integer>	Profiler.scopeVersionMap

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

Modifier and Type	Method	Description
IRScope	InterpreterContext.getScope()

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

Modifier and Type	Method	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

Modifier	Constructor	Description
	FullInterpreterContext(IRScope scope, Instr[] instructions, int temporaryVariableCount, EnumSet<IRFlags> flags)
	FullInterpreterContext(IRScope scope, CFG cfg, BasicBlock[] linearizedBBList, int temporaryVariableCount, EnumSet<IRFlags> flags)
	InterpreterContext(IRScope scope, Supplier<List<Instr>> instructions, int temporaryVariableCount, EnumSet<IRFlags> flags)
	InterpreterContext(IRScope scope, List<Instr> instructions, int temporaryVariableCount, EnumSet<IRFlags> flags)

Uses of IRScope in org.jruby.ir.listeners

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

Modifier and Type	Method	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.operands

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

Modifier and Type	Field	Description
private final IRScope	Scope.scope

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

Modifier and Type	Method	Description
IRScope	Scope.getScope()

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

Modifier	Constructor	Description
	NthRef(IRScope scope, int matchNumber)
	Scope(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	Description
private boolean	AddCallProtocolInstructions.explicitCallProtocolSupported(IRScope scope)
private String	BasicCompilerPassListener.getScopeUUID(IRScope scope)
boolean	UnboxingPass.invalidate(IRScope scope)

Uses of IRScope in org.jruby.ir.persistence

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

Modifier and Type	Field	Description
private IRScope	IRReaderStream.currentScope
(package private) IRScope	IRWriterStream.currentScope

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

Modifier and Type	Field	Description
private final Map<IRScope,Integer>	IRWriterAnalyzer.offsetIds
private final Map<IRScope,Integer>	IRWriterStream.scopeInstructionOffsets
private final Map<IRScope,Integer>	IRWriterStream.scopePoolOffsets
private final List<IRScope>	IRReaderStream.scopes

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

Modifier and Type	Method	Description
static IRScope	IRReader.createScope(IRManager manager, IRScopeType type, ByteList byteName, String file, int line, IRScope lexicalParent, Signature signature, StaticScope staticScope)
IRScope	IRReaderDecoder.decodeScope()
IRScope	IRReaderStream.decodeScope()
private static IRScope	IRReader.decodeScopeHeader(IRManager manager, IRReaderDecoder decoder, IRScopeType type, int line)
IRScope	IRReaderDecoder.getCurrentScope()
IRScope	IRReaderStream.getCurrentScope()
IRScope	IRWriterAnalyzer.getCurrentScope()
IRScope	IRWriterEncoder.getCurrentScope()
IRScope	IRWriterStream.getCurrentScope()
static IRScope	IRReader.load(IRManager manager, IRReaderDecoder file)

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

Modifier and Type	Method	Description
void	IRReaderDecoder.addScope(IRScope scope)
void	IRReaderStream.addScope(IRScope scope)
void	IRWriterStream.addScopeInstructionOffset(IRScope scope)	Record current offset as the beginning of specified scopes list of instructions.
static IRScope	IRReader.createScope(IRManager manager, IRScopeType type, ByteList byteName, String file, int line, IRScope lexicalParent, Signature signature, StaticScope staticScope)
List<Instr>	IRReaderDecoder.decodeInstructionsAt(IRScope scope, int poolOffset, int instructionOffset)
List<Instr>	IRReaderStream.decodeInstructionsAt(IRScope scope, int poolOffset, int offset)
void	IRWriterAnalyzer.encode(IRScope value)
void	IRWriterEncoder.encode(IRScope scope)
void	IRWriterStream.encode(IRScope value)
void	IRWriterAnalyzer.endEncoding(IRScope script)
void	IRWriterEncoder.endEncoding(IRScope script)
void	IRWriterStream.endEncoding(IRScope script)
void	IRWriterAnalyzer.endEncodingScopeHeader(IRScope scope)
void	IRWriterEncoder.endEncodingScopeHeader(IRScope scope)
void	IRWriterStream.endEncodingScopeHeader(IRScope scope)
void	IRWriterAnalyzer.endEncodingScopeHeaders(IRScope script)
void	IRWriterEncoder.endEncodingScopeHeaders(IRScope script)
void	IRWriterStream.endEncodingScopeHeaders(IRScope script)
void	IRWriterAnalyzer.endEncodingScopeInstrs(IRScope scope)
void	IRWriterEncoder.endEncodingScopeInstrs(IRScope scope)
void	IRWriterStream.endEncodingScopeInstrs(IRScope scope)
int	IRWriterAnalyzer.getScopeID(IRScope value)
int	IRWriterStream.getScopeInstructionOffset(IRScope scope)	Get recorded offset for this scropes instruction list.
static void	IRWriter.persist(IRWriterEncoder file, IRScope script)
private static void	IRWriter.persistScopeHeader(IRWriterEncoder file, IRScope scope)
private static void	IRWriter.persistScopeHeaders(IRWriterEncoder file, IRScope parent)
private static void	IRWriter.persistScopeInstrs(IRWriterEncoder file, IRScope scope)
private static void	IRWriter.persistScopeInstructions(IRWriterEncoder file, IRScope parent)
static ByteArrayOutputStream	IRDumper.printIR(IRScope scope, boolean full)
static ByteArrayOutputStream	IRDumper.printIR(IRScope scope, boolean full, boolean recurse)
void	IRWriterAnalyzer.startEncoding(IRScope script)
void	IRWriterEncoder.startEncoding(IRScope script)
void	IRWriterStream.startEncoding(IRScope script)
void	IRWriterAnalyzer.startEncodingScopeHeader(IRScope scope)
void	IRWriterEncoder.startEncodingScopeHeader(IRScope scope)
void	IRWriterStream.startEncodingScopeHeader(IRScope scope)
void	IRWriterAnalyzer.startEncodingScopeHeaders(IRScope script)
void	IRWriterEncoder.startEncodingScopeHeaders(IRScope script)
void	IRWriterStream.startEncodingScopeHeaders(IRScope script)
void	IRWriterAnalyzer.startEncodingScopeInstrs(IRScope scope)
void	IRWriterEncoder.startEncodingScopeInstrs(IRScope scope)
void	IRWriterStream.startEncodingScopeInstrs(IRScope scope)
void	IRDumper.visit(IRScope scope, boolean full, boolean recurse)

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

Modifier	Constructor	Description
private	IRReaderStream(ByteBuffer buf, IRManager manager, List<IRScope> scopes, IRScope currentScope, ByteList filename, RubySymbol[] constantPool)

Constructor parameters in org.jruby.ir.persistence with type arguments of type IRScope

Modifier	Constructor	Description
private	IRReaderStream(ByteBuffer buf, IRManager manager, List<IRScope> scopes, IRScope currentScope, ByteList filename, RubySymbol[] constantPool)

Uses of IRScope in org.jruby.ir.representations

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

Modifier and Type	Field	Description
private final IRScope	CFG.scope

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

Modifier and Type	Method	Description
IRScope	CFG.getScope()

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

Modifier and Type	Method	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

Modifier	Constructor	Description
	CFG(IRScope scope)

Uses of IRScope in org.jruby.ir.runtime

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

Modifier and Type	Method	Description
static IRScope	IRRuntimeHelpers.decodeScopeFromBytes(Ruby runtime, byte[] scopeBytes, String filename)

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

Modifier and Type	Method	Description
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.newInterpretedMetaClass(Ruby runtime, IRScope metaClassBody, IRubyObject obj)	Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object.
static ProfilingCachingCallSite	IRRuntimeHelpers.newProfilingCachingCallSite(CallType callType, String name, IRScope scope, long callSiteId)

Uses of IRScope in org.jruby.ir.targets

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

Modifier and Type	Field	Description
final IRScope	MethodData.scope

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

Modifier and Type	Method	Description
protected void	JVMVisitor.codegenScope(IRScope scope, JVMVisitorMethodContext context)
Class	JVMVisitor.compile(IRScope scope, ClassDefiningClassLoader jrubyClassLoader)
byte[]	JVMVisitor.compileToBytecode(IRScope scope, JVMVisitorMethodContext context)
Class	JVMVisitor.defineFromBytecode(IRScope scope, byte[] code, ClassDefiningClassLoader jrubyClassLoader)	Define a scope's compiled class from bytecode.
Class	JVMVisitor.defineFromBytecode(IRScope scope, byte[] code, ClassDefiningClassLoader jrubyClassLoader, boolean setScopes)
Class	JVMVisitor.defineScriptFromBytecode(IRScope scope, byte[] code, ClassDefiningClassLoader jrubyClassLoader)	Define a class from a top-level script's bytecode.
private void	JVMVisitor.emitClosures(IRScope s, boolean print)
protected void	JVMVisitor.emitScope(IRScope scope, String name, com.headius.invokebinder.Signature signature, boolean specificArity, boolean print)
protected void	JVMVisitor.emitVarargsMethodWrapper(IRScope scope, String variableName, String specificName, com.headius.invokebinder.Signature variableSignature, com.headius.invokebinder.Signature specificSignature)
void	ClassData.pushmethod(String name, IRScope scope, String scopeField, com.headius.invokebinder.Signature signature, boolean specificArity)
void	JVM.pushmethod(String name, IRScope scope, String scopeField, com.headius.invokebinder.Signature signature, boolean specificArity)
private StaticScope	JVMVisitor.registerScopeField(IRScope scope, String scopeField)
protected static final com.headius.invokebinder.Signature	JVMVisitor.signatureFor(IRScope method, boolean aritySplit)

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

Modifier	Constructor	Description
	MethodData(IRBytecodeAdapter method, IRScope scope, String scopeField, 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	Description
private final IRScope	CFGInliner.hostScope
protected final IRScope	CloneInfo.scope
private final IRScope	InlineCloneInfo.scopeBeingInlined

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

Modifier and Type	Method	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	Description
InlineCloneInfo	InlineCloneInfo.cloneForInliningClosure(IRScope scopeBeingInlined)
String	CFGInliner.inlineMethod(IRScope scopeToInline, RubyModule implClass, int classToken, BasicBlock callBB, CallBase call, boolean cloneHost)
private boolean	CFGInliner.isRecursiveInline(IRScope methodScope)
private void	CFGInliner.printInlineDebugPrologue(IRScope scopeToInline, CallBase call)

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

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

Uses of IRScope in org.jruby.parser

Fields in org.jruby.parser declared as IRScope

Modifier and Type	Field	Description
private IRScope	StaticScope.irScope

Methods in org.jruby.parser that return IRScope

Modifier and Type	Method	Description
IRScope	StaticScope.getIRScope()

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

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

Uses of IRScope in org.jruby.runtime

Methods in org.jruby.runtime that return IRScope

Modifier and Type	Method	Description
IRScope	InterpretedIRBlockBody.getIRScope()
IRScope	MixedModeIRBlockBody.getIRScope()

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

Modifier and Type	Method	Description
static CallSite	MethodIndex.getProfilingCallSite(CallType callType, String name, IRScope scope, long callsiteId)
static StaticScope	Helpers.getStaticScope(IRScope scope)

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

Modifier	Constructor	Description
	IRBlockBody(IRScope closure, Signature signature)

Uses of IRScope in org.jruby.runtime.callsite

Fields in org.jruby.runtime.callsite declared as IRScope

Modifier and Type	Field	Description
private final IRScope	ProfilingCachingCallSite.hostScope

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

Modifier	Constructor	Description
	ProfilingCachingCallSite(CallType callType, String methodName, IRScope scope, long callSiteId)
	RefinedCachingCallSite(String methodName, IRScope scope, CallType callType)

Uses of IRScope in org.jruby.runtime.load

Methods in org.jruby.runtime.load that return IRScope

Modifier and Type	Method	Description
static IRScope	CompiledScriptLoader.loadScriptFromFile(Ruby runtime, InputStream inStream, File resourcePath, String resourceName, boolean isAbsolute)

Uses of IRScope in org.jruby.util

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

Modifier and Type	Method	Description
static String	JavaNameMangler.encodeScopeForBacktrace(IRScope scope)