[AIX][XCOFF][Patch2] decode vector information and extent long table of the traceback table of the xcoff.

[DiggerLin]

Summary

1. decode the Vector extension if has_vec is set
2. decode long table fields, if longtbtable is set.

There is conflict on the bit order of HasVectorInfoMask and HasExtensionTableMask between AIX os header and IBM aix compiler XLC.
In the /usr/include/sys/debug.h defines
static constexpr uint32_t HasVectorInfoMask = 0x0040'0000;
static constexpr uint32_t HasExtensionTableMask = 0x0080'0000;
but the XLC defines as

static constexpr uint32_t HasVectorInfoMask = 0x0080'0000;
static constexpr uint32_t HasExtensionTableMask = 0x0040'0000;
we follows the definition of the IBM AIX compiler XLC here.

for the convenient to review , I copy some related code from the /usr/include/sys/debug.h of aix os
‘’‘
/*

• Vector extension portion of the optional table (if has_vec is set). */

struct vec_ext {

unsigned vr_saved:6;    /* Number of non-volatile vector regs saved */
                        /* first register saved is assumed to be */
                        /* 32 - vr_saved                         */
unsigned saves_vrsave:1;/* Set if vrsave is saved on the stack */
unsigned has_varargs:1;
unsigned vectorparms:7; /* number of vector parameters */
unsigned vec_present:1; /* Set if routine performs vmx instructions */
unsigned char vecparminfo[4];/* bitmask array for each vector parm in */
                         /* order as found in the original parminfo, */
                         /* describes the type of vector:            */
                         /*       b'00 = vector char                 */
                         /*       b'01 = vector short                */
                         /*       b'10 = vector int                  */
                         /*       b'11 = vector float                */

};

/*

• Optional portions of procedure-end table. *
• Optional portions exist in the following order independently, not as
• a structure or an union. Whether or not portions exist is determinable
• from bit-fields within the base procedure-end table. *
• parminfo exists if fixedparms or floatparms != 0.
• tb_offset exists if has_tboff bit is set.
• hand_mask exists if int_hndl bit is set.
• ctl_info exists if has_ctl bit is set.
• ctl_info_disp exists if ctl_info exists.
• name_len exists if name_present bit is set.
• name exists if name_len exists.
• alloca_reg exists if uses_alloca bit is set.
• vec_ext exists if has_vec bit is set. */

struct tbtable_ext {

unsigned int parminfo;  /* Order and type encoding of parameters:
                         * Left-justified bit-encoding as follows:
                         * '0'  ==> fixed parameter
                         * '10' ==> single-precision float parameter
                         * '11' ==> double-precision float parameter
                         *
                         * if has_vec is set, encoded as follows:
                         * '00' ==> fixed parameter
                         * '01' ==> vector parameter
                         * '10' ==> single-precision float parameter
                         * '11' ==> double-precision float parameter
                         */
unsigned int tb_offset; /* Offset from start of code to tb table */
int hand_mask;          /* What interrupts are handled by */
int ctl_info;           /* Number of CTL anchors, followed by */
int ctl_info_disp[1];   /* Actually ctl_info_disp[ctl_info] */
                        /* Displacements into stack of each anchor */
short name_len;         /* Length of procedure name */
char name[1];           /* Actually char[name_len] (no NULL) */
char alloca_reg;        /* Register for alloca automatic storage */
struct vec_ext vec_ext; /* Vector extension (if has_vec is set) */
unsigned char xtbtable; /* More tbtable fields, if longtbtable is set*/

};’‘’

[jasonliu]

llvm/include/llvm/BinaryFormat/XCOFF.h

350–381

I think with the two newly added fields, these two fields are not necessary. We just need to tweak parseParmsType a little bit so that it could uses the ParmTypeIsFloatingBits and ParmTypeIsDoubleBits below instead?

llvm/include/llvm/Object/XCOFFObjectFile.h

403

If this constructor is only intended to get called by XCOFFTracebackTable, could we make the constructor private and mark XCOFFTracebackTable as a friend in this class?

