[llvm][XCOFF] Don't seperate mergable strings by alignment

[daltenty]

Summary

Currently when we place mergable strings into a csect, we generate the name according to the size and alignment, which is something
we inherited from the ELF backend, which merges the strings in compatible sections.

However, for XCOFF, this causes problems (as seen in https://reviews.llvm.org/D134282) if a late CodeGen pass tries to update the
alignment of the global, as we emit relocations directly to this section for XCOFF. To avoid this situation and simplify things, this
change drops the alignment from the identifier, since it doesn't really serve a purpose without the accompanying linker feature.

[daltenty]

It seems there's actually some work going on at the present time to re-work how constant data like this is structured in the XCOFF codegen (e.g. to do some pooling). This patch is likely to conflict and/or be superseded by that approach, so I'm going to put this on hold for the moment till that refactoring lands and we see whether this is still relevant.

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (Kind.isBSSLocal() || GO->hasCommonLinkage() || Kind.isThreadBSSLocal()) {
     XCOFF::StorageMappingClass SMC = Kind.isBSSLocal() ? XCOFF::XMC_BS
                                      : Kind.isCommon() ? XCOFF::XMC_RW
                                                        : XCOFF::XMC_UL;
     return getContext().getXCOFFSection(
         Name, Kind, XCOFF::CsectProperties(SMC, XCOFF::XTY_CM));
   }
 
   if (Kind.isMergeableCString()) {
-    Align Alignment = GO->getParent()->getDataLayout().getPreferredAlign(
-        cast<GlobalVariable>(GO));
-
     unsigned EntrySize = getEntrySizeForKind(Kind);
-    std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
-    SmallString<128> Name;
-    Name = SizeSpec + utostr(Alignment.value());
+    SmallString<128> Name(".rodata.str");
+    Name += utostr(EntrySize);
 
     if (TM.getDataSections())
       getNameWithPrefix(Name, GO, TM);
 
     return getContext().getXCOFFSection(
         Name, Kind, XCOFF::CsectProperties(XCOFF::XMC_RO, XCOFF::XTY_SD),
         /* MultiSymbolsAllowed*/ !TM.getDataSections());
   }

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

 ; CHECK: li 3, 55
 ; CHECK: blr
 }
 
 ;CHECKOBJ32:    00000000 <.foo>:
 ;CHECKOBJ64:    0000000000000000 <.foo>:
 ;CHECKOBJ-NEXT:       0: 38 60 00 37                    li 3, 55
 ;CHECKOBJ-NEXT:       4: 4e 80 00 20                    blr{{[[:space:]] *}}
-;CHECKOBJ32-NEXT: 00000008 <.rodata.str1.1>:
-;CHECKOBJ64-NEXT: 0000000000000008 <.rodata.str1.1>:
+;CHECKOBJ32-NEXT: 00000008 <.rodata.str1>:
+;CHECKOBJ64-NEXT: 0000000000000008 <.rodata.str1>:
 ;CHECKOBJ-NEXT:       8: 68 65 6c 6c                   xori 5, 3, 27756
 ;CHECKOBJ-NEXT:       c: 6f 77 6f 72 xoris 23, 27, 28530
 ;CHECKOBJ-NEXT:      10: 0a 00 00 00 tdlti 0, 0{{[[:space:]] *}}
 ;CHECKOBJ-NEXT:   Disassembly of section .data:{{[[:space:]] *}}
 ;CHECKOBJ32-NEXT: 00000018 <a>:
 ;CHECKOBJ64-NEXT: 0000000000000018 <a>:
 ;CHECKOBJ-NEXT:      18: 00 01 23 45                   <unknown>
 ;CHECKOBJ-NEXT:      1c: 67 8a bc de                   oris 10, 28, 48350{{[[:space:]] *}}

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

 ; CHECK-NEXT:         .align  2
 ; CHECK-NEXT:         .vbyte  4, 35                           # 0x23
 ; CHECK-NEXT:         .csect const_ivar[RO],2
 ; CHECK-NEXT:         .globl  const_ivar[RO]
 ; CHECK-NEXT:         .align  2
 ; CHECK-NEXT:         .vbyte  4, 35                           # 0x23
 ; CHECK-NEXT:         .comm   a[RW],4,2
 ; CHECK-NEXT:         .comm   f[RW],4,2
-; CHECK-NEXT:         .csect .rodata.str1.1L...str[RO],2
+; CHECK-NEXT:         .csect .rodata.str1L...str[RO],2
 ; CHECK-NEXT:         .string "abcdefgh"
 ; CHECK32:            .csect p[RW],2
 ; CHECK32-NEXT:       .globl  p[RW]
 ; CHECK32-NEXT:       .align  2
-; CHECK32-NEXT:       .vbyte  4, .rodata.str1.1L...str[RO]
+; CHECK32-NEXT:       .vbyte  4, .rodata.str1L...str[RO]
 ; CHECK64:            .csect p[RW],3
 ; CHECK64-NEXT:       .globl  p[RW]
 ; CHECK64-NEXT:       .align  3
-; CHECK64-NEXT:       .vbyte  8, .rodata.str1.1L...str[RO]
+; CHECK64-NEXT:       .vbyte  8, .rodata.str1L...str[RO]
 ; CHECK:              .toc
 ; CHECK-NEXT: L..C0:
 ; CHECK-NEXT:         .tc p[TC],p[RW]
 ; CHECK-NEXT: L..C1:
 ; CHECK-NEXT:         .tc ivar[TC],ivar[RW]
 ; CHECK-NEXT: L..C2:
 ; CHECK-NEXT:         .tc a[TC],a[RW]
 ; CHECK-NEXT: L..C3:
 ; CHECK-NEXT:         .tc f[TC],f[RW]
 
 ; CHECKOBJ:        00000038 (idx: 7) const_ivar[RO]:
 ; CHECKOBJ-NEXT:         38: 00 00 00 23   <unknown>
 ; CHECKOBJ-EMPTY:
