Expand and rename Relocation Models

Author: CodaFi

Sources/LLVM/TargetData.swift

@@ -463,16 +463,49 @@ public enum CodeGenOptLevel {
 }
 
 /// The relocation model types supported by LLVM.
-public enum RelocMode {
+public enum RelocationModel {
   /// Generated code will assume the default for a particular target architecture.
   case `default`
   /// Generated code will exist at static offsets.
   case `static`
-  /// Generated code will be Position-Independent.
+  /// Generated code will be position-independent.
   case pic
-  /// Generated code will not be Position-Independent and may be used in static
+  /// Generated code will not be position-independent and may be used in static
   /// or dynamic executables but not necessarily a shared library.
   case dynamicNoPIC
+  /// Generated code will be compiled in read-only position independent mode.
+  /// In this mode, all read-only data and functions are at a link-time constant
+  /// offset from the program counter.
+  ///
+  /// ROPI is not supported by all target architectures and calling conventions.
+  /// It is a particular feature of ARM targets, though.
+  ///
+  /// ROPI may be useful to avoid committing to compile-time constant locations
+  /// for code in memory.  This may be useful in the following circumstances:
+  ///
+  /// - Code is loaded dynamically.
+  /// - Code is loaded into memory conditionally, or in an undefined order.
+  /// - Code is mapped into different addresses during different executions.
+  case ropi
+  /// Generated code will be compiled in read-write position independent mode.
+  /// In this mode, all writable data is at a link-time constant offset from the
+  /// static base register.
+  ///
+  /// RWPI is not supported by all target architectures and calling conventions.
+  /// It is a particular feature of ARM targets, though.
+  ///
+  /// RWPI may be useful to avoid committing to compile-time constant locations
+  /// for code in memory. This is particularly useful for data that must be
+  /// multiply instantiated for reentrant routines, as each thread executing a
+  /// reentrant routine will recieve its own copy of any data in
+  /// read-write segments.
+  case rwpi
+  /// Combines the `ropi` and `rwpi` modes.  Generated code will be compiled in
+  /// both read-only and read-write position independent modes.  All read-only
+  /// data appears at a link-time constant offset from the program counter,
+  /// and all writable data appears at a link-time constant offset from the
+  /// static base register.
+  case ropiRWPI
 
   /// Returns the underlying `LLVMRelocMode` associated with this
   /// relocation model.
@@ -482,6 +515,9 @@ public enum RelocMode {
     case .static: return LLVMRelocStatic
     case .pic: return LLVMRelocPIC
     case .dynamicNoPIC: return LLVMRelocDynamicNoPic
+    case .ropi: return LLVMRelocROPI
+    case .rwpi: return LLVMRelocRWPI
+    case .ropiRWPI: return LLVMRelocROPI_RWPI
     }
   }
 }

Sources/LLVM/TargetMachine.swift

@@ -184,14 +184,14 @@ public class TargetMachine {
   ///   particular target provides.
   /// - parameter optLevel: The optimization level for generated code.  If no
   ///   value is provided, the default level of optimization is assumed.
-  /// - parameter relocMode: The relocation mode of the target environment.  If
-  ///   no mode is provided, the default mode for the target architecture is
+  /// - parameter relocations: The relocation model of the target environment.
+  ///   If no mode is provided, the default model for the target architecture is
   ///   assumed.
   /// - parameter codeModel: The kind of code to produce for this target.  If
   ///   no model is provided, the default model for the target architecture is
   ///   assumed.
   public init(triple: String? = nil, cpu: String = "", features: String = "",
-              optLevel: CodeGenOptLevel = .default, relocMode: RelocMode = .default,
+              optLevel: CodeGenOptLevel = .default, relocations: RelocationModel = .default,
               codeModel: CodeModel = .default) throws {
 
     // Ensure the LLVM initializer is called when the first module is created
@@ -209,7 +209,7 @@ public class TargetMachine {
     self.target = Target(llvm: target!)
     self.llvm = LLVMCreateTargetMachine(target!, self.triple, cpu, features,
                                         optLevel.asLLVM(),
-                                        relocMode.asLLVM(),
+                                        relocations.asLLVM(),
                                         codeModel.asLLVM())
     self.dataLayout = TargetData(llvm: LLVMCreateTargetDataLayout(self.llvm))
   }

Tests/LLVMTests/UnitSpec.swift

@@ -80,7 +80,7 @@ class UnitSpec : XCTestCase {
   func testStructLayoutOnMachine() {
     let mod = Module(name: "StructLayout")
     let aarch64 = try! TargetMachine(triple: "aarch64--", cpu: "", features: "",
-                                     optLevel: .none, relocMode: .default, codeModel: .default)
+                                     optLevel: .none, relocations: .default, codeModel: .default)
     mod.dataLayout = aarch64.dataLayout
     XCTAssertEqual(mod.dataLayoutString, "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128")
 
@@ -115,7 +115,7 @@ class UnitSpec : XCTestCase {
     ])
 
     let aarch32 = try! TargetMachine(triple: "arm--", cpu: "", features: "",
-                                     optLevel: .none, relocMode: .default, codeModel: .default)
+                                     optLevel: .none, relocations: .default, codeModel: .default)
     mod.dataLayout = aarch32.dataLayout
     XCTAssertEqual(mod.dataLayoutString, "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64")