[AIX] unset bit "IsBackChainStored" of traceback table for leaf functions with no stack frame

[DiggerLin]

Summary

in function PPCAIXAsmPrinter::emitTracebackTable() ,the bit "IsBackChainStored" of traceback table always set true, it will cause aix debug tools "dbx" emit an error info "libdebug assertion "(framep->getGpr(STKP, &addr) == DB_SUCCESS && *nextStkpp == addr)" when debug a leaf functions with no stack frame.

If a a leaf functions with no stack frame , the bit IsBackChainStored should be unset.

[stephenpeckham]

Are there still tests where IsBackChainStored is true?

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2098–2099

Comment no longer applies

[shchenz]

We should already have case for leaf/non-leaf functions. Can we also add cases on the boundary conditions for redzone with below MIR?

---
name:            test
tracksRegLiveness: true
stack:
  - { id: 0, size: 288, alignment: 16 }
body: |
  bb.0:
    BLR8 implicit $lr8, implicit $rm
...

288 is redzone size for 64-bit PPC.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2100

Are you using the wrong diff baseline? Seems like the left side is a local commit of your working branch? In the main trunk, I see

// Always store back chain.
SecondHalfOfMandatoryField |= TracebackTable::IsBackChainStoredMask;

[DiggerLin]

fixed part of comment.

[DiggerLin]

In D146071#4194372, @stephenpeckham wrote:

Are there still tests where IsBackChainStored is true?

yes, for example ,in the test llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable.ll , line 177

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2098–2099

thanks

2100

yes, left side is working. thanks

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2100

I git diff again my local branch, it correct now.

[DiggerLin]

add a redzone boundary test case

[shchenz]

LGTM. Thanks for improving this.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

#define GENVALUECOMMENT(PrefixAndName, V, Field)                               \
   GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsCRSaved);
   GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsLRSaved);
   EmitComment();
   OutStreamer->emitIntValueInHexWithPadding((FirstHalfOfMandatoryField & 0xff),
                                             1);
 
   // Set the 5th byte of mandatory field.
   uint32_t SecondHalfOfMandatoryField = 0;
 
-  // Always store back chain.
-  SecondHalfOfMandatoryField |= TracebackTable::IsBackChainStoredMask;
+  SecondHalfOfMandatoryField |= MF->getFrameInfo().getStackSize()
+                                    ? TracebackTable::IsBackChainStoredMask
+                                    : 0;
 
   uint32_t FPRSaved = 0;
   for (unsigned Reg = PPC::F14; Reg <= PPC::F31; ++Reg) {
     if (MRI.isPhysRegModified(Reg)) {
       FPRSaved = PPC::F31 - Reg + 1;
       break;
     }
   }

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

 ; 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   0x85                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 5
+; COMMON-NEXT:  .byte   0x05                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 5
 ; COMMON-NEXT:  .byte   0x04                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 4
 ; COMMON-NEXT:  .byte   0x00                            # NumberOfFixedParms = 0
 ; COMMON-NEXT:  .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; CHECK-ASM-NEXT:   .vbyte  4, L..bar0-.bar                 # Function size
 ; CHECK-FUNC-NEXT:  .vbyte  4, L..bar0-.bar[PR]             # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0003                       # Function name len = 3
 ; COMMON-NEXT:  .byte   "bar"                           # Function Name
 ; COMMON-NEXT:                                        # -- End function
 
 ; COMMON:     L..foov0:
 ; 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
 ; 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                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; COMMON-NEXT:  .byte   0xc0                            # +HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x00                            # NumberOfFixedParms = 0
 ; COMMON-NEXT:  .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; CHECK-ASM-NEXT:   .vbyte  4, L..foov0-.foov               # Function size
 ; CHECK-FUNC-NEXT:  .vbyte  4, L..foov0-.foov[PR]           # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0004                       # Function name len = 4
 ; COMMON-NEXT:  .byte   "foov"                          # Function Name 
 ; COMMON-NEXT:  .byte   0x12                            # NumOfVRsSaved = 4, +IsVRSavedOnStack, -HasVarArgs