409

Remove this declaration if it's not used.

428

The naming of XTBTable is not very self-explanatory here.
And I'm not sure if this field is actually useful, as this is really like a placeholder field. We don't really know what it is or what it does.
It's guaranteed later we will find out what it actually does, then we would need to update it to something else. So should we just skip this field?

llvm/lib/Object/XCOFFObjectFile.cpp

851

nit: it might be better just spell it out as getNumberOfVRSaved so that it matches the field name below.

862

nit: getNumberOfVectorParms

876

It would be better if I's type matches the return types of getNumOfVectorParms(), which is uint8_t.

902

If we are going to separate it into two functions, why don't we also passing in the number of vector parameters as parameter here? So that the while loop could just check if the total number of parameter is reached instead of using || Value. And you don't need the bool Begin as well.

915

nit: ++I would be better here?

917

nit: I don't see a blank line very often after a break in the switch.

930

Let's have a default statement and assert here, so that we don't get surprised.

1036

I feel how we get the vector extension portion of the optional table is a bit wierd.
This extension part is an all or nothing, but we takes two steps to get the data out of it.

Could we do something like
VecExt = TBVectorExt(DE.getBytes(Cur, TBVectorExtLength));

Then do some extra conversion inside of the constructor?

llvm/unittests/Object/XCOFFObjectFileTest.cpp

234–236

I noticed we always test the same result from these three fields, is it possible to edit the traceback table a little bit to get it to return a different result?

[DiggerLin]

llvm/include/llvm/BinaryFormat/XCOFF.h

350–381

I will change the Macro as
static constexpr uint32_t ParmTypeIsFloatingBit = 0x8000'0000;
-->
static constexpr uint32_t ParmTypeIsFixedBit = 0x8000'0000;

and

If I change function parseParmsType as

