Implement support for __llvm_addrsig for MachO in llvm-mc

[alx32]

Summary

The __llvm_addrsig section is a section that the linker needs for safe icf.
This was not yet implemented for MachO - this is the implementation.
It has been tested with a safe deduplication implementation inside lld.

[smeenai]

Adding some more MC reviewers.

You're missing a test case. You should also upload the patch with context (arc does this for you automatically, otherwise use git diff -U99999 if uploading a patch manually).

[MaskRay]

llvm/include/llvm/BinaryFormat/MachO.h

178 ↗

(On Diff #422707)

The values may be defined by Apple. We cannot randomly grab a value.

[tschuett]

llvm/include/llvm/BinaryFormat/MachO.h

176 ↗

(On Diff #422707)

This one is in my local loader.h. S_ADDRSIG is not there.

[smeenai]

D112160 is a similar recent example of adding a custom Mach-O section, and it might be a good reference for adding a test and assigning a section identifier.

[alx32]

Add unit test & address section ID comments

[int3]

llvm/test/MC/MachO/addrsig-macho.ll

6

similar to my comment on D123752, let's minimize this test case

118

would be nice to follow up with a diff that teaches objdump to properly dump this section

[int3]

@MaskRay do you feel comfortable reviewing this?

[MaskRay]

Placing code gen test/MC

llvm/include/llvm/MC/MCObjectWriter.h

37

Moving the small boolean variable after the vector. If someone adds more smaller variables to the class in the future, it will make the class size smaller.

llvm/lib/MC/MachObjectWriter.cpp

767

*fragmentList.begin() the dereference has implied that it can't be nullptr, so assert can be removed.

773

drop brace

llvm/test/MC/MachO/addrsig-macho.ll

55

CodeGen/X86/addrsig.ll has some interesting IR objects which may be worth adding here. It seems to me that CodeGen may be a better directory.

[ayermolo]

llvm/lib/MC/MCMachOStreamer.cpp

34

I think this snuck in?

llvm/lib/MC/MachObjectWriter.cpp

760

replace with actual type

[alx32]

@MaskRay, @ayermolo - Addressed all feedback, could you have a look again ? Thanks!

[MaskRay]

llvm/lib/MC/MachObjectWriter.cpp

765

delete the blank line

llvm/test/CodeGen/AArch64/addrsig-macho.ll

5 ↗

(On Diff #425054)

[ayermolo]

lgtm

llvm/include/llvm/MC/MCMachObjectWriter.h

bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                               bool InSet) const override;
 
   bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                               const MCSymbol &SymA,
                                               const MCFragment &FB, bool InSet,
                                               bool IsPCRel) const override;
 
   uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
+
+  void writeAddrsigSection(MCAssembler &Asm);
 };
 
 /// Construct a new Mach-O writer instance.
 ///
 /// This routine takes ownership of the target writer subclass.
 ///
 /// \param MOTW - The target specific Mach-O writer subclass.
 /// \param OS - The stream to write to.
 /// \returns The constructed object writer.
 std::unique_ptr<MCObjectWriter>
 createMachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
                        raw_pwrite_stream &OS, bool IsLittleEndian);
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCMACHOBJECTWRITER_H

llvm/include/llvm/MC/MCObjectFileInfo.h

protected:
   MCSection *DataCommonSection = nullptr;
   MCSection *DataBSSSection = nullptr;
   MCSection *FourByteConstantSection = nullptr;
   MCSection *EightByteConstantSection = nullptr;
   MCSection *SixteenByteConstantSection = nullptr;
   MCSection *LazySymbolPointerSection = nullptr;
   MCSection *NonLazySymbolPointerSection = nullptr;
   MCSection *ThreadLocalPointerSection = nullptr;
+  MCSection *AddrSigSection = nullptr;
 
   /// COFF specific sections.
   MCSection *DrectveSection = nullptr;
   MCSection *PDataSection = nullptr;
   MCSection *XDataSection = nullptr;
   MCSection *SXDataSection = nullptr;
   MCSection *GEHContSection = nullptr;
   MCSection *GFIDsSection = nullptr;
MCSection *getLazySymbolPointerSection() const {
     return LazySymbolPointerSection;
   }
   MCSection *getNonLazySymbolPointerSection() const {
     return NonLazySymbolPointerSection;
   }
   MCSection *getThreadLocalPointerSection() const {
     return ThreadLocalPointerSection;
   }
