[MC] Add support for generating missing GNU build notes

[tbaeder]

Summary

Add support for generating missing GNU build notes to the LLVM assembler.

This makes clang accept and pass through -Wa,--generate-missing-build-notes=[yes/no]. If =yes is passed (the default is no), then the assembler will check whether a .gnu.build.attributes section is present. If not, it will generate one for all relevant code sections.

This is the equivalent to what the GNU assembler gas is already doing in maybe_generate_build_notes() in gas/write.c: https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gas/write.c;h=0b43063bbaab76d21fe3bac5fb4643bfff3c72e2;hb=HEAD#l1954

[tbaeder]

Add a test that checks that clang accepts -Wa,--generate-missing-build-notes=yes and -Wa,--generate-missing-build-notes=no

[tbaeder]

Ping

[MaskRay]

https://fedoraproject.org/wiki/Toolchain/Watermark Seems that .gnu.build.attributes is used with a GCC plugin (annobin?). The feature on its own is probably not that useful. .gnu.linkonce is a proto-comdat legacy feature which the patch should ignore.

[tbaeder]

In D84846#2396303, @MaskRay wrote:

https://fedoraproject.org/wiki/Toolchain/Watermark Seems that .gnu.build.attributes is used with a GCC plugin (annobin?). The feature on its own is probably not that useful. .gnu.linkonce is a proto-comdat legacy feature which the patch should ignore.

I can update the patch to ignore .gnu.linkonce. As for annobin, it can also be used as a clang plugin these days.

[tbaeder]

Sorry about the last change, that was the wrong patch.

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(MSVolatile        , 1, 0) ///< Set when /volatile:ms is enabled.
 CODEGENOPT(NoCommon          , 1, 0) ///< Set when -fno-common or C++ is enabled.
 CODEGENOPT(NoDwarfDirectoryAsm , 1, 0) ///< Set when -fno-dwarf-directory-asm is
                                        ///< enabled.
 CODEGENOPT(NoExecStack       , 1, 0) ///< Set when -Wa,--noexecstack is enabled.
 CODEGENOPT(FatalWarnings     , 1, 0) ///< Set when -Wa,--fatal-warnings is
                                      ///< enabled.
 CODEGENOPT(NoWarn            , 1, 0) ///< Set when -Wa,--no-warn is enabled.
+CODEGENOPT(GenerateMissingBuildNotes, 1, 0) ///< Set when -Wa,--generate-missing-build-notes=yes is passed
 CODEGENOPT(EnableSegmentedStacks , 1, 0) ///< Set when -fsplit-stack is enabled.
 CODEGENOPT(NoInlineLineTables, 1, 0) ///< Whether debug info should contain
                                      ///< inline line tables.
 CODEGENOPT(StackClashProtector, 1, 0) ///< Set when -fstack-clash-protection is enabled.
 CODEGENOPT(NoImplicitFloat   , 1, 0) ///< Set when -mno-implicit-float is enabled.
 CODEGENOPT(NullPointerIsValid , 1, 0) ///< Assume Null pointer deference is defined.
 CODEGENOPT(CorrectlyRoundedDivSqrt, 1, 0) ///< -cl-fp32-correctly-rounded-divide-sqrt
 CODEGENOPT(UniqueInternalLinkageNames, 1, 0) ///< Internal Linkage symbols get unique names.

clang/include/clang/Driver/Options.td

 def compress_debug_sections : Flag<["-", "--"], "compress-debug-sections">,
     HelpText<"DWARF debug sections compression">;
 def compress_debug_sections_EQ : Joined<["-", "--"], "compress-debug-sections=">,
     HelpText<"DWARF debug sections compression type">;
 def mno_exec_stack : Flag<["-"], "mnoexecstack">,
   HelpText<"Mark the file as not needing an executable stack">;
 def massembler_no_warn : Flag<["-"], "massembler-no-warn">,
   HelpText<"Make assembler not emit warnings">;