static SmallString<32> parseParmsType(uint32_t Value, unsigned ParmsNum) {

SmallString<32> ParmsType;
for (unsigned I = 0; I < ParmsNum; ++I) {
  if (I != 0)
    ParmsType += ", ";
  if ((Value & TracebackTable::ParmTypeIsFixedBit) == 0) {
    // Fixed parameter type.
    ParmsType += "i";
    Value <<= 1;
  } else {
    switch (Value & TracebackTable::**ParmTypeMask**) {
       case TracebackTable::ParmTypeIsFloatingBits:
           ParmsType += "f";
       case  TracebackTable::ParmTypeIsDoubleBits
            ParmsType += "d";
    Value <<= 2;
  }
}
return ParmsType;

}

I do not think using Macro ParmTypeMask is a good idea hear. for the parameter type without vector info , the ParmType is not always 2bits.

llvm/include/llvm/Object/XCOFFObjectFile.h

403

OK, thanks

409

thanks

428

I unsigned char xtbtable; /* More tbtable fields, if longtbtable is set*/

I changed the name to ExtLongTBTable.

llvm/lib/Object/XCOFFObjectFile.cpp

902

the Vector parameter is not included in the ParmsNum. I think we do not know the number of vector parameter untill we parse the VecExt = TBVectorExt(VRData, VecParmsInfo);

1036

for the definition of

struct vec_ext {

unsigned vr_saved:6;    /* Number of non-volatile vector regs saved */
                        /* first register saved is assumed to be */
                        /* 32 - vr_saved                         */
unsigned saves_vrsave:1;/* Set if vrsave is saved on the stack */
unsigned has_varargs:1;
unsigned vectorparms:7; /* number of vector parameters */
unsigned vec_present:1; /* Set if routine performs vmx instructions */
unsigned char vecparminfo[4];/* bitmask array for each vector parm in */
                         /* order as found in the original parminfo, */
                         /* describes the type of vector:            */
                         /*       b'00 = vector char                 */
                         /*       b'01 = vector short                */
                         /*       b'10 = vector int                  */
                         /*       b'11 = vector float                */

};

for the first 5 element of the structure vec_ext are bit fields of 2 bytes data.
the vecparminfo is 4 bytes. If I do as as your suggest , I still split the 6 bytes data into uint16_t and uint32_t when parsing the data in the TBVectorExt.

[DiggerLin]

address comment

[jasonliu]

llvm/include/llvm/BinaryFormat/XCOFF.h

350

Suggest to add a comment to separate the two groups of masks.

352

llvm/include/llvm/Object/XCOFFObjectFile.h

412

nit: move friend declaration to the line just below class TBVectorExt {

llvm/lib/Object/XCOFFObjectFile.cpp

851

929–930

1036

Instead of splitting it here, it would make more sense to do that inside of TBVectorExt().

1041

Since we already have the query hasExtensionTable(), it would make sense to call this field ExtensionTableFlags, and its getter getExtensionTableFlags.

llvm/unittests/Object/XCOFFObjectFileTest.cpp

211

If we have an extension table, it doesn't make sense that we do not set any flags in it. Maybe we could put a canary flag into the data and check it here:

#define TB_SSP_CANARY 0x20  /* stack smasher canary present on stack */

244

Same above for setting ExtensionTable, but not having any value in it.

[DiggerLin]

llvm/lib/Object/XCOFFObjectFile.cpp

1041

we already has
if (Cur && hasTraceBackTableOffset())

TraceBackTableOffset = DE.getU32(Cur);

if (Cur && hasExtensionTable())

ExtensionTable = DE.getU8(Cur);

[DiggerLin]

address comment

[jasonliu]

llvm/include/llvm/Object/XCOFFObjectFile.h

404

It doesn't really make sense to pass it as const &.
Please see https://llvm.org/docs/ProgrammersManual.html#the-stringref-class for the last sentence.

llvm/lib/Object/XCOFFObjectFile.cpp

929–930

This comment is not addressed yet.

[jasonliu]

llvm/unittests/Object/XCOFFObjectFileTest.cpp

192

This is a mask that's likely to get reused somewhere else when we try to decoding and encoding the traceback table content. Could we put that set of masks in the XCOFF.h header?

[DiggerLin]

address comment

[jasonliu]

Thanks. LGTM.
Could you create a new revision that contains the context for future reference?

[DiggerLin]

upload a revision with context.

llvm/include/llvm/BinaryFormat/XCOFF.h

struct TracebackTable {
 
   // Byte 5
   static constexpr uint32_t IsBackChainStoredMask = 0x8000'0000;
   static constexpr uint32_t IsFixupMask = 0x4000'0000;
   static constexpr uint32_t FPRSavedMask = 0x3F00'0000;
   static constexpr uint32_t FPRSavedShift = 24;
 
   // Byte 6
-  static constexpr uint32_t HasExtensionTableMask = 0x0080'0000;
-  static constexpr uint32_t HasVectorInfoMask = 0x0040'0000;
+  static constexpr uint32_t HasVectorInfoMask = 0x0080'0000;
+  static constexpr uint32_t HasExtensionTableMask = 0x0040'0000;
   static constexpr uint32_t GPRSavedMask = 0x003F'0000;
   static constexpr uint32_t GPRSavedShift = 16;
 
   // Byte 7
   static constexpr uint32_t NumberOfFixedParmsMask = 0x0000'FF00;
   static constexpr uint8_t NumberOfFixedParmsShift = 8;
 
   // Byte 8
   static constexpr uint32_t NumberOfFloatingPointParmsMask = 0x0000'00FE;
   static constexpr uint32_t HasParmsOnStackMask = 0x0000'0001;
   static constexpr uint8_t NumberOfFloatingPointParmsShift = 1;
 
   // Masks to select leftmost bits for decoding parameter type information.
+  // Bit to use when vector info is not presented.
   static constexpr uint32_t ParmTypeIsFloatingBit = 0x8000'0000;
   static constexpr uint32_t ParmTypeFloatingIsDoubleBit = 0x4000'0000;
+  // Bits to use when vector info is presented.
+  static constexpr uint32_t ParmTypeIsFixedBits = 0x0000'0000;
+  static constexpr uint32_t ParmTypeIsVectorBits = 0x4000'0000;
+  static constexpr uint32_t ParmTypeIsFloatingBits = 0x8000'0000;
+  static constexpr uint32_t ParmTypeIsDoubleBits = 0xC000'0000;
+  static constexpr uint32_t ParmTypeMask = 0xC000'0000;
+
+  // Vector extension
+  static constexpr uint16_t NumberOfVRSavedMask = 0xFC00;
+  static constexpr uint16_t IsVRSavedOnStackMask = 0x0200;
+  static constexpr uint16_t HasVarArgsMask = 0x0100;
+  static constexpr uint8_t NumberOfVRSavedShift = 10;
+
+  static constexpr uint16_t NumberOfVectorParmsMask = 0x00FE;
+  static constexpr uint16_t HasVMXInstructionMask = 0x0001;
+  static constexpr uint8_t NumberOfVectorParmsShift = 1;
+
+  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
 };
 
 } // end namespace XCOFF
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Object/XCOFFObjectFile.h

public:
   const XCOFFCsectAuxEnt32 *getXCOFFCsectAuxEnt32() const;
   uint16_t getType() const;
   int16_t getSectionNumber() const;
 
   bool hasCsectAuxEnt() const;
   bool isFunction() const;
 };
 
