[llvm-objcopy][ELF] Add --set-section-type

[MaskRay]

Summary

The request is mentioned on D129053. I feel that having this functionality is
mildly useful (not strong).

• Rename .ctors to .init_array and change sh_type to SHT_INIT_ARRAY (GNU objcopy detects the special name but we don't).
• Craft tests for a new SHT_LLVM_* extension

[MaskRay]

more test

[jhenderson]

Documentation needs updating.

llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp

686–688

As --set-section-flags can potentially change the type, we might want to add a specific test to document the behaviour that --set-section-type overrides whatever --set-section-flags does.

llvm/test/tools/llvm-objcopy/ELF/set-section-attr-and-rename.test

15–28

Would it not make sense to fold this into the above test-case, so that it tests all three of the --set-section-* options in one go?

llvm/test/tools/llvm-objcopy/ELF/set-section-type.test

21

I pronounce uint32_t as "you-int-thir-ty-two-tee", which would mean it should be "a" not "an". I'm curious if you say it differently?

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

281

I think you should be able to avoid the code duplication with parseSetSectionAlignment by factoring most of this code out into a separate function called both here and there.

291

If not refactoring, this local variable name is wrong.

833

Local variable needs renaming.

850–854

As this is quite verbose, it might be good to factor it into a helper function or lambda, to avoid duplication with the set section flags case.

[MaskRay]

Thanks for the comments. Updated.

llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp

686–688

Added a test ## --set-section-flags does not specify "readonly", so the output gets SHF_WRITE.

llvm/test/tools/llvm-objcopy/ELF/set-section-type.test

21

I say "you-int-thir-ty-two-tee", too... Fixed.

[jhenderson]

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

243–244

I'm not sure I follow the reasoning for switch to make_error?

840

[MaskRay]

update a comment

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

243–244

createStringError is a wrapper which accepts const char *. The underlying StringError constructor actually supports Twine.

[jhenderson]

LGTM, thanks!

[jhenderson]

Hang on, looks like the llvm-objcopy CommandGuide file hasn't been updated?

[MaskRay]

update llvm/docs/CommandGuide/llvm-objcopy.rst

[jhenderson]

LGTM, with suggested changes.

llvm/docs/CommandGuide/llvm-objcopy.rst

130 ↗

(On Diff #444172)

Unrelated, but if you get a moment whilst updating this doc, would you mean fixing the typo with the uneven ` characters around "<align>", please?

174 ↗

(On Diff #444172)

I suggest adopting the wording that --set-section-alignment uses. Something like this would be good:

Set the type of section ``<section>`` to the integer ``<type>``. Can be specified multiple times to update multiple sections.

As this option is ELF-only, it should be put under the "ELF-SPECIFIC OPTIONS" section of the doc.

[MaskRay]

llvm/docs/CommandGuide/llvm-objcopy.rst

130 ↗

(On Diff #444172)

Thanks for spotting this! Fixed separately in ccfc54028860a71780361128f861444825a24a05

174 ↗

(On Diff #444172)

Thanks for the suggestion. Moved and updated the wording.

llvm/include/llvm/ObjCopy/CommonConfig.h

struct CommonConfig {
   NameMatcher UnneededSymbolsToRemove;
   NameMatcher SymbolsToWeaken;
   NameMatcher SymbolsToKeepGlobal;
 
   // Map options
   StringMap<SectionRename> SectionsToRename;
   StringMap<uint64_t> SetSectionAlignment;
   StringMap<SectionFlagsUpdate> SetSectionFlags;
+  StringMap<uint64_t> SetSectionType;
   StringMap<StringRef> SymbolsToRename;
 
   // Symbol info specified by --add-symbol option.
   std::vector<NewSymbolInfo> SymbolsToAdd;
 
   // Boolean options
   bool DeterministicArchives = true;
   bool ExtractDWO = false;

llvm/lib/ObjCopy/ConfigManager.cpp

 
 Expected<const COFFConfig &> ConfigManager::getCOFFConfig() const {
   if (!Common.SplitDWO.empty() || !Common.SymbolsPrefix.empty() ||
       !Common.AllocSectionsPrefix.empty() || !Common.DumpSection.empty() ||
       !Common.KeepSection.empty() || !Common.SymbolsToGlobalize.empty() ||
       !Common.SymbolsToKeep.empty() || !Common.SymbolsToLocalize.empty() ||
       !Common.SymbolsToWeaken.empty() || !Common.SymbolsToKeepGlobal.empty() ||
       !Common.SectionsToRename.empty() || !Common.SetSectionAlignment.empty() ||
-      Common.ExtractDWO || Common.PreserveDates || Common.StripDWO ||
-      Common.StripNonAlloc || Common.StripSections || Common.Weaken ||
-      Common.DecompressDebugSections ||
+      !Common.SetSectionType.empty() || Common.ExtractDWO ||
+      Common.PreserveDates || Common.StripDWO || Common.StripNonAlloc ||
+      Common.StripSections || Common.Weaken || Common.DecompressDebugSections ||
       Common.DiscardMode == DiscardType::Locals || !Common.SymbolsToAdd.empty())
     return createStringError(llvm::errc::invalid_argument,
                              "option is not supported for COFF");
 
   return COFF;
 }
 
 Expected<const MachOConfig &> ConfigManager::getMachOConfig() const {
   if (!Common.SplitDWO.empty() || !Common.SymbolsPrefix.empty() ||
       !Common.AllocSectionsPrefix.empty() || !Common.KeepSection.empty() ||
       !Common.SymbolsToGlobalize.empty() || !Common.SymbolsToKeep.empty() ||
       !Common.SymbolsToLocalize.empty() || !Common.SymbolsToWeaken.empty() ||
       !Common.SymbolsToKeepGlobal.empty() || !Common.SectionsToRename.empty() ||
       !Common.UnneededSymbolsToRemove.empty() ||
       !Common.SetSectionAlignment.empty() || !Common.SetSectionFlags.empty() ||
-      Common.ExtractDWO || Common.PreserveDates || Common.StripAllGNU ||
-      Common.StripDWO || Common.StripNonAlloc || Common.StripSections ||
-      Common.Weaken || Common.DecompressDebugSections || Common.StripUnneeded ||
+      !Common.SetSectionType.empty() || Common.ExtractDWO ||
+      Common.PreserveDates || Common.StripAllGNU || Common.StripDWO ||
+      Common.StripNonAlloc || Common.StripSections || Common.Weaken ||
+      Common.DecompressDebugSections || Common.StripUnneeded ||
       Common.DiscardMode == DiscardType::Locals || !Common.SymbolsToAdd.empty())
     return createStringError(llvm::errc::invalid_argument,
                              "option is not supported for MachO");
 
   return MachO;
 }
 
 Expected<const WasmConfig &> ConfigManager::getWasmConfig() const {
   if (!Common.AddGnuDebugLink.empty() || Common.ExtractPartition ||
       !Common.SplitDWO.empty() || !Common.SymbolsPrefix.empty() ||
       !Common.AllocSectionsPrefix.empty() ||
       Common.DiscardMode != DiscardType::None || !Common.SymbolsToAdd.empty() ||
       !Common.SymbolsToGlobalize.empty() || !Common.SymbolsToLocalize.empty() ||
       !Common.SymbolsToKeep.empty() || !Common.SymbolsToRemove.empty() ||
       !Common.UnneededSymbolsToRemove.empty() ||
       !Common.SymbolsToWeaken.empty() || !Common.SymbolsToKeepGlobal.empty() ||
       !Common.SectionsToRename.empty() || !Common.SetSectionAlignment.empty() ||
-      !Common.SetSectionFlags.empty() || !Common.SymbolsToRename.empty())
+      !Common.SetSectionFlags.empty() || !Common.SetSectionType.empty() ||
+      !Common.SymbolsToRename.empty())
     return createStringError(llvm::errc::invalid_argument,
                              "only flags for section dumping, removal, and "
                              "addition are supported");
 
   return Wasm;
 }
 
 Expected<const XCOFFConfig &> ConfigManager::getXCOFFConfig() const {
   if (!Common.AddGnuDebugLink.empty() || Common.ExtractPartition ||
       !Common.SplitDWO.empty() || !Common.SymbolsPrefix.empty() ||
       !Common.AllocSectionsPrefix.empty() ||
       Common.DiscardMode != DiscardType::None || !Common.AddSection.empty() ||
       !Common.DumpSection.empty() || !Common.SymbolsToAdd.empty() ||
       !Common.KeepSection.empty() || !Common.OnlySection.empty() ||
       !Common.ToRemove.empty() || !Common.SymbolsToGlobalize.empty() ||
       !Common.SymbolsToKeep.empty() || !Common.SymbolsToLocalize.empty() ||
       !Common.SymbolsToRemove.empty() ||
       !Common.UnneededSymbolsToRemove.empty() ||
       !Common.SymbolsToWeaken.empty() || !Common.SymbolsToKeepGlobal.empty() ||
       !Common.SectionsToRename.empty() || !Common.SetSectionAlignment.empty() ||
-      !Common.SetSectionFlags.empty() || !Common.SymbolsToRename.empty() ||
-      Common.ExtractDWO || Common.ExtractMainPartition ||
-      Common.OnlyKeepDebug || Common.PreserveDates || Common.StripAllGNU ||
-      Common.StripDWO || Common.StripDebug || Common.StripNonAlloc ||
-      Common.StripSections || Common.Weaken || Common.StripUnneeded ||
-      Common.DecompressDebugSections) {
+      !Common.SetSectionFlags.empty() || !Common.SetSectionType.empty() ||
+      !Common.SymbolsToRename.empty() || Common.ExtractDWO ||
+      Common.ExtractMainPartition || Common.OnlyKeepDebug ||
+      Common.PreserveDates || Common.StripAllGNU || Common.StripDWO ||
+      Common.StripDebug || Common.StripNonAlloc || Common.StripSections ||
+      Common.Weaken || Common.StripUnneeded || Common.DecompressDebugSections) {
     return createStringError(
         llvm::errc::invalid_argument,
         "no flags are supported yet, only basic copying is allowed");
   }
 
   return XCOFF;
 }
 
 } // end namespace objcopy
 } // end namespace llvm

llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp

static Error handleArgs(const CommonConfig &Config, const ELFConfig &ELFConfig,
   // before adding new symbols.
   if (!Obj.SymbolTable && !Config.SymbolsToAdd.empty())
     if (Error E = Obj.addNewSymbolTable())
       return E;
 
   for (const NewSymbolInfo &SI : Config.SymbolsToAdd)
     addSymbol(Obj, SI, ELFConfig.NewSymbolVisibility);
 
-  // --set-section-flags works with sections added by --add-section.
-  if (!Config.SetSectionFlags.empty()) {
+  // --set-section-{flags,type} work with sections added by --add-section.
+  if (!Config.SetSectionFlags.empty() || !Config.SetSectionType.empty()) {
     for (auto &Sec : Obj.sections()) {
       const auto Iter = Config.SetSectionFlags.find(Sec.Name);
       if (Iter != Config.SetSectionFlags.end()) {
         const SectionFlagsUpdate &SFU = Iter->second;
         setSectionFlagsAndType(Sec, SFU.NewFlags);
       }
+      auto It2 = Config.SetSectionType.find(Sec.Name);
+      if (It2 != Config.SetSectionType.end())
+        Sec.Type = It2->second;
     }
   }
 
   if (!Config.SectionsToRename.empty()) {
     std::vector<RelocationSectionBase *> RelocSections;
     DenseSet<SectionBase *> RenamedSections;
     for (SectionBase &Sec : Obj.sections()) {
       auto *RelocSec = dyn_cast<RelocationSectionBase>(&Sec);

llvm/test/tools/llvm-objcopy/ELF/add-section-and-set-attr.test

+## Check --set-section-flags/--set-section-types work with sections added by --add-section.
+
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy --add-section=foo=/dev/null --set-section-flags=foo=alloc,exclude %t %t.1
+# RUN: llvm-readobj -S %t.1 | FileCheck %s
+
+# CHECK:      Name: foo
+# CHECK-NEXT: Type: SHT_PROGBITS
+# CHECK-NEXT: Flags [
+# CHECK-NEXT:   SHF_ALLOC
+# CHECK-NEXT:   SHF_EXCLUDE
+# CHECK-NEXT:   SHF_WRITE
+# CHECK-NEXT: ]
+
+# RUN: llvm-objcopy --add-section=foo=/dev/null --set-section-type=foo=7 %t %t.2
+# RUN: llvm-readobj -S %t.2 | FileCheck %s --check-prefix=CHECK2
+
+# CHECK2:      Name: foo
+# CHECK2-NEXT: Type: SHT_NOTE (0x7)
+# CHECK2-NEXT: Flags [
+# CHECK2-NEXT: ]
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_EXEC
+  Machine: EM_X86_64

llvm/test/tools/llvm-objcopy/ELF/add-section-and-set-flags.test

-## Check --set-section-flags works with sections added by --add-section.
-
-# RUN: yaml2obj %s -o %t
-# RUN: llvm-objcopy --add-section=foo=/dev/null --set-section-flags=foo=alloc,exclude %t %t.out
-# RUN: llvm-readobj -S %t.out | FileCheck %s
-
-# CHECK:      Name: foo
-# CHECK-NEXT: Type: SHT_PROGBITS
-# CHECK-NEXT: Flags [
-# CHECK-NEXT:   SHF_ALLOC
-# CHECK-NEXT:   SHF_EXCLUDE
-# CHECK-NEXT:   SHF_WRITE
-# CHECK-NEXT: ]
-
---- !ELF
-FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_EXEC
-  Machine: EM_X86_64

llvm/test/tools/llvm-objcopy/ELF/set-section-attr-and-rename.test

 # RUN: yaml2obj %s -o %t
 
 # RUN: llvm-objcopy --rename-section=.foo=.bar --set-section-alignment=.foo=16 --set-section-flags=.foo=alloc %t %t.1
 # RUN: llvm-readobj -S %t.1 | FileCheck %s
 
 # CHECK:      Name: .bar
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT:   SHF_WRITE
 # CHECK-NEXT: ]
 # CHECK:      AddressAlignment:
 # CHECK-SAME:   {{^}} 16
 
-# RUN: not llvm-objcopy --rename-section=.foo=.bar --set-section-flags=.bar=alloc %t %t.2 2>&1 | FileCheck %s --check-prefix=SET-BAR
+# RUN: llvm-objcopy --rename-section=.foo=.bar --set-section-type=.foo=5 %t %t.2
+# RUN: llvm-readobj -S %t.2 | FileCheck %s --check-prefix=CHECK2
+
+# CHECK2:      Name: .bar
+# CHECK2-NEXT: Type: SHT_HASH
+# CHECK2-NEXT: Flags [
+# CHECK2-NEXT:   SHF_ALLOC
+# CHECK2-NEXT: ]
+
+# RUN: not llvm-objcopy --rename-section=.foo=.bar --set-section-flags=.bar=alloc %t %t.2 2>&1 | FileCheck %s --check-prefix=SET-BAR1
+# SET-BAR1: --set-section-flags=.bar conflicts with --rename-section=.foo=.bar
+
+# RUN: not llvm-objcopy --rename-section=.foo=.bar --set-section-type=.bar=1 %t %t.2 2>&1 | FileCheck %s --check-prefix=SET-BAR2
+# SET-BAR2: --set-section-type=.bar conflicts with --rename-section=.foo=.bar
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:  .foo
     Type:  SHT_PROGBITS
     Flags: [ SHF_ALLOC ]
-
-# SET-BAR: --set-section-flags=.bar conflicts with --rename-section=.foo=.bar

llvm/test/tools/llvm-objcopy/ELF/set-section-type.test

+# RUN: yaml2obj %s -o %t
+
+# RUN: llvm-objcopy --set-section-type=.foo=14 --set-section-type .bar=0xf %t %t.1
+# RUN: llvm-readobj --sections %t.1 | FileCheck %s
+
+# RUN: llvm-objcopy --set-section-type=.foo=13 --set-section-type=.foo=14 --set-section-type .bar=0xf %t %t.1
+# RUN: llvm-readobj --sections %t.1 | FileCheck %s
+
+# CHECK:        Name: .foo
+# CHECK-NEXT:   Type: SHT_INIT_ARRAY (0xE)
+# CHECK-NEXT:   Flags [
+# CHECK-NEXT:     SHF_ALLOC
+# CHECK-NEXT:   ]
+
+# CHECK:        Name: .bar
+# CHECK-NEXT:   Type: SHT_FINI_ARRAY (0xF)
+# CHECK-NEXT:   Flags [
+# CHECK-NEXT:   ]
+
+## sh_type is an uint32_t. There is no diagnostic for an overflow value.
+# RUN: llvm-objcopy --set-section-type=.foo=0x10000000a %t %t.2 2>&1 | count 0
+# RUN: llvm-readobj --sections %t.2 | FileCheck %s --check-prefix=CHECK2
+
+# CHECK2:        Name: .foo
+# CHECK2-NEXT:   Type: SHT_SHLIB
+# CHECK2-NEXT:   Flags [
+# CHECK2-NEXT:     SHF_ALLOC
+# CHECK2-NEXT:   ]
+
+!ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .foo
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+  - Name:  .bar
+    Type:  SHT_PROGBITS
+    Flags: [ ]

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

static Expected<SectionRename> parseRenameSectionValue(StringRef FlagValue) {
   return SR;
 }
 
 static Expected<std::pair<StringRef, uint64_t>>
 parseSetSectionAlignment(StringRef FlagValue) {
   if (!FlagValue.contains('='))
     return createStringError(
         errc::invalid_argument,
         "bad format for --set-section-alignment: missing '='");
   auto Split = StringRef(FlagValue).split('=');
   if (Split.first.empty())
     return createStringError(
         errc::invalid_argument,
         "bad format for --set-section-alignment: missing section name");
   uint64_t NewAlign;
   if (Split.second.getAsInteger(0, NewAlign))
     return createStringError(
         errc::invalid_argument,
parseSetSectionFlagValue(StringRef FlagValue) {
   Expected<SectionFlag> ParsedFlagSet = parseSectionFlagSet(SectionFlags);
   if (!ParsedFlagSet)
     return ParsedFlagSet.takeError();
   SFU.NewFlags = *ParsedFlagSet;
 
   return SFU;
 }
 
+static Expected<std::pair<StringRef, uint64_t>>
+parseSetSectionType(StringRef TypeValue) {
+  if (!TypeValue.contains('='))
+    return createStringError(
+        errc::invalid_argument,
+        "bad format for --set-section-type: missing '='");
+  auto Split = StringRef(TypeValue).split('=');
+  if (Split.first.empty())
+    return createStringError(
+        errc::invalid_argument,
+        "bad format for --set-section-type: missing section name");
+  uint64_t NewAlign;
+  if (Split.second.getAsInteger(0, NewAlign))
+    return createStringError(
+        errc::invalid_argument,
+        "invalid type for --set-section-type: '%s'",
+        Split.second.str().c_str());
+  return std::make_pair(Split.first, NewAlign);
+}
+
 namespace {
 struct TargetInfo {
   FileFormat Format;
   MachineInfo Machine;
 };
 } // namespace
 
 // FIXME: consolidate with the bfd parsing used by lld.
for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_flags)) {
     if (!SFU)
       return SFU.takeError();
     if (!Config.SetSectionFlags.try_emplace(SFU->Name, *SFU).second)
       return createStringError(
           errc::invalid_argument,
           "--set-section-flags set multiple times for section '%s'",
           SFU->Name.str().c_str());
   }
-  // Prohibit combinations of --set-section-flags when the section name is used
-  // by the destination of a --rename-section.
+  for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_type)) {
+    Expected<std::pair<StringRef, uint64_t>> NameAndAlign =
+        parseSetSectionType(Arg->getValue());
+    if (!NameAndAlign)
+      return NameAndAlign.takeError();
+    Config.SetSectionType[NameAndAlign->first] = NameAndAlign->second;
+  }
+  // Prohibit combinations of --set-section-{flags,type} when the section name
+  // is used by the destination of a --rename-section.
   for (const auto &E : Config.SectionsToRename) {
     const SectionRename &SR = E.second;
     if (Config.SetSectionFlags.count(SR.NewName))
       return createStringError(
           errc::invalid_argument,
           "--set-section-flags=%s conflicts with --rename-section=%s=%s",
           SR.NewName.str().c_str(), SR.OriginalName.str().c_str(),
           SR.NewName.str().c_str());
+    if (Config.SetSectionType.count(SR.NewName))
+      return createStringError(
+          errc::invalid_argument,
+          "--set-section-type=%s conflicts with --rename-section=%s=%s",
+          SR.NewName.str().c_str(), SR.OriginalName.str().c_str(),
+          SR.NewName.str().c_str());
   }
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
     if (Error E = Config.ToRemove.addMatcher(NameOrPattern::create(
             Arg->getValue(), SectionMatchStyle, ErrorCallback)))
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
     if (Error E = Config.KeepSection.addMatcher(NameOrPattern::create(

llvm/tools/llvm-objcopy/ObjcopyOpts.td

 
 defm set_section_flags
     : Eq<"set-section-flags",
          "Set section flags for a given section. Flags supported for GNU "
          "compatibility: alloc, load, noload, readonly, exclude, debug, code, "
          "data, rom, share, contents, merge, strings.">,
       MetaVarName<"section=flag1[,flag2,...]">;
 
+defm set_section_type
+    : Eq<"set-section-type",
+         "Set the type for a given section to the integer <type>">,
+      MetaVarName<"section=type">;
+
 def S : Flag<["-"], "S">,
         Alias<strip_all>,
         HelpText<"Alias for --strip-all">;
 def strip_dwo : Flag<["--"], "strip-dwo">,
                 HelpText<"Remove all DWARF .dwo sections from file">;
 def strip_non_alloc
     : Flag<["--"], "strip-non-alloc">,
       HelpText<"Remove all non-allocated sections outside segments">;