[llvm-readelf][llvm-readobj] - Reimplement the logic of section flags dumping.

[grimar]

Summary

Our logic that dumped the flags was buggy.

For LLVM style it dumped SHF_MASKPROC/SHF_MASKOS named constants, though
they are not flags, but masks.

For GNU style it was just very inconsistent with GNU which has logic
that is not straightforward. Imagine we have sh_flags == 0x90000000.
SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000.
GNU readelf will not print "E" or "Ep" in this case, but will print just
"p". It only will print "E" when no other processor flag is set.
I had to investigate the GNU source to find the algorithm and now our logic should
match it.

[jhenderson]

I don't see any testing for the 'x' flag printing. I think it makes sense to add it here, since the behaviour could be impacted by this patch.

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

128–129

This comment probably belongs with the YAML below.

I'd change the last part of the sentence as follows:

"when have this bits set." -> "when bits in the OS and processor specific ranges are set."

133–134

I'd change as follows:
"GNU readelf does not print "E", it drops this bits, because handles SHF_MASKPROC mask first" -> "GNU readelf does not necessarily print "E", because it handles the SHF_MASKPROC mask first"

148

What is this test case trying to show?

160

Same as above. What is this case trying to show?

179

Same as above. What is this case actually trying to show?

200

What should GNU output do for a MIPS object with SHF_EXCLUDE set, since that value is also a used processor-specific one?

llvm/tools/llvm-readobj/ELFDumper.cpp

1497

It's entirely possible I'm misreading the code (I hate trying to follow bit-wise arithmetic), but isn't this line just a duplicate of the Flags &= ~Flag; above?

1502

a OS -> an OS

1509

It took me quite a long time to identify how this algorithm achieves the stated aim in the comment, and I think it's because this block doesn't make clear in comments that the SHF_EXCLUDE flag is masked off by the masking below. Perhaps a comment here would be a good idea to clarify. Something along the lines of "Mask off all the processor-specific bits. This removes the SHF_EXCLUDE bit if set so that it doesn't also get printed."

[grimar]

• Addressed review comments.

[grimar]

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

148

I wanted to show how we handle the value that is (SHF_MASKOS - 1).
I supposed it is reasonable, because we might have some logic (and we actually have it)
that works with SHF_MASKOS in the code. Hence I tried to check the bounds: a minimal possible value,
the mask itself and something that is almost large as SHF_MASKOS, but != SHF_MASKOS.

Do you think it is excessive?

160

The same, it is SHF_MASKPROC - 1.

179

It's just both SHF_MASKPROC - 1 and SHF_MASKOS - 1 together.
for consistency of .both.flags* and .proc.flags*/.os.flags* tests.

This might test we drop the bits that belong to the right mask probably.

200

If we have:

--- !ELF
FileHeader:
  Class:   ELFCLASS32
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_MIPS
Sections:
  - Name:  .mips
    Type:  SHT_PROGBITS
    Flags: [ SHF_MIPS_STRING ]

Then both GNU readelf and llvm-readelf print "E". I've added a test case to demonstrate.

llvm/tools/llvm-readobj/ELFDumper.cpp

1497

Right! I was expermenting with this code alot and seems forgot to remove this line.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

56

an MIPS -> a MIPS
has the SHF_MIPS_STRING

132

proccessor -> processor

148

I think it's okay to have one not on the boundaries, but I'd change the naming of this and the similar issues elsewhere, since "max" implies it is trying to be the maximum OS-specific flag value, which is not the case (that would be 0xff00000).

183–186

This should probably be in the regular section-flags.test.

I'm not actually sure if any of this test case belongs in this test, as it's not about the architecture really. How about moving it into a new test (e.g. section-flags-os-proc.test)?

203

arbitraty -> arbitrary

[jhenderson]

llvm/tools/llvm-readobj/ELFDumper.cpp

1502

proccessor -> processor

[grimar]

• Addressed review comments.

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

148

I've used "low" and "high" suffixes instead.

183–186

This should probably be in the regular section-flags.test.

OK.

I'm not actually sure if any of this test case belongs in this test, as it's not about the architecture really. How about moving it into a new test (e.g. section-flags-os-proc.test)?

OK, I've also added one more test (.all.possible) there too.

[jhenderson]

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

