protected override LLVMValueRef ValueAsTypeInternal(LLVMTypeRef type, LLVMBuilderRef builder, bool signExtend)
{
LLVMTypeRef origLLVMType = ILImporter.GetLLVMTypeForTypeDesc(Type);
LLVMValueRef value = _importer.LoadTemp(LocalIndex, origLLVMType);
return(ILImporter.CastIfNecessary(builder, value, type));
}
protected override LLVMValueRef ValueAsTypeInternal(LLVMTypeRef type, LLVMBuilderRef builder, bool signExtend)
{
if (RawLLVMValue.Pointer == IntPtr.Zero)
throw new NullReferenceException();
return ILImporter.CastIfNecessary(builder, RawLLVMValue, type, Name);
}
protected override LLVMValueRef ValueAsTypeInternal(LLVMTypeRef type, LLVMBuilderRef builder, bool signExtend)
{
if (type.IsPackedStruct && type.Handle != RawLLVMValue.TypeOf.Handle)
{
var destStruct = type.Undef;
for (uint elemNo = 0; elemNo < RawLLVMValue.TypeOf.StructElementTypesCount; elemNo++)
{
var elemValRef = builder.BuildExtractValue(RawLLVMValue, 0, "ex" + elemNo);
destStruct = builder.BuildInsertValue(destStruct, elemValRef, elemNo, "st" + elemNo);
}
return(destStruct);
}
return(ILImporter.CastIfNecessary(builder, RawLLVMValue, type, Name, !signExtend));
}
public SpilledExpressionEntry(StackValueKind kind, string name, TypeDesc type, int localIndex, ILImporter importer) : base(kind, name, new LLVMValueRef(IntPtr.Zero), type)
{
LocalIndex = localIndex;
_importer = importer;
}
protected override LLVMValueRef ValueAsTypeInternal(LLVMTypeRef type, LLVMBuilderRef builder, bool signExtend)
{
return(ILImporter.CastIfNecessary(builder, RawLLVMValue, type));
}
protected override LLVMValueRef ValueAsTypeInternal(LLVMTypeRef type, LLVMBuilderRef builder, bool signExtend)
{
return(ILImporter.LoadValue(builder, RawLLVMValue, Type, type, signExtend));
}
public LLVMValueRef ValueAsType(TypeDesc type, LLVMBuilderRef builder)
{
return(ValueAsType(ILImporter.GetLLVMTypeForTypeDesc(type), builder));
}
public static void CompileMethod(WebAssemblyCodegenCompilation compilation, WebAssemblyMethodCodeNode methodCodeNodeNeedingCode)
{
MethodDesc method = methodCodeNodeNeedingCode.Method;
if (compilation.Logger.IsVerbose)
{
string methodName = method.ToString();
compilation.Logger.Writer.WriteLine("Compiling " + methodName);
}
if (method.HasCustomAttribute("System.Runtime", "RuntimeImportAttribute"))
{
methodCodeNodeNeedingCode.CompilationCompleted = true;
//throw new NotImplementedException();
//CompileExternMethod(methodCodeNodeNeedingCode, ((EcmaMethod)method).GetRuntimeImportName());
//return;
}
if (method.IsRawPInvoke())
{
//CompileExternMethod(methodCodeNodeNeedingCode, method.GetPInvokeMethodMetadata().Name ?? method.Name);
//return;
}
var methodIL = compilation.GetMethodIL(method);
if (methodIL == null)
{
return;
}
ILImporter ilImporter = null;
try
{
string mangledName;
// TODO: We should use the startup node to generate StartupCodeMain and avoid special casing here
if (methodCodeNodeNeedingCode.Method.Signature.IsStatic && methodCodeNodeNeedingCode.Method.Name == "Main")
{
mangledName = "Main";
}
else
{
mangledName = compilation.NameMangler.GetMangledMethodName(methodCodeNodeNeedingCode.Method).ToString();
}
ilImporter = new ILImporter(compilation, method, methodIL, mangledName);
CompilerTypeSystemContext typeSystemContext = compilation.TypeSystemContext;
//MethodDebugInformation debugInfo = compilation.GetDebugInfo(methodIL);
/* if (!compilation.Options.HasOption(CppCodegenConfigProvider.NoLineNumbersString))*/
{
//IEnumerable<ILSequencePoint> sequencePoints = debugInfo.GetSequencePoints();
/*if (sequencePoints != null)
* ilImporter.SetSequencePoints(sequencePoints);*/
}
//IEnumerable<ILLocalVariable> localVariables = debugInfo.GetLocalVariables();
/*if (localVariables != null)
* ilImporter.SetLocalVariables(localVariables);*/
IEnumerable <string> parameters = GetParameterNamesForMethod(method);
/*if (parameters != null)
* ilImporter.SetParameterNames(parameters);*/
ilImporter.Import();
methodCodeNodeNeedingCode.CompilationCompleted = true;
}
catch (Exception e)
{
compilation.Logger.Writer.WriteLine(e.Message + " (" + method + ")");
methodCodeNodeNeedingCode.CompilationCompleted = true;
// methodCodeNodeNeedingCode.SetDependencies(ilImporter.GetDependencies());
//throw new NotImplementedException();
//methodCodeNodeNeedingCode.SetCode(sb.ToString(), Array.Empty<Object>());
}
// Ensure dependencies show up regardless of exceptions to avoid breaking LLVM
methodCodeNodeNeedingCode.SetDependencies(ilImporter.GetDependencies());
}
public static void CompileMethod(WebAssemblyCodegenCompilation compilation, WebAssemblyMethodCodeNode methodCodeNodeNeedingCode)
{
MethodDesc method = methodCodeNodeNeedingCode.Method;
if (compilation.Logger.IsVerbose)
{
string methodName = method.ToString();
compilation.Logger.Writer.WriteLine("Compiling " + methodName);
}
if (method.HasCustomAttribute("System.Runtime", "RuntimeImportAttribute"))
{
methodCodeNodeNeedingCode.CompilationCompleted = true;
//throw new NotImplementedException();
//CompileExternMethod(methodCodeNodeNeedingCode, ((EcmaMethod)method).GetRuntimeImportName());
//return;
}
if (method.IsRawPInvoke())
{
//CompileExternMethod(methodCodeNodeNeedingCode, method.GetPInvokeMethodMetadata().Name ?? method.Name);
//return;
}
var methodIL = compilation.GetMethodIL(method);
if (methodIL == null)
{
return;
}
ILImporter ilImporter = null;
try
{
string mangledName;
// TODO: Better detection of the StartupCodeMain method
if (methodCodeNodeNeedingCode.Method.Signature.IsStatic && methodCodeNodeNeedingCode.Method.Name == "StartupCodeMain")
{
mangledName = "StartupCodeMain";
}
else
{
mangledName = compilation.NameMangler.GetMangledMethodName(methodCodeNodeNeedingCode.Method).ToString();
}
ilImporter = new ILImporter(compilation, method, methodIL, mangledName, methodCodeNodeNeedingCode is WebAssemblyUnboxingThunkNode);
CompilerTypeSystemContext typeSystemContext = compilation.TypeSystemContext;
//MethodDebugInformation debugInfo = compilation.GetDebugInfo(methodIL);
/* if (!compilation.Options.HasOption(CppCodegenConfigProvider.NoLineNumbersString))*/
{
//IEnumerable<ILSequencePoint> sequencePoints = debugInfo.GetSequencePoints();
/*if (sequencePoints != null)
* ilImporter.SetSequencePoints(sequencePoints);*/
}
//IEnumerable<ILLocalVariable> localVariables = debugInfo.GetLocalVariables();
/*if (localVariables != null)
* ilImporter.SetLocalVariables(localVariables);*/
IEnumerable <string> parameters = GetParameterNamesForMethod(method);
/*if (parameters != null)
* ilImporter.SetParameterNames(parameters);*/
ilImporter.Import();
ilImporter.CreateEHData(methodCodeNodeNeedingCode);
methodCodeNodeNeedingCode.CompilationCompleted = true;
}
catch (Exception e)
{
compilation.Logger.Writer.WriteLine(e.Message + " (" + method + ")");
methodCodeNodeNeedingCode.CompilationCompleted = true;
// methodCodeNodeNeedingCode.SetDependencies(ilImporter.GetDependencies());
//throw new NotImplementedException();
//methodCodeNodeNeedingCode.SetCode(sb.ToString(), Array.Empty<Object>());
}
// Uncomment the block below to get specific method failures when LLVM fails for cryptic reasons
#if false
LLVMBool result = LLVM.VerifyFunction(ilImporter._llvmFunction, LLVMVerifierFailureAction.LLVMPrintMessageAction);
if (result.Value != 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Error compliling {method.OwningType}.{method}");
Console.ResetColor();
}
#endif // false
// Ensure dependencies show up regardless of exceptions to avoid breaking LLVM
methodCodeNodeNeedingCode.SetDependencies(ilImporter.GetDependencies());
}
public void CompileMethod(CppMethodCodeNode methodCodeNodeNeedingCode)
{
MethodDesc method = methodCodeNodeNeedingCode.Method;
_compilation.Logger.Writer.WriteLine("Compiling " + method.ToString());
if (method.HasCustomAttribute("System.Runtime", "RuntimeImportAttribute"))
{
CompileExternMethod(methodCodeNodeNeedingCode, ((EcmaMethod)method).GetRuntimeImportName());
return;
}
if (method.IsRawPInvoke())
{
CompileExternMethod(methodCodeNodeNeedingCode, method.GetPInvokeMethodMetadata().Name ?? method.Name);
return;
}
var methodIL = _compilation.GetMethodIL(method);
if (methodIL == null)
return;
// TODO: Remove this code once CppCodegen is able to generate code for the reflection startup path.
// The startup path runs before any user code is executed.
// For now we replace the startup path with a simple "ret". Reflection won't work, but
// programs not using reflection will.
if (method.Name == ".cctor")
{
MetadataType owningType = method.OwningType as MetadataType;
if (owningType != null &&
owningType.Name == "ReflectionExecution" && owningType.Namespace == "Internal.Reflection.Execution")
{
methodIL = new Internal.IL.Stubs.ILStubMethodIL(method, new byte[] { (byte)ILOpcode.ret }, Array.Empty<LocalVariableDefinition>(), null);
}
}
try
{
// TODO: hacky special-case
if (method.Name == "_ecvt_s")
throw new NotImplementedException();
var ilImporter = new ILImporter(_compilation, this, method, methodIL);
CompilerTypeSystemContext typeSystemContext = _compilation.TypeSystemContext;
MethodDebugInformation debugInfo = _compilation.GetDebugInfo(methodIL);
if (!_compilation.Options.HasOption(CppCodegenConfigProvider.NoLineNumbersString))
{
IEnumerable<ILSequencePoint> sequencePoints = debugInfo.GetSequencePoints();
if (sequencePoints != null)
ilImporter.SetSequencePoints(sequencePoints);
}
IEnumerable<ILLocalVariable> localVariables = debugInfo.GetLocalVariables();
if (localVariables != null)
ilImporter.SetLocalVariables(localVariables);
IEnumerable<string> parameters = GetParameterNamesForMethod(method);
if (parameters != null)
ilImporter.SetParameterNames(parameters);
ilImporter.Compile(methodCodeNodeNeedingCode);
}
catch (Exception e)
{
_compilation.Logger.Writer.WriteLine(e.Message + " (" + method + ")");
var sb = new CppGenerationBuffer();
sb.AppendLine();
AppendCppMethodDeclaration(sb, method, true);
sb.AppendLine();
sb.Append("{");
sb.Indent();
sb.AppendLine();
sb.Append("throw 0xC000C000;");
sb.Exdent();
sb.AppendLine();
sb.Append("}");
methodCodeNodeNeedingCode.SetCode(sb.ToString(), Array.Empty<Object>());
}
}
public void CompileMethod(CppMethodCodeNode methodCodeNodeNeedingCode)
{
MethodDesc method = methodCodeNodeNeedingCode.Method;
_compilation.Log.WriteLine("Compiling " + method.ToString());
SpecialMethodKind kind = method.DetectSpecialMethodKind();
if (kind != SpecialMethodKind.Unknown)
{
string specialMethodCode = CompileSpecialMethod(method, kind);
methodCodeNodeNeedingCode.SetCode(specialMethodCode, Array.Empty<Object>());
return;
}
var methodIL = _compilation.GetMethodIL(method);
if (methodIL == null)
return;
string methodCode;
try
{
var ilImporter = new ILImporter(_compilation, this, method, methodIL);
CompilerTypeSystemContext typeSystemContext = _compilation.TypeSystemContext;
if (!_compilation.Options.NoLineNumbers)
{
IEnumerable<ILSequencePoint> sequencePoints = typeSystemContext.GetSequencePointsForMethod(method);
if (sequencePoints != null)
ilImporter.SetSequencePoints(sequencePoints);
}
IEnumerable<ILLocalVariable> localVariables = typeSystemContext.GetLocalVariableNamesForMethod(method);
if (localVariables != null)
ilImporter.SetLocalVariables(localVariables);
IEnumerable<string> parameters = typeSystemContext.GetParameterNamesForMethod(method);
if (parameters != null)
ilImporter.SetParameterNames(parameters);
ilImporter.Compile(methodCodeNodeNeedingCode);
}
catch (Exception e)
{
_compilation.Log.WriteLine(e.Message + " (" + method + ")");
methodCode = GetCppMethodDeclaration(method, true) + " { throw 0xC000C000; }" + Environment.NewLine;
methodCodeNodeNeedingCode.SetCode(methodCode, Array.Empty<Object>());
}
}
public void CompileMethod(CppMethodCodeNode methodCodeNodeNeedingCode)
{
MethodDesc method = methodCodeNodeNeedingCode.Method;
_compilation.Log.WriteLine("Compiling " + method.ToString());
if (method.HasCustomAttribute("System.Runtime", "RuntimeImportAttribute"))
{
CompileExternMethod(methodCodeNodeNeedingCode, ((EcmaMethod)method).GetRuntimeImportName());
return;
}
if (method.IsRawPInvoke())
{
CompileExternMethod(methodCodeNodeNeedingCode, method.GetPInvokeMethodMetadata().Name ?? method.Name);
return;
}
var methodIL = _compilation.GetMethodIL(method);
if (methodIL == null)
return;
try
{
var ilImporter = new ILImporter(_compilation, this, method, methodIL);
CompilerTypeSystemContext typeSystemContext = _compilation.TypeSystemContext;
MethodDebugInformation debugInfo = _compilation.GetDebugInfo(methodIL);
if (!_compilation.Options.NoLineNumbers)
{
IEnumerable<ILSequencePoint> sequencePoints = debugInfo.GetSequencePoints();
if (sequencePoints != null)
ilImporter.SetSequencePoints(sequencePoints);
}
IEnumerable<ILLocalVariable> localVariables = debugInfo.GetLocalVariables();
if (localVariables != null)
ilImporter.SetLocalVariables(localVariables);
IEnumerable<string> parameters = GetParameterNamesForMethod(method);
if (parameters != null)
ilImporter.SetParameterNames(parameters);
ilImporter.Compile(methodCodeNodeNeedingCode);
}
catch (Exception e)
{
_compilation.Log.WriteLine(e.Message + " (" + method + ")");
var builder = new CppGenerationBuffer();
builder.AppendLine();
builder.Append(GetCppMethodDeclaration(method, true));
builder.AppendLine();
builder.Append("{");
builder.Indent();
builder.AppendLine();
builder.Append("throw 0xC000C000;");
builder.Exdent();
builder.AppendLine();
builder.Append("}");
methodCodeNodeNeedingCode.SetCode(builder.ToString(), Array.Empty<Object>());
}
}
public override StackEntry Duplicate(LLVMBuilderRef builder)
{
return(new ExpressionEntry(Kind, "duplicate_" + Name, ILImporter.LoadValue(builder, RawLLVMValue, Type, ILImporter.GetLLVMTypeForTypeDesc(Type), false, "load_duplicate_" + Name), Type));
}
protected override LLVMValueRef ValueAsTypeInternal(LLVMTypeRef type, LLVMBuilderRef builder, bool signExtend)
{
//TODO: deal with sign extension here
return(ILImporter.CastIfNecessary(builder, RawLLVMValue, type, Name));
}
public static void CompileMethod(WebAssemblyCodegenCompilation compilation, WebAssemblyMethodCodeNode methodCodeNodeNeedingCode)
{
MethodDesc method = methodCodeNodeNeedingCode.Method;
compilation.Logger.Writer.WriteLine("Compiling " + method.ToString());
if (method.HasCustomAttribute("System.Runtime", "RuntimeImportAttribute"))
{
throw new NotImplementedException();
//CompileExternMethod(methodCodeNodeNeedingCode, ((EcmaMethod)method).GetRuntimeImportName());
//return;
}
if (method.IsRawPInvoke())
{
//CompileExternMethod(methodCodeNodeNeedingCode, method.GetPInvokeMethodMetadata().Name ?? method.Name);
//return;
}
var methodIL = compilation.GetMethodIL(method);
if (methodIL == null)
{
return;
}
ILImporter ilImporter = null;
try
{
ilImporter = new ILImporter(compilation, method, methodIL, methodCodeNodeNeedingCode.GetMangledName(compilation.NameMangler));
CompilerTypeSystemContext typeSystemContext = compilation.TypeSystemContext;
//MethodDebugInformation debugInfo = compilation.GetDebugInfo(methodIL);
/* if (!compilation.Options.HasOption(CppCodegenConfigProvider.NoLineNumbersString))*/
{
//IEnumerable<ILSequencePoint> sequencePoints = debugInfo.GetSequencePoints();
/*if (sequencePoints != null)
* ilImporter.SetSequencePoints(sequencePoints);*/
}
//IEnumerable<ILLocalVariable> localVariables = debugInfo.GetLocalVariables();
/*if (localVariables != null)
* ilImporter.SetLocalVariables(localVariables);*/
IEnumerable <string> parameters = GetParameterNamesForMethod(method);
/*if (parameters != null)
* ilImporter.SetParameterNames(parameters);*/
ilImporter.Import();
methodCodeNodeNeedingCode.CompilationCompleted = true;
methodCodeNodeNeedingCode.SetDependencies(ilImporter.GetDependencies());
}
catch (Exception e)
{
compilation.Logger.Writer.WriteLine(e.Message + " (" + method + ")");
methodCodeNodeNeedingCode.CompilationCompleted = true;
// methodCodeNodeNeedingCode.SetDependencies(ilImporter.GetDependencies());
//throw new NotImplementedException();
//methodCodeNodeNeedingCode.SetCode(sb.ToString(), Array.Empty<Object>());
}
}