clang-format

gen/dynamiccompile.cpp

@@ -26,9 +26,7 @@
 
 namespace {
 
-enum {
+enum { ApiVersion = LDC_DYNAMIC_COMPILE_API_VERSION };
-    ApiVersion = LDC_DYNAMIC_COMPILE_API_VERSION
-};
 
 const char *DynamicCompileModulesHeadName = "dynamiccompile_modules_head";
 
@@ -577,8 +575,7 @@ llvm::GlobalVariable *generateModuleListElem(IRState *irs, const Types &types,
   auto symListInit = generateSymList(irs, types, globalVals);
   auto varlistInit = generateVarList(irs, types);
   llvm::Constant *fields[] = {
-      llvm::ConstantInt::get(irs->context(),
+      llvm::ConstantInt::get(irs->context(), APInt(32, ApiVersion)), // version
-          APInt(32, ApiVersion)),    // version
       llvm::ConstantPointerNull::get(llvm::dyn_cast<llvm::PointerType>(
           elem_type->getElementType(1))), // next
       irData->getInitializer(),           // irdata

runtime/jit-rt/cpp-so/compile.cpp

@@ -186,17 +186,15 @@ public:
             llvm::sys::getHostCPUName(), getHostAttrs())),
         dataLayout(targetmachine->createDataLayout()),
 #if LDC_LLVM_VER >= 700
-        execSession(stringPool),
+        execSession(stringPool), resolver(createResolver()),
-        resolver(createResolver()),
+        objectLayer(execSession,
-        objectLayer(
+                    [](llvm::orc::VModuleKey) {
-          execSession,
+                      return std::make_shared<llvm::SectionMemoryManager>();
-          [](llvm::orc::VModuleKey) {
+                    },
-            return std::make_shared<llvm::SectionMemoryManager>();
+                    [this](llvm::orc::VModuleKey) { return resolver; }),
-          },
-          [this](llvm::orc::VModuleKey) { return resolver; }),
 #else
         objectLayer(
-          []() { return std::make_shared<llvm::SectionMemoryManager>(); }),
+            []() { return std::make_shared<llvm::SectionMemoryManager>(); }),
 #endif
         listenerlayer(objectLayer, ModuleListener(*targetmachine)),
         compileLayer(listenerlayer, llvm::orc::SimpleCompiler(*targetmachine)) {
@@ -256,33 +254,31 @@ private:
   }
 
 #if LDC_LLVM_VER >= 700
-  std::shared_ptr<llvm::orc::SymbolResolver>
+  std::shared_ptr<llvm::orc::SymbolResolver> createResolver() {
-  createResolver() {
     return llvm::orc::createLegacyLookupResolver(
-          [this](const std::string &name) -> llvm::JITSymbol {
+        [this](const std::string &name) -> llvm::JITSymbol {
-      if (auto Sym = compileLayer.findSymbol(name, false)) {
+          if (auto Sym = compileLayer.findSymbol(name, false)) {
-        return Sym;
+            return Sym;
-      }
+          } else if (auto Err = Sym.takeError()) {
-      else if (auto Err = Sym.takeError()) {
+            return std::move(Err);
-        return std::move(Err);
+          }
-      }
+          auto it = symMap.find(name);
-      auto it = symMap.find(name);
+          if (symMap.end() != it) {
-      if (symMap.end() != it) {
+            return llvm::JITSymbol(
-        return llvm::JITSymbol(
+                reinterpret_cast<llvm::JITTargetAddress>(it->second),
-              reinterpret_cast<llvm::JITTargetAddress>(it->second),
+                llvm::JITSymbolFlags::Exported);
-              llvm::JITSymbolFlags::Exported);
+          }
-      }
+          if (auto SymAddr = getSymbolInProcess(name)) {
-      if (auto SymAddr = getSymbolInProcess(name)) {
+            return llvm::JITSymbol(SymAddr, llvm::JITSymbolFlags::Exported);
-        return llvm::JITSymbol(SymAddr, llvm::JITSymbolFlags::Exported);
+          }
-      }
+          return nullptr;
-      return nullptr;
+        },
-    },
+        [](llvm::Error Err) {
-    [](llvm::Error Err) { llvm::cantFail(std::move(Err),
+          llvm::cantFail(std::move(Err), "lookupFlags failed");
-                                         "lookupFlags failed"); });
+        });
   }
 #else