+  MCSection *getAddrSigSection() const { return AddrSigSection; }
 
   // COFF specific sections.
   MCSection *getDrectveSection() const { return DrectveSection; }
   MCSection *getPDataSection() const { return PDataSection; }
   MCSection *getXDataSection() const { return XDataSection; }
   MCSection *getSXDataSection() const { return SXDataSection; }
   MCSection *getGEHContSection() const { return GEHContSection; }
   MCSection *getGFIDsSection() const { return GFIDsSection; }

llvm/include/llvm/MC/MCObjectWriter.h

 //===- llvm/MC/MCObjectWriter.h - Object File Writer Interface --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCOBJECTWRITER_H
 #define LLVM_MC_MCOBJECTWRITER_H
 
 #include "llvm/ADT/Triple.h"
+#include "llvm/MC/MCSymbol.h"
 #include <cstdint>
 
 namespace llvm {
 
 class MCAsmLayout;
 class MCAssembler;
 class MCFixup;
 class MCFragment;
 class MCSymbol;
 class MCSymbolRefExpr;
 class MCValue;
 
 /// Defines the object file and target independent interfaces used by the
 /// assembler backend to write native file format object files.
 ///
 /// The object writer contains a few callbacks used by the assembler to allow
 /// the object writer to modify the assembler data structures at appropriate
 /// points. Once assembly is complete, the object writer is given the
 /// MCAssembler instance, which contains all the symbol and section data which
 /// should be emitted as part of writeObject().
 class MCObjectWriter {
 protected:
+  bool EmitAddrsigSection = false;
+  std::vector<const MCSymbol *> AddrsigSyms;
+
   MCObjectWriter() = default;
 
 public:
   MCObjectWriter(const MCObjectWriter &) = delete;
   MCObjectWriter &operator=(const MCObjectWriter &) = delete;
   virtual ~MCObjectWriter();
 
   /// lifetime management
virtual bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
                                                       bool IsPCRel) const;
 
   /// ELF only. Mark that we have seen GNU ABI usage (e.g. SHF_GNU_RETAIN).
   virtual void markGnuAbi() {}
 
   /// Tell the object writer to emit an address-significance table during
   /// writeObject(). If this function is not called, all symbols are treated as
   /// address-significant.
-  virtual void emitAddrsigSection() {}
+  void emitAddrsigSection() { EmitAddrsigSection = true; }
+
+  bool getEmitAddrsigSection() { return EmitAddrsigSection; }
 
   /// Record the given symbol in the address-significance table to be written
   /// diring writeObject().
-  virtual void addAddrsigSymbol(const MCSymbol *Sym) {}
+  void addAddrsigSymbol(const MCSymbol *Sym) { AddrsigSyms.push_back(Sym); }
+
+  std::vector<const MCSymbol *> &getAddrsigSyms() { return AddrsigSyms; }
 
   /// Write the object file and returns the number of bytes written.
   ///
   /// This routine is called by the assembler after layout and relaxation is
   /// complete, fixups have been evaluated and applied, and relocations
   /// generated.
   virtual uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) = 0;
 

llvm/lib/MC/ELFObjectWriter.cpp

class ELFObjectWriter : public MCObjectWriter {
   /// The target specific ELF writer instance.
   std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
 
   DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>> Relocations;
 
   DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;
 
   bool SeenGnuAbi = false;
-  bool EmitAddrsigSection = false;
-  std::vector<const MCSymbol *> AddrsigSyms;
 
   bool hasRelocationAddend() const;
 
   bool shouldRelocateWithSymbol(const MCAssembler &Asm,
                                 const MCSymbolRefExpr *RefA,
                                 const MCSymbolELF *Sym, uint64_t C,
                                 unsigned Type) const;
 
void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void executePostLayoutBinding(MCAssembler &Asm,
                                 const MCAsmLayout &Layout) override;
 
   void markGnuAbi() override { SeenGnuAbi = true; }
   bool seenGnuAbi() const { return SeenGnuAbi; }
-  void emitAddrsigSection() override { EmitAddrsigSection = true; }
-  void addAddrsigSymbol(const MCSymbol *Sym) override {
-    AddrsigSyms.push_back(Sym);
-  }
 