1 ↗

(On Diff #234049)

Perhaps a top-level comment explaining that this tests the dumping of flags in the respective regions would be a good idea.

110–118 ↗

(On Diff #234049)

I'd rearrange and rename these to be consistent with the previous os and proc ones above:

- Name: .both.flags.low
- Name: .both.flags.high
- Name: .both.flags.mask

llvm/test/tools/llvm-readobj/ELF/section-flags.test

175 ↗

(On Diff #234049)

.unknown -> unknown for consistency with the other sections.

[MaskRay]

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

90 ↗

(On Diff #234049)

Or use EM_NONE

llvm/tools/llvm-readobj/ELFDumper.cpp

1490

Flags -= Flag;

[grimar]

• Addressed review comments.

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

90 ↗

(On Diff #234049)

Nice! I've forgot about EM_NONE.

[jhenderson]

LGTM, with one remaining nit.

llvm/test/tools/llvm-readobj/ELF/section-flags-os-proc.test

5 ↗

(On Diff #234232)

Shouldn't this be above the corresponding RUNs?

llvm/test/tools/llvm-objcopy/ELF/rename-section-flag-osproc-mask.test

 # Note: llvm-readobj prints SHF_EXCLUDE/SHF_MASKPROC since specifying all
 # SHF_MIPS_* flags covers the same bitset.
 
 # MIPS:        Name: .bar
 # MIPS-NEXT:   Type: SHT_PROGBITS
 # MIPS-NEXT:   Flags [
 # MIPS-NEXT:     SHF_ALLOC (0x2)
 # MIPS-NEXT:     SHF_EXCLUDE (0x80000000)
-# MIPS-NEXT:     SHF_MASKPROC (0xF0000000)
 # MIPS-NEXT:     SHF_MIPS_ADDR (0x40000000)
 # MIPS-NEXT:     SHF_MIPS_GPREL (0x10000000)
 # MIPS-NEXT:     SHF_MIPS_LOCAL (0x4000000)
 # MIPS-NEXT:     SHF_MIPS_MERGE (0x20000000)
 # MIPS-NEXT:     SHF_MIPS_NAMES (0x2000000)
 # MIPS-NEXT:     SHF_MIPS_NODUPES (0x1000000)
 # MIPS-NEXT:     SHF_MIPS_NOSTRIP (0x8000000)
 # MIPS-NEXT:     SHF_MIPS_STRING (0x80000000)

llvm/test/tools/llvm-readobj/ELF/section-arch-flags.test

- Name:  .hex
     Type:  SHT_PROGBITS
     Flags: [ SHF_HEX_GPREL ]
 
 # RUN: yaml2obj --docnum 2 %s -o %t-mips.o
 # RUN: llvm-readobj -S %t-mips.o | FileCheck --check-prefix=MIPS-LLVM %s
 # RUN: llvm-readelf -S %t-mips.o | FileCheck --check-prefix=MIPS-GNU %s
 
 # MIPS-GNU: [Nr] Name  Type     Address  Off    Size   ES Flg Lk Inf Al
-# MIPS-GNU: [ 1] .mips PROGBITS 00000000 000034 000000 00 Eop  0   0  0
+# MIPS-GNU: [ 1] .mips PROGBITS 00000000 000034 000000 00  op  0   0  0
 
 # MIPS-LLVM:      Flags [ (0xFF000000)
 # MIPS-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
-## FIXME: we should not print SHF_MASKPROC, because it is a mask value.
-# MIPS-LLVM-NEXT:   SHF_MASKPROC (0xF0000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_ADDR (0x40000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_GPREL (0x10000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_LOCAL (0x4000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_MERGE (0x20000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_NAMES (0x2000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_NODUPES (0x1000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_NOSTRIP (0x8000000)
 # MIPS-LLVM-NEXT:   SHF_MIPS_STRING (0x80000000)
 # MIPS-LLVM-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_MIPS
 Sections:
   - Name:  .mips
     Type:  SHT_PROGBITS
     Flags: [ SHF_MIPS_NODUPES, SHF_MIPS_NAMES, SHF_MIPS_LOCAL, SHF_MIPS_NOSTRIP,
               SHF_MIPS_GPREL, SHF_MIPS_MERGE, SHF_MIPS_ADDR, SHF_MIPS_STRING ]
 
-# RUN: yaml2obj --docnum 3 %s -o %t-x86_64.o
+## Test what we print when an MIPS object when it has SHF_MIPS_STRING flag.
+## SHF_MIPS_STRING has a value of 0x80000000, which matches the value of SHF_EXCLUDE.
+
+# RUN: yaml2obj --docnum 3 %s -o %t-mips-exclude.o
+# RUN: llvm-readobj -S %t-mips-exclude.o | FileCheck --check-prefix=MIPS-EXCLUDE-LLVM %s
+# RUN: llvm-readelf -S %t-mips-exclude.o | FileCheck --check-prefix=MIPS-EXCLUDE-GNU %s
+
+# MIPS-EXCLUDE-LLVM:      Name: .mips
+# MIPS-EXCLUDE-LLVM-NEXT: Type: SHT_PROGBITS
+# MIPS-EXCLUDE-LLVM-NEXT: Flags [ (0x80000000)
+# MIPS-EXCLUDE-LLVM-NEXT:  SHF_EXCLUDE (0x80000000)
+# MIPS-EXCLUDE-LLVM-NEXT:  SHF_MIPS_STRING (0x80000000)
+# MIPS-EXCLUDE-LLVM-NEXT: ]
+
+# MIPS-EXCLUDE-GNU: [Nr] Name  Type     Address  Off    Size   ES Flg Lk Inf Al
+# MIPS-EXCLUDE-GNU: [ 1] .mips PROGBITS 00000000 000034 000000 00   E  0   0  0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_MIPS
+Sections:
+  - Name:  .mips
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_MIPS_STRING ]
+
+# RUN: yaml2obj --docnum 4 %s -o %t-x86_64.o
 # RUN: llvm-readobj -S %t-x86_64.o | FileCheck --check-prefix=X86_64-LLVM %s
 # RUN: llvm-readelf -S %t-x86_64.o | FileCheck --check-prefix=X86_64-GNU %s
 
 # X86_64-LLVM:      Flags [ (0x10000000)
 # X86_64-LLVM-NEXT:   SHF_X86_64_LARGE (0x10000000)
 # X86_64-LLVM-NEXT: ]
 
 # X86_64-GNU: [Nr] Name    Type     Address          Off    Size   ES Flg Lk Inf Al
 # X86_64-GNU: [ 1] .x86_64 PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name:  .x86_64
     Type:  SHT_PROGBITS
     Flags: [ SHF_X86_64_LARGE ]
 
-# RUN: yaml2obj --docnum 4 %s -o %t-arm.o
+# RUN: yaml2obj --docnum 5 %s -o %t-arm.o
 # RUN: llvm-readobj -S %t-arm.o | FileCheck --check-prefix=ARM-LLVM %s
 # RUN: llvm-readelf -S %t-arm.o | FileCheck --check-prefix=ARM-GNU %s
 
 # ARM-LLVM:      Flags [ (0x20000000)
 # ARM-LLVM-NEXT:   SHF_ARM_PURECODE (0x20000000)
 # ARM-LLVM-NEXT: ]
 
 # ARM-GNU: [Nr] Name Type     Address          Off    Size   ES Flg Lk Inf Al
 # ARM-GNU: [ 1] foo  PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_ARM
 Sections:
   - Name:  foo
     Type:  SHT_PROGBITS
     Flags: [ SHF_ARM_PURECODE ]
+
+## SHF_MASKPROC has a value of 0xf0000000, SHF_EXCLUDE has a value of
+## 0x80000000. When SHF_EXCLUDE is mixed with other proccessor specific
+## flags, GNU readelf does not necessarily print "E", because it handles
+## the SHF_MASKPROC mask first. It only prints "E" when there are no other
+## proccessor flags set. Check llvm-readelf output matches GNU.
+
+# RUN: yaml2obj --docnum 6 %s -o %t6.o
+# RUN: llvm-readobj -S %t6.o | FileCheck --check-prefix=OS-PROC-LLVM %s
+# RUN: llvm-readelf -S %t6.o | FileCheck --check-prefix=OS-PROC-GNU %s
+
+# OS-PROC-LLVM:      Name: .os.flags.min
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0x100000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .os.flags.max
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xFE00000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .os.flags.mask
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xFF00000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .proc.flags.min
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0x10000000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .proc.flags.max
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xE0000000)
+# OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .proc.flags.mask
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xF0000000)
+# OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .both.flags.mask
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xFFF00000)
+# OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .both.flags.minvalues
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0x10100000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .both.flags.maxvalues
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xEFE00000)
+# OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .exclude
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0x80000000)
+# OS-PROC-LLVM-NEXT:   SHF_EXCLUDE (0x80000000)
+# OS-PROC-LLVM-NEXT: ]
+# OS-PROC-LLVM:      Name: .unknown
+# OS-PROC-LLVM-NEXT: Type: SHT_PROGBITS
+# OS-PROC-LLVM-NEXT: Flags [ (0xF0000)
+# OS-PROC-LLVM-NEXT: ]
+
+# OS-PROC-GNU:      Section Headers:
+# OS-PROC-GNU-NEXT:  [Nr] Name                  Type     Address          Off    Size   ES Flg Lk Inf Al
+# OS-PROC-GNU-NEXT:  [ 0]                       NULL     0000000000000000 000000 000000 00     0   0  0
+# OS-PROC-GNU-NEXT:  [ 1] .os.flags.min         PROGBITS 0000000000000000 000040 000000 00   o 0   0  0
+# OS-PROC-GNU-NEXT:  [ 2] .os.flags.max         PROGBITS 0000000000000000 000040 000000 00   o 0   0  0
+# OS-PROC-GNU-NEXT:  [ 3] .os.flags.mask        PROGBITS 0000000000000000 000040 000000 00   o 0   0  0
+# OS-PROC-GNU-NEXT:  [ 4] .proc.flags.min       PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
+# OS-PROC-GNU-NEXT:  [ 5] .proc.flags.max       PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
+# OS-PROC-GNU-NEXT:  [ 6] .proc.flags.mask      PROGBITS 0000000000000000 000040 000000 00   p 0   0  0
+# OS-PROC-GNU-NEXT:  [ 7] .both.flags.mask      PROGBITS 0000000000000000 000040 000000 00  op 0   0  0
+# OS-PROC-GNU-NEXT:  [ 8] .both.flags.minvalues PROGBITS 0000000000000000 000040 000000 00  op 0   0  0
+# OS-PROC-GNU-NEXT:  [ 9] .both.flags.maxvalues PROGBITS 0000000000000000 000040 000000 00  op 0   0  0
+# OS-PROC-GNU-NEXT:  [10] .exclude              PROGBITS 0000000000000000 000040 000000 00   E 0   0  0
+# OS-PROC-GNU-NEXT:  [11] .unknown              PROGBITS 0000000000000000 000040 000000 00   x 0   0  0
+
+## Use an arbitraty EM_* machine type that does not have specific SHF_* OS/Processor
+## flags to test what we dump when bits in the OS and processor specific ranges are set.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_386
+Sections:
+  - Name:  .os.flags.min
+    Type:  SHT_PROGBITS
+    ShFlags: 0x00100000
+  - Name:  .os.flags.max
+    Type:  SHT_PROGBITS
+    ShFlags: 0x0FE00000
+  - Name:  .os.flags.mask
+    Type:  SHT_PROGBITS
+    ShFlags: 0x0FF00000
+  - Name:  .proc.flags.min
+    Type:  SHT_PROGBITS
+    ShFlags: 0x10000000
+  - Name:  .proc.flags.max
+    Type:  SHT_PROGBITS
+    ShFlags: 0xE0000000
+  - Name:  .proc.flags.mask
+    Type:  SHT_PROGBITS
+    ShFlags: 0xF0000000
+  - Name:  .both.flags.mask
+    Type:  SHT_PROGBITS
+    ShFlags: 0xFFF00000
+  - Name:  .both.flags.minvalues
+    Type:  SHT_PROGBITS
+    ShFlags: 0x10100000
+  - Name:  .both.flags.maxvalues
+    Type:  SHT_PROGBITS
+    ShFlags: 0xEFE00000
+  - Name:  .exclude
+    Type:  SHT_PROGBITS
+    ShFlags: 0x80000000
+  - Name:  .unknown
+    Type:  SHT_PROGBITS
+    ShFlags: 0x000f0000

