[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–21

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

279

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.

289

If not refactoring, this local variable name is wrong.

811

Local variable needs renaming.

828–832

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

241–243

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

818

[MaskRay]

update a comment

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

241–243

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

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

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

Thanks for spotting this! Fixed separately in ccfc54028860a71780361128f861444825a24a05

174

Thanks for the suggestion. Moved and updated the wording.

llvm/docs/CommandGuide/llvm-objcopy.rst

  Remove the specified section from the output. Can be specified multiple times
  to remove multiple sections simultaneously.
 
  For MachO objects, ``<section>`` must be formatted as
  ``<segment name>,<section name>``.
 
 .. option:: --set-section-alignment <section>=<align>
 
  Set the alignment of section ``<section>`` to `<align>``. Can be specified
  multiple times to update multiple sections.
 
 .. option:: --set-section-flags <section>=<flag>[,<flag>,...]
 
  Set section properties in the output of section ``<section>`` based on the
  specified ``<flag>`` values. Can be specified multiple times to update multiple
  sections.
 

  - `code` = add the `IMAGE_SCN_CNT_CODE`, `IMAGE_SCN_MEM_EXECUTE` and
    `IMAGE_SCN_MEM_READ` flags.
  - `data` = add the `IMAGE_SCN_CNT_INITIALIZED_DATA` and `IMAGE_SCN_MEM_READ`
    flags.
  - `share` = add the `IMAGE_SCN_MEM_SHARED` and `IMAGE_SCN_MEM_READ` flags.
 
 .. option:: --strip-all-gnu
 
  Remove all symbols, debug sections and relocations from the output. This option
  is equivalent to GNU :program:`objcopy`'s ``--strip-all`` switch.
 
 .. option:: --strip-all, -S
 
  For ELF objects, remove from the output all symbols and non-alloc sections not
  within segments, except for .gnu.warning, .ARM.attribute sections and the
  section name table.
 

  Preserve access and modification timestamps in the output.
 
 .. option:: --rename-section <old>=<new>[,<flag>,...]
 
  Rename sections called ``<old>`` to ``<new>`` in the output, and apply any
  specified ``<flag>`` values. See :option:`--set-section-flags` for a list of
  supported flags. Can be specified multiple times to rename multiple sections.
 
+.. option:: --set-section-type <section>=<type>
+
+ Set the type of section ``<section>`` to the integer ``<type>``. Can be
+ specified multiple times to update multiple sections.
+
 .. option:: --set-start-addr <addr>
 
  Set the start address of the output to ``<addr>``. Overrides any previously
  specified :option:`--change-start` or :option:`--adjust-start` options.
 
 .. option:: --split-dwo <dwo-file>
 
  Equivalent to running :program:`llvm-objcopy` with :option:`--extract-dwo` and

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-alignment.test

 # MISSING-EQUAL:   error: bad format for --set-section-alignment: missing '='
 
 # RUN: not llvm-objcopy --set-section-alignment==4 %t /dev/null 2>&1 | \
 # RUN:   FileCheck --check-prefix=MISSING-SECTION %s
 # MISSING-SECTION: error: bad format for --set-section-alignment: missing section name
 
 # RUN: not llvm-objcopy --set-section-alignment=.foo=bar %t /dev/null 2>&1 | \
 # RUN:   FileCheck --check-prefix=INVALID-ALIGN %s
-# INVALID-ALIGN:   error: invalid alignment for --set-section-alignment: 'bar'
+# INVALID-ALIGN:   error: invalid value for --set-section-alignment: 'bar'
 
 !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name:         .foo
     Type:         SHT_PROGBITS
   - Name:         .bar
     Type:         SHT_NOBITS
   - Name:         .baz
     Type:         SHT_NOTE
     AddressAlign: 4
     Notes:        []

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-objcopy --rename-section=.foo=.bar --set-section-alignment=.foo=16 --set-section-flags=.foo=alloc --set-section-type=.foo=5 %t %t.1
 # RUN: llvm-readobj -S %t.1 | FileCheck %s
 
 # CHECK:      Name: .bar
-# CHECK-NEXT: Type: SHT_PROGBITS
+# CHECK-NEXT: Type: SHT_HASH (0x5)
 # 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 | \
-# RUN:   FileCheck %s --check-prefix=SET-BAR
+# RUN:   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 | \
+# RUN:   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:   ]
+
+## --set-section-flags does not specify "readonly", so the output gets SHF_WRITE.
+## "contents" changes SHT_NOBITS to SHT_PROGBITS, but this is overridden by --set-section-type.
+## sh_type is a uint32_t. There is no diagnostic for an overflow value.
+# RUN: llvm-objcopy --set-section-flags=.foo=alloc,contents --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:     SHF_WRITE
+# CHECK2-NEXT:   ]
+
+# RUN: not llvm-objcopy --set-section-type=.foo %t /dev/null 2>&1 | FileCheck %s --check-prefix=BAD-FORMAT
+# BAD-FORMAT: bad format for --set-section-type: missing '='
+
+# RUN: not llvm-objcopy --set-section-type==4 %t /dev/null 2>&1 | FileCheck %s --check-prefix=MISSING-SECTION
+# MISSING-SECTION: error: bad format for --set-section-type: missing section name
+
+# RUN: not llvm-objcopy --set-section-type=.foo=aaa %t /dev/null 2>&1 | FileCheck %s --check-prefix=INVALID-TYPE
+# INVALID-TYPE: error: invalid value for --set-section-type: 'aaa'
+
+!ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .foo
+    Type:  SHT_NOBITS
+    Flags: [ SHF_ALLOC ]
+  - Name:  .bar
+    Type:  SHT_PROGBITS
+    Flags: [ ]

llvm/tools/llvm-objcopy/ObjcopyOptions.cpp

if (!ParsedFlagSet)
       return ParsedFlagSet.takeError();
     SR.NewFlags = *ParsedFlagSet;
   }
 
   return SR;
 }
 
 static Expected<std::pair<StringRef, uint64_t>>
-parseSetSectionAlignment(StringRef FlagValue) {
+parseSetSectionAttribute(StringRef Option, StringRef FlagValue) {
   if (!FlagValue.contains('='))
-    return createStringError(
-        errc::invalid_argument,
-        "bad format for --set-section-alignment: missing '='");
+    return make_error<StringError>("bad format for " + Option + ": missing '='",
+                                   errc::invalid_argument);
   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,
-        "invalid alignment for --set-section-alignment: '%s'",
-        Split.second.str().c_str());
-  return std::make_pair(Split.first, NewAlign);
+    return make_error<StringError>("bad format for " + Option +
+                                       ": missing section name",
+                                   errc::invalid_argument);
+  uint64_t Value;
+  if (Split.second.getAsInteger(0, Value))
+    return make_error<StringError>("invalid value for " + Option + ": '" +
+                                       Split.second + "'",
+                                   errc::invalid_argument);
+  return std::make_pair(Split.first, Value);
 }
 
 static Expected<SectionFlagsUpdate>
 parseSetSectionFlagValue(StringRef FlagValue) {
   if (!StringRef(FlagValue).contains('='))
     return createStringError(errc::invalid_argument,
                              "bad format for --set-section-flags: missing '='");
 
parseSetSectionFlagValue(StringRef FlagValue) {
   if (!ParsedFlagSet)
     return ParsedFlagSet.takeError();
   SFU.NewFlags = *ParsedFlagSet;
 
   return SFU;
 }
 
 namespace {
 struct TargetInfo {
   FileFormat Format;
   MachineInfo Machine;
 };
 } // namespace
 
 // FIXME: consolidate with the bfd parsing used by lld.
 static const StringMap<MachineInfo> TargetMap{
     // Name, {EMachine, 64bit, LittleEndian}
     // x86
     {"elf32-i386", {ELF::EM_386, false, true}},
     {"elf32-x86-64", {ELF::EM_X86_64, false, true}},
     {"elf64-x86-64", {ELF::EM_X86_64, true, true}},
     // Intel MCU
     {"elf32-iamcu", {ELF::EM_IAMCU, false, true}},
     // ARM
     {"elf32-littlearm", {ELF::EM_ARM, false, true}},
     // ARM AArch64
     {"elf64-aarch64", {ELF::EM_AARCH64, true, true}},
if (!SR)
       return SR.takeError();
     if (!Config.SectionsToRename.try_emplace(SR->OriginalName, *SR).second)
       return createStringError(errc::invalid_argument,
                                "multiple renames of section '%s'",
                                SR->OriginalName.str().c_str());
   }
   for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_alignment)) {
     Expected<std::pair<StringRef, uint64_t>> NameAndAlign =
-        parseSetSectionAlignment(Arg->getValue());
+        parseSetSectionAttribute("--set-section-alignment", Arg->getValue());
     if (!NameAndAlign)
       return NameAndAlign.takeError();
     Config.SetSectionAlignment[NameAndAlign->first] = NameAndAlign->second;
   }
   for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_flags)) {
     Expected<SectionFlagsUpdate> SFU =
         parseSetSectionFlagValue(Arg->getValue());
     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
-  // as the destination of a --rename-section.
+  for (auto Arg : InputArgs.filtered(OBJCOPY_set_section_type)) {
+    Expected<std::pair<StringRef, uint64_t>> NameAndType =
+        parseSetSectionAttribute("--set-section-type", Arg->getValue());
+    if (!NameAndType)
+      return NameAndType.takeError();
+    Config.SetSectionType[NameAndType->first] = NameAndType->second;
+  }
+  // Prohibit combinations of --set-section-{flags,type} when the section name
+  // is used as the destination of a --rename-section.
   for (const auto &E : Config.SectionsToRename) {
     const SectionRename &SR = E.second;
-    if (Config.SetSectionFlags.count(SR.NewName))
+    auto Err = [&](const char *Option) {
       return createStringError(
           errc::invalid_argument,
-          "--set-section-flags=%s conflicts with --rename-section=%s=%s",
+          "--set-section-%s=%s conflicts with --rename-section=%s=%s", Option,
           SR.NewName.str().c_str(), SR.OriginalName.str().c_str(),
           SR.NewName.str().c_str());
+    };
+    if (Config.SetSectionFlags.count(SR.NewName))
+      return Err("flags");
+    if (Config.SetSectionType.count(SR.NewName))
+      return Err("type");
   }
 
   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(
             Arg->getValue(), SectionMatchStyle, ErrorCallback)))

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 of section <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">;