Use empty symbol name for XCOFF text csect

[stephenpeckham]

Summary

When generating XCOFF, the compiler generates a csect with an internal name. Each function results in a label within the csect. This patch replaces the internal name ".text" with an empty string "". This avoids adding special code to handle a function text() in the source file, and works better with some XCOFF tools that are confused when the csect and the first function have the same address.

[hubert.reinterpretcast]

llvm/lib/MC/MCObjectFileInfo.cpp

923–924

Comment wording suggestion.

llvm/test/CodeGen/PowerPC/aix-pgo-function-sections.ll

123 ↗

(On Diff #538658)

It is somewhat unfortunate that the default tool outputs for empty names is especially bad, but I don't want to hold up this patch on changing that.

llvm/test/CodeGen/PowerPC/aix-text.ll

3

Since this is a new test, I think we should use --symbol-description (same for other case below).

41

I think it should be possible to remove this (and the directive referring to this). Please try to remove the other metadata and attributes (and their uses) as well.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/aix-text.ll

3

@stephenpeckham, while the case where text() is defined needs function-sections to exhibit the failure, there is another case where text() is an external reference that does not need function-sections.

I suggest adding that additional test as well.

[stephenpeckham]

llvm/test/CodeGen/PowerPC/aix-pgo-function-sections.ll

123 ↗

(On Diff #538658)

A change to llvm-objdump that prints a visible string for empty names could be done in another patch.

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/aix-pgo-function-sections.ll

123 ↗

(On Diff #538658)

Sounds good. Such a future patch should probably update all of the cases changed here too (although most of them will continue to pass even without such a future update).

llvm/test/CodeGen/PowerPC/aix-text.ll

3

This test (where text is defined as a function) needs function-sections to exhibit the problem.
A separate test (different source), where text is an undefined function being referenced, exhibits the problem with or without function-sections. In other words, a different test file is needed to capture the additional case.

32–33

I expect we will see these named with the storage mapping class?

36–37

Same comment.

[hubert.reinterpretcast]

LGTM; thanks!

[daltenty]

LGTM with some minor nits

llvm/test/CodeGen/PowerPC/aix-text-ref.ll

7–9

nit: you can remove all this metadata, since it doesn't affect the test. The defaults will be supplied by your llc invocation.

21–25

nit: ditto the earlier comment, you can strip all this metadata out to simplify the test

llvm/test/CodeGen/PowerPC/aix-text.ll

11

nit: ditto the metadata comments about the other test file.

llvm/lib/MC/MCObjectFileInfo.cpp

LSDASection = Ctx->getWasmSection(".rodata.gcc_except_table",
                                     SectionKind::getReadOnlyWithRel());
 
   // TODO: Define more sections.
 }
 
 void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
   // The default csect for program code. Functions without a specified section
   // get placed into this csect. The choice of csect name is not a property of
-  // the ABI or object file format. For example, the XL compiler uses an unnamed
-  // csect for program code.
+  // the ABI or object file format, but various tools rely on the section
+  // name being empty (considering named symbols to be "user symbol names").
   TextSection = Ctx->getXCOFFSection(
-      ".text", SectionKind::getText(),
+      "", SectionKind::getText(),
       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD),
       /* MultiSymbolsAllowed*/ true);
 
   DataSection = Ctx->getXCOFFSection(
       ".data", SectionKind::getData(),
       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD),
       /* MultiSymbolsAllowed*/ true);
 

llvm/test/CodeGen/PowerPC/aix-alias-alignment-2.ll

 ; ASM-NEXT: var3:
 ; ASM-NEXT:      .vbyte     4, 0        # 0xc
 ; ASM-NEXT:      .vbyte     4, 12
 ; ASM-NEXT:      .vbyte     4, 0        # 0x22
 ; ASM-NEXT:      .vbyte     4, 34
 
 ; SYM:      SYMBOL TABLE:
 ; SYM-NEXT: 00000000      df *DEBUG*  00000000 <stdin>
-; SYM-NEXT: 00000000 l       .text  0000008a .text
-; SYM-NEXT: 00000000 g     F .text (csect: .text)   00000000 .foo1
-; SYM-NEXT: 00000030 g     F .text (csect: .text)   00000000 .foo2
-; SYM-NEXT: 00000060 g     F .text (csect: .text)   00000000 .foo3
+; SYM-NEXT: 00000000 l       .text  0000008a 
+; SYM-NEXT: 00000000 g     F .text (csect: )  00000000 .foo1
+; SYM-NEXT: 00000030 g     F .text (csect: )  00000000 .foo2
+; SYM-NEXT: 00000060 g     F .text (csect: )  00000000 .foo3
 ; SYM-NEXT: 00000090 l       .data  00000030 .data
 ; SYM-NEXT: 00000090 g     O .data (csect: .data)   00000000 ConstVector
 ; SYM-NEXT: 00000098 g     O .data (csect: .data)   00000000 var1
 ; SYM-NEXT: 000000a0 g     O .data (csect: .data)   00000000 ConstDataSeq
 ; SYM-NEXT: 000000a8 g     O .data (csect: .data)   00000000 var2
 ; SYM-NEXT: 000000b0 g     O .data (csect: .data)   00000000 ConstArray
 ; SYM-NEXT: 000000b0 g     O .data (csect: .data)   00000000 var3
 ; SYM-NEXT: 000000c0 g     O .data  0000000c foo1
 ; SYM-NEXT: 000000cc g     O .data  0000000c foo2
 ; SYM-NEXT: 000000d8 g     O .data  0000000c foo3
 ; SYM-NEXT: 000000e4 l       .data  00000000 TOC
 ; SYM-NEXT: 000000e4 l     O .data  00000004 ConstVector
 ; SYM-NEXT: 000000e8 l     O .data  00000004 ConstDataSeq
 ; SYM-NEXT: 000000ec l     O .data  00000004 ConstArray

llvm/test/CodeGen/PowerPC/aix-alias-alignment.ll

 ; OBJ-NEXT:        0: 80 a2 00 00   lwz 5, 0(2)
 ; OBJ-NEXT:       00000002:  R_TOC  _MergedGlobals
 ; OBJ-NEXT:        4: 90 65 00 00   stw 3, 0(5)
 ; OBJ-NEXT:        8: 90 85 00 04   stw 4, 4(5)
 ; OBJ-NEXT:        c: 4e 80 00 20   blr
 
 ; SYM:      SYMBOL TABLE:
 ; SYM-NEXT: 00000000      df *DEBUG*  00000000 <stdin>
-; SYM-NEXT: 00000000 l       .text  00000029 .text
-; SYM-NEXT: 00000000 g     F .text (csect: .text)   00000000 .foo
+; SYM-NEXT: 00000000 l       .text  00000029 
+; SYM-NEXT: 00000000 g     F .text (csect: )  00000000 .foo
 ; SYM-NEXT: 0000002c l       .data  00000008 .data
 ; SYM-NEXT: 0000002c g     O .data (csect: .data)   00000000 _MergedGlobals
 ; SYM-NEXT: 0000002c g     O .data (csect: .data)   00000000 var1
 ; SYM-NEXT: 00000030 g     O .data (csect: .data)   00000000 var2
 ; SYM-NEXT: 00000030 g     O .data (csect: .data)   00000000 var3
 ; SYM-NEXT: 00000034 g     O .data  0000000c foo
 ; SYM-NEXT: 00000040 l       .data  00000000 TOC
 ; SYM-NEXT: 00000040 l     O .data  00000004 _MergedGlobals

