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

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–242

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-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
+  // as 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))
+    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 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">;