+class TBVectorExt {
+  friend class XCOFFTracebackTable;
+
+  uint16_t Data;
+  uint32_t VecParmsInfo;
+
+  TBVectorExt(StringRef TBvectorStrRef);
+
+public:
+  uint8_t geNumberOfVRSaved() const;
+  bool isVRSavedOnStack() const;
+  bool hasVarArgs() const;
+  uint8_t getNumberOfVectorParms() const;
+  bool hasVMXInstruction() const;
+  SmallString<32> getVectorParmsInfoString() const;
+};
+
 /// This class provides methods to extract traceback table data from a buffer.
 /// The various accessors may reference the buffer provided via the constructor.
 
 class XCOFFTracebackTable {
   const uint8_t *const TBPtr;
   Optional<SmallString<32>> ParmsType;
   Optional<uint32_t> TraceBackTableOffset;
   Optional<uint32_t> HandlerMask;
   Optional<uint32_t> NumOfCtlAnchors;
   Optional<SmallVector<uint32_t, 8>> ControlledStorageInfoDisp;
   Optional<StringRef> FunctionName;
   Optional<uint8_t> AllocaRegister;
+  Optional<TBVectorExt> VecExt;
+  Optional<uint8_t> ExtensionTable;
 
   XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size, Error &Err);
-
 public:
   /// Parse an XCOFF Traceback Table from \a Ptr with \a Size bytes.
   /// Returns an XCOFFTracebackTable upon successful parsing, otherwise an
   /// Error is returned.
   ///
   /// \param[in] Ptr
   ///   A pointer that points just past the initial 4 bytes of zeros at the
   ///   beginning of an XCOFF Traceback Table.
public:
   }
   const Optional<uint32_t> &getHandlerMask() const { return HandlerMask; }
   const Optional<uint32_t> &getNumOfCtlAnchors() { return NumOfCtlAnchors; }
   const Optional<SmallVector<uint32_t, 8>> &getControlledStorageInfoDisp() {
     return ControlledStorageInfoDisp;
   }
   const Optional<StringRef> &getFunctionName() const { return FunctionName; }
   const Optional<uint8_t> &getAllocaRegister() const { return AllocaRegister; }
+  const Optional<TBVectorExt> &getVectorExt() const { return VecExt; }
+  const Optional<uint8_t> &getExtensionTable() const { return ExtensionTable; }
 };
 
 bool doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes);
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H

llvm/lib/Object/XCOFFObjectFile.cpp

 
 bool doesXCOFFTracebackTableBegin(ArrayRef<uint8_t> Bytes) {
   if (Bytes.size() < 4)
     return false;
 
   return support::endian::read32be(Bytes.data()) == 0;
 }
 
