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;
}