   friend struct ELFWriter;
 };
 
 class ELFSingleObjectWriter : public ELFObjectWriter {
   raw_pwrite_stream &OS;
   bool IsLittleEndian;
 

llvm/lib/MC/MCMachOStreamer.cpp

 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <vector>
 
 namespace llvm {
 class MCInst;
 class MCStreamer;
 class MCSubtargetInfo;
void emitCGProfileEntry(const MCSymbolRefExpr *From,
     if (!From->getSymbol().isTemporary() && !To->getSymbol().isTemporary())
       getAssembler().CGProfile.push_back({From, To, Count});
   }
 
   void finishImpl() override;
 
   void finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE);
   void finalizeCGProfile();
+  void createAddrSigSection();
 };
 
 } // end anonymous namespace.
 
 static bool canGoAfterDWARF(const MCSectionMachO &MSec) {
   // These sections are created by the assembler itself after the end of
   // the .s file.
   StringRef SegName = MSec.getSegmentName();
for (MCFragment &Frag : Sec) {
       if (const MCSymbol *Symbol = DefiningSymbolMap.lookup(&Frag))
         CurrentAtom = Symbol;
       Frag.setAtom(CurrentAtom);
     }
   }
 
   finalizeCGProfile();
 
+  createAddrSigSection();
   this->MCObjectStreamer::finishImpl();
 }
 
 void MCMachOStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
   const MCSymbol *S = &SRE->getSymbol();
   bool Created;
   getAssembler().registerSymbol(*S, &Created);
   if (Created)
MCStreamer *llvm::createMachOStreamer(MCContext &Context,
   S->emitVersionForTarget(
       Target, Context.getObjectFileInfo()->getSDKVersion(),
       Context.getObjectFileInfo()->getDarwinTargetVariantTriple(),
       Context.getObjectFileInfo()->getDarwinTargetVariantSDKVersion());
   if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;
 }
+
+// Create the AddrSig section and first data fragment here as its layout needs
+// to be computed immediately after in order for it to be exported correctly.
+void MCMachOStreamer::createAddrSigSection() {
+  MCAssembler &Asm = getAssembler();
+  MCObjectWriter &writer = Asm.getWriter();
+  if (!writer.getEmitAddrsigSection())
+    return;
+  MCSection *AddrSigSection =
+      Asm.getContext().getObjectFileInfo()->getAddrSigSection();
+  Asm.registerSection(*AddrSigSection);
+  new MCDataFragment(AddrSigSection);
+}

llvm/lib/MC/MCObjectFileInfo.cpp

= Ctx->getMachOSection("__DATA", "__nl_symbol_ptr",
                            MachO::S_NON_LAZY_SYMBOL_POINTERS,
                            SectionKind::getMetadata());
 
   ThreadLocalPointerSection
     = Ctx->getMachOSection("__DATA", "__thread_ptr",
                            MachO::S_THREAD_LOCAL_VARIABLE_POINTERS,
                            SectionKind::getMetadata());
 
+  AddrSigSection = Ctx->getMachOSection("__DATA", "__llvm_addrsig", 0,
+                                        SectionKind::getData());
+
   // Exception Handling.
   LSDASection = Ctx->getMachOSection("__TEXT", "__gcc_except_tab", 0,
                                      SectionKind::getReadOnlyWithRel());
 
   COFFDebugSymbolsSection = nullptr;
   COFFDebugTypesSection = nullptr;
   COFFGlobalTypeHashesSection = nullptr;
 

llvm/lib/MC/MachObjectWriter.cpp

 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCFragment.h"
 #include "llvm/MC/MCMachObjectWriter.h"
+#include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolMachO.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <string>
 #include <utility>
 #include <vector>
static MachO::LoadCommandType getLCFromMCVM(MCVersionMinType Type) {
   case MCVM_OSXVersionMin:     return MachO::LC_VERSION_MIN_MACOSX;
   case MCVM_IOSVersionMin:     return MachO::LC_VERSION_MIN_IPHONEOS;
   case MCVM_TvOSVersionMin:    return MachO::LC_VERSION_MIN_TVOS;
   case MCVM_WatchOSVersionMin: return MachO::LC_VERSION_MIN_WATCHOS;
   }
   llvm_unreachable("Invalid mc version min type");
 }
 
+// Encode addrsig data as symbol indexes in variable length encoding.
+void MachObjectWriter::writeAddrsigSection(MCAssembler &Asm) {
+  MCSection *AddrSigSection =
+      Asm.getContext().getObjectFileInfo()->getAddrSigSection();
+  auto &fragmentList = AddrSigSection->getFragmentList();
+  if (!fragmentList.size())
+    return;
+
+  assert(fragmentList.size() == 1);
+
+  MCFragment *pFragment = &*fragmentList.begin();
+  assert(pFragment);
+  MCDataFragment *pDataFragment = dyn_cast_or_null<MCDataFragment>(pFragment);
+  assert(pDataFragment);
+
+  raw_svector_ostream OS(pDataFragment->getContents());
+  for (const MCSymbol *sym : this->getAddrsigSyms()) {
+    encodeULEB128(sym->getIndex(), OS);
+  }
+}
+
 uint64_t MachObjectWriter::writeObject(MCAssembler &Asm,
                                        const MCAsmLayout &Layout) {
   uint64_t StartOffset = W.OS.tell();
 
   // Compute symbol table information and bind symbol indices.
   computeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
                      UndefinedSymbolData);
