LTO C API: always parse modules in opaque pointer mode.

[t.p.northover]

Summary

Once an LLVMContext has been told it needs to track pointer types, it can no longer be used to parse opaque modules. However, we are likely (at least for a while) to have old LTO .o files in the SDK that need to interoperate with just-generated ones, so deciding opaqueness based on the first module read causes linker failures.

This makes the llvm-c LTO interface (used by ld64) parse any object it sees in opaque mode, even if type data is present, which guarantees compatibility.

[steven_wu]

LGTM

[t.p.northover]

Thanks, committed as 8ba9a5218782

[dmgreen]

llvm/tools/lto/lto.cpp

138

Hi - We noticed from out downstream embedded linker that this can be null if it comes in via lto_codegen_create, as opposed to lto_codegen_create_in_local_context.

[lenary]

llvm/tools/lto/lto.cpp

138

We got downstream failures from this patch, because OwnedContext can be null here (if you use the first constructor on line 127, above).

I think maybe my suggestion is less falliable, but alters global state, so I'm not sure it's right either. It should at least work when OwnedContext is null, because the LTOCodeGenerator will still have a context to return (the global one)

[nikic]

FWIW, now that D139940 has landed, you likely don't need this change at all.

[w2yehia]

llvm/tools/lto/lto.cpp

138

this is breaking the AIX linker too - for the same reasons as above.

[steven_wu]

llvm/tools/lto/lto.cpp

138

Reverted in 3a5426f57243.

It is likely this is not needed anymore.

llvm/tools/lto/lto.cpp

#endif
     InitializeAllTargets();
     InitializeAllTargetMCs();
     InitializeAllAsmParsers();
     InitializeAllAsmPrinters();
     InitializeAllDisassemblers();
 
     static LLVMContext Context;
     LTOContext = &Context;
+    LTOContext->setOpaquePointers(true);
     LTOContext->setDiagnosticHandler(
         std::make_unique<LTOToolDiagnosticHandler>(), true);
     initialized = true;
   }
 }
 
 namespace {
 
LibLTOCodeGenerator(std::unique_ptr<LLVMContext> Context)
       : LTOCodeGenerator(*Context), OwnedContext(std::move(Context)) {
     init();
   }
 
   // Reset the module first in case MergedModule is created in OwnedContext.
   // Module must be destructed before its context gets destructed.
   ~LibLTOCodeGenerator() { resetMergedModule(); }
 
-  void init() { setDiagnosticHandler(handleLibLTODiagnostic, nullptr); }
+  void init() {
+    OwnedContext->setOpaquePointers(true);
+    setDiagnosticHandler(handleLibLTODiagnostic, nullptr);
+  }
 
   std::unique_ptr<MemoryBuffer> NativeObjectFile;
   std::unique_ptr<LLVMContext> OwnedContext;
 };
 
 }
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(LibLTOCodeGenerator, lto_code_gen_t)

 lto_module_t lto_module_create_in_local_context(const void *mem, size_t length,
                                                 const char *path) {
   lto_initialize();
   llvm::TargetOptions Options =
       codegen::InitTargetOptionsFromCodeGenFlags(Triple());
 
   // Create a local context. Ownership will be transferred to LTOModule.
   std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
+  Context->setOpaquePointers(true);
   Context->setDiagnosticHandler(std::make_unique<LTOToolDiagnosticHandler>(),
                                 true);
 
   ErrorOr<std::unique_ptr<LTOModule>> M = LTOModule::createInLocalContext(
       std::move(Context), mem, length, Options, StringRef(path));
   if (!M)
     return nullptr;
   return wrap(M->release());