llvm/test/CodeGen/PowerPC/aix-emit-tracebacktable-redzone-boundary.mir

+## Test when the frame size is equal to or large than redzone boundary size(288).
+## The behaviour of IsBackChainStored bit of traceback table.
+# RUN: llc  -mtriple powerpc64-ibm-aix-xcoff -o -\
+# RUN:   %s | FileCheck %s
+
+---
+name:            test
+tracksRegLiveness: true
+stack:
+  - { id: 0, size: 288, alignment: 16 }
+body: |
+  bb.0:
+    BLR8 implicit $lr8, implicit $rm
+
+---
+name:            overredzone
+tracksRegLiveness: true
+stack:
+  - { id: 0, size: 296, alignment: 16 }
+body: |
+  bb.0:
+    BLR8 implicit $lr8, implicit $rm
+
+
+  ; CHECK:              .vbyte  4, 0x00000000                   # Traceback table begin
+  ; CHECK-NEXT:         .byte   0x00                            # Version = 0
+  ; CHECK-NEXT:         .byte   0x09                            # Language = CPlusPlus
+  ; CHECK-NEXT:         .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
+  ; CHECK-NEXT:                                         # +HasTraceBackTableOffset, -IsInternalProcedure
+  ; CHECK-NEXT:                                         # -HasControlledStorage, -IsTOCless
+  ; CHECK-NEXT:                                         # -IsFloatingPointPresent
+  ; CHECK-NEXT:                                         # -IsFloatingPointOperationLogOrAbortEnabled
+  ; CHECK-NEXT:         .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
+  ; CHECK-NEXT:                                         # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
+  ; CHECK-NEXT:         .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+  ; 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..test0-.test               # Function size
+  ; CHECK-NEXT:         .vbyte  2, 0x0004                       # Function name len = 4
+  ; CHECK-NEXT:         .byte   "test"                          # Function Name
+
+  ; CHECK:              .vbyte  4, 0x00000000                   # Traceback table begin
+  ; CHECK-NEXT:         .byte   0x00                            # Version = 0
+  ; CHECK-NEXT:         .byte   0x09                            # Language = CPlusPlus
+  ; CHECK-NEXT:         .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
+  ; CHECK-NEXT:                                         # +HasTraceBackTableOffset, -IsInternalProcedure
+  ; CHECK-NEXT:                                         # -HasControlledStorage, -IsTOCless
+  ; CHECK-NEXT:                                         # -IsFloatingPointPresent
+  ; CHECK-NEXT:                                         # -IsFloatingPointOperationLogOrAbortEnabled
+  ; CHECK-NEXT:         .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
+  ; CHECK-NEXT:                                         # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
+  ; CHECK-NEXT:         .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+  ; 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..overredzone0-.overredzone # Function size
+  ; CHECK-NEXT:         .vbyte  2, 0x000b                       # Function name len = 11
+  ; CHECK-NEXT:         .byte   "overredzone"                   # Function Name
+...

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

 ; 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                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x40                            # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x02                            # NumberOfFixedParms = 2
 ; COMMON-NEXT:  .byte   0x05                            # NumberOfFPParms = 2, +HasParmsOnStack
 ; COMMON-NEXT:  .vbyte  4, 0x42740000                   # Parameter type = v, i, i, f, v, d, v
 ; CHECK-ASM-NEXT:  .vbyte  4, L..f0-.f                     # Function size
 ; CHECK-FUNC-NEXT: .vbyte  4, L..f0-.f[PR]                 # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0001                       # Function name len = 1
 ; COMMON-NEXT:  .byte   102                             # Function Name
 ; COMMON-NEXT:  .byte   0x00                            # NumOfVRsSaved = 0, -IsVRSavedOnStack, -HasVarArgs
 ; COMMON-NEXT:  .byte   0x07                            # NumOfVectorParams = 3, +HasVMXInstruction
 ; COMMON-NEXT:  .vbyte  4, 0xb0000000                   # Vector Parameter type = vi, vf, vc
 ; COMMON-NEXT:  .vbyte  2, 0x0000                       # Padding 
 
 ; COMMON:     L..fin0:
 ; COMMON-NEXT:  .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                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x40                            # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x01                            # NumberOfFixedParms = 1
 ; COMMON-NEXT:  .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; COMMON-NEXT:  .vbyte  4, 0x00000000                   # Parameter type = i
 ; CHECK-ASM-NEXT:       .vbyte  4, L..fin0-.fin                 # Function size
 ; CHECK-FUNC-NEXT:      .vbyte  4, L..fin0-.fin[PR]             # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0003                       # Function name len = 3
 ; COMMON-NEXT:  .byte   "fin"                           # Function Name 
 ; COMMON-NEXT:  .byte   0x00                            # NumOfVRsSaved = 0, -IsVRSavedOnStack, -HasVarArgs
 ; COMMON-NEXT:  .byte   0x01                            # NumOfVectorParams = 0, +HasVMXInstruction
 ; COMMON-NEXT:  .vbyte  4, 0x00000000                   # Vector Parameter type =
 ; COMMON-NEXT:  .vbyte  2, 0x0000                       # Padding

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

 ;CHECK-ASM-NEXT:        .byte   0x09                            # Language = CPlusPlus
 ;CHECK-ASM-NEXT:        .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ;CHECK-ASM-NEXT:                                         # +HasTraceBackTableOffset, -IsInternalProcedure
 ;CHECK-ASM-NEXT:                                         # -HasControlledStorage, -IsTOCless
 ;CHECK-ASM-NEXT:                                         # -IsFloatingPointPresent
 ;CHECK-ASM-NEXT:                                         # -IsFloatingPointOperationLogOrAbortEnabled
 ;CHECK-ASM-NEXT:        .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ;CHECK-ASM-NEXT:                                         # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
