private LLVMBasicBlockRef WriteReturnBlock(
LLVMType Type,
LLVMMethod Implementation,
LLVMModuleBuilder Module)
{
return(WriteReturnBlock(Type.Name.ToString(), Module.DeclareVirtual(Implementation)));
}
/// <summary>
/// Writes this type's definitions to the given module.
/// </summary>
/// <param name="Module">The module to populate.</param>
public void Emit(LLVMModuleBuilder Module)
{
foreach (var accessors in declaredAccessors)
{
accessors.Emit(Module);
}
}
private static LLVMValueRef DeclareGxxPersonalityV0(
LLVMModuleBuilder ModuleBuilder, LLVMModuleRef LLVMModule)
{
var funcType = FunctionType(Int32Type(), new LLVMTypeRef[] { }, true);
var result = AddFunction(LLVMModule, "__gxx_personality_v0", funcType);
return(result);
}
public LLVMModuleRef ToModule()
{
var module = ModuleCreateWithName(Name.ToString());
var moduleBuilder = new LLVMModuleBuilder(this, module);
rootNamespace.Emit(moduleBuilder);
moduleBuilder.EmitStubs();
return(module);
}
private static LLVMValueRef DeclareCxaVoidPointerRtti(
LLVMModuleBuilder ModuleBuilder, LLVMModuleRef LLVMModule)
{
var type = PrimitiveTypes.Void.MakePointerType(PointerKind.TransientPointer);
var result = ModuleBuilder.DeclareGlobal(ModuleBuilder.Declare(type), "_ZTIPv");
result.SetGlobalConstant(true);
return(result);
}
private static LLVMValueRef DeclareFromSignature(
IMethod Signature,
LLVMModuleBuilder ModuleBuilder,
LLVMModuleRef LLVMModule)
{
return(AddFunction(
LLVMModule,
Signature.Name.ToString(),
ModuleBuilder.DeclarePrototype(Signature)));
}
/// <summary>
/// Writes this namespace's definitions to the given module.
/// </summary>
/// <param name="Module">The module to populate.</param>
public void Emit(LLVMModuleBuilder Module)
{
for (int i = 0; i < declaredNamespaces.Count; i++)
{
declaredNamespaces[i].Emit(Module);
}
for (int i = 0; i < declaredTypes.Count; i++)
{
declaredTypes[i].Emit(Module);
}
}
/// <summary>
/// Defines the vtable for this type.
/// </summary>
/// <param name="Module">The module to define the vtable in.</param>
/// <returns>An LLVM global for this type's vtable.</returns>
public VTableInstance DefineVTable(LLVMModuleBuilder Module)
{
var allEntries = new List <LLVMMethod>();
GetAllVTableEntries(allEntries);
return(new VTableInstance(
DefineVTableGlobal(
Module,
this,
GetVTableEntryImpls(Module, allEntries)), allEntries));
}
/// <summary>
/// Writes this type's definitions to the given module.
/// </summary>
/// <param name="Module">The module to populate.</param>
public void Emit(LLVMModuleBuilder Module)
{
foreach (var method in declaredMethods)
{
method.Emit(Module);
}
foreach (var property in declaredProperties)
{
property.Emit(Module);
}
}
private LLVMValueRef[] GetVTableEntryImpls(
LLVMModuleBuilder Module,
List <LLVMMethod> AllEntries)
{
var allImpls = new LLVMValueRef[AllEntries.Count];
for (int i = 0; i < allImpls.Length; i++)
{
allImpls[i] = ConstBitCast(
Module.DeclareVirtual(AllEntries[i].GetImplementation(this) ?? AllEntries[i]),
PointerType(Int8Type(), 0));
}
return(allImpls);
}
/// <summary>
/// Defines the data layout of this type as an LLVM type.
/// </summary>
/// <param name="Module">The module to define the type in.</param>
/// <returns>An LLVM type ref for this type's data layout.</returns>
public LLVMTypeRef DefineLayout(LLVMModuleBuilder Module)
{
if (IsRuntimeImplementedDelegate)
{
return(DelegateBlock.MethodTypeLayout);
}
if (this.GetIsEnum())
{
return(Module.Declare(this.GetParent()));
}
bool isStruct = this.GetIsValueType();
if (isStruct && IsSingleValue)
{
return(Module.Declare(declaredInstanceFields[0].FieldType));
}
int offset = isStruct ? 0 : 1;
var elementTypes = new LLVMTypeRef[offset + declaredInstanceFields.Count];
if (!isStruct)
{
var baseType = this.GetParent();
if (baseType == null)
{
// Type is a root type. Embed a pointer to its vtable.
elementTypes[0] = Module.Declare(
PrimitiveTypes.UInt8.MakePointerType(
PointerKind.TransientPointer));
}
else
{
// Type is not a root type. Embed its base type.
elementTypes[0] = Module.DeclareDataLayout((LLVMType)baseType);
}
}
for (int i = 0; i < elementTypes.Length - offset; i++)
{
elementTypes[i + offset] = Module.Declare(
declaredInstanceFields[i].FieldType);
}
return(StructType(elementTypes, false));
}
/// <summary>
/// Writes this method definitions to the given module.
/// </summary>
/// <param name="Module">The module to populate.</param>
public void Emit(LLVMModuleBuilder Module)
{
if (this.GetRecursiveGenericParameters().Any <IType>())
{
throw new NotSupportedException("LLVM methods do not support generic parameters");
}
if (!DeclaringType.GetIsInterface() &&
!this.GetIsAbstract())
{
var func = Module.Declare(this);
func.SetLinkage(Linkage);
var methodBody = this.body;
if (methodBody == null &&
this.HasAttribute(
PrimitiveAttributes.Instance.RuntimeImplementedAttribute.AttributeType))
{
// Auto-implement runtime-implemented methods here.
methodBody = (CodeBlock)AutoImplement().Emit(codeGenerator);
}
if (methodBody != null)
{
// Generate the method body.
var bodyBuilder = new FunctionBodyBuilder(Module, func);
var entryPointBuilder = bodyBuilder.AppendBasicBlock("entry");
entryPointBuilder = codeGenerator.Prologue.Emit(entryPointBuilder);
var codeGen = methodBody.Emit(entryPointBuilder);
BuildUnreachable(codeGen.BasicBlock.Builder);
}
}
foreach (var iface in allInterfaceImpls.Value)
{
Module.GetInterfaceStub(iface).Implement(ParentType, this);
}
}
/// <summary>
/// Defines the global variable that backs a vtable.
/// </summary>
/// <param name="Module">The module to declare the global in.</param>
/// <param name="Type">The type that owns the vtable.</param>
/// <param name="VTableEntryImpls">
/// The list of virtual function pointers in the vtable.
/// </param>
/// <returns>A vtable global variable.</returns>
public static LLVMValueRef DefineVTableGlobal(
LLVMModuleBuilder Module,
IType Type,
LLVMValueRef[] VTableEntryImpls)
{
var fields = new LLVMValueRef[3];
fields[0] = ConstInt(Int64Type(), Module.GetTypeId(Type), false);
fields[1] = ConstInt(Int64Type(), Module.GetTypeIndex(Type), false);
fields[2] = ConstArray(
PointerType(Int8Type(), 0),
VTableEntryImpls);
var vtableContents = ConstStruct(fields, false);
var vtable = Module.DeclareGlobal(
vtableContents.TypeOf(),
Type.FullName.ToString() + ".vtable");
vtable.SetGlobalConstant(true);
vtable.SetLinkage(LLVMLinkage.LLVMInternalLinkage);
vtable.SetInitializer(vtableContents);
return(vtable);
}
/// <summary>
/// Defines this stub's body.
/// </summary>
/// <param name="Module">The module that defines the stub.</param>
public void Emit(LLVMModuleBuilder Module)
{
var entryBlock = AppendBasicBlock(Function, "entry");
var defaultBlock = AppendBasicBlock(Function, "unknown_type");
var builder = CreateBuilder();
PositionBuilderAtEnd(builder, defaultBlock);
BuildUnreachable(builder);
DisposeBuilder(builder);
builder = CreateBuilder();
PositionBuilderAtEnd(builder, entryBlock);
var switchInstr = BuildSwitch(builder, GetParam(Function, 0), defaultBlock, (uint)impls.Count);
foreach (var pair in impls)
{
switchInstr.AddCase(
ConstInt(Int64Type(), (ulong)Module.GetTypeIndex(pair.Key), false),
WriteReturnBlock(pair.Key, pair.Value, Module));
}
DisposeBuilder(builder);
}
private static LLVMValueRef DeclareCxaEndCatch(
LLVMModuleBuilder ModuleBuilder, LLVMModuleRef LLVMModule)
{
return(DeclareFromSignature(CxaEndCatchSignature, ModuleBuilder, LLVMModule));
}
private static LLVMValueRef DeclareCxaAllocateException(
LLVMModuleBuilder ModuleBuilder, LLVMModuleRef LLVMModule)
{
return(DeclareFromSignature(CxaAllocateExceptionSignature, ModuleBuilder, LLVMModule));
}
/// <summary>
/// Declares this intrinsic in the given module.
/// </summary>
/// <param name="ModuleBuilder">The module builder for the module to declare the intrinsic in.</param>
/// <param name="LLVMModule">The module to declare the intrinsic in.</param>
/// <returns>The intrinsic's declaration.</returns>
public LLVMValueRef Declare(LLVMModuleBuilder ModuleBuilder, LLVMModuleRef LLVMModule)
{
return(declareIntrinsic(ModuleBuilder, LLVMModule));
}
private static LLVMValueRef DeclareCxaRethrow(
LLVMModuleBuilder ModuleBuilder, LLVMModuleRef LLVMModule)
{
return(DeclareFromSignature(CxaRethrowSignature, ModuleBuilder, LLVMModule));
}
