[MachO] Update LLD to use 64-bit offsets with DataExtractor (3/5)

[ruiu]

LGTM

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

dataExtractorFromSection(const NormalizedFile &normalizedFile,
   const bool isBig = MachOLinkingContext::isBigEndian(normalizedFile.arch);
   StringRef SecData(reinterpret_cast<const char*>(S.content.data()),
                     S.content.size());
   return llvm::DataExtractor(SecData, !isBig, is64 ? 8 : 4);
 }
 
 // FIXME: Cribbed from llvm-dwp -- should share "lightweight CU DIE
 //        inspection" code if possible.
-static uint32_t getCUAbbrevOffset(llvm::DataExtractor abbrevData,
+static uint64_t getCUAbbrevOffset(llvm::DataExtractor abbrevData,
                                   uint64_t abbrCode) {
   uint64_t curCode;
-  uint32_t offset = 0;
+  uint64_t offset = 0;
   while ((curCode = abbrevData.getULEB128(&offset)) != abbrCode) {
     // Tag
     abbrevData.getULEB128(&offset);
     // DW_CHILDREN
     abbrevData.getU8(&offset);
     // Attributes
     while (abbrevData.getULEB128(&offset) | abbrevData.getULEB128(&offset))
       ;
   }
   return offset;
 }
 
 // FIXME: Cribbed from llvm-dwp -- should share "lightweight CU DIE
 //        inspection" code if possible.
 static Expected<const char *>
 getIndexedString(const NormalizedFile &normalizedFile,
                  llvm::dwarf::Form form, llvm::DataExtractor infoData,
-                 uint32_t &infoOffset, const Section &stringsSection) {
+                 uint64_t &infoOffset, const Section &stringsSection) {
   if (form == llvm::dwarf::DW_FORM_string)
    return infoData.getCStr(&infoOffset);
   if (form != llvm::dwarf::DW_FORM_strp)
     return llvm::make_error<GenericError>(
         "string field encoded without DW_FORM_strp");
-  uint32_t stringOffset = infoData.getU32(&infoOffset);
+  uint64_t stringOffset = infoData.getU32(&infoOffset);
   llvm::DataExtractor stringsData =
     dataExtractorFromSection(normalizedFile, stringsSection);
   return stringsData.getCStr(&stringOffset);
 }
 
 // FIXME: Cribbed from llvm-dwp -- should share "lightweight CU DIE
 //        inspection" code if possible.
 static llvm::Expected<TranslationUnitSource>
 readCompUnit(const NormalizedFile &normalizedFile,
              const Section &info,
              const Section &abbrev,
              const Section &strings,
              StringRef path) {
   // FIXME: Cribbed from llvm-dwp -- should share "lightweight CU DIE
   //        inspection" code if possible.
-  uint32_t offset = 0;
+  uint64_t offset = 0;
   llvm::dwarf::DwarfFormat Format = llvm::dwarf::DwarfFormat::DWARF32;
   auto infoData = dataExtractorFromSection(normalizedFile, info);
   uint32_t length = infoData.getU32(&offset);
   if (length == 0xffffffff) {
     Format = llvm::dwarf::DwarfFormat::DWARF64;
     infoData.getU64(&offset);
   }
   else if (length > 0xffffff00)
     return llvm::make_error<GenericError>("Malformed DWARF in " + path);
 
   uint16_t version = infoData.getU16(&offset);
 
   if (version < 2 || version > 4)
     return llvm::make_error<GenericError>("Unsupported DWARF version in " +
                                           path);
 
   infoData.getU32(&offset); // Abbrev offset (should be zero)
   uint8_t addrSize = infoData.getU8(&offset);
 
   uint32_t abbrCode = infoData.getULEB128(&offset);
   auto abbrevData = dataExtractorFromSection(normalizedFile, abbrev);
-  uint32_t abbrevOffset = getCUAbbrevOffset(abbrevData, abbrCode);
+  uint64_t abbrevOffset = getCUAbbrevOffset(abbrevData, abbrCode);
   uint64_t tag = abbrevData.getULEB128(&abbrevOffset);
   if (tag != llvm::dwarf::DW_TAG_compile_unit)
     return llvm::make_error<GenericError>("top level DIE is not a compile unit");
   // DW_CHILDREN
   abbrevData.getU8(&abbrevOffset);
   uint32_t name;
   llvm::dwarf::Form form;
   llvm::dwarf::FormParams formParams = {version, addrSize, Format};