[XCOFF] change default program code csect alignment to 32

[shchenz]

Summary

This is the same with commercial XLC on AIX. And Some internal improvements were found after this change.

There are some follow-ups:
1: for commercial XLC on AIX, the default csect alignment for read-write data section is 4 bytes for 32bit XCOFF and 8 bytes for 64 bit XCOFF. For llvm on AIX, now they are both 4 bytes.
2: For the XCOFF section that has one entry in the section header, commercial XLC on AIX also use 32 bytes as alignment, but now in XCOFFObjectWriter.cpp, the alignment is also 4 bytes.

[nemanjai]

Just out of curiosity, if the csect that contains a function is aligned at 2 bytes, how do we ensure loops within those functions are aligned at 32 bytes?

[shchenz]

In D114419#3148440, @nemanjai wrote:

Just out of curiosity, if the csect that contains a function is aligned at 2 bytes, how do we ensure loops within those functions are aligned at 32 bytes?

I am not checking the details, but if a function has a loop that is aligned at 32bytes, will the function be aligned at 2 bytes? I think the function alignment should be no smaller than its nested loop's alignment?

And there is a logic in the csect alignment setting that the csect alignment must be no smaller than its nested function's alignment. See

AsmPrinter::emitFunctionHeader() {
  if (MAI->hasFunctionAlignment())
    emitAlignment(MF->getAlignment(), &F)
}

[shchenz]

gentle ping

[shchenz]

gentle ping

[jsji]

Do we have any data about the *size* change due to alignment change? especially for code with lots of small functions, like perlbench?

[shchenz]

In D114419#3189763, @jsji wrote:

Do we have any data about the *size* change due to alignment change? especially for code with lots of small functions, like perlbench?

I tested perlbench on AIX with -ffunction-sections and found about 1% size increase.
I also tested some other benchmarks, and the size increments are all in 1% ~ 2% scope.

[jsji]

Can you try adding a testcase for Os or Oz to see what happens? I suspect that this change might override the pref alignment settings in Lowering.

Also have you tried to gather the performance by changing setPrefLoopAlignment(16) to setPrefLoopAlignment(32) for AIX in PPCISelLowering.cpp?
I suspect most of the performance improvement you get should be from chanig loop alignment for *large* loops -- we only set inner most small loops to 32 for now.

[shchenz]

In D114419#3197868, @jsji wrote:

Can you try adding a testcase for Os or Oz to see what happens? I suspect that this change might override the pref alignment settings in Lowering.

There is a case test_minsize() in file test/CodeGen/PowerPC/code-align.ll, there is no change for that case, so I think there should be no change for the loop alignment after this patch?

Also have you tried to gather the performance by changing setPrefLoopAlignment(16) to setPrefLoopAlignment(32) for AIX in PPCISelLowering.cpp?
I suspect most of the performance improvement you get should be from chanig loop alignment for *large* loops -- we only set inner most small loops to 32 for now.

After changing setPrefLoopAlignment(16) to setPrefLoopAlignment(32) (with/without setPrefFunctionAlignment(32)), there is no improvements found for the benchmarks that this patch improves.

Function/Loop alignment setting in PPCISelLowering.cpp should be an input to the csect alignment setting in AsmPrinter. AsmPrinter must ensure the csect alignment is suitable for the Function/Loop alignments.

AsmPrinter::emitFunctionHeader() {
  if (MAI->hasFunctionAlignment())
    emitAlignment(MF->getAlignment(), &F)
}

void MCObjectStreamer::emitValueToAlignment(unsigned ByteAlignment,
                                            int64_t Value,
                                            unsigned ValueSize,
                                            unsigned MaxBytesToEmit) {
  if (MaxBytesToEmit == 0)
    MaxBytesToEmit = ByteAlignment;
  insert(new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit));

  // Update the maximum alignment on the current section if necessary.
  MCSection *CurSec = getCurrentSectionOnly();
  if (ByteAlignment > CurSec->getAlignment())
    CurSec->setAlignment(Align(ByteAlignment));
}

[jsji]

llvm/lib/MC/XCOFFObjectWriter.cpp

1050 ↗

