private static LLVMAbi PickLLVMAbi(ITypeMember Member, LLVMAssembly DeclaringAssembly) { var abiName = LLVMAttributes.GetAbiName(Member); if (abiName != null) { switch (abiName.ToLowerInvariant()) { case "c": return(DeclaringAssembly.ExternalAbi); case "c++": case "c#": return(DeclaringAssembly.Abi); default: throw new InvalidDataException( LLVMAttributes.AbiAttributeName + " specified unknown ABI '" + abiName + "'"); } } else if (Member.IsStatic && IsImportedMember(Member)) { return(DeclaringAssembly.ExternalAbi); } else { return(DeclaringAssembly.Abi); } }
public LLVMNamespace( UnqualifiedName Name, QualifiedName FullName, LLVMAssembly Assembly) { this.Name = Name; this.FullName = FullName; this.Assembly = Assembly; this.declaredTypes = new List <LLVMType>(); this.declaredNamespaces = new List <LLVMNamespace>(); }
/// <summary> /// Gets the ABI for the given member. /// </summary> /// <param name="Member">The member for which an ABI is to be found.</param> /// <param name="DeclaringAssembly">The assembly that is examined for candidate ABIs.</param> /// <returns>The right ABI for the given member.</returns> public static LLVMAbi GetLLVMAbi(ITypeMember Member, LLVMAssembly DeclaringAssembly) { if (Member is LLVMMethod) { return(((LLVMMethod)Member).Abi); } else if (Member is LLVMField) { return(((LLVMField)Member).Abi); } else { return(PickLLVMAbi(Member, DeclaringAssembly)); } }
/// <summary> /// Creates a module builder from the given assembly and module. /// </summary> public LLVMModuleBuilder(LLVMAssembly Assembly, LLVMModuleRef Module) { this.assembly = Assembly; this.module = Module; this.declaredMethods = new Dictionary <IMethod, LLVMValueRef>(); this.declaredVirtMethods = new Dictionary <IMethod, LLVMValueRef>(); this.declaredPrototypes = new Dictionary <IMethod, LLVMTypeRef>(); this.declaredTypes = new Dictionary <IType, LLVMTypeRef>(); this.declaredDataLayouts = new Dictionary <LLVMType, LLVMTypeRef>(); this.declaredGlobals = new Dictionary <IField, LLVMValueRef>(); this.declaredTypeIds = new Dictionary <IType, ulong>(); this.declaredTypePrimes = new Dictionary <IType, ulong>(); this.declaredTypeIndices = new Dictionary <IType, ulong>(); this.declaredVTables = new Dictionary <IType, VTableInstance>(); this.declaredIntrinsics = new Dictionary <IntrinsicValue, LLVMValueRef>(); this.interfaceStubs = new Dictionary <LLVMMethod, InterfaceStub>(); this.primeGen = new PrimeNumberGenerator(); this.staticConstructorLocks = new Dictionary < LLVMType, Tuple <LLVMValueRef, LLVMValueRef, LLVMValueRef, LLVMValueRef> >(); this.declaredStringChars = new Dictionary <string, LLVMValueRef>(); }
public BuildTarget CreateBuildTarget(string PlatformIdentifier, AssemblyCreationInfo Info, IDependencyBuilder DependencyBuilder) { var multiBinder = new MultiBinder(DependencyBuilder.Binder.Environment); multiBinder.AddBinder(DependencyBuilder.Binder); bool isWholeProgram = DependencyBuilder.Log.Options.GetFlag( Flags.WholeProgramFlagName, Info.IsExecutable); var targetAsm = new LLVMAssembly( new SimpleName(Info.Name), Info.Version, DependencyBuilder.Environment, new LLVMAbi( ItaniumMangler.Instance, new ExternalGCDescription(multiBinder, DependencyBuilder.Log), ItaniumCxxEHDescription.Instance), AttributeMap.Empty, isWholeProgram); // -fintegrated-runtime will look in the compiled assembly for runtime types. // This flag facilitates building the runtime library. if (DependencyBuilder.Log.Options.GetFlag("integrated-runtime", false)) { multiBinder.AddBinder(targetAsm.CreateBinder()); } var extraPasses = new PassManager(); // Always use -flower-box-unbox-types to lower box/unbox. extraPasses.RegisterMethodPass( new AtomicPassInfo <BodyPassArgument, IStatement>( BoxUnboxTypePass.Instance, BoxUnboxTypePass.BoxUnboxTypePassName)); extraPasses.RegisterPassCondition(BoxUnboxTypePass.BoxUnboxTypePassName, UseAlways); // Always use -flower-string-concat to lower string concatenation to calls. extraPasses.RegisterMethodPass( new AtomicPassInfo <BodyPassArgument, IStatement>( StringConcatPass.Instance, StringConcatPass.StringConcatPassName)); extraPasses.RegisterPassCondition(StringConcatPass.StringConcatPassName, UseAlways); // Always use -flower-string-literals to lower string literals to calls. extraPasses.RegisterMethodPass( new AtomicPassInfo <BodyPassArgument, IStatement>( StringLiteralPass.Instance, StringLiteralPass.StringLiteralPassName)); extraPasses.RegisterPassCondition(StringLiteralPass.StringLiteralPassName, UseAlways); // Always use -fregister-finalizers to setup finalizers. extraPasses.RegisterMethodPass( new AtomicPassInfo <IStatement, IStatement>( new FinalizerRegistrationPass(targetAsm.Abi.GarbageCollector), FinalizerRegistrationPass.FinalizerRegistrationPassName)); extraPasses.RegisterPassCondition(FinalizerRegistrationPass.FinalizerRegistrationPassName, UseAlways); // Always use -flower-new-struct, for correctness reasons. extraPasses.RegisterPassCondition(NewValueTypeLoweringPass.NewValueTypeLoweringPassName, UseAlways); // Always use -fexpand-generics-llvm to expand generic definitions. extraPasses.RegisterMemberLoweringPass( new AtomicPassInfo <MemberLoweringPassArgument, MemberConverter>( new GenericsExpansionPass(NameExpandedType, NameExpandedMethod), GenericsExpansionPass.GenericsExpansionPassName + "-llvm")); extraPasses.RegisterPassCondition( GenericsExpansionPass.GenericsExpansionPassName + "-llvm", UseAlways); // Use -finternalize-generics to keep generic definitions from creeping // into assemblies that are not compiled with -fwhole-program. extraPasses.RegisterSignaturePass( new AtomicPassInfo <MemberSignaturePassArgument <IMember>, MemberSignaturePassResult>( GenericsInternalizingPass.Instance, GenericsInternalizingPass.GenericsInternalizingPassName)); extraPasses.RegisterPassCondition( GenericsInternalizingPass.GenericsInternalizingPassName, UseAlways); // Use -fdeconstruct-cfg-eh to deconstruct exception control-flow graphs // if -O2 or higher has been specified (we won't construct a flow graph // otherwise) extraPasses.RegisterPassCondition( new PassCondition( DeconstructExceptionFlowPass.DeconstructExceptionFlowPassName, UseOptimizeNormal)); // Use -fdeconstruct-cfg to deconstruct control-flow graphs if -O2 or more // has been specified (we won't construct a flow graph otherwise) extraPasses.RegisterPassCondition( new PassCondition( DeconstructFlowGraphPass.DeconstructFlowGraphPassName, UseOptimizeNormal)); return(new BuildTarget(targetAsm, DependencyBuilder, "ll", true, extraPasses.ToPreferences())); }