public void AddInstructions(LightCompiler compiler)
{
if (this.LoopStatementCount < 300)
{
this.EnterLoopInstruction = new System.Management.Automation.Interpreter.EnterLoopInstruction(this.Loop, compiler.Locals, 0x10, compiler.Instructions.Count);
compiler.Instructions.Emit(this.EnterLoopInstruction);
}
}
public void AddInstructions(LightCompiler compiler)
{
EnterLoopInstruction enterLoopInstruction = null;
compiler.PushLabelBlock(LabelScopeKind.Statement);
foreach (Expression expression in this._exprs)
{
compiler.CompileAsVoid(expression);
EnterLoopExpression expression2 = expression as EnterLoopExpression;
if (expression2 != null)
{
enterLoopInstruction = expression2.EnterLoopInstruction;
}
}
compiler.PopLabelBlock(LabelScopeKind.Statement);
if (enterLoopInstruction != null)
{
enterLoopInstruction.FinishLoop(compiler.Instructions.Count);
}
}
public void AddInstructions(LightCompiler compiler)
{
compiler.Instructions.Emit(UpdatePositionInstruction.Create(this._sequencePoint, this._checkBreakpoints));
}
private void CompileLambdaExpression(Expression expr)
{
LambdaExpression node = (LambdaExpression) expr;
LightCompiler compiler = new LightCompiler(this);
LightDelegateCreator creator = compiler.CompileTop(node);
if (compiler._locals.ClosureVariables != null)
{
foreach (ParameterExpression expression2 in compiler._locals.ClosureVariables.Keys)
{
this.CompileGetBoxedVariable(expression2);
}
}
this._instructions.EmitCreateDelegate(creator);
}
private LightCompiler(LightCompiler parent) : this(parent._compilationThreshold)
{
this._parent = parent;
}
public void AddInstructions(LightCompiler compiler)
{
// The EnterLoopInstruction is the instruction the interpreter uses to track the number of iterations a loop
// has executed and the instruction that kicks of the background compilation.
// If the statement count is too high, JIT takes too much time/resources to compile, so
// we just skip it. By not emitting a EnterLoopInstruction, we'll never attempt to JIT the loop body.
if (LoopStatementCount < 300)
{
// Start compilation after 16 iterations of the loop.
EnterLoopInstruction = new EnterLoopInstruction(Loop, compiler.Locals, 16, compiler.Instructions.Count);
compiler.Instructions.Emit(EnterLoopInstruction);
}
}
public void AddInstructions(LightCompiler compiler)
{
EnterLoopInstruction enterLoop = null;
compiler.PushLabelBlock(LabelScopeKind.Statement);
// emit loop body:
foreach (var expr in _exprs)
{
compiler.CompileAsVoid(expr);
var enterLoopExpression = expr as EnterLoopExpression;
if (enterLoopExpression != null)
{
enterLoop = enterLoopExpression.EnterLoopInstruction;
}
}
compiler.PopLabelBlock(LabelScopeKind.Statement);
// If enterLoop is null, we will never JIT compile the loop.
if (enterLoop != null)
{
enterLoop.FinishLoop(compiler.Instructions.Count);
}
}
private Action<FunctionContext> CompileTree(Expression<Action<FunctionContext>> lambda, CompileInterpretChoice compileInterpretChoice)
{
if (lambda == null)
return null;
if (compileInterpretChoice == CompileInterpretChoice.AlwaysCompile)
{
return lambda.Compile();
}
// threshold is # of times the script must run before we decide to compile
// NeverCompile sets the threshold to int.MaxValue, so theoretically we might compile
// at some point, but it's very unlikely.
int threshold = (compileInterpretChoice == CompileInterpretChoice.NeverCompile) ? int.MaxValue : -1;
var deleg = new LightCompiler(threshold).CompileTop(lambda).CreateDelegate();
return (Action<FunctionContext>)deleg;
}
public virtual object GetDebugCookie(LightCompiler compiler)
{
return null;
}