-;CHECK-ASM-NEXT:        .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+;CHECK-ASM-NEXT:        .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ;CHECK-ASM-NEXT:        .byte   0x40                            # -HasExtensionTable, +HasVectorInfo, NumOfGPRsSaved = 0
 ;CHECK-ASM-NEXT:        .byte   0x00                            # NumberOfFixedParms = 0
 ;CHECK-ASM-NEXT:        .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ;CHECK-ASM-NEXT:        .vbyte  4, L..f0-.f                     # Function size
 ;CHECK-ASM-NEXT:        .vbyte  2, 0x0001                       # Function name len = 1
 ;CHECK-ASM-NEXT:        .byte   102                             # Function Name
 ;CHECK-ASM-NEXT:        .byte   0x01                            # NumOfVRsSaved = 0, -IsVRSavedOnStack, +HasVarArgs
 ;CHECK-ASM-NEXT:        .byte   0x03                            # NumOfVectorParams = 1, +HasVMXInstruction
 ;CHECK-ASM-NEXT:        .vbyte  4, 0xc0000000                   # Vector Parameter type = vf
 ;CHECK-ASM-NEXT:        .vbyte  2, 0x0000                       # Padding 
 ;CHECK-ASM-NEXT:                                         # -- End function

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

 ; 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                            # -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, 0x58000000                   # Parameter type = i, f, d, i, i, i, i
 ; 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:  .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                            # -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:  .byte   0x09                            # Language = CPlusPlus
 ; COMMON-NEXT:  .byte   0x20                            # -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                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x00                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; COMMON-NEXT:  .byte   0x07                            # NumberOfFixedParms = 7
 ; COMMON-NEXT:  .byte   0x1b                            # NumberOfFPParms = 13, +HasParmsOnStack
 ; COMMON-NEXT:  .vbyte  4, 0x01555554                   # Parameter type = i, i, i, i, i, i, i, f, f, f, f, f, f, f, f, f, f, f, f, ...
 ; CHECK-ASM-NEXT:  .vbyte  4, L..foo0-.foo                 # Function size
 ; CHECK-FUNC-NEXT: .vbyte  4, L..foo0-.foo[PR]                 # Function size
 ; COMMON-NEXT:  .vbyte  2, 0x0003                       # Function name len = 3
 ; COMMON-NEXT:  .byte   "foo"                           # Function Name
 ; COMMON-NEXT:                                        # -- End function

