Print unknown section header flags has hex in assembly output

[christof]

Summary

Use hexadecimal notation for section header flags in case we have a section header with flag without a textual/symbolic representation. The hex syntax is introduced in GNU as version 2.27 [1] and was added to llvm in r289785 [2]. A previous change to do was rejected [3] and this change takes the comments there into account.

I've refactored the section header flags printing to detect if there are any flags we have no symbolic section flag for. In such case, print the section header flags as hex instead.

[1] https://sourceware.org/binutils/docs-2.27/as/Section.html
[2] https://reviews.llvm.org/rL289785
[3] https://reviews.llvm.org/D27986

[christof]

To clarify. This patch fixes some cases where:

clang -S file.c -o - | clang -c - -o file.o

is not identical to:

clang -c file.c -o file.o

because the assembly output 'forgets' some of the flags in the output assembly.

This impacts some assembly test that cover the MIPS code generator. In general, code generators that have section header flags without any assembly syntax will now use the new hex notation.

lib/MC/MCSectionELF.cpp

 //===- lib/MC/MCSectionELF.cpp - ELF Code Section Representation ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Format.h"
 
 using namespace llvm;
 
 MCSectionELF::~MCSectionELF() {} // anchor.
 
 // Decides whether a '.section' directive
 // should be printed before the section name.
 bool MCSectionELF::ShouldOmitSectionDirective(StringRef Name,
for (const char *B = Name.begin(), *E = Name.end(); B < E; ++B) {
     else {
       OS << B[0] << B[1]; // Quoted character
       ++B;
     }
   }
   OS << '"';
 }
 