-; CHECKOBJ-NEXT:   0000003c (idx: 9) .rodata.str1.1L...str[RO]:
+; CHECKOBJ-NEXT:   0000003c (idx: 9) .rodata.str1L...str[RO]:
 ; CHECKOBJ-NEXT:         3c: 61 62 63 64
 ; CHECKOBJ-NEXT:         40: 65 66 67 68
 ; CHECKOBJ-NEXT:         44: 00 00 00 00   <unknown>
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   Disassembly of section .data:
 ; CHECKOBJ-EMPTY:
 ; CHECKOBJ-NEXT:   00000048 (idx: 11) ivar[RW]:
 ; CHECKOBJ-NEXT:         48: 00 00 00 23   <unknown>

 ; CHECKSYM:        SymbolAlignmentLog2: 2
 ; CHECKSYM:        SymbolType: XTY_SD (0x1)
 ; CHECKSYM:        StorageMappingClass: XMC_RO (0x1)
 ; CHECKSYM:        StabInfoIndex: 0x0
 ; CHECKSYM:        StabSectNum: 0x0
 ; CHECKSYM:      }
 ; CHECKSYM:    }
 ; CHECKSYM:    Symbol {
-; CHECKSYM:      Name: .rodata.str1.1L...str
+; CHECKSYM:      Name: .rodata.str1L...str
 ; CHECKSYM:      Value (RelocatableAddress): 0x3C
 ; CHECKSYM:      Section: .text
 ; CHECKSYM:      Type: 0x0
 ; CHECKSYM:      StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM:      NumberOfAuxEntries: 1
 ; CHECKSYM:      CSECT Auxiliary Entry {
 ; CHECKSYM:        SectionLen: 9
 ; CHECKSYM:        ParameterHashIndex: 0x0

llvm/test/CodeGen/PowerPC/aix-xcoff-mergeable-str.ll

 ; Function Attrs: noinline nounwind optnone
 define i8 @foo() #0 {
 entry:
   %0 = load ptr, ptr @p, align 4
   %1 = load i8, ptr %0, align 1
   ret i8 %1
 }
 
-; CHECK:   .csect .rodata.str2.2[RO],2
+; CHECK:   .csect .rodata.str2[RO],2
 ; CHECK-NEXT:   .align  1
 ; CHECK-NEXT: L..magic16:
 ; CHECK-NEXT:   .vbyte  2, 264                     # 0x108
 ; CHECK-NEXT:   .vbyte  2, 272                     # 0x110
 ; CHECK-NEXT:   .vbyte  2, 213                     # 0xd5
 ; CHECK-NEXT:   .vbyte  2, 0                       # 0x0
-; CHECK-NEXT:   .csect .rodata.str4.4[RO],2
+; CHECK-NEXT:   .csect .rodata.str4[RO],2
 ; CHECK-NEXT:   .align  2
 ; CHECK-NEXT: L..magic32:
 ; CHECK-NEXT:   .vbyte  4, 464                     # 0x1d0
 ; CHECK-NEXT:   .vbyte  4, 472                     # 0x1d8
 ; CHECK-NEXT:   .vbyte  4, 413                     # 0x19d
 ; CHECK-NEXT:   .vbyte  4, 0                       # 0x0
-; CHECK-NEXT:   .csect .rodata.str1.1[RO],2
+; CHECK-NEXT:   .csect .rodata.str1[RO],2
 ; CHECK-NEXT: L..strA:
 ; CHECK-NEXT: .byte   'h,'e,'l,'l,'o,' ,'w,'o,'r,'l,'d,'!,0012,0000
 ; CHECK-NEXT: L...str:
 ; CHECK-NEXT: .string "abcdefgh"
 
-; CHECKOBJ:     00000010 <.rodata.str2.2>:
+; CHECKOBJ:     00000010 <.rodata.str2>:
 ; CHECKOBJ-NEXT:       10: 01 08 01 10
 ; CHECKOBJ-NEXT:       14: 00 d5 00 00    {{.*}}{{[[:space:]] *}}
-; CHECKOBJ-NEXT: 00000018 <.rodata.str4.4>:
+; CHECKOBJ-NEXT: 00000018 <.rodata.str4>:
 ; CHECKOBJ-NEXT:       18: 00 00 01 d0
 ; CHECKOBJ-NEXT:       1c: 00 00 01 d8
 ; CHECKOBJ-NEXT:       20: 00 00 01 9d
 ; CHECKOBJ-NEXT:       24: 00 00 00 00    {{.*}}{{[[:space:]] *}}
-; CHECKOBJ-NEXT: 00000028 <.rodata.str1.1>:
+; CHECKOBJ-NEXT: 00000028 <.rodata.str1>:
 ; CHECKOBJ-NEXT:       28: 68 65 6c 6c
 ; CHECKOBJ-NEXT:       2c: 6f 20 77 6f
 ; CHECKOBJ-NEXT:       30: 72 6c 64 21
 ; CHECKOBJ-NEXT:       34: 0a 00 61 62
 ; CHECKOBJ-NEXT:       38: 63 64 65 66
 ; CHECKOBJ-NEXT:       3c: 67 68 00 00

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

 }
 
 ; 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: 00000094 l       .text      00000013 .rodata.str1.1L...str
+; SYM-NEXT: 00000094 l       .text      00000013 .rodata.str1L...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: 00000094 l       .text      00000013 (idx: 9) .rodata.str1.1L...str[RO]
+; SYM-DES-NEXT: 00000094 l       .text      00000013 (idx: 9) .rodata.str1L...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]