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); }
public override string ToString() { StringBuilder sb = new StringBuilder(); if (mReturnDestination != null) { sb.AppendFormat("{0} = ", mReturnDestination); } sb.AppendFormat("call {0} {1}(", mReturnDestination == null ? LLModule.VoidType : mReturnDestination.Type, mFunctionSource); for (int index = 0; index < mParameterSources.Count; ++index) { LLLocation parameterSource = mParameterSources[index]; if (index > 0) { sb.Append(", "); } sb.AppendFormat("{0} {1}", parameterSource.Type, parameterSource); } sb.Append(")"); if (mFunctionSource is LLFunctionLocation) { LLFunction function = ((LLFunctionLocation)mFunctionSource).Function; if (function.Description != null) { sb.AppendFormat(" ; {0}", function.Description); } } return(sb.ToString()); }
public static LLBitcastInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pSource) { LLBitcastInstruction instruction = new LLBitcastInstruction(pFunction); instruction.mDestination = pDestination; instruction.mSource = pSource; return instruction; }
public static LLAllocateInstruction Create(LLFunction pFunction, LLLocation pDestination) { LLAllocateInstruction instruction = new LLAllocateInstruction(pFunction); instruction.mDestination = pDestination; return(instruction); }
public override LLLocation Load(LLInstructionBlock pBlock) { LLLocation destination = LLTemporaryLocation.Create(pBlock.Function.CreateTemporary(Type.PointerDepthMinusOne)); pBlock.EmitLoad(destination, this); return(destination); }
internal override LLLocation Load(LLFunction pFunction) { LLLocation locationAddress = mAddress.Load(pFunction); locationAddress = pFunction.CurrentBlock.EmitConversion(locationAddress, Type.LLType); return(locationAddress.Load(pFunction.CurrentBlock)); }
public static LLReturnInstruction Create(LLFunction pFunction, LLLocation pSource) { LLReturnInstruction instruction = new LLReturnInstruction(pFunction); instruction.mSource = pSource; return(instruction); }
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 static LLIntegerToPointerInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pSource) { LLIntegerToPointerInstruction instruction = new LLIntegerToPointerInstruction(pFunction); instruction.mDestination = pDestination; instruction.mSource = pSource; return instruction; }
internal override void Transform(LLFunction pFunction) { LLLocation locationCondition = mConditionSource.Load(pFunction); locationCondition = pFunction.CurrentBlock.EmitConversion(locationCondition, LLModule.BooleanType); pFunction.CurrentBlock.EmitBranch(locationCondition, pFunction.Labels.GetByIdentifier(mTrueLabel.Identifier), pFunction.Labels.GetByIdentifier(mFalseLabel.Identifier)); }
internal override void Store(LLFunction pFunction, LLLocation pSource) { LLLocation locationLocal = LLLocalLocation.Create(pFunction.Locals[Temporary.Name]); LLLocation locationSource = pFunction.CurrentBlock.EmitConversion(pSource, locationLocal.Type.PointerDepthMinusOne); pFunction.CurrentBlock.EmitStore(locationLocal, locationSource); }
public static LLCallInstruction Create(LLFunction pFunction, LLLocation pReturnDestination, LLLocation pFunctionSource, List<LLLocation> pParameterSources) { LLCallInstruction instruction = new LLCallInstruction(pFunction); instruction.mReturnDestination = pReturnDestination; instruction.mFunctionSource = pFunctionSource; instruction.mParameterSources = new List<LLLocation>(pParameterSources); return instruction; }
public static LLSignedRightShiftInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource) { LLSignedRightShiftInstruction instruction = new LLSignedRightShiftInstruction(pFunction); instruction.mDestination = pDestination; instruction.mLeftSource = pLeftSource; instruction.mRightSource = pRightSource; return instruction; }
internal override LLLocation Load(LLFunction pFunction) { LLLocation locationFieldPointer = HLFieldAddressLocation.LoadInstanceFieldPointer(pFunction, Instance, Field); LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationFieldPointer.Type.PointerDepthMinusOne)); pFunction.CurrentBlock.EmitLoad(locationTemporary, locationFieldPointer); return(locationTemporary); }
internal override LLLocation Load(LLFunction pFunction) { LLLocation locationLocal = LLLocalLocation.Create(pFunction.Locals[Temporary.Name]); LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationLocal.Type.PointerDepthMinusOne)); pFunction.CurrentBlock.EmitLoad(locationTemporary, locationLocal); return(locationTemporary); }
public static LLTruncateInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pSource) { LLTruncateInstruction instruction = new LLTruncateInstruction(pFunction); instruction.mDestination = pDestination; instruction.mSource = pSource; return(instruction); }
public static LLGetElementPointerInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pPointerSource, params LLLocation[] pIndexSources) { LLGetElementPointerInstruction instruction = new LLGetElementPointerInstruction(pFunction); instruction.mDestination = pDestination; instruction.mPointerSource = pPointerSource; instruction.mIndexSources = new List<LLLocation>(pIndexSources); return instruction; }
public static LLBranchInstruction Create(LLFunction pFunction, LLLocation pConditionSource, LLLabel pTrueTargetLabel, LLLabel pFalseTargetLabel) { LLBranchInstruction instruction = new LLBranchInstruction(pFunction); instruction.mConditionSource = pConditionSource; instruction.mTrueTargetLabel = pTrueTargetLabel; instruction.mFalseTargetLabel = pFalseTargetLabel; return instruction; }
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 LLLocation Load(LLFunction pFunction) { LLLocation locationElementPointer = HLArrayElementAddressLocation.LoadArrayElementPointer(pFunction, Instance, Index, ElementType); LLLocation locationTemporary = LLTemporaryLocation.Create(pFunction.CreateTemporary(locationElementPointer.Type.PointerDepthMinusOne)); pFunction.CurrentBlock.EmitLoad(locationTemporary, locationElementPointer); return(locationTemporary); }
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); }
public static LLGetElementPointerInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pPointerSource, params LLLocation[] pIndexSources) { LLGetElementPointerInstruction instruction = new LLGetElementPointerInstruction(pFunction); instruction.mDestination = pDestination; instruction.mPointerSource = pPointerSource; instruction.mIndexSources = new List <LLLocation>(pIndexSources); return(instruction); }
public static LLCallInstruction Create(LLFunction pFunction, LLLocation pReturnDestination, LLLocation pFunctionSource, List <LLLocation> pParameterSources) { LLCallInstruction instruction = new LLCallInstruction(pFunction); instruction.mReturnDestination = pReturnDestination; instruction.mFunctionSource = pFunctionSource; instruction.mParameterSources = new List <LLLocation>(pParameterSources); return(instruction); }
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); }
public static LLBranchInstruction Create(LLFunction pFunction, LLLocation pConditionSource, LLLabel pTrueTargetLabel, LLLabel pFalseTargetLabel) { LLBranchInstruction instruction = new LLBranchInstruction(pFunction); instruction.mConditionSource = pConditionSource; instruction.mTrueTargetLabel = pTrueTargetLabel; instruction.mFalseTargetLabel = pFalseTargetLabel; return(instruction); }
public static LLOrInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource) { LLOrInstruction instruction = new LLOrInstruction(pFunction); instruction.mDestination = pDestination; instruction.mLeftSource = pLeftSource; instruction.mRightSource = pRightSource; return(instruction); }
public static LLCompareIntegersInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource, LLCompareIntegersCondition pCondition) { LLCompareIntegersInstruction instruction = new LLCompareIntegersInstruction(pFunction); instruction.mDestination = pDestination; instruction.mLeftSource = pLeftSource; instruction.mRightSource = pRightSource; instruction.mCondition = pCondition; return instruction; }
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); }
public static LLSwitchInstruction Create(LLFunction pFunction, LLLocation pConditionSource, LLLabel pDefaultTargetLabel, List <LLSwitchCase> pCases) { LLSwitchInstruction instruction = new LLSwitchInstruction(pFunction); instruction.mConditionSource = pConditionSource; instruction.mDefaultTargetLabel = pDefaultTargetLabel; instruction.mCases = new List <LLSwitchCase>(pCases); return(instruction); }
public static LLCompareIntegersInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pLeftSource, LLLocation pRightSource, LLCompareIntegersCondition pCondition) { LLCompareIntegersInstruction instruction = new LLCompareIntegersInstruction(pFunction); instruction.mDestination = pDestination; instruction.mLeftSource = pLeftSource; instruction.mRightSource = pRightSource; instruction.mCondition = pCondition; return(instruction); }
internal override LLLocation Load(LLFunction pFunction) { LLLocation location = LLLocalLocation.Create(pFunction.Locals[Local.Name]); if (mLocal.IsReference) { location = location.Load(pFunction.CurrentBlock); } return(location); }
public static LLCompareExchangeInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pPointerSource, LLLocation pComparedSource, LLLocation pNewSource, LLCompareExchangeOrdering pOrdering) { LLCompareExchangeInstruction instruction = new LLCompareExchangeInstruction(pFunction); instruction.mDestination = pDestination; instruction.mPointerSource = pPointerSource; instruction.mComparedSource = pComparedSource; instruction.mNewSource = pNewSource; instruction.mOrdering = pOrdering; return instruction; }
internal override void Transform(LLFunction pFunction) { LLLocation locationSource = null; if (mSource != null) { locationSource = mSource.Load(pFunction); } pFunction.CurrentBlock.EmitReturn(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); }
internal override void Transform(LLFunction pFunction) { LLLocation locationCondition = mConditionSource.Load(pFunction); List <LLSwitchCase> cases = new List <LLSwitchCase>(); foreach (Tuple <HLLiteralLocation, HLLabel> tupleCase in mCases) { cases.Add(LLSwitchCase.Create(LLLiteral.Create(tupleCase.Item1.Type.LLType, tupleCase.Item1.LiteralAsString), pFunction.Labels.GetByIdentifier(tupleCase.Item2.Identifier))); } pFunction.CurrentBlock.EmitSwitch(locationCondition, pFunction.Labels.GetByIdentifier(mDefaultLabel.Identifier), cases); }
public static LLCompareExchangeInstruction Create(LLFunction pFunction, LLLocation pDestination, LLLocation pPointerSource, LLLocation pComparedSource, LLLocation pNewSource, LLCompareExchangeOrdering pOrdering) { LLCompareExchangeInstruction instruction = new LLCompareExchangeInstruction(pFunction); instruction.mDestination = pDestination; instruction.mPointerSource = pPointerSource; instruction.mComparedSource = pComparedSource; instruction.mNewSource = pNewSource; instruction.mOrdering = pOrdering; return(instruction); }
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 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)); }
public static LLSwitchInstruction Create(LLFunction pFunction, LLLocation pConditionSource, LLLabel pDefaultTargetLabel, List<LLSwitchCase> pCases) { LLSwitchInstruction instruction = new LLSwitchInstruction(pFunction); instruction.mConditionSource = pConditionSource; instruction.mDefaultTargetLabel = pDefaultTargetLabel; instruction.mCases = new List<LLSwitchCase>(pCases); return instruction; }
public override void Store(LLInstructionBlock pBlock, LLLocation pSource) { LLLocation source = pBlock.EmitConversion(pSource, Type.PointerDepthMinusOne); pBlock.EmitStore(this, source); }
public static LLReturnInstruction Create(LLFunction pFunction, LLLocation pSource) { LLReturnInstruction instruction = new LLReturnInstruction(pFunction); instruction.mSource = pSource; return instruction; }
public static LLAllocateInstruction Create(LLFunction pFunction, LLLocation pDestination) { LLAllocateInstruction instruction = new LLAllocateInstruction(pFunction); instruction.mDestination = pDestination; return instruction; }