+def massembler_generate_missing_build_notes : Flag<["-"], "massembler-generate-missing-build-notes">,
+  HelpText<"Make assembler emit missing GNU build notes">;
 def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
   HelpText<"Make assembler warnings fatal">;
 def mrelax_relocations : Flag<["--"], "mrelax-relocations">,
     HelpText<"Use relaxable elf relocations">;
 def msave_temp_labels : Flag<["-"], "msave-temp-labels">,
   HelpText<"Save temporary labels in the symbol table. "
            "Note this may change .s semantics and shouldn't generally be used "
            "on compiler-generated code.">;

clang/lib/CodeGen/BackendUtil.cpp

static void initTargetOptions(DiagnosticsEngine &Diags,
   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
   Options.MCOptions.MCIncrementalLinkerCompatible =
       CodeGenOpts.IncrementalLinkerCompatible;
   Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
   Options.MCOptions.MCNoWarn = CodeGenOpts.NoWarn;
+  Options.MCOptions.MCGenerateMissingBuildNotes =
+      CodeGenOpts.GenerateMissingBuildNotes;
   Options.MCOptions.AsmVerbose = CodeGenOpts.AsmVerbose;
   Options.MCOptions.PreserveAsmComments = CodeGenOpts.PreserveAsmComments;
   Options.MCOptions.ABIName = TargetOpts.ABI;
   for (const auto &Entry : HSOpts.UserEntries)
     if (!Entry.IsFramework &&
         (Entry.Group == frontend::IncludeDirGroup::Quoted ||
          Entry.Group == frontend::IncludeDirGroup::Angled ||
          Entry.Group == frontend::IncludeDirGroup::System))

clang/lib/Driver/ToolChains/Clang.cpp

static void CollectArgsForIntegratedAssembler(Compilation &C,
   // unconditionally take the next argument.  For example, when parsing
   // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the
   // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo'
   // arg after parsing the '-I' arg.
   bool TakeNextArg = false;
 
   bool UseRelaxRelocations = C.getDefaultToolChain().useRelaxRelocations();
   bool UseNoExecStack = C.getDefaultToolChain().isNoExecStackDefault();
+  bool UseGenerateMissingBuildNotes = false;
   const char *MipsTargetFeature = nullptr;
   for (const Arg *A :
        Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
     A->claim();
 
     for (StringRef Value : A->getValues()) {
       if (TakeNextArg) {
         CmdArgs.push_back(Value.data());
for (StringRef Value : A->getValues()) {
       if (Value == "-force_cpusubtype_ALL") {
         // Do nothing, this is the default and we don't support anything else.
       } else if (Value == "-L") {
         CmdArgs.push_back("-msave-temp-labels");
       } else if (Value == "--fatal-warnings") {
         CmdArgs.push_back("-massembler-fatal-warnings");
       } else if (Value == "--no-warn" || Value == "-W") {
         CmdArgs.push_back("-massembler-no-warn");
+      } else if (Value == "--generate-missing-build-notes=yes") {
+        UseGenerateMissingBuildNotes = true;
+      } else if (Value == "--generate-missing-build-notes=no") {
+        UseGenerateMissingBuildNotes = false;
       } else if (Value == "--noexecstack") {
         UseNoExecStack = true;
       } else if (Value.startswith("-compress-debug-sections") ||
                  Value.startswith("--compress-debug-sections") ||
                  Value == "-nocompress-debug-sections" ||
                  Value == "--nocompress-debug-sections") {
         CmdArgs.push_back(Value.data());
       } else if (Value == "-mrelax-relocations=yes" ||
for (StringRef Value : A->getValues()) {
             << A->getOption().getName() << Value;
       }
     }
   }
   if (UseRelaxRelocations)
     CmdArgs.push_back("--mrelax-relocations");
   if (UseNoExecStack)
     CmdArgs.push_back("-mnoexecstack");
+  if (UseGenerateMissingBuildNotes)
+    CmdArgs.push_back("-massembler-generate-missing-build-notes");
   if (MipsTargetFeature != nullptr) {
     CmdArgs.push_back("-target-feature");
     CmdArgs.push_back(MipsTargetFeature);
   }
 
   // forward -fembed-bitcode to assmebler
   if (C.getDriver().embedBitcodeEnabled() ||
       C.getDriver().embedBitcodeMarkerOnly())

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
 
   Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_fno_zero_initialized_in_bss);
   Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
   Opts.SmallDataLimit =
       getLastArgIntValue(Args, OPT_msmall_data_limit, 0, Diags);
   Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
   Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
+  Opts.GenerateMissingBuildNotes =
+      Args.hasArg(OPT_massembler_generate_missing_build_notes);
   Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
   Opts.IncrementalLinkerCompatible =
       Args.hasArg(OPT_mincremental_linker_compatible);
   Opts.PIECopyRelocations =
       Args.hasArg(OPT_mpie_copy_relocations);
   Opts.NoPLT = Args.hasArg(OPT_fno_plt);
   Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);

clang/tools/driver/cc1as_main.cpp

struct AssemblerInvocation {
   /// @}
   /// @name Assembler Options
   /// @{
 
   unsigned RelaxAll : 1;
   unsigned NoExecStack : 1;
   unsigned FatalWarnings : 1;
   unsigned NoWarn : 1;
+  unsigned GenerateMissingBuildNotes : 1;
   unsigned IncrementalLinkerCompatible : 1;
   unsigned EmbedBitcode : 1;
 
   /// The name of the relocation model to use.
   std::string RelocationModel;
 
   /// The ABI targeted by the backend. Specified using -target-abi. Empty
   /// otherwise.
AssemblerInvocation() {
     OutputType = FT_Asm;
     OutputAsmVariant = 0;
     ShowInst = 0;
     ShowEncoding = 0;
     RelaxAll = 0;
     NoExecStack = 0;
     FatalWarnings = 0;
     NoWarn = 0;
+    GenerateMissingBuildNotes = 0;
     IncrementalLinkerCompatible = 0;
     DwarfVersion = 0;
     EmbedBitcode = 0;
   }
 
   static bool CreateFromArgs(AssemblerInvocation &Res,
                              ArrayRef<const char *> Argv,
                              DiagnosticsEngine &Diags);
bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   Opts.ShowEncoding = Args.hasArg(OPT_show_encoding);
   Opts.ShowInst = Args.hasArg(OPT_show_inst);
 
   // Assemble Options
   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
   Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
   Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
+  Opts.GenerateMissingBuildNotes =
+      Args.hasArg(OPT_massembler_generate_missing_build_notes);
   Opts.RelocationModel =
       std::string(Args.getLastArgValue(OPT_mrelocation_model, "pic"));
   Opts.TargetABI = std::string(Args.getLastArgValue(OPT_target_abi));
   Opts.IncrementalLinkerCompatible =
       Args.hasArg(OPT_mincremental_linker_compatible);
   Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);
 
   // EmbedBitcode Option. If -fembed-bitcode is enabled, set the flag.
if (!Opts.DebugPrefixMap.empty())
     for (const auto &KV : Opts.DebugPrefixMap)
       Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
   if (!Opts.MainFileName.empty())
     Ctx.setMainFileName(StringRef(Opts.MainFileName));
   Ctx.setDwarfVersion(Opts.DwarfVersion);
   if (Opts.GenDwarfForAssembly)
     Ctx.setGenDwarfRootFile(Opts.InputFile,
                             SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());
+  if (Opts.GenerateMissingBuildNotes)
+    Ctx.setGenerateMissingBuildNotes(true);
 
   // Build up the feature string from the target feature list.
   std::string FS = llvm::join(Opts.Features, ",");
 
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
   std::unique_ptr<MCSubtargetInfo> STI(
       TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
 
   raw_pwrite_stream *Out = FDOS.get();
   std::unique_ptr<buffer_ostream> BOS;
 
   MCOptions.MCNoWarn = Opts.NoWarn;
   MCOptions.MCFatalWarnings = Opts.FatalWarnings;
+  MCOptions.MCGenerateMissingBuildNotes = Opts.GenerateMissingBuildNotes;
   MCOptions.ABIName = Opts.TargetABI;
 
   // FIXME: There is a bit of code duplication with addPassesToEmitFile.
   if (Opts.OutputType == AssemblerInvocation::FT_Asm) {
     MCInstPrinter *IP = TheTarget->createMCInstPrinter(
         llvm::Triple(Opts.Triple), Opts.OutputAsmVariant, *MAI, *MCII, *MRI);
 
     std::unique_ptr<MCCodeEmitter> CE;

llvm/include/llvm/MC/MCContext.h

private:
     /// The format of dwarf that we emit.
     dwarf::DwarfFormat DwarfFormat = dwarf::DWARF32;
 
     /// Honor temporary labels, this is useful for debugging semantic
     /// differences between temporary and non-temporary labels (primarily on
     /// Darwin).
     bool AllowTemporaryLabels = true;
     bool UseNamesOnTempLabels = false;
+    bool GenerateMissingBuildNotes = false;
 
     /// The Compile Unit ID that we are currently processing.
     unsigned DwarfCompileUnitID = 0;
 
     // Sections are differentiated by the quadruple (section_name, group_name,
     // unique_id, link_to_symbol_name). Sections sharing the same quadruple are
     // combined into one section.
     struct ELFSectionKey {
public:
     const MCRegisterInfo *getRegisterInfo() const { return MRI; }
 
     const MCObjectFileInfo *getObjectFileInfo() const { return MOFI; }
 
     CodeViewContext &getCVContext();
 
     void setAllowTemporaryLabels(bool Value) { AllowTemporaryLabels = Value; }
     void setUseNamesOnTempLabels(bool Value) { UseNamesOnTempLabels = Value; }
+    void setGenerateMissingBuildNotes(bool Value) {
+      GenerateMissingBuildNotes = Value;
+    }
+    bool getGenerateMissingBuildNotes() const {
+      return GenerateMissingBuildNotes;
+    }
 
     /// \name Module Lifetime Management
     /// @{
 
     /// reset - return object to right after construction state to prepare
     /// to process a new module
     void reset();
 
public:
 
     MCSectionMachO *getMachOSection(StringRef Segment, StringRef Section,
                                     unsigned TypeAndAttributes, SectionKind K,
                                     const char *BeginSymName = nullptr) {
       return getMachOSection(Segment, Section, TypeAndAttributes, 0, K,
                              BeginSymName);
     }
 
+    bool hasELFSection(const Twine &Section, const MCSymbolELF *GroupSym,
+                       unsigned UniqueID, const MCSymbolELF *LinkedToSym);
+
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags) {
       return getELFSection(Section, Type, Flags, 0, "");
     }
 
     MCSectionELF *getELFSection(const Twine &Section, unsigned Type,
                                 unsigned Flags, unsigned EntrySize,
                                 const Twine &Group) {

llvm/include/llvm/MC/MCTargetOptions.h

public:
   bool MCRelaxAll : 1;
   bool MCNoExecStack : 1;
   bool MCFatalWarnings : 1;
   bool MCNoWarn : 1;
   bool MCNoDeprecatedWarn : 1;
   bool MCSaveTempLabels : 1;
   bool MCUseDwarfDirectory : 1;
   bool MCIncrementalLinkerCompatible : 1;
+  bool MCGenerateMissingBuildNotes : 1;
   bool ShowMCEncoding : 1;
   bool ShowMCInst : 1;
   bool AsmVerbose : 1;
 
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
   bool Dwarf64 : 1;

llvm/lib/CodeGen/LLVMTargetMachine.cpp

 bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
                                       raw_pwrite_stream &Out,
                                       raw_pwrite_stream *DwoOut,
                                       CodeGenFileType FileType,
                                       MCContext &Context) {
   if (Options.MCOptions.MCSaveTempLabels)
     Context.setAllowTemporaryLabels(false);
 
+  if (Options.MCOptions.MCGenerateMissingBuildNotes)
+    Context.setGenerateMissingBuildNotes(true);
+
   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
   const MCAsmInfo &MAI = *getMCAsmInfo();
   const MCRegisterInfo &MRI = *getMCRegisterInfo();
   const MCInstrInfo &MII = *getMCInstrInfo();
 
   std::unique_ptr<MCStreamer> AsmStreamer;
 
   switch (FileType) {
if (!PassConfig)
     return true;
   assert(TargetPassConfig::willCompleteCodeGenPipeline() &&
          "Cannot emit MC with limited codegen pipeline");
 
   Ctx = &MMIWP->getMMI().getContext();
   if (Options.MCOptions.MCSaveTempLabels)
     Ctx->setAllowTemporaryLabels(false);
 
+  if (Options.MCOptions.MCGenerateMissingBuildNotes)
+    Ctx->setGenerateMissingBuildNotes(true);
+
   // Create the code emitter for the target if it exists.  If not, .o file
   // emission fails.
   const MCSubtargetInfo &STI = *getMCSubtargetInfo();
   const MCRegisterInfo &MRI = *getMCRegisterInfo();
   MCCodeEmitter *MCE =
       getTarget().createMCCodeEmitter(*getMCInstrInfo(), MRI, *Ctx);
   MCAsmBackend *MAB =
       getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions);

llvm/lib/MC/ELFObjectWriter.cpp

public:
 
   void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
                         uint64_t Address, uint64_t Offset, uint64_t Size,
                         uint32_t Link, uint32_t Info, uint64_t Alignment,
                         uint64_t EntrySize);
 
   void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
 
+  void writeBuildNote(MCContext &Ctx, const MCSectionELF *Section,
+                      const MCSectionELF *BuildAttributes,
+                      uint64_t BuildAttributesStart,
+                      SectionOffsetsTy &SectionOffsets);
   uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeSection(const SectionIndexMapTy &SectionIndexMap,
                     uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
                     const MCSectionELF &Section);
 };
 
 class ELFObjectWriter : public MCObjectWriter {
   /// The target specific ELF writer instance.
for (const MCSectionELF *Section : SectionTable) {
     else
       Size = Offsets.second - Offsets.first;
 
     writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
                  *Section);
   }
 }
 
+void ELFWriter::writeBuildNote(MCContext &Ctx, const MCSectionELF *Section,
+                               const MCSectionELF *BuildAttributes,
+                               uint64_t BuildAttributesStart,
+                               SectionOffsetsTy &SectionOffsets) {
+  const MCSymbolELF *SectionSymbol =
+      static_cast<const MCSymbolELF *>(Section->getBeginSymbol());
+  const uint64_t BuildNoteSize = is64Bit() ? 36 : 28;
+  const uint64_t RelEndOffset = is64Bit() ? 28 : 24;
+  const uint64_t SectionOffset = W.OS.tell() - BuildAttributesStart;
+  const uint64_t SectionSize =
+      SectionOffsets[Section].second - SectionOffsets[Section].first;
+  const uint64_t BuildNoteStart = W.OS.tell();
+
+  W.write<uint32_t>(8);                  // strlen(name) + 1
+  W.write<uint32_t>(is64Bit() ? 16 : 8); // Two N-byte offsets
+  W.write<uint32_t>(ELF::NT_GNU_BUILD_ATTRIBUTE_OPEN);
+
+  // The a2 version number indicates that this note was
+  // generated by the LLVM assembler and not the annobin plugin.
+  W.write<uint8_t>('G');
+  W.write<uint8_t>('A');
+  W.write<uint8_t>('$');
+  W.write<uint8_t>('␁');
+  W.write<uint8_t>('3');
+  W.write<uint8_t>('a');
+  W.write<uint8_t>('2');
+  W.write<uint8_t>('\0');
+
+  // 20 bytes so far
+  assert(W.OS.tell() - BuildNoteStart == 20);
+
+  if (!hasRelocationAddend()) {
+    if (is64Bit()) {
+      W.write<uint64_t>(SectionSize);
+    } else {
+      W.OS.write_zeros(4);
+      W.write<uint32_t>(SectionSize);
+    }
+  }
+
+  W.OS.write_zeros(BuildNoteSize -
+                   (W.OS.tell() - BuildNoteStart)); // Fill up with zeroes
+
+  MCFixup Fixup = MCFixup::create(SectionOffset, nullptr,
+                                  is64Bit() ? MCFixupKind::FK_Data_8
+                                            : MCFixupKind::FK_Data_4);
+  MCValue Value = MCValue::get(nullptr, nullptr, 0, 0);
+  auto RelocType =
+      OWriter.TargetObjectWriter->getRelocType(Ctx, Value, Fixup, false);
+
+  SectionSymbol->setUsedInReloc();
+  // Create a relocation to install the start address of the note
+  ELFRelocationEntry RelStart(SectionOffset + 20, SectionSymbol, RelocType, 0,
+                              nullptr, 0);
+  OWriter.Relocations[BuildAttributes].push_back(RelStart);
+
+  // ... and one to install the end address
+  ELFRelocationEntry RelEnd(SectionOffset + RelEndOffset, SectionSymbol,
+                            RelocType, SectionSize, nullptr, 0);
+  OWriter.Relocations[BuildAttributes].push_back(RelEnd);
+}
+
 uint64_t ELFWriter::writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) {
   uint64_t StartOffset = W.OS.tell();
 
   MCContext &Ctx = Asm.getContext();
   MCSectionELF *StrtabSection =
       Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
   StringTableIndex = addToSectionTable(StrtabSection);
 
for (MCSection &Sec : Asm) {
     if (RelSection) {
       SectionIndexMap[RelSection] = addToSectionTable(RelSection);
       Relocations.push_back(RelSection);
     }
 
     OWriter.TargetObjectWriter->addTargetSectionFlags(Ctx, Section);
   }
 
+  // .gnu.build.attributes section
+  if (Ctx.getGenerateMissingBuildNotes() &&
+      !Ctx.hasELFSection(".gnu.build.attributes", nullptr,
+                         MCSection::NonUniqueID, nullptr)) {
+    MCSectionELF *BuildAttributes =
+        Ctx.getELFSection(".gnu.build.attributes", ELF::SHT_NOTE, 0);
+    BuildAttributes->setAlignment(Align(2));
+    SectionIndexMap[BuildAttributes] = addToSectionTable(BuildAttributes);
+
+    // Create a build note for each code section
+    const uint64_t BuildAttributesStart = W.OS.tell();
+    for (const MCSection &Section : Asm) {
+      const MCSectionELF *SectionELF =
+          static_cast<const MCSectionELF *>(&Section);
+
+      if (Section.getKind().isMetadata())
+        continue;
+
+      if (!Section.hasInstructions() && !Section.getKind().isText())
+        continue;
+
+      // TODO: Are linkonce sections marked in any other way?
+      if (Section.getName().startswith(".gnu.linkonce"))
+        continue;
+
+      writeBuildNote(Ctx, SectionELF, BuildAttributes, BuildAttributesStart,
+                     SectionOffsets);
+    }
+    const uint64_t BuildAttributesEnd = W.OS.tell();
+
+    if (BuildAttributesEnd != BuildAttributesStart) {
+      SectionOffsets[BuildAttributes] =
+          std::make_pair(BuildAttributesStart, BuildAttributesEnd);
+
+      auto RelocSection = createRelocationSection(Ctx, *BuildAttributes);
+      assert(RelocSection);
+      SectionIndexMap[RelocSection] = addToSectionTable(RelocSection);
+      Relocations.push_back(RelocSection);
+    }
+  }
+
   MCSectionELF *CGProfileSection = nullptr;
   if (!Asm.CGProfile.empty()) {
     CGProfileSection = Ctx.getELFSection(".llvm.call-graph-profile",
                                          ELF::SHT_LLVM_CALL_GRAPH_PROFILE,
                                          ELF::SHF_EXCLUDE, 16, "");
     SectionIndexMap[CGProfileSection] = addToSectionTable(CGProfileSection);
   }
 

llvm/lib/MC/MCContext.cpp

MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
   MCSymbolELF *GroupSym = nullptr;
   if (!Group.isTriviallyEmpty() && !Group.str().empty())
     GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
 
   return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
                        LinkedToSym);
 }
 
+bool MCContext::hasELFSection(const Twine &Section, const MCSymbolELF *GroupSym,
+                              unsigned UniqueID,
+                              const MCSymbolELF *LinkedToSym) {
+  StringRef Group = "";
+  if (GroupSym)
+    Group = GroupSym->getName();
+  assert(!(LinkedToSym && LinkedToSym->getName().empty()));
+
+  auto key = ELFUniquingMap.find(
+      ELFSectionKey{Section.str(), Group,
+                    LinkedToSym ? LinkedToSym->getName() : "", UniqueID});
+
+  return key != ELFUniquingMap.end();
+}
+
 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
                                        unsigned Flags, unsigned EntrySize,
                                        const MCSymbolELF *GroupSym,
                                        unsigned UniqueID,
                                        const MCSymbolELF *LinkedToSym) {
   StringRef Group = "";
   if (GroupSym)
     Group = GroupSym->getName();

llvm/lib/MC/MCTargetOptions.cpp

 #include "llvm/ADT/StringRef.h"
 
 using namespace llvm;
 
 MCTargetOptions::MCTargetOptions()
     : MCRelaxAll(false), MCNoExecStack(false), MCFatalWarnings(false),
       MCNoWarn(false), MCNoDeprecatedWarn(false), MCSaveTempLabels(false),
       MCUseDwarfDirectory(false), MCIncrementalLinkerCompatible(false),
-      ShowMCEncoding(false), ShowMCInst(false), AsmVerbose(false),
-      PreserveAsmComments(true), Dwarf64(false) {}
+      MCGenerateMissingBuildNotes(false), ShowMCEncoding(false),
+      ShowMCInst(false), AsmVerbose(false), PreserveAsmComments(true),
+      Dwarf64(false) {}
 
 StringRef MCTargetOptions::getABIName() const {
   return ABIName;
 }
 
 StringRef MCTargetOptions::getAssemblyLanguage() const {
   return AssemblyLanguage;
 }

llvm/test/MC/ELF/build-notes.s

+// RUN: llvm-mc --generate-missing-build-notes -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -r --section-relocations --hex-dump=.gnu.build.attributes - | FileCheck %s
+// RUN: llvm-mc --generate-missing-build-notes -filetype=obj -triple i386-pc-linux-gnu %s -o - | llvm-readobj -r --section-relocations --hex-dump=.gnu.build.attributes - | FileCheck %s --check-prefix=i386
+// RUN: llvm-mc --generate-missing-build-notes -filetype=obj -triple armeb-pc-linux-gnu %s -o - | llvm-readobj -r --section-relocations --hex-dump=.gnu.build.attributes - | FileCheck %s --check-prefix=armbe32
+
+        .text
+        .dc.l 1
+
+        .section .text.unused,"ax"
+        .space 1025
+
+        .section .gnu.linkonce,"ax"
+        .dc.l 3
+
+// CHECK:      Relocations [
+// CHECK-NEXT:   Section {{.*}} .rela.gnu.build.attributes {
+// CHECK-NEXT:     0x14 R_X86_64_64 .text 0x0
+// CHECK-NEXT:     0x1C R_X86_64_64 .text 0x4
+// CHECK-NEXT:     0x38 R_X86_64_64 .text.unused 0x0
+// CHECK-NEXT:     0x40 R_X86_64_64 .text.unused 0x401
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
+// CHECK: Hex dump of section '.gnu.build.attributes':
+// CHECK-NEXT: 0x00000000 08000000 10000000 00010000 47412401 ............GA$.
+// CHECK-NEXT: 0x00000010 33613200 00000000 00000000 00000000 3a2.............
+// CHECK-NEXT: 0x00000020 00000000 08000000 10000000 00010000 ................
+// CHECK-NEXT: 0x00000030 47412401 33613200 00000000 00000000 GA$.3a2.........
+// CHECK-NEXT: 0x00000040 00000000 00000000                   ........
+
+// i386:      Relocations [
+// i386-NEXT:   Section {{.*}} .rel.gnu.build.attributes {
+// i386-NEXT:     0x14 R_386_32 .text 0x0
+// i386-NEXT:     0x18 R_386_32 .text 0x0
+// i386-NEXT:     0x30 R_386_32 .text.unused 0x0
+// i386-NEXT:     0x34 R_386_32 .text.unused 0x0
+// i386-NEXT:   }
+// i386-NEXT: ]
+// i386: Hex dump of section '.gnu.build.attributes':
+// i386-NEXT: 0x00000000 08000000 08000000 00010000 47412401 ............GA$.
+// i386-NEXT: 0x00000010 33613200 00000000 04000000 08000000 3a2.............
+// i386-NEXT: 0x00000020 08000000 00010000 47412401 33613200 ........GA$.3a2.
+// i386-NEXT: 0x00000030 00000000 01040000                   ........
+
+// armbe32:      Relocations [
+// armbe32-NEXT:   Section {{.*}} .rel.gnu.build.attributes {
+// armbe32-NEXT:     0x14 R_ARM_ABS32 .text 0x0
+// armbe32-NEXT:     0x18 R_ARM_ABS32 .text 0x0
+// armbe32-NEXT:     0x30 R_ARM_ABS32 .text.unused 0x0
+// armbe32-NEXT:     0x34 R_ARM_ABS32 .text.unused 0x0
+// armbe32-NEXT:   }
+// armbe32-NEXT: ]
+// armbe32: Hex dump of section '.gnu.build.attributes':
+// armbe32-NEXT: 0x00000000 00000008 00000008 00000100 47412401 ............GA$.
+// armbe32-NEXT: 0x00000010 33613200 00000000 00000004 00000008 3a2.............
+// armbe32-NEXT: 0x00000020 00000008 00000100 47412401 33613200 ........GA$.3a2.
+// armbe32-NEXT: 0x00000030 00000000 00000401                   ........

llvm/tools/llvm-mc/llvm-mc.cpp

 
 static cl::opt<bool> LexMasmIntegers(
     "masm-integers",
     cl::desc("Enable binary and hex masm integers (0b110 and 0ABCh)"));
 
 static cl::opt<bool> NoExecStack("no-exec-stack",
                                  cl::desc("File doesn't need an exec stack"));
 
+static cl::opt<bool>
+    GenerateMissingBuildNotes("generate-missing-build-notes",
+                              cl::desc("Generate missing GNU build notes"));
+
 enum ActionType {
   AC_AsLex,
   AC_Assemble,
   AC_Disassemble,
   AC_MDisassemble,
 };
 
 static cl::opt<ActionType>
int main(int argc, char **argv) {
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
   MCObjectFileInfo MOFI;
   MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr, &MCOptions);
   MOFI.InitMCObjectFileInfo(TheTriple, PIC, Ctx, LargeCodeModel);
 
   if (SaveTempLabels)
     Ctx.setAllowTemporaryLabels(false);
 
+  if (GenerateMissingBuildNotes)
+    Ctx.setGenerateMissingBuildNotes(true);
+
   Ctx.setGenDwarfForAssembly(GenDwarfForAssembly);
   // Default to 4 for dwarf version.
   unsigned DwarfVersion = MCOptions.DwarfVersion ? MCOptions.DwarfVersion : 4;
   if (DwarfVersion < 2 || DwarfVersion > 5) {
     errs() << ProgName << ": Dwarf version " << DwarfVersion
            << " is not supported." << '\n';
     return 1;
   }