internal void BuildFunction()
{
// DONE: Convert HLMethods to LLFunctions
List <LLParameter> parameters = new List <LLParameter>();
foreach (HLParameter parameter in Parameters)
{
LLType typeParameter = parameter.Type.LLType;
// DONE: Adjust first parameter for string constructors to additional pointer depth plus one
if (parameter == Parameters.First() && Container == HLDomain.SystemString && !IsStatic && IsConstructor)
{
typeParameter = typeParameter.PointerDepthPlusOne;
}
parameters.Add(LLParameter.Create(typeParameter, parameter.Name));
}
bool entryFunction = HLDomain.EntryMethod == this;
mLLFunction = LLModule.GetOrCreateFunction(entryFunction ? "main" : (Container.ToString() + "." + ToString()), entryFunction, IsExternal, IsAbstract || IsRuntimeImplemented, ReturnType.LLType, parameters);
LLFunction.Description = Signature;
foreach (HLParameter parameter in Parameters.Where(p => p.RequiresAddressing))
{
parameter.AddressableLocal = LLFunction.CreateLocal(parameter.Type.LLType, "local_" + parameter.Name);
}
foreach (HLLocal local in Locals)
{
LLFunction.CreateLocal(local.Type.LLType, local.Name);
}
foreach (HLTemporary temporary in Temporaries)
{
LLFunction.CreateLocal(temporary.Type.LLType, temporary.Name);
}
}
private static void BuildDelegateInstance()
{
List <LLParameter> parametersFunction = new List <LLParameter>();
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1), "this"));
sDelegateInstance = LLModule.GetOrCreateFunction("DelegateInstance", true, true, false, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1), parametersFunction);
}
public static LLFunctionLocation Create(LLFunction pFunction)
{
LLFunctionLocation location = new LLFunctionLocation(LLModule.GetOrCreateFunctionType(pFunction.ReturnType, pFunction.Parameters.ToTypeList()).PointerDepthPlusOne);
location.mFunction = pFunction;
return(location);
}
internal override void Store(LLFunction pFunction, LLLocation pSource)
{
HLStaticFieldAddressLocation.CheckStaticConstructorCalled(pFunction, StaticField.Container);
LLLocation locationFieldPointer = LLGlobalLocation.Create(LLModule.GetGlobal(StaticField.Container.ToString() + "." + StaticField.ToString()));
LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationFieldPointer.Type.PointerDepthMinusOne);
pFunction.CurrentBlock.EmitStore(locationFieldPointer, locationSource);
}
private static void BuildGCRoot()
{
List <LLParameter> parametersFunction = new List <LLParameter>();
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 2), "ptrloc"));
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1), "metadata"));
sGCRoot = LLModule.GetOrCreateFunction("llvm.gcroot", true, true, false, LLModule.VoidType, parametersFunction);
}
private static void BuildVTableFunctionLookup()
{
List <LLParameter> parametersFunction = new List <LLParameter>();
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1), "this"));
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreateSignedType(32), "index"));
sVTableFunctionLookup = LLModule.GetOrCreateFunction("VTableFunctionLookup", true, true, false, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1), parametersFunction);
}
internal override void Transform(LLFunction pFunction)
{
LLLocation locationLeftOperand = mLeftOperandSource.Load(pFunction);
LLLocation locationRightOperand = mRightOperandSource.Load(pFunction);
LLType typeOperands = LLModule.BinaryResult(locationLeftOperand.Type, locationRightOperand.Type);
locationLeftOperand = pFunction.CurrentBlock.EmitConversion(locationLeftOperand, typeOperands);
locationRightOperand = pFunction.CurrentBlock.EmitConversion(locationRightOperand, typeOperands);
LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(LLModule.BooleanType));
if (typeOperands.Primitive == LLPrimitive.Float)
{
LLCompareFloatsCondition condition = LLCompareFloatsCondition.oeq;
switch (mCompareType)
{
case HLCompareType.Equal: condition = LLCompareFloatsCondition.oeq; break;
case HLCompareType.NotEqual: condition = LLCompareFloatsCondition.one; break;
case HLCompareType.GreaterThan: condition = LLCompareFloatsCondition.ogt; break;
case HLCompareType.GreaterThanOrEqual: condition = LLCompareFloatsCondition.oge; break;
case HLCompareType.LessThan: condition = LLCompareFloatsCondition.olt; break;
case HLCompareType.LessThanOrEqual: condition = LLCompareFloatsCondition.ole; break;
default: throw new NotSupportedException();
}
pFunction.CurrentBlock.EmitCompareFloats(locationTemporary, locationLeftOperand, locationRightOperand, condition);
}
else
{
LLCompareIntegersCondition condition = LLCompareIntegersCondition.eq;
switch (mCompareType)
{
case HLCompareType.Equal: condition = LLCompareIntegersCondition.eq; break;
case HLCompareType.NotEqual: condition = LLCompareIntegersCondition.ne; break;
case HLCompareType.GreaterThan: condition = typeOperands.Primitive == LLPrimitive.Unsigned ? LLCompareIntegersCondition.ugt : LLCompareIntegersCondition.sgt; break;
case HLCompareType.GreaterThanOrEqual: condition = typeOperands.Primitive == LLPrimitive.Unsigned ? LLCompareIntegersCondition.uge : LLCompareIntegersCondition.sge; break;
case HLCompareType.LessThan: condition = typeOperands.Primitive == LLPrimitive.Unsigned ? LLCompareIntegersCondition.ult : LLCompareIntegersCondition.slt; break;
case HLCompareType.LessThanOrEqual: condition = typeOperands.Primitive == LLPrimitive.Unsigned ? LLCompareIntegersCondition.ule : LLCompareIntegersCondition.sle; break;
default: throw new NotSupportedException();
}
pFunction.CurrentBlock.EmitCompareIntegers(locationTemporary, locationLeftOperand, locationRightOperand, condition);
}
mDestination.Store(pFunction, locationTemporary);
}
internal override LLLocation Load(LLFunction pFunction)
{
HLStaticFieldAddressLocation.CheckStaticConstructorCalled(pFunction, StaticField.Container);
LLLocation locationFieldPointer = LLGlobalLocation.Create(LLModule.GetGlobal(StaticField.Container.ToString() + "." + StaticField.ToString()));
LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationFieldPointer.Type.PointerDepthMinusOne));
pFunction.CurrentBlock.EmitLoad(locationTemporary, locationFieldPointer);
return(locationTemporary);
}
private static void BuildGCAllocate()
{
List <LLParameter> parametersFunction = new List <LLParameter>();
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 2), "this"));
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreateUnsignedType(32), "size"));
parametersFunction.Add(LLParameter.Create(LLModule.GetOrCreateSignedType(32), "handle"));
sGCAllocate = LLModule.GetOrCreateFunction("GCAllocate", true, true, false, LLModule.VoidType, parametersFunction);
}
private static void BuildRuntimeDataStringTable(HLStringTable pStringTable)
{
byte[] bufferRuntimeDataStringTable = pStringTable.ToASCIIBytes();
string[] literalsRuntimeDataStringTable = Array.ConvertAll(bufferRuntimeDataStringTable, b => b.ToString());
LLType typeRuntimeDataStringTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateSignedType(8), literalsRuntimeDataStringTable.Length);
LLGlobal globalRuntimeDataStringTable = LLModule.CreateGlobal(typeRuntimeDataStringTable.PointerDepthPlusOne, "RuntimeDataStringTable");
globalRuntimeDataStringTable.InitialValue = typeRuntimeDataStringTable.ToLiteral(literalsRuntimeDataStringTable);
}
private static void BuildRuntimeMethodData(HLStringTable pStringTable)
{
List <LLType> fieldsRuntimeMethodData = sSystemRuntimeMethodData.Fields.Where(f => !f.IsStatic).ToList().ConvertAll(f => f.Type.LLType);
LLType typePointer = LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1);
LLType typeRuntimeMethodData = LLModule.GetOrCreateStructureType("RuntimeMethodData", true, fieldsRuntimeMethodData);
LLType typeRuntimeMethodDataTable = LLModule.GetOrCreateArrayType(typeRuntimeMethodData, sMethods.Values.Count);
LLGlobal globalRuntimeMethodDataTable = LLModule.CreateGlobal(typeRuntimeMethodDataTable.PointerDepthPlusOne, "RuntimeMethodDataTable");
List <LLLiteral> literalsRuntimeMethodDataTable = new List <LLLiteral>();
List <LLFunction> functionsRuntimeMethodDataFunctionTable = new List <LLFunction>();
List <LLLiteral> literalsRuntimeMethodDataFunctionTable = new List <LLLiteral>();
foreach (HLMethod method in sMethods.Values.OrderBy(m => m.RuntimeMethodHandle))
{
int flags = 0;
if (method.IsStatic)
{
flags |= 1 << 0;
}
string definitionName = method.Definition.Name.Value;
int offsetName = pStringTable.Include(definitionName);
literalsRuntimeMethodDataTable.Add(typeRuntimeMethodData.ToLiteral(method.RuntimeMethodHandle.ToString(), flags.ToString(), offsetName.ToString()));
LLFunction function = method.LLFunction;
functionsRuntimeMethodDataFunctionTable.Add(function);
string literalAddress = null;
if (method.LLFunction.Abstract)
{
literalAddress = "null";
}
else
{
literalAddress = string.Format("bitcast({0} {1} to {2})", LLModule.GetOrCreatePointerType(function.FunctionType, 1), function, typePointer);
}
literalsRuntimeMethodDataFunctionTable.Add(LLLiteral.Create(typePointer, literalAddress));
}
globalRuntimeMethodDataTable.InitialValue = typeRuntimeMethodDataTable.ToLiteral(literalsRuntimeMethodDataTable.ConvertAll(l => l.Value).ToArray());
LLGlobal globalRuntimeMethodDataTableCount = LLModule.CreateGlobal(LLModule.GetOrCreateSignedType(32), "RuntimeMethodDataTableCount");
globalRuntimeMethodDataTableCount.InitialValue = LLLiteral.Create(LLModule.GetOrCreateSignedType(32), sMethods.Values.Count.ToString());
LLType typeRuntimeMethodDataFunctionTable = LLModule.GetOrCreateArrayType(typePointer, functionsRuntimeMethodDataFunctionTable.Count);
LLGlobal globalRuntimeMethodDataFunctionTable = LLModule.CreateGlobal(typeRuntimeMethodDataFunctionTable.PointerDepthPlusOne, "RuntimeMethodDataFunctionTable");
globalRuntimeMethodDataFunctionTable.InitialValue = typeRuntimeMethodDataFunctionTable.ToLiteral(literalsRuntimeMethodDataFunctionTable.ConvertAll(l => l.Value).ToArray());
LLGlobal globalRuntimeMethodDataFunctionTableCount = LLModule.CreateGlobal(LLModule.GetOrCreateSignedType(32), "RuntimeMethodDataFunctionTableCount");
globalRuntimeMethodDataFunctionTableCount.InitialValue = LLLiteral.Create(LLModule.GetOrCreateSignedType(32), functionsRuntimeMethodDataFunctionTable.Count.ToString());
sRuntimeMethodDataFunctionTable = globalRuntimeMethodDataFunctionTable;
}
private static void BuildRuntimeTypeHandles()
{
foreach (HLType type in sTypes.Values.OrderBy(t => t.RuntimeTypeHandle).Where(t => t.Definition.TypeCode != PrimitiveTypeCode.Pointer && t.Definition.TypeCode != PrimitiveTypeCode.Reference && !(t.Definition is IArrayType)))
{
string globalName = "RuntimeTypeHandle_" + type.ToString().Replace(".", "");
//int startOfPtrOrRef = globalName.IndexOfAny(new char[] { '*', '&' });
//if (startOfPtrOrRef > 0) globalName = globalName.Insert(startOfPtrOrRef, "_");
//globalName = globalName.Replace("*", "Ptr");
//globalName = globalName.Replace("&", "Ref");
LLGlobal globalHandle = LLModule.CreateGlobal(LLModule.GetOrCreateSignedType(32), globalName);
globalHandle.InitialValue = LLLiteral.Create(LLModule.GetOrCreateSignedType(32), type.RuntimeTypeHandle.ToString());
}
}
internal override LLLocation Load(LLFunction pFunction)
{
List <LLLocation> parameters = new List <LLLocation>();
LLLocation locationStringReference = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.SystemStringCtorWithCharPointer.Parameters[0].Type.LLType.PointerDepthPlusOne));
pFunction.CurrentBlock.EmitAllocate(locationStringReference);
pFunction.CurrentBlock.EmitStore(locationStringReference, LLLiteralLocation.Create(LLLiteral.Create(locationStringReference.Type.PointerDepthMinusOne, "zeroinitializer")));
parameters.Add(locationStringReference);
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCRoot.Parameters[1].Type, "null")));
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCRoot), parameters);
parameters.Clear();
parameters.Add(locationStringReference);
char[] data = Literal.ToCharArray();
Array.Resize(ref data, data.Length + 1);
LLType typeChar = LLModule.GetOrCreateSignedType(16);
LLType typeLiteralData = LLModule.GetOrCreateArrayType(typeChar, data.Length);
LLLocation locationLiteralData = LLTemporaryLocation.Create(pFunction.CreateTemporary(typeLiteralData.PointerDepthPlusOne));
pFunction.CurrentBlock.EmitAllocate(locationLiteralData);
StringBuilder sb = new StringBuilder();
sb.Append("[ ");
for (int index = 0; index < data.Length; ++index)
{
if (index > 0)
{
sb.Append(", ");
}
sb.AppendFormat("{0} {1}", typeChar, (int)data[index]);
}
sb.Append(" ]");
pFunction.CurrentBlock.EmitStore(locationLiteralData, LLLiteralLocation.Create(LLLiteral.Create(typeLiteralData, sb.ToString())));
parameters.Add(locationLiteralData);
for (int index = 1; index < parameters.Count; ++index)
{
parameters[index] = pFunction.CurrentBlock.EmitConversion(parameters[index], HLDomain.SystemStringCtorWithCharPointer.Parameters[index].Type.LLType);
}
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.SystemStringCtorWithCharPointer.LLFunction), parameters);
LLLocation locationString = LLTemporaryLocation.Create(pFunction.CreateTemporary(Type.LLType));
pFunction.CurrentBlock.EmitLoad(locationString, locationStringReference);
return(locationString);
}
private static void BuildGlobals()
{
foreach (HLType type in sTypes.Values)
{
// DONE: Create LLGlobal for static constructor runtime called check
if (type.StaticConstructor != null)
{
LLModule.CreateGlobal(LLModule.GetOrCreateUnsignedType(8).PointerDepthPlusOne, type.ToString());
}
// DONE: Convert Static Non-Constant HLFields to LLGlobals
foreach (HLField field in type.StaticFields.Where(f => !f.IsCompileTimeConstant))
{
LLModule.CreateGlobal(field.Type.LLType.PointerDepthPlusOne, type.ToString() + "." + field.ToString());
}
}
}
internal override void Transform(LLFunction pFunction)
{
LLLocation locationLeftOperand = mLeftOperandSource.Load(pFunction);
LLLocation locationRightOperand = mRightOperandSource.Load(pFunction);
LLType typeOperands = LLModule.BinaryResult(locationLeftOperand.Type, locationRightOperand.Type);
locationLeftOperand = pFunction.CurrentBlock.EmitConversion(locationLeftOperand, typeOperands);
locationRightOperand = pFunction.CurrentBlock.EmitConversion(locationRightOperand, typeOperands);
LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(typeOperands));
pFunction.CurrentBlock.EmitMultiply(locationTemporary, locationLeftOperand, locationRightOperand);
mDestination.Store(pFunction, locationTemporary);
}
internal static void CheckStaticConstructorCalled(LLFunction pFunction, HLType pType)
{
if (pType.StaticConstructor == null)
{
return;
}
if (pType.StaticConstructor.LLFunction == pFunction)
{
return;
}
LLLocation locationConstructorCalled = LLGlobalLocation.Create(LLModule.GetGlobal(pType.ToString()));
LLLocation locationConstructorCalledOriginal = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationConstructorCalled.Type.PointerDepthMinusOne));
pFunction.CurrentBlock.EmitCompareExchange(locationConstructorCalledOriginal, locationConstructorCalled, LLLiteralLocation.Create(LLLiteral.Create(locationConstructorCalledOriginal.Type, "0")), LLLiteralLocation.Create(LLLiteral.Create(locationConstructorCalledOriginal.Type, "1")), LLCompareExchangeOrdering.acq_rel);
LLLocation locationConstructorCall = LLTemporaryLocation.Create(pFunction.CreateTemporary(LLModule.BooleanType));
pFunction.CurrentBlock.EmitCompareIntegers(locationConstructorCall, locationConstructorCalledOriginal, LLLiteralLocation.Create(LLLiteral.Create(locationConstructorCalledOriginal.Type, "0")), LLCompareIntegersCondition.eq);
LLLabel labelTrue = pFunction.CreateLabel(pFunction.Labels.Count);
LLLabel labelFalse = pFunction.CreateLabel(pFunction.Labels.Count);
LLLabel labelNext = pFunction.CreateLabel(pFunction.Labels.Count);
pFunction.CurrentBlock.EmitBranch(locationConstructorCall, labelTrue, labelFalse);
LLInstructionBlock blockTrue = pFunction.CreateBlock(labelTrue);
List <LLLocation> parameters = new List <LLLocation>();
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(pType.StaticConstructor.LLFunction.Parameters[0].Type, "zeroinitializer")));
blockTrue.EmitCall(null, LLFunctionLocation.Create(pType.StaticConstructor.LLFunction), parameters);
blockTrue.EmitGoto(labelNext);
LLInstructionBlock blockFalse = pFunction.CreateBlock(labelFalse);
blockFalse.EmitGoto(labelNext);
pFunction.CurrentBlock = pFunction.CreateBlock(labelNext);
}
internal static LLLocation LoadArrayElementPointer(LLFunction pFunction, HLLocation pInstance, HLLocation pIndex, HLType pElementType)
{
LLLocation locationIndex = pIndex.Load(pFunction);
LLLocation locationElementOffset = locationIndex;
long? literalElementOffset = null;
if (locationIndex is LLLiteralLocation)
{
literalElementOffset = Convert.ToInt64(((LLLiteralLocation)locationIndex).Literal.Value) * pElementType.VariableSize;
}
else if (pElementType.VariableSize > 1)
{
locationElementOffset = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationIndex.Type));
pFunction.CurrentBlock.EmitMultiply(locationElementOffset, locationIndex, LLLiteralLocation.Create(LLLiteral.Create(locationElementOffset.Type, pElementType.VariableSize.ToString())));
}
LLLocation locationArrayPointer = pInstance.Load(pFunction);
locationArrayPointer = pFunction.CurrentBlock.EmitConversion(locationArrayPointer, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1));
LLLocation locationElementPointer = null;
if (literalElementOffset.HasValue)
{
locationElementOffset = LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(64), (literalElementOffset.Value + HLDomain.SystemArray.CalculatedSize).ToString()));
locationElementPointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationArrayPointer.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationElementPointer, locationArrayPointer, locationElementOffset);
}
else
{
LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationArrayPointer.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationTemporary, locationArrayPointer, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), (HLDomain.SystemArray.CalculatedSize).ToString())));
locationElementPointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationArrayPointer.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationElementPointer, locationTemporary, locationElementOffset);
}
return(pFunction.CurrentBlock.EmitConversion(locationElementPointer, pElementType.LLType.PointerDepthPlusOne));
}
public static void Process(string pInputPath)
{
sModule = Decompiler.GetCodeModelFromMetadataModel(Host, Host.LoadUnitFrom(pInputPath) as IModule, null);
sPlatformType = Module.PlatformType;
sRuntimeAssembly = (IAssembly)PlatformType.SystemRuntimeTypeHandle.ContainingUnitNamespace.Unit.ResolvedUnit;
EnlistRuntimeTypes();
EnlistRuntimeMethods();
sEntryMethod = GetOrCreateMethod(Module.EntryPoint);
int checkedTypes = 0;
while (sTypes.Count != checkedTypes || sPendingMethods.Count > 0)
{
// STARTED: Process IStatements/IExpressions into HLInstructionBlocks/HLInstructions
while (sPendingMethods.Count > 0)
{
sPendingMethods.Dequeue().Process();
}
// STARTED: Build virtual map for each type and include any missing override methods
// starting at the top the chain (Object) and working down to the given type, then process
// pending methods and repeat until no methods or types are added, as each new method may
// add new types and methods
checkedTypes = sTypes.Count;
foreach (HLType type in sTypes.Values.ToList())
{
type.MapVirtualMethods();
}
}
// NOTE: After this point, do not GetOrCreate types and methods
// DONE: Build virtual table and virtual index lookup from the complete virtual maps
foreach (HLType type in sTypes.Values)
{
type.BuildVirtualTable();
}
// DONE: Determine HLType Calculated and Variable sizes
// DONE: Layout Non-Static HLField offsets
foreach (HLType type in sTypes.Values)
{
type.LayoutFields();
}
// NOTE: After this point, conversion to LL begins
// DONE: Convert HLTypes to LLTypes
BuildGCAllocate();
BuildGCRoot();
BuildVTableHandleLookup();
BuildVTableFunctionLookup();
BuildDelegateLookup();
BuildDelegateInstance();
BuildGlobals();
foreach (HLMethod method in sMethods.Values.ToList())
{
method.BuildFunction();
}
HLStringTable stringTable = new HLStringTable();
// STARTED: Build constant global runtime type handles
BuildRuntimeTypeHandles();
// STARTED: Build constant global runtime type data
BuildRuntimeTypeData(stringTable);
// STARTED: Build constant global runtime method data
BuildRuntimeMethodData(stringTable);
// STARTED: Build constant global runtime data string table
BuildRuntimeDataStringTable(stringTable);
// STARTED: Convert HLInstructions to LLInstructions
foreach (HLMethod method in sMethods.Values)
{
method.Transform();
}
using (StreamWriter writer = new StreamWriter(Path.ChangeExtension(pInputPath, ".ll")))
{
LLModule.Dump(writer);
}
}
private static void BuildRuntimeTypeData(HLStringTable pStringTable)
{
List <LLType> fieldsRuntimeTypeData = sSystemRuntimeTypeData.Fields.Where(f => !f.IsStatic).ToList().ConvertAll(f => f.Type.LLType);
LLType typePointer = LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1);
LLType typeRuntimeTypeData = LLModule.GetOrCreateStructureType("RuntimeTypeData", true, fieldsRuntimeTypeData);
LLType typeRuntimeTypeDataTable = LLModule.GetOrCreateArrayType(typeRuntimeTypeData, sTypes.Values.Count);
LLGlobal globalRuntimeTypeDataTable = LLModule.CreateGlobal(typeRuntimeTypeDataTable.PointerDepthPlusOne, "RuntimeTypeDataTable");
List <LLLiteral> literalsRuntimeTypeDataTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum8ValueTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum16ValueTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum32ValueTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum64ValueTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum8NameTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum16NameTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum32NameTable = new List <LLLiteral>();
List <LLLiteral> literalsRuntimeTypeDataEnum64NameTable = new List <LLLiteral>();
List <int> handlesRuntimeTypeDataVirtualTable = new List <int>();
List <LLLiteral> literalsRuntimeTypeDataVirtualTable = new List <LLLiteral>();
foreach (HLType type in sTypes.Values.OrderBy(t => t.RuntimeTypeHandle))
{
int flags = 0;
if (type.Definition.IsValueType)
{
flags |= 1 << 0;
}
if (type.Definition.IsEnum)
{
flags |= 1 << 1;
}
string definitionName = TypeHelper.GetTypeName(type.Definition, NameFormattingOptions.OmitContainingNamespace);
int offsetName = pStringTable.Include(definitionName);
int offsetNamespace = 0;
if (type.Definition is INamespaceTypeDefinition)
{
string definitionNamespace = TypeHelper.GetNamespaceName(((INamespaceTypeDefinition)type.Definition).ContainingUnitNamespace, NameFormattingOptions.None);
offsetNamespace = pStringTable.Include(definitionNamespace);
}
int offsetEnum = 0;
int countEnum = 0;
if (type.Definition.IsEnum)
{
countEnum = type.StaticFields.Count;
switch (type.MemberFields[0].Type.VariableSize)
{
case 1:
offsetEnum = literalsRuntimeTypeDataEnum8ValueTable.Count;
for (int index = 0; index < type.StaticFields.Count; ++index)
{
int offsetEnumName = pStringTable.Include(type.StaticFields[index].Name);
literalsRuntimeTypeDataEnum8ValueTable.Add(LLLiteral.Create(LLModule.GetOrCreateUnsignedType(8), type.StaticFields[index].CompileTimeConstant.ToString()));
literalsRuntimeTypeDataEnum8NameTable.Add(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), offsetEnumName.ToString()));
}
break;
case 2:
offsetEnum = literalsRuntimeTypeDataEnum16ValueTable.Count;
for (int index = 0; index < type.StaticFields.Count; ++index)
{
int offsetEnumName = pStringTable.Include(type.StaticFields[index].Name);
literalsRuntimeTypeDataEnum16ValueTable.Add(LLLiteral.Create(LLModule.GetOrCreateUnsignedType(16), type.StaticFields[index].CompileTimeConstant.ToString()));
literalsRuntimeTypeDataEnum16NameTable.Add(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), offsetEnumName.ToString()));
}
break;
case 4:
offsetEnum = literalsRuntimeTypeDataEnum32ValueTable.Count;
for (int index = 0; index < type.StaticFields.Count; ++index)
{
int offsetEnumName = pStringTable.Include(type.StaticFields[index].Name);
literalsRuntimeTypeDataEnum32ValueTable.Add(LLLiteral.Create(LLModule.GetOrCreateUnsignedType(32), type.StaticFields[index].CompileTimeConstant.ToString()));
literalsRuntimeTypeDataEnum32NameTable.Add(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), offsetEnumName.ToString()));
}
break;
case 8:
offsetEnum = literalsRuntimeTypeDataEnum64ValueTable.Count;
for (int index = 0; index < type.StaticFields.Count; ++index)
{
int offsetEnumName = pStringTable.Include(type.StaticFields[index].Name);
literalsRuntimeTypeDataEnum64ValueTable.Add(LLLiteral.Create(LLModule.GetOrCreateUnsignedType(64), type.StaticFields[index].CompileTimeConstant.ToString()));
literalsRuntimeTypeDataEnum64NameTable.Add(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), offsetEnumName.ToString()));
}
break;
default: throw new NotSupportedException();
}
}
literalsRuntimeTypeDataTable.Add(typeRuntimeTypeData.ToLiteral(type.RuntimeTypeHandle.ToString(),
flags.ToString(),
type.CalculatedSize.ToString(),
offsetName.ToString(),
offsetNamespace.ToString(),
handlesRuntimeTypeDataVirtualTable.Count.ToString(),
offsetEnum.ToString(),
countEnum.ToString()));
//List<LLFunction> functions = type.VirtualTable.ConvertAll(m => m.LLFunction);
foreach (HLMethod method in type.VirtualTable)
{
handlesRuntimeTypeDataVirtualTable.Add(method.RuntimeMethodHandle);
literalsRuntimeTypeDataVirtualTable.Add(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), method.RuntimeMethodHandle.ToString()));
}
//foreach (LLFunction function in functions)
//{
// handlesRuntimeTypeDataVirtualTable.Add(function);
// string literalAddress = null;
// if (function.Abstract) literalAddress = "null";
// else literalAddress = string.Format("bitcast({0} {1} to {2})", LLModule.GetOrCreatePointerType(function.FunctionType, 1), function, typePointer);
// literalsRuntimeTypeDataVirtualTable.Add(LLLiteral.Create(typePointer, literalAddress));
//}
}
globalRuntimeTypeDataTable.InitialValue = typeRuntimeTypeDataTable.ToLiteral(literalsRuntimeTypeDataTable.ConvertAll(l => l.Value).ToArray());
LLGlobal globalRuntimeTypeDataTableCount = LLModule.CreateGlobal(LLModule.GetOrCreateSignedType(32), "RuntimeTypeDataTableCount");
globalRuntimeTypeDataTableCount.InitialValue = LLLiteral.Create(LLModule.GetOrCreateSignedType(32), sTypes.Values.Count.ToString());
LLType typeRuntimeTypeDataEnum8ValueTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateUnsignedType(8), literalsRuntimeTypeDataEnum8ValueTable.Count);
LLGlobal globalRuntimeTypeDataEnum8ValueTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum8ValueTable.PointerDepthPlusOne, "RuntimeTypeDataEnum8ValueTable");
globalRuntimeTypeDataEnum8ValueTable.InitialValue = typeRuntimeTypeDataEnum8ValueTable.ToLiteral(literalsRuntimeTypeDataEnum8ValueTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum8NameTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateSignedType(32), literalsRuntimeTypeDataEnum8NameTable.Count);
LLGlobal globalRuntimeTypeDataEnum8NameTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum8NameTable.PointerDepthPlusOne, "RuntimeTypeDataEnum8NameTable");
globalRuntimeTypeDataEnum8NameTable.InitialValue = typeRuntimeTypeDataEnum8NameTable.ToLiteral(literalsRuntimeTypeDataEnum8NameTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum16ValueTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateUnsignedType(16), literalsRuntimeTypeDataEnum16ValueTable.Count);
LLGlobal globalRuntimeTypeDataEnum16ValueTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum16ValueTable.PointerDepthPlusOne, "RuntimeTypeDataEnum16ValueTable");
globalRuntimeTypeDataEnum16ValueTable.InitialValue = typeRuntimeTypeDataEnum16ValueTable.ToLiteral(literalsRuntimeTypeDataEnum16ValueTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum16NameTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateSignedType(32), literalsRuntimeTypeDataEnum16NameTable.Count);
LLGlobal globalRuntimeTypeDataEnum16NameTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum16NameTable.PointerDepthPlusOne, "RuntimeTypeDataEnum16NameTable");
globalRuntimeTypeDataEnum16NameTable.InitialValue = typeRuntimeTypeDataEnum16NameTable.ToLiteral(literalsRuntimeTypeDataEnum16NameTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum32ValueTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateUnsignedType(32), literalsRuntimeTypeDataEnum32ValueTable.Count);
LLGlobal globalRuntimeTypeDataEnum32ValueTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum32ValueTable.PointerDepthPlusOne, "RuntimeTypeDataEnum32ValueTable");
globalRuntimeTypeDataEnum32ValueTable.InitialValue = typeRuntimeTypeDataEnum32ValueTable.ToLiteral(literalsRuntimeTypeDataEnum32ValueTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum32NameTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateSignedType(32), literalsRuntimeTypeDataEnum32NameTable.Count);
LLGlobal globalRuntimeTypeDataEnum32NameTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum32NameTable.PointerDepthPlusOne, "RuntimeTypeDataEnum32NameTable");
globalRuntimeTypeDataEnum32NameTable.InitialValue = typeRuntimeTypeDataEnum32NameTable.ToLiteral(literalsRuntimeTypeDataEnum32NameTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum64ValueTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateUnsignedType(64), literalsRuntimeTypeDataEnum64ValueTable.Count);
LLGlobal globalRuntimeTypeDataEnum64ValueTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum64ValueTable.PointerDepthPlusOne, "RuntimeTypeDataEnum64ValueTable");
globalRuntimeTypeDataEnum64ValueTable.InitialValue = typeRuntimeTypeDataEnum64ValueTable.ToLiteral(literalsRuntimeTypeDataEnum64ValueTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataEnum64NameTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateSignedType(32), literalsRuntimeTypeDataEnum64NameTable.Count);
LLGlobal globalRuntimeTypeDataEnum64NameTable = LLModule.CreateGlobal(typeRuntimeTypeDataEnum64NameTable.PointerDepthPlusOne, "RuntimeTypeDataEnum64NameTable");
globalRuntimeTypeDataEnum64NameTable.InitialValue = typeRuntimeTypeDataEnum64NameTable.ToLiteral(literalsRuntimeTypeDataEnum64NameTable.ConvertAll(l => l.Value).ToArray());
LLType typeRuntimeTypeDataVirtualTable = LLModule.GetOrCreateArrayType(LLModule.GetOrCreateSignedType(32), handlesRuntimeTypeDataVirtualTable.Count);
LLGlobal globalRuntimeTypeDataVirtualTable = LLModule.CreateGlobal(typeRuntimeTypeDataVirtualTable.PointerDepthPlusOne, "RuntimeTypeDataVirtualTable");
globalRuntimeTypeDataVirtualTable.InitialValue = typeRuntimeTypeDataVirtualTable.ToLiteral(literalsRuntimeTypeDataVirtualTable.ConvertAll(l => l.Value).ToArray());
LLGlobal globalRuntimeTypeDataVirtualTableCount = LLModule.CreateGlobal(LLModule.GetOrCreateSignedType(32), "RuntimeTypeDataVirtualTableCount");
globalRuntimeTypeDataVirtualTableCount.InitialValue = LLLiteral.Create(LLModule.GetOrCreateSignedType(32), handlesRuntimeTypeDataVirtualTable.Count.ToString());
}
internal override LLLocation Load(LLFunction pFunction)
{
CheckStaticConstructorCalled(pFunction, StaticField.Container);
return(LLGlobalLocation.Create(LLModule.GetGlobal(StaticField.Container.ToString() + "." + StaticField.ToString())));
}
internal override void Transform(LLFunction pFunction)
{
List <LLLocation> parameters = new List <LLLocation>();
LLLocation locationArrayReference = mDestinationSource.Load(pFunction);
pFunction.CurrentBlock.EmitStore(locationArrayReference, LLLiteralLocation.Create(LLLiteral.Create(locationArrayReference.Type.PointerDepthMinusOne, "zeroinitializer")));
parameters.Add(locationArrayReference);
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCRoot.Parameters[1].Type, "null")));
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCRoot), parameters);
LLLocation locationSize = mSizeSource.Load(pFunction);
LLLocation locationElementsSize = locationSize;
if (mElementType.VariableSize > 1)
{
locationElementsSize = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationSize.Type));
pFunction.CurrentBlock.EmitMultiply(locationElementsSize, locationSize, LLLiteralLocation.Create(LLLiteral.Create(locationSize.Type, mElementType.VariableSize.ToString())));
}
LLLocation locationTotalSize = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationSize.Type));
pFunction.CurrentBlock.EmitAdd(locationTotalSize, locationElementsSize, LLLiteralLocation.Create(LLLiteral.Create(locationSize.Type, (HLDomain.SystemArray.CalculatedSize).ToString())));
locationTotalSize = pFunction.CurrentBlock.EmitConversion(locationTotalSize, HLDomain.GCAllocate.Parameters[1].Type);
LLLocation locationHandle = LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCAllocate.Parameters[2].Type, mArrayType.RuntimeTypeHandle.ToString()));
parameters.Clear();
parameters.Add(locationArrayReference);
parameters.Add(locationTotalSize);
parameters.Add(locationHandle);
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCAllocate), parameters);
LLLocation locationArrayPointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationArrayReference.Type.PointerDepthMinusOne));
pFunction.CurrentBlock.EmitLoad(locationArrayPointer, locationArrayReference);
locationArrayPointer = pFunction.CurrentBlock.EmitConversion(locationArrayPointer, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1));
LLLocation locationArraySizePointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationArrayPointer.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationArraySizePointer, locationArrayPointer, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), HLDomain.SystemObject.CalculatedSize.ToString())));
locationArraySizePointer = pFunction.CurrentBlock.EmitConversion(locationArraySizePointer, locationSize.Type.PointerDepthPlusOne);
pFunction.CurrentBlock.EmitStore(locationArraySizePointer, locationSize);
}
internal override void Transform(LLFunction pFunction)
{
List <LLLocation> parameters = new List <LLLocation>();
LLLocation locationDelegateReference = mDestinationSource.Load(pFunction);
pFunction.CurrentBlock.EmitStore(locationDelegateReference, LLLiteralLocation.Create(LLLiteral.Create(locationDelegateReference.Type.PointerDepthMinusOne, "zeroinitializer")));
parameters.Add(locationDelegateReference);
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCRoot.Parameters[1].Type, "null")));
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCRoot), parameters);
LLLocation locationTotalSize = LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCAllocate.Parameters[1].Type, mNewDelegateType.CalculatedSize.ToString()));
LLLocation locationHandle = LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCAllocate.Parameters[2].Type, mNewDelegateType.RuntimeTypeHandle.ToString()));
parameters.Clear();
parameters.Add(locationDelegateReference);
parameters.Add(locationTotalSize);
parameters.Add(locationHandle);
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCAllocate), parameters);
LLLocation locationDelegate = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationDelegateReference.Type.PointerDepthMinusOne));
pFunction.CurrentBlock.EmitLoad(locationDelegate, locationDelegateReference);
LLLocation locationTargetObj = null;
if (mInstanceSource != null)
{
LLLocation locationTargetObjPointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationDelegate.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationTargetObjPointer, locationDelegate, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), mNewDelegateType.Fields["mTargetObj"].Offset.ToString())));
locationTargetObjPointer = pFunction.CurrentBlock.EmitConversion(locationTargetObjPointer, mInstanceSource.Type.LLType.PointerDepthPlusOne);
locationTargetObj = mInstanceSource.Load(pFunction);
pFunction.CurrentBlock.EmitStore(locationTargetObjPointer, locationTargetObj);
}
LLLocation locationTargetMethodPointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationDelegate.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationTargetMethodPointer, locationDelegate, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), mNewDelegateType.Fields["mTargetMethod"].Offset.ToString())));
locationTargetMethodPointer = pFunction.CurrentBlock.EmitConversion(locationTargetMethodPointer, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateSignedType(32), 1));
LLLocation locationTargetMethod = null;
if (!mVirtual)
{
locationTargetMethod = LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), mMethodCalled.RuntimeMethodHandle.ToString()));
}
else
{
LLType typeFunction = LLModule.GetOrCreateFunctionType(mMethodCalled.ReturnType == null ? null : mMethodCalled.ReturnType.LLType, mMethodCalled.Parameters.ConvertAll(p => p.Type.LLType));
int virtualIndex = mMethodCalled.Container.VirtualLookup[mMethodCalled];
parameters.Clear();
parameters.Add(locationTargetObj);
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), virtualIndex.ToString())));
for (int index = 0; index < parameters.Count; ++index)
{
parameters[index] = pFunction.CurrentBlock.EmitConversion(parameters[index], HLDomain.VTableHandleLookup.Parameters[index].Type);
}
locationTargetMethod = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.VTableHandleLookup.ReturnType));
pFunction.CurrentBlock.EmitCall(locationTargetMethod, LLFunctionLocation.Create(HLDomain.VTableHandleLookup), parameters);
locationTargetMethod = pFunction.CurrentBlock.EmitConversion(locationTargetMethod, LLModule.GetOrCreateSignedType(32));
}
pFunction.CurrentBlock.EmitStore(locationTargetMethodPointer, locationTargetMethod);
}
internal override LLLocation Load(LLFunction pFunction)
{
LLLocation locationArrayPointer = Instance.Load(pFunction);
locationArrayPointer = pFunction.CurrentBlock.EmitConversion(locationArrayPointer, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1));
LLLocation locationArraySizePointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationArrayPointer.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationArraySizePointer, locationArrayPointer, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), HLDomain.SystemArray.Fields["mLength"].Offset.ToString())));
locationArraySizePointer = pFunction.CurrentBlock.EmitConversion(locationArraySizePointer, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateSignedType(32), 1));
LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(LLModule.GetOrCreateSignedType(32)));
pFunction.CurrentBlock.EmitLoad(locationTemporary, locationArraySizePointer);
return(pFunction.CurrentBlock.EmitConversion(locationTemporary, Type.LLType));
}
internal override void Transform(LLFunction pFunction)
{
List <LLLocation> parameters = new List <LLLocation>();
LLLocation locationReturn = null;
LLLocation locationFunction = null;
LLLocation locationAlternativeThis = null;
if (!mVirtual)
{
locationFunction = LLFunctionLocation.Create(mCalledMethod.LLFunction);
}
else if (mCalledMethod.Container.Definition.IsDelegate && mCalledMethod.Name == "Invoke")
{
parameters.Add(mParameterSources[0].Load(pFunction));
locationFunction = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.DelegateLookup.ReturnType));
pFunction.CurrentBlock.EmitCall(locationFunction, LLFunctionLocation.Create(HLDomain.DelegateLookup), parameters);
LLType typeFunction = LLModule.GetOrCreateFunctionType(mCalledMethod.ReturnType == null ? null : mCalledMethod.ReturnType.LLType, mParameterSources.ConvertAll(l => l.Type.LLType));
locationFunction = pFunction.CurrentBlock.EmitConversion(locationFunction, LLModule.GetOrCreatePointerType(typeFunction, 1));
locationAlternativeThis = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.DelegateInstance.ReturnType));
pFunction.CurrentBlock.EmitCall(locationAlternativeThis, LLFunctionLocation.Create(HLDomain.DelegateInstance), parameters);
}
else
{
LLType typeFunction = LLModule.GetOrCreateFunctionType(mCalledMethod.ReturnType == null ? null : mCalledMethod.ReturnType.LLType, mParameterSources.ConvertAll(l => l.Type.LLType));
int virtualIndex = mCalledMethod.Container.VirtualLookup[mCalledMethod];
parameters.Add(mParameterSources[0].Load(pFunction));
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), virtualIndex.ToString())));
for (int index = 0; index < parameters.Count; ++index)
{
parameters[index] = pFunction.CurrentBlock.EmitConversion(parameters[index], HLDomain.VTableFunctionLookup.Parameters[index].Type);
}
locationReturn = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.VTableFunctionLookup.ReturnType));
pFunction.CurrentBlock.EmitCall(locationReturn, LLFunctionLocation.Create(HLDomain.VTableFunctionLookup), parameters);
locationFunction = pFunction.CurrentBlock.EmitConversion(locationReturn, typeFunction.PointerDepthPlusOne);
}
parameters.Clear();
if (locationAlternativeThis == null)
{
mParameterSources.ForEach(l => parameters.Add(l.Load(pFunction)));
}
else
{
parameters.Add(locationAlternativeThis);
for (int index = 1; index < mParameterSources.Count; ++index)
{
parameters.Add(mParameterSources[index].Load(pFunction));
}
}
for (int index = 0; index < parameters.Count; ++index)
{
parameters[index] = pFunction.CurrentBlock.EmitConversion(parameters[index], mCalledMethod.LLFunction.Parameters[index].Type);
}
locationReturn = null;
if (mReturnDestination != null)
{
locationReturn = LLTemporaryLocation.Create(pFunction.CreateTemporary(mReturnDestination.Type.LLType));
}
pFunction.CurrentBlock.EmitCall(locationReturn, locationFunction, parameters);
if (mReturnDestination != null)
{
mReturnDestination.Store(pFunction, locationReturn);
}
}
internal static LLLocation LoadInstanceFieldPointer(LLFunction pFunction, HLLocation pInstance, HLField pField)
{
LLLocation locationInstance = pInstance.Load(pFunction);
locationInstance = pFunction.CurrentBlock.EmitConversion(locationInstance, LLModule.GetOrCreatePointerType(LLModule.GetOrCreateUnsignedType(8), 1));
LLLocation locationFieldPointer = locationInstance;
if (pField.Offset > 0)
{
locationFieldPointer = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationFieldPointer.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationFieldPointer, locationInstance, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateUnsignedType(32), pField.Offset.ToString())));
}
return(pFunction.CurrentBlock.EmitConversion(locationFieldPointer, pField.Type.LLType.PointerDepthPlusOne));
}
internal override void Transform(LLFunction pFunction)
{
LLLocation locationSource = mSource.Load(pFunction);
if (mSource.Type.Definition.IsValueType && mDestination.Type == HLDomain.SystemObject)
{
// Boxing
List <LLLocation> parameters = new List <LLLocation>();
LLLocation locationObjectReference = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.SystemObject.LLType.PointerDepthPlusOne));
pFunction.CurrentBlock.EmitAllocate(locationObjectReference);
pFunction.CurrentBlock.EmitStore(locationObjectReference, LLLiteralLocation.Create(LLLiteral.Create(locationObjectReference.Type.PointerDepthMinusOne, "zeroinitializer")));
parameters.Add(locationObjectReference);
parameters.Add(LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCRoot.Parameters[1].Type, "null")));
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCRoot), parameters);
LLLocation locationTotalSize = LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCAllocate.Parameters[1].Type, (HLDomain.SystemObject.CalculatedSize + mSource.Type.CalculatedSize).ToString()));
LLLocation locationHandle = LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCAllocate.Parameters[2].Type, mSource.Type.RuntimeTypeHandle.ToString()));
parameters.Clear();
parameters.Add(locationObjectReference);
parameters.Add(locationTotalSize);
parameters.Add(locationHandle);
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCAllocate), parameters);
LLLocation locationObject = LLTemporaryLocation.Create(pFunction.CreateTemporary(HLDomain.SystemObject.LLType));
pFunction.CurrentBlock.EmitLoad(locationObject, locationObjectReference);
LLLocation locationObjectValue = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationObject.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationObjectValue, locationObject, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), HLDomain.SystemObject.CalculatedSize.ToString())));
locationObjectValue = pFunction.CurrentBlock.EmitConversion(locationObjectValue, mSource.Type.LLType.PointerDepthPlusOne);
pFunction.CurrentBlock.EmitStore(locationObjectValue, locationSource);
locationSource = locationObject;
}
else if (mSource.Type == HLDomain.SystemObject && mDestination.Type.Definition.IsValueType)
{
// Unboxing
// TODO: Branch on destination type handle not matching object handle, and throw exception
LLLocation locationObjectValue = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationSource.Type));
pFunction.CurrentBlock.EmitGetElementPointer(locationObjectValue, locationSource, LLLiteralLocation.Create(LLLiteral.Create(LLModule.GetOrCreateSignedType(32), HLDomain.SystemObject.CalculatedSize.ToString())));
locationObjectValue = pFunction.CurrentBlock.EmitConversion(locationObjectValue, mDestination.Type.LLType.PointerDepthPlusOne);
LLLocation locationValue = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationObjectValue.Type.PointerDepthMinusOne));
pFunction.CurrentBlock.EmitLoad(locationValue, locationObjectValue);
locationSource = locationValue;
}
mDestination.Store(pFunction, locationSource);
}
