public void SaveBranchStackValue(OpCodePart opCode, BaseWriter baseWriter)
{
switch (opCode.ToCode())
{
case Code.Br:
case Code.Br_S:
case Code.Beq:
case Code.Beq_S:
case Code.Blt:
case Code.Blt_S:
case Code.Bgt:
case Code.Bgt_S:
case Code.Ble:
case Code.Ble_S:
case Code.Bge:
case Code.Bge_S:
case Code.Blt_Un:
case Code.Blt_Un_S:
case Code.Bgt_Un:
case Code.Bgt_Un_S:
case Code.Ble_Un:
case Code.Ble_Un_S:
case Code.Bge_Un:
case Code.Bge_Un_S:
case Code.Bne_Un:
case Code.Bne_Un_S:
case Code.Brtrue:
case Code.Brtrue_S:
case Code.Brfalse:
case Code.Brfalse_S:
if (opCode.IsJumpForward() && this.main.Any())
{
opCode.BranchStackValue = this.main.Peek();
}
break;
}
}
/// <summary>
/// </summary>
/// <param name="llvmWriter">
/// </param>
/// <param name="opCodeMethodInfo">
/// </param>
/// <param name="methodInfo">
/// </param>
/// <param name="thisType">
/// </param>
/// <param name="opCodeFirstOperand">
/// </param>
/// <param name="resultOfirstOperand">
/// </param>
/// <param name="requiredType">
/// </param>
/// <returns>
/// </returns>
public static FullyDefinedReference GenerateVirtualCall(
this LlvmWriter llvmWriter,
OpCodePart opCodeMethodInfo,
IMethod methodInfo,
IType thisType,
OpCodePart opCodeFirstOperand,
BaseWriter.ReturnResult resultOfirstOperand,
ref IType requiredType)
{
var writer = llvmWriter.Output;
FullyDefinedReference virtualMethodAddressResultNumber = null;
if (thisType.IsInterface && resultOfirstOperand.Type.TypeNotEquals(thisType))
{
// we need to extract interface from an object
requiredType = thisType;
}
// get pointer to Virtual Table and call method
// 1) get pointer to virtual table
writer.WriteLine("; Get Virtual Table");
IType requiredInterface;
var effectiveType = requiredType ?? thisType;
var methodIndex = effectiveType.GetVirtualMethodIndex(methodInfo, llvmWriter, out requiredInterface);
if (requiredInterface != null)
{
llvmWriter.WriteInterfaceAccess(
writer,
opCodeMethodInfo.OpCodeOperands[0],
effectiveType,
requiredInterface);
opCodeMethodInfo.Result = opCodeMethodInfo.OpCodeOperands[0].Result;
requiredType = requiredInterface;
}
llvmWriter.UnaryOper(writer, opCodeMethodInfo, "bitcast", requiredType ?? thisType);
writer.Write(" to ");
llvmWriter.WriteMethodPointerType(writer, methodInfo, thisType);
writer.WriteLine("**");
var pointerToInterfaceVirtualTablePointersResultNumber = opCodeMethodInfo.Result;
// load pointer
llvmWriter.WriteSetResultNumber(
opCodeMethodInfo,
llvmWriter.System.System_Byte.ToPointerType().ToPointerType());
writer.Write("load ");
llvmWriter.WriteMethodPointerType(writer, methodInfo, thisType);
writer.Write("** ");
llvmWriter.WriteResult(pointerToInterfaceVirtualTablePointersResultNumber);
writer.Write(", align {0}", LlvmWriter.PointerSize);
writer.WriteLine(string.Empty);
var virtualTableOfMethodPointersResultNumber = opCodeMethodInfo.Result;
// get address of a function
writer.WriteLine("; Get Virtual Index of Method: {0}", methodInfo.FullName);
llvmWriter.WriteSetResultNumber(opCodeMethodInfo, llvmWriter.System.System_Byte.ToPointerType());
writer.Write("getelementptr inbounds ");
llvmWriter.WriteMethodPointerType(writer, methodInfo, thisType);
writer.Write("* ");
llvmWriter.WriteResult(virtualTableOfMethodPointersResultNumber);
writer.WriteLine(", i64 {0}", methodIndex);
var pointerToFunctionPointerResultNumber = opCodeMethodInfo.Result;
// load method address
llvmWriter.WriteSetResultNumber(opCodeMethodInfo, llvmWriter.System.System_Byte.ToPointerType());
writer.Write("load ");
llvmWriter.WriteMethodPointerType(writer, methodInfo, thisType);
writer.Write("* ");
llvmWriter.WriteResult(pointerToFunctionPointerResultNumber);
writer.WriteLine(string.Empty);
// remember virtual method address result
virtualMethodAddressResultNumber = opCodeMethodInfo.Result;
if (thisType.IsInterface)
{
opCodeFirstOperand.Result = virtualTableOfMethodPointersResultNumber;
llvmWriter.WriteGetThisPointerFromInterfacePointer(
writer,
opCodeMethodInfo,
methodInfo,
thisType,
pointerToInterfaceVirtualTablePointersResultNumber);
var thisPointerResultNumber = opCodeMethodInfo.Result;
// set ot for Call op code
opCodeMethodInfo.OpCodeOperands[0].Result = thisPointerResultNumber;
}
return virtualMethodAddressResultNumber;
}
public void WriteFile(CR2WFile file)
{
_file = file;
BaseStream.WriteStruct(CR2WFile.MAGIC);
var fileHeader = new CR2WFileHeader {
version = _file.MetaData.Version, buildVersion = _file.MetaData.BuildVersion, numChunks = 6
};
var tableHeaders = new CR2WTable[10];
var headerPos = BaseStream.Position;
// Write empty header, fill it later
BaseStream.WriteStruct(fileHeader);
BaseStream.WriteStructs(tableHeaders);
Debug.Assert(BaseStream.Position == 160);
var dataCollection = GenerateData();
foreach (var embedded in _file.EmbeddedFiles)
{
var tuple = ("", (CName)embedded.FileName, (ushort)8);
if (!dataCollection.ImportList.Contains(tuple))
{
dataCollection.ImportList.Add(tuple);
}
}
fileHeader.objectsEnd = (uint)BaseStream.Position;
var combinedList = new List <CName>(dataCollection.StringList);
combinedList.AddRange(dataCollection.ImportList.Select(x => x.Item2).ToList());
var(stringBuffer, stringOffsets) = GenerateStringBuffer(combinedList);
tableHeaders[0] = new CR2WTable()
{
offset = (uint)BaseStream.Position,
itemCount = (uint)stringBuffer.Length,
crc32 = Crc32Algorithm.Compute(stringBuffer)
};
BaseWriter.Write(stringBuffer);
if (_file.Properties.Count < 1)
{
_file.Properties.Add(new CR2WProperty());
}
var afterHeaderPosition = CalculateHeaderLength(dataCollection);
fileHeader.objectsEnd += (uint)afterHeaderPosition;
#region Names
tableHeaders[1].offset = (uint)BaseStream.Position;
tableHeaders[1].itemCount = (uint)dataCollection.StringList.Count;
var crc = new Crc32Algorithm(false);
foreach (var str in dataCollection.StringList)
{
if (_file.MetaData.HashVersion == EHashVersion.Pre120)
{
#pragma warning disable CS0618 // Typ oder Element ist veraltet
BaseStream.WriteStruct(new CR2WNameInfo {
hash = str.GetOldRedHash(), offset = stringOffsets[str]
}, crc);
#pragma warning restore CS0618 // Typ oder Element ist veraltet
}
else
{
BaseStream.WriteStruct(new CR2WNameInfo {
hash = str.GetShortRedHash(), offset = stringOffsets[str]
}, crc);
}
}
tableHeaders[1].crc32 = crc.HashUInt32;
#endregion Names
#region Imports
if (dataCollection.ImportList.Count > 0)
{
tableHeaders[2].offset = (uint)BaseStream.Position;
tableHeaders[2].itemCount = (uint)dataCollection.ImportList.Count;
crc = new Crc32Algorithm(false);
foreach (var import in dataCollection.ImportList)
{
var entry = new CR2WImportInfo()
{
className = (ushort)dataCollection.StringList.IndexOf(import.Item1),
offset = stringOffsets[import.Item2],
flags = import.Item3
};
BaseStream.WriteStruct(entry, crc);
}
tableHeaders[2].crc32 = crc.HashUInt32;
}
#endregion Imports
#region Properties
tableHeaders[3].offset = (uint)BaseStream.Position;
tableHeaders[3].itemCount = (uint)_file.Properties.Count;
crc = new Crc32Algorithm(false);
foreach (var property in _file.Properties)
{
BaseStream.WriteStruct(new CR2WPropertyInfo(), crc);
}
tableHeaders[3].crc32 = crc.HashUInt32;
#endregion
#region Chunks
if (dataCollection.ChunkInfoList.Count > 0)
{
tableHeaders[4].offset = (uint)BaseStream.Position;
tableHeaders[4].itemCount = (uint)dataCollection.ChunkInfoList.Count;
crc = new Crc32Algorithm(false);
foreach (var chunkInfo in dataCollection.ChunkInfoList)
{
var entry = chunkInfo;
entry.dataOffset += (uint)afterHeaderPosition;
BaseStream.WriteStruct(entry, crc);
}
tableHeaders[4].crc32 = crc.HashUInt32;
}
#endregion Chunks
#region Buffers
var beforeBufferTablePos = BaseStream.Position;
if (dataCollection.BufferInfoList.Count > 0)
{
tableHeaders[5].offset = (uint)BaseStream.Position;
tableHeaders[5].itemCount = (uint)dataCollection.BufferInfoList.Count;
foreach (var buffer in dataCollection.BufferInfoList)
{
BaseStream.WriteStruct(buffer, crc);
}
}
#endregion Buffers
#region Embedded
var(embeddedInfoList, embeddedData) = GenerateEmbeddedData(dataCollection.ImportList);
if (embeddedInfoList.Count > 0)
{
tableHeaders[6].offset = (uint)BaseStream.Position;
tableHeaders[6].itemCount = (uint)embeddedInfoList.Count;
crc = new Crc32Algorithm(false);
foreach (var embedded in embeddedInfoList)
{
BaseStream.WriteStruct(embedded, crc);
}
tableHeaders[6].crc32 = crc.HashUInt32;
}
#endregion Embedded
Debug.Assert(BaseStream.Position == afterHeaderPosition);
BaseStream.Write(dataCollection.ChunkData);
fileHeader.objectsEnd = (uint)BaseStream.Position;
if (dataCollection.BufferInfoList.Count > 0)
{
BaseStream.Position = beforeBufferTablePos;
crc = new Crc32Algorithm(false);
for (var i = 0; i < dataCollection.BufferInfoList.Count; i++)
{
var entry = dataCollection.BufferInfoList[i];
entry.offset += fileHeader.objectsEnd;
dataCollection.BufferInfoList[i] = entry;
BaseStream.WriteStruct(entry, crc);
}
tableHeaders[5].crc32 = crc.HashUInt32;
}
BaseStream.Position = fileHeader.objectsEnd;
BaseStream.Write(dataCollection.BufferData);
fileHeader.buffersEnd = (uint)BaseStream.Position;
fileHeader.crc32 = CalculateHeaderCRC32(fileHeader, tableHeaders);
BaseStream.Position = headerPos;
BaseStream.WriteStruct(fileHeader);
BaseStream.WriteStructs(tableHeaders);
//for (int i = 0; i < dataCollection.ChunkInfoList.Count; i++)
//{
// var newInfo = dataCollection.ChunkInfoList[i];
// var oldInfo = _file.Info.ExportInfo[i];
//
// if ((newInfo.dataOffset + afterHeaderPosition) != oldInfo.dataOffset)
// {
//
// }
//
// if (newInfo.dataSize != oldInfo.dataSize)
// {
//
// }
//
// if (newInfo.parentID != oldInfo.parentID)
// {
// throw new TodoException("Invalid parent id");
// }
//
// if (newInfo.className != oldInfo.className)
// {
//
// }
//
// if (newInfo.objectFlags != oldInfo.objectFlags)
// {
//
// }
//
// if (newInfo.template != oldInfo.template)
// {
//
// }
//}
//
//for (int i = 0; i < dataCollection.BufferInfoList.Count; i++)
//{
// var newInfo = dataCollection.BufferInfoList[i];
// var oldInfo = _file.Info.BufferInfo[i];
//
// if (newInfo.index != oldInfo.index)
// {
//
// }
//
// if (newInfo.crc32 != oldInfo.crc32)
// {
//
// }
//
// if (newInfo.diskSize != oldInfo.diskSize)
// {
//
// }
//
// if (newInfo.flags != oldInfo.flags)
// {
//
// }
//
// if (newInfo.memSize != oldInfo.memSize)
// {
//
// }
//
// if (newInfo.offset != oldInfo.offset)
// {
//
// }
//}
}
/// <summary>
/// </summary>
/// <param name="baseWriter">
/// </param>
/// <param name="index">
/// </param>
/// <returns>
/// </returns>
public static string GetArgName(this BaseWriter baseWriter, int index)
{
var parameter = baseWriter.Parameters[index - (baseWriter.HasMethodThis ? 1 : 0)];
return(parameter.Name);
}
/// <summary>
/// </summary>
/// <param name="baseWriter">
/// </param>
/// <returns>
/// </returns>
public static int GetArgCount(this BaseWriter baseWriter)
{
return(baseWriter.Parameters.Count() - (baseWriter.HasMethodThis ? 1 : 0));
}
public void Dispose()
{
BaseWriter.Flush();
BaseWriter.Dispose();
}
public IEnumerable <T> Query <T>(ISessionState sessionState, SelectQuery <T> query) where T : class, new()
{
this.AssertConfigured();
var table = this.tables[typeof(T)];
var whereClauseNullCheckRewriter = new WhereClauseNullCheckRewriter();
var whereClauseOpEqualityRewriter = new WhereClauseOpEqualityRewriter();
var fetchCloner = new FetchCloner(this.Configuration);
var enumerable =
typeof(InMemoryTable <,>).MakeGenericType(typeof(T), this.Configuration.GetMap(typeof(T)).PrimaryKey.Type)
.GetMethod("Query")
.Invoke(table, new object[0]) as IEnumerable <T>;
var fetchParser = new FetchTreeParser(this.Configuration);
int numberCollectionFetches;
int aliasCounter;
var fetchTree = fetchParser.GetFetchTree(query, out aliasCounter, out numberCollectionFetches);
// we may have to query across non-fetched stuff
var baseWriter = new BaseWriter(new SqlServer2012Dialect(), this.configuration);
baseWriter.AddWhereClause(query.WhereClauses, new StringBuilder(), ref fetchTree);
// note that this fetches all the things in the tree as the whereclause may reference things not fetched
if (fetchTree != null)
{
enumerable = enumerable.Fetch(fetchTree, this.tables);
}
foreach (var whereClause in query.WhereClauses)
{
var rewrittenWhereClause = whereClauseNullCheckRewriter.Rewrite(whereClause);
rewrittenWhereClause = whereClauseOpEqualityRewriter.Rewrite(rewrittenWhereClause);
enumerable = enumerable.Where(rewrittenWhereClause.Compile());
}
var firstOrderClause = true;
foreach (var orderClause in query.OrderClauses)
{
var expr = ((LambdaExpression)orderClause.Expression).Compile();
var funcName = firstOrderClause
? (orderClause.Direction == ListSortDirection.Ascending ? "OrderBy" : "OrderByDescending")
: (orderClause.Direction == ListSortDirection.Ascending ? "ThenBy" : "ThenByDescending");
var orderBy =
typeof(Enumerable).GetMethods()
.Single(
m =>
m.GetParameters().Count() == 2 &&
m.Name == funcName).MakeGenericMethod(typeof(T), ((LambdaExpression)orderClause.Expression).ReturnType);
enumerable = (IEnumerable <T>)orderBy.Invoke(null, new object[] { enumerable, expr });
firstOrderClause = false;
}
if (query.SkipN > 0)
{
enumerable = enumerable.Skip(query.SkipN);
}
if (query.TakeN > 0)
{
enumerable = enumerable.Take(query.TakeN);
}
foreach (var entity in enumerable)
{
yield return(fetchCloner.Clone(query, entity));
}
}
/// <summary>
/// </summary>
/// <param name="opCode">
/// </param>
/// <param name="baseWriter">
/// </param>
/// <returns>
/// </returns>
public static OpCodePart JumpOpCode(this OpCodePart opCode, BaseWriter baseWriter)
{
var jumpAddress = opCode.JumpAddress();
OpCodePart stopForBranch;
if (baseWriter.OpsByAddressStart.TryGetValue(jumpAddress, out stopForBranch))
{
return stopForBranch;
}
return null;
}
internal EmptySendContext(BaseWriter writer, LazyAsyncResult result)
{
_writer = writer;
_result = result;
}
/// <summary>
/// </summary>
/// <param name="methodInfo">
/// </param>
/// <param name="opCodeMethodInfo">
/// </param>
/// <param name="isVirtual">
/// </param>
/// <param name="hasThis">
/// </param>
/// <param name="llvmWriter">
/// </param>
/// <param name="thisType">
/// </param>
/// <param name="hasThisArgument">
/// </param>
/// <param name="opCodeFirstOperand">
/// </param>
/// <param name="resultOfFirstOperand">
/// </param>
/// <param name="isIndirectMethodCall">
/// </param>
/// <param name="ownerOfExplicitInterface">
/// </param>
/// <param name="requiredType">
/// </param>
public static void WriteFunctionCallProlog(
this IMethod methodInfo,
OpCodePart opCodeMethodInfo,
bool isVirtual,
bool hasThis,
LlvmWriter llvmWriter,
out IType thisType,
out bool hasThisArgument,
out OpCodePart opCodeFirstOperand,
out BaseWriter.ReturnResult resultOfFirstOperand,
out bool isIndirectMethodCall,
out IType ownerOfExplicitInterface,
out IType requiredType)
{
thisType = methodInfo.DeclaringType.ToClass();
hasThisArgument = hasThis && opCodeMethodInfo.OpCodeOperands != null
&& opCodeMethodInfo.OpCodeOperands.Length - methodInfo.GetParameters().Count() > 0;
opCodeFirstOperand = opCodeMethodInfo.OpCodeOperands != null && opCodeMethodInfo.OpCodeOperands.Length > 0
? opCodeMethodInfo.OpCodeOperands[0]
: null;
resultOfFirstOperand = opCodeFirstOperand != null ? llvmWriter.ResultOf(opCodeFirstOperand) : null;
isIndirectMethodCall = isVirtual
&&
(methodInfo.IsAbstract || methodInfo.IsVirtual ||
(thisType.IsInterface && thisType.TypeEquals(resultOfFirstOperand.Type)));
ownerOfExplicitInterface = isVirtual && thisType.IsInterface &&
thisType.TypeNotEquals(resultOfFirstOperand.Type)
? resultOfFirstOperand.Type
: null;
var rollbackType = false;
requiredType = ownerOfExplicitInterface != null ? resultOfFirstOperand.Type : null;
if (requiredType != null)
{
thisType = requiredType;
rollbackType = true;
}
if (isIndirectMethodCall && methodInfo.DeclaringType.TypeNotEquals(thisType) &&
methodInfo.DeclaringType.IsInterface && !thisType.IsInterface
&& thisType.HasExplicitInterfaceMethodOverride(methodInfo))
{
// this is explicit call of interface
isIndirectMethodCall = false;
}
else if (rollbackType)
{
thisType = methodInfo.DeclaringType;
}
}
/// <summary>
/// </summary>
/// <param name="opCodeMethodInfo">
/// </param>
/// <param name="thisType">
/// </param>
/// <param name="opCodeFirstOperand">
/// </param>
/// <param name="resultOfFirstOperand">
/// </param>
/// <param name="llvmWriter">
/// </param>
public static void WriteFunctionCallPrepareThisExpression(
this OpCodePart opCodeMethodInfo,
IType thisType,
OpCodePart opCodeFirstOperand,
BaseWriter.ReturnResult resultOfFirstOperand,
LlvmWriter llvmWriter)
{
var writer = llvmWriter.Output;
// check if you need to cast this parameter
var isPrimitive = resultOfFirstOperand.Type.IsPrimitiveTypeOrEnum();
var isPrimitivePointer = resultOfFirstOperand.Type.IsPointer &&
resultOfFirstOperand.Type.GetElementType().IsPrimitiveTypeOrEnum();
var dynamicCastRequired = false;
if (!isPrimitive && !isPrimitivePointer &&
thisType.IsClassCastRequired(opCodeFirstOperand, out dynamicCastRequired))
{
writer.WriteLine("; Cast of 'This' parameter");
llvmWriter.WriteCast(opCodeFirstOperand, opCodeFirstOperand.Result, thisType);
writer.WriteLine(string.Empty);
}
if (dynamicCastRequired)
{
writer.WriteLine("; Dynamic Cast of 'This' parameter");
llvmWriter.WriteDynamicCast(writer, opCodeFirstOperand, opCodeFirstOperand.Result, thisType);
writer.WriteLine(string.Empty);
}
if (isPrimitive || isPrimitivePointer)
{
var primitiveType = resultOfFirstOperand.Type;
if (isPrimitivePointer)
{
writer.WriteLine("; Box Primitive pointer type for 'This' parameter");
primitiveType = resultOfFirstOperand.Type.GetElementType();
var firstOperandResult = opCodeFirstOperand.Result;
opCodeFirstOperand.Result = null;
llvmWriter.WriteLlvmLoad(
opCodeFirstOperand,
firstOperandResult.Type.ToDereferencedType(),
firstOperandResult);
}
else
{
writer.WriteLine("; Box Primitive type(void*) for 'This' parameter");
var intType = llvmWriter.GetIntTypeByByteSize(LlvmWriter.PointerSize);
var uintType = llvmWriter.GetUIntTypeByByteSize(LlvmWriter.PointerSize);
if (intType.TypeEquals(primitiveType) || uintType.TypeEquals(primitiveType))
{
var declType = (opCodeMethodInfo as OpCodeMethodInfoPart).Operand.DeclaringType;
Debug.Assert(declType.IsStructureType(), "only Struct type can be used");
primitiveType = declType.ToClass();
llvmWriter.AdjustIntConvertableTypes(
writer,
opCodeMethodInfo.OpCodeOperands[0],
declType.ToPointerType());
}
else
{
Debug.Assert(false, "only Int type allowed");
}
}
// convert value to object
opCodeMethodInfo.Result = null;
var opCodeNone = OpCodePart.CreateNop;
opCodeNone.OpCodeOperands = new[] { opCodeMethodInfo.OpCodeOperands[0] };
primitiveType.ToClass().WriteCallBoxObjectMethod(llvmWriter, opCodeNone);
opCodeFirstOperand.Result = opCodeNone.Result;
writer.WriteLine(string.Empty);
if (thisType.IsClassCastRequired(opCodeFirstOperand, out dynamicCastRequired))
{
writer.WriteLine("; Cast of 'Boxed' 'This' parameter");
llvmWriter.WriteCast(opCodeFirstOperand, opCodeFirstOperand.Result, thisType);
writer.WriteLine(string.Empty);
}
}
}
/// <summary>
/// </summary>
/// <param name="opCodeMethodInfo">
/// </param>
/// <param name="thisType">
/// </param>
/// <param name="opCodeFirstOperand">
/// </param>
/// <param name="resultOfFirstOperand">
/// </param>
/// <param name="llvmWriter">
/// </param>
public static void WriteFunctionCallPrepareThisExpression(
this OpCodePart opCodeMethodInfo, IType thisType, OpCodePart opCodeFirstOperand, BaseWriter.ReturnResult resultOfFirstOperand, LlvmWriter llvmWriter)
{
var writer = llvmWriter.Output;
// check if you need to cast this parameter
var isPrimitive = resultOfFirstOperand.Type.IsPrimitiveTypeOrEnum();
var isPrimitivePointer = resultOfFirstOperand.Type.IsPointer && resultOfFirstOperand.Type.GetElementType().IsPrimitiveTypeOrEnum();
var dynamicCastRequired = false;
if (!isPrimitive && !isPrimitivePointer && thisType.IsClassCastRequired(opCodeFirstOperand, out dynamicCastRequired))
{
writer.WriteLine("; Cast of 'This' parameter");
llvmWriter.WriteCast(opCodeFirstOperand, opCodeFirstOperand.Result, thisType);
writer.WriteLine(string.Empty);
}
if (dynamicCastRequired)
{
writer.WriteLine("; Dynamic Cast of 'This' parameter");
llvmWriter.WriteDynamicCast(writer, opCodeFirstOperand, opCodeFirstOperand.Result, thisType);
writer.WriteLine(string.Empty);
}
if (isPrimitive || isPrimitivePointer)
{
writer.WriteLine("; Box Primitive type for 'This' parameter");
var primitiveType = !isPrimitivePointer ? resultOfFirstOperand.Type : resultOfFirstOperand.Type.GetElementType();
if (isPrimitivePointer)
{
var firstOperandResult = opCodeFirstOperand.Result;
opCodeFirstOperand.Result = null;
llvmWriter.WriteLlvmLoad(opCodeFirstOperand, firstOperandResult.Type.ToDereferencedType(), firstOperandResult);
}
// convert value to object
opCodeMethodInfo.Result = null;
var opCodeNone = OpCodePart.CreateNop;
opCodeNone.OpCodeOperands = new[] { opCodeMethodInfo.OpCodeOperands[0] };
primitiveType.ToClass().WriteCallBoxObjectMethod(llvmWriter, opCodeNone);
opCodeFirstOperand.Result = opCodeNone.Result;
writer.WriteLine(string.Empty);
if (thisType.IsClassCastRequired(opCodeFirstOperand, out dynamicCastRequired))
{
writer.WriteLine("; Cast of 'Boxed' 'This' parameter");
llvmWriter.WriteCast(opCodeFirstOperand, opCodeFirstOperand.Result, thisType);
writer.WriteLine(string.Empty);
}
}
}
internal IAsyncResult BeginSend(BaseWriter writer, bool sendEnvelope, bool allowUnicode,
AsyncCallback?callback, object?state)
{
SetContent(allowUnicode);
return(_message.BeginSend(writer, sendEnvelope, allowUnicode, callback, state));
}
internal void Send(BaseWriter writer, bool sendEnvelope, bool allowUnicode)
{
SetContent(allowUnicode);
_message.Send(writer, sendEnvelope, allowUnicode);
}
internal EmptySendContext(BaseWriter writer, LazyAsyncResult result)
{
this.writer = writer;
this.result = result;
}
public void SaveBranchStackValue(OpCodePart opCode, BaseWriter baseWriter)
{
switch (opCode.ToCode())
{
case Code.Br:
case Code.Br_S:
case Code.Beq:
case Code.Beq_S:
case Code.Blt:
case Code.Blt_S:
case Code.Bgt:
case Code.Bgt_S:
case Code.Ble:
case Code.Ble_S:
case Code.Bge:
case Code.Bge_S:
case Code.Blt_Un:
case Code.Blt_Un_S:
case Code.Bgt_Un:
case Code.Bgt_Un_S:
case Code.Ble_Un:
case Code.Ble_Un_S:
case Code.Bge_Un:
case Code.Bge_Un_S:
case Code.Bne_Un:
case Code.Bne_Un_S:
case Code.Brtrue:
case Code.Brtrue_S:
case Code.Brfalse:
case Code.Brfalse_S:
if (opCode.IsJumpForward() && this.main.Any())
{
// to clone whole stack
var clonedStack = this.main.ToList();
clonedStack.Reverse();
opCode.BranchStackValue = new Stack<OpCodePart>(clonedStack);
}
break;
}
}
/// <summary>
/// </summary>
/// <param name="opCode">
/// </param>
/// <param name="baseWriter">
/// </param>
/// <returns>
/// </returns>
public static IType GetLocalType(this OpCodePart opCode, BaseWriter baseWriter)
{
var asString = opCode.ToCode().ToString();
var index = -1;
if (opCode.Any(Code.Ldloc_S, Code.Ldloc, Code.Ldloca_S, Code.Ldloca) || opCode.Any(Code.Stloc_S, Code.Stloc))
{
index = (opCode as OpCodeInt32Part).Operand;
}
else
{
index = int.Parse(asString.Substring(asString.Length - 1));
}
Debug.Assert(baseWriter.LocalInfo.Length > index);
var localType = baseWriter.LocalInfo[index].LocalType;
return localType;
}
public void Write(string value)
{
BaseWriter.Write(value);
}
/// <summary>
/// </summary>
/// <param name="opCode">
/// </param>
/// <param name="baseWriter">
/// </param>
/// <returns>
/// </returns>
public static OpCodePart NextOpCodeGroup(this OpCodePart opCode, BaseWriter baseWriter)
{
OpCodePart ret = null;
baseWriter.OpsByGroupAddressStart.TryGetValue(opCode.GroupAddressEnd, out ret);
return ret;
}
public void Write(char[] value, long sizeOfContent)
{
BytesWritten += sizeOfContent;
BaseWriter.Write(value);
}
