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);
}
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);
}
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 locationObjectReference = mDestinationSource.Load(pFunction);
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, mNewObjectType.CalculatedSize.ToString()));
LLLocation locationHandle = LLLiteralLocation.Create(LLLiteral.Create(HLDomain.GCAllocate.Parameters[2].Type, mNewObjectType.RuntimeTypeHandle.ToString()));
parameters.Clear();
parameters.Add(locationObjectReference);
parameters.Add(locationTotalSize);
parameters.Add(locationHandle);
pFunction.CurrentBlock.EmitCall(null, LLFunctionLocation.Create(HLDomain.GCAllocate), parameters);
}
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));
}
internal override LLLocation Load(LLFunction pFunction)
{
return(LLLiteralLocation.Create(LLLiteral.Create(Type.LLType, Literal.ToString())));
}
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)
{
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);
}
public LLLocation EmitConversion(LLLocation pSource, LLType pType)
{
if (pSource.Type == pType)
{
return(pSource);
}
LLLocation destination = pSource;
switch (pSource.Type.Primitive)
{
case LLPrimitive.Signed:
{
switch (pType.Primitive)
{
case LLPrimitive.Signed: // Signed to Signed
{
if (pSource.Type.SizeInBits != pType.SizeInBits)
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
}
if (pSource.Type.SizeInBits > pType.SizeInBits)
{
EmitTruncate(destination, pSource);
}
else if (pSource.Type.SizeInBits < pType.SizeInBits)
{
EmitExtend(destination, pSource);
}
break;
}
case LLPrimitive.Unsigned: // Signed to Unsigned
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
if (pSource.Type.SizeInBits > pType.SizeInBits)
{
EmitTruncate(destination, pSource);
}
else if (pSource.Type.SizeInBits < pType.SizeInBits)
{
EmitExtend(destination, pSource);
}
else
{
EmitAdd(destination, pSource, LLLiteralLocation.Create(LLLiteral.Create(pType, "0")));
}
break;
}
case LLPrimitive.Float: // Signed to Float
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitIntegerToFloat(destination, pSource);
break;
}
case LLPrimitive.Pointer: // Signed to Pointer
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitIntegerToPointer(destination, pSource);
break;
}
default: throw new NotSupportedException();
}
break;
}
case LLPrimitive.Unsigned:
{
switch (pType.Primitive)
{
case LLPrimitive.Signed: // Unsigned to Signed
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
if (pSource.Type.SizeInBits > pType.SizeInBits)
{
EmitTruncate(destination, pSource);
}
else if (pSource.Type.SizeInBits < pType.SizeInBits)
{
EmitExtend(destination, pSource);
}
else
{
EmitAdd(destination, pSource, LLLiteralLocation.Create(LLLiteral.Create(pType, "0")));
}
break;
}
case LLPrimitive.Unsigned: // Unsigned to Unsigned
{
if (pSource.Type.SizeInBits != pType.SizeInBits)
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
}
if (pSource.Type.SizeInBits > pType.SizeInBits)
{
EmitTruncate(destination, pSource);
}
else if (pSource.Type.SizeInBits < pType.SizeInBits)
{
EmitExtend(destination, pSource);
}
break;
}
case LLPrimitive.Float: // Unsigned to Float
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitIntegerToFloat(destination, pSource);
break;
}
case LLPrimitive.Pointer: // Unsigned to Pointer
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitIntegerToPointer(destination, pSource);
break;
}
default: throw new NotSupportedException();
}
break;
}
case LLPrimitive.Float:
{
switch (pType.Primitive)
{
case LLPrimitive.Signed: // Float to Signed
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitFloatToInteger(destination, pSource);
break;
}
case LLPrimitive.Unsigned: // Float to Unsigned
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitFloatToInteger(destination, pSource);
break;
}
case LLPrimitive.Float: // Float to Float
{
if (pSource.Type.SizeInBits != pType.SizeInBits)
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
}
if (pSource.Type.SizeInBits > pType.SizeInBits)
{
EmitTruncate(destination, pSource);
}
else if (pSource.Type.SizeInBits < pType.SizeInBits)
{
EmitExtend(destination, pSource);
}
break;
}
case LLPrimitive.Pointer: // Float to Pointer
{
LLLocation temporaryInteger = LLTemporaryLocation.Create(Function.CreateTemporary(LLModule.GetOrCreateUnsignedType(pType.SizeInBits)));
EmitFloatToInteger(temporaryInteger, pSource);
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitIntegerToPointer(destination, temporaryInteger);
break;
}
default: throw new NotSupportedException();
}
break;
}
case LLPrimitive.Pointer:
{
switch (pType.Primitive)
{
case LLPrimitive.Signed: // Pointer to Signed
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitPointerToInteger(destination, pSource);
break;
}
case LLPrimitive.Unsigned: // Pointer to Unsigned
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitPointerToInteger(destination, pSource);
break;
}
case LLPrimitive.Float: // Pointer to Float
{
LLLocation temporaryInteger = LLTemporaryLocation.Create(Function.CreateTemporary(LLModule.GetOrCreateUnsignedType(pSource.Type.SizeInBits)));
EmitPointerToInteger(temporaryInteger, pSource);
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitIntegerToFloat(destination, temporaryInteger);
break;
}
case LLPrimitive.Pointer: // Pointer to Pointer
{
destination = LLTemporaryLocation.Create(Function.CreateTemporary(pType));
EmitBitcast(destination, pSource);
break;
}
default: throw new NotSupportedException();
}
break;
}
default: throw new NotSupportedException();
}
return(destination);
}
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 override LLLocation Load(LLFunction pFunction)
{
return(LLLiteralLocation.Create(LLLiteral.Create(Type.LLType, SizeOfType.CalculatedSize.ToString())));
}
internal override LLLocation Load(LLFunction pFunction)
{
return(LLLiteralLocation.Create(LLLiteral.Create(Type.LLType, "zeroinitializer")));
}
