[llvm-objcopy] Add --prefix-alloc-sections

[seiya]

Summary

This patch adds support for --prefix-alloc-sections, which adds a prefix to every allocated section names.

It adds a prefix after renaming section names by --rename-section as GNU objcopy does.

Fixes PR41266: https://bugs.llvm.org/show_bug.cgi?id=41266

[rupprecht]

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

16

section content seems irrelevant to this test, so I think you can just remove content/--section-data

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

679

Typical llvm style is to only include braces if there is more than one statement, i.e. this should just be:

if (!Config.AllocSectionsPrefix.empty())
  for (auto &Sec : Obj.sections())
    if ((Sec.Flags & SHF_ALLOC) != 0)
      Sec.Name = (Config.AllocSectionsPrefix + Sec.Name).str();

[seiya]

• Removed section contents from tests.
• Removed braces.

[rupprecht]

Looks good to me, thanks! Do you need one of us to commit on your behalf?

[seiya]

Thank you for taking your time!

Looks good to me, thanks! Do you need one of us to commit on your behalf?

Yes please.

[jhenderson]

Thanks for the patch. Before this goes in, I'd like to ask one question:

Does GNU objcopy do anything with relocation sections to sections with changed names. I suspect that it renames them to match, but I don't think this patch does that.

llvm/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

176–177

Nit: It would probably make sense for this to swap with Config.AddSection.empty() to match the member order.

llvm/tools/llvm-objcopy/CopyConfig.cpp

502

Nit: this line hasn't been clang-formatted.

[seiya]

In D60042#1451203, @jhenderson wrote:

Thanks for the patch. Before this goes in, I'd like to ask one question:

Does GNU objcopy do anything with relocation sections to sections with changed names. I suspect that it renames them to match, but I don't think this patch does that.

It seems so:

$ echo "int x; int foo() { return x; }" > test.c
$ clang -c test.c -o test.o
$ objcopy --prefix-alloc-sections=.alloc_prefix test.o
$ llvm-readobj --sections test.o | grep Name
LoadName:
    Name:  (0)
    Name: .alloc_prefix.text (32)
    Name: .rela.alloc_prefix.text (27)
    Name: .comment (51)
    Name: .note.GNU-stack (60)
    Name: .alloc_prefix.eh_frame (81)
    Name: .rela.alloc_prefix.eh_frame (76)
    Name: .symtab (1)
    Name: .strtab (9)
    Name: .shstrtab (17)

I'll update the patch to handle this.

[seiya]

• Rename relocation section names associated to the allocated sections.

[jakehehrlich]

I'm not sure I like renaming and I'm not sure anyone requires that behavior. It also introduces n^2 behavior which I don't like. That should be removed at the very least.

Also don't we already have an update sections loop somewhere in this already? I think this should go there to reduce the number of passes we make over the sections

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

679

Do we follow that even for such deep nestings? I think I've only been doing it 2 layers deep before I add brackets to the outer most block.

[rupprecht]

In D60042#1452652, @jakehehrlich wrote:

I'm not sure I like renaming and I'm not sure anyone requires that behavior.

From the bug in the patch description, this is used by linux here: https://github.com/ClangBuiltLinux/linux/blob/master/drivers/firmware/efi/libstub/Makefile#L75