(On Diff #390011)

these are unrelated to the default alignment change? If we change the text alignment with -align-all-functions , we also need to deal with these? If so, please split these changes into another patch.

[shchenz]

llvm/lib/MC/XCOFFObjectWriter.cpp

1050 ↗

(On Diff #390011)

Right, if the DWARF csect alignment is the same as the section alignment defined in this file(DefaultSectionAlign=4), we are ok. But if they are not the same, we will have some issue. This is to fix this issue. I will split them into another patch.

[shchenz]

rebase for D116092

[shchenz]

gentle ping

[Esme]

I have no more comments other than some nits.

llvm/include/llvm/MC/MCSectionXCOFF.h

62

63

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

92–93

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

177

[Esme]

BTW, some tests failed in pre-merge checks, and it might be related to this patch?

[shchenz]

address @Esme comments

[shchenz]

Thanks for review @Esme . Updated accordingly.

[Esme]

LGTM, thx.

llvm/include/llvm/MC/MCSectionXCOFF.h

class MCSectionXCOFF final : public MCSection {
   friend class MCContext;
 
   Optional<XCOFF::CsectProperties> CsectProp;
   MCSymbolXCOFF *const QualName;
   StringRef SymbolTableName;
   Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags;
   bool MultiSymbolsAllowed;
   static constexpr unsigned DefaultAlignVal = 4;
+  static constexpr unsigned DefaultTextAlignVal = 32;
 
   MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
                  XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName,
                  MCSymbol *Begin, StringRef SymbolTableName,
                  bool MultiSymbolsAllowed)
       : MCSection(SV_XCOFF, Name, K, Begin),
         CsectProp(XCOFF::CsectProperties(SMC, ST)), QualName(QualName),
         SymbolTableName(SymbolTableName), DwarfSubtypeFlags(None),
         MultiSymbolsAllowed(MultiSymbolsAllowed) {
     assert(
         (ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
         "Invalid or unhandled type for csect.");
     assert(QualName != nullptr && "QualName is needed.");
     if (SMC == XCOFF::XMC_UL)
       assert((ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
              "Invalid csect type for storage mapping class XCOFF::XMC_UL");
 
     QualName->setRepresentedCsect(this);
     QualName->setStorageClass(XCOFF::C_HIDEXT);
-    // A csect is 4 byte aligned by default, except for undefined symbol csects.
-    if (ST != XCOFF::XTY_ER)
+    if (ST != XCOFF::XTY_ER) {
+      // For a csect for program code, set the alignment to 32 bytes by default.
+      // For other csects, set the alignment to 4 bytes by default.
+      if (SMC == XCOFF::XMC_PR)
+        setAlignment(Align(DefaultTextAlignVal));
+      else
         setAlignment(Align(DefaultAlignVal));
     }
+  }
 
   MCSectionXCOFF(StringRef Name, SectionKind K, MCSymbolXCOFF *QualName,
                  XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags,
                  MCSymbol *Begin, StringRef SymbolTableName,
                  bool MultiSymbolsAllowed)
       : MCSection(SV_XCOFF, Name, K, Begin), QualName(QualName),
         SymbolTableName(SymbolTableName), DwarfSubtypeFlags(DwarfSubtypeFlags),
         MultiSymbolsAllowed(MultiSymbolsAllowed) {
     assert(QualName != nullptr && "QualName is needed.");
 
     // FIXME: use a more meaningful name for non csect sections.
     QualName->setRepresentedCsect(this);
 
-    // Set default alignment 4 for all non csect sections for now.
-    // FIXME: set different alignments according to section types.
-    setAlignment(Align(DefaultAlignVal));
+    // Use default text alignment as the alignment for DWARF sections.
+    setAlignment(Align(DefaultTextAlignVal));
   }
 
   void printCsectDirective(raw_ostream &OS) const;
 
 public:
   ~MCSectionXCOFF();
 
   static bool classof(const MCSection *S) {

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],2
+; ASM:         .csect .text[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],2
+; ASM:       .csect .text[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:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 2
 ; SEC-NEXT:      Name: .data
 ; SEC-NEXT:      PhysicalAddress: 0x28
 ; SEC-NEXT:      VirtualAddress: 0x28
 ; SEC32-NEXT:    Size: 0xC
 ; SEC32-NEXT:    RawDataOffset: 0x104
-; SEC32-NEXT:    RelocationPointer: 0x1D8
+; SEC32-NEXT:    RelocationPointer: 0x1F4
 ; SEC64-NEXT:    Size: 0x18
 ; SEC64-NEXT:    RawDataOffset: 0x1A8
-; SEC64-NEXT:    RelocationPointer: 0x2B0
+; SEC64-NEXT:    RelocationPointer: 0x2C8
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 2
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DATA (0x40)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 3
 ; SEC-NEXT:      Name: .dwabrev
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC-NEXT:      Size: 0x36
-; SEC32-NEXT:    RawDataOffset: 0x110
+; SEC32-NEXT:    RawDataOffset: 0x11C
 ; SEC64-NEXT:    RawDataOffset: 0x1C0
 ; SEC-NEXT:      RelocationPointer: 0x0
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 0
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 4
 ; SEC-NEXT:      Name: .dwinfo
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC32-NEXT:    Size: 0x57
-; SEC32-NEXT:    RawDataOffset: 0x148
-; SEC32-NEXT:    RelocationPointer: 0x1EC
+; SEC32-NEXT:    RawDataOffset: 0x15C
+; SEC32-NEXT:    RelocationPointer: 0x208
 ; SEC64-NEXT:    Size: 0x6F
-; SEC64-NEXT:    RawDataOffset: 0x1F8
-; SEC64-NEXT:    RelocationPointer: 0x2CC
+; SEC64-NEXT:    RawDataOffset: 0x200
+; SEC64-NEXT:    RelocationPointer: 0x2E4
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 4
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:    Section {
 ; SEC-NEXT:      Index: 5
 ; SEC-NEXT:      Name: .dwline
 ; SEC-NEXT:      PhysicalAddress: 0x0
 ; SEC-NEXT:      VirtualAddress: 0x0
 ; SEC32-NEXT:    Size: 0x36
-; SEC32-NEXT:    RawDataOffset: 0x1A0
-; SEC32-NEXT:    RelocationPointer: 0x214
+; SEC32-NEXT:    RawDataOffset: 0x1BC
+; SEC32-NEXT:    RelocationPointer: 0x230
 ; SEC64-NEXT:    Size: 0x46
-; SEC64-NEXT:    RawDataOffset: 0x268
-; SEC64-NEXT:    RelocationPointer: 0x304
+; SEC64-NEXT:    RawDataOffset: 0x280
+; SEC64-NEXT:    RelocationPointer: 0x31C
 ; SEC-NEXT:      LineNumberPointer: 0x0
 ; SEC-NEXT:      NumberOfRelocations: 1
 ; SEC-NEXT:      NumberOfLineNumbers: 0
 ; SEC-NEXT:      Type: STYP_DWARF (0x10)
 ; SEC-NEXT:    }
 ; SEC-NEXT:  ]
 
 ; RELO:      RELOCATION RECORDS FOR [.dwinfo]:

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],2
-; CHECK-FUNC-NEXT:  .csect .foov[PR],2
+; CHECK-ASM-NEXT:   .csect .text[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

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

 define i32 @foo(i32 %i1, i32 %i2, i32 %i3, i32 %i4, i32 %i5, i32 %i6, i32 %i7, float %f1, float %f2, float %f3, float %f4, float %f5, float %f6, float %f7, float %f8, float %f9, float %f10, float %f11, float %f12, float %f13, float %f14, i32 %i8) {
 entry:
   %i1.addr = alloca i32, align 4
   store i32 %i1, i32* %i1.addr, align 4
   ret i32 %i1
 }
 
 ; CHECK-ASM-LABEL:  ._Z10add_structifd1SP2SD1Di:{{[[:space:]] *}}# %bb.0:
-; CHECK-FUNC-LABEL: csect ._Z10add_structifd1SP2SD1Di[PR],2{{[[:space:]] *}}# %bb.0:
+; CHECK-FUNC-LABEL: csect ._Z10add_structifd1SP2SD1Di[PR],5{{[[:space:]] *}}# %bb.0:
 ; COMMON-NEXT:   lwz 4, L..C0(2)
 ; COMMON-NEXT:   stfs 1, -24(1)
 ; COMMON-NEXT:   lfs 0, 0(4)
 ; COMMON-NEXT:   lwz 4, 56(1)
 ; COMMON:        fsub 0, 2, 0
 ; COMMON-NEXT:   stw 9, -36(1)
 ; COMMON-NEXT:   fadd 1, 1, 0
 ; COMMON-NEXT:   blr

 ; CHECK-ASM-NEXT:   .vbyte  4, L.._Z10add_structifd1SP2SD1Di0-._Z10add_structifd1SP2SD1Di # Function size
 ; CHECK-FUNC-NEXT:   .vbyte  4, L.._Z10add_structifd1SP2SD1Di0-._Z10add_structifd1SP2SD1Di[PR] # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x001a                       # Function name len = 26
 ; COMMON-NEXT:  .byte   "_Z10add_structifd1SP2SD1Di"    # Function Name
 ; COMMON-NEXT:                                        # -- End function
 
 
 ; CHECK-ASM-LABEL:     .main:{{[[:space:]] *}}# %bb.0:
-; CHECK-FUNC-LABEL:   .csect .main[PR],2{{[[:space:]] *}}# %bb.0
+; CHECK-FUNC-LABEL:    .csect .main[PR],5{{[[:space:]] *}}# %bb.0
 ; COMMON-NEXT:   mflr 0
 ; COMMON-NEXT:   stw 0, 8(1)
 ; COMMON:        mtlr 0
 ; COMMON-NEXT:   blr
 ; COMMON-NEXT: L..main0:
 ; COMMON-NEXT:  .vbyte  4, 0x00000000                   # Traceback table begin
 ; COMMON-NEXT:  .byte   0x00                            # Version = 0
 ; COMMON-NEXT:  .byte   0x09                            # Language = CPlusPlus

 ; CHECK-ASM-NEXT:   .vbyte  4, L..main0-.main               # Function size
 ; CHECK-FUNC-NEXT:   .vbyte  4, L..main0-.main[PR]               # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0004                       # Function name len = 4
 ; COMMON-NEXT:  .byte   "main"                        # Function Name
 ; COMMON-NEXT:                                        # -- End function
 
 
 ; CHECK-ASM-LABEL:    ._Z7add_bari1SfdP2SD1Di:{{[[:space:]] *}}# %bb.0:
-; CHECK-FUNC-LABEL:   .csect ._Z7add_bari1SfdP2SD1Di[PR],2{{[[:space:]] *}}# %bb.0:
+; CHECK-FUNC-LABEL:   .csect ._Z7add_bari1SfdP2SD1Di[PR],5{{[[:space:]] *}}# %bb.0:
 ; COMMON:       .vbyte  4, 0x00000000                   # Traceback table begin
 ; COMMON-NEXT:  .byte   0x00                            # Version = 0
 ; COMMON-NEXT:  .byte   0x09                            # Language = CPlusPlus
 ; COMMON-NEXT:  .byte   0x22                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; COMMON-NEXT:                                        # +HasTraceBackTableOffset, -IsInternalProcedure
 ; COMMON-NEXT:                                        # -HasControlledStorage, -IsTOCless
 ; COMMON-NEXT:                                        # +IsFloatingPointPresent
 ; COMMON-NEXT:                                        # -IsFloatingPointOperationLogOrAbortEnabled
 ; COMMON-NEXT:  .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; COMMON-NEXT:                                        # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
 ; COMMON-NEXT:  .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x00                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x05                            # NumberOfFixedParms = 5
 ; COMMON-NEXT:  .byte   0x05                            # NumberOfFPParms = 2, +HasParmsOnStack
 ; COMMON-NEXT:  .vbyte  4, 0x16000000                   # Parameter type = i, i, i, f, d, i, i
 ; CHECK-ASM-NEXT:  .vbyte  4, L.._Z7add_bari1SfdP2SD1Di0-._Z7add_bari1SfdP2SD1Di # Function size
 ; CHECK-FUNC-NEXT:  .vbyte  4, L.._Z7add_bari1SfdP2SD1Di0-._Z7add_bari1SfdP2SD1Di[PR] # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0016                       # Function name len = 22
 ; COMMON-NEXT:  .byte   "_Z7add_bari1SfdP2SD1Di"        # Function Name
 ; COMMON-NEXT:                                        # -- End function
 
 
 ; CHECK-ASM-LABEL:    .foo:{{[[:space:]] *}}# %bb.0:
-; CHECK-FUNC-LABEL:   .csect .foo[PR],2{{[[:space:]] *}}# %bb.0:
+; CHECK-FUNC-LABEL:   .csect .foo[PR],5{{[[:space:]] *}}# %bb.0:
 ; COMMON:       stw 3, -4(1)
 ; COMMON-NEXT:  blr
 ; COMMON-NEXT:L..foo0:
 ; COMMON-NEXT:  .vbyte  4, 0x00000000                   # Traceback table begin
 ; COMMON-NEXT:  .byte   0x00                            # Version = 0
 ; COMMON-NEXT:  .byte   0x09                            # Language = CPlusPlus
 ; COMMON-NEXT:  .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; COMMON-NEXT:                                        # +HasTraceBackTableOffset, -IsInternalProcedure

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

entry:
   %exception = call i8* @__cxa_allocate_exception(i32 4) #2
   %0 = bitcast i8* %exception to i32*
   store i32 1, i32* %0, align 16
   call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null) #3
   unreachable
 }
 
 ; ASMNFS: ._Z9throwFuncv:
-; ASMFS:    .csect ._Z9throwFuncv[PR],2
+; ASMFS:    .csect ._Z9throwFuncv[PR],5
 ; ASM:      bl .__cxa_allocate_exception[PR]
 ; ASM:      nop
 ; ASM32:    lwz 4, L..C0(2)
 ; ASM64:    ld 4, L..C0(2)
 ; ASM:      bl .__cxa_throw[PR]
 ; ASM:      nop
 
 define i32 @_Z9catchFuncv() personality i8* bitcast (i32 (...)* @__xlcxx_personality_v1 to i8*) {
eh.resume:                                        ; preds = %catch.dispatch
   %exn1 = load i8*, i8** %exn.slot, align 4
   %sel2 = load i32, i32* %ehselector.slot, align 4
   %lpad.val = insertvalue { i8*, i32 } undef, i8* %exn1, 0
   %lpad.val3 = insertvalue { i8*, i32 } %lpad.val, i32 %sel2, 1
   resume { i8*, i32 } %lpad.val3
 }
 
 ; ASMNFS: ._Z9catchFuncv:
-; ASMFS:        .csect ._Z9catchFuncv[PR],2
+; ASMFS:        .csect ._Z9catchFuncv[PR],5
 ; ASM:  L..func_begin0:
 ; ASM:  # %bb.0:                                # %entry
 ; ASM:    mflr 0
 ; ASM:  L..tmp0:
 ; ASM:    bl ._Z9throwFuncv
 ; ASM:    nop
 ; ASM:  L..tmp1:
 ; ASM:  # %bb.1:                                # %invoke.cont

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

 ; 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
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 5
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
 ; CHECKSYM32-NEXT:     StabSectNum: 0x0
 ; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

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

 ; 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
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 5
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
 ; CHECKSYM32-NEXT:     StabSectNum: 0x0
 ; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

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

 ; 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
 ; CHECK-NEXT:       ParameterHashIndex: 0x0
 ; CHECK-NEXT:       TypeChkSectNum: 0x0
-; CHECK-NEXT:       SymbolAlignmentLog2: 4
+; CHECK-NEXT:       SymbolAlignmentLog2: 5
 ; CHECK-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECK-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; CHECK-NEXT:       StabInfoIndex: 0x0
 ; CHECK-NEXT:       StabSectNum: 0x0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {
 ; CHECK-NEXT:     Index: [[#Index+2]]

llvm/test/CodeGen/PowerPC/aix-lower-jump-table.ll

 ; 64LARGE-ASM:      .csect .rodata[RO],2
 ; 64LARGE-ASM:      .align  2
 ; 64LARGE-ASM: L..JTI0_0:
 ; 64LARGE-ASM:      .vbyte  4, L..BB0_2-L..JTI0_0
 ; 64LARGE-ASM:      .vbyte  4, L..BB0_3-L..JTI0_0
 ; 64LARGE-ASM:      .vbyte  4, L..BB0_4-L..JTI0_0
 ; 64LARGE-ASM:      .vbyte  4, L..BB0_5-L..JTI0_0
 
-; FUNC-ASM:         .csect .jump_table[PR],2
+; FUNC-ASM:         .csect .jump_table[PR],5
 ; FUNC-ASM: L..BB0_2:
 ; FUNC-ASM: L..BB0_3:
 ; FUNC-ASM: L..BB0_4:
 ; FUNC-ASM: L..BB0_5:
 ; FUNC-ASM: L..BB0_6:
 ; FUNC-ASM:         li 3, 0
 ; FUNC-ASM:         blr
 ; FUNC-ASM:         .csect .rodata.jmp..jump_table[RO],2

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],2
+;   SYM:    .csect .text[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-tls-xcoff-reloc-large.ll

 ; 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
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 4
+; SYM-NEXT:       SymbolAlignmentLog2: 5
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 5

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

 ; 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
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 4
+; SYM-NEXT:       SymbolAlignmentLog2: 5
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM-NEXT:       StabInfoIndex: 0x0
 ; SYM-NEXT:       StabSectNum: 0x0
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {
 ; SYM-NEXT:     Index: 5

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

 ; 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
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
-; SYMS-NEXT:       SymbolAlignmentLog2: 2
+; SYMS-NEXT:       SymbolAlignmentLog2: 5
 ; SYMS-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYMS-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYMS-NEXT:       StabInfoIndex: 0x0
 ; SYMS-NEXT:       StabSectNum: 0x0
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 
 ; SYMS-NODATASECT:        Symbol {

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

 ; 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
 ; CHECKSYM-NEXT:       ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:       TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:       SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:       SymbolAlignmentLog2: 5
 ; CHECKSYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; CHECKSYM32-NEXT:     StabInfoIndex: 0x0
 ; CHECKSYM32-NEXT:     StabSectNum: 0x0
 ; CHECKSYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; CHECKSYM-NEXT:     }
 ; CHECKSYM-NEXT:   }
 ; CHECKSYM-NEXT:   Symbol {

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],2
+; CHECK:      .csect .text[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:     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
 ; SYMS-NEXT:       ParameterHashIndex: 0x0
 ; SYMS-NEXT:       TypeChkSectNum: 0x0
-; SYMS-NEXT:       SymbolAlignmentLog2: 2
+; SYMS-NEXT:       SymbolAlignmentLog2: 5
 ; SYMS-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYMS-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYMS32-NEXT:     StabInfoIndex: 0x0
 ; SYMS32-NEXT:     StabSectNum: 0x0
 ; SYMS64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYMS-NEXT:     }
 ; SYMS-NEXT:   }
 

llvm/test/CodeGen/PowerPC/aix-xcoff-explicit-section.ll

entry:
   %add1 = add nsw i32 %add, %2
   ret i32 %add1
 }
 
 ; CHECK:              .globl  ext_fun[DS]                     # -- Begin function ext_fun
 ; CHECK-NEXT:         .globl  .ext_fun
 ; CHECK-NEXT:         .align  4
 ; CHECK-NEXT:         .csect ext_fun[DS]
-; CHECK:              .csect .ext_fun_sec[PR],2
+; CHECK:              .csect .ext_fun_sec[PR],5
 ; CHECK-NEXT: .ext_fun:
 ; CHECK:              .csect .ext_const_sec[RO],2
 ; CHECK-NEXT:         .globl  ext_const
 ; CHECK-NEXT:         .align  2
 ; CHECK-NEXT: ext_const:
 ; CHECK-NEXT:         .vbyte  4, 1                            # 0x1
 ; CHECK-NEXT:         .csect .ext_var_sec[RW],2
 ; CHECK-NEXT:         .globl  ext_var

 ; CHECKSYM-NEXT:      Type: 0x0
 ; CHECKSYM-NEXT:      StorageClass: C_HIDEXT (0x6B)
 ; CHECKSYM-NEXT:      NumberOfAuxEntries: 1
 ; CHECKSYM-NEXT:      CSECT Auxiliary Entry {
 ; CHECKSYM-NEXT:        Index: [[#INDX+1]]
 ; CHECKSYM-NEXT:        SectionLen: 28
 ; CHECKSYM-NEXT:        ParameterHashIndex: 0x0
 ; CHECKSYM-NEXT:        TypeChkSectNum: 0x0
-; CHECKSYM-NEXT:        SymbolAlignmentLog2: 4
+; CHECKSYM-NEXT:        SymbolAlignmentLog2: 5
 ; CHECKSYM-NEXT:        SymbolType: XTY_SD (0x1)
 ; CHECKSYM-NEXT:        StorageMappingClass: XMC_PR (0x0)
 ; CHECKSYM-NEXT:        StabInfoIndex: 0x0
 ; CHECKSYM-NEXT:        StabSectNum: 0x0
 ; CHECKSYM-NEXT:      }
 ; CHECKSYM-NEXT:    }
 ; CHECKSYM-NEXT:    Symbol {
 ; CHECKSYM-NEXT:      Index: [[#INDX+2]]

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

 
 declare void @extern_foo(...)
 
 define internal void @static_overalign_foo() align 64 {
 entry:
   ret void
 }
 
-; ASM:        .csect .foo[PR],2
+; ASM:        .csect .foo[PR],5
 ; ASM-NEXT:   .globl  foo[DS]                         # -- Begin function foo
 ; ASM-NEXT:   .globl  .foo[PR]
 ; ASM-NEXT:   .align  4
 ; ASM-NEXT:   .csect foo[DS]
 ; ASM-NEXT:  alias_foo:                                # @foo
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, .foo[PR]
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
-; ASM-NEXT:   .csect .foo[PR],2
+; ASM-NEXT:   .csect .foo[PR],5
 ; ASM-NEXT:  .alias_foo:
 ; ASM-NEXT:  # %bb.0:                                # %entry
 ; ASM-NEXT:   blr
-; ASM:        .csect .hidden_foo[PR],2
+; ASM:        .csect .hidden_foo[PR],5
 ; ASM-NEXT:   .globl  hidden_foo[DS],hidden           # -- Begin function hidden_foo
 ; ASM-NEXT:   .globl  .hidden_foo[PR],hidden
 ; ASM-NEXT:   .align  4
 ; ASM-NEXT:   .csect hidden_foo[DS]
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, .hidden_foo[PR]              # @hidden_foo
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
 ; ASM-NEXT:   .csect .hidden_foo[PR]
 ; ASM-NEXT:  # %bb.0:                                # %entry
 ; ASM-NEXT:   blr
-; ASM:        .csect .bar[PR],2
+; ASM:        .csect .bar[PR],5
 ; ASM-NEXT:   .globl  bar[DS]                         # -- Begin function bar
 ; ASM-NEXT:   .globl  .bar[PR]
 ; ASM-NEXT:   .align  4
 ; ASM-NEXT:   .csect bar[DS]
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, .bar[PR]                     # @bar
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, TOC[TC0]
 ; ASM-NEXT:   .vbyte  {{[0-9]+}}, 0
-; ASM-NEXT:   .csect .bar[PR],2
+; ASM-NEXT:   .csect .bar[PR],5
 ; ASM-NEXT:  # %bb.0:                                # %entry
 ; ASM:        bl .foo[PR]
 ; ASM-NEXT:   nop
 ; ASM-NEXT:   bl .static_overalign_foo[PR]
 ; ASM-NEXT:   nop
 ; ASM-NEXT:   bl .alias_foo
 ; ASM-NEXT:   nop
 ; ASM-NEXT:   bl .extern_foo

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

 # 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
 # SYM-NEXT:      ParameterHashIndex: 0x0
 # SYM-NEXT:      TypeChkSectNum: 0x0
-# SYM-NEXT:      SymbolAlignmentLog2: 4
+# SYM-NEXT:      SymbolAlignmentLog2: 5
 # SYM-NEXT:      SymbolType: XTY_SD (0x1)
 # SYM-NEXT:      StorageMappingClass: XMC_PR (0x0)
 # SYM-NEXT:      StabInfoIndex: 0x0
 # SYM-NEXT:      StabSectNum: 0x0
 # SYM-NEXT:    }
 # SYM-NEXT:  }
 # SYM:       Symbol {{[{][[:space:]] *}}Index: [[#RO_INDX]]{{[[:space:]] *}}Name: .rodata
 # SYM-NEXT:    Value (RelocatableAddress): 0x8

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

 ; 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
 ; SYM-NEXT:       ParameterHashIndex: 0x0
 ; SYM-NEXT:       TypeChkSectNum: 0x0
-; SYM-NEXT:       SymbolAlignmentLog2: 4
+; SYM-NEXT:       SymbolAlignmentLog2: 5
 ; SYM-NEXT:       SymbolType: XTY_SD (0x1)
 ; SYM-NEXT:       StorageMappingClass: XMC_PR (0x0)
 ; SYM32-NEXT:     StabInfoIndex: 0x0
 ; SYM32-NEXT:     StabSectNum: 0x0
 ; SYM64-NEXT:     Auxiliary Type: AUX_CSECT (0xFB)
 ; SYM-NEXT:     }
 ; SYM-NEXT:   }
 ; SYM-NEXT:   Symbol {

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],2
+; ASM-NEXT:    .csect .text[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],2
+; ASM-NEXT:    .csect .text[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],2
+; ASM-NEXT:    .csect .text[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/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],2
+; CHECK-NEXT: .csect .text[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],2
+; CHECK-NEXT: .csect .text[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],2
+; CHECK-NEXT: .csect .text[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],2
+; ASM32:               .csect .text[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],2
+; ASM32-NEXT:          .csect .text[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],2
+; ASM64:               .csect .text[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],2
+; ASM64-NEXT:          .csect .text[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],2
+; CHECK:               .csect .text[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],2
+; CHECK-NEXT:          .csect .text[PR],5
 ; CHECK-NEXT:  .bar:
 ; CHECK-NEXT:  L..func_begin0:
 ; CHECK-NEXT:  # %bb.0:                                # %entry
 ; CHECK-NEXT:  L..tmp0:
 ; CHECK-NEXT:  L..tmp1:
 ; CHECK-NEXT:          li 3, 1
 ; CHECK-NEXT:          blr
 ; CHECK-NEXT:  L..tmp2:

 ; CHECK-NEXT:          .byte   0x00                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; CHECK-NEXT:          .byte   0x00                            # NumberOfFixedParms = 0
 ; CHECK-NEXT:          .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; CHECK-NEXT:          .vbyte  4, L..bar0-.bar                 # Function size
 ; CHECK-NEXT:          .vbyte  2, 0x0003                       # Function name len = 3
 ; CHECK-NEXT:          .byte   "bar"                           # Function Name
 ; CHECK-NEXT:  L..func_end0:
 ; CHECK-NEXT:                                          # -- End function
-; CHECK-NEXT:          .csect explicit_main_sec[PR],2
+; CHECK-NEXT:          .csect explicit_main_sec[PR],5
 ; CHECK-NEXT:          .globl  main[DS]                        # -- Begin function main
 ; CHECK-NEXT:          .globl  .main
 ; CHECK-NEXT:          .align  2
 ; CHECK-NEXT:          .csect main[DS],2
 ; CHECK-NEXT:          .vbyte  4, .main                        # @main
 ; CHECK-NEXT:          .vbyte  4, TOC[TC0]
 ; CHECK-NEXT:          .vbyte  4, 0
-; CHECK-NEXT:          .csect explicit_main_sec[PR],2
+; CHECK-NEXT:          .csect explicit_main_sec[PR],5
 ; CHECK-NEXT:  .main:
 ; CHECK-NEXT:  L..func_begin1:
 ; CHECK-NEXT:  # %bb.0:                                # %entry
 ; CHECK-NEXT:  L..tmp3:
 ; CHECK-NEXT:          mflr 0
 ; CHECK-NEXT:          stw 0, 8(1)
 ; CHECK-NEXT:          stwu 1, -64(1)
 ; CHECK-NEXT:          li 3, 0

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],2
+; CHECK:               .csect .text[PR],5
 ; CHECK-NEXT:          .file   "1.c"
-; CHECK-NEXT:          .csect .foo[PR],2
+; 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]
 ; CHECK-NEXT:          .vbyte  4, 0
-; CHECK-NEXT:          .csect .foo[PR],2
+; CHECK-NEXT:          .csect .foo[PR],5
 ; CHECK-NEXT:  L..func_begin0:
 ; CHECK-NEXT:  # %bb.0:                                # %entry
 ; CHECK-NEXT:  L..tmp0:
 ; CHECK-NEXT:  L..tmp1:
 ; CHECK-NEXT:          li 3, 0
 ; CHECK-NEXT:          blr
 ; CHECK-NEXT:  L..tmp2:
 ; CHECK-NEXT:  L..foo0:

 ; CHECK-NEXT:          .byte   0x00                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; CHECK-NEXT:          .byte   0x00                            # NumberOfFixedParms = 0
 ; CHECK-NEXT:          .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; CHECK-NEXT:          .vbyte  4, L..foo0-.foo[PR]             # Function size
 ; CHECK-NEXT:          .vbyte  2, 0x0003                       # Function name len = 3
 ; CHECK-NEXT:          .byte   "foo"                           # Function Name
 ; CHECK-NEXT:  L..func_end0:
 ; CHECK-NEXT:                                          # -- End function
-; CHECK-NEXT:          .csect .bar[PR],2
+; CHECK-NEXT:          .csect .bar[PR],5
 ; CHECK-NEXT:          .globl  bar[DS]                         # -- Begin function bar
 ; CHECK-NEXT:          .globl  .bar[PR]
 ; CHECK-NEXT:          .align  2
 ; CHECK-NEXT:          .csect bar[DS],2
 ; CHECK-NEXT:          .vbyte  4, .bar[PR]                     # @bar
 ; CHECK-NEXT:          .vbyte  4, TOC[TC0]
 ; CHECK-NEXT:          .vbyte  4, 0
-; CHECK-NEXT:          .csect .bar[PR],2
+; CHECK-NEXT:          .csect .bar[PR],5
 ; CHECK-NEXT:  L..func_begin1:
 ; CHECK-NEXT:  # %bb.0:                                # %entry
 ; CHECK-NEXT:  L..tmp3:
 ; CHECK-NEXT:  L..tmp4:
 ; CHECK-NEXT:          li 3, 1
 ; CHECK-NEXT:          blr
 ; CHECK-NEXT:  L..tmp5:
 ; CHECK-NEXT:  L..bar0: