internal override void Store(LLFunction pFunction, LLLocation pSource)
 {
     LLLocation locationAddress = mAddress.Load(pFunction);
     locationAddress = pFunction.CurrentBlock.EmitConversion(locationAddress, Type.LLType);
     LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationAddress.Type.PointerDepthMinusOne);
     pFunction.CurrentBlock.EmitStore(locationAddress, locationSource);
 }
 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);
 }
 internal override void Store(LLFunction pFunction, LLLocation pSource)
 {
     if (!Parameter.RequiresAddressing) throw new NotSupportedException();
     LLLocation locationLocal = LLLocalLocation.Create(Parameter.AddressableLocal);
     LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationLocal.Type.PointerDepthMinusOne);
     pFunction.CurrentBlock.EmitStore(locationLocal, locationSource);
 }
Example #4
0
 public void EmitSubtract(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLSubtractInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
Example #5
0
 public void EmitPointerToInteger(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLPointerToIntegerInstruction.Create(mFunction, pDestination, pSource));
 }
Example #6
0
 public void EmitIntegerToFloat(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLIntegerToFloatInstruction.Create(mFunction, pDestination, pSource));
 }
Example #7
0
 public void EmitExtend(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLExtendInstruction.Create(mFunction, pDestination, pSource));
 }
 public void EmitExtend(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLExtendInstruction.Create(mFunction, pDestination, pSource));
 }
 public void EmitSubtract(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLSubtractInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
Example #10
0
 public void EmitAllocate(LLLocation pDestination)
 {
     Emit(LLAllocateInstruction.Create(mFunction, pDestination));
 }
 public void EmitPointerToInteger(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLPointerToIntegerInstruction.Create(mFunction, pDestination, pSource));
 }
 public void EmitReturn(LLLocation pSource)
 {
     Emit(LLReturnInstruction.Create(mFunction, pSource));
 }
 public void EmitMultiply(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLMultiplyInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
 public void EmitIntegerToFloat(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLIntegerToFloatInstruction.Create(mFunction, pDestination, pSource));
 }
 public void EmitGetElementPointer(LLLocation pDestination, LLLocation pPointerSource, params LLLocation[] pIndexSources)
 {
     Emit(LLGetElementPointerInstruction.Create(mFunction, pDestination, pPointerSource, pIndexSources));
 }
Example #16
0
 public void EmitTruncate(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLTruncateInstruction.Create(mFunction, pDestination, pSource));
 }
 public void EmitSwitch(LLLocation pConditionSource, LLLabel pDefaultTargetLabel, List<LLSwitchCase> pCases)
 {
     Emit(LLSwitchInstruction.Create(mFunction, pConditionSource, pDefaultTargetLabel, pCases));
 }
Example #18
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);
        }
 public void EmitTruncate(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLTruncateInstruction.Create(mFunction, pDestination, pSource));
 }
Example #20
0
 public void EmitBranch(LLLocation pConditionSource, LLLabel pTrueTargetLabel, LLLabel pFalseTargetLabel)
 {
     Emit(LLBranchInstruction.Create(mFunction, pConditionSource, pTrueTargetLabel, pFalseTargetLabel));
 }
 public void EmitUnsignedRightShift(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLUnsignedRightShiftInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
Example #22
0
 internal override void Store(LLFunction pFunction, LLLocation pSource)
 {
     LLLocation locationLocal = LLLocalLocation.Create(pFunction.Locals[Local.Name]);
     LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationLocal.Type.PointerDepthMinusOne);
     pFunction.CurrentBlock.EmitStore(locationLocal, locationSource);
 }
 public void EmitAllocate(LLLocation pDestination)
 {
     Emit(LLAllocateInstruction.Create(mFunction, pDestination));
 }
Example #24
0
 public void EmitCompareIntegers(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource, LLCompareIntegersCondition pCondition)
 {
     Emit(LLCompareIntegersInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource, pCondition));
 }
 public void EmitAnd(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLAndInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
Example #26
0
 public void EmitGetElementPointer(LLLocation pDestination, LLLocation pPointerSource, params LLLocation[] pIndexSources)
 {
     Emit(LLGetElementPointerInstruction.Create(mFunction, pDestination, pPointerSource, pIndexSources));
 }
 public void EmitBitcast(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLBitcastInstruction.Create(mFunction, pDestination, pSource));
 }