llvm/tools/llvm-readobj/ELFDumper.cpp

static const EnumEntry<unsigned> ElfSectionFlags[] = {
   ENUM_ENT(SHF_STRINGS,          "S"),
   ENUM_ENT(SHF_INFO_LINK,        "I"),
   ENUM_ENT(SHF_LINK_ORDER,       "L"),
   ENUM_ENT(SHF_OS_NONCONFORMING, "O"),
   ENUM_ENT(SHF_GROUP,            "G"),
   ENUM_ENT(SHF_TLS,              "T"),
   ENUM_ENT(SHF_COMPRESSED,       "C"),
   ENUM_ENT(SHF_EXCLUDE,          "E"),
-  ENUM_ENT(SHF_MASKOS,           "o"),
-  ENUM_ENT(SHF_MASKPROC,         "p"),
 };
 
 static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
   LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION)
 };
 
 static const EnumEntry<unsigned> ElfARMSectionFlags[] = {
static const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_STRING )
 };
 
 static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
   LLVM_READOBJ_ENUM_ENT(ELF, SHF_X86_64_LARGE)
 };
 
 static std::string getGNUFlags(uint64_t Flags) {
+  // Here we are trying to build the flags string in the same way as GNU does.
+  // It is not that straightforward. Imagine we have sh_flags == 0x90000000.
+  // SHF_EXCLUDE ("E") has a value of 0x80000000 and SHF_MASKPROC is 0xf0000000.
+  // GNU readelf will not print "E" or "Ep" in this case, but will print just
+  // "p". It only will print "E" when no other processor flag is set.
   std::string Str;
-  for (auto Entry : ElfSectionFlags) {
-    uint64_t Flag = Entry.Value & Flags;
-    Flags &= ~Entry.Value;
-    switch (Flag) {
-    case ELF::SHF_WRITE:
-    case ELF::SHF_ALLOC:
-    case ELF::SHF_EXECINSTR:
-    case ELF::SHF_MERGE:
-    case ELF::SHF_STRINGS:
-    case ELF::SHF_INFO_LINK:
-    case ELF::SHF_LINK_ORDER:
-    case ELF::SHF_OS_NONCONFORMING:
-    case ELF::SHF_GROUP:
-    case ELF::SHF_TLS:
-    case ELF::SHF_COMPRESSED:
-    case ELF::SHF_EXCLUDE:
-      Str += Entry.AltName;
-      break;
-    default:
-      if (Flag & ELF::SHF_MASKOS)
-        Str += "o";
-      else if (Flag & ELF::SHF_MASKPROC)
-        Str += "p";
-      else if (Flag)
-        Str += "x";
-    }
-  }
+  bool HasUnknownFlag = false;
+  bool HasOSFlag = false;
+  bool HasProcFlag = false;
+  while (Flags) {
+    // Take the least significant bit as a flag.
+    uint64_t Flag = Flags & -Flags;
+    Flags &= ~Flag;
+
+    // Find the flag in the known flags list.
+    auto I = llvm::find_if(ElfSectionFlags, [=](const EnumEntry<unsigned> &E) {
+      return E.Value == Flag;
+    });
+    if (I != std::end(ElfSectionFlags)) {
+      Str += I->AltName;
+      continue;
+    }
+
+    // If we did not find a matching regular flag, then we deal with an OS
+    // specific flag, proccessor specific flag or an unknown flag.
+    if (Flag & ELF::SHF_MASKOS) {
+      HasOSFlag = true;
+      Flags &= ~ELF::SHF_MASKOS;
+    } else if (Flag & ELF::SHF_MASKPROC) {
+      HasProcFlag = true;
+      // Mask off all the processor-specific bits. This removes the SHF_EXCLUDE
+      // bit if set so that it doesn't also get printed.
+      Flags &= ~ELF::SHF_MASKPROC;
+    } else {
+      HasUnknownFlag = true;
+    }
+  }
+
+  // "o", "p" and "x" are printed last.
+  if (HasOSFlag)
+  if (HasProcFlag)
+  if (HasUnknownFlag)
   return Str;
 }
 
 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
   // Check potentially overlapped processor-specific
   // program header type.
   switch (Arch) {
   case ELF::EM_ARM: