[XCOFF][AIX] Emit EH information in traceback table

[DiggerLin]

Summary

In order for the runtime on AIX to find the compact unwind section(EHInfo table),
we would need to set the following on the traceback table:

1. The 6th byte's longtbtable field to true to signal there is an Extended TB Table Flag.
2. The Extended TB Table Flag to be 0x08 to signal there is an exception handling info presents.
3. Emit the offset between ehinfo TC entry and TOC base after all other optional portions of traceback table.

[majnemer]

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

119

Is this right? I'd expect '_', 'Z', '9',...

[jasonliu]

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

119

I think this is the accepted syntax for the assembler on AIX at least.
https://www.ibm.com/support/knowledgecenter/ssw_aix_72/assembler/assembler_pdf.pdf

ASCII character constants (for example, 'X) and string constants (for example, Hello, world) can also
be assembled using the .byte pseudo-op.

and example in the guide:

.csect data[rw]
.byte "Hello, world"
.byte 'H,'e,'l,'l,'o,',,' ,'w,'o,'r,'l,'d

[DiggerLin]

llvm/lib/BinaryFormat/XCOFF.cpp

131

there already have a function define getExtendedTBTableFlagString in the https://reviews.llvm.org/D92398

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1988

since we only have ShouldEmitEHBlock. if the ShouldEmitEHBlock is false, it will still output an ExtensionTableFlag. Add an assert(ShouldEmitEHBlock) here ?

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

2

we can delete -xcoff-traceback-table here after rebased on the latest https://reviews.llvm.org/D92398

[jasonliu]

llvm/lib/BinaryFormat/XCOFF.cpp

131

It's not in the Phabricator review that you point out. It's in D89049. But that revision is going to land after this one I think.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1988

I think it's more natural this way. As later we might add in more flags in ExtensionTableFlag (e.g. for stack protection canary). It won't be necessarily the only field for this ExtensionTableFlag anymore.

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

2

For sure.

[daltenty]

llvm/include/llvm/BinaryFormat/XCOFF.h

398

nit: since every other entry is missing a period, lets just omit it (and the s)

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

71

Compared with what was here before it seems like F.getPersonalityFn() can assert if hasPersonalityFn() is false, which can happen now because we won't check that before setting Per anymore, and we'll answer ShouldEmitEHBlock true if we have landing pads regardless of the personality setting.

[jasonliu]

llvm/include/llvm/BinaryFormat/XCOFF.h

398

I think we are suppose to have periods in every comments (at least it's the most used form in this file as well), so I will do a drive by fix to add periods in every entry.

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

71

Runtime need to use personality routine to parses LSDA area to get to those landingpads. So without personality routine, there is no reason for us to have landingpads.
So if we have landingpads, but no personality rountine presents in this function, something might already gone wrong somewhere else.
I could add an assert here and if we hit it in any case, we would need to examine the situation at that point.

[jasonliu]

Address comments.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

73

Constant *Function::getPersonalityFn() const {

assert(hasPersonalityFn() && getNumOperands());
return cast<Constant>(Op<0>());

}

do we need the
assert(F.hasPersonalityFn() &&

"Landingpads are presented, but no personality routine is found.");

once more ?

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

73

It helps to tell exactly what went wrong in this context. i.e. landingpad presents, but no personality routine gets us here.
But if you think it's really redundant, I could remove it.

[jasonliu]

ping.

[jasonliu]

Rebased on the latest parent.

[DiggerLin]

no further comment on it . It just need to rebased after

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

73

it is ok for me

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2077

it means there will be same symbol name in the different translation unit ?

[DiggerLin]

LGTM

[jasonliu]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

2077

Yes, and that's Okay because these symbols are internal(HIDE_EXT).

[DiggerLin]

for Jason is on vacation , I will take over the revision and rebase the patch based on the committed https://reviews.llvm.org/D92398

[DiggerLin]

rebased the patch based on the https://reviews.llvm.org/D92398.

[daltenty]

LGTM

llvm/include/llvm/BinaryFormat/XCOFF.h

struct TracebackTable {
   static constexpr uint32_t ParmTypeIsVectorCharBit = 0x0000'0000;
   static constexpr uint32_t ParmTypeIsVectorShortBit = 0x4000'0000;
   static constexpr uint32_t ParmTypeIsVectorIntBit = 0x8000'0000;
   static constexpr uint32_t ParmTypeIsVectorFloatBit = 0xC000'0000;
 };
 
 // Extended Traceback table flags.
 enum ExtendedTBTableFlag : uint8_t {
-  TB_OS1 = 0x80,         ///< Reserved for OS use
-  TB_RESERVED = 0x40,    ///< Reserved for compiler
-  TB_SSP_CANARY = 0x20,  ///< stack smasher canary present on stack
-  TB_OS2 = 0x10,         ///< Reserved for OS use
-  TB_LONGTBTABLE2 = 0x01 ///< Additional tbtable extension exists
+  TB_OS1 = 0x80,         ///< Reserved for OS use.
+  TB_RESERVED = 0x40,    ///< Reserved for compiler.
+  TB_SSP_CANARY = 0x20,  ///< stack smasher canary present on stack.
+  TB_OS2 = 0x10,         ///< Reserved for OS use.
+  TB_EH_INFO = 0x08,     ///< Exception handling info present.
+  TB_LONGTBTABLE2 = 0x01 ///< Additional tbtable extension exists.
 };
 
 StringRef getNameForTracebackTableLanguageId(TracebackTable::LanguageID LangId);
+SmallString<32> getExtendedTBTableFlagString(uint8_t Flag);
 
 } // end namespace XCOFF
 } // end namespace llvm
 
 #endif

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 
 class GlobalValue;
 class MachineModuleInfo;
+class MachineFunction;
 class MCContext;
 class MCExpr;
 class MCSection;
 class MCSymbol;
 class Module;
 class TargetMachine;
 
 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
                                        const TargetMachine &TM) const override;
 };
 
 class TargetLoweringObjectFileXCOFF : public TargetLoweringObjectFile {
 public:
   TargetLoweringObjectFileXCOFF() = default;
   ~TargetLoweringObjectFileXCOFF() override = default;
 
+  static bool ShouldEmitEHBlock(const MachineFunction *MF);
+
+  static MCSymbol *getEHInfoTableSymbol(const MachineFunction *MF);
+
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
   bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
                                            const Function &F) const override;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 

llvm/lib/BinaryFormat/XCOFF.cpp

if ((Value & TracebackTable::ParmTypeIsFloatingBit) == 0) {
 
       Value <<= 2;
     }
   }
   assert(Value == 0u && "ParmsType encodes more than ParmsNum parameters.");
   return ParmsType;
 }
 
+SmallString<32> XCOFF::getExtendedTBTableFlagString(uint8_t Flag) {
+  SmallString<32> Res;
+
+  if (Flag & ExtendedTBTableFlag::TB_OS1)
+    Res += "TB_OS1 ";
+  if (Flag & ExtendedTBTableFlag::TB_RESERVED)
+    Res += "TB_RESERVED ";
+  if (Flag & ExtendedTBTableFlag::TB_SSP_CANARY)
+    Res += "TB_SSP_CANARY ";
+  if (Flag & ExtendedTBTableFlag::TB_OS2)
+    Res += "TB_OS2 ";
+  if (Flag & ExtendedTBTableFlag::TB_EH_INFO)
+    Res += "TB_EH_INFO ";
+  if (Flag & ExtendedTBTableFlag::TB_LONGTBTABLE2)
+    Res += "TB_LONGTBTABLE2 ";
+
+  // Two of the bits that haven't got used in the mask.
+  if (Flag & 0x06)
+    Res += "Unknown ";
+
+  // Pop the last space.
+  Res.pop_back();
+  return Res;
+}
+
 #undef RELOC_CASE