llvm/test/CodeGen/PowerPC/aix-alias.ll

 }
 
 ; ASM:         .globl  fun[DS]
 ; ASM-NEXT:    .globl  .fun
 ; ASM-NEXT:    .align  4
 ; ASM-NEXT:    .csect fun[DS]
 ; ASM-NEXT:  fun_weak:                               # @fun
 ; ASM-NEXT:  fun_hidden:
-; ASM:         .csect .text[PR],5
+; ASM:         .csect [PR],5
 ; ASM-NEXT:  .fun:
 ; ASM-NEXT:  .fun_weak:
 ; ASM-NEXT:  .fun_hidden:
 ; ASM-NEXT:  # %bb.0:
 ; ASM-NEXT:    li 3, 0
 ; ASM-NEXT:    blr
 ; ASM-NEXT:                                          # -- End function
-; ASM:       .csect .text[PR],5
+; ASM:       .csect [PR],5
 ; ASM-NEXT:  .test:
 ; ASM-NEXT:  # %bb.0:                                # %entry
 ; ASM:         bl .fun
 ; ASM-NEXT:    nop
 ; ASM:         bl .fun_weak
 ; ASM-NEXT:    nop
 ; ASM:         bl .fun_hidden
 ; ASM:                                               # -- End function

llvm/test/CodeGen/PowerPC/aix-dwarf.ll

 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:  ]
 
 ; RELO:      RELOCATION RECORDS FOR [.dwinfo]:
 ; RELO-NEXT:  OFFSET   TYPE                     VALUE
 ; RELO-NEXT:  00000006 R_POS                    .dwabrev
 ; RELO-NEXT:  00000027 R_POS                    .dwline
-; RELO-NEXT:  00000009 R_POS                    .text
-; RELO-NEXT:  0000003a R_POS                    .text
+; RELO-NEXT:  00000009 R_POS                    
+; RELO-NEXT:  0000003a R_POS                    
 ; RELO:       RELOCATION RECORDS FOR [.dwline]:
 ; RELO-NEXT:  OFFSET   TYPE                     VALUE
-; RELO-NEXT:  00000000 R_POS                    .text
+; RELO-NEXT:  00000000 R_POS                    
 
 ; RELO64:      RELOCATION RECORDS FOR [.dwinfo]:
 ; RELO64-NEXT: OFFSET           TYPE                     VALUE
 ; RELO64-NEXT: 000000000000000e R_POS                    .dwabrev
 ; RELO64-NEXT: 000000000000000b R_POS                    .dwline
-; RELO64-NEXT: 0000000000000041 R_POS                    .text
-; RELO64-NEXT: 000000000000004e R_POS                    .text
+; RELO64-NEXT: 0000000000000041 R_POS                    
+; RELO64-NEXT: 000000000000004e R_POS                    
 ; RELO64:      RELOCATION RECORDS FOR [.dwline]:
 ; RELO64-NEXT: OFFSET           TYPE                     VALUE
-; RELO64-NEXT: 000000000000000c R_POS                    .text
+; RELO64-NEXT: 000000000000000c R_POS                    

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-clobber-register.ll

 ; COMMON-NEXT:  .vbyte  4, L..C2-TOC[TC0]               # EHInfo Table
 
 ; COMMON:       .csect .eh_info_table[RW],2
 ; COMMON-NEXT:__ehinfo.1:
 ; COMMON-NEXT:  .vbyte  4, 0
 ; COMMON-NEXT:  .align  2
 ; COMMON-NEXT:  .vbyte  4, 0
 ; COMMON-NEXT:  .vbyte  4, 0
-; CHECK-ASM-NEXT:   .csect .text[PR],5
+; CHECK-ASM-NEXT:   .csect [PR],5
 ; CHECK-FUNC-NEXT:  .csect .foov[PR],5
 ; COMMON-NEXT:                                         # -- End function
 ; COMMON:       .toc
 ; COMMON:      L..C2:
 ; COMMON-NEXT:  .tc __ehinfo.1[TC],__ehinfo.1
 
 
 ; OBJ-DIS:      9c: 00 00 00 00   # Traceback table start

llvm/test/CodeGen/PowerPC/aix-extern-weak.ll

 ; COMMON-NEXT:    .align  4
 ; COMMON-NEXT:    .csect main[DS]
 ; BIT32-NEXT:     .vbyte  4, .main                   # @main
 ; BIT32-NEXT:     .vbyte  4, TOC[TC0]
 ; BIT32-NEXT:     .vbyte  4, 0
 ; BIT64-NEXT:     .vbyte  8, .main                   # @main
 ; BIT64-NEXT:     .vbyte  8, TOC[TC0]
 ; BIT64-NEXT:     .vbyte  8, 0
-; COMMON-NEXT:    .csect  .text[PR]
+; COMMON-NEXT:    .csect  [PR]
 ; COMMON-NEXT:    .main:
 
 ; COMMON:         .csect  .data[RW]
 ; COMMON:         .globl  foo_ext_weak_p
 ; BIT32-NEXT:     .align  2
 ; BIT64-NEXT:     .align  3
 ; COMMON-NEXT: foo_ext_weak_p:
 ; BIT32-NEXT:     .vbyte  4, foo_ext_weak_ref[DS]

 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
 ; CHECKSYM32-NEXT:     StabSectNum: 0x0
 ; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+10]]
-; CHECKSYM-NEXT:     Name: .text
+; CHECKSYM-NEXT:     Name:
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+11]]
 ; CHECKSYM-NEXT:       SectionLen: 80

llvm/test/CodeGen/PowerPC/aix-extern.ll

 ; COMMON-NEXT:      .align  4
 ; COMMON-NEXT:      .csect foo[DS]
 ; BIT32-NEXT:       .vbyte  4, .foo                    # @foo
 ; BIT32-NEXT:       .vbyte  4, TOC[TC0]
 ; BIT32-NEXT:       .vbyte  4, 0
 ; BIT64-NEXT:       .vbyte  8, .foo                    # @foo
 ; BIT64-NEXT:       .vbyte  8, TOC[TC0]
 ; BIT64-NEXT:       .vbyte  8, 0
-; COMMON-NEXT:      .csect .text[PR]
+; COMMON-NEXT:      .csect [PR]
 ; COMMON-NEXT: .foo:
 
 ; COMMON:           .globl  main[DS]                # -- Begin function main
 ; COMMON-NEXT:      .globl  .main
 ; COMMON-NEXT:      .align  4
 ; COMMON-NEXT:      .csect main[DS]
 ; BIT32-NEXT:       .vbyte  4, .main                   # @main
 ; BIT32-NEXT:       .vbyte  4, TOC[TC0]
 ; BIT32-NEXT:       .vbyte  4, 0
 ; BIT64-NEXT:       .vbyte  8, .main                   # @main
 ; BIT64-NEXT:       .vbyte  8, TOC[TC0]
 ; BIT64-NEXT:       .vbyte  8, 0
