Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        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));
        }
Ejemplo n.º 7
0
 internal override LLLocation Load(LLFunction pFunction)
 {
     return(LLLiteralLocation.Create(LLLiteral.Create(Type.LLType, Literal.ToString())));
 }
Ejemplo n.º 8
0
        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));
        }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 10
0
        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);
        }
Ejemplo n.º 11
0
        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));
        }
Ejemplo n.º 12
0
        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);
            }
        }
Ejemplo n.º 13
0
 internal override LLLocation Load(LLFunction pFunction)
 {
     return(LLLiteralLocation.Create(LLLiteral.Create(Type.LLType, SizeOfType.CalculatedSize.ToString())));
 }
Ejemplo n.º 14
0
 internal override LLLocation Load(LLFunction pFunction)
 {
     return(LLLiteralLocation.Create(LLLiteral.Create(Type.LLType, "zeroinitializer")));
 }