[AIX][XCOFF][Bug-Fixed] parse the parameter type of the traceback table.

[DiggerLin]

Summary

1. in the function PPCFunctionInfo::getParmsType(), there is if (Bits > 31 || (Bits > 30 && (Elt != FixedType || hasVectorParms())))
   
   when the Bit is 31 and the Elt is not FixedType(for example the Elt is FloatingType) , the 31th bit will be not encoded, it leave the bit as zero, when the function Expected<SmallString<32>> XCOFF::parseParmsType() the original implement

**// unsigned ParmsNum = FixedParmsNum + FloatingParmsNum;

while (Bits < 32 && ParsedNum < ParmsNum) {
...
}//**
it will look the 31 bits (zero) as FixedType. which should be FloatingType,  and get a error.

[jasonliu]

llvm/lib/BinaryFormat/XCOFF.cpp

147

IIUC, this is not a NFC, and we are changing the behavior in a user visible way. So we need to add a test case for this change.

[jasonliu]

llvm/lib/BinaryFormat/XCOFF.cpp

155

Relay offline discussion:
The underlying issue with the current approach is that FixedParmsNum and FloatingParmsNum passed in are the real parameters number of those types that we get, but the number of them could be more than what Value could encode.
I don't think the current solution in this patch addressed that underlying issue.

[DiggerLin]

added a corner test case.

[DiggerLin]

nit, update the comment

[ZarkoCA]

llvm/lib/BinaryFormat/XCOFF.cpp

120–129

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

136

252

[DiggerLin]

rebase the patch and address comment

[ZarkoCA]

LGTM, thanks.

llvm/lib/BinaryFormat/XCOFF.cpp

Expected<SmallString<32>> XCOFF::parseParmsType(uint32_t Value,
                                                 unsigned FloatingParmsNum) {
   SmallString<32> ParmsType;
   int Bits = 0;
   unsigned ParsedFixedNum = 0;
   unsigned ParsedFloatingNum = 0;
   unsigned ParsedNum = 0;
   unsigned ParmsNum = FixedParmsNum + FloatingParmsNum;
 
-  while (Bits < 32 && ParsedNum < ParmsNum) {
+  // In the function PPCFunctionInfo::getParmsType(), when there are no vector
+  // parameters, the 31st bit of ParmsType is always zero even if it indicates a
+  // floating point parameter. The parameter type information is lost. There
+  // are only 8 GPRs used for parameters passing, the floating parameters
+  // also occupy GPRs if there are available, so the 31st bit can never be a
+  // fixed parameter. At the same time, we also do not know whether the zero of
+  // the 31st bit indicates a float or double parameter type here. Therefore, we
+  // ignore the 31st bit.
+  while (Bits < 31 && ParsedNum < ParmsNum) {
     if (++ParsedNum > 1)
       ParmsType += ", ";
     if ((Value & TracebackTable::ParmTypeIsFloatingBit) == 0) {
       // Fixed parameter type.
       ParmsType += "i";
       ++ParsedFixedNum;
       Value <<= 1;
       ++Bits;
     } else {
while (Bits < 31 && ParsedNum < ParmsNum) {
     }
   }
 
   // We have more parameters than the 32 Bits could encode.
   if (ParsedNum < ParmsNum)
     ParmsType += ", ...";
 
   if (Value != 0u || ParsedFixedNum > FixedParmsNum ||
       ParsedFloatingNum > FloatingParmsNum)
     return createStringError(errc::invalid_argument,
                              "ParmsType encodes can not map to ParmsNum "
                              "parameters in parseParmsType.");
   return ParmsType;
 }
 
 SmallString<32> XCOFF::getExtendedTBTableFlagString(uint8_t Flag) {
   SmallString<32> Res;

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

entry:
   %conv7 = fpext float %9 to double
   %add8 = fadd double %add6, %conv7
   %10 = load i32, i32* %v2.addr, align 4
   %conv9 = sitofp i32 %10 to double
   %add10 = fadd double %add8, %conv9
   ret double %add10
 }
 
+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:
 ; 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:  .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:
+; 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
+; 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   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