-; COMMON-NEXT:      .csect .text[PR]
+; COMMON-NEXT:      .csect [PR]
 ; COMMON-NEXT: .main:
 
 ; COMMON:           .csect .data[RW]
 ; COMMON-NEXT:      .globl  bar_p
 ; BIT32-NEXT:       .align  2
 ; BIT64-NEXT:       .align  3
 ; COMMON-NEXT: bar_p:
 ; BIT32-NEXT:       .vbyte  4, bar_ref[DS]

 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
 ; CHECKSYM32-NEXT:     StabSectNum: 0x0
 ; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index+10]]
-; CHECKSYM-NEXT:     Name: .text
+; CHECKSYM-NEXT:     Name:
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+11]]
 ; CHECKSYM-NEXT:       SectionLen: 112

llvm/test/CodeGen/PowerPC/aix-func-align.ll

entry:
   ret i32 0
 }
 
 define i32 @bar()  align 64 {
 entry:
   ret i32 0
 }
 
-; CHECK:      .csect .text[PR],6
+; CHECK:      .csect [PR],6
 ; CHECK-NEXT: .foo:
 
-; CHECK:      .csect .text[PR],6
+; CHECK:      .csect [PR],6
 ; CHECK-NEXT: .bar:
 
-; SYMS:       Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *}}Name: .text
+; SYMS:       Symbol {{[{][[:space:]] *}}Index: [[#INDX:]]{{[[:space:]] *Name: $}}
 ; SYMS-NEXT:    Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:    Section: .text
 ; SYMS-NEXT:    Type: 0x0
 ; SYMS-NEXT:    StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:    NumberOfAuxEntries: 1
 ; SYMS-NEXT:    CSECT Auxiliary Entry {
 ; SYMS-NEXT:      Index: [[#INDX+1]]
 ; SYMS-NEXT:      SectionLen: 72

llvm/test/CodeGen/PowerPC/aix-func-dsc-gen.ll

 ; CHECK-NEXT:     Section: N_DEBUG
 ; CHECK-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECK-NEXT:     CPU Version ID: 0x0
 ; CHECK-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECK-NEXT:     NumberOfAuxEntries: 0
 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {
 ; CHECK-NEXT:     Index: [[#Index:]]
-; CHECK-NEXT:     Name: .text
+; CHECK-NEXT:     Name:
 ; CHECK-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECK-NEXT:     Section: .text
 ; CHECK-NEXT:     Type: 0x0
 ; CHECK-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECK-NEXT:     NumberOfAuxEntries: 1
 ; CHECK-NEXT:     CSECT Auxiliary Entry {
 ; CHECK-NEXT:       Index: [[#Index+1]]
 ; CHECK-NEXT:       SectionLen: 4

llvm/test/CodeGen/PowerPC/aix-personality-alias.ll

 ;   SYM:    .csect __gxx_personality_v0[DS]
 ;   SYM:  __xlcxx_personality_v1:                 # @__gxx_personality_v0
 ; SYM32:    .vbyte  4, .__gxx_personality_v0
 ; SYM32:    .vbyte  4, TOC[TC0]
 ; SYM32:    .vbyte  4, 0
 ; SYM64:    .vbyte  8, .__gxx_personality_v0
 ; SYM64:    .vbyte  8, TOC[TC0]
 ; SYM64:    .vbyte  8, 0
-;   SYM:    .csect .text[PR],5
+;   SYM:    .csect [PR],5
 ;   SYM:  .__gxx_personality_v0:
 ;   SYM:  .__xlcxx_personality_v1:
 ;   SYM:  # %bb.0:                                # %entry
 ;   SYM:    li 3, 1
 ;   SYM:    blr
 
 ;   SYM:    .csect .eh_info_table[RW],2
 ;   SYM:  __ehinfo.1:
 ;   SYM:    .vbyte  4, 0
 ; SYM32:    .align  2
 ; SYM32:    .vbyte  4, GCC_except_table1
 ; SYM32:    .vbyte  4, __xlcxx_personality_v1
 ; SYM64:    .align  3
 ; SYM64:    .vbyte  8, GCC_except_table1
 ; SYM64:    .vbyte  8, __xlcxx_personality_v1

llvm/test/CodeGen/PowerPC/aix-text-ref.ll

+; RUN: llc -filetype=obj -mtriple powerpc-ibm-aix-xcoff -o %t.o < %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=CHECK32 %s
+; RUN: llc -filetype=obj -mtriple powerpc64-ibm-aix-xcoff -o %t.o < %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=CHECK64 %s
+
+define i32 @main() {
+entry:
+  %retval = alloca i32, align 4
+  store i32 0, ptr %retval, align 4
+  %call = call i32 @text()
+  ret i32 %call
+}
+
+declare i32 @text(...)
+
+; CHECK32: 00000000         *UND*  00000000 (idx: {{[[:digit:]]*}}) .text[PR]
+; CHECK32: 00000000         *UND*  00000000 (idx: {{[[:digit:]]*}}) text[DS]
+
+; CHECK64: 0000000000000000         *UND*  0000000000000000 (idx: {{[[:digit:]]*}}) .text[PR]
+; CHECK64: 0000000000000000         *UND*  0000000000000000 (idx: {{[[:digit:]]*}}) text[DS]

llvm/test/CodeGen/PowerPC/aix-text.ll

+; RUN: llc -filetype=obj --function-sections -mtriple powerpc-ibm-aix-xcoff -o %t.o < %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=CHECKFS32 %s
+; RUN: llc -filetype=obj --function-sections -mtriple powerpc64-ibm-aix-xcoff -o %t.o < %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=CHECKFS64 %s
+; RUN: llc -filetype=obj -mtriple powerpc-ibm-aix-xcoff -o %t.o < %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=CHECK32 %s
+; RUN: llc -filetype=obj -mtriple powerpc64-ibm-aix-xcoff -o %t.o < %s
+; RUN: llvm-objdump --syms --symbol-description %t.o | FileCheck --check-prefix=CHECK64 %s
+
+define i32 @text() {
+entry:
+  ret i32 1
+}
+
+define i32 @text2() {
+entry:
+  ret i32 2
+}
+
+; CHECKFS32: 00000000 l       .text  00000000 (idx: {{[[:digit:]]*}}) [PR]
+; CHECKFS32-NEXT: 00000000 g       .text  {{([[:xdigit:]]{8})}} (idx: {{[[:digit:]]*}}) .text[PR]
+; CHECKFS32-NEXT: {{([[:xdigit:]]{8})}} g       .text  {{([[:xdigit:]]{8})}} (idx: {{[[:digit:]]*}}) .text2[PR]
+
+; CHECKFS64: 0000000000000000 l       .text  0000000000000000 
+; CHECKFS64-NEXT: 0000000000000000 g       .text  {{([[:xdigit:]]{16})}} (idx: {{[[:digit:]]*}}) .text[PR]
+; CHECKFS64-NEXT: {{([[:xdigit:]]{16})}} g       .text  {{([[:xdigit:]]{16})}} (idx: {{[[:digit:]]*}}) .text2[PR]
+
+; CHECK32: 00000000 l       .text  {{([[:xdigit:]]{8})}} (idx: {{[[:digit:]]*}}) [PR]
+; CHECK32-NEXT: {{([[:xdigit:]]{8})}} g     F .text (csect: (idx: {{[[:digit:]]*}}) [PR])   00000000 (idx: {{[[:digit:]]*}}) .text
+; CHECK32-NEXT: {{([[:xdigit:]]{8})}} g     F .text (csect: (idx: {{[[:digit:]]*}}) [PR])   00000000 (idx: {{[[:digit:]]*}}) .text2
+
+; CHECK64: 0000000000000000 l       .text  {{([[:xdigit:]]{16})}} (idx: {{[[:digit:]]*}}) [PR]
+; CHECK64-NEXT: {{([[:xdigit:]]{16})}} g     F .text (csect: (idx: {{[[:digit:]]*}}) [PR])   0000000000000000 (idx: {{[[:digit:]]*}}) .text
+; CHECK64-NEXT: {{([[:xdigit:]]{8})}} g     F .text (csect: (idx: {{[[:digit:]]*}}) [PR])   0000000000000000 (idx: {{[[:digit:]]*}}) .text2

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-reloc-large.ll

 ; SYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 3
-; SYM-NEXT:     Name: .text
+; SYM-NEXT:     Name:
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: 4
 ; SYM-NEXT:       SectionLen: 132

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-reloc.ll

 ; SYM-NEXT:       SymbolType: XTY_ER (0x0)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 3
-; SYM-NEXT:     Name: .text
+; SYM-NEXT:     Name:
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: 4
 ; SYM-NEXT:       SectionLen: 104

llvm/test/CodeGen/PowerPC/aix-tls-xcoff-variables.ll

 
 ; SECTION:      File: {{.*}}aix-tls-xcoff-variables.ll.tmp.o
 ; SECTION-NEXT: Format: aixcoff-rs6000
 ; SECTION-NEXT: Arch: powerpc
 ; SECTION-NEXT: AddressSize: 32bit
 ; SECTION-NEXT: Sections [
 ; SECTION-NEXT:   Section {
 ; SECTION-NEXT:     Index: 1
-; SECTION-NEXT:     Name: .text
+; SECTION-NEXT:     Name:
 ; SECTION-NEXT:     PhysicalAddress: 0x0
 ; SECTION-NEXT:     VirtualAddress: 0x0
 ; SECTION-NEXT:     Size: 0x4
 ; SECTION-NEXT:     RawDataOffset: 0x8C
 ; SECTION-NEXT:     RelocationPointer: 0x0
 ; SECTION-NEXT:     LineNumberPointer: 0x0
 ; SECTION-NEXT:     NumberOfRelocations: 0
 ; SECTION-NEXT:     NumberOfLineNumbers: 0

 ; SYMS-NEXT:       StorageMappingClass: XMC_UL (0x15)
 ; SYMS-NEXT:       StabInfoIndex: 0x0
 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: [[#INDX+4]]
-; SYMS-NEXT:     Name: .text
+; SYMS-NEXT:     Name:
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+5]]
 ; SYMS-NEXT:       SectionLen: 0

llvm/test/CodeGen/PowerPC/aix-weak.ll

 ; COMMON-NEXT:          .align  4
 ; COMMON-NEXT:          .csect foo_weak[DS]
 ; BIT32-NEXT:           .vbyte  4, .foo_weak               # @foo_weak
 ; BIT32-NEXT:           .vbyte  4, TOC[TC0]
 ; BIT32-NEXT:           .vbyte  4, 0
 ; BIT64-NEXT:           .vbyte  8, .foo_weak               # @foo_weak
 ; BIT64-NEXT:           .vbyte  8, TOC[TC0]
 ; BIT64-NEXT:           .vbyte  8, 0
-; COMMON-NEXT:          .csect .text[PR]
+; COMMON-NEXT:          .csect [PR]
 ; COMMON-NEXT:  .foo_weak:
 
 ; COMMON:               .weak   foo_ref_weak[DS]        # -- Begin function foo_ref_weak
 ; COMMON-NEXT:          .weak .foo_ref_weak
 ; COMMON-NEXT:          .align  4
 ; COMMON-NEXT:          .csect foo_ref_weak[DS]
 ; BIT32-NEXT:           .vbyte  4, .foo_ref_weak           # @foo_ref_weak
 ; BIT32-NEXT:           .vbyte  4, TOC[TC0]
 ; BIT32-NEXT:           .vbyte  4, 0
 ; BIT64-NEXT:           .vbyte  8, .foo_ref_weak           # @foo_ref_weak
 ; BIT64-NEXT:           .vbyte  8, TOC[TC0]
 ; BIT64-NEXT:           .vbyte  8, 0
-; COMMON-NEXT:          .csect .text[PR]
+; COMMON-NEXT:          .csect [PR]
 ; COMMON-NEXT:  .foo_ref_weak:
 
 ; COMMON:               .globl  main[DS]                # -- Begin function main
 ; COMMON-NEXT:          .globl  .main
 ; COMMON-NEXT:          .align  4
 ; COMMON-NEXT:          .csect main[DS]
 ; BIT32-NEXT:           .vbyte  4, .main                   # @main
 ; BIT32-NEXT:           .vbyte  4, TOC[TC0]
 ; BIT32-NEXT:           .vbyte  4, 0
 ; BIT64-NEXT:           .vbyte  8, .main                   # @main
 ; BIT64-NEXT:           .vbyte  8, TOC[TC0]
 ; BIT64-NEXT:           .vbyte  8, 0
-; COMMON-NEXT:          .csect .text[PR]
+; COMMON-NEXT:          .csect [PR]
 ; COMMON-NEXT:  .main:
 
 ; COMMON:               .csect .data[RW]
 ; COMMON-NEXT:          .globl  foo_weak_p
 ; BIT32-NEXT:           .align  2
 ; BIT64-NEXT:           .align  3
 ; COMMON-NEXT:  foo_weak_p:
 ; BIT32-NEXT:           .vbyte  4, foo_ref_weak[DS]

 ; CHECKSYM-NEXT:     Section: N_DEBUG
 ; CHECKSYM-NEXT:     Source Language ID: TB_C (0x0)
 ; CHECKSYM-NEXT:     CPU Version ID: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_FILE (0x67)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 0
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {
 ; CHECKSYM-NEXT:     Index: [[#Index:]]
-; CHECKSYM-NEXT:     Name: .text
+; CHECKSYM-NEXT:     Name: 
 ; CHECKSYM-NEXT:     Value (RelocatableAddress): 0x0
 ; CHECKSYM-NEXT:     Section: .text
 ; CHECKSYM-NEXT:     Type: 0x0
 ; CHECKSYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:     NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:     CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:       Index: [[#Index+1]]
 ; CHECKSYM-NEXT:       SectionLen: 136

llvm/test/CodeGen/PowerPC/aix-xcoff-cold.ll

 ; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -filetype=obj -o %t.o < %s
 ; RUN: llvm-objdump --syms %t.o | FileCheck %s
 
 ; CHECK:      SYMBOL TABLE:
 ; CHECK-NEXT: 0000000000000000      df *DEBUG* 0000000000000000 <stdin>
-; CHECK-NEXT: 0000000000000000 l       .text   000000000000001e .text
-; CHECK-NEXT: 0000000000000000 g     F .text (csect: .text)  0000000000000000 .cold_fun
+; CHECK-NEXT: 0000000000000000 l       .text   000000000000001e 
+; CHECK-NEXT: 0000000000000000 g     F .text (csect: )  0000000000000000 .cold_fun
 ; CHECK-NEXT: 0000000000000020 g     O .data   0000000000000018 cold_fun
 
 define dso_local void @cold_fun() #1 {
 entry:
   ret void
 }
 
 attributes #1 = { cold }

llvm/test/CodeGen/PowerPC/aix-xcoff-data.ll

 @f = common local_unnamed_addr global float 0.000000e+00, align 4
 
 @over_aligned_comm = common local_unnamed_addr global double 0.000000e+00, align 32
 
 @array = common local_unnamed_addr global [33 x i8] zeroinitializer, align 1
 
 ; CHECK-NOT: .toc
 
-; CHECK:      .csect .text[PR],5
+; CHECK:      .csect [PR],5
 ; CHECK-NEXT:  .file
 
 ; CHECK:      .csect .data[RW],5
 ; CHECK-NEXT: .globl  ivar
 ; CHECK-NEXT: .align  2
 ; CHECK-NEXT: ivar:
 ; CHECK-NEXT: .vbyte  4, 35
 

 ; SYMS-NEXT:     Section: N_DEBUG
 ; SYMS-NEXT:     Source Language ID: TB_C (0x0)
 ; SYMS-NEXT:     CPU Version ID: 0x0
 ; SYMS-NEXT:     StorageClass: C_FILE (0x67)
 ; SYMS-NEXT:     NumberOfAuxEntries: 0
 ; SYMS-NEXT:   }
 ; SYMS-NEXT:   Symbol {
 ; SYMS-NEXT:     Index: [[#INDX:]]
-; SYMS-NEXT:     Name: .text
+; SYMS-NEXT:     Name:
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .text
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#INDX+1]]
 ; SYMS-NEXT:       SectionLen: 0

llvm/test/CodeGen/PowerPC/aix-xcoff-funcsect.ll

 ; ASM-NEXT:   .extern extern_foo[DS]
 ; ASM-NEXT:   .globl  alias_foo
 ; ASM-NEXT:   .globl  .alias_foo
 
 ; XCOFF32:      SYMBOL TABLE:
 ; XCOFF32-NEXT: 00000000      df *DEBUG*  00000000 (idx: 0) <stdin>
 ; XCOFF32-NEXT: 00000000         *UND*  00000000 (idx: 1) .extern_foo[PR]
 ; XCOFF32-NEXT: 00000000         *UND*  00000000 (idx: 3) extern_foo[DS]
-; XCOFF32-NEXT: 00000000 l       .text  00000000 (idx: 5) .text[PR]
+; XCOFF32-NEXT: 00000000 l       .text  00000000 (idx: 5) [PR]
 ; XCOFF32-NEXT: 00000000 g       .text  00000019 (idx: 7) .foo[PR]
 ; XCOFF32-NEXT: 00000000 g     F .text (csect: (idx: 7) .foo[PR])   00000000 (idx: 9) .alias_foo
 ; XCOFF32-NEXT: 00000020 g       .text  00000020 .hidden (idx: 11) .hidden_foo[PR]
 ; XCOFF32-NEXT: 00000040 g       .text  00000059 (idx: 13) .bar[PR]
 ; XCOFF32-NEXT: 000000c0 l       .text  0000002a (idx: 15) .static_overalign_foo[PR]
 ; XCOFF32-NEXT: 000000ec g     O .data  0000000c (idx: 17) foo[DS]
 ; XCOFF32-NEXT: 000000ec g     O .data (csect: (idx: 17) foo[DS])   00000000 (idx: 19) alias_foo
 ; XCOFF32-NEXT: 000000f8 g     O .data  0000000c .hidden (idx: 21) hidden_foo[DS]

 ; XCOFF32-NEXT: 0000001c R_POS                    (idx: 27) TOC[TC0]
 ; XCOFF32-NEXT: 00000024 R_POS                    (idx: 15) .static_overalign_foo[PR]
 ; XCOFF32-NEXT: 00000028 R_POS                    (idx: 27) TOC[TC0]
 
 ; XCOFF64:      SYMBOL TABLE:
 ; XCOFF64-NEXT: 0000000000000000      df *DEBUG*  0000000000000000 (idx: 0) <stdin>
 ; XCOFF64-NEXT: 0000000000000000         *UND*  0000000000000000 (idx: 1) .extern_foo[PR]
 ; XCOFF64-NEXT: 0000000000000000         *UND*  0000000000000000 (idx: 3) extern_foo[DS]
-; XCOFF64-NEXT: 0000000000000000 l       .text  0000000000000000 (idx: 5) .text[PR]
+; XCOFF64-NEXT: 0000000000000000 l       .text  0000000000000000 (idx: 5) [PR]
 ; XCOFF64-NEXT: 0000000000000000 g       .text  0000000000000019 (idx: 7) .foo[PR]
 ; XCOFF64-NEXT: 0000000000000000 g     F .text (csect: (idx: 7) .foo[PR])   0000000000000000 (idx: 9) .alias_foo
 ; XCOFF64-NEXT: 0000000000000020 g       .text  0000000000000020 .hidden (idx: 11) .hidden_foo[PR]
 ; XCOFF64-NEXT: 0000000000000040 g       .text  0000000000000059 (idx: 13) .bar[PR]
 ; XCOFF64-NEXT: 00000000000000c0 l       .text  000000000000002a (idx: 15) .static_overalign_foo[PR]
 ; XCOFF64-NEXT: 00000000000000f0 g     O .data  0000000000000018 (idx: 17) foo[DS]
 ; XCOFF64-NEXT: 00000000000000f0 g     O .data (csect: (idx: 17) foo[DS])   0000000000000000 (idx: 19) alias_foo
 ; XCOFF64-NEXT: 0000000000000108 g     O .data  0000000000000018 .hidden (idx: 21) hidden_foo[DS]

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc-symb.mir

body:             |
   bb.0:
     successors: %bb.0(0x20000000)
     liveins: $r2
     renamable $r3 = LWZtoc %jump-table.0, $r2 :: (load (s32) from got)
     BLR implicit $lr, implicit $rm, implicit killed $r3
 ...
 
 # RELOC:       Relocation {{[{][[:space:]] *}}Virtual Address: 0x8
-# RELOC-NEXT:    Symbol: .text ([[#TXT_INDX:]])
+# RELOC-NEXT:    Symbol:  ([[#TXT_INDX:]])
 # RELOC-NEXT:    IsSigned: No
 # RELOC-NEXT:    FixupBitValue: 0
 # RELOC-NEXT:    Length: 32
 # RELOC-NEXT:    Type: R_POS (0x0)
 # RELOC-NEXT:  }
 # RELOC-NEXT:  Relocation {
 # RELOC-NEXT:    Virtual Address: 0x8
 # RELOC-NEXT:    Symbol: .rodata ([[#RO_INDX:]])
 # RELOC-NEXT:    IsSigned: No
 # RELOC-NEXT:    FixupBitValue: 0
 # RELOC-NEXT:    Length: 32
 # RELOC-NEXT:    Type: R_NEG (0x1)
 # RELOC-NEXT:  }
 
-# SYM:       Symbol {{[{][[:space:]] *}}Index: [[#TXT_INDX]]{{[[:space:]] *}}Name: .text
+# SYM:       Symbol {{[{][[:space:]] *}}Index: [[#TXT_INDX]]{{[[:space:]] *}}Name: 
 # SYM-NEXT:    Value (RelocatableAddress): 0x0
 # SYM-NEXT:    Section: .text
 # SYM-NEXT:    Type: 0x0
 # SYM-NEXT:    StorageClass: C_HIDEXT (0x6B)
 # SYM-NEXT:    NumberOfAuxEntries: 1
 # SYM-NEXT:    CSECT Auxiliary Entry {
 # SYM-NEXT:      Index: [[#TXT_INDX+1]]
 # SYM-NEXT:      SectionLen: 8

llvm/test/CodeGen/PowerPC/aix-xcoff-reloc.ll

 ; SYM-NEXT:       StorageMappingClass: XMC_DS (0xA)
 ; SYM32-NEXT:     StabInfoIndex: 0x0
 ; SYM32-NEXT:     StabSectNum: 0x0
 ; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: [[#INDX+4]]
-; SYM-NEXT:     Name: .text
+; SYM-NEXT:     Name:
 ; SYM-NEXT:     Value (RelocatableAddress): 0x0
 ; SYM-NEXT:     Section: .text
 ; SYM-NEXT:     Type: 0x0
 ; SYM-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYM-NEXT:     NumberOfAuxEntries: 1
 ; SYM-NEXT:     CSECT Auxiliary Entry {
 ; SYM-NEXT:       Index: [[#INDX+5]]
 ; SYM-NEXT:       SectionLen: 64

llvm/test/CodeGen/PowerPC/aix-xcoff-symbol-rename.ll

 ; ASM-NEXT:    .rename _Renamed..24f_o[DS],"f$o"
 ; ASM-NEXT:    .lglobl ._Renamed..24f_o
 ; ASM-NEXT:    .rename ._Renamed..24f_o,".f$o"
 ; ASM-NEXT:    .align  4
 ; ASM-NEXT:    .csect _Renamed..24f_o[DS],2
 ; ASM-NEXT:    .vbyte  4, ._Renamed..24f_o     # @"f$o"
 ; ASM-NEXT:    .vbyte  4, TOC[TC0]
 ; ASM-NEXT:    .vbyte  4, 0
-; ASM-NEXT:    .csect .text[PR],5
+; ASM-NEXT:    .csect [PR],5
 ; ASM-NEXT:  ._Renamed..24f_o:
 ; ASM:         bl ._Renamed..40f_o[PR]
 ; ASM-NEXT:    nop
 ; ASM:         .globl  _Renamed..26f_o[DS] # -- Begin function f&o
 ; ASM-NEXT:    .rename _Renamed..26f_o[DS],"f&o"
 ; ASM-NEXT:    .globl  ._Renamed..26f_o
 ; ASM-NEXT:    .rename ._Renamed..26f_o,".f&o"
 ; ASM-NEXT:    .align  4
 ; ASM-NEXT:    .csect _Renamed..26f_o[DS],2
 ; ASM-NEXT:    .vbyte  4, ._Renamed..26f_o     # @"f&o"
 ; ASM-NEXT:    .vbyte  4, TOC[TC0]
 ; ASM-NEXT:    .vbyte  4, 0
-; ASM-NEXT:    .csect .text[PR],5
+; ASM-NEXT:    .csect [PR],5
 ; ASM-NEXT:  ._Renamed..26f_o:
 ; ASM:         bl ._Renamed..24f_o
 ; ASM:         .globl  _Renamed..265ff__o[DS] # -- Begin function f&_o
 ; ASM-NEXT:    .rename _Renamed..265ff__o[DS],"f&_o"
 ; ASM-NEXT:    .globl  ._Renamed..265ff__o
 ; ASM-NEXT:    .rename ._Renamed..265ff__o,".f&_o"
 ; ASM-NEXT:    .align  4
 ; ASM-NEXT:    .csect _Renamed..265ff__o[DS],2
 ; ASM-NEXT:    .vbyte  4, ._Renamed..265ff__o  # @"f&_o"
 ; ASM-NEXT:    .vbyte  4, TOC[TC0]
 ; ASM-NEXT:    .vbyte  4, 0
-; ASM-NEXT:    .csect .text[PR],5
+; ASM-NEXT:    .csect [PR],5
 ; ASM-NEXT:  ._Renamed..265ff__o:
 ; ASM:         .csect .data[RW],2
 ; ASM-NEXT:    .globl  _Renamed..60f_o
 ; ASM-NEXT:    .rename _Renamed..60f_o,"f`o"
 ; ASM-NEXT:    .align  2
 ; ASM-NEXT:  _Renamed..60f_o:
 ; ASM-NEXT:    .vbyte  4, 10                   # 0xa
 ; ASM-NEXT:    .comm _Renamed..2222f_o_[RW],4,2

llvm/test/CodeGen/PowerPC/pgo-ref-directive.ll

 ; WITHVNDS:      .csect __llvm_prf_cnts[RW],3
 ; WITHVNDS:      .csect __llvm_prf_cnts[RW],3
 ; WITHVNDS-NEXT: .ref __llvm_prf_data[RW]
 ; WITHVNDS-NEXT: .ref __llvm_prf_names[RO]
 ; WITHVNDS-NEXT: .ref __llvm_prf_vnds[RW]
 
 ; WITHVNDS-OBJ:      SYMBOL TABLE:
 ; WITHVNDS-OBJ-NEXT: 00000000      df *DEBUG* 00000000 <stdin>
-; WITHVNDS-OBJ-NEXT: 00000000 l       .text 00000008 .text
-; WITHVNDS-OBJ-NEXT: 00000000 g     F .text (csect: .text)  00000000 .main
+; WITHVNDS-OBJ-NEXT: 00000000 l       .text 00000008 
+; WITHVNDS-OBJ-NEXT: 00000000 g     F .text (csect: )   00000000 .main
 ; WITHVNDS-OBJ-NEXT: 00000008 l       .text 00000006 __llvm_prf_names
 ; WITHVNDS-OBJ-NEXT: 00000010 l     O .data 00000008 __llvm_prf_cnts
 ; WITHVNDS-OBJ-NEXT: 00000018 l     O .data 00000008 __llvm_prf_data
 ; WITHVNDS-OBJ-NEXT: 00000020 l     O .data 000000f0 __llvm_prf_vnds
 ; WITHVNDS-OBJ-NEXT: 00000110 g     O .data 0000000c main
 ; WITHVNDS-OBJ-NEXT: 0000011c l       .data 00000000 TOC
 
 ; WITHVNDS-OBJ:      RELOCATION RECORDS FOR [.data]:
 ; WITHVNDS-OBJ-NEXT: OFFSET   TYPE                     VALUE
 ; WITHVNDS-OBJ-NEXT: 00000000 R_REF                    __llvm_prf_data
 ; WITHVNDS-OBJ-NEXT: 00000000 R_REF                    __llvm_prf_names
 ; WITHVNDS-OBJ-NEXT: 00000000 R_REF                    __llvm_prf_vnds
 ; WITHVNDS-OBJ-NEXT: 00000100 R_POS                    .main
 ; WITHVNDS-OBJ-NEXT: 00000104 R_POS                    TOC

llvm/test/CodeGen/PowerPC/test_func_desc.ll

 ; 32BIT: .csect foo[DS],2
 ; 32BIT-NEXT: .vbyte  4, .foo
 ; 32BIT-NEXT: .vbyte  4, TOC[TC0]
 ; 32BIT-NEXT: .vbyte  4, 0
 ; 64BIT: .csect foo[DS],3
 ; 64BIT-NEXT: .vbyte  8, .foo
 ; 64BIT-NEXT: .vbyte  8, TOC[TC0]
 ; 64BIT-NEXT: .vbyte  8, 0
-; CHECK-NEXT: .csect .text[PR],5
+; CHECK-NEXT: .csect [PR],5
 ; CHECK-LABEL: .foo:
 
 ; CHECK: .globl main[DS]
 ; CHECK: .globl .main
 ; 32BIT: .csect main[DS],2
 ; 32BIT-NEXT: .vbyte  4, .main
 ; 32BIT-NEXT: .vbyte  4, TOC[TC0]
 ; 32BIT-NEXT: .vbyte  4, 0
 ; 64BIT: .csect main[DS],3
 ; 64BIT-NEXT: .vbyte  8, .main
 ; 64BIT-NEXT: .vbyte  8, TOC[TC0]
 ; 64BIT-NEXT: .vbyte  8, 0
-; CHECK-NEXT: .csect .text[PR],5
+; CHECK-NEXT: .csect [PR],5
 ; CHECK-LABEL: .main:
 ; CHECK: bl .foo
 ; CHECK: bl .extern_foo
 ; CHECK: bl .static_foo
 
 ; CHECK: .lglobl static_foo[DS]
 ; CHECK: .lglobl .static_foo
 ; 32BIT: .csect static_foo[DS],2
 ; 32BIT-NEXT: .vbyte  4, .static_foo
 ; 32BIT-NEXT: .vbyte  4, TOC[TC0]
 ; 32BIT-NEXT: .vbyte  4, 0
 ; 64BIT: .csect static_foo[DS],3
 ; 64BIT-NEXT: .vbyte  8, .static_foo
 ; 64BIT-NEXT: .vbyte  8, TOC[TC0]
 ; 64BIT-NEXT: .vbyte  8, 0
-; CHECK-NEXT: .csect .text[PR],5
+; CHECK-NEXT: .csect [PR],5
 ; CHECK-LABEL: .static_foo:
 
 ; CHECK-NOT: .csect extern_foo
 
 ; CHECK: .toc
 ; CHECK-NOT: .tc

llvm/test/DebugInfo/XCOFF/empty.ll

 !6 = !{i32 7, !"PIC Level", i32 2}
 !7 = !{!"clang version 12.0.0"}
 !8 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !9, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !9 = !DISubroutineType(types: !10)
 !10 = !{!11}
 !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !12 = !DILocation(line: 3, column: 3, scope: !8)
 
-; ASM32:               .csect .text[PR],5
+; ASM32:               .csect [PR],5
 ; ASM32-NEXT:          .file   "1.c"
 ; ASM32-NEXT:          .globl  main[DS]                        # -- Begin function main
 ; ASM32-NEXT:          .globl  .main
 ; ASM32-NEXT:          .align  2
 ; ASM32-NEXT:          .csect main[DS],2
 ; ASM32-NEXT:          .vbyte  4, .main                        # @main
 ; ASM32-NEXT:          .vbyte  4, TOC[TC0]
 ; ASM32-NEXT:          .vbyte  4, 0
-; ASM32-NEXT:          .csect .text[PR],5
+; ASM32-NEXT:          .csect [PR],5
 ; ASM32-NEXT:  .main:
 ; ASM32-NEXT:  L..func_begin0:
 ; ASM32-NEXT:  # %bb.0:                                # %entry
 ; ASM32-NEXT:  L..tmp0:
 ; ASM32-NEXT:          li 4, 0
 ; ASM32-NEXT:  L..tmp1:
 ; ASM32-NEXT:  L..tmp2:
 ; ASM32-NEXT:          li 3, 0

 ; ASM32-NEXT:          .byte   5
 ; ASM32-NEXT:          .byte   2
 ; ASM32-NEXT:          .vbyte  4, L..func_end0
 ; ASM32-NEXT:          .byte   0                               # End sequence
 ; ASM32-NEXT:          .byte   1
 ; ASM32-NEXT:          .byte   1
 ; ASM32-NEXT:  L..debug_line_end0:
 
-; ASM64:               .csect .text[PR],5
+; ASM64:               .csect [PR],5
 ; ASM64-NEXT:          .file   "1.c"
 ; ASM64-NEXT:          .globl  main[DS]                        # -- Begin function main
 ; ASM64-NEXT:          .globl  .main
 ; ASM64-NEXT:          .align  2
 ; ASM64-NEXT:          .csect main[DS],3
 ; ASM64-NEXT:          .vbyte  8, .main                        # @main
 ; ASM64-NEXT:          .vbyte  8, TOC[TC0]
 ; ASM64-NEXT:          .vbyte  8, 0
-; ASM64-NEXT:          .csect .text[PR],5
+; ASM64-NEXT:          .csect [PR],5
 ; ASM64-NEXT:  .main:
 ; ASM64-NEXT:  L..func_begin0:
 ; ASM64-NEXT:  # %bb.0:                                # %entry
 ; ASM64-NEXT:  L..tmp0:
 ; ASM64-NEXT:          li 4, 0
 ; ASM64-NEXT:  L..tmp1:
 ; ASM64-NEXT:  L..tmp2:
 ; ASM64-NEXT:          li 3, 0

llvm/test/DebugInfo/XCOFF/explicit-section.ll

 !10 = !DISubroutineType(types: !11)
 !11 = !{!12}
 !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !13 = !DILocation(line: 1, column: 12, scope: !8)
 !14 = distinct !DISubprogram(name: "main", scope: !9, file: !9, line: 2, type: !10, scopeLine: 2, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !15 = !DILocation(line: 3, column: 10, scope: !14)
 !16 = !DILocation(line: 3, column: 3, scope: !14)
 
-; CHECK:               .csect .text[PR],5
+; CHECK:               .csect [PR],5
 ; CHECK-NEXT:          .file   "2.c"
 ; CHECK-NEXT:          .globl  bar[DS]                         # -- Begin function bar
 ; CHECK-NEXT:          .globl  .bar
 ; CHECK-NEXT:          .align  2
 ; CHECK-NEXT:          .csect bar[DS],2
 ; CHECK-NEXT:          .vbyte  4, .bar                         # @bar
 ; CHECK-NEXT:          .vbyte  4, TOC[TC0]
 ; CHECK-NEXT:          .vbyte  4, 0
-; CHECK-NEXT:          .csect .text[PR],5
+; CHECK-NEXT:          .csect [PR],5
 ; CHECK-NEXT:  .bar:
 ; CHECK-NEXT:  L..func_begin0:
 ; CHECK-NEXT:  # %bb.0:                                # %entry
 ; CHECK-NEXT:  L..tmp0:
 ; CHECK-NEXT:          li 3, 1
 ; CHECK-NEXT:          blr
 ; CHECK-NEXT:  L..tmp1:
 ; CHECK-NEXT:  L..bar0:

llvm/test/DebugInfo/XCOFF/function-sections.ll

 !8 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !9, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !9 = !DISubroutineType(types: !10)
 !10 = !{!11}
 !11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 !12 = !DILocation(line: 3, column: 3, scope: !8)
 !13 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 6, type: !9, scopeLine: 7, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
 !14 = !DILocation(line: 8, column: 3, scope: !13)
 
-; CHECK:               .csect .text[PR],5
+; CHECK:               .csect [PR],5
 ; CHECK-NEXT:          .file   "1.c"
 ; CHECK-NEXT:          .csect .foo[PR],5
 ; CHECK-NEXT:          .globl  foo[DS]                         # -- Begin function foo
 ; CHECK-NEXT:          .globl  .foo[PR]
 ; CHECK-NEXT:          .align  2
 ; CHECK-NEXT:          .csect foo[DS],2
 ; CHECK-NEXT:          .vbyte  4, .foo[PR]                     # @foo
 ; CHECK-NEXT:          .vbyte  4, TOC[TC0]

llvm/test/MC/PowerPC/aix-file-symbols-empty.s

 ## Emit ".file" as the source file name when there is no file name.
 # RUN: llvm-mc -triple powerpc-ibm-aix-xcoff %s -filetype=obj -o - | \
 # RUN:    llvm-objdump --syms - | FileCheck %s
 
       .globl .var1
 .var1:
       .globl .var2
 .var2:
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT: 00000000      df *DEBUG*  00000000 .file
-# CHECK-NEXT: 00000000 l       .text  00000000 .text
-# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var1
-# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var2
+# CHECK-NEXT: 00000000 l       .text  00000000 
+# CHECK-NEXT: 00000000 g     F .text (csect: )  00000000 .var1
+# CHECK-NEXT: 00000000 g     F .text (csect: )  00000000 .var2

llvm/test/MC/PowerPC/aix-file-symbols.s

 ## Check mutiple C_FILE symbols are emitted.
 # RUN: llvm-mc -triple powerpc-ibm-aix-xcoff %s -filetype=obj -o - | \
 # RUN:    llvm-objdump --syms - | FileCheck %s
 
       .file   "1.c"
       .globl .var1
 .var1:
       .file   "2.c"
       .globl .var2
 .var2:
       .file   "3.c"
 
 # CHECK:      SYMBOL TABLE:
 # CHECK-NEXT: 00000000      df *DEBUG*  00000000 1.c
 # CHECK-NEXT: 00000000      df *DEBUG*  00000000 2.c
 # CHECK-NEXT: 00000000      df *DEBUG*  00000000 3.c
-# CHECK-NEXT: 00000000 l       .text  00000000 .text
-# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var1
-# CHECK-NEXT: 00000000 g     F .text (csect: .text)   00000000 .var2
+# CHECK-NEXT: 00000000 l       .text  00000000 
+# CHECK-NEXT: 00000000 g     F .text (csect: )  00000000 .var1
+# CHECK-NEXT: 00000000 g     F .text (csect: )  00000000 .var2

llvm/test/tools/llvm-objdump/XCOFF/symbol-table.test

entry:
   %0 = load i8*, i8** @con, align 4
   %call = call i32 @bar(i8* %0)
   ret void
 }
 
 ; SYM:      SYMBOL TABLE:
 ; SYM-NEXT: 00000000      df *DEBUG*    00000000 <stdin>
 ; SYM-NEXT: 00000000         *UND*      00000000 ei
-; SYM-NEXT: 00000000 l       .text      00000091 .text
-; SYM-NEXT: 00000000 g     F .text (csect: .text)       00000000 .bar
-; SYM-NEXT: 00000050 g     F .text (csect: .text)       00000000 .foo
+; SYM-NEXT: 00000000 l       .text      00000091 
+; SYM-NEXT: 00000000 g     F .text (csect: )       00000000 .bar
+; SYM-NEXT: 00000050 g     F .text (csect: )       00000000 .foo
 ; SYM-NEXT: 00000094 l       .text      00000013 .rodata.str1.1L...str
 ; SYM-NEXT: 000000a8 g     O .data      00000004 con
 ; SYM-NEXT: 000000ac  w    O .data      00000004 wi
 ; SYM-NEXT: 000000b0 g     O .data      00000004 i
 ; SYM-NEXT: 000000b4 g     O .data      00000001 c
 ; SYM-NEXT: 000000b8 g     O .data      00000004 ap
 ; SYM-NEXT: 000000bc g     O .data      00000004 f
 ; SYM-NEXT: 000000c0 g     O .data      00000008 ll
 ; SYM-NEXT: 000000c8 g     O .data      0000000c bar
 ; SYM-NEXT: 000000d4 g     O .data      0000000c foo
 ; SYM-NEXT: 000000e0 l       .data      00000000 TOC
 ; SYM-NEXT: 000000e0 l     O .data      00000004 si
 ; SYM-NEXT: 000000e4 l     O .data      00000004 ei
 ; SYM-NEXT: 000000e8 l     O .data      00000004 con
 ; SYM-NEXT: 000000ec l     O *COM*      00000004 si
 
 ; SYM-DES:      SYMBOL TABLE:
 ; SYM-DES-NEXT: 00000000      df *DEBUG*    00000000 (idx: 0) <stdin>
 ; SYM-DES-NEXT: 00000000         *UND*      00000000 (idx: 1) ei[UA]
-; SYM-DES-NEXT: 00000000 l       .text      00000091 (idx: 3) .text[PR]
-; SYM-DES-NEXT: 00000000 g     F .text (csect: (idx: 3) .text[PR])  00000000 (idx: 5) .bar
-; SYM-DES-NEXT: 00000050 g     F .text (csect: (idx: 3) .text[PR])  00000000 (idx: 7) .foo
+; SYM-DES-NEXT: 00000000 l       .text      00000091 (idx: 3) [PR]
+; SYM-DES-NEXT: 00000000 g     F .text (csect: (idx: 3) [PR])  00000000 (idx: 5) .bar
+; SYM-DES-NEXT: 00000050 g     F .text (csect: (idx: 3) [PR])  00000000 (idx: 7) .foo
 ; SYM-DES-NEXT: 00000094 l       .text      00000013 (idx: 9) .rodata.str1.1L...str[RO]
 ; SYM-DES-NEXT: 000000a8 g     O .data      00000004 (idx: 11) con[RW]
 ; SYM-DES-NEXT: 000000ac  w    O .data      00000004 (idx: 13) wi[RW]
 ; SYM-DES-NEXT: 000000b0 g     O .data      00000004 (idx: 15) i[RW]
 ; SYM-DES-NEXT: 000000b4 g     O .data      00000001 (idx: 17) c[RW]
 ; SYM-DES-NEXT: 000000b8 g     O .data      00000004 (idx: 19) ap[RW]
 ; SYM-DES-NEXT: 000000bc g     O .data      00000004 (idx: 21) f[RW]
 ; SYM-DES-NEXT: 000000c0 g     O .data      00000008 (idx: 23) ll[RW]
 ; SYM-DES-NEXT: 000000c8 g     O .data      0000000c (idx: 25) bar[DS]
 ; SYM-DES-NEXT: 000000d4 g     O .data      0000000c (idx: 27) foo[DS]
 ; SYM-DES-NEXT: 000000e0 l       .data      00000000 (idx: 29) TOC[TC0]
 ; SYM-DES-NEXT: 000000e0 l     O .data      00000004 (idx: 31) si[TC]
 ; SYM-DES-NEXT: 000000e4 l     O .data      00000004 (idx: 33) ei[TC]
 ; SYM-DES-NEXT: 000000e8 l     O .data      00000004 (idx: 35) con[TC]
 ; SYM-DES-NEXT: 000000ec l     O *COM*      00000004 (idx: 37) si[BS]