llvm/lib/CodeGen/AsmPrinter/AIXException.cpp

 //===-- CodeGen/AsmPrinter/AIXException.cpp - AIX Exception Impl ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing AIX exception info into asm files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfException.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 
 AIXException::AIXException(AsmPrinter *A) : DwarfCFIExceptionBase(A) {}
 
 void AIXException::emitExceptionInfoTable(const MCSymbol *LSDA,
                                           const MCSymbol *PerSym) {
   // Generate EH Info Table.
   // The EH Info Table, aka, 'compat unwind section' on AIX, have the following
   // format: struct eh_info_t {
   //   unsigned version;           /* EH info verion 0 */
   // #if defined(__64BIT__)
   //   char _pad[4];               /* padding */
   // #endif
   //   unsigned long lsda;         /* Pointer to LSDA */
   //   unsigned long personality;  /* Pointer to the personality routine */
   //   }
 
   Asm->OutStreamer->SwitchSection(
       Asm->getObjFileLowering().getCompactUnwindSection());
-  MCSymbol *EHInfoLabel = MMI->getContext().getOrCreateSymbol(
-      "__ehinfo." + Twine(Asm->getFunctionNumber()));
+  MCSymbol *EHInfoLabel =
+      TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(Asm->MF);
   Asm->OutStreamer->emitLabel(EHInfoLabel);
 
   // Version number.
   Asm->emitInt32(0);
 
   const DataLayout &DL = MMI->getModule()->getDataLayout();
   const unsigned PointerSize = DL.getPointerSize();
 
   // Add necessary paddings in 64 bit mode.
   Asm->OutStreamer->emitValueToAlignment(PointerSize);
 
   // LSDA location.
   Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(LSDA, Asm->OutContext),
                               PointerSize);
 
   // Personality routine.
   Asm->OutStreamer->emitValue(MCSymbolRefExpr::create(PerSym, Asm->OutContext),
                               PointerSize);
 }
 
 void AIXException::endFunction(const MachineFunction *MF) {
-  const Function &F = MF->getFunction();
-  bool HasLandingPads = !MF->getLandingPads().empty();
-  const Function *Per = nullptr;
-  if (F.hasPersonalityFn())
-    Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
-  bool EmitEHBlock =
-      HasLandingPads || (F.hasPersonalityFn() &&
-                         !isNoOpWithoutInvoke(classifyEHPersonality(Per)) &&
-                         F.needsUnwindTableEntry());
-
-  if (!EmitEHBlock)
+  if (!TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(MF))
     return;
 
   const MCSymbol *LSDALabel = emitExceptionTable();
+
+  const Function &F = MF->getFunction();
+  assert(F.hasPersonalityFn() &&
+         "Landingpads are presented, but no personality routine is found.");
+  const Function *Per =
+      dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
   const MCSymbol *PerSym = Asm->TM.getSymbol(Per);
 
   emitExceptionInfoTable(LSDALabel, PerSym);
 }
 
 } // End of namespace llvm

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileWasm::getStaticDtorSection(
     unsigned Priority, const MCSymbol *KeySym) const {
   llvm_unreachable("@llvm.global_dtors should have been lowered already");
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 //                                  XCOFF
 //===----------------------------------------------------------------------===//
+bool TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(
+    const MachineFunction *MF) {
+  if (!MF->getLandingPads().empty())
+    return true;
+
+  const Function &F = MF->getFunction();
+  if (!F.hasPersonalityFn() || !F.needsUnwindTableEntry())
+    return false;
+
+  const Function *Per =
+      dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
+  if (isNoOpWithoutInvoke(classifyEHPersonality(Per)))
+    return false;
+
+  return true;
+}
+
+MCSymbol *
+TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(const MachineFunction *MF) {
+  return MF->getMMI().getContext().getOrCreateSymbol(
+      "__ehinfo." + Twine(MF->getFunctionNumber()));
+}
+
 MCSymbol *
 TargetLoweringObjectFileXCOFF::getTargetSymbol(const GlobalValue *GV,
                                                const TargetMachine &TM) const {
   // We always use a qualname symbol for a GV that represents
   // a declaration, a function descriptor, or a common symbol.
   // If a GV represents a GlobalVariable and -fdata-sections is enabled, we
   // also return a qualname so that a label symbol could be avoided.
   // It is inherently ambiguous when the GO represents the address of a

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

#define GENVALUECOMMENT(PrefixAndName, V, Field)                               \
   GENBOOLCOMMENT("", SecondHalfOfMandatoryField, IsBackChainStored);
   GENBOOLCOMMENT(", ", SecondHalfOfMandatoryField, IsFixup);
   GENVALUECOMMENT(", NumOfFPRsSaved", SecondHalfOfMandatoryField, FPRSaved);
   EmitComment();
   OutStreamer->emitIntValueInHexWithPadding(
       (SecondHalfOfMandatoryField & 0xff000000) >> 24, 1);
 
   // Set the 6th byte of mandatory field.
+  bool ShouldEmitEHBlock = TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(MF);
+  if (ShouldEmitEHBlock)
+    SecondHalfOfMandatoryField |= TracebackTable::HasExtensionTableMask;
+
   uint32_t GPRSaved = 0;
 
   // X13 is reserved under 64-bit environment.
   unsigned GPRBegin = Subtarget->isPPC64() ? PPC::X14 : PPC::R13;
   unsigned GPREnd = Subtarget->isPPC64() ? PPC::X31 : PPC::R31;
 
   for (unsigned Reg = GPRBegin; Reg <= GPREnd; ++Reg) {
     if (MRI.isPhysRegModified(Reg)) {
if (FirstHalfOfMandatoryField & TracebackTable::IsFunctionNamePresentMask) {
     OutStreamer->emitBytes(Name);
   }
 
   if (FirstHalfOfMandatoryField & TracebackTable::IsAllocaUsedMask) {
     uint8_t AllocReg = XCOFF::AllocRegNo;
     OutStreamer->AddComment("AllocaUsed");
     OutStreamer->emitIntValueInHex(AllocReg, sizeof(AllocReg));
   }
+
+  uint8_t ExtensionTableFlag = 0;
+  if (SecondHalfOfMandatoryField & TracebackTable::HasExtensionTableMask) {
+    if (ShouldEmitEHBlock)
+      ExtensionTableFlag |= ExtendedTBTableFlag::TB_EH_INFO;
+
+    CommentOS << "ExtensionTableFlag = "
+              << getExtendedTBTableFlagString(ExtensionTableFlag);
+    EmitCommentAndValue(ExtensionTableFlag, sizeof(ExtensionTableFlag));
+  }
+
+  if (ExtensionTableFlag & ExtendedTBTableFlag::TB_EH_INFO) {
+    auto &Ctx = OutStreamer->getContext();
+    MCSymbol *EHInfoSym =
+        TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(MF);
+    MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(EHInfoSym);
+    const MCSymbol *TOCBaseSym =
+        cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
+            ->getQualNameSymbol();
+    const MCExpr *Exp =
+        MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCEntry, Ctx),
+                                MCSymbolRefExpr::create(TOCBaseSym, Ctx), Ctx);
+
+    const DataLayout &DL = getDataLayout();
+    OutStreamer->emitValueToAlignment(4);
+    OutStreamer->AddComment("EHInfo Table");
+    OutStreamer->emitValue(Exp, DL.getPointerSize());
+  }
+
 #undef GENBOOLCOMMENT
 #undef GENVALUECOMMENT
 }
 
 void PPCAIXAsmPrinter::ValidateGV(const GlobalVariable *GV) {
   // Early error checking limiting what is supported.
   if (GV->isThreadLocal())
     report_fatal_error("Thread local not yet supported on AIX.");

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

 ; RUN: llc -verify-machineinstrs -mtriple powerpc-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec < %s | \
 ; RUN:   FileCheck --check-prefixes=ASM,ASM32 %s
 
 ; RUN: llc -verify-machineinstrs -mtriple powerpc64-ibm-aix-xcoff -mcpu=pwr4 \
 ; RUN:     -mattr=-altivec < %s | \
 ; RUN:   FileCheck --check-prefixes=ASM,ASM64 %s
 
 @_ZTIi = external constant i8*
 

 ; ASM:    blr
 ; ASM:  L..BB1_3:                               # %lpad
 ; ASM:  L..tmp2:
 ; ASM:    bl .__cxa_begin_catch[PR]
 ; ASM:    nop
 ; ASM:    bl .__cxa_end_catch[PR]
 ; ASM:    nop
 ; ASM:    b L..BB1_2
+
+; ASM:  L.._Z9catchFuncv0:
+; ASM:    .vbyte  4, 0x00000000                   # Traceback table begin
+; ASM:    .byte   0x00                            # Version = 0
+; ASM:    .byte   0x09                            # Language = CPlusPlus
+; ASM:    .byte   0x22                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
+; ASM:                                    # +HasTraceBackTableOffset, -IsInternalProcedure
+; ASM:                                    # -HasControlledStorage, -IsTOCless
+; ASM:                                    # +IsFloatingPointPresent
+; ASM:                                    # -IsFloatingPointOperationLogOrAbortEnabled
+; ASM:    .byte   0x41                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
+; ASM:                                    # OnConditionDirective = 0, -IsCRSaved, +IsLRSaved
+; ASM:    .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; ASM:    .byte   0x40                            # -HasVectorInfo, +HasExtensionTable, NumOfGPRsSaved = 0
+; ASM:    .byte   0x00                            # NumberOfFixedParms = 0
+; ASM:    .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
+; ASM:    .vbyte  4, L.._Z9catchFuncv0-._Z9catchFuncv # Function size
+; ASM:    .vbyte  2, 0x000d                       # Function name len = 13
+; ASM:    .byte   '_,'Z,'9,'c,'a,'t,'c,'h,'F,'u,'n,'c,'v # Function Name
+; ASM:    .byte   0x08                            # ExtensionTableFlag = TB_EH_INFO
+; ASM:    .align  2
+; ASM32:  .vbyte  4, L..C1-TOC[TC0]               # EHInfo Table
+; ASM64:  .vbyte  8, L..C1-TOC[TC0]               # EHInfo Table
 ; ASM:  L..func_end0:
 
 ; ASM:    .csect .gcc_except_table[RO],2
 ; ASM:    .align  2
 ; ASM:  GCC_except_table1:
 ; ASM:  L..exception0:
 ; ASM:    .byte 255                             # @LPStart Encoding = omit
 ; ASM32:  .byte 187                             # @TType Encoding = indirect datarel sdata4

 ; ASM:                                          #   Catch TypeInfo 1
 ; ASM:    .byte 0                               #   No further actions
 ; ASM:    .align  2
 ; ASM:                                          # >> Catch TypeInfos <<
 ; ASM32:  .vbyte  4, L..C0-TOC[TC0]               # TypeInfo 1
 ; ASM64:  .vbyte  8, L..C0-TOC[TC0]               # TypeInfo 1
 ; ASM:  L..ttbase0:
 ; ASM:    .align  2
+
 ; ASM:    .csect .eh_info_table[RW],2
 ; ASM:  __ehinfo.1:
 ; ASM:    .vbyte  4, 0
 ; ASM32:  .align  2
 ; ASM32:  .vbyte  4, GCC_except_table1
 ; ASM32:  .vbyte  4, __xlcxx_personality_v1[DS]
 ; ASM64:  .align  3
 ; ASM64:  .vbyte  8, GCC_except_table1
 ; ASM64:  .vbyte  8, __xlcxx_personality_v1[DS]
 
 ; ASM:    .toc
 ; ASM:  L..C0:
 ; ASM:    .tc _ZTIi[TC],_ZTIi[UA]
+; ASM:  L..C1:
+; ASM:    .tc __ehinfo.1[TC],__ehinfo.1
 
 declare i8* @__cxa_allocate_exception(i32)
 declare void @__cxa_throw(i8*, i8*, i8*)
 declare i32 @__xlcxx_personality_v1(...)
 declare i32 @llvm.eh.typeid.for(i8*)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()