[PECOFF] Add support for bigobj

[majnemer]

Summary

lld shouldn't directly use the COFF header nor should it use raw
coff_symbols. Instead, query the header properties from the
COFFObjectFile and use COFFSymbolRef to abstractly reference COFF
symbols.

This is just enough to get lld compiling with the changes to
llvm::object. Bigobj specific testing will come later.

[ruiu]

lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

364

Is this change valid? It depended on the fact that you can identify a symbol by its address, but I don't think after your change COFFSymbolRef is not guaranteed to be unique for a symbol.

[majnemer]

lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

364

I have COFFSymbolRef an operator< in LLVM.

[ruiu]

LGTM

[majnemer]

Closed by commit rL217497 (authored by @majnemer).

lib/ReaderWriter/PECOFF/ReaderCOFF.cpp

 using llvm::support::ulittle32_t;
 
 using namespace lld;
 
 namespace {
 
 class FileCOFF : public File {
 private:
-  typedef std::vector<const coff_symbol *> SymbolVectorT;
+  typedef std::vector<llvm::object::COFFSymbolRef> SymbolVectorT;
   typedef std::map<const coff_section *, SymbolVectorT> SectionToSymbolsT;
   typedef std::map<const StringRef, Atom *> SymbolNameToAtomT;
   typedef std::map<const coff_section *, std::vector<COFFDefinedFileAtom *>>
   SectionToAtomsT;
 
 public:
   typedef const std::map<std::string, std::string> StringMap;
 
public:
 
   void addUndefinedSymbol(StringRef sym) {
     _undefinedAtoms._atoms.push_back(new (_alloc) COFFUndefinedAtom(*this, sym));
   }
 
   mutable llvm::BumpPtrAllocator _alloc;
 
 private:
-  std::error_code readSymbolTable(std::vector<const coff_symbol *> &result);
+  std::error_code readSymbolTable(SymbolVectorT &result);
 
   void createAbsoluteAtoms(const SymbolVectorT &symbols,
                            std::vector<const AbsoluteAtom *> &result);
 
   std::error_code
   createUndefinedAtoms(const SymbolVectorT &symbols,
                        std::vector<const UndefinedAtom *> &result);
 
   std::error_code
   createDefinedSymbols(const SymbolVectorT &symbols,
                        std::vector<const DefinedAtom *> &result);
 
   std::error_code cacheSectionAttributes();
   std::error_code maybeCreateSXDataAtoms();
 
   std::error_code
   AtomizeDefinedSymbolsInSection(const coff_section *section,
-                                 std::vector<const coff_symbol *> &symbols,
+                                 SymbolVectorT &symbols,
                                  std::vector<COFFDefinedFileAtom *> &atoms);
 
   std::error_code
   AtomizeDefinedSymbols(SectionToSymbolsT &definedSymbols,
                         std::vector<const DefinedAtom *> &definedAtoms);
 
   std::error_code findAtomAt(const coff_section *section,
                              uint32_t targetAddress,
private:
   // The contents of .drectve section.
   StringRef _directives;
 
   // True if the object has "@feat.00" symbol.
   bool _compatibleWithSEH;
 
   // A map from symbol to its name. All symbols should be in this map except
   // unnamed ones.
-  std::map<const coff_symbol *, StringRef> _symbolName;
+  std::map<llvm::object::COFFSymbolRef, StringRef> _symbolName;
 
   // A map from symbol to its resultant atom.
-  std::map<const coff_symbol *, Atom *> _symbolAtom;
+  std::map<llvm::object::COFFSymbolRef, Atom *> _symbolAtom;
 
   // A map from symbol to its aux symbol.
-  std::map<const coff_symbol *, const coff_symbol *> _auxSymbol;
+  std::map<llvm::object::COFFSymbolRef, llvm::object::COFFSymbolRef> _auxSymbol;
 
   // A map from section to its atoms.
   std::map<const coff_section *, std::vector<COFFDefinedFileAtom *>>
   _sectionAtoms;
 
   // A set of COMDAT sections.
   std::set<const coff_section *> _comdatSections;
 
public:
   }
 
 private:
   llvm::BumpPtrAllocator _alloc;
   std::mutex _allocMutex;
 };
 
 // Converts the COFF symbol attribute to the LLD's atom attribute.
-Atom::Scope getScope(const coff_symbol *symbol) {
-  switch (symbol->StorageClass) {
+Atom::Scope getScope(llvm::object::COFFSymbolRef symbol) {
+  switch (symbol.getStorageClass()) {
   case llvm::COFF::IMAGE_SYM_CLASS_EXTERNAL:
     return Atom::scopeGlobal;
   case llvm::COFF::IMAGE_SYM_CLASS_STATIC:
   case llvm::COFF::IMAGE_SYM_CLASS_LABEL:
     return Atom::scopeTranslationUnit;
   }
   llvm_unreachable("Unknown scope");
 }
if (std::error_code ec = addRelocationReferenceToAtoms())
     return ec;
   if (std::error_code ec = maybeCreateSXDataAtoms())
     return ec;
   return std::error_code();
 }
 
 /// Iterate over the symbol table to retrieve all symbols.
 std::error_code
-FileCOFF::readSymbolTable(std::vector<const coff_symbol *> &result) {
-  const llvm::object::coff_file_header *header = nullptr;
-  if (std::error_code ec = _obj->getHeader(header))
-    return ec;
-
-  for (uint32_t i = 0, e = header->NumberOfSymbols; i != e; ++i) {
+FileCOFF::readSymbolTable(SymbolVectorT &result) {
+  for (uint32_t i = 0, e = _obj->getNumberOfSymbols(); i != e; ++i) {
     // Retrieve the symbol.
-    const coff_symbol *sym;
+    ErrorOr<llvm::object::COFFSymbolRef> sym = _obj->getSymbol(i);
     StringRef name;
-    if (std::error_code ec = _obj->getSymbol(i, sym))
+    if (std::error_code ec = sym.getError())
       return ec;
-    if (sym->SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
+    if (sym->getSectionNumber() == llvm::COFF::IMAGE_SYM_DEBUG)
       goto next;
-    result.push_back(sym);
+    result.push_back(*sym);
 
-    if (std::error_code ec = _obj->getSymbolName(sym, name))
+    if (std::error_code ec = _obj->getSymbolName(*sym, name))
       return ec;
 
     // Existence of the symbol @feat.00 indicates that object file is compatible
     // with Safe Exception Handling.
     if (name == "@feat.00") {
       _compatibleWithSEH = true;
       goto next;
     }
 
     // Cache the name.
-    _symbolName[sym] = name;
+    _symbolName[*sym] = name;
 
     // Symbol may be followed by auxiliary symbol table records. The aux
     // record can be in any format, but the size is always the same as the
     // regular symbol. The aux record supplies additional information for the
     // standard symbol. We do not interpret the aux record here, but just
     // store it to _auxSymbol.
-    if (sym->NumberOfAuxSymbols > 0) {
-      const coff_symbol *aux = nullptr;
-      if (std::error_code ec = _obj->getAuxSymbol(i + 1, aux))
+    if (sym->getNumberOfAuxSymbols() > 0) {
+      ErrorOr<llvm::object::COFFSymbolRef> aux = _obj->getSymbol(i + 1);
+      if (std::error_code ec = aux.getError())
         return ec;
-      _auxSymbol[sym] = aux;
+      _auxSymbol[*sym] = *aux;
     }
   next:
-    i += sym->NumberOfAuxSymbols;
+    i += sym->getNumberOfAuxSymbols();
   }
   return std::error_code();
 }
 
 /// Create atoms for the absolute symbols.
 void FileCOFF::createAbsoluteAtoms(const SymbolVectorT &symbols,
                                    std::vector<const AbsoluteAtom *> &result) {
-  for (const coff_symbol *sym : symbols) {
-    if (sym->SectionNumber != llvm::COFF::IMAGE_SYM_ABSOLUTE)
+  for (llvm::object::COFFSymbolRef sym : symbols) {
+    if (sym.getSectionNumber() != llvm::COFF::IMAGE_SYM_ABSOLUTE)
       continue;
-    auto *atom = new (_alloc)
-        COFFAbsoluteAtom(*this, _symbolName[sym], getScope(sym), sym->Value);
+    auto *atom = new (_alloc) COFFAbsoluteAtom(*this, _symbolName[sym],
+                                               getScope(sym), sym.getValue());
 
     result.push_back(atom);
     _symbolAtom[sym] = atom;
   }
 }
 
 /// Create atoms for the undefined symbols. This code is bit complicated
 /// because it supports "weak externals" mechanism of COFF. If an undefined
 /// symbol (sym1) has auxiliary data, the data contains a symbol table index
 /// at which the "second symbol" (sym2) for sym1 exists. If sym1 is resolved,
 /// it's linked normally. If not, sym1 is resolved as if it has sym2's
 /// name. This relationship between sym1 and sym2 is represented using
 /// fallback mechanism of undefined symbol.
 std::error_code
 FileCOFF::createUndefinedAtoms(const SymbolVectorT &symbols,
                                std::vector<const UndefinedAtom *> &result) {
   // Sort out undefined symbols from all symbols.
-  std::set<const coff_symbol *> undefines;
-  std::map<const coff_symbol *, const coff_symbol *> weakExternal;
-  for (const coff_symbol *sym : symbols) {
-    if (sym->SectionNumber != llvm::COFF::IMAGE_SYM_UNDEFINED)
+  std::set<llvm::object::COFFSymbolRef> undefines;
+  std::map<llvm::object::COFFSymbolRef, llvm::object::COFFSymbolRef>
+      weakExternal;
+  for (llvm::object::COFFSymbolRef sym : symbols) {
+    if (sym.getSectionNumber() != llvm::COFF::IMAGE_SYM_UNDEFINED)
       continue;
     undefines.insert(sym);
 
     // Create a mapping from sym1 to sym2, if the undefined symbol has
     // auxiliary data.
     auto iter = _auxSymbol.find(sym);
     if (iter == _auxSymbol.end())
       continue;
     const coff_aux_weak_external *aux =
-        reinterpret_cast<const coff_aux_weak_external *>(iter->second);
-    const coff_symbol *sym2;
-    if (std::error_code ec = _obj->getSymbol(aux->TagIndex, sym2))
+        reinterpret_cast<const coff_aux_weak_external *>(
+            iter->second.getRawPtr());
+    ErrorOr<llvm::object::COFFSymbolRef> sym2 = _obj->getSymbol(aux->TagIndex);
+    if (std::error_code ec = sym2.getError())
       return ec;
-    weakExternal[sym] = sym2;
+    weakExternal[sym] = *sym2;
   }
 
   // Sort out sym1s from sym2s. Sym2s shouldn't be added to the undefined atom
   // list because they shouldn't be resolved unless sym1 is failed to
   // be resolved.
   for (auto i : weakExternal)
     undefines.erase(i.second);
 
   // Create atoms for the undefined symbols.
-  for (const coff_symbol *sym : undefines) {
+  for (llvm::object::COFFSymbolRef sym : undefines) {
     // If the symbol has sym2, create an undefiend atom for sym2, so that we
     // can pass it as a fallback atom.
     UndefinedAtom *fallback = nullptr;
     auto iter = weakExternal.find(sym);
     if (iter != weakExternal.end()) {
-      const coff_symbol *sym2 = iter->second;
+      llvm::object::COFFSymbolRef sym2 = iter->second;
       fallback = new (_alloc) COFFUndefinedAtom(*this, _symbolName[sym2]);
       _symbolAtom[sym2] = fallback;
     }
 
     // Create an atom for the symbol.
     auto *atom =
         new (_alloc) COFFUndefinedAtom(*this, _symbolName[sym], fallback);
     result.push_back(atom);
FileCOFF::createDefinedSymbols(const SymbolVectorT &symbols,
   // to be merged. In COFF, it's not very easy to get the section attribute
   // for the symbol, so scan all sections in advance and cache the attributes
   // for later use.
   if (std::error_code ec = cacheSectionAttributes())
     return ec;
 
   // Filter non-defined atoms, and group defined atoms by its section.
   SectionToSymbolsT definedSymbols;
-  for (const coff_symbol *sym : symbols) {
+  for (llvm::object::COFFSymbolRef sym : symbols) {
     // A symbol with section number 0 and non-zero value represents a common
     // symbol. The MS COFF spec did not give a definition of what the common
     // symbol is. We should probably follow ELF's definition shown below.
     //
     // - If one object file has a common symbol and another has a definition,
     //   the common symbol is treated as an undefined reference.
     // - If there is no definition for a common symbol, the program linker
     //   acts as though it saw a definition initialized to zero of the
     //   appropriate size.
     // - Two object files may have common symbols of
     //   different sizes, in which case the program linker will use the
     //   largest size.
     //
     // FIXME: We are currently treating the common symbol as a normal
     // mergeable atom. Implement the above semantcis.
-    if (sym->SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED &&
-        sym->Value > 0) {
+    if (sym.getSectionNumber() == llvm::COFF::IMAGE_SYM_UNDEFINED &&
+        sym.getValue() > 0) {
       StringRef name = _symbolName[sym];
-      uint32_t size = sym->Value;
+      uint32_t size = sym.getValue();
       auto *atom = new (_alloc)
           COFFBSSAtom(*this, name, getScope(sym), DefinedAtom::permRW_,
                       DefinedAtom::mergeAsWeakAndAddressUsed, size, _ordinal++);
 
       // Common symbols should be aligned on natural boundaries with the maximum
       // of 32 byte. It's not documented anywhere, but it's what MSVC link.exe
       // seems to be doing.
       uint64_t alignment = std::min((uint64_t)32, llvm::NextPowerOf2(size));
       atom->setAlignment(
           DefinedAtom::Alignment(llvm::countTrailingZeros(alignment)));
       result.push_back(atom);
       continue;
     }
 
     // Skip if it's not for defined atom.
-    if (sym->SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG ||
-        sym->SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE ||
-        sym->SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED)
+    if (sym.getSectionNumber() == llvm::COFF::IMAGE_SYM_DEBUG ||
+        sym.getSectionNumber() == llvm::COFF::IMAGE_SYM_ABSOLUTE ||
+        sym.getSectionNumber() == llvm::COFF::IMAGE_SYM_UNDEFINED)
       continue;
 
     const coff_section *sec;
-    if (std::error_code ec = _obj->getSection(sym->SectionNumber, sec))
+    if (std::error_code ec = _obj->getSection(sym.getSectionNumber(), sec))
       return ec;
     assert(sec && "SectionIndex > 0, Sec must be non-null!");
 
     // Skip if it's a section symbol for a COMDAT section. A section symbol
     // has the name of the section and value 0. A translation unit may contain
     // multiple COMDAT sections whose section name are the same. We don't want
     // to make atoms for them as they would become duplicate symbols.
     StringRef sectionName;
     if (std::error_code ec = _obj->getSectionName(sec, sectionName))
       return ec;
-    if (_symbolName[sym] == sectionName && sym->Value == 0 &&
+    if (_symbolName[sym] == sectionName && sym.getValue() == 0 &&
         _merge[sec] != DefinedAtom::mergeNo)
       continue;
 
-    uint8_t sc = sym->StorageClass;
+    uint8_t sc = sym.getStorageClass();
     if (sc != llvm::COFF::IMAGE_SYM_CLASS_EXTERNAL &&
         sc != llvm::COFF::IMAGE_SYM_CLASS_STATIC &&
         sc != llvm::COFF::IMAGE_SYM_CLASS_FUNCTION &&
         sc != llvm::COFF::IMAGE_SYM_CLASS_LABEL) {
       llvm::errs() << "Unable to create atom for: " << _symbolName[sym] << " ("
                    << static_cast<int>(sc) << ")\n";
       return llvm::object::object_error::parse_failed;
     }

 // section can be merged or not.
 std::error_code FileCOFF::cacheSectionAttributes() {
   // The COMDAT section attribute is not an attribute of coff_section, but is
   // stored in the auxiliary symbol for the first symbol referring a COMDAT
   // section. It feels to me that it's unnecessarily complicated, but this is
   // how COFF works.
   for (auto i : _auxSymbol) {
     // Read a section from the file
-    const coff_symbol *sym = i.first;
-    if (sym->SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE ||
-        sym->SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED)
+    llvm::object::COFFSymbolRef sym = i.first;
+    if (sym.getSectionNumber() == llvm::COFF::IMAGE_SYM_ABSOLUTE ||
+        sym.getSectionNumber() == llvm::COFF::IMAGE_SYM_UNDEFINED)
       continue;
 
     const coff_section *sec;
-    if (std::error_code ec = _obj->getSection(sym->SectionNumber, sec))
+    if (std::error_code ec = _obj->getSection(sym.getSectionNumber(), sec))
       return ec;
     const coff_aux_section_definition *aux =
-        reinterpret_cast<const coff_aux_section_definition *>(i.second);
+        reinterpret_cast<const coff_aux_section_definition *>(
+            i.second.getRawPtr());
 
     if (sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_COMDAT) {
       // Read aux symbol data.
       _comdatSections.insert(sec);
       _merge[sec] = getMerge(aux);
     }
 
     // Handle associative sections.
if (!_merge.count(sec))
       _merge[sec] = DefinedAtom::mergeNo;
   }
   return std::error_code();
 }
 
 /// Atomize \p symbols and append the results to \p atoms. The symbols are
 /// assumed to have been defined in the \p section.
 std::error_code FileCOFF::AtomizeDefinedSymbolsInSection(
-    const coff_section *section, std::vector<const coff_symbol *> &symbols,
+    const coff_section *section, SymbolVectorT &symbols,
     std::vector<COFFDefinedFileAtom *> &atoms) {
   // Sort symbols by position.
   std::stable_sort(
       symbols.begin(), symbols.end(),
       // For some reason MSVC fails to allow the lambda in this context with a
       // "illegal use of local type in type instantiation". MSVC is clearly
       // wrong here. Force a conversion to function pointer to work around.
-      static_cast<bool (*)(const coff_symbol *, const coff_symbol *)>(
-          [](const coff_symbol *a, const coff_symbol *b)
-              -> bool { return a->Value < b->Value; }));
+      static_cast<bool (*)(llvm::object::COFFSymbolRef,
+                           llvm::object::COFFSymbolRef)>(
+          [](llvm::object::COFFSymbolRef a, llvm::object::COFFSymbolRef b)
+              -> bool { return a.getValue() < b.getValue(); }));
 
   StringRef sectionName;
   if (std::error_code ec = _obj->getSectionName(section, sectionName))
     return ec;
 
   // BSS section does not have contents. If this is the BSS section, create
   // COFFBSSAtom instead of COFFDefinedAtom.
   if (section->Characteristics & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) {
     for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
-      const coff_symbol *sym = *si;
-      uint32_t size = (si + 1 == se) ? section->SizeOfRawData - sym->Value
-                                     : si[1]->Value - sym->Value;
+      llvm::object::COFFSymbolRef sym = *si;
+      uint32_t size = (si + 1 == se) ? section->SizeOfRawData - sym.getValue()
+                                     : si[1].getValue() - sym.getValue();
       auto *atom = new (_alloc) COFFBSSAtom(
           *this, _symbolName[sym], getScope(sym), getPermissions(section),
           DefinedAtom::mergeAsWeakAndAddressUsed, size, _ordinal++);
       atoms.push_back(atom);
       _symbolAtom[sym] = atom;
     }
     return std::error_code();
   }
auto *atom = new (_alloc) COFFDefinedAtom(
         perms, _merge[section], data, _ordinal++);
     atoms.push_back(atom);
     _definedAtomLocations[section][0].push_back(atom);
     return std::error_code();
   }
 
   // Create an unnamed atom if the first atom isn't at the start of the
   // section.
-  if (symbols[0]->Value != 0) {
-    uint64_t size = symbols[0]->Value;
+  if (symbols[0].getValue() != 0) {
+    uint64_t size = symbols[0].getValue();
     ArrayRef<uint8_t> data(secData.data(), size);
     auto *atom = new (_alloc) COFFDefinedAtom(
         *this, "", sectionName, Atom::scopeTranslationUnit, type, isComdat,
         perms, _merge[section], data, _ordinal++);
     atoms.push_back(atom);
     _definedAtomLocations[section][0].push_back(atom);
   }
 
   for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) {
-    const uint8_t *start = secData.data() + (*si)->Value;
+    const uint8_t *start = secData.data() + si->getValue();
     // if this is the last symbol, take up the remaining data.
     const uint8_t *end = (si + 1 == se) ? secData.data() + secData.size()
-                                        : secData.data() + (*(si + 1))->Value;
+                                        : secData.data() + (si + 1)->getValue();
     ArrayRef<uint8_t> data(start, end);
     auto *atom = new (_alloc) COFFDefinedAtom(
         *this, _symbolName[*si], sectionName, getScope(*si), type, isComdat,
         perms, _merge[section], data, _ordinal++);
     atoms.push_back(atom);
     _symbolAtom[*si] = atom;
-    _definedAtomLocations[section][(*si)->Value].push_back(atom);
+    _definedAtomLocations[section][si->getValue()].push_back(atom);
   }
   return std::error_code();
 }
 
 std::error_code FileCOFF::AtomizeDefinedSymbols(
     SectionToSymbolsT &definedSymbols,
     std::vector<const DefinedAtom *> &definedAtoms) {
   // For each section, make atoms for all the symbols defined in the
   // section, and append the atoms to the result objects.
   for (auto &i : definedSymbols) {
     const coff_section *section = i.first;
-    std::vector<const coff_symbol *> &symbols = i.second;
+    SymbolVectorT &symbols = i.second;
     std::vector<COFFDefinedFileAtom *> atoms;
     if (std::error_code ec =
             AtomizeDefinedSymbolsInSection(section, symbols, atoms))
       return ec;
 
     // Set alignment to the first atom so that the section contents
     // will be aligned as specified by the object section header.
     if (atoms.size() > 0)
std::error_code FileCOFF::findAtomAt(const coff_section *section,
   }
   // Relocation target is out of range
   return llvm::object::object_error::parse_failed;
 }
 
 /// Find the atom for the symbol that was at the \p index in the symbol
 /// table.
 std::error_code FileCOFF::getAtomBySymbolIndex(uint32_t index, Atom *&ret) {
-  const coff_symbol *symbol;
-  if (std::error_code ec = _obj->getSymbol(index, symbol))
+  ErrorOr<llvm::object::COFFSymbolRef> symbol = _obj->getSymbol(index);
+  if (std::error_code ec = symbol.getError())
     return ec;
-  ret = _symbolAtom[symbol];
+  ret = _symbolAtom[*symbol];
   assert(ret);
   return std::error_code();
 }
 
 /// Add relocation information to an atom based on \p rel. \p rel is an
 /// relocation entry for the \p section, and \p atoms are all the atoms
 /// defined in the \p section.
 std::error_code FileCOFF::addRelocationReference(
if (!section)
     return std::error_code();
   if (std::error_code ec = _obj->getSectionContents(section, result))
     return ec;
   return std::error_code();
 }
 
 /// Returns the target machine type of the current object file.
 std::error_code FileCOFF::getReferenceArch(Reference::KindArch &result) {
-  const llvm::object::coff_file_header *header = nullptr;
-  if (std::error_code ec = _obj->getHeader(header))
-    return ec;
-  switch (header->Machine) {
+  switch (_obj->getMachine()) {
   case llvm::COFF::IMAGE_FILE_MACHINE_I386:
     result = Reference::KindArch::x86;
     return std::error_code();
   case llvm::COFF::IMAGE_FILE_MACHINE_AMD64:
     result = Reference::KindArch::x86_64;
     return std::error_code();
   case llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN:
     result = Reference::KindArch::all;
     return std::error_code();
   }
-  llvm::errs() << "Unsupported machine type: " << header->Machine << "\n";
+  llvm::errs() << "Unsupported machine type: " << _obj->getMachine() << '\n';
   return llvm::object::object_error::parse_failed;
 }
 
 std::error_code FileCOFF::is64(bool &result) {
-  const llvm::object::coff_file_header *header = nullptr;
-  if (std::error_code ec = _obj->getHeader(header))
-    return ec;
-  result = (header->Machine == llvm::COFF::IMAGE_FILE_MACHINE_AMD64);
+  result = (_obj->getMachine() == llvm::COFF::IMAGE_FILE_MACHINE_AMD64);
   return std::error_code();
 }
 
 /// Add relocation information to atoms.
 std::error_code FileCOFF::addRelocationReferenceToAtoms() {
   // Relocation entries are defined for each section.
   for (const auto &sec : _obj->sections()) {
     const coff_section *section = _obj->getCOFFSection(sec);