LTO: introduce object file-based on-disk module format.

[pcc]

Summary

This format is simply a regular object file with the bitcode stored in a
section named ".llvmbc", plus any number of other (non-allocated) sections.

One immediate use case for this is to accommodate compilation processes
which expect the object file to contain metadata in non-allocated sections,
such as the ".go_export" section used by some Go compilers [1], although I
imagine that in the future we could consider compiling parts of the module
(such as large non-inlinable functions) directly into the object file to
improve LTO efficiency.

[1] http://golang.org/doc/install/gccgo#Imports

[• rafael]

+ /// Returns 'true' if the bitcode bc is for the specified target triple.
+ static bool isTargetMatch(StringRef bc, const char *triplePrefix);

Using a StringRef is a nice independent improvement in here
(isTargetMatch), please commit it first. Nit: take the opportunity to
rename the argument names to match the llvm style.

LTOModule *LTOModule::createFromBuffer(const void *mem, size_t length,

                                     TargetOptions options,
                                     std::string &errMsg, StringRef path) {
std::unique_ptr<MemoryBuffer> buffer(makeBuffer(mem, length, path));
if (!buffer)
  return nullptr;

• return makeLTOModule(buffer.release(), options, errMsg);

+ return makeLTOModule(StringRef((const char *)mem, length), options, errMsg);

The buffer is not need in here anymore, is it?

• return makeLTOModule(buffer.release(), options, errMsg);

+ return makeLTOModule(buffer->getBuffer(), options, errMsg);

The MemoryBuffer is now destroyed immediately instead of being
transferred into the produced LTOModule. This would work with the
current setup, except you also do

• m->materializeAllPermanently();

Which means the IRReader will be pointed to unmapped memory, no?

BTW, the materializeAllPermanently is a very unfortunate but necessary
thing for the C api. The reason it is there is the way ld64 implements
an optimization:

• We want to avoid putting linkonce_odr symbols in the symbol table

unless their address is significant.

• The way ld64 implements this is being told for every symbol if it

can be dropped from the symbol table.

• To tell ld64 about that we need to look at every use of a symbol.
• To look at every use of a symbol we have to materialize all function

bodies since they may contain an use.

Two higher level questions about this approach:

• It is effectively a way of doing fat object files. GCC does

something similar. One small but recurring annoyance I had when
working with GCC LTO is that it can end up falling back silently to
non-LTO since tho outer container is ELF, with IR in a section. With
LLVM right now we get an error, since without our help the linker is
clueless as to what LLVM IR is. Can't you invert this? Put the ELF in
the IR (or even represent .go_export directly in some metadata) and
extent the gold plugin API to handle this? Another advantage is that
it should be easier to support fat COFF and MachO objects too.

• If we do need to go with IR in ELF instead of ELF in IR, we also

need to update lib/Object to handle it. We still want to get an
IRObjectFile (by default at least) when given one of those files so
that llvm-nm/llvm-ar do the right thing.

[pcc]

Rebase, add LLVMObject support

[• rafael]

It feels like these new format support should be documented somewhere. BitCodeFormat.rst maybe?

Also, an entry in the release notes would be nice.

include/llvm/Object/IRObjectFile.h

54 ↗

(On Diff #13563)

Some comments saying what these function do would be nice.

I wonder if findBitcodeIn... might be a more appropriate name. Not sure.

lib/LTO/LTOModule.cpp

109

I don't think we use auto for cases like this.

111

Is the empty check needed? It seems better to say that an empty section would be a broken bitcode. That is, this should return true and we would print an error afterwards.

114

It seems tempting to just get the buffer and forward to IRObjectFile::getBitcodeFromMemBuffer. Would avoid the duplicated switch over the type.

lib/Object/IRObjectFile.cpp

268 ↗

(On Diff #13563)

Maybe this should take an ObjectFile&?

271 ↗

(On Diff #13563)

You don't need the {

276 ↗

(On Diff #13563)

You don't need the {

lib/Object/SymbolicFile.cpp

65 ↗

(On Diff #13563)

Explicit type, not auto I think.

66 ↗

(On Diff #13563)

The empty check looks odd.

tools/gold/gold-plugin.cpp

551 ↗

(On Diff #13563)

You have to handle the case where we don't have a get_view (bfd using the plugin).

On trunk we create a BufferRef in both branches of the if, so you can probably just move this after the end of the else.

[pcc]

Address comments.

[pcc]

Added docs.

include/llvm/Object/IRObjectFile.h

54 ↗

(On Diff #13563)

Some comments saying what these function do would be nice.

Added.

I wonder if findBitcodeIn... might be a more appropriate name. Not sure.

Ok, I like that name better. Done.

lib/LTO/LTOModule.cpp

109

Changed.

111

Previously I returned an empty memory buffer from getBitcodeFromMemBuffer if the file was of the wrong type or there was no .llvmbc section present. That was a bad decision in retrospect; that function now returns error codes in those cases, which lets me drop the empty check here and elsewhere.

114

Done. Now that I think about it, the previous way wasn't saving us much.

lib/Object/IRObjectFile.cpp

268 ↗

(On Diff #13563)

It can even take a const ObjectFile &. Done.

271 ↗

(On Diff #13563)

Done.

276 ↗

(On Diff #13563)

Done.

lib/Object/SymbolicFile.cpp

65 ↗

(On Diff #13563)

Done.

66 ↗

(On Diff #13563)

Removed.

tools/gold/gold-plugin.cpp

551 ↗

(On Diff #13563)

Are you thinking of another function (claim_file_hook?) It looks like the code in this function (getModuleForFile) uses get_view unconditionally. I don't know if this is correct or not, but it seems to have worked up to now.

[• rafael]

LGTM with a nit.

test/tools/gold/bcsection.ll

5 ↗

(On Diff #13798)

Since the intention is to check that %T/bcsection.o is not just a copy of %T/bcsection.bco, how about extending this to:

llvm-nm -no-llvm-bc %T/bcsection.bco | FileCheck %s --check-prefix=NO-MAIN
lvm-nm %T/bcsection.bco | FileCheck %s
lvm-nm %T/bcsection.o| FileCheck %s

?

[pcc]

test/tools/gold/bcsection.ll

5 ↗

(On Diff #13798)

The first test seems useful (as a negative test for -no-llvm-bc); added.

The LTO test suite already has variations of the second test.

I don't see what the third one would accomplish. More specifically, I don't see how it could fail if "llvm-nm -no-llvm-bc %T/bcsection.o | FileCheck %s" passes. Maybe if the object file had an .llvmbc section whose bitcode does not define 'main'? But this seems unlikely.

[pcc]

Closed by commit rL218078 (authored by @pcc).

[echristo]

Hi Peter,

Sorry to perform some thread necromancy here, but I didn't see this go around the first time. What are you trying to accomplish with this? I'm not sure I see how this is necessary to push metadata around, but maybe I'm missing something. Can you explain a bit?

Thanks!

-eric

[pcc]

Hi Eric,

Have you seen my original proposal? (http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-July/074540.html) In the second paragraph in particular it explains how llgo uses this feature.

Peter

[echristo]

Hi Peter,

If the imports are for .o files and the bitcode is for before compilation
is complete? If it's post compilation then we'll have a .o file and can put
the metadata in as normal? Otherwise if we're using lazy compilation you'll
need to teach something how to read llvm-ir anyhow and so might as well not
bother storing it in an elf file?

I could easily be missing something of the compilation pipeline here.

-eric

include/llvm/LTO/LTOModule.h

private:
   void addObjCCategory(const GlobalVariable *clgv);
 
   /// Parse i386/ppc ObjC class list data structure.
   void addObjCClassRef(const GlobalVariable *clgv);
 
   /// Get string that the data pointer points to.
   bool objcClassNameFromExpression(const Constant *c, std::string &name);
 
-  /// Returns 'true' if the memory buffer is for the specified target triple.
-  static bool isTargetMatch(MemoryBuffer *memBuffer, const char *triplePrefix);
+  /// Returns 'true' if the bitcode bc is for the specified target triple.
+  static bool isTargetMatch(StringRef bc, const char *triplePrefix);
 
-  /// Create an LTOModule (private version). N.B. This method takes ownership of
-  /// the buffer.
-  static LTOModule *makeLTOModule(MemoryBuffer *buffer, TargetOptions options,
+  /// Create an LTOModule (private version).
+  static LTOModule *makeLTOModule(StringRef data, TargetOptions options,
                                   std::string &errMsg);
 
   /// Create a MemoryBuffer from a memory range with an optional name.
   static MemoryBuffer *makeBuffer(const void *mem, size_t length,
                                   StringRef name = "");
 };
 }
 #endif // LTO_MODULE_H

lib/LTO/LTOModule.cpp

 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetAsmParser.h"
 #include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Transforms/Utils/GlobalStatus.h"
 #include <system_error>
 using namespace llvm;
+using namespace llvm::object;
 
 LTOModule::LTOModule(llvm::Module *m, llvm::TargetMachine *t)
   : _module(m), _target(t),
     _context(_target->getMCAsmInfo(), _target->getRegisterInfo(), &ObjFileInfo),
     _mangler(t->getDataLayout()) {
   ObjFileInfo.InitMCObjectFileInfo(t->getTargetTriple(),
                                    t->getRelocationModel(), t->getCodeModel(),
                                    _context);
 }
 
+static StringRef getObjectBitcodeData(ObjectFile *obj,
+                                      std::string *errMsg = 0) {
+  for (auto sec : obj->sections()) {
+    StringRef secName;
+    if (std::error_code ec = sec.getName(secName)) {
+      if (errMsg)
+        *errMsg = ec.message();
+      return StringRef();
+    }
+    if (secName == ".llvmbc") {
+      StringRef secContents;
+      if (std::error_code ec = sec.getContents(secContents)) {
+        if (errMsg)
+          *errMsg = ec.message();
+        return StringRef();
+      }
+      return secContents;
+    }
+  }
+
+  if (errMsg)
+    *errMsg = "section .llvmbc not found";
+  return StringRef();
+}
+
+static StringRef getBitcodeData(StringRef str, std::string *errMsg = 0) {
+  switch (sys::fs::identify_magic(str)) {
+  case sys::fs::file_magic::bitcode:
+    return str;
+  case sys::fs::file_magic::elf_relocatable:
+  case sys::fs::file_magic::macho_object:
+  case sys::fs::file_magic::coff_object: {
+    std::unique_ptr<MemoryBuffer> buffer(
+        MemoryBuffer::getMemBuffer(str, "", false));
+    auto obj = ObjectFile::createObjectFile(buffer);
+    if (!obj) {
+      if (errMsg)
+        *errMsg = obj.getError().message();
+      return StringRef();
+    }
+    return getObjectBitcodeData(*obj, errMsg);
+  }
+  default:
+    return StringRef();
+  }
+}
+
 /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
 /// bitcode.
 bool LTOModule::isBitcodeFile(const void *mem, size_t length) {
-  return sys::fs::identify_magic(StringRef((const char *)mem, length)) ==
-         sys::fs::file_magic::bitcode;
+  return !getBitcodeData(StringRef((const char *)mem, length)).empty();
 }
 
 bool LTOModule::isBitcodeFile(const char *path) {
   sys::fs::file_magic type;
   if (sys::fs::identify_magic(path, type))
     return false;
-  return type == sys::fs::file_magic::bitcode;
+  switch (type) {
+  case sys::fs::file_magic::bitcode:
+    return true;
+  case sys::fs::file_magic::elf_relocatable:
+  case sys::fs::file_magic::macho_object:
+  case sys::fs::file_magic::coff_object: {
+    auto Obj = ObjectFile::createObjectFile(path);
+    if (!Obj)
+      return false;
+    return !getObjectBitcodeData(*Obj).empty();
+  }
+  default:
+    return false;
+  }
 }
 
 /// isBitcodeFileForTarget - Returns 'true' if the file (or memory contents) is
 /// LLVM bitcode for the specified triple.
 bool LTOModule::isBitcodeFileForTarget(const void *mem, size_t length,
                                        const char *triplePrefix) {
-  MemoryBuffer *buffer = makeBuffer(mem, length);
-  if (!buffer)
+  StringRef data =
+      getBitcodeData(StringRef((const char *)mem, length));
+  if (data.empty())
     return false;
-  return isTargetMatch(buffer, triplePrefix);
+  return isTargetMatch(data, triplePrefix);
 }
 
 bool LTOModule::isBitcodeFileForTarget(const char *path,
                                        const char *triplePrefix) {
   std::unique_ptr<MemoryBuffer> buffer;
   if (MemoryBuffer::getFile(path, buffer))
     return false;
-  return isTargetMatch(buffer.release(), triplePrefix);
+  StringRef data = getBitcodeData(buffer->getBuffer());
+  if (data.empty())
+    return false;
+  return isTargetMatch(data, triplePrefix);
 }
 
-/// isTargetMatch - Returns 'true' if the memory buffer is for the specified
+/// isTargetMatch - Returns 'true' if the bitcode bc is for the specified
 /// target triple.
-bool LTOModule::isTargetMatch(MemoryBuffer *buffer, const char *triplePrefix) {
-  std::string Triple = getBitcodeTargetTriple(buffer, getGlobalContext());
-  delete buffer;
+bool LTOModule::isTargetMatch(StringRef bc, const char *triplePrefix) {
+  std::unique_ptr<MemoryBuffer> buffer(
+      MemoryBuffer::getMemBuffer(bc, "", false));
+  std::string Triple = getBitcodeTargetTriple(buffer.get(), getGlobalContext());
   return strncmp(Triple.c_str(), triplePrefix, strlen(triplePrefix)) == 0;
 }
 
 /// makeLTOModule - Create an LTOModule. N.B. These methods take ownership of
 /// the buffer.
 LTOModule *LTOModule::createFromFile(const char *path, TargetOptions options,
                                      std::string &errMsg) {
   std::unique_ptr<MemoryBuffer> buffer;
   if (std::error_code ec = MemoryBuffer::getFile(path, buffer)) {
     errMsg = ec.message();
     return nullptr;
   }
-  return makeLTOModule(buffer.release(), options, errMsg);
+  return makeLTOModule(buffer->getBuffer(), options, errMsg);
 }
 
 LTOModule *LTOModule::createFromOpenFile(int fd, const char *path, size_t size,
                                          TargetOptions options,
                                          std::string &errMsg) {
   return createFromOpenFileSlice(fd, path, size, 0, options, errMsg);
 }
 
 LTOModule *LTOModule::createFromOpenFileSlice(int fd, const char *path,
                                               size_t map_size, off_t offset,
                                               TargetOptions options,
                                               std::string &errMsg) {
   std::unique_ptr<MemoryBuffer> buffer;
   if (std::error_code ec =
           MemoryBuffer::getOpenFileSlice(fd, path, buffer, map_size, offset)) {
     errMsg = ec.message();
     return nullptr;
   }
-  return makeLTOModule(buffer.release(), options, errMsg);
+  return makeLTOModule(buffer->getBuffer(), options, errMsg);
 }
 
 LTOModule *LTOModule::createFromBuffer(const void *mem, size_t length,
                                        TargetOptions options,
                                        std::string &errMsg, StringRef path) {
   std::unique_ptr<MemoryBuffer> buffer(makeBuffer(mem, length, path));
   if (!buffer)
     return nullptr;
-  return makeLTOModule(buffer.release(), options, errMsg);
+  return makeLTOModule(StringRef((const char *)mem, length), options, errMsg);
 }
 
-LTOModule *LTOModule::makeLTOModule(MemoryBuffer *buffer,
+LTOModule *LTOModule::makeLTOModule(StringRef data,
                                     TargetOptions options,
                                     std::string &errMsg) {
+  StringRef bc = getBitcodeData(data, &errMsg);
+  if (bc.empty())
+    return nullptr;
+
+  std::unique_ptr<MemoryBuffer> buffer(
+      MemoryBuffer::getMemBuffer(bc, "", false));
+
   // parse bitcode buffer
   ErrorOr<Module *> ModuleOrErr =
-      getLazyBitcodeModule(buffer, getGlobalContext());
+      parseBitcodeFile(buffer.get(), getGlobalContext());
   if (std::error_code EC = ModuleOrErr.getError()) {
     errMsg = EC.message();
-    delete buffer;
     return nullptr;
   }
   std::unique_ptr<Module> m(ModuleOrErr.get());
 
   std::string TripleStr = m->getTargetTriple();
   if (TripleStr.empty())
     TripleStr = sys::getDefaultTargetTriple();
   llvm::Triple Triple(TripleStr);
else if (Triple.getArch() == llvm::Triple::x86)
       CPU = "yonah";
     else if (Triple.getArch() == llvm::Triple::arm64 ||
              Triple.getArch() == llvm::Triple::aarch64)
       CPU = "cyclone";
   }
 
   TargetMachine *target = march->createTargetMachine(TripleStr, CPU, FeatureStr,
                                                      options);
-  m->materializeAllPermanently();
-
   LTOModule *Ret = new LTOModule(m.release(), target);
 
   // We need a MCContext set up in order to get mangled names of private
   // symbols. It is a bit odd that we need to report uses and definitions
   // of private symbols, but it does look like ld64 expects to be informed
   // of at least the ones with an 'l' prefix.
   MCContext &Context = Ret->_context;
   const TargetLoweringObjectFile &TLOF =

test/LTO/Inputs/bcsection.macho.s

+.section .llvmbc,.llvmbc
+.incbin "bcsection.bc"

test/LTO/Inputs/bcsection.s

+.section .llvmbc
+.incbin "bcsection.bc"

test/LTO/bcsection.ll

+; RUN: llvm-as -o %T/bcsection.bc %s
+
+; RUN: llvm-mc -I=%T -filetype=obj -triple=x86_64-pc-win32 -o %T/bcsection.coff.bco %p/Inputs/bcsection.s
+; RUN: llvm-lto -exported-symbol=main -o %T/bcsection.coff.o %T/bcsection.coff.bco
+; RUN: llvm-nm %T/bcsection.coff.o | FileCheck %s
+
+; RUN: llvm-mc -I=%T -filetype=obj -triple=x86_64-unknown-linux-gnu -o %T/bcsection.elf.bco %p/Inputs/bcsection.s
+; RUN: llvm-lto -exported-symbol=main -o %T/bcsection.elf.o %T/bcsection.elf.bco
+; RUN: llvm-nm %T/bcsection.elf.o | FileCheck %s
+
+; RUN: llvm-mc -I=%T -filetype=obj -triple=x86_64-apple-darwin11 -o %T/bcsection.macho.bco %p/Inputs/bcsection.macho.s
+; RUN: llvm-lto -exported-symbol=main -o %T/bcsection.macho.o %T/bcsection.macho.bco
+; RUN: llvm-nm %T/bcsection.macho.o | FileCheck %s
+
+; CHECK: main
+define i32 @main() {
+  ret i32 0
+}