+TBVectorExt::TBVectorExt(StringRef TBvectorStrRef) {
+  const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(TBvectorStrRef.data());
+  Data = support::endian::read16be(Ptr);
+  VecParmsInfo = support::endian::read32be(Ptr + 2);
+}
+
+#define GETVALUEWITHMASK(X) (Data & (TracebackTable::X))
+#define GETVALUEWITHMASKSHIFT(X, S)                                            \
+  ((Data & (TracebackTable::X)) >> (TracebackTable::S))
+uint8_t TBVectorExt::geNumberOfVRSaved() const {
+  return GETVALUEWITHMASKSHIFT(NumberOfVRSavedMask, NumberOfVRSavedShift);
+}
+
+bool TBVectorExt::isVRSavedOnStack() const {
+  return GETVALUEWITHMASK(IsVRSavedOnStackMask);
+}
+
+bool TBVectorExt::hasVarArgs() const {
+  return GETVALUEWITHMASK(HasVarArgsMask);
+}
+uint8_t TBVectorExt::getNumberOfVectorParms() const {
+  return GETVALUEWITHMASKSHIFT(NumberOfVectorParmsMask,
+                               NumberOfVectorParmsShift);
+}
+
+bool TBVectorExt::hasVMXInstruction() const {
+  return GETVALUEWITHMASK(HasVMXInstructionMask);
+}
+#undef GETVALUEWITHMASK
+#undef GETVALUEWITHMASKSHIFT
+
+SmallString<32> TBVectorExt::getVectorParmsInfoString() const {
+  SmallString<32> ParmsType;
+  uint32_t Value = VecParmsInfo;
+  for (uint8_t I = 0; I < getNumberOfVectorParms(); ++I) {
+    if (I != 0)
+      ParmsType += ", ";
+    switch (Value & TracebackTable::ParmTypeMask) {
+    case TracebackTable::ParmTypeIsVectorCharBit:
+      ParmsType += "vc";
+      break;
+
+    case TracebackTable::ParmTypeIsVectorShortBit:
+      ParmsType += "vs";
+      break;
+
+    case TracebackTable::ParmTypeIsVectorIntBit:
+      ParmsType += "vi";
+      break;
+
+    case TracebackTable::ParmTypeIsVectorFloatBit:
+      ParmsType += "vf";
+      break;
+    }
+    Value <<= 2;
+  }
+  return ParmsType;
+}
+
+static SmallString<32> parseParmsTypeWithVecInfo(uint32_t Value,
+                                                 unsigned int ParmsNum) {
+  SmallString<32> ParmsType;
+  unsigned I = 0;
+  bool Begin = false;
+  while (I < ParmsNum || Value) {
+    if (Begin)
+      ParmsType += ", ";
+    else
+      Begin = true;
+
+    switch (Value & TracebackTable::ParmTypeMask) {
+    case TracebackTable::ParmTypeIsFixedBits:
+      ParmsType += "i";
+      ++I;
+      break;
+    case TracebackTable::ParmTypeIsVectorBits:
+      ParmsType += "v";
+      break;
+    case TracebackTable::ParmTypeIsFloatingBits:
+      ParmsType += "f";
+      ++I;
+      break;
+    case TracebackTable::ParmTypeIsDoubleBits:
+      ParmsType += "d";
+      ++I;
+      break;
+    default:
+      assert(false && "Unrecognized bits in ParmsType.");
+    }
+    Value <<= 2;
+  }
+  assert(I == ParmsNum &&
+         "The total parameters number of fixed-point or floating-point "
+         "parameters not equal to the number in the parameter type!");
+  return ParmsType;
+}
+
 static SmallString<32> parseParmsType(uint32_t Value, unsigned ParmsNum) {
   SmallString<32> ParmsType;
   for (unsigned I = 0; I < ParmsNum; ++I) {
     if (I != 0)
       ParmsType += ", ";
     if ((Value & TracebackTable::ParmTypeIsFloatingBit) == 0) {
       // Fixed parameter type.
       ParmsType += "i";
XCOFFTracebackTable::XCOFFTracebackTable(const uint8_t *Ptr, uint64_t &Size,
   if (Cur) {
     unsigned ParmNum = getNumberOfFixedParms() + getNumberOfFPParms();
 
     // As long as there are no "fixed-point" or floating-point parameters, this
     // field remains not present even when hasVectorInfo gives true and
     // indicates the presence of vector parameters.
     if (ParmNum > 0) {
       uint32_t ParamsTypeValue = DE.getU32(Cur);
-      // TODO: when hasVectorInfo() is true, we need to implement a new version
-      // of parsing parameter type for vector info.
-      if (Cur && !hasVectorInfo())
-        ParmsType = parseParmsType(ParamsTypeValue, ParmNum);
+      if (Cur)
+        ParmsType = hasVectorInfo()
+                        ? parseParmsTypeWithVecInfo(ParamsTypeValue, ParmNum)
+                        : parseParmsType(ParamsTypeValue, ParmNum);
     }
   }
 
   if (Cur && hasTraceBackTableOffset())
     TraceBackTableOffset = DE.getU32(Cur);
 
   if (Cur && isInterruptHandler())
     HandlerMask = DE.getU32(Cur);
if (Cur && isFuncNamePresent()) {
     uint16_t FunctionNameLen = DE.getU16(Cur);
     if (Cur)
       FunctionName = DE.getBytes(Cur, FunctionNameLen);
   }
 
   if (Cur && isAllocaUsed())
     AllocaRegister = DE.getU8(Cur);
 
-  // TODO: Need to parse vector info and extension table if there is one.
+  if (Cur && hasVectorInfo()) {
+    StringRef VectorExtRef = DE.getBytes(Cur, 6);
+    if (Cur)
+      VecExt = TBVectorExt(VectorExtRef);
+  }
+
+  if (Cur && hasExtensionTable())
+    ExtensionTable = DE.getU8(Cur);
 
   if (!Cur)
     Err = Cur.takeError();
   Size = Cur.tell();
 }
 
 #define GETBITWITHMASK(P, X)                                                   \
   (support::endian::read32be(TBPtr + (P)) & (TracebackTable::X))
 #define GETBITWITHMASKSHIFT(P, X, S)                                           \
   ((support::endian::read32be(TBPtr + (P)) & (TracebackTable::X)) >>           \
    (TracebackTable::S))

llvm/unittests/Object/XCOFFObjectFileTest.cpp

 //===- XCOFFObjectFileTest.cpp - Tests for XCOFFObjectFile ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace llvm::object;
+using namespace llvm::XCOFF;
 
 TEST(XCOFFObjectFileTest, XCOFFObjectType) {
   // Create an arbitrary object of a non-XCOFF type and test that
   // dyn_cast<XCOFFObjectFile> returns null for it.
   char Buf[sizeof(typename ELF64LE::Ehdr)] = {};
   memcpy(Buf, "\177ELF", 4);
 
   auto *EHdr = reinterpret_cast<typename ELF64LE::Ehdr *>(Buf);
TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIParmsType) {
   Size = sizeof(V);
   Expected<XCOFFTracebackTable> TTOrErr3 = XCOFFTracebackTable::create(V, Size);
   ASSERT_THAT_EXPECTED(TTOrErr3, Succeeded());
   XCOFFTracebackTable TT3 = *TTOrErr3;
   ASSERT_TRUE(TT3.getParmsType());
   EXPECT_EQ(TT3.getParmsType().getValue(), "d, i, f, f");
 }
 
-const uint8_t TBTableData[] = {0x00, 0x00, 0x2A, 0x40, 0x80, 0x40, 0x01, 0x05,
-                               0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
-                               0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00,
-                               0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64,
-                               0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x00, 0x00, 0x00};
+const uint8_t TBTableData[] = {
+    0x00, 0x00, 0x2A, 0x60, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc4, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00,
+    0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c,
+    0x6c, 0x1f, 0x02, 0x05, 0xf0, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00};
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIControlledStorageInfoDisp) {
-  uint64_t Size = 40;
+  uint64_t Size = sizeof(TBTableData);
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
   XCOFFTracebackTable TT = *TTOrErr;
   EXPECT_TRUE(TT.hasControlledStorage());
   ASSERT_TRUE(TT.getNumOfCtlAnchors());
   EXPECT_EQ(TT.getNumOfCtlAnchors().getValue(), 2u);
 
   ASSERT_TRUE(TT.getControlledStorageInfoDisp());
 
   SmallVector<uint32_t, 8> Disp = TT.getControlledStorageInfoDisp().getValue();
 
   ASSERT_EQ(Disp.size(), 2UL);
   EXPECT_EQ(Disp[0], 0x05050000u);
   EXPECT_EQ(Disp[1], 0x06060000u);
+  EXPECT_EQ(Size, 45u);
+}
+
+TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIAllocaRegister) {
+  uint64_t Size = sizeof(TBTableData);
+  Expected<XCOFFTracebackTable> TTOrErr =
+      XCOFFTracebackTable::create(TBTableData, Size);
+  ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
+  XCOFFTracebackTable TT = *TTOrErr;
+  ASSERT_TRUE(TT.getAllocaRegister());
+  EXPECT_EQ(TT.getAllocaRegister().getValue(), 31u);
 }
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo) {
-  uint64_t Size = 40;
+
+  uint64_t Size = sizeof(TBTableData);
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
   XCOFFTracebackTable TT = *TTOrErr;
 
+  EXPECT_EQ(TT.getNumberOfFixedParms(), 3);
+  EXPECT_EQ(TT.getNumberOfFPParms(), 2);
   EXPECT_TRUE(TT.hasVectorInfo());
-  EXPECT_FALSE(TT.getParmsType());
+  EXPECT_TRUE(TT.hasExtensionTable());
+
+  ASSERT_TRUE(TT.getParmsType());
+  EXPECT_EQ(TT.getParmsType().getValue(), "v, i, f, i, d, i, v");
+
+  ASSERT_TRUE(TT.getVectorExt());
+  TBVectorExt VecExt = TT.getVectorExt().getValue();
+
+  EXPECT_EQ(VecExt.geNumberOfVRSaved(), 0);
+  EXPECT_TRUE(VecExt.isVRSavedOnStack());
+  EXPECT_FALSE(VecExt.hasVarArgs());
+
+  EXPECT_EQ(VecExt.getNumberOfVectorParms(), 2u);
+  EXPECT_TRUE(VecExt.hasVMXInstruction());
+
+  EXPECT_EQ(VecExt.getVectorParmsInfoString(), "vf, vf");
+
+  ASSERT_TRUE(TT.getExtensionTable());
+  EXPECT_EQ(TT.getExtensionTable().getValue(),
+            ExtendedTBTableFlag::TB_SSP_CANARY);
+
+  EXPECT_EQ(Size, 45u);
+}
+
+TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo1) {
+  const uint8_t TBTableData[] = {
+      0x00, 0x00, 0x2A, 0x40, 0x80, 0xc0, 0x03, 0x05, 0x48, 0xc0, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x00, 0x00,
+      0x06, 0x06, 0x00, 0x00, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c,
+      0x6c, 0x11, 0x07, 0x90, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00};
+  uint64_t Size = sizeof(TBTableData);
+  Expected<XCOFFTracebackTable> TTOrErr =
+      XCOFFTracebackTable::create(TBTableData, Size);
+  ASSERT_THAT_EXPECTED(TTOrErr, Succeeded());
+  XCOFFTracebackTable TT = *TTOrErr;
+
+  ASSERT_TRUE(TT.getParmsType());
+  EXPECT_EQ(TT.getParmsType().getValue(), "v, i, f, i, d, i");
+
+  ASSERT_TRUE(TT.getVectorExt());
+  TBVectorExt VecExt = TT.getVectorExt().getValue();
+
+  EXPECT_EQ(VecExt.geNumberOfVRSaved(), 4);
+  EXPECT_FALSE(VecExt.isVRSavedOnStack());
+  EXPECT_TRUE(VecExt.hasVarArgs());
+
+  EXPECT_EQ(VecExt.getNumberOfVectorParms(), 3u);
+  EXPECT_TRUE(VecExt.hasVMXInstruction());
+
+  EXPECT_EQ(VecExt.getVectorParmsInfoString(), "vi, vs, vc");
+
+  ASSERT_TRUE(TT.getExtensionTable());
+  EXPECT_EQ(TT.getExtensionTable().getValue(),
+            ExtendedTBTableFlag::TB_SSP_CANARY);
+
+  EXPECT_EQ(Size, 44u);
 }
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtMandatory) {
   uint64_t Size = 6;
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
       FailedWithMessage(
           "unexpected end of data at offset 0x6 while reading [0x0, 0x8)"));