llvm/test/DebugInfo/XCOFF/empty.ll

 ; ASM32-NEXT:          .byte   0x09                            # Language = CPlusPlus
 ; ASM32-NEXT:          .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; ASM32-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
 ; ASM32-NEXT:                                          # -HasControlledStorage, -IsTOCless
 ; ASM32-NEXT:                                          # -IsFloatingPointPresent
 ; ASM32-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
 ; ASM32-NEXT:          .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; ASM32-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
-; ASM32-NEXT:          .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; ASM32-NEXT:          .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; ASM32-NEXT:          .byte   0x00                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; ASM32-NEXT:          .byte   0x00                            # NumberOfFixedParms = 0
 ; ASM32-NEXT:          .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; ASM32-NEXT:          .vbyte  4, L..main0-.main               # Function size
 ; ASM32-NEXT:          .vbyte  2, 0x0004                       # Function name len = 4
 ; ASM32-NEXT:          .byte   "main"                          # Function Name
 ; ASM32-NEXT:  L..func_end0:
 ; ASM32-NEXT:                                          # -- End function

 ; ASM64-NEXT:          .byte   0x09                            # Language = CPlusPlus
 ; ASM64-NEXT:          .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; ASM64-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
 ; ASM64-NEXT:                                          # -HasControlledStorage, -IsTOCless
 ; ASM64-NEXT:                                          # -IsFloatingPointPresent
 ; ASM64-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
 ; ASM64-NEXT:          .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; ASM64-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
-; ASM64-NEXT:          .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; ASM64-NEXT:          .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; ASM64-NEXT:          .byte   0x00                            # -HasExtensionTable, -HasVectorInfo, NumOfGPRsSaved = 0
 ; ASM64-NEXT:          .byte   0x00                            # NumberOfFixedParms = 0
 ; ASM64-NEXT:          .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
 ; ASM64-NEXT:          .vbyte  4, L..main0-.main               # Function size
 ; ASM64-NEXT:          .vbyte  2, 0x0004                       # Function name len = 4
 ; ASM64-NEXT:          .byte   "main"                          # Function Name
 ; ASM64-NEXT:  L..func_end0:
 ; ASM64-NEXT:                                          # -- End function

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

 ; CHECK-NEXT:          .byte   0x09                            # Language = CPlusPlus
 ; CHECK-NEXT:          .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; CHECK-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
 ; CHECK-NEXT:                                          # -HasControlledStorage, -IsTOCless
 ; CHECK-NEXT:                                          # -IsFloatingPointPresent
 ; CHECK-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
 ; CHECK-NEXT:          .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; CHECK-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
-; CHECK-NEXT:          .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; CHECK-NEXT:          .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; 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

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

 ; CHECK-NEXT:          .byte   0x09                            # Language = CPlusPlus
 ; CHECK-NEXT:          .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; CHECK-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
 ; CHECK-NEXT:                                          # -HasControlledStorage, -IsTOCless
 ; CHECK-NEXT:                                          # -IsFloatingPointPresent
 ; CHECK-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
 ; CHECK-NEXT:          .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; CHECK-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
-; CHECK-NEXT:          .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; CHECK-NEXT:          .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; 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:          .byte   0x09                            # Language = CPlusPlus
 ; CHECK-NEXT:          .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
 ; CHECK-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
 ; CHECK-NEXT:                                          # -HasControlledStorage, -IsTOCless
 ; CHECK-NEXT:                                          # -IsFloatingPointPresent
 ; CHECK-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
 ; CHECK-NEXT:          .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
 ; CHECK-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
-; CHECK-NEXT:          .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; CHECK-NEXT:          .byte   0x00                            # -IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
 ; 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[PR]             # Function size
 ; CHECK-NEXT:          .vbyte  2, 0x0003                       # Function name len = 3
 ; CHECK-NEXT:          .byte   "bar"                           # Function Name
 ; CHECK-NEXT:  L..func_end1:
 ; CHECK-NEXT:                                          # -- End function