public MetadataToken GetStandAloneSignature(CallSite call_site)
{
var signature = metadata.GetCallSiteBlobIndex(call_site);
var token = GetStandAloneSignatureToken(signature);
call_site.MetadataToken = token;
return token;
}
public Instruction Create (OpCode opcode, CallSite site)
{
if (site == null)
throw new ArgumentNullException ("site");
if (opcode.Code != Code.Calli)
throw new ArgumentException ("code");
return FinalCreate (opcode, site);
}
internal object Invoke(object[] args) {
Debug.Assert(args != null);
// If it is a delegate, just let DynamicInvoke do the binding.
var d = _callable as Delegate;
if (d != null) {
return d.DynamicInvoke(args);
}
// Otherwise, create a CallSite and invoke it.
if (_site == null) {
_site = CallSite<Func<CallSite, object, object[], object>>.Create(SplatInvokeBinder.Instance);
}
return _site.Target(_site, _callable, args);
}
public FunctionPointerEvaluator(StackValue pointer, Interpreter dsi)
{
Validity.Assert(pointer.optype == AddressType.FunctionPointer);
mRunTime = dsi;
Core core = dsi.runtime.Core;
int fptr = (int)pointer.opdata;
ProtoCore.DSASM.FunctionPointerNode fptrNode;
if (core.FunctionPointerTable.functionPointerDictionary.TryGetByFirst(fptr, out fptrNode))
{
int blockId = fptrNode.blockId;
int procId = fptrNode.procId;
mProcNode = dsi.runtime.exe.procedureTable[blockId].procList[procId];
}
mCallSite = new ProtoCore.CallSite(ProtoCore.DSASM.Constants.kGlobalScope, Name, core.FunctionTable, core.Options.ExecutionMode);
}
public FunctionPointerEvaluator(StackValue pointer, Interpreter dsi)
{
Validity.Assert(pointer.IsFunctionPointer);
interpreter = dsi;
RuntimeCore runtimeCore = dsi.runtime.RuntimeCore;
int fptr = (int)pointer.opdata;
FunctionPointerNode fptrNode;
int classScope = Constants.kGlobalScope;
if (runtimeCore.DSExecutable.FuncPointerTable.functionPointerDictionary.TryGetByFirst(fptr, out fptrNode))
{
int blockId = fptrNode.blockId;
int procId = fptrNode.procId;
classScope = fptrNode.classScope;
procNode = dsi.runtime.GetProcedureNode(blockId, classScope, procId);
}
callsite = new ProtoCore.CallSite(classScope, Name, interpreter.runtime.exe.FunctionTable, runtimeCore.Options.ExecutionMode);
}
} // ctor
private void UpdateCallSite(CallInfo callInfo, CallSite callSite)
{
this.callSite = callSite;
} // proc UpdateCallSite
public void FindMethod (CallSite site, object o, object[] args)
{
if (o == null) {
throw new NullReferenceException ();
}
InvokeInfo info = this.invokeInfo;
if (info == null) {
info = new InvokeInfo();
info.lastObj = new WeakReference (o);
info.lastArgTypes = new Type[args.Length];
this.invokeInfo = info;
} else {
this.invokeInfo.lastObj.Target = o;
}
var arg_len = args.Length;
for (var i = 0; i < arg_len; i++) {
info.lastArgTypes[i] = (args != null && args[i]!=null) ? args[i].GetType () : null;
}
if (o is ExpandoObject) {
var expando = (ExpandoObject)o;
// special case .hasOwnProperty here
if (name == "hasOwnProperty")
{
info.method = o.GetType().GetMethod("hasOwnProperty");
info.args = args;
info.del = null;
info.generation = 0;
}
else
{
object delObj;
expando.TryGetValue(name, out delObj);
Delegate del = delObj as Delegate;
if (del == null) {
throw new Exception ("No delegate found with the name '" + name + "'");
}
info.method = null;
info.del = del;
info.generation = expando.Generation;
}
} else {
MethodInfo method = null;
bool isStatic;
System.Type otype;
if (o is System.Type) {
// this is a static method invocation where o is the class
isStatic = true;
otype = (System.Type)o;
} else {
// this is a non-static method invocation
isStatic = false;
otype = o.GetType();
}
// find method for type that matches argument list
method = FindMethodForType(site, otype, name, isStatic, args, out info.args);
if (method == null) {
if (!isStatic) {
// find extension methods
method = FindExtensionMethodForType(site, otype, name, o, args, out info.args);
}
if (method == null) {
throw new Exception("No matching method found for the type '" + otype.FullName + "' with the name '" + name + "'");
}
}
info.method = method;
info.del = null;
info.generation = 0;
}
}
public static void Action10 (CallSite site, object o1, object o2, object o3, object o4, object o5, object o6, object o7, object o8, object o9, object o10)
{
((Delegate)o1).DynamicInvoke(new [] { o2, o3, o4, o5, o6, o7, o8, o10 });
}
public static object Func7 (CallSite site, object o1, object o2, object o3, object o4, object o5, object o6, object o7)
{
return ((Delegate)o1).DynamicInvoke(new [] { o2, o3, o4, o5, o6, o7 });
}
public static object Func7 (CallSite site, object o1, object o2, object o3, object o4, object o5, object o6, object o7)
{
return InvokeConstructor((Type)o1, new [] { o2, o3, o4, o5, o6, o7 });
}
// readonly CSharpBinderFlags flags;
// List<CSharpArgumentInfo> argumentInfo;
// Type callingContext;
public static void Action1 (CallSite site, object o1)
{
((Delegate)o1).DynamicInvoke(null);
}
private void PatchRawCode(ByteBuffer buffer, int code_size, CodeWriter writer)
{
MetadataBuilder metadata = writer.metadata;
buffer.WriteBytes(base.ReadBytes(code_size));
int position = buffer.position;
buffer.position -= code_size;
while (buffer.position < position)
{
byte b = buffer.ReadByte();
OpCode opCode;
if (b != 254)
{
opCode = OpCodes.OneByteOpCode[(int)b];
}
else
{
byte b2 = buffer.ReadByte();
opCode = OpCodes.TwoBytesOpCode[(int)b2];
}
switch (opCode.OperandType)
{
case OperandType.InlineBrTarget:
case OperandType.InlineI:
case OperandType.ShortInlineR:
buffer.position += 4;
break;
case OperandType.InlineField:
case OperandType.InlineMethod:
case OperandType.InlineTok:
case OperandType.InlineType:
{
IMetadataTokenProvider provider = this.reader.LookupToken(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
buffer.WriteUInt32(metadata.LookupToken(provider).ToUInt32());
break;
}
case OperandType.InlineI8:
case OperandType.InlineR:
buffer.position += 8;
break;
case OperandType.InlineSig:
{
CallSite callSite = this.GetCallSite(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
buffer.WriteUInt32(writer.GetStandAloneSignature(callSite).ToUInt32());
break;
}
case OperandType.InlineString:
{
string @string = this.GetString(new MetadataToken(buffer.ReadUInt32()));
buffer.position -= 4;
buffer.WriteUInt32(new MetadataToken(TokenType.String, metadata.user_string_heap.GetStringIndex(@string)).ToUInt32());
break;
}
case OperandType.InlineSwitch:
{
int num = buffer.ReadInt32();
buffer.position += num * 4;
break;
}
case OperandType.InlineVar:
case OperandType.InlineArg:
buffer.position += 2;
break;
case OperandType.ShortInlineBrTarget:
case OperandType.ShortInlineI:
case OperandType.ShortInlineVar:
case OperandType.ShortInlineArg:
buffer.position++;
break;
}
}
}
private static void InvokeAction0(CallSite site, object o)
{
var binder = (PSInvokeMemberBinder)site.Binder;
Invoke(binder, o, 0);
}
public Instruction Create(OpCode opcode, CallSite site)
{
return(Instruction.Create(opcode, site));
}
/// <summary>
/// Gets the value dynamically.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="dynamicMemberName">Name of the dynamic member.</param>
/// <returns></returns>
public static object GetValueDynamically(object entity, string dynamicMemberName)
{
Func <string, CallSite <Func <CallSite, object, object> > > valueFactory = s => CallSite <Func <CallSite, object, object> > .Create(
Binder.GetMember(
CSharpBinderFlags.None,
dynamicMemberName,
null,
new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }
));
var callsite = callsitesCache.GetOrAdd(dynamicMemberName, valueFactory);
return(callsite.Target(callsite, entity));
}
public void Emit(OpCode opcode, CallSite site)
{
Append(Create(opcode, site));
}
public override T BindDelegate <T>(CallSite <T> site, object[] args)
{
Debug.Assert(args[1].GetType() == typeof(CodeContext));
IFastGettable fastGet = args[0] as IFastGettable;
if (fastGet != null)
{
T res = fastGet.MakeGetBinding <T>(site, this, (CodeContext)args[1], Name);
if (res != null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.BindingFast, "IFastGettable");
return(res);
}
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "IFastGettable");
return(base.BindDelegate <T>(site, args));
}
IPythonObject pyObj = args[0] as IPythonObject;
if (pyObj != null && !(args[0] is IProxyObject))
{
FastBindResult <T> res = UserTypeOps.MakeGetBinding <T>((CodeContext)args[1], site, pyObj, this);
if (res.Target != null)
{
PerfTrack.NoteEvent(PerfTrack.Categories.BindingFast, "IPythonObject");
if (res.ShouldCache)
{
CacheTarget(res.Target);
}
return(res.Target);
}
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "IPythonObject Get");
return(base.BindDelegate <T>(site, args));
}
if (args[0] != null)
{
if (args[0].GetType() == typeof(PythonModule))
{
if (SupportsLightThrow)
{
return((T)(object)new Func <CallSite, object, CodeContext, object>(new PythonModuleDelegate(_name).LightThrowTarget));
}
else if (!IsNoThrow)
{
return((T)(object)new Func <CallSite, object, CodeContext, object>(new PythonModuleDelegate(_name).Target));
}
else
{
return((T)(object)new Func <CallSite, object, CodeContext, object>(new PythonModuleDelegate(_name).NoThrowTarget));
}
}
else if (args[0].GetType() == typeof(NamespaceTracker))
{
switch (Name)
{
case "__str__":
case "__repr__":
case "__doc__":
// need to return the built in method descriptor for these...
break;
case "__file__":
return((T)(object)new Func <CallSite, object, CodeContext, object>(new NamespaceTrackerDelegate(_name).GetFile));
case "__dict__":
return((T)(object)new Func <CallSite, object, CodeContext, object>(new NamespaceTrackerDelegate(_name).GetDict));
case "__name__":
return((T)(object)new Func <CallSite, object, CodeContext, object>(new NamespaceTrackerDelegate(_name).GetName));
default:
if (IsNoThrow)
{
return((T)(object)new Func <CallSite, object, CodeContext, object>(new NamespaceTrackerDelegate(_name).NoThrowTarget));
}
else
{
return((T)(object)new Func <CallSite, object, CodeContext, object>(new NamespaceTrackerDelegate(_name).Target));
}
}
}
}
if (args[0] != null &&
#if FEATURE_COM
!Microsoft.Scripting.ComInterop.ComBinder.IsComObject(args[0]) &&
#endif
!(args[0] is IDynamicMetaObjectProvider))
{
Type selfType = typeof(T).GetMethod("Invoke").GetParameters()[1].ParameterType;
CodeContext context = (CodeContext)args[1];
T res = null;
if (selfType == typeof(object))
{
res = (T)(object)MakeGetMemberTarget <object>(Name, args[0], context);
}
else if (selfType == typeof(List))
{
res = (T)(object)MakeGetMemberTarget <List>(Name, args[0], context);
}
else if (selfType == typeof(string))
{
res = (T)(object)MakeGetMemberTarget <string>(Name, args[0], context);
}
if (res != null)
{
return((T)(object)res);
}
return(base.BindDelegate <T>(site, args));
}
PerfTrack.NoteEvent(PerfTrack.Categories.BindingSlow, "GetNoFast " + IsNoThrow + " " + CompilerHelpers.GetType(args[0]));
return(this.LightBind <T>(args, this.Context.Options.CompilationThreshold));
}
public override T BindDelegate <T>(CallSite <T> site, object[] args)
{
throw ExceptionToThrow;
}
private static void InvokeAction7 (CallSite site, object o, object a1, object a2, object a3, object a4,
object a5, object a6, object a7)
{
var binder = ((CSharpInvokeMemberBinder)site.Binder);
var info = binder.invokeInfo;
object[] args;
if (info == null || !info.InvokeMatches(o, a1, a2, a3, a4, a5, a6, a7)) {
binder.FindMethod (site, o, new [] { a1, a2, a3, a4, a5, a6, a7 });
info = binder.invokeInfo;
args = info.args;
} else {
args = info.args;
args[0] = a1; args[1] = a2; args[2] = a3; args[3] = a4; args[4] = a5; args[5] = a6; args[6] = a7;
}
if (info.method != null)
info.method.Invoke (o, args);
else
info.del.DynamicInvoke(null, args);
}
public static void setCallSiteTargetVolatile(CallSite site, MethodHandle target)
{
setCallSiteTargetNormal(site, target);
}
private static object InvokeFunc3 (CallSite site, object o, object a1, object a2, object a3)
{
var binder = ((CSharpInvokeMemberBinder)site.Binder);
var info = binder.invokeInfo;
object[] args;
if (info == null || !info.InvokeMatches(o, a1, a2, a3)) {
binder.FindMethod (site, o, new [] { a1, a2, a3 });
info = binder.invokeInfo;
args = info.args;
} else {
args = info.args;
args[0] = a1; args[1] = a2; args[2] = a3;
}
object ret;
if (info.method != null)
ret = info.method.Invoke (o, args);
else
ret = info.del.DynamicInvoke(null, args);
return ret;
}
public void SetUpCallrForDebug(RuntimeCore runtimeCore, DSASM.Executive exec, ProcedureNode fNode, int pc, bool isBaseCall = false,
CallSite callsite = null, List <StackValue> arguments = null, List <List <ReplicationGuide> > replicationGuides = null, StackFrame stackFrame = null,
List <StackValue> dotCallDimensions = null, bool hasDebugInfo = false, bool isMember = false, StackValue?thisPtr = null)
{
//ProtoCore.DSASM.Executive exec = core.CurrentExecutive.CurrentDSASMExec;
DebugFrame debugFrame = new DebugFrame();
debugFrame.IsBaseCall = isBaseCall;
debugFrame.Arguments = arguments;
debugFrame.IsMemberFunction = isMember;
debugFrame.ThisPtr = thisPtr;
debugFrame.HasDebugInfo = hasDebugInfo;
if (CoreUtils.IsDisposeMethod(fNode.Name))
{
debugFrame.IsDisposeCall = true;
ReturnPCFromDispose = DebugEntryPC;
}
if (RunMode == Runmode.StepNext)
{
debugFrame.FunctionStepOver = true;
}
bool isReplicating = false;
bool isExternalFunction = false;
// callsite is set to null for a base class constructor call in CALL
if (callsite == null)
{
isReplicating = false;
isExternalFunction = false;
SetUpCallr(ref debugFrame, isReplicating, isExternalFunction, exec);
DebugStackFrame.Push(debugFrame);
return;
}
// Comment Jun: A dot call does not replicate and must be handled immediately
if (fNode.Name == Constants.kDotMethodName)
{
isReplicating = false;
isExternalFunction = false;
debugFrame.IsDotCall = true;
debugFrame.DotCallDimensions = dotCallDimensions;
SetUpCallr(ref debugFrame, isReplicating, isExternalFunction, exec);
DebugStackFrame.Push(debugFrame);
return;
}
List <List <ReplicationInstruction> > replicationTrials;
bool willReplicate = callsite.WillCallReplicate(new Context(), arguments, replicationGuides, stackFrame, runtimeCore, out replicationTrials);
// the inline conditional built-in is handled separately as 'WillCallReplicate' is always true in this case
if (fNode.Name.Equals(Constants.kInlineConditionalMethodName))
{
// The inline conditional built-in is created only for associative blocks and needs to be handled separately as below
InstructionStream istream = runtimeCore.DSExecutable.instrStreamList[CurrentBlockId];
Validity.Assert(istream.language == Language.Associative);
{
runtimeCore.DebugProps.InlineConditionOptions.isInlineConditional = true;
runtimeCore.DebugProps.InlineConditionOptions.startPc = pc;
runtimeCore.DebugProps.InlineConditionOptions.endPc = FindEndPCForAssocGraphNode(pc, istream, fNode, exec.Properties.executingGraphNode, runtimeCore.Options.ExecuteSSA);
runtimeCore.DebugProps.InlineConditionOptions.instructionStream = runtimeCore.RunningBlock;
debugFrame.IsInlineConditional = true;
}
// no replication case
if (willReplicate && replicationTrials.Count == 1)
{
runtimeCore.DebugProps.InlineConditionOptions.ActiveBreakPoints.AddRange(runtimeCore.Breakpoints);
isReplicating = false;
isExternalFunction = false;
}
else // an inline conditional call that replicates
{
// Clear all breakpoints for outermost replicated call
if (!DebugStackFrameContains(StackFrameFlagOptions.IsReplicating))
{
ActiveBreakPoints.AddRange(runtimeCore.Breakpoints);
runtimeCore.Breakpoints.Clear();
}
isExternalFunction = false;
isReplicating = true;
}
SetUpCallr(ref debugFrame, isReplicating, isExternalFunction, exec, 0);
DebugStackFrame.Push(debugFrame);
return;
}
// Prevent breaking inside a function that is external except for dot calls
// by clearing all breakpoints from outermost external function call
// This check takes precedence over the replication check
else if (fNode.IsExternal && fNode.Name != Constants.kDotMethodName)
{
// Clear all breakpoints
if (!DebugStackFrameContains(StackFrameFlagOptions.IsExternalFunction) && fNode.Name != Constants.kFunctionRangeExpression)
{
ActiveBreakPoints.AddRange(runtimeCore.Breakpoints);
runtimeCore.Breakpoints.Clear();
}
isExternalFunction = true;
isReplicating = false;
}
// Find if function call will replicate or not and if so
// prevent stepping in by removing all breakpoints from outermost replicated call
else if (willReplicate)
{
// Clear all breakpoints for outermost replicated call
if (!DebugStackFrameContains(StackFrameFlagOptions.IsReplicating))
{
ActiveBreakPoints.AddRange(runtimeCore.Breakpoints);
runtimeCore.Breakpoints.Clear();
}
isReplicating = true;
isExternalFunction = false;
}
// For all other function calls
else
{
isReplicating = false;
isExternalFunction = false;
}
SetUpCallr(ref debugFrame, isReplicating, isExternalFunction, exec);
DebugStackFrame.Push(debugFrame);
}
public static object Func2 (CallSite site, object o1, object o2)
{
return InvokeConstructor((Type)o1, new [] { o2 });
}
public override FrameApplicationBuilder CreateFrameApplicationBuilder(IStorageBinder binder, CallSite site, Expression callee)
{
return(new X86FrameApplicationBuilder(this, binder, site, callee, false));
}
public void Emit(OpCode opcode, CallSite site)
{
Append (Create (opcode, site));
}
/// <summary>
/// Retrieves an existing instance of a callsite associated with a UID
/// It creates a new callsite if non was found
/// </summary>
/// <param name="core"></param>
/// <param name="uid"></param>
/// <returns></returns>
public CallSite GetCallSite(int classScope, string methodName, Executable executable, RuntimeCore runtimeCore)
{
Validity.Assert(null != executable.FunctionTable);
CallSite csInstance = null;
var graphNode = executable.ExecutingGraphnode;
var topGraphNode = graphNode;
// If it is a nested function call, append all callsite ids
List <string> callsiteIdentifiers = new List <string>();
foreach (var prop in runtimeCore.InterpreterProps)
{
if (prop != null && prop.executingGraphNode != null && graphNode != prop.executingGraphNode)
{
topGraphNode = prop.executingGraphNode;
if (!string.IsNullOrEmpty(topGraphNode.CallsiteIdentifier))
{
callsiteIdentifiers.Add(topGraphNode.CallsiteIdentifier);
}
}
}
if (graphNode != null)
{
callsiteIdentifiers.Add(graphNode.CallsiteIdentifier);
}
var callsiteID = string.Join(";", callsiteIdentifiers.ToArray());
// TODO Jun: Currently generates a new callsite for imperative and
// internally generated functions.
// Fix the issues that cause the cache to go out of sync when
// attempting to cache internal functions. This may require a
// secondary callsite cache for internal functions so they dont
// clash with the graphNode UID key
var language = executable.instrStreamList[runtimeCore.RunningBlock].language;
bool isImperative = language == Language.Imperative;
bool isInternalFunction = CoreUtils.IsInternalFunction(methodName);
if (isInternalFunction || isImperative)
{
csInstance = new CallSite(classScope,
methodName,
executable.FunctionTable,
runtimeCore.Options.ExecutionMode);
}
else if (!CallsiteCache.TryGetValue(callsiteID, out csInstance))
{
// Attempt to retrieve a preloaded callsite data (optional).
var traceData = GetAndRemoveTraceDataForNode(topGraphNode.guid, callsiteID);
csInstance = new CallSite(classScope,
methodName,
executable.FunctionTable,
runtimeCore.Options.ExecutionMode,
traceData);
CallsiteCache[callsiteID] = csInstance;
CallSiteToNodeMap[csInstance.CallSiteID] = topGraphNode.guid;
}
if (graphNode != null && !CoreUtils.IsDisposeMethod(methodName))
{
csInstance.UpdateCallSite(classScope, methodName);
if (runtimeCore.Options.IsDeltaExecution)
{
runtimeCore.RuntimeStatus.ClearWarningForExpression(graphNode.exprUID);
}
}
return(csInstance);
}
public static void Action4 (CallSite site, object o1, object o2, object o3, object o4)
{
((Delegate)o1).DynamicInvoke(new [] { o2, o3, o4 });
}
// Dev10 Bug 914027 - Changed the callsite's target parameter from dynamic to object, see comment at top for details
public static CallSite <Func <CallSite, object, object> > GetMemberAccessCallSite(CallSiteBinder binder)
{
return(CallSite <Func <CallSite, object, object> > .Create(binder));
}
public static object Func2 (CallSite site, object o1, object o2)
{
return ((Delegate)o1).DynamicInvoke(new [] { o2 });
}
private static CallSite <Func <CallSite, object, object> > CreateCallSiteGetter(string name) => CallSite <Func <CallSite, object, object> > .Create(new NoThrowGetBinderMember((GetMemberBinder)DynamicUtils.BinderWrapper.GetMember(name, typeof(DynamicUtils))));
private static object TestOut(CallSite dummy, object @in, out string @out)
{
@out = @in as string;
return(@out != null);
}
private void CloneTo(MethodBody body, MethodDefinition parent)
{
MethodBody nb = new MethodBody(parent);
parent.Body = nb;
nb.MaxStackSize = body.MaxStackSize;
nb.InitLocals = body.InitLocals;
nb.LocalVarToken = body.LocalVarToken;
foreach (VariableDefinition var in body.Variables)
{
nb.Variables.Add(new VariableDefinition(var.Name,
Import(var.VariableType, parent)));
}
nb.Instructions.SetCapacity(body.Instructions.Count);
_repackContext.LineIndexer.PreMethodBodyRepack(body, parent);
foreach (Instruction instr in body.Instructions)
{
_repackContext.LineIndexer.ProcessMethodBodyInstruction(instr);
Instruction ni;
if (instr.OpCode.Code == Code.Calli)
{
var callSite = (CallSite)instr.Operand;
CallSite ncs = new CallSite(Import(callSite.ReturnType, parent))
{
HasThis = callSite.HasThis,
ExplicitThis = callSite.ExplicitThis,
CallingConvention = callSite.CallingConvention
};
foreach (ParameterDefinition param in callSite.Parameters)
{
CloneTo(param, parent, ncs.Parameters);
}
ni = Instruction.Create(instr.OpCode, ncs);
}
else
{
switch (instr.OpCode.OperandType)
{
case OperandType.InlineArg:
case OperandType.ShortInlineArg:
if (instr.Operand == body.ThisParameter)
{
ni = Instruction.Create(instr.OpCode, nb.ThisParameter);
}
else
{
int param = body.Method.Parameters.IndexOf((ParameterDefinition)instr.Operand);
ni = Instruction.Create(instr.OpCode, parent.Parameters[param]);
}
break;
case OperandType.InlineVar:
case OperandType.ShortInlineVar:
int var = body.Variables.IndexOf((VariableDefinition)instr.Operand);
ni = Instruction.Create(instr.OpCode, nb.Variables[var]);
break;
case OperandType.InlineField:
ni = Instruction.Create(instr.OpCode, Import((FieldReference)instr.Operand, parent));
break;
case OperandType.InlineMethod:
ni = Instruction.Create(instr.OpCode, Import((MethodReference)instr.Operand, parent));
FixAspNetOffset(nb.Instructions, (MethodReference)instr.Operand, parent);
break;
case OperandType.InlineType:
ni = Instruction.Create(instr.OpCode, Import((TypeReference)instr.Operand, parent));
break;
case OperandType.InlineTok:
if (instr.Operand is TypeReference)
{
ni = Instruction.Create(instr.OpCode, Import((TypeReference)instr.Operand, parent));
}
else if (instr.Operand is FieldReference)
{
ni = Instruction.Create(instr.OpCode, Import((FieldReference)instr.Operand, parent));
}
else if (instr.Operand is MethodReference)
{
ni = Instruction.Create(instr.OpCode, Import((MethodReference)instr.Operand, parent));
}
else
{
throw new InvalidOperationException();
}
break;
case OperandType.ShortInlineBrTarget:
case OperandType.InlineBrTarget:
ni = Instruction.Create(instr.OpCode, (Instruction)instr.Operand);
break;
case OperandType.InlineSwitch:
ni = Instruction.Create(instr.OpCode, (Instruction[])instr.Operand);
break;
case OperandType.InlineR:
ni = Instruction.Create(instr.OpCode, (double)instr.Operand);
break;
case OperandType.ShortInlineR:
ni = Instruction.Create(instr.OpCode, (float)instr.Operand);
break;
case OperandType.InlineNone:
ni = Instruction.Create(instr.OpCode);
break;
case OperandType.InlineString:
ni = Instruction.Create(instr.OpCode, (string)instr.Operand);
break;
case OperandType.ShortInlineI:
if (instr.OpCode == OpCodes.Ldc_I4_S)
{
ni = Instruction.Create(instr.OpCode, (sbyte)instr.Operand);
}
else
{
ni = Instruction.Create(instr.OpCode, (byte)instr.Operand);
}
break;
case OperandType.InlineI8:
ni = Instruction.Create(instr.OpCode, (long)instr.Operand);
break;
case OperandType.InlineI:
ni = Instruction.Create(instr.OpCode, (int)instr.Operand);
break;
default:
throw new InvalidOperationException();
}
}
ni.SequencePoint = instr.SequencePoint;
nb.Instructions.Add(ni);
}
_repackContext.LineIndexer.PostMethodBodyRepack(parent);
for (int i = 0; i < body.Instructions.Count; i++)
{
Instruction instr = nb.Instructions[i];
switch (instr.OpCode.OperandType)
{
case OperandType.ShortInlineBrTarget:
case OperandType.InlineBrTarget:
instr.Operand = GetInstruction(body, nb, (Instruction)body.Instructions[i].Operand);
break;
case OperandType.InlineSwitch:
instr.Operand = ((Instruction[])body.Instructions[i].Operand).Select(op => GetInstruction(body, nb, op)).ToArray();
break;
default:
break;
}
}
foreach (ExceptionHandler eh in body.ExceptionHandlers)
{
ExceptionHandler neh = new ExceptionHandler(eh.HandlerType);
neh.TryStart = GetInstruction(body, nb, eh.TryStart);
neh.TryEnd = GetInstruction(body, nb, eh.TryEnd);
neh.HandlerStart = GetInstruction(body, nb, eh.HandlerStart);
neh.HandlerEnd = GetInstruction(body, nb, eh.HandlerEnd);
switch (eh.HandlerType)
{
case ExceptionHandlerType.Catch:
neh.CatchType = Import(eh.CatchType, parent);
break;
case ExceptionHandlerType.Filter:
neh.FilterStart = GetInstruction(body, nb, eh.FilterStart);
break;
}
nb.ExceptionHandlers.Add(neh);
}
}
private MethodInfo FindExtensionMethodForType(CallSite site, System.Type otype, string name, object o, object[] args, out object[] outArgs)
{
Type extensionClass = PlayScript.Dynamic.GetExtensionClassForType(otype);
if (extensionClass != null) {
// add 'this' to arguments
var extArgs = new object[args.Length + 1];
extArgs[0] = o;
Array.Copy(args, 0, extArgs, 1, args.Length);
var methods = extensionClass.GetMethods();
var len = methods.Length;
for (var mi = 0; mi < len; mi++) {
var m = methods[mi];
if (m.Name == name) {
// attempt to convert method parameters
if (Dynamic.ConvertMethodParameters(m, extArgs, out outArgs)) {
return m;
}
}
}
}
// method not found
outArgs = null;
return null;
}
public ParseException(string message, CallSite callsite)
: base(message, callsite)
{
}
private static void InvokeAction2 (CallSite site, object o, object a1, object a2)
{
var binder = ((CSharpInvokeMemberBinder)site.Binder);
var info = binder.invokeInfo;
object[] args;
if (info == null || !info.InvokeMatches(o, a1, a2)) {
binder.FindMethod (site, o, new [] { a1, a2 });
info = binder.invokeInfo;
args = info.args;
} else {
args = info.args;
args[0] = a1; args[1] = a2;
}
if (info.method != null)
info.method.Invoke (o, args);
else
info.del.DynamicInvoke(null, args);
}
public PrintfApplicationBuilder(
IProcessorArchitecture arch, Frame frame, CallSite site, Expression callee, FunctionType sigCallee, bool ensureVariables) :
base(arch, frame, site, callee, sigCallee, ensureVariables)
{
}
private static object InvokeFunc (CallSite site, object o)
{
var binder = ((CSharpInvokeMemberBinder)site.Binder);
var info = binder.invokeInfo;
object[] args;
if (info == null || !info.InvokeMatches (o)) {
binder.FindMethod (site, o, new object[] {});
info = binder.invokeInfo;
}
args = info.args;
if (info.method != null)
return info.method.Invoke (o, args);
else
return info.del.DynamicInvoke(args);
}
private static CallSite <Func <CallSite, CodeContext, object, string, object> > MakeGetAttrSite(CodeContext context)
{
return(CallSite <Func <CallSite, CodeContext, object, string, object> > .Create(
PythonContext.GetContext(context).InvokeOne
));
}
private static object InvokeFunc8 (CallSite site, object o, object a1, object a2, object a3, object a4,
object a5, object a6, object a7, object a8)
{
var binder = ((CSharpInvokeMemberBinder)site.Binder);
var info = binder.invokeInfo;
object[] args;
if (info == null || !info.InvokeMatches(o, a1, a2, a3, a4, a5, a6, a7, a8)) {
binder.FindMethod (site, o, new [] { a1, a2, a3, a4, a5, a6, a7, a8 });
info = binder.invokeInfo;
args = info.args;
} else {
args = info.args;
args[0] = a1; args[1] = a2; args[2] = a3; args[3] = a4; args[4] = a5; args[5] = a6; args[6] = a7; args[7] = a8;
}
object ret;
if (info.method != null)
ret = info.method.Invoke (o, args);
else
ret = info.del.DynamicInvoke(null, args);
return ret;
}
internal static Binding.FastBindResult <T> MakeGetBinding <T>(CodeContext codeContext, CallSite <T> site, IPythonObject self, Binding.PythonGetMemberBinder getBinder) where T : class
{
Type finalType = PythonTypeOps.GetFinalSystemType(self.PythonType.UnderlyingSystemType);
if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(finalType) &&
!(self is IFastGettable))
{
// very tricky, user is inheriting from a class which implements IDO, we
// don't optimize this yet.
return(new Binding.FastBindResult <T>());
}
return((Binding.FastBindResult <T>)(object) new Binding.MetaUserObject.FastGetBinderHelper(
codeContext,
(CallSite <Func <CallSite, object, CodeContext, object> >)(object) site,
self,
getBinder).GetBinding(codeContext, getBinder.Name));
}
public static object Func1 (CallSite site, object o1)
{
return InvokeConstructor((Type)o1, new object[] {});
}
internal static FastBindResult <T> MakeSetBinding <T>(CodeContext codeContext, CallSite <T> site, IPythonObject self, object value, Binding.PythonSetMemberBinder setBinder) where T : class
{
if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(self.GetType().BaseType))
{
// very tricky, user is inheriting from a class which implements IDO, we
// don't optimize this yet.
return(new FastBindResult <T>());
}
// optimized versions for possible literals that can show up in code.
Type setType = typeof(T);
if (setType == typeof(Func <CallSite, object, object, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <object>(
codeContext,
self,
value,
setBinder).MakeSet());
}
else if (setType == typeof(Func <CallSite, object, string, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <string>(
codeContext,
self,
value,
setBinder).MakeSet());
}
else if (setType == typeof(Func <CallSite, object, int, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <int>(
codeContext,
self,
value,
setBinder).MakeSet());
}
else if (setType == typeof(Func <CallSite, object, double, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <double>(
codeContext,
self,
value,
setBinder).MakeSet());
}
else if (setType == typeof(Func <CallSite, object, List, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <List>(
codeContext,
self,
value,
setBinder).MakeSet());
}
else if (setType == typeof(Func <CallSite, object, PythonTuple, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <PythonTuple>(
codeContext,
self,
value,
setBinder).MakeSet());
}
else if (setType == typeof(Func <CallSite, object, PythonDictionary, object>))
{
return((FastBindResult <T>)(object) new Binding.MetaUserObject.FastSetBinderHelper <PythonDictionary>(
codeContext,
self,
value,
setBinder).MakeSet());
}
return(new FastBindResult <T>());
}
public static object Func4 (CallSite site, object o1, object o2, object o3, object o4)
{
return InvokeConstructor((Type)o1, new [] { o2, o3, o4 });
}
private static CallSite <Func <CallSite, object, object?, object> > CreateCallSiteSetter(string name)
{
SetMemberBinder binder = (SetMemberBinder)DynamicUtils.BinderWrapper.SetMember(name, typeof(DynamicUtils));
return(CallSite <Func <CallSite, object, object?, object> > .Create(new NoThrowSetBinderMember(binder)));
}
public static object Func10 (CallSite site, object o1, object o2, object o3, object o4, object o5, object o6, object o7, object o8, object o9, object o10)
{
return InvokeConstructor((Type)o1, new [] { o2, o3, o4, o5, o6, o7, o8, o9, o10 });
}
public override bool Handle(ulong remoteUserId, CallSite site, BitStream stream, object obj)
{
return(true);
}
public Instruction Create(OpCode opcode, CallSite site)
{
return Instruction.Create (opcode, site);
}
public override T BindDelegate <T>(CallSite <T> site, object[] args)
{
//Debug.Assert(typeof(T).GetMethod("Invoke").ReturnType == Type);
object target = args[0];
T res = null;
if (typeof(T) == typeof(Func <CallSite, object, string>) && target is string)
{
res = (T)(object)new Func <CallSite, object, string>(StringConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, int>))
{
if (target is int)
{
res = (T)(object)new Func <CallSite, object, int>(IntConversion);
}
else if (target is bool)
{
res = (T)(object)new Func <CallSite, object, int>(BoolToIntConversion);
}
}
else if (typeof(T) == typeof(Func <CallSite, bool, int>))
{
res = (T)(object)new Func <CallSite, bool, int>(BoolToIntConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
if (target is bool)
{
res = (T)(object)new Func <CallSite, object, bool>(BoolConversion);
}
else if (target is string)
{
res = (T)(object)new Func <CallSite, object, bool>(StringToBoolConversion);
}
else if (target is int)
{
res = (T)(object)new Func <CallSite, object, bool>(IntToBoolConversion);
}
else if (target == null)
{
res = (T)(object)new Func <CallSite, object, bool>(NullToBoolConversion);
}
else if (target.GetType() == typeof(object))
{
res = (T)(object)new Func <CallSite, object, bool>(ObjectToBoolConversion);
}
else if (target.GetType() == typeof(List))
{
res = (T)(object)new Func <CallSite, object, bool>(ListToBoolConversion);
}
else if (target.GetType() == typeof(PythonTuple))
{
res = (T)(object)new Func <CallSite, object, bool>(TupleToBoolConversion);
}
}
else if (target != null)
{
// Special cases:
// - string or bytes to IEnumerable or IEnumerator
// - CLR 4 only: BigInteger -> Complex
#if !CLR2
if (target is BigInteger)
{
if (typeof(T) == typeof(Func <CallSite, BigInteger, Complex>))
{
res = (T)(object)new Func <CallSite, BigInteger, Complex>(BigIntegerToComplexConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, Complex>))
{
res = (T)(object)new Func <CallSite, object, Complex>(BigIntegerObjectToComplexConversion);
}
else if (typeof(T) == typeof(Func <CallSite, BigInteger, object>))
{
res = (T)(object)new Func <CallSite, BigInteger, object>(BigIntegerToComplexObjectConversion);
}
}
else
#endif
if (target is string)
{
if (typeof(T) == typeof(Func <CallSite, string, IEnumerable>))
{
res = (T)(object)new Func <CallSite, string, IEnumerable>(StringToIEnumerableConversion);
}
else if (typeof(T) == typeof(Func <CallSite, string, IEnumerator>))
{
res = (T)(object)new Func <CallSite, string, IEnumerator>(StringToIEnumeratorConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, IEnumerable>))
{
res = (T)(object)new Func <CallSite, object, IEnumerable>(ObjectToIEnumerableConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, IEnumerator>))
{
res = (T)(object)new Func <CallSite, object, IEnumerator>(ObjectToIEnumeratorConversion);
}
}
else if (target.GetType() == typeof(Bytes))
{
if (typeof(T) == typeof(Func <CallSite, Bytes, IEnumerable>))
{
res = (T)(object)new Func <CallSite, Bytes, IEnumerable>(BytesToIEnumerableConversion);
}
else if (typeof(T) == typeof(Func <CallSite, Bytes, IEnumerator>))
{
res = (T)(object)new Func <CallSite, Bytes, IEnumerator>(BytesToIEnumeratorConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, IEnumerable>))
{
res = (T)(object)new Func <CallSite, object, IEnumerable>(ObjectToIEnumerableConversion);
}
else if (typeof(T) == typeof(Func <CallSite, object, IEnumerator>))
{
res = (T)(object)new Func <CallSite, object, IEnumerator>(ObjectToIEnumeratorConversion);
}
}
if (res == null && (target.GetType() == Type || Type.IsAssignableFrom(target.GetType())))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
// called via a helper call site in the runtime (e.g. Converter.Convert)
res = (T)(object)new Func <CallSite, object, object>(new IdentityConversion(target.GetType()).Convert);
}
else
{
// called via an embedded call site
Debug.Assert(typeof(T).GetMethod("Invoke").ReturnType == Type);
if (typeof(T).GetMethod("Invoke").GetParameters()[1].ParameterType == typeof(object))
{
object identityConversion = Activator.CreateInstance(typeof(IdentityConversion <>).MakeGenericType(Type), target.GetType());
res = (T)(object)Delegate.CreateDelegate(typeof(T), identityConversion, identityConversion.GetType().GetMethod("Convert"));
}
}
}
}
if (res != null)
{
CacheTarget(res);
return(res);
}
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Convert " + Type.FullName + " " + CompilerHelpers.GetType(args[0]) + " " + typeof(T));
return(base.BindDelegate(site, args));
}
public static void Action2 (CallSite site, object o1, object o2)
{
((Delegate)o1).DynamicInvoke(new [] { o2 });
}
public int BoolToIntConversion(CallSite site, bool value)
{
return((bool)value ? 1 : 0);
}
public static void Action7 (CallSite site, object o1, object o2, object o3, object o4, object o5, object o6, object o7)
{
((Delegate)o1).DynamicInvoke(new [] { o2, o3, o4, o5, o6, o7 });
}
public Complex BigIntegerToComplexConversion(CallSite site, BigInteger value)
{
return(BigIntegerOps.ConvertToComplex(value));
}
public static object Func1 (CallSite site, object o1)
{
return ((Delegate)o1).DynamicInvoke(null);
}
public void NullBinder()
{
AssertExtensions.Throws <ArgumentNullException>("binder", () => CallSite <Func <CallSite, object, object> > .Create(null));
}
public static object Func4 (CallSite site, object o1, object o2, object o3, object o4)
{
return ((Delegate)o1).DynamicInvoke(new [] { o2, o3, o4 });
}
private static object InvokeFunc0(CallSite site, object o)
{
var binder = (PSInvokeMemberBinder)site.Binder;
return(Invoke(binder, o, 0));
}
public static object Func10 (CallSite site, object o1, object o2, object o3, object o4, object o5, object o6, object o7, object o8, object o9, object o10)
{
return ((Delegate)o1).DynamicInvoke(new [] { o2, o3, o4, o5, o6, o7, o8, o9, o10 });
}
private MethodInfo FindMethodForType(CallSite site, System.Type otype, string name, bool isStatic, object[] args, out object[] outArgs)
{
BindingFlags bindingFlags = isStatic ? BindingFlags.Static | BindingFlags.FlattenHierarchy : BindingFlags.Instance;
var methods = otype.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | bindingFlags);
var len = methods.Length;
for (var mi = 0; mi < len; mi++) {
var m = methods[mi];
if ((m.IsStatic == isStatic) && m.Name == name) {
// attempt to convert method parameters
if (Dynamic.ConvertMethodParameters(m, args, out outArgs)) {
return m;
}
}
}
// method not found
outArgs = null;
return null;
}
public void NonGenericCreateNullBinder()
{
AssertExtensions.Throws <ArgumentNullException>("binder", () => CallSite.Create(typeof(Func <string>), null));
}
public override T BindDelegate <T>(CallSite <T> site, object[] args)
{
switch (Operation)
{
case ExpressionType.Negate:
if (CompilerHelpers.GetType(args[0]) == typeof(int))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(IntNegate));
}
}
break;
case ExpressionType.IsFalse:
if (args[0] == null)
{
if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
return((T)(object)new Func <CallSite, object, bool>(NoneIsFalse));
}
}
else if (args[0].GetType() == typeof(string))
{
if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
return((T)(object)new Func <CallSite, object, bool>(StringIsFalse));
}
}
else if (args[0].GetType() == typeof(bool))
{
if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
return((T)(object)new Func <CallSite, object, bool>(BoolIsFalse));
}
}
else if (args[0].GetType() == typeof(List))
{
if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
return((T)(object)new Func <CallSite, object, bool>(ListIsFalse));
}
}
else if (args[0].GetType() == typeof(PythonTuple))
{
if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
return((T)(object)new Func <CallSite, object, bool>(TupleIsFalse));
}
}
else if (args[0].GetType() == typeof(int))
{
if (typeof(T) == typeof(Func <CallSite, object, bool>))
{
return((T)(object)new Func <CallSite, object, bool>(IntIsFalse));
}
}
break;
case ExpressionType.Not:
if (args[0] == null)
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(NoneNot));
}
}
else if (args[0].GetType() == typeof(string))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(StringNot));
}
}
else if (args[0].GetType() == typeof(bool))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(BoolNot));
}
}
else if (args[0].GetType() == typeof(List))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(ListNot));
}
}
else if (args[0].GetType() == typeof(PythonTuple))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(TupleNot));
}
}
else if (args[0].GetType() == typeof(int))
{
if (typeof(T) == typeof(Func <CallSite, object, object>))
{
return((T)(object)new Func <CallSite, object, object>(IntNot));
}
}
break;
}
return(base.BindDelegate(site, args));
}