+  writeAddrsigSection(Asm);
 
   if (!Asm.CGProfile.empty()) {
     MCSection *CGProfileSection = Asm.getContext().getMachOSection(
         "__LLVM", "__cg_profile", 0, SectionKind::getMetadata());
     MCDataFragment *Frag = dyn_cast_or_null<MCDataFragment>(
         &*CGProfileSection->getFragmentList().begin());
     assert(Frag && "call graph profile section not reserved");
     Frag->getContents().clear();

llvm/lib/MC/WinCOFFObjectWriter.cpp

public:
   section_map SectionMap;
   symbol_map SymbolMap;
 
   symbol_list WeakDefaults;
 
   bool UseBigObj;
   bool UseOffsetLabels = false;
 
-  bool EmitAddrsigSection = false;
   MCSectionCOFF *AddrsigSection;
-  std::vector<const MCSymbol *> AddrsigSyms;
 
   MCSectionCOFF *CGProfileSection = nullptr;
 
   WinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
                       raw_pwrite_stream &OS);
 
   void reset() override {
     memset(&Header, 0, sizeof(Header));
void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void createFileSymbols(MCAssembler &Asm);
   void setWeakDefaultNames();
   void assignSectionNumbers();
   void assignFileOffsets(MCAssembler &Asm, const MCAsmLayout &Layout);
 
-  void emitAddrsigSection() override { EmitAddrsigSection = true; }
-  void addAddrsigSymbol(const MCSymbol *Sym) override {
-    AddrsigSyms.push_back(Sym);
-  }
-
   uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
 };
 
 } // end anonymous namespace
 
 //------------------------------------------------------------------------------
 // Symbol class implementation
 

llvm/test/MC/MachO/addrsig-macho.ll

+; RUN: llc -filetype=asm %s -o - -mtriple arm64-apple-ios -addrsig | FileCheck %s
+; RUN: llc -filetype=obj %s -o %t -mtriple arm64-apple-ios -addrsig
+; RUN: llvm-readobj --hex-dump='__llvm_addrsig' %t | FileCheck %s --check-prefix=OBJ
+
+; CHECK:  .addrsig
+; CHECK-NEXT: .addrsig_sym _func03_takeaddr
+; CHECK-NEXT: .addrsig_sym _result
+; OBJ: Hex dump of section '__llvm_addrsig':
+; OBJ-NEXT:0x{{[0-9a-f]*}}
+
+target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
+target triple = "arm64-apple-ios7.0.0"
+
+@result = global i32 0, align 4
+
+; Function Attrs: minsize nofree noinline norecurse nounwind optsize ssp uwtable
+define void @func01() local_unnamed_addr #0 {
+entry:
+  %0 = load volatile i32, ptr @result, align 4
+  %add = add nsw i32 %0, 1
+  store volatile i32 %add, ptr @result, align 4
+  ret void
+}
+
+; Function Attrs: minsize nofree noinline norecurse nounwind optsize ssp uwtable
+define void @func02() local_unnamed_addr #0 {
+entry:
+  %0 = load volatile i32, ptr @result, align 4
+  %add = add nsw i32 %0, 1
+  store volatile i32 %add, ptr @result, align 4
+  ret void
+}
+
+; Function Attrs: minsize nofree noinline norecurse nounwind optsize ssp uwtable
+define void @func03_takeaddr() #0 {
+entry:
+  %0 = load volatile i32, ptr @result, align 4
+  %add = add nsw i32 %0, 1
+  store volatile i32 %add, ptr @result, align 4
+  ret void
+}
+
+; Function Attrs: minsize nofree norecurse nounwind optsize ssp uwtable
+define void @callAllFunctions() local_unnamed_addr {
+entry:
+  tail call void @func01()
+  tail call void @func02()
+  tail call void @func03_takeaddr()
+  %0 = load volatile i32, ptr @result, align 4
+  %add = add nsw i32 %0, ptrtoint (ptr @func03_takeaddr to i32)
+  store volatile i32 %add, ptr @result, align 4
+  ret void
+}
+
+attributes #0 = { noinline }