-  std::shared_ptr<llvm::JITSymbolResolver>
+  std::shared_ptr<llvm::JITSymbolResolver> createResolver() {
-  createResolver() {
     // Build our symbol resolver:
     // Lambda 1: Look back into the JIT itself to find symbols that are part of
     //           the same "logical dylib".
@@ -381,8 +377,7 @@ struct JitFinaliser final {
 
 template <typename F>
 void enumModules(const RtCompileModuleList *modlist_head,
-                 const Context& context,
+                 const Context &context, F &&fun) {
-                 F &&fun) {
   auto current = modlist_head;
   while (current != nullptr) {
     interruptPoint(context, "check version");
@@ -516,8 +511,8 @@ __declspec(dllexport)
 #else
 __attribute__ ((visibility ("default")))
 #endif
-void JIT_API_ENTRYPOINT(const void *modlist_head,
+void JIT_API_ENTRYPOINT(const void *modlist_head, const Context *context,
-                        const Context *context, size_t contextSize) {
+                        size_t contextSize) {
   assert(nullptr != context);
   assert(sizeof(*context) == contextSize);
   rtCompileProcessImplSoInternal(

runtime/jit-rt/cpp-so/context.h

@@ -23,15 +23,13 @@ enum class DumpStage : int {
   FinalAsm = 3
 };
 
-enum {
+enum { ApiVersion = LDC_DYNAMIC_COMPILE_API_VERSION };
-    ApiVersion = LDC_DYNAMIC_COMPILE_API_VERSION
-};
 
 #define MAKE_JIT_API_CALL_IMPL(prefix, version) prefix##version
-#define MAKE_JIT_API_CALL(prefix, version) \
+#define MAKE_JIT_API_CALL(prefix, version)                                     \
   MAKE_JIT_API_CALL_IMPL(prefix, version)
-#define JIT_API_ENTRYPOINT MAKE_JIT_API_CALL(rtCompileProcessImplSo, \
+#define JIT_API_ENTRYPOINT                                                     \
-  LDC_DYNAMIC_COMPILE_API_VERSION)
+  MAKE_JIT_API_CALL(rtCompileProcessImplSo, LDC_DYNAMIC_COMPILE_API_VERSION)
 
 typedef void (*InterruptPointHandlerT)(void *, const char *action,
                                        const char *object);

runtime/jit-rt/cpp-so/disassembler.cpp

@@ -200,8 +200,7 @@ public:
   }
 };
 
-void processRelocations(SymTable &symTable,
+void processRelocations(SymTable &symTable, uint64_t offset,
-                        uint64_t offset,
                         const llvm::object::ObjectFile &object,
                         const llvm::object::SectionRef &sec) {
   for (const auto &reloc : sec.relocations()) {
@@ -336,8 +335,7 @@ void disassemble(const llvm::TargetMachine &tm,
           }
         }
         llvm::ArrayRef<uint8_t> buff(
-              reinterpret_cast<const uint8_t *>(data.data() + offset),
+            reinterpret_cast<const uint8_t *>(data.data() + offset), size);
-              size);
 
         printFunction(*disasm, *mcia, buff, symTable, *sti, *asmStreamer);
         asmStreamer->EmitRawText("");

runtime/jit-rt/cpp/compile.cpp

@@ -17,10 +17,10 @@
 struct Context;
 
 #define MAKE_JIT_API_CALL_IMPL(prefix, version) prefix##version
-#define MAKE_JIT_API_CALL(prefix, version) \
+#define MAKE_JIT_API_CALL(prefix, version)                                     \
   MAKE_JIT_API_CALL_IMPL(prefix, version)
-#define JIT_API_ENTRYPOINT MAKE_JIT_API_CALL(rtCompileProcessImplSo, \
+#define JIT_API_ENTRYPOINT                                                     \
-  LDC_DYNAMIC_COMPILE_API_VERSION)
+  MAKE_JIT_API_CALL(rtCompileProcessImplSo, LDC_DYNAMIC_COMPILE_API_VERSION)
 
 extern "C" {
 
@@ -32,8 +32,8 @@ const void *dynamiccompile_modules_head = nullptr;
 __declspec(dllimport)
 #endif
 extern void JIT_API_ENTRYPOINT(const void *modlist_head,
-                                   const Context *context,
+                               const Context *context,
-                                   std::size_t contextSize);
+                               std::size_t contextSize);
 
 void rtCompileProcessImpl(const Context *context, std::size_t contextSize) {
   JIT_API_ENTRYPOINT(dynamiccompile_modules_head, context, contextSize);