Example #28
0
 public void EmitMultiply(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLMultiplyInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
 public void EmitBranch(LLLocation pConditionSource, LLLabel pTrueTargetLabel, LLLabel pFalseTargetLabel)
 {
     Emit(LLBranchInstruction.Create(mFunction, pConditionSource, pTrueTargetLabel, pFalseTargetLabel));
 }
Example #30
0
 public void EmitReturn(LLLocation pSource)
 {
     Emit(LLReturnInstruction.Create(mFunction, pSource));
 }
 public void EmitCall(LLLocation pReturnDestination, LLLocation pFunctionSource, List<LLLocation> pParameterSources)
 {
     Emit(LLCallInstruction.Create(mFunction, pReturnDestination, pFunctionSource, pParameterSources));
 }
Example #32
0
 public void EmitSwitch(LLLocation pConditionSource, LLLabel pDefaultTargetLabel, List <LLSwitchCase> pCases)
 {
     Emit(LLSwitchInstruction.Create(mFunction, pConditionSource, pDefaultTargetLabel, pCases));
 }
 public void EmitCompareExchange(LLLocation pDestination, LLLocation pPointerSource, LLLocation pComparedSource, LLLocation pNewSource, LLCompareExchangeOrdering pOrdering)
 {
     Emit(LLCompareExchangeInstruction.Create(mFunction, pDestination, pPointerSource, pComparedSource, pNewSource, pOrdering));
 }
Example #34
0
 public void EmitUnsignedRightShift(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLUnsignedRightShiftInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
 public void EmitCompareFloats(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource, LLCompareFloatsCondition pCondition)
 {
     Emit(LLCompareFloatsInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource, pCondition));
 }
Example #36
0
 public void EmitAnd(LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource)
 {
     Emit(LLAndInstruction.Create(mFunction, pDestination, pLeftSource, pRightSource));
 }
Example #37
0
 public virtual void Store(LLInstructionBlock pBlock, LLLocation pSource)
 {
     throw new NotSupportedException();
 }
Example #38
0
 public void EmitBitcast(LLLocation pDestination, LLLocation pSource)
 {
     Emit(LLBitcastInstruction.Create(mFunction, pDestination, pSource));
 }
Example #39
0
 internal override void Store(LLFunction pFunction, LLLocation pSource)
 {
     LLLocation locationFieldPointer = HLFieldAddressLocation.LoadInstanceFieldPointer(pFunction, Instance, Field);
     LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationFieldPointer.Type.PointerDepthMinusOne);
     pFunction.CurrentBlock.EmitStore(locationFieldPointer, locationSource);
 }
Example #40
0
 public void EmitCall(LLLocation pReturnDestination, LLLocation pFunctionSource, List <LLLocation> pParameterSources)
 {
     Emit(LLCallInstruction.Create(mFunction, pReturnDestination, pFunctionSource, pParameterSources));
 }
Example #41
0
 public virtual void Store(LLInstructionBlock pBlock, LLLocation pSource)
 {
     throw new NotSupportedException();
 }
Example #42
0
 internal virtual void Store(LLFunction pFunction, LLLocation pSource)
 {
     throw new NotSupportedException();
 }
Example #43
0
 public void EmitCompareExchange(LLLocation pDestination, LLLocation pPointerSource, LLLocation pComparedSource, LLLocation pNewSource, LLCompareExchangeOrdering pOrdering)
 {
     Emit(LLCompareExchangeInstruction.Create(mFunction, pDestination, pPointerSource, pComparedSource, pNewSource, pOrdering));
 }
 internal override void Store(LLFunction pFunction, LLLocation pSource)
 {
     LLLocation locationElementPointer = HLArrayElementAddressLocation.LoadArrayElementPointer(pFunction, Instance, Index, ElementType);
     LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationElementPointer.Type.PointerDepthMinusOne);
     pFunction.CurrentBlock.EmitStore(locationElementPointer, locationSource);
 }
 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;
 }