+static inline void clearFlags(unsigned &val, unsigned flags) {
+    val &= ~flags;
+}
+
+// print section header flags to OS and return the set of unknown flags
+static unsigned
+printSectionFlags(raw_ostream &OS, const Triple &T, unsigned Flags) {
+  if (Flags & ELF::SHF_ALLOC) {
+    clearFlags(Flags, ELF::SHF_ALLOC);
+    OS << 'a';
+  }
+  if (Flags & ELF::SHF_EXCLUDE) {
+    clearFlags(Flags, ELF::SHF_EXCLUDE);
+    OS << 'e';
+  }
+  if (Flags & ELF::SHF_EXECINSTR) {
+    clearFlags(Flags, ELF::SHF_EXECINSTR);
+    OS << 'x';
+  }
+  if (Flags & ELF::SHF_GROUP) {
+    clearFlags(Flags, ELF::SHF_GROUP);
+    OS << 'G';
+  }
+  if (Flags & ELF::SHF_WRITE) {
+    clearFlags(Flags, ELF::SHF_WRITE);
+    OS << 'w';
+  }
+  if (Flags & ELF::SHF_MERGE) {
+    clearFlags(Flags, ELF::SHF_MERGE);
+    OS << 'M';
+  }
+  if (Flags & ELF::SHF_STRINGS) {
+    clearFlags(Flags, ELF::SHF_STRINGS);
+    OS << 'S';
+  }
+  if (Flags & ELF::SHF_TLS) {
+    clearFlags(Flags, ELF::SHF_TLS);
+    OS << 'T';
+  }
+
+  // If there are target-specific flags, print them.
+  Triple::ArchType Arch = T.getArch();
+  if (Arch == Triple::xcore) {
+    if (Flags & ELF::XCORE_SHF_CP_SECTION) {
+      clearFlags(Flags, ELF::XCORE_SHF_CP_SECTION);
+      OS << 'c';
+    }
+    if (Flags & ELF::XCORE_SHF_DP_SECTION) {
+      clearFlags(Flags, ELF::XCORE_SHF_DP_SECTION);
+      OS << 'd';
+    }
+  } else if (Arch == Triple::arm || Arch == Triple::armeb ||
+             Arch == Triple::thumb || Arch == Triple::thumbeb) {
+    if (Flags & ELF::SHF_ARM_PURECODE) {
+      clearFlags(Flags, ELF::SHF_ARM_PURECODE);
+      OS << 'y';
+    }
+  }
+  return Flags;
+}
+
 void MCSectionELF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                                         raw_ostream &OS,
                                         const MCExpr *Subsection) const {
 
   if (ShouldOmitSectionDirective(SectionName, MAI)) {
     OS << '\t' << getSectionName();
     if (Subsection) {
       OS << '\t';
if (MAI.usesSunStyleELFSectionSwitchSyntax() &&
     if (Flags & ELF::SHF_EXCLUDE)
       OS << ",#exclude";
     if (Flags & ELF::SHF_TLS)
       OS << ",#tls";
     OS << '\n';
     return;
   }
 
-  OS << ",\"";
-  if (Flags & ELF::SHF_ALLOC)
-    OS << 'a';
-  if (Flags & ELF::SHF_EXCLUDE)
-    OS << 'e';
-  if (Flags & ELF::SHF_EXECINSTR)
-    OS << 'x';
-  if (Flags & ELF::SHF_GROUP)
-    OS << 'G';
-  if (Flags & ELF::SHF_WRITE)
-    OS << 'w';
-  if (Flags & ELF::SHF_MERGE)
-    OS << 'M';
-  if (Flags & ELF::SHF_STRINGS)
-    OS << 'S';
-  if (Flags & ELF::SHF_TLS)
-    OS << 'T';
-
-  // If there are target-specific flags, print them.
-  Triple::ArchType Arch = T.getArch();
-  if (Arch == Triple::xcore) {
-    if (Flags & ELF::XCORE_SHF_CP_SECTION)
-      OS << 'c';
-    if (Flags & ELF::XCORE_SHF_DP_SECTION)
-      OS << 'd';
-  } else if (Arch == Triple::arm || Arch == Triple::armeb ||
-             Arch == Triple::thumb || Arch == Triple::thumbeb) {
-    if (Flags & ELF::SHF_ARM_PURECODE)
-      OS << 'y';
-  }
 
+  OS << ",\"";
+  llvm::SmallString<8> flagText;
+  raw_svector_ostream SOS { flagText };
+  unsigned UnknownFlags = printSectionFlags(SOS, T, Flags);
+  if (UnknownFlags)
+      OS << format_hex(Flags, 0);
+  else
+      OS << flagText;
   OS << '"';
 
   OS << ',';
 
   // If comment string is '@', e.g. as on ARM - use '%' instead
   if (MAI.getCommentString()[0] == '@')
     OS << '%';
   else

test/CodeGen/Mips/2008-07-15-SmallSection.ll

 ; RUN: llc < %s -march=mips -mcpu=mips32 -mips-ssection-threshold=8 -relocation-model=static -mattr=+noabicalls -mgpopt | FileCheck %s
 
 %struct.anon = type { i32, i32 }
 
 @s0 = constant [8 x i8] c"AAAAAAA\00", align 4
 
 ; CHECK: .type  foo,@object
-; CHECK-NEXT: .section .sdata,"aw",@progbits
+; CHECK-NEXT: .section .sdata,"0x10000003",@progbits
 @foo = global %struct.anon { i32 2, i32 3 }
 
 ; CHECK:  .type bar,@object
-; CHECK-NEXT:  .section  .sbss,"aw",@nobits
+; CHECK-NEXT:  .section  .sbss,"0x10000003",@nobits
 @bar = global %struct.anon zeroinitializer 
 
 define i8* @A0() nounwind {
 entry:
   ret i8* getelementptr ([8 x i8], [8 x i8]* @s0, i32 0, i32 0)
 }
 
 define i32 @A1() nounwind {
 entry:
   load i32, i32* getelementptr (%struct.anon, %struct.anon* @foo, i32 0, i32 0), align 8 
   load i32, i32* getelementptr (%struct.anon, %struct.anon* @foo, i32 0, i32 1), align 4 
   add i32 %1, %0
   ret i32 %2
 }
 

test/CodeGen/Mips/mips-shf-gprel.s

 # Check that .sdata and .sbss sections have SHF_MIPS_GPREL flags
 # and proper section types.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o - \
 # RUN:   | llvm-readobj -s | FileCheck %s
 
+# RUN: llvm-mc -filetype=asm -triple=mips-unknown-linux %s -o - \
+# RUN:   | FileCheck -check-prefix=ASM %s
+
   .sdata
   .word 0
 
   .sbss
   .zero 4
 
+# ASM: .section .sdata,"0x10000003",@progbits
+# ASM: .section    .sbss,"0x10000003",@nobits
+
 # CHECK:      Name: .sdata
 # CHECK-NEXT: Type: SHT_PROGBITS
 # CHECK-NEXT: Flags [ (0x10000003)
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT:   SHF_MIPS_GPREL
 # CHECK-NEXT:   SHF_WRITE
 # CHECK-NEXT: ]
 
 # CHECK:      Name: .sbss
 # CHECK-NEXT: Type: SHT_NOBITS
 # CHECK-NEXT: Flags [ (0x10000003)
 # CHECK-NEXT:   SHF_ALLOC
 # CHECK-NEXT:   SHF_MIPS_GPREL
 # CHECK-NEXT:   SHF_WRITE
 # CHECK-NEXT: ]