1226 lines
40 KiB
C#
1226 lines
40 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// ***NOTE*** If this code is changed, make corresponding changes in System.Runtime.Serialization.CodeGenerator also
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Runtime;
|
|
using System.Security;
|
|
using System.ServiceModel.Diagnostics;
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Generates IL into an ILGenerator that was created under an Assert."
|
|
+ "Generated IL must be correct and must not subvert the type system.")]
|
|
#pragma warning disable 618 // have not moved to the v4 security model yet
|
|
[SecurityCritical(SecurityCriticalScope.Everything)]
|
|
#pragma warning restore 618
|
|
internal class CodeGenerator
|
|
{
|
|
static MethodInfo getTypeFromHandle;
|
|
static MethodInfo stringConcat2;
|
|
static MethodInfo objectToString;
|
|
static MethodInfo boxPointer;
|
|
static MethodInfo unboxPointer;
|
|
|
|
#if USE_REFEMIT
|
|
AssemblyBuilder assemblyBuilder;
|
|
ModuleBuilder moduleBuilder;
|
|
TypeBuilder typeBuilder;
|
|
static int typeCounter;
|
|
MethodBuilder methodBuilder;
|
|
#else
|
|
static Module SerializationModule = typeof(CodeGenerator).Module; // Can be replaced by different assembly with SkipVerification set to false
|
|
DynamicMethod dynamicMethod;
|
|
|
|
#if DEBUG
|
|
bool allowPrivateMemberAccess;
|
|
#endif
|
|
#endif
|
|
|
|
Type delegateType;
|
|
ILGenerator ilGen;
|
|
ArrayList argList;
|
|
Stack blockStack;
|
|
Label methodEndLabel;
|
|
|
|
Hashtable localNames;
|
|
int lineNo = 1;
|
|
enum CodeGenTrace { None, Save, Tron };
|
|
CodeGenTrace codeGenTrace;
|
|
|
|
internal CodeGenerator()
|
|
{
|
|
SourceSwitch codeGenSwitch = OperationInvokerTrace.CodeGenerationSwitch;
|
|
if ((codeGenSwitch.Level & SourceLevels.Verbose) == SourceLevels.Verbose)
|
|
codeGenTrace = CodeGenTrace.Tron;
|
|
else if ((codeGenSwitch.Level & SourceLevels.Information) == SourceLevels.Information)
|
|
codeGenTrace = CodeGenTrace.Save;
|
|
else
|
|
codeGenTrace = CodeGenTrace.None;
|
|
}
|
|
|
|
static MethodInfo GetTypeFromHandle
|
|
{
|
|
get
|
|
{
|
|
if (getTypeFromHandle == null)
|
|
getTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle");
|
|
return getTypeFromHandle;
|
|
}
|
|
}
|
|
|
|
static MethodInfo StringConcat2
|
|
{
|
|
get
|
|
{
|
|
if (stringConcat2 == null)
|
|
stringConcat2 = typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) });
|
|
return stringConcat2;
|
|
}
|
|
}
|
|
|
|
static MethodInfo ObjectToString
|
|
{
|
|
get
|
|
{
|
|
if (objectToString == null)
|
|
objectToString = typeof(object).GetMethod("ToString", new Type[0]);
|
|
return objectToString;
|
|
}
|
|
}
|
|
|
|
static MethodInfo BoxPointer
|
|
{
|
|
get
|
|
{
|
|
if (boxPointer == null)
|
|
boxPointer = typeof(Pointer).GetMethod("Box");
|
|
return boxPointer;
|
|
}
|
|
}
|
|
|
|
static MethodInfo UnboxPointer
|
|
{
|
|
get
|
|
{
|
|
if (unboxPointer == null)
|
|
unboxPointer = typeof(Pointer).GetMethod("Unbox");
|
|
return unboxPointer;
|
|
}
|
|
}
|
|
|
|
internal void BeginMethod(string methodName, Type delegateType, bool allowPrivateMemberAccess)
|
|
{
|
|
MethodInfo signature = delegateType.GetMethod("Invoke");
|
|
ParameterInfo[] parameters = signature.GetParameters();
|
|
Type[] paramTypes = new Type[parameters.Length];
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
paramTypes[i] = parameters[i].ParameterType;
|
|
BeginMethod(signature.ReturnType, methodName, paramTypes, allowPrivateMemberAccess);
|
|
this.delegateType = delegateType;
|
|
}
|
|
|
|
void BeginMethod(Type returnType, string methodName, Type[] argTypes, bool allowPrivateMemberAccess)
|
|
{
|
|
#if USE_REFEMIT
|
|
string typeName = "Type" + (typeCounter++);
|
|
InitAssemblyBuilder(typeName + "." + methodName);
|
|
this.typeBuilder = moduleBuilder.DefineType(typeName, TypeAttributes.Public);
|
|
this.methodBuilder = typeBuilder.DefineMethod(methodName, MethodAttributes.Public|MethodAttributes.Static, returnType, argTypes);
|
|
this.ilGen = this.methodBuilder.GetILGenerator();
|
|
#else
|
|
this.dynamicMethod = new DynamicMethod(methodName, returnType, argTypes, SerializationModule, allowPrivateMemberAccess);
|
|
this.ilGen = this.dynamicMethod.GetILGenerator();
|
|
#if DEBUG
|
|
this.allowPrivateMemberAccess = allowPrivateMemberAccess;
|
|
#endif
|
|
#endif
|
|
|
|
this.methodEndLabel = ilGen.DefineLabel();
|
|
this.blockStack = new Stack();
|
|
this.argList = new ArrayList();
|
|
for (int i = 0; i < argTypes.Length; i++)
|
|
argList.Add(new ArgBuilder(i, argTypes[i]));
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceLabel("Begin method " + methodName + " {");
|
|
}
|
|
|
|
internal Delegate EndMethod()
|
|
{
|
|
MarkLabel(methodEndLabel);
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceLabel("} End method");
|
|
Ret();
|
|
|
|
Delegate retVal = null;
|
|
#if USE_REFEMIT
|
|
Type type = typeBuilder.CreateType();
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
assemblyBuilder.Save(assemblyBuilder.GetName().Name+".dll");
|
|
|
|
MethodInfo method = type.GetMethod(methodBuilder.Name);
|
|
retVal = Delegate.CreateDelegate(delegateType, method);
|
|
methodBuilder = null;
|
|
#else
|
|
retVal = dynamicMethod.CreateDelegate(delegateType);
|
|
dynamicMethod = null;
|
|
#endif
|
|
delegateType = null;
|
|
|
|
ilGen = null;
|
|
blockStack = null;
|
|
argList = null;
|
|
return retVal;
|
|
}
|
|
|
|
internal MethodInfo CurrentMethod
|
|
{
|
|
get
|
|
{
|
|
#if USE_REFEMIT
|
|
return methodBuilder;
|
|
#else
|
|
return dynamicMethod;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
internal ArgBuilder GetArg(int index)
|
|
{
|
|
return (ArgBuilder)argList[index];
|
|
}
|
|
|
|
internal Type GetVariableType(object var)
|
|
{
|
|
if (var is ArgBuilder)
|
|
return ((ArgBuilder)var).ArgType;
|
|
else if (var is LocalBuilder)
|
|
return ((LocalBuilder)var).LocalType;
|
|
else
|
|
return var.GetType();
|
|
}
|
|
|
|
internal LocalBuilder DeclareLocal(Type type, string name)
|
|
{
|
|
return DeclareLocal(type, name, false);
|
|
}
|
|
|
|
internal LocalBuilder DeclareLocal(Type type, string name, bool isPinned)
|
|
{
|
|
LocalBuilder local = ilGen.DeclareLocal(type, isPinned);
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
{
|
|
LocalNames[local] = name;
|
|
EmitSourceComment("Declare local '" + name + "' of type " + type);
|
|
}
|
|
return local;
|
|
}
|
|
|
|
internal void If()
|
|
{
|
|
InternalIf(false);
|
|
}
|
|
|
|
internal void IfNot()
|
|
{
|
|
InternalIf(true);
|
|
}
|
|
|
|
internal void Else()
|
|
{
|
|
IfState ifState = PopIfState();
|
|
Br(ifState.EndIf);
|
|
MarkLabel(ifState.ElseBegin);
|
|
|
|
ifState.ElseBegin = ifState.EndIf;
|
|
blockStack.Push(ifState);
|
|
}
|
|
|
|
internal void EndIf()
|
|
{
|
|
IfState ifState = PopIfState();
|
|
if (!ifState.ElseBegin.Equals(ifState.EndIf))
|
|
MarkLabel(ifState.ElseBegin);
|
|
MarkLabel(ifState.EndIf);
|
|
}
|
|
|
|
internal void Call(MethodInfo methodInfo)
|
|
{
|
|
if (methodInfo.IsVirtual)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Callvirt " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString());
|
|
ilGen.Emit(OpCodes.Callvirt, methodInfo);
|
|
}
|
|
else if (methodInfo.IsStatic)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Static Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString());
|
|
ilGen.Emit(OpCodes.Call, methodInfo);
|
|
}
|
|
else
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString());
|
|
ilGen.Emit(OpCodes.Call, methodInfo);
|
|
}
|
|
}
|
|
|
|
internal void New(ConstructorInfo constructor)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Newobj " + constructor.ToString() + " on type " + constructor.DeclaringType.ToString());
|
|
ilGen.Emit(OpCodes.Newobj, constructor);
|
|
}
|
|
|
|
internal void InitObj(Type valueType)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Initobj " + valueType);
|
|
ilGen.Emit(OpCodes.Initobj, valueType);
|
|
}
|
|
|
|
internal void LoadArrayElement(object obj, object arrayIndex)
|
|
{
|
|
Type objType = GetVariableType(obj).GetElementType();
|
|
Load(obj);
|
|
Load(arrayIndex);
|
|
if (IsStruct(objType))
|
|
{
|
|
Ldelema(objType);
|
|
Ldobj(objType);
|
|
}
|
|
else
|
|
Ldelem(objType);
|
|
}
|
|
|
|
internal void StoreArrayElement(object obj, object arrayIndex, object value)
|
|
{
|
|
Type objType = GetVariableType(obj).GetElementType();
|
|
Load(obj);
|
|
Load(arrayIndex);
|
|
if (IsStruct(objType))
|
|
Ldelema(objType);
|
|
Load(value);
|
|
ConvertValue(GetVariableType(value), objType);
|
|
if (IsStruct(objType))
|
|
Stobj(objType);
|
|
else
|
|
Stelem(objType);
|
|
}
|
|
|
|
static bool IsStruct(Type objType)
|
|
{
|
|
return objType.IsValueType && !objType.IsPrimitive;
|
|
}
|
|
|
|
internal void Load(object obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldnull");
|
|
ilGen.Emit(OpCodes.Ldnull);
|
|
}
|
|
else if (obj is ArgBuilder)
|
|
Ldarg((ArgBuilder)obj);
|
|
else if (obj is LocalBuilder)
|
|
Ldloc((LocalBuilder)obj);
|
|
else
|
|
Ldc(obj);
|
|
}
|
|
|
|
internal void Store(object var)
|
|
{
|
|
if (var is ArgBuilder)
|
|
Starg((ArgBuilder)var);
|
|
else if (var is LocalBuilder)
|
|
Stloc((LocalBuilder)var);
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenCanOnlyStoreIntoArgOrLocGot0, var.GetType().FullName)));
|
|
}
|
|
|
|
internal void LoadAddress(object obj)
|
|
{
|
|
if (obj is ArgBuilder)
|
|
LdargAddress((ArgBuilder)obj);
|
|
else if (obj is LocalBuilder)
|
|
LdlocAddress((LocalBuilder)obj);
|
|
else
|
|
Load(obj);
|
|
}
|
|
|
|
internal void ConvertAddress(Type source, Type target)
|
|
{
|
|
InternalConvert(source, target, true);
|
|
}
|
|
|
|
internal void ConvertValue(Type source, Type target)
|
|
{
|
|
InternalConvert(source, target, false);
|
|
}
|
|
|
|
internal void Castclass(Type target)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Castclass " + target);
|
|
ilGen.Emit(OpCodes.Castclass, target);
|
|
}
|
|
|
|
internal void Box(Type type)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Box " + type);
|
|
ilGen.Emit(OpCodes.Box, type);
|
|
}
|
|
|
|
internal void Unbox(Type type)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Unbox " + type);
|
|
ilGen.Emit(OpCodes.Unbox, type);
|
|
}
|
|
|
|
internal void Ldobj(Type type)
|
|
{
|
|
OpCode opCode = GetLdindOpCode(Type.GetTypeCode(type));
|
|
if (!opCode.Equals(OpCodes.Nop))
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction(opCode.ToString());
|
|
ilGen.Emit(opCode);
|
|
}
|
|
else
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldobj " + type);
|
|
ilGen.Emit(OpCodes.Ldobj, type);
|
|
}
|
|
}
|
|
|
|
internal void Stobj(Type type)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Stobj " + type);
|
|
ilGen.Emit(OpCodes.Stobj, type);
|
|
}
|
|
|
|
internal void Ldtoken(Type t)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldtoken " + t);
|
|
ilGen.Emit(OpCodes.Ldtoken, t);
|
|
}
|
|
|
|
internal void Ldc(object o)
|
|
{
|
|
Type valueType = o.GetType();
|
|
if (o is Type)
|
|
{
|
|
Ldtoken((Type)o);
|
|
Call(GetTypeFromHandle);
|
|
}
|
|
else if (valueType.IsEnum)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceComment("Ldc " + o.GetType() + "." + o);
|
|
Ldc(((IConvertible)o).ToType(Enum.GetUnderlyingType(valueType), null));
|
|
}
|
|
else
|
|
{
|
|
switch (Type.GetTypeCode(valueType))
|
|
{
|
|
case TypeCode.Boolean:
|
|
Ldc((bool)o);
|
|
break;
|
|
case TypeCode.Char:
|
|
Ldc((int)(char)o);
|
|
break;
|
|
case TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
Ldc(((IConvertible)o).ToInt32(CultureInfo.InvariantCulture));
|
|
break;
|
|
case TypeCode.Int32:
|
|
Ldc((int)o);
|
|
break;
|
|
case TypeCode.UInt32:
|
|
Ldc((int)(uint)o);
|
|
break;
|
|
case TypeCode.String:
|
|
Ldstr((string)o);
|
|
break;
|
|
case TypeCode.UInt64:
|
|
case TypeCode.Int64:
|
|
case TypeCode.Single:
|
|
case TypeCode.Double:
|
|
case TypeCode.Object:
|
|
case TypeCode.Decimal:
|
|
case TypeCode.DateTime:
|
|
case TypeCode.Empty:
|
|
case TypeCode.DBNull:
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenUnknownConstantType, valueType.FullName)));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void Ldc(bool boolVar)
|
|
{
|
|
if (boolVar)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldc.i4 1");
|
|
ilGen.Emit(OpCodes.Ldc_I4_1);
|
|
}
|
|
else
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldc.i4 0");
|
|
ilGen.Emit(OpCodes.Ldc_I4_0);
|
|
}
|
|
}
|
|
|
|
internal void Ldc(int intVar)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldc.i4 " + intVar);
|
|
switch (intVar)
|
|
{
|
|
case -1:
|
|
ilGen.Emit(OpCodes.Ldc_I4_M1);
|
|
break;
|
|
case 0:
|
|
ilGen.Emit(OpCodes.Ldc_I4_0);
|
|
break;
|
|
case 1:
|
|
ilGen.Emit(OpCodes.Ldc_I4_1);
|
|
break;
|
|
case 2:
|
|
ilGen.Emit(OpCodes.Ldc_I4_2);
|
|
break;
|
|
case 3:
|
|
ilGen.Emit(OpCodes.Ldc_I4_3);
|
|
break;
|
|
case 4:
|
|
ilGen.Emit(OpCodes.Ldc_I4_4);
|
|
break;
|
|
case 5:
|
|
ilGen.Emit(OpCodes.Ldc_I4_5);
|
|
break;
|
|
case 6:
|
|
ilGen.Emit(OpCodes.Ldc_I4_6);
|
|
break;
|
|
case 7:
|
|
ilGen.Emit(OpCodes.Ldc_I4_7);
|
|
break;
|
|
case 8:
|
|
ilGen.Emit(OpCodes.Ldc_I4_8);
|
|
break;
|
|
default:
|
|
ilGen.Emit(OpCodes.Ldc_I4, intVar);
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal void Ldstr(string strVar)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldstr " + strVar);
|
|
ilGen.Emit(OpCodes.Ldstr, strVar);
|
|
}
|
|
|
|
internal void LdlocAddress(LocalBuilder localBuilder)
|
|
{
|
|
if (localBuilder.LocalType.IsValueType)
|
|
Ldloca(localBuilder);
|
|
else
|
|
Ldloc(localBuilder);
|
|
}
|
|
|
|
internal void Ldloc(LocalBuilder localBuilder)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldloc " + LocalNames[localBuilder]);
|
|
ilGen.Emit(OpCodes.Ldloc, localBuilder);
|
|
EmitStackTop(localBuilder.LocalType);
|
|
}
|
|
|
|
internal void Stloc(LocalBuilder local)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Stloc " + LocalNames[local]);
|
|
EmitStackTop(local.LocalType);
|
|
ilGen.Emit(OpCodes.Stloc, local);
|
|
}
|
|
|
|
internal void Ldloc(int slot)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldloc " + slot);
|
|
|
|
switch (slot)
|
|
{
|
|
case 0:
|
|
ilGen.Emit(OpCodes.Ldloc_0);
|
|
break;
|
|
case 1:
|
|
ilGen.Emit(OpCodes.Ldloc_1);
|
|
break;
|
|
case 2:
|
|
ilGen.Emit(OpCodes.Ldloc_2);
|
|
break;
|
|
case 3:
|
|
ilGen.Emit(OpCodes.Ldloc_3);
|
|
break;
|
|
default:
|
|
if (slot <= 255)
|
|
ilGen.Emit(OpCodes.Ldloc_S, slot);
|
|
else
|
|
ilGen.Emit(OpCodes.Ldloc, slot);
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal void Stloc(int slot)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Stloc " + slot);
|
|
switch (slot)
|
|
{
|
|
case 0:
|
|
ilGen.Emit(OpCodes.Stloc_0);
|
|
break;
|
|
case 1:
|
|
ilGen.Emit(OpCodes.Stloc_1);
|
|
break;
|
|
case 2:
|
|
ilGen.Emit(OpCodes.Stloc_2);
|
|
break;
|
|
case 3:
|
|
ilGen.Emit(OpCodes.Stloc_3);
|
|
break;
|
|
default:
|
|
if (slot <= 255)
|
|
ilGen.Emit(OpCodes.Stloc_S, slot);
|
|
else
|
|
ilGen.Emit(OpCodes.Stloc, slot);
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal void Ldloca(LocalBuilder localBuilder)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldloca " + LocalNames[localBuilder]);
|
|
ilGen.Emit(OpCodes.Ldloca, localBuilder);
|
|
EmitStackTop(localBuilder.LocalType);
|
|
}
|
|
|
|
internal void Ldloca(int slot)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldloca " + slot);
|
|
if (slot <= 255)
|
|
ilGen.Emit(OpCodes.Ldloca_S, slot);
|
|
else
|
|
ilGen.Emit(OpCodes.Ldloca, slot);
|
|
}
|
|
|
|
internal void LdargAddress(ArgBuilder argBuilder)
|
|
{
|
|
if (argBuilder.ArgType.IsValueType)
|
|
Ldarga(argBuilder);
|
|
else
|
|
Ldarg(argBuilder);
|
|
}
|
|
|
|
internal void Ldarg(ArgBuilder arg)
|
|
{
|
|
Ldarg(arg.Index);
|
|
}
|
|
|
|
internal void Starg(ArgBuilder arg)
|
|
{
|
|
Starg(arg.Index);
|
|
}
|
|
|
|
internal void Ldarg(int slot)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldarg " + slot);
|
|
switch (slot)
|
|
{
|
|
case 0:
|
|
ilGen.Emit(OpCodes.Ldarg_0);
|
|
break;
|
|
case 1:
|
|
ilGen.Emit(OpCodes.Ldarg_1);
|
|
break;
|
|
case 2:
|
|
ilGen.Emit(OpCodes.Ldarg_2);
|
|
break;
|
|
case 3:
|
|
ilGen.Emit(OpCodes.Ldarg_3);
|
|
break;
|
|
default:
|
|
if (slot <= 255)
|
|
ilGen.Emit(OpCodes.Ldarg_S, slot);
|
|
else
|
|
ilGen.Emit(OpCodes.Ldarg, slot);
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal void Starg(int slot)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Starg " + slot);
|
|
if (slot <= 255)
|
|
ilGen.Emit(OpCodes.Starg_S, slot);
|
|
else
|
|
ilGen.Emit(OpCodes.Starg, slot);
|
|
}
|
|
|
|
internal void Ldarga(ArgBuilder argBuilder)
|
|
{
|
|
Ldarga(argBuilder.Index);
|
|
}
|
|
|
|
internal void Ldarga(int slot)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ldarga " + slot);
|
|
if (slot <= 255)
|
|
ilGen.Emit(OpCodes.Ldarga_S, slot);
|
|
else
|
|
ilGen.Emit(OpCodes.Ldarga, slot);
|
|
}
|
|
|
|
internal void Ldelem(Type arrayElementType)
|
|
{
|
|
if (arrayElementType.IsEnum)
|
|
{
|
|
Ldelem(Enum.GetUnderlyingType(arrayElementType));
|
|
}
|
|
else
|
|
{
|
|
OpCode opCode = GetLdelemOpCode(Type.GetTypeCode(arrayElementType));
|
|
if (opCode.Equals(OpCodes.Nop))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenArrayTypeIsNotSupported, arrayElementType.FullName)));
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction(opCode.ToString());
|
|
ilGen.Emit(opCode);
|
|
EmitStackTop(arrayElementType);
|
|
}
|
|
}
|
|
|
|
internal void Ldelema(Type arrayElementType)
|
|
{
|
|
OpCode opCode = OpCodes.Ldelema;
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction(opCode.ToString());
|
|
ilGen.Emit(opCode, arrayElementType);
|
|
|
|
EmitStackTop(arrayElementType);
|
|
}
|
|
|
|
internal void Stelem(Type arrayElementType)
|
|
{
|
|
if (arrayElementType.IsEnum)
|
|
Stelem(Enum.GetUnderlyingType(arrayElementType));
|
|
else
|
|
{
|
|
OpCode opCode = GetStelemOpCode(Type.GetTypeCode(arrayElementType));
|
|
if (opCode.Equals(OpCodes.Nop))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenArrayTypeIsNotSupported, arrayElementType.FullName)));
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction(opCode.ToString());
|
|
EmitStackTop(arrayElementType);
|
|
ilGen.Emit(opCode);
|
|
}
|
|
}
|
|
|
|
internal Label DefineLabel()
|
|
{
|
|
return ilGen.DefineLabel();
|
|
}
|
|
|
|
internal void MarkLabel(Label label)
|
|
{
|
|
ilGen.MarkLabel(label);
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceLabel(label.GetHashCode() + ":");
|
|
}
|
|
|
|
internal void Ret()
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Ret");
|
|
ilGen.Emit(OpCodes.Ret);
|
|
}
|
|
|
|
internal void Br(Label label)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Br " + label.GetHashCode());
|
|
ilGen.Emit(OpCodes.Br, label);
|
|
}
|
|
|
|
internal void Brfalse(Label label)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Brfalse " + label.GetHashCode());
|
|
ilGen.Emit(OpCodes.Brfalse, label);
|
|
}
|
|
|
|
internal void Brtrue(Label label)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Brtrue " + label.GetHashCode());
|
|
ilGen.Emit(OpCodes.Brtrue, label);
|
|
}
|
|
|
|
internal void Pop()
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Pop");
|
|
ilGen.Emit(OpCodes.Pop);
|
|
}
|
|
|
|
internal void Dup()
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction("Dup");
|
|
ilGen.Emit(OpCodes.Dup);
|
|
}
|
|
|
|
void InternalIf(bool negate)
|
|
{
|
|
IfState ifState = new IfState();
|
|
ifState.EndIf = DefineLabel();
|
|
ifState.ElseBegin = DefineLabel();
|
|
if (negate)
|
|
Brtrue(ifState.ElseBegin);
|
|
else
|
|
Brfalse(ifState.ElseBegin);
|
|
blockStack.Push(ifState);
|
|
}
|
|
|
|
void InternalConvert(Type source, Type target, bool isAddress)
|
|
{
|
|
if (target == source)
|
|
return;
|
|
if (target.IsValueType)
|
|
{
|
|
if (source.IsValueType)
|
|
{
|
|
OpCode opCode = GetConvOpCode(Type.GetTypeCode(target));
|
|
if (opCode.Equals(OpCodes.Nop))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenNoConversionPossibleTo, target.FullName)));
|
|
else
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
EmitSourceInstruction(opCode.ToString());
|
|
ilGen.Emit(opCode);
|
|
}
|
|
}
|
|
else if (source.IsAssignableFrom(target))
|
|
{
|
|
Unbox(target);
|
|
if (!isAddress)
|
|
Ldobj(target);
|
|
}
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenIsNotAssignableFrom, target.FullName, source.FullName)));
|
|
}
|
|
else if (target.IsPointer)
|
|
{
|
|
Call(UnboxPointer);
|
|
}
|
|
else if (source.IsPointer)
|
|
{
|
|
Load(source);
|
|
Call(BoxPointer);
|
|
}
|
|
else if (target.IsAssignableFrom(source))
|
|
{
|
|
if (source.IsValueType)
|
|
{
|
|
if (isAddress)
|
|
Ldobj(source);
|
|
Box(source);
|
|
}
|
|
}
|
|
else if (source.IsAssignableFrom(target))
|
|
{
|
|
//assert(source.IsValueType == false);
|
|
Castclass(target);
|
|
}
|
|
else if (target.IsInterface || source.IsInterface)
|
|
{
|
|
Castclass(target);
|
|
}
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenIsNotAssignableFrom, target.FullName, source.FullName)));
|
|
}
|
|
|
|
IfState PopIfState()
|
|
{
|
|
object stackTop = blockStack.Pop();
|
|
IfState ifState = stackTop as IfState;
|
|
if (ifState == null)
|
|
ThrowMismatchException(stackTop);
|
|
return ifState;
|
|
}
|
|
|
|
#if USE_REFEMIT
|
|
void InitAssemblyBuilder(string methodName)
|
|
{
|
|
//if (assemblyBuilder == null) {
|
|
AssemblyName name = new AssemblyName();
|
|
name.Name = "Microsoft.GeneratedCode."+methodName;
|
|
bool saveAssembly = false;
|
|
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
saveAssembly = true;
|
|
|
|
if (saveAssembly)
|
|
{
|
|
assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndSave);
|
|
moduleBuilder = assemblyBuilder.DefineDynamicModule(name.Name, name.Name + ".dll", false);
|
|
}
|
|
else
|
|
{
|
|
assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run);
|
|
moduleBuilder = assemblyBuilder.DefineDynamicModule(name.Name, false);
|
|
}
|
|
//}
|
|
}
|
|
#endif
|
|
|
|
void ThrowMismatchException(object expected)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCodeGenExpectingEnd, expected.ToString())));
|
|
}
|
|
|
|
Hashtable LocalNames
|
|
{
|
|
get
|
|
{
|
|
if (localNames == null)
|
|
localNames = new Hashtable();
|
|
return localNames;
|
|
}
|
|
}
|
|
|
|
OpCode GetConvOpCode(TypeCode typeCode)
|
|
{
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Boolean:
|
|
return OpCodes.Conv_I1; // TypeCode.Boolean:
|
|
case TypeCode.Char:
|
|
return OpCodes.Conv_I2; // TypeCode.Char:
|
|
case TypeCode.SByte:
|
|
return OpCodes.Conv_I1; // TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
return OpCodes.Conv_U1; // TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
return OpCodes.Conv_I2; // TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
return OpCodes.Conv_U2; // TypeCode.UInt16:
|
|
case TypeCode.Int32:
|
|
return OpCodes.Conv_I4; // TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
return OpCodes.Conv_U4; // TypeCode.UInt32:
|
|
case TypeCode.Int64:
|
|
return OpCodes.Conv_I8; // TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
return OpCodes.Conv_I8; // TypeCode.UInt64:
|
|
case TypeCode.Single:
|
|
return OpCodes.Conv_R4; // TypeCode.Single:
|
|
case TypeCode.Double:
|
|
return OpCodes.Conv_R8; // TypeCode.Double:
|
|
default:
|
|
return OpCodes.Nop;
|
|
}
|
|
}
|
|
|
|
OpCode GetLdindOpCode(TypeCode typeCode)
|
|
{
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Boolean:
|
|
return OpCodes.Ldind_I1; // TypeCode.Boolean:
|
|
case TypeCode.Char:
|
|
return OpCodes.Ldind_I2; // TypeCode.Char:
|
|
case TypeCode.SByte:
|
|
return OpCodes.Ldind_I1; // TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
return OpCodes.Ldind_U1; // TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
return OpCodes.Ldind_I2; // TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
return OpCodes.Ldind_U2; // TypeCode.UInt16:
|
|
case TypeCode.Int32:
|
|
return OpCodes.Ldind_I4; // TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
return OpCodes.Ldind_U4; // TypeCode.UInt32:
|
|
case TypeCode.Int64:
|
|
return OpCodes.Ldind_I8; // TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
return OpCodes.Ldind_I8; // TypeCode.UInt64:
|
|
case TypeCode.Single:
|
|
return OpCodes.Ldind_R4; // TypeCode.Single:
|
|
case TypeCode.Double:
|
|
return OpCodes.Ldind_R8; // TypeCode.Double:
|
|
case TypeCode.String:
|
|
return OpCodes.Ldind_Ref; // TypeCode.String:
|
|
default:
|
|
return OpCodes.Nop;
|
|
}
|
|
//
|
|
}
|
|
|
|
OpCode GetLdelemOpCode(TypeCode typeCode)
|
|
{
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Object:
|
|
return OpCodes.Ldelem_Ref; // TypeCode.Object:
|
|
case TypeCode.Boolean:
|
|
return OpCodes.Ldelem_I1; // TypeCode.Boolean:
|
|
case TypeCode.Char:
|
|
return OpCodes.Ldelem_I2; // TypeCode.Char:
|
|
case TypeCode.SByte:
|
|
return OpCodes.Ldelem_I1; // TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
return OpCodes.Ldelem_U1; // TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
return OpCodes.Ldelem_I2; // TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
return OpCodes.Ldelem_U2; // TypeCode.UInt16:
|
|
case TypeCode.Int32:
|
|
return OpCodes.Ldelem_I4; // TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
return OpCodes.Ldelem_U4; // TypeCode.UInt32:
|
|
case TypeCode.Int64:
|
|
return OpCodes.Ldelem_I8; // TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
return OpCodes.Ldelem_I8; // TypeCode.UInt64:
|
|
case TypeCode.Single:
|
|
return OpCodes.Ldelem_R4; // TypeCode.Single:
|
|
case TypeCode.Double:
|
|
return OpCodes.Ldelem_R8; // TypeCode.Double:
|
|
case TypeCode.String:
|
|
return OpCodes.Ldelem_Ref; // TypeCode.String:
|
|
default:
|
|
return OpCodes.Nop;
|
|
}
|
|
}
|
|
|
|
OpCode GetStelemOpCode(TypeCode typeCode)
|
|
{
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Object:
|
|
return OpCodes.Stelem_Ref; // TypeCode.Object:
|
|
case TypeCode.Boolean:
|
|
return OpCodes.Stelem_I1; // TypeCode.Boolean:
|
|
case TypeCode.Char:
|
|
return OpCodes.Stelem_I2; // TypeCode.Char:
|
|
case TypeCode.SByte:
|
|
return OpCodes.Stelem_I1; // TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
return OpCodes.Stelem_I1; // TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
return OpCodes.Stelem_I2; // TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
return OpCodes.Stelem_I2; // TypeCode.UInt16:
|
|
case TypeCode.Int32:
|
|
return OpCodes.Stelem_I4; // TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
return OpCodes.Stelem_I4; // TypeCode.UInt32:
|
|
case TypeCode.Int64:
|
|
return OpCodes.Stelem_I8; // TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
return OpCodes.Stelem_I8; // TypeCode.UInt64:
|
|
case TypeCode.Single:
|
|
return OpCodes.Stelem_R4; // TypeCode.Single:
|
|
case TypeCode.Double:
|
|
return OpCodes.Stelem_R8; // TypeCode.Double:
|
|
case TypeCode.String:
|
|
return OpCodes.Stelem_Ref; // TypeCode.String:
|
|
default:
|
|
return OpCodes.Nop;
|
|
}
|
|
}
|
|
|
|
internal void EmitSourceInstruction(string line)
|
|
{
|
|
EmitSourceLine(" " + line);
|
|
}
|
|
|
|
internal void EmitSourceLabel(string line)
|
|
{
|
|
EmitSourceLine(line);
|
|
}
|
|
|
|
internal void EmitSourceComment(string comment)
|
|
{
|
|
EmitSourceInstruction("// " + comment);
|
|
}
|
|
|
|
internal void EmitSourceLine(string line)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.None)
|
|
OperationInvokerTrace.WriteInstruction(lineNo++, line);
|
|
if (ilGen != null && codeGenTrace == CodeGenTrace.Tron)
|
|
{
|
|
ilGen.Emit(OpCodes.Ldstr, string.Format(CultureInfo.InvariantCulture, "{0:00000}: {1}", lineNo - 1, line));
|
|
ilGen.Emit(OpCodes.Call, OperationInvokerTrace.TraceInstructionMethod);
|
|
}
|
|
}
|
|
|
|
internal void EmitStackTop(Type stackTopType)
|
|
{
|
|
if (codeGenTrace != CodeGenTrace.Tron)
|
|
return;
|
|
codeGenTrace = CodeGenTrace.None;
|
|
Dup();
|
|
ToString(stackTopType);
|
|
LocalBuilder topValue = DeclareLocal(typeof(string), "topValue");
|
|
Store(topValue);
|
|
Load("//value = ");
|
|
Load(topValue);
|
|
Concat2();
|
|
Call(OperationInvokerTrace.TraceInstructionMethod);
|
|
codeGenTrace = CodeGenTrace.Tron;
|
|
}
|
|
|
|
internal void ToString(Type type)
|
|
{
|
|
if (type.IsValueType)
|
|
{
|
|
Box(type);
|
|
Call(ObjectToString);
|
|
}
|
|
else
|
|
{
|
|
Dup();
|
|
IfNot();
|
|
Pop();
|
|
Load("<null>");
|
|
Else();
|
|
Call(ObjectToString);
|
|
EndIf();
|
|
}
|
|
}
|
|
|
|
internal void Concat2()
|
|
{
|
|
Call(StringConcat2);
|
|
}
|
|
|
|
internal void LoadZeroValueIntoLocal(Type type, LocalBuilder local)
|
|
{
|
|
if (type.IsValueType)
|
|
{
|
|
switch (Type.GetTypeCode(type))
|
|
{
|
|
case TypeCode.Boolean:
|
|
case TypeCode.Char:
|
|
case TypeCode.SByte:
|
|
case TypeCode.Byte:
|
|
case TypeCode.Int16:
|
|
case TypeCode.UInt16:
|
|
case TypeCode.Int32:
|
|
case TypeCode.UInt32:
|
|
ilGen.Emit(OpCodes.Ldc_I4_0);
|
|
Store(local);
|
|
break;
|
|
case TypeCode.Int64:
|
|
case TypeCode.UInt64:
|
|
ilGen.Emit(OpCodes.Ldc_I4_0);
|
|
ilGen.Emit(OpCodes.Conv_I8);
|
|
Store(local);
|
|
break;
|
|
case TypeCode.Single:
|
|
ilGen.Emit(OpCodes.Ldc_R4, 0.0F);
|
|
Store(local);
|
|
break;
|
|
case TypeCode.Double:
|
|
ilGen.Emit(OpCodes.Ldc_R8, 0.0);
|
|
Store(local);
|
|
break;
|
|
case TypeCode.Decimal:
|
|
case TypeCode.DateTime:
|
|
default:
|
|
LoadAddress(local);
|
|
InitObj(type);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Load(null);
|
|
Store(local);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class ArgBuilder
|
|
{
|
|
internal int Index;
|
|
internal Type ArgType;
|
|
internal ArgBuilder(int index, Type argType)
|
|
{
|
|
this.Index = index;
|
|
this.ArgType = argType;
|
|
}
|
|
}
|
|
|
|
internal class IfState
|
|
{
|
|
Label elseBegin;
|
|
Label endIf;
|
|
|
|
internal Label EndIf
|
|
{
|
|
get
|
|
{
|
|
return this.endIf;
|
|
}
|
|
set
|
|
{
|
|
this.endIf = value;
|
|
}
|
|
}
|
|
|
|
internal Label ElseBegin
|
|
{
|
|
get
|
|
{
|
|
return this.elseBegin;
|
|
}
|
|
set
|
|
{
|
|
this.elseBegin = value;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|