(I don't have time to review the latest patch tonight, but I can take a look tomorrow)

[jakehehrlich]

Ah well then we should implement that behavior. We should get rid of the n^2 loop however.

[rupprecht]

Also don't we already have an update sections loop somewhere in this already? I think this should go there to reduce the number of passes we make over the sections

It looks like we already have multiple loops over the sections so that some flags can apply on top of each other, though it's possible a few of the passes could be combined. O(n^2) is really the only real performance killer though, simply iterating over sections multiple times is a *much* less bigger deal.

Quick check:

grep -c ": Obj.sections())" llvm/tools/llvm-objcopy/ELF/* | grep -v :0
llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp:6
llvm/tools/llvm-objcopy/ELF/Object.cpp:11

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

4

It'd be good to check --relocs as well

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

685

Instead of the O(n^2) loop over the sections, you can do it one pass:

• If Name == Config.AllocSectionsPrefix then do the usual rename
• If is_a<RelocationSectionBase>(&Sec) and dyn_cast<RelocationSectionbase>(&Sec)->getSection()->getName() == Config.AllocSectionsPrefix, then change based on the .rel/.rela pattern below

getSection() is probably not well named since that makes it sound like a regular getter, it should probably be getTargetSection() or similar.

[seiya]

• Rename sections in one pass.
• Check --relocs in a test.

[jhenderson]

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

4

Dumb question maybe, but what does this give us?

llvm/test/tools/llvm-objcopy/ELF/rename-section-and-prefix-alloc-sections.test

18

Not that it really matters, but you don't need the SHF_EXECINSTR here, as it has no impact on the behaviour.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

681

Hmm... What does GNU objcopy do for dynamic relocation sections (i.e. SHT_REL[A] with SHF_ALLOC)? Will it rename them according to the switch, or something else (e.g. renaming based on their target section). In other words, if for example I had a .rela.plt section targeting .plt and I did --prefix-alloc-sections=.foo, do you get .foo.rela.plt or .rela.foo.plt or something else?

You need a test case for this too.

[seiya]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

681

It seems that GNU objcopy does not support such sections [1]. It produces .foo.rela.plt but does not preserve its link field:

$ readelf -S hello
There are 29 section headers, starting at offset 0x19e0:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .prefix.interp    PROGBITS         0000000000000238  00000238
       000000000000001c  0000000000000000   A       0     0     1
  [ 2] .prefix.note.ABI- NOTE             0000000000000254  00000254
       0000000000000020  0000000000000000   A       0     0     4
  [ 3] .prefix.note.gnu. NOTE             0000000000000274  00000274
       0000000000000024  0000000000000000   A       0     0     4
  [ 4] .prefix.gnu.hash  GNU_HASH         0000000000000298  00000298
       000000000000001c  0000000000000000   A       5     0     8
readelf: Warning: [ 5]: Link field (0) should index a string section.
  [ 5] .prefix.dynsym    DYNSYM           00000000000002b8  000002b8
       00000000000000a8  0000000000000018   A       0     1     8
  [ 6] .prefix.dynstr    STRTAB           0000000000000360  00000360
       0000000000000082  0000000000000000   A       0     0     1
  [ 7] .prefix.gnu.versi VERSYM           00000000000003e2  000003e2
       000000000000000e  0000000000000002   A       5     0     2
  [ 8] .prefix.gnu.versi VERNEED          00000000000003f0  000003f0
       0000000000000020  0000000000000000   A       6     1     8
readelf: Warning: [ 9]: Link field (0) should index a symtab section.
  [ 9] .prefix.rela.dyn  RELA             0000000000000410  00000410
       00000000000000c0  0000000000000018   A       0     0     8
readelf: Warning: [10]: Link field (0) should index a symtab section.
  [10] .prefix.rela.plt  RELA             00000000000004d0  000004d0
       0000000000000018  0000000000000018   A       0     0     8
  [11] .prefix.init      PROGBITS         00000000000004e8  000004e8
       0000000000000017  0000000000000000  AX       0     0     4
  [12] .prefix.plt       PROGBITS         0000000000000500  00000500
       0000000000000020  0000000000000010  AX       0     0     16
  [13] .prefix.plt.got   PROGBITS         0000000000000520  00000520
       0000000000000008  0000000000000008  AX       0     0     8
  [14] .prefix.text      PROGBITS         0000000000000530  00000530
       00000000000001a2  0000000000000000  AX       0     0     16
  [15] .prefix.fini      PROGBITS         00000000000006d4  000006d4
       0000000000000009  0000000000000000  AX       0     0     4
  [16] .prefix.rodata    PROGBITS         00000000000006e0  000006e0
       000000000000000a  0000000000000000   A       0     0     4
  [17] .prefix.eh_frame_ PROGBITS         00000000000006ec  000006ec
       000000000000003c  0000000000000000   A       0     0     4
  [18] .prefix.eh_frame  PROGBITS         0000000000000728  00000728
       0000000000000108  0000000000000000   A       0     0     8
  [19] .prefix.init_arra INIT_ARRAY       0000000000200db8  00000db8
       0000000000000008  0000000000000008  WA       0     0     8
  [20] .prefix.fini_arra FINI_ARRAY       0000000000200dc0  00000dc0
       0000000000000008  0000000000000008  WA       0     0     8
readelf: Warning: [21]: Link field (0) should index a string section.

I'll add a test case for this.

[1]: https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=bfd/elf.c;h=952e4bfe11b4a222823a31d07615007e91b519ba;hb=HEAD#l2398

[seiya]

• Updated a test case for dynamic relocation sections (SHT_REL[A] with SHF_ALLOC).
  • This makes sure that .rela.plt is renamed to .prefix.rela.plt, not .rela.prefix.plt (GNU objcopy does so).
• Removed an unnecessary flag from a test.

[jhenderson]

LGTM, but please wait for one of the other reviewers too.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

686

Probably worth a comment saying that this doesn't apply to dynamic relocation sections and why.

[jhenderson]

llvm/tools/llvm-objcopy/ObjcopyOpts.td

242

Nit: names -> name

[seiya]

• Added a comment which describes how it handles dynamic relocations sections and why.
• Fixed a help message.

[seiya]

• Removed a redundant whitespace from a comment.

[jhenderson]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

689

Nit: remove the "in".

[rupprecht]

Just a couple small comments, but also LGTM

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

60

Checking the } isn't necessary (unless you're checking a whole section w/ CHECK-NEXT)

llvm/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

176–177

I think this block needs to be clang formatted

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

706–710

Can you add a comment why this block is necessary?

It looks like all the test coverage is .rel sections coming after their target section. Is it possible to add a test case for the other half of this clause? e.g. a section w/ .rel.data coming before .data?

[seiya]

• Updated a test case to test that it renames properly when a relocation section comes before its target section.
• Removed unnecessary } from a test.
• Added a comment which describes the case when a relocation section comes before its target section.
• Fixed a comment.
• Applied clang-format.

[jhenderson]

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

4

I'm still not sure what extra coverage --relocs gives us. Could somebody explain, please?

[seiya]

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

4

I think it would be good to make sure that this feature (--prefix-alloc-sections) does not destroy the contents of relocation sections other than their names. I should add a comment here.

How do you think @rupprecht ?

[rupprecht]

I'm out the rest of the week, I'll leave it to James to do the commit on your behalf

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

4

After talking to James offline, the --relocs effectively isn't testing anything in addition to what's already covered, so it should be fine to remove. Sorry for suggesting that.

[seiya]

• Removed --relocs from a test.

[seiya]

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

4

No problem! I've updated the diff.

[jhenderson]

Having looked at this a bit more, I wonder if this should be part of the existing SectionsToRename loop. After all, there isn't much difference between the two behaviours, apart from the fact that this new switch doesn't change the flags. Would you mind folding the two loops together? As a side effect of this, I expect you might want to rename relocation sections when --rename-section alone is used, which I don't think is currently happening.

Also @jakehehrlich explicitly requested changes, I'd like him to give a thumbs up before I commit this. Thanks for the work @seiya!

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

584–586

This is the loop I'm talking about in the out-of-line comment.

[seiya]

In D60042#1462369, @jhenderson wrote:

Having looked at this a bit more, I wonder if this should be part of the existing SectionsToRename loop. After all, there isn't much difference between the two behaviours, apart from the fact that this new switch doesn't change the flags. Would you mind folding the two loops together? As a side effect of this, I expect you might want to rename relocation sections when --rename-section alone is used, which I don't think is currently happening.

That's a good idea. I'll fold them together.

[seiya]

• Merged the existing SectionsToRename loop and the AllocSectionsPrefix loop into a single loop.

[jhenderson]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

583

You should probably keep this if, but expand it to be:
if (!Config.SectionsToRename.empty() || !Config.AllocSectionsPrefix.empty())

That will mean that this loop only happens if one or both of the options is specified.

602

Nit config -> Config to match the variable name.

[seiya]

• Check if one or both of --rename-section/--prefix-alloc-sections options is specified.
• Fixed a comment.

[jhenderson]

LGTM. As I mentioned earlier, @jakehehrlich should review this before it gets committed. However, he may be away, so you might have to wait a few days.

[jakehehrlich]

A few comments.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

609

You can do if (auto *RelocSec = dyn_cast<RelocationSectionBase>(&Sec)) and then SectionBase *TargetSec = RelocSec->getSection()

609

I forget. Does this apply to dynamic relocation sections as well? Does this flag rename the dynamic relocation section? My hunch is that it doesn't.

628

This is not a good way to do this.

I think the right way is to have the "OriginalName" and do this in a non-conditional way. I tried thinking about a bunch of alternatives but they all have sticky issues. Your best bet is to just add OriginalName to SectionBase and unconditionally assign the section name here.

[seiya]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

609

Yes. This flag renames dynamic relocation sections too. It seems that GNU objcopy simply checks whether ALLOC flag is set:

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;a=blob;f=binutils/objcopy.c;h=330b93c1ad3f87a0f5777ac88dc4af1398959bbe;hb=HEAD#l3772

628

I think that's not sufficient. If both --rename-section and --prefix-alloc-sections are given, GNU objcopy renames sections by --rename-section first and then adds the prefix specified by --prefix-alloc-sections.

For example, --rename-section=.text=.text2 --prefix-alloc-sections=.prefix renames .rel.text to .rel.prefix.text2.

It looks that the current patch only renames correctly if the target section comes before its relocation section by the way.

I have two ideas:

• Iterate sections twice: rename sections first and then add the prefix.
• Add Renamed flag to SectionBase: check the flag here and rename the section if needed.

I would like to hear your thoughts on this @jakehehrlich .

[seiya]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

628

Or add OriginalName to SectionBase and use Config.SectionsToRename here:

const auto Iter = Config.SectionsToRename.find(TargetSec->OriginalName);
if (Iter != Config.SectionsToRename.end()) {
  // Both `--rename-section` and `--prefix-alloc-sections` are given.
  const SectionRename &SR = Iter->second;
  Sec.Name = (prefix + Config.AllocSectionsPrefix + SR.NewName).str();
} else {
  Sec.Name = (prefix + Config.AllocSectionsPrefix + TargetSec->Name).str();
}

[jakehehrlich]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

609

Can you add a test case for this. We have a binary checked in that you can use. I want to make sure it isn't double renamed and all that. It's just a slightly more tricky real world use case.

628

Ah right, good catch. I think the proposal you just gave is better than what we currently have but the issue of the section being renamed should probably happen more smoothly I suppose. In principal we could add a new mechanism for section renaming in the future which would invalidate this and then require us to update it in the future.

What if you build a map of renamed sections here and then check if the section is renamed. That should avoid the fragility of checking for the prefix like this.

[seiya]

• Use dyn_cast
• Add PrefixedSections to check whether the target section is already prefixed AllocSectionsPrefix.
• Handle the case when --rename-section and --prefix-alloc-sections are given and the relocation section comes before its target section.

[seiya]

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

55

This .rela.plt is a testcase what I mean.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

609

We have a test case which renames dynamic relocation sections. Should I clarify that in a comment or add a test case against a binary file, say, test/tools/llvm-objcopy/ELF/Inputs/dynrel.elf?

[jakehehrlich]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

609

Those two cases are slightly different and reflects more realistic set up than the yaml file does. Should be a short 5 or so line test.

629

I'm *really* against doing this kind of string searching when we can build a map. What if a section already contains the prefix being used. This won't be consistent in that case.

Also you should add a test case for that above.

[seiya]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

629

Let me clarify my understanding a bit. You mean a map which contains a pointer to a section like DenseSet<SectionBase *> PrefixedSections?

[jakehehrlich]

LGTM

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

629

Ah whoops. I saw "find" and thought it hadn't changed. Big mistake on my part. Sorry. This LGTM.

[seiya]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

629

Thank you for your comment. I'll update the patch.

[seiya]

• Add a test case: a section which already has the prefix specified by this option (.prefix.already_prefixed).
• Use ELF/Inputs/dynrel.elf in a test instead of a binary constructed by yaml2obj.
• Store a pointer to a SectionBase in PrefixedSections instead of its name.

[seiya]

• Rename a test file.

[jhenderson]

llvm/test/tools/llvm-objcopy/ELF/rename-section-and-prefix-alloc-sections.test

2

In this test, you don't really want to test the cases that you already tested in the main --prefix-alloc-sections test. As a result, you can probably remove the bar section, at the very least, nor do you need to test a section that isn't renamed at all.

I'm also not sure you get anything by testing two different section renames.

[seiya]

llvm/test/tools/llvm-objcopy/ELF/rename-section-and-prefix-alloc-sections.test

2

Indeed. I'll remove the test.

I'm also not sure you get anything by testing two different section renames.

We should test the cases when the relocation section comes after/before its target section because this patch deals with them differently to perform both --rename-section and --prefix-alloc-sections in one pass.

I'll update the patch to mention it in this test file.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

633

I mean this if block.

[seiya]

• Add a comment in rename-section-and-prefix-alloc-sections.test.
• Remove some test cases which already tested in another test.

[jhenderson]

Great! LGTM. Would you like me to commit it?

[MaskRay]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

599

It looks most other places don't put != 0

[MaskRay]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

629

PrefixedSections.count(TargetSec)

[jhenderson]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

599

Hmm... I find != 0 easier to read personally, but I don't feel strongly about it.

[seiya]

• Applied feedbacks from @MaskRay. NFC.

[seiya]

In D60042#1487388, @jhenderson wrote:

Great! LGTM. Would you like me to commit it?

Yes please if it got accepted by others :)

[jhenderson]

In D60042#1490712, @seiya wrote:

In D60042#1487388, @jhenderson wrote:

Great! LGTM. Would you like me to commit it?

Yes please if it got accepted by others :)

Okay. As @MaskRay had some previous comments, I'll give him a chance to review further before committing.

[MaskRay]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

637

How about Sec.Name = (prefix + Config.AllocSectionsPrefix + Iter->second.NewName).str();

[seiya]

• Cleaned up the code a bit (suggested by @MaskRay). NFC.

[seiya]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

637

Looks better. Thanks.

[jhenderson]

Great! I'll get this landed later today.

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections-dynrelocsec.test

+# RUN: llvm-objcopy --prefix-alloc-sections=.prefix %p/Inputs/dynrel.elf %t
+# RUN: llvm-readobj --sections %t | FileCheck %s
+
+# CHECK: Name: .prefix.rela.plt
+# CHECK: Name: .prefix.plt

llvm/test/tools/llvm-objcopy/ELF/prefix-alloc-sections.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy --prefix-alloc-sections=.prefix %t %t2
+# RUN: llvm-readobj --sections %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .foo
+    Type:            SHT_PROGBITS
+    Flags:           [  ]
+  - Name:            .prefix.already_prefixed
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Info:            .text
+  - Name:            .rela.data
+    Type:            SHT_RELA
+    Info:            .data
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+
+# CHECK: Name: .foo
+# CHECK: Name: .prefix.prefix.already_prefixed
+# CHECK: Name: .prefix.text
+# CHECK: Name: .rel.prefix.text
+# CHECK: Name: .rela.prefix.data
+# CHECK: Name: .prefix.data

llvm/test/tools/llvm-objcopy/ELF/rename-section-and-prefix-alloc-sections.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy --rename-section=.text=.text2 --rename-section=.data=.data2 --prefix-alloc-sections=.prefix %t %t2
+# RUN: llvm-readobj --sections %t2 | FileCheck %s
+
+# .text/.rel.text and .data/.rela.data are the cases when the relocation section
+# comes after/before its target section respectively. We handle them in different
+# ways to perform both --rename-section and --prefix-alloc-sections in one pass.
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Info:            .text
+  - Name:            .rela.data
+    Type:            SHT_RELA
+    Info:            .data
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+
+# CHECK: Name: .prefix.text2
+# CHECK: Name: .rel.prefix.text2
+# CHECK: Name: .rela.prefix.data2
+# CHECK: Name: .prefix.data2

llvm/tools/llvm-objcopy/COFF/COFFObjcopy.cpp

if (!Sym.Referenced) {
         return true;
     }
 
     return false;
   });
 
   if (!Config.AddGnuDebugLink.empty())
     addGnuDebugLink(Obj, Config.AddGnuDebugLink);
 
   if (Config.AllowBrokenLinks || !Config.BuildIdLinkDir.empty() ||
       Config.BuildIdLinkInput || Config.BuildIdLinkOutput ||
       !Config.SplitDWO.empty() || !Config.SymbolsPrefix.empty() ||
-      !Config.AddSection.empty() || !Config.DumpSection.empty() ||
-      !Config.KeepSection.empty() || !Config.SymbolsToGlobalize.empty() ||
-      !Config.SymbolsToKeep.empty() || !Config.SymbolsToLocalize.empty() ||
-      !Config.SymbolsToWeaken.empty() || !Config.SymbolsToKeepGlobal.empty() ||
-      !Config.SectionsToRename.empty() || !Config.SetSectionFlags.empty() ||
-      !Config.SymbolsToRename.empty() || Config.ExtractDWO ||
-      Config.KeepFileSymbols || Config.LocalizeHidden || Config.PreserveDates ||
-      Config.StripDWO || Config.StripNonAlloc || Config.StripSections ||
-      Config.Weaken || Config.DecompressDebugSections ||
+      !Config.AllocSectionsPrefix.empty() || !Config.AddSection.empty() ||
+      !Config.DumpSection.empty() || !Config.KeepSection.empty() ||
+      !Config.SymbolsToGlobalize.empty() || !Config.SymbolsToKeep.empty() ||
+      !Config.SymbolsToLocalize.empty() || !Config.SymbolsToWeaken.empty() ||
+      !Config.SymbolsToKeepGlobal.empty() || !Config.SectionsToRename.empty() ||
+      !Config.SetSectionFlags.empty() || !Config.SymbolsToRename.empty() ||
+      Config.ExtractDWO || Config.KeepFileSymbols || Config.LocalizeHidden ||
+      Config.PreserveDates || Config.StripDWO || Config.StripNonAlloc ||
+      Config.StripSections || Config.Weaken || Config.DecompressDebugSections ||
       Config.DiscardMode == DiscardType::Locals ||
       !Config.SymbolsToAdd.empty() || Config.EntryExpr) {
     return createStringError(llvm::errc::invalid_argument,
                              "Option not supported by llvm-objcopy for COFF");
   }
 
   return Error::success();
 }

llvm/tools/llvm-objcopy/CopyConfig.h

struct CopyConfig {
 
   // Advanced options
   StringRef AddGnuDebugLink;
   StringRef BuildIdLinkDir;
   Optional<StringRef> BuildIdLinkInput;
   Optional<StringRef> BuildIdLinkOutput;
   StringRef SplitDWO;
   StringRef SymbolsPrefix;
+  StringRef AllocSectionsPrefix;
   DiscardType DiscardMode = DiscardType::None;
 
   // Repeated options
   std::vector<StringRef> AddSection;
   std::vector<StringRef> DumpSection;
   std::vector<NewSymbolInfo> SymbolsToAdd;
   std::vector<NameOrRegex> KeepSection;
   std::vector<NameOrRegex> OnlySection;

llvm/tools/llvm-objcopy/CopyConfig.cpp

Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   if (InputArgs.hasArg(OBJCOPY_build_id_link_input))
     Config.BuildIdLinkInput =
         InputArgs.getLastArgValue(OBJCOPY_build_id_link_input);
   if (InputArgs.hasArg(OBJCOPY_build_id_link_output))
     Config.BuildIdLinkOutput =
         InputArgs.getLastArgValue(OBJCOPY_build_id_link_output);
   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
   Config.SymbolsPrefix = InputArgs.getLastArgValue(OBJCOPY_prefix_symbols);
+  Config.AllocSectionsPrefix =
+      InputArgs.getLastArgValue(OBJCOPY_prefix_alloc_sections);
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbol)) {
     if (!StringRef(Arg->getValue()).contains('='))
       return createStringError(errc::invalid_argument,
                                "Bad format for --redefine-sym");
     auto Old2New = StringRef(Arg->getValue()).split('=');
     if (!Config.SymbolsToRename.insert(Old2New).second)
       return createStringError(errc::invalid_argument,

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

 //===- ELFObjcopy.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ELFObjcopy.h"
 #include "Buffer.h"
 #include "CopyConfig.h"
 #include "Object.h"
 #include "llvm-objcopy.h"
 
 #include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Object/Binary.h"
static Error handleArgs(const CopyConfig &Config, Object &Obj,
   // us to avoid reporting the inappropriate errors about removing symbols
   // named in relocations.
   if (Error E = replaceAndRemoveSections(Config, Obj))
     return E;
 
   if (Error E = updateAndRemoveSymbols(Config, Obj))
     return E;
 
-  if (!Config.SectionsToRename.empty()) {
+  if (!Config.SectionsToRename.empty() || !Config.AllocSectionsPrefix.empty()) {
+    DenseSet<SectionBase *> PrefixedSections;
     for (auto &Sec : Obj.sections()) {
       const auto Iter = Config.SectionsToRename.find(Sec.Name);
       if (Iter != Config.SectionsToRename.end()) {
         const SectionRename &SR = Iter->second;
         Sec.Name = SR.NewName;
         if (SR.NewFlags.hasValue())
           setSectionFlagsAndType(Sec, SR.NewFlags.getValue());
       }
+
+      // Add a prefix to allocated sections and their relocation sections. This
+      // should be done after renaming the section by Config.SectionToRename to
+      // imitate the GNU objcopy behavior.
+      if (!Config.AllocSectionsPrefix.empty()) {
+        if (Sec.Flags & SHF_ALLOC) {
+          Sec.Name = (Config.AllocSectionsPrefix + Sec.Name).str();
+          PrefixedSections.insert(&Sec);
+
+        // Rename relocation sections associated to the allocated sections.
+        // For example, if we rename .text to .prefix.text, we also rename
+        // .rel.text to .rel.prefix.text.
+        //
+        // Dynamic relocation sections (SHT_REL[A] with SHF_ALLOC) are handled
+        // above, e.g., .rela.plt is renamed to .prefix.rela.plt, not
+        // .rela.prefix.plt since GNU objcopy does so.
+        } else if (auto *RelocSec = dyn_cast<RelocationSectionBase>(&Sec)) {
+          auto *TargetSec = RelocSec->getSection();
+          if (TargetSec && (TargetSec->Flags & SHF_ALLOC)) {
+            StringRef prefix;
+            switch (Sec.Type) {
+            case SHT_REL:
+              prefix = ".rel";
+              break;
+            case SHT_RELA:
+              prefix = ".rela";
+              break;
+            default:
+              continue;
+            }
+
+            // If the relocation section comes *after* the target section, we
+            // don't add Config.AllocSectionsPrefix because we've already added
+            // the prefix to TargetSec->Name. Otherwise, if the relocation
+            // section comes *before* the target section, we add the prefix.
+            if (PrefixedSections.count(TargetSec)) {
+              Sec.Name = (prefix + TargetSec->Name).str();
+            } else {
+              const auto Iter = Config.SectionsToRename.find(TargetSec->Name);
+              if (Iter != Config.SectionsToRename.end()) {
+                // Both `--rename-section` and `--prefix-alloc-sections` are
+                // given but the target section is not yet renamed.
+                Sec.Name =
+                    (prefix + Config.AllocSectionsPrefix + Iter->second.NewName)
+                        .str();
+              } else {
+                Sec.Name =
+                    (prefix + Config.AllocSectionsPrefix + TargetSec->Name)
+                        .str();
+              }
+            }
+          }
+        }
+      }
     }
   }
 
   if (!Config.SetSectionFlags.empty()) {
     for (auto &Sec : Obj.sections()) {
       const auto Iter = Config.SetSectionFlags.find(Sec.Name);
       if (Iter != Config.SetSectionFlags.end()) {
         const SectionFlagsUpdate &SFU = Iter->second;
ArrayRef<uint8_t> Data(
         reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
         Buf->getBufferSize());
     OwnedDataSection &NewSection =
         Obj.addSection<OwnedDataSection>(SecName, Data);
     if (SecName.startswith(".note") && SecName != ".note.GNU-stack")
       NewSection.Type = SHT_NOTE;
   }
 
   for (const auto &Flag : Config.DumpSection) {
     std::pair<StringRef, StringRef> SecPair = Flag.split("=");
     StringRef SecName = SecPair.first;
     StringRef File = SecPair.second;
     if (Error E = dumpSectionToFile(SecName, File, Obj))
       return createFileError(Config.InputFilename, std::move(E));
   }
 
   if (!Config.AddGnuDebugLink.empty())
     Obj.addSection<GnuDebugLinkSection>(Config.AddGnuDebugLink);
 
   for (const NewSymbolInfo &SI : Config.SymbolsToAdd) {
     SectionBase *Sec = Obj.findSection(SI.SectionName);
     uint64_t Value = Sec ? Sec->Addr + SI.Value : SI.Value;
     Obj.SymbolTable->addSymbol(
         SI.SymbolName, SI.Bind, SI.Type, Sec, Value, SI.Visibility,
         Sec ? (uint16_t)SYMBOL_SIMPLE_INDEX : (uint16_t)SHN_ABS, 0);
   }
 
   if (Config.EntryExpr)
     Obj.Entry = Config.EntryExpr(Obj.Entry);
   return Error::success();
 }
 
 Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
                                 Buffer &Out) {
   BinaryReader Reader(Config.BinaryArch, &In);
   std::unique_ptr<Object> Obj = Reader.create();
 
   // Prefer OutputArch (-O<format>) if set, otherwise fallback to BinaryArch
   // (-B<arch>).
   const ElfType OutputElfType = getOutputElfType(
       Config.OutputArch ? Config.OutputArch.getValue() : Config.BinaryArch);
   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
     return E;
   std::unique_ptr<Writer> Writer =
       createWriter(Config, *Obj, Out, OutputElfType);
   if (Error E = Writer->finalize())
     return E;
   return Writer->write();

llvm/tools/llvm-objcopy/ObjcopyOpts.td

 defm dump_section
     : Eq<"dump-section",
          "Dump contents of section named <section> into file <file>">,
       MetaVarName<"section=file">;
 defm prefix_symbols
     : Eq<"prefix-symbols", "Add <prefix> to the start of every symbol name">,
       MetaVarName<"prefix">;
 
+defm prefix_alloc_sections
+    : Eq<"prefix-alloc-sections", "Add <prefix> to the start of every allocated section name">,
+      MetaVarName<"prefix">;
+
 def version : Flag<["--"], "version">,
               HelpText<"Print the version and exit.">;
 def V : Flag<["-"], "V">, Alias<version>;
 defm build_id_link_dir
     : Eq<"build-id-link-dir", "Set directory for --build-id-link-input and "
                               "--build-id-link-output to <dir>">,
       MetaVarName<"dir">;
 defm build_id_link_input