-  EXPECT_EQ(Size, 0UL);
+  EXPECT_EQ(Size, 0u);
 }
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtParmsType) {
   uint64_t Size = 9;
   Expected<XCOFFTracebackTable> TTOrErr =
       XCOFFTracebackTable::create(TBTableData, Size);
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtFunctionName) {
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
       FailedWithMessage(
           "unexpected end of data at offset 0x24 while reading [0x1e, 0x25)"));
   EXPECT_EQ(Size, 30u);
 }
 
 TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtAllocaUsed) {
-  uint8_t V[] = {0x00, 0x00, 0x2A, 0x60, 0x80, 0x00, 0x01, 0x05, 0x58, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x02,
-                 0x05, 0x05, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x07,
-                 0x61, 0x64, 0x64, 0x5f, 0x61, 0x6c, 0x6c};
-  uint64_t Size = sizeof(V);
-  Expected<XCOFFTracebackTable> TTOrErr = XCOFFTracebackTable::create(V, Size);
+  uint64_t Size = 37;
+  Expected<XCOFFTracebackTable> TTOrErr =
+      XCOFFTracebackTable::create(TBTableData, Size);
   EXPECT_THAT_ERROR(
       TTOrErr.takeError(),
       FailedWithMessage(
           "unexpected end of data at offset 0x25 while reading [0x25, 0x26)"));
   EXPECT_EQ(Size, 37u);
 }
