[llvm-objcopy][MachO] Support ARM64_RELOC_ADDEND

[MaskRay]

Summary

An ARM64_RELOC_ADDEND relocation reuses the symbol field for the addend value.
We should pass through such relocations.

[alexander-shaposhnikov]

llvm/tools/llvm-objcopy/MachO/Object.h

183

Would be good to expand this comment a little bit explaining the specifics of such relocations
(basically mention that the symbol field actually stores the addend value)

[MaskRay]

improve comment

llvm/test/tools/llvm-objcopy/MachO/arm64-relocs.s

+# REQUIRES: aarch64-registered-target
+
+# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t
+# RUN: llvm-objcopy %t %t.copy
+# RUN: cmp %t %t.copy
+
+.text
+.globl _foo, _bar
+_foo:
+  ## ARM64_RELOC_ADDEND and ARM64_RELOC_BRANCH26
+  bl _bar + 123
+
+_bar:
+  ret
+
+.subsections_via_symbols

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

for (; reinterpret_cast<const void *>(Curr) < End; Curr++) {
     Expected<ArrayRef<uint8_t>> Data =
         MachOObj.getSectionContents(SecRef->getRawDataRefImpl());
     if (!Data)
       return Data.takeError();
 
     S.Content =
         StringRef(reinterpret_cast<const char *>(Data->data()), Data->size());
 
+    const uint32_t CPUType = MachOObj.getHeader().cputype;
     S.Relocations.reserve(S.NReloc);
     for (auto RI = MachOObj.section_rel_begin(SecRef->getRawDataRefImpl()),
               RE = MachOObj.section_rel_end(SecRef->getRawDataRefImpl());
          RI != RE; ++RI) {
       RelocationInfo R;
       R.Symbol = nullptr; // We'll fill this field later.
       R.Info = MachOObj.getRelocation(RI->getRawDataRefImpl());
       R.Scattered = MachOObj.isRelocationScattered(R.Info);
+      unsigned Type = MachOObj.getAnyRelocationType(R.Info);
+      // TODO Support CPU_TYPE_ARM.
+      R.IsAddend = !R.Scattered && (CPUType == MachO::CPU_TYPE_ARM64 &&
+                                    Type == MachO::ARM64_RELOC_ADDEND);
       R.Extern = !R.Scattered && MachOObj.getPlainRelocationExternal(R.Info);
       S.Relocations.push_back(R);
     }
 
     assert(S.NReloc == S.Relocations.size() &&
            "Incorrect number of relocations");
   }
   return std::move(Sections);
void MachOReader::setSymbolInRelocationInfo(Object &O) const {
   std::vector<const Section *> Sections;
   for (auto &LC : O.LoadCommands)
     for (std::unique_ptr<Section> &Sec : LC.Sections)
       Sections.push_back(Sec.get());
 
   for (LoadCommand &LC : O.LoadCommands)
     for (std::unique_ptr<Section> &Sec : LC.Sections)
       for (auto &Reloc : Sec->Relocations)
-        if (!Reloc.Scattered) {
+        if (!Reloc.Scattered && !Reloc.IsAddend) {
           const uint32_t SymbolNum =
               Reloc.getPlainRelocationSymbolNum(MachOObj.isLittleEndian());
           if (Reloc.Extern) {
             Reloc.Symbol = O.SymTable.getSymbolByIndex(SymbolNum);
           } else {
             // FIXME: Refactor error handling in MachOReader and report an error
             // if we encounter an invalid relocation.
             assert(SymbolNum >= 1 && SymbolNum <= Sections.size() &&

llvm/tools/llvm-objcopy/MachO/MachOWriter.cpp

for (const std::unique_ptr<Section> &Sec : LC.Sections) {
       }
 
       assert(Sec->Offset && "Section offset can not be zero");
       assert((Sec->Size == Sec->Content.size()) && "Incorrect section size");
       memcpy(Buf->getBufferStart() + Sec->Offset, Sec->Content.data(),
              Sec->Content.size());
       for (size_t Index = 0; Index < Sec->Relocations.size(); ++Index) {
         RelocationInfo RelocInfo = Sec->Relocations[Index];
-        if (!RelocInfo.Scattered) {
+        if (!RelocInfo.Scattered && !RelocInfo.IsAddend) {
           const uint32_t SymbolNum = RelocInfo.Extern
                                          ? (*RelocInfo.Symbol)->Index
                                          : (*RelocInfo.Sec)->Index;
           RelocInfo.setPlainRelocationSymbolNum(SymbolNum, IsLittleEndian);
         }
         if (IsLittleEndian != sys::IsLittleEndianHost)
           MachO::swapStruct(
               reinterpret_cast<MachO::any_relocation_info &>(RelocInfo.Info));

llvm/tools/llvm-objcopy/MachO/Object.h

 
 struct RelocationInfo {
   // The referenced symbol entry. Set if !Scattered && Extern.
   Optional<const SymbolEntry *> Symbol;
   // The referenced section. Set if !Scattered && !Extern.
   Optional<const Section *> Sec;
   // True if Info is a scattered_relocation_info.
   bool Scattered;
+  // True if the type is an ADDEND. r_symbolnum holds the addend instead of a
+  // symbol index.
+  bool IsAddend;
   // True if the r_symbolnum points to a section number (i.e. r_extern=0).
   bool Extern;
   MachO::any_relocation_info Info;
 
   unsigned getPlainRelocationSymbolNum(bool IsLittleEndian) {
     if (IsLittleEndian)
       return Info.r_word1 & 0xffffff;
     return Info.r_word1 >> 8;