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

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

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

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.

31–32

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

35–36

Same comment.

[hubert.reinterpretcast]

LGTM; thanks!

[daltenty]

LGTM with some minor nits

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

6–8 ↗

(On Diff #540010)

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

20–24 ↗

(On Diff #540010)

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-pgo-function-sections.ll

 ; CHECK:             .csect __llvm_prf_data.__profd_func2[RW]
 ; CHECK-NEXT:        .rename __llvm_prf_data.__profd_func2[RW],"__llvm_prf_data"
 
 ; OBJ32:      SYMBOL TABLE:
 ; OBJ32-NEXT: 00000000      df *DEBUG*  00000000 <stdin>
 ; OBJ32-NEXT: 00000000         *UND*  00000000 .external_func
 ; OBJ32-NEXT: 00000000         *UND*  00000000 i
 ; OBJ32-NEXT: 00000000         *UND*  00000000 external_func
-; OBJ32-NEXT: 00000000 l       .text  00000000 .text
+; OBJ32-NEXT: 00000000 l       .text  00000000 
 ; OBJ32-NEXT: 00000000 g       .text  0000003f .func1
 ; OBJ32-NEXT: 00000040 g       .text  0000005f .func2
 ; OBJ32-NEXT: 000000a0  w      .text  00000008 .hidden __llvm_profile_raw_version
 ; OBJ32-NEXT: 000000a8 l       .text  0000000d __llvm_prf_names
 ; OBJ32-NEXT: 000000c0  w      .text  00000013 .hidden __llvm_profile_filename
 ; OBJ32-NEXT: 000000d8 l     O .data  00000008 __llvm_prf_cnts
 ; OBJ32-NEXT: 000000e0 l     O .data  00000028 __llvm_prf_data
 ; OBJ32-NEXT: 00000108 l     O .data  00000008 __llvm_prf_cnts

 ; OBJ32-NEXT: 0000007c R_POS                    i
 ; OBJ32-NEXT: 00000080 R_POS                    __llvm_prf_cnts
 
 ; OBJ64:      SYMBOL TABLE:
 ; OBJ64-NEXT: 0000000000000000      df *DEBUG*  0000000000000000 <stdin>
 ; OBJ64-NEXT: 0000000000000000         *UND*  0000000000000000 .external_func
 ; OBJ64-NEXT: 0000000000000000         *UND*  0000000000000000 i
 ; OBJ64-NEXT: 0000000000000000         *UND*  0000000000000000 external_func
-; OBJ64-NEXT: 0000000000000000 l       .text  0000000000000000 .text
+; OBJ64-NEXT: 0000000000000000 l       .text  0000000000000000 
 ; OBJ64-NEXT: 0000000000000000 g       .text  0000000000000033 .func1
 ; OBJ64-NEXT: 0000000000000040 g       .text  0000000000000053 .func2
 ; OBJ64-NEXT: 0000000000000098  w      .text  0000000000000008 .hidden __llvm_profile_raw_version
 ; OBJ64-NEXT: 00000000000000a0 l       .text  000000000000000d __llvm_prf_names
 ; OBJ64-NEXT: 00000000000000b0  w      .text  0000000000000013 .hidden __llvm_profile_filename
 ; OBJ64-NEXT: 00000000000000c8 l     O .data  0000000000000008 __llvm_prf_cnts
 ; OBJ64-NEXT: 00000000000000d0 l     O .data  0000000000000038 __llvm_prf_data
 ; OBJ64-NEXT: 0000000000000108 l     O .data  0000000000000008 __llvm_prf_cnts

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
+
+source_filename = "text.c"
+target datalayout = "E-m:a-p:32:32-Fi32-i64:64-n32"
+target triple = "powerpc-ibm-aix7.2.0.0"
+
+define i32 @text() {
+entry:
+  ret i32 1
+}
+
+define i32 @text2() {
+entry:
+  ret i32 2
+}
+
+!llvm.module.flags = !{!1}
+!llvm.ident = !{!3}
+
+!1 = !{i32 8, !"PIC Level", i32 2}
+!3 = !{!""}
+
+; CHECKFS32: 00000000 l       .text  00000000 (idx: {{[[:digit:]]*}}) [PR]
+; CHECKFS32-NEXT: 00000000 g       .text  {{([[:xdigit:]]{8})}} (idx: {{[[:digit:]]*}}) .text
+; CHECKFS32-NEXT: {{([[:xdigit:]]{8})}} g       .text  {{([[:xdigit:]]{8})}} (idx: {{[[:digit:]]*}}) .text2
+
+; CHECKFS64: 0000000000000000 l       .text  0000000000000000 
+; CHECKFS64-NEXT: 0000000000000000 g       .text  {{([[:xdigit:]]{16})}} (idx: {{[[:digit:]]*}}) .text
+; CHECKFS64-NEXT: {{([[:xdigit:]]{16})}} g       .text  {{([[:xdigit:]]{16})}} (idx: {{[[:digit:]]*}}) .text2
+
+; 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.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