+
+TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtVectorInfoData) {
+  uint64_t Size = 39;
+  Expected<XCOFFTracebackTable> TTOrErr =
+      XCOFFTracebackTable::create(TBTableData, Size);
+
+  EXPECT_THAT_ERROR(
+      TTOrErr.takeError(),
+      FailedWithMessage(
+          "unexpected end of data at offset 0x27 while reading [0x26, 0x2c)"));
+  EXPECT_EQ(Size, 38u);
+}
+
+TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtVectorInfoParmsInfo) {
+  uint64_t Size = 43;
+  Expected<XCOFFTracebackTable> TTOrErr =
+      XCOFFTracebackTable::create(TBTableData, Size);
+
+  EXPECT_THAT_ERROR(
+      TTOrErr.takeError(),
+      FailedWithMessage(
+          "unexpected end of data at offset 0x2b while reading [0x26, 0x2c)"));
+  EXPECT_EQ(Size, 38u);
+}
+
+TEST(XCOFFObjectFileTest, XCOFFTracebackTableTruncatedAtExtLongTBTable) {
+  uint64_t Size = 44;
+  Expected<XCOFFTracebackTable> TTOrErr =
+      XCOFFTracebackTable::create(TBTableData, Size);
+
+  EXPECT_THAT_ERROR(
+      TTOrErr.takeError(),
+      FailedWithMessage(
+          "unexpected end of data at offset 0x2c while reading [0x2c, 0x2d)"));
+  EXPECT_EQ(Size, 44u);
+}