[lldb] Add dummy field to RegisterInfo for register flags use later

[DavidSpickett]

Summary

This structure is supposed to be trivial, so we cannot simply do
"= nullptr;" on the new member. Doing that means you are non trivial,
regardless of whether you emulate the previously implied constructor somehow.

The next option is to update every use of brace initialisation.

Given that this is some hundreds of lines, this change just adds a dummy
pointer that is set to nullptr. Subsequent changes will actually use that
to point to register flags information.

Note: This change is not clang-format-ted because it changes a bunch of
areas that are not themselves formatted. It would just add noise.

[DavidSpickett]

Rebase

[jasonmolenda]

LGTM.

[DavidSpickett]

Rebase

[JDevlieghere]

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

57–68

Would using a .def file make this easier to maintain?

[DavidSpickett]

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

57–68

Almost certainly, do you mean in general? Half of these files are using some macro to make the defs already, one could probably generalise that. You'd end up with a sort of constructor for RegisterInfo, but it's a macro. So if some file wants to diverge, it can.

Let me see what I can do about that, though I think it would be best done in a new patch.

[DavidSpickett]

Rebase

[JDevlieghere]

LGTM

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

57–68

Yeah, I meant the g_register_infos as a whole. Tablegen would be an option too, but that might be overkill for this. Separate patch sounds fair.

[DavidSpickett]

Rebase

lldb/include/lldb/lldb-private-types.h

struct RegisterInfo {
   /// of eRegisterKindLLDB. If multiple registers are listed, the final
   /// value will be the concatenation of them.
   uint32_t *value_regs;
   /// List of registers (terminated with LLDB_INVALID_REGNUM). If this value is
   /// not null, all registers in this list will be invalidated when the value of
   /// this register changes. For example, the invalidate list for eax would be
   /// rax ax, ah, and al.
   uint32_t *invalidate_regs;
+  // Will be replaced with register flags info in the next patch.
+  void *unused;
 
   llvm::ArrayRef<uint8_t> data(const uint8_t *context_base) const {
     return llvm::ArrayRef<uint8_t>(context_base + byte_offset, byte_size);
   }
 
   llvm::MutableArrayRef<uint8_t> mutable_data(uint8_t *context_base) const {
     return llvm::MutableArrayRef<uint8_t>(context_base + byte_offset,
                                           byte_size);

lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp

 // The ABI is not a source of such information as size, offset, encoding, etc.
 // of a register. Just provides correct dwarf and eh_frame numbers.
 
 #define DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, generic_num)        \
   {                                                                           \
     DEFINE_REG_NAME(dwarf_num), DEFINE_REG_NAME_STR(str_name),                \
     0, 0, eEncodingInvalid, eFormatDefault,                                   \
     { dwarf_num, dwarf_num, generic_num, LLDB_INVALID_REGNUM, dwarf_num },    \
-    nullptr, nullptr                                                          \
+    nullptr, nullptr, nullptr,                                                \
   }
 
 #define DEFINE_REGISTER_STUB(dwarf_num, str_name) \
   DEFINE_GENERIC_REGISTER_STUB(dwarf_num, str_name, LLDB_INVALID_REGNUM)
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp

static const RegisterInfo g_register_infos[] = {
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r1",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r2",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r3",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r4",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r5",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r6",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r7",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sp",
      "r13",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lr",
      "r14",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      "r15",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cpsr",
      "psr",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s0",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s1",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s2",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s3",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s4",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s5",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s6",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s7",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s8",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s9",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s10",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s11",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s12",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s13",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s14",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s15",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s16",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s17",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s18",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s19",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s20",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s21",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s22",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s23",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s24",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s25",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s26",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s27",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s28",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s29",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s30",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s31",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fpscr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d0",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d1",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d2",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d3",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d4",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d5",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d6",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d7",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d8",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d9",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d10",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d11",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d12",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d13",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d14",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d15",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d16",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d17",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d18",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d19",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d20",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d21",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d22",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d23",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d24",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d25",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d26",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d27",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d28",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d29",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d30",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d31",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_usr",
      "sp_usr",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_usr",
      "lr_usr",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_fiq",
      "sp_fiq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_fiq",
      "lr_fiq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_irq",
      "sp_irq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_irq",
      "lr_irq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_abt",
      "sp_abt",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_abt",
      "lr_abt",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_und",
      "sp_und",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_und",
      "lr_und",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_svc",
      "sp_svc",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_svc",
      "lr_svc",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
      }};
 
 static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABIMacOSX_arm::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;

lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp

static const RegisterInfo g_register_infos[] = {
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r1",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r2",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r3",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r4",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r5",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r6",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r7",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sp",
      "r13",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lr",
      "r14",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      "r15",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cpsr",
      "psr",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s0",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s1",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s2",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s3",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s4",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s5",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s6",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s7",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s8",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s9",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s10",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s11",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s12",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s13",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s14",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s15",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s16",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s17",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s18",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s19",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s20",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s21",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s22",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s23",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s24",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s25",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s26",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s27",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s28",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s29",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s30",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s31",
      nullptr,
      4,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fpscr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d0",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d1",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d2",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d3",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d4",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d5",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d6",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d7",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d8",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d9",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d10",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d11",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d12",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d13",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d14",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d15",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d16",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d17",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d18",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d19",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d20",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d21",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d22",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d23",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d24",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d25",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d26",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d27",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d28",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d29",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d30",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"d31",
      nullptr,
      8,
      0,
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_d31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r8_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r9_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r10_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r11_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12_usr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r12_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_usr",
      "sp_usr",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_usr",
      "lr_usr",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_usr, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r8_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r9_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r10_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r11_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12_fiq",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r12_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_fiq",
      "sp_fiq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_fiq",
      "lr_fiq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_fiq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_irq",
      "sp_irq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_irq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_irq",
      "lr_irq",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_irq, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_abt",
      "sp_abt",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_abt, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_abt",
      "lr_abt",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_abt, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13_und",
      "sp_und",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_und, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_und",
      "lr_und",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_und, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
+
     },
     {"r13_svc",
      "sp_svc",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r13_svc, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14_svc",
      "lr_svc",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, dwarf_r14_svc, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
      }};
 
 static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_arm::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;

lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.cpp

static const RegisterInfo g_register_infos[] = {
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {0, 0, LLDB_INVALID_REGNUM, 0, 0},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r01",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {1, 1, LLDB_INVALID_REGNUM, 1, 1},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r02",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {2, 2, LLDB_INVALID_REGNUM, 2, 2},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r03",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {3, 3, LLDB_INVALID_REGNUM, 3, 3},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r04",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {4, 4, LLDB_INVALID_REGNUM, 4, 4},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r05",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {5, 5, LLDB_INVALID_REGNUM, 5, 5},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r06",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {6, 6, LLDB_INVALID_REGNUM, 6, 6},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r07",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {7, 7, LLDB_INVALID_REGNUM, 7, 7},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r08",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {8, 8, LLDB_INVALID_REGNUM, 8, 8},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r09",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {9, 9, LLDB_INVALID_REGNUM, 9, 9},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {10, 10, LLDB_INVALID_REGNUM, 10, 10},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {11, 11, LLDB_INVALID_REGNUM, 11, 11},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {12, 12, LLDB_INVALID_REGNUM, 12, 12},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {13, 13, LLDB_INVALID_REGNUM, 13, 13},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {14, 14, LLDB_INVALID_REGNUM, 14, 14},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r15",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {15, 15, LLDB_INVALID_REGNUM, 15, 15},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r16",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {16, 16, LLDB_INVALID_REGNUM, 16, 16},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r17",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {17, 17, LLDB_INVALID_REGNUM, 17, 17},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r18",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {18, 18, LLDB_INVALID_REGNUM, 18, 18},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r19",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {19, 19, LLDB_INVALID_REGNUM, 19, 19},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r20",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {20, 20, LLDB_INVALID_REGNUM, 20, 20},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r21",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {21, 21, LLDB_INVALID_REGNUM, 21, 21},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r22",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {22, 22, LLDB_INVALID_REGNUM, 22, 22},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r23",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {23, 23, LLDB_INVALID_REGNUM, 23, 23},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r24",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {24, 24, LLDB_INVALID_REGNUM, 24, 24},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r25",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {25, 25, LLDB_INVALID_REGNUM, 25, 25},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r26",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {26, 26, LLDB_INVALID_REGNUM, 26, 26},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r27",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {27, 27, LLDB_INVALID_REGNUM, 27, 27},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r28",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {28, 28, LLDB_INVALID_REGNUM, 28, 28},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sp",
      "r29",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {29, 29, LLDB_REGNUM_GENERIC_SP, 29, 29},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fp",
      "r30",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {30, 30, LLDB_REGNUM_GENERIC_FP, 30, 30},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lr",
      "r31",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {31, 31, LLDB_REGNUM_GENERIC_RA, 31, 31},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sa0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {32, 32, LLDB_INVALID_REGNUM, 32, 32},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lc0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {33, 33, LLDB_INVALID_REGNUM, 33, 33},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sa1",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {34, 34, LLDB_INVALID_REGNUM, 34, 34},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lc1",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {35, 35, LLDB_INVALID_REGNUM, 35, 35},
      nullptr,
      nullptr,
+     nullptr,
     },
     // --> hexagon-v4/5/55/56-sim.xml
     {"p3_0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {36, 36, LLDB_INVALID_REGNUM, 36, 36},
      nullptr,
      nullptr,
+     nullptr,
+
     },
     // PADDING {
     {"p00",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {37, 37, LLDB_INVALID_REGNUM, 37, 37},
      nullptr,
      nullptr,
+     nullptr,
     },
     // }
     {"m0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {38, 38, LLDB_INVALID_REGNUM, 38, 38},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"m1",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {39, 39, LLDB_INVALID_REGNUM, 39, 39},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"usr",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {40, 40, LLDB_INVALID_REGNUM, 40, 40},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {41, 41, LLDB_REGNUM_GENERIC_PC, 41, 41},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"ugp",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {42, 42, LLDB_INVALID_REGNUM, 42, 42},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"gp",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {43, 43, LLDB_INVALID_REGNUM, 43, 43},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cs0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {44, 44, LLDB_INVALID_REGNUM, 44, 44},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cs1",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {45, 45, LLDB_INVALID_REGNUM, 45, 45},
      nullptr,
      nullptr,
+     nullptr,
     },
     // PADDING {
     {"p01",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {46, 46, LLDB_INVALID_REGNUM, 46, 46},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p02",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {47, 47, LLDB_INVALID_REGNUM, 47, 47},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p03",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {48, 48, LLDB_INVALID_REGNUM, 48, 48},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p04",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {49, 49, LLDB_INVALID_REGNUM, 49, 49},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p05",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {50, 50, LLDB_INVALID_REGNUM, 50, 50},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p06",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {51, 51, LLDB_INVALID_REGNUM, 51, 51},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p07",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {52, 52, LLDB_INVALID_REGNUM, 52, 52},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p08",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {53, 53, LLDB_INVALID_REGNUM, 53, 53},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p09",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {54, 54, LLDB_INVALID_REGNUM, 54, 54},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p10",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {55, 55, LLDB_INVALID_REGNUM, 55, 55},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p11",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {56, 56, LLDB_INVALID_REGNUM, 56, 56},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p12",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {57, 57, LLDB_INVALID_REGNUM, 57, 57},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p13",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {58, 58, LLDB_INVALID_REGNUM, 58, 58},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p14",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {59, 59, LLDB_INVALID_REGNUM, 59, 59},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p15",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {60, 60, LLDB_INVALID_REGNUM, 60, 60},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p16",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {61, 61, LLDB_INVALID_REGNUM, 61, 61},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p17",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {62, 62, LLDB_INVALID_REGNUM, 62, 62},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p18",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {63, 63, LLDB_INVALID_REGNUM, 63, 63},
      nullptr,
      nullptr,
+     nullptr,
     },
     // }
     {"sgp0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {64, 64, LLDB_INVALID_REGNUM, 64, 64},
      nullptr,
      nullptr,
+     nullptr,
     },
     // PADDING {
     {"p19",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {65, 65, LLDB_INVALID_REGNUM, 65, 65},
      nullptr,
      nullptr,
+     nullptr,
     },
     // }
     {"stid",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {66, 66, LLDB_INVALID_REGNUM, 66, 66},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"elr",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {67, 67, LLDB_INVALID_REGNUM, 67, 67},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"badva0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {68, 68, LLDB_INVALID_REGNUM, 68, 68},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"badva1",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {69, 69, LLDB_INVALID_REGNUM, 69, 69},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"ssr",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {70, 70, LLDB_INVALID_REGNUM, 70, 70},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"ccr",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {71, 71, LLDB_INVALID_REGNUM, 71, 71},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"htid",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {72, 72, LLDB_INVALID_REGNUM, 72, 72},
      nullptr,
      nullptr,
+     nullptr,
     },
     // PADDING {
     {"p20",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {73, 73, LLDB_INVALID_REGNUM, 73, 73},
      nullptr,
      nullptr,
+     nullptr,
     },
     // }
     {"imask",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {74, 74, LLDB_INVALID_REGNUM, 74, 74},
      nullptr,
      nullptr,
+     nullptr,
     },
     // PADDING {
     {"p21",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {75, 75, LLDB_INVALID_REGNUM, 75, 75},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p22",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {76, 76, LLDB_INVALID_REGNUM, 76, 76},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p23",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {77, 77, LLDB_INVALID_REGNUM, 77, 77},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p24",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {78, 78, LLDB_INVALID_REGNUM, 78, 78},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"p25",
      "",
      4,
      0,
      eEncodingInvalid,
      eFormatInvalid,
      {79, 79, LLDB_INVALID_REGNUM, 79, 79},
      nullptr,
      nullptr,
+     nullptr,
     },
     // }
     {"g0",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {80, 80, LLDB_INVALID_REGNUM, 80, 80},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"g1",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {81, 81, LLDB_INVALID_REGNUM, 81, 81},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"g2",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {82, 82, LLDB_INVALID_REGNUM, 82, 82},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"g3",
      "",
      4,
      0,
      eEncodingUint,
      eFormatAddressInfo,
      {83, 83, LLDB_INVALID_REGNUM, 83, 83},
      nullptr,
      nullptr,
+     nullptr,
      }};
 
 static const uint32_t k_num_register_infos =
     sizeof(g_register_infos) / sizeof(RegisterInfo);
 
 const lldb_private::RegisterInfo *
 ABISysV_hexagon::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;

lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp

static const RegisterInfo g_register_infos[] = {
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r0, dwarf_r0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r1",
      "AT",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r1, dwarf_r1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r2",
      "v0",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r2, dwarf_r2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r3",
      "v1",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r3, dwarf_r3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r4",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r4, dwarf_r4, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r5",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r5, dwarf_r5, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r6",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r6, dwarf_r6, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r7",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r7, dwarf_r7, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8",
      "arg5",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9",
      "arg6",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10",
      "arg7",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11",
      "arg8",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r13, dwarf_r13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r14, dwarf_r14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r15",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r15, dwarf_r15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r16",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r16, dwarf_r16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r17",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r17, dwarf_r17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r18",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r18, dwarf_r18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r19",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r19, dwarf_r19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r20",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r20, dwarf_r20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r21",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r21, dwarf_r21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r22",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r22, dwarf_r22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r23",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r23, dwarf_r23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r24",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r24, dwarf_r24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r25",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r25, dwarf_r25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r26",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r26, dwarf_r26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r27",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r27, dwarf_r27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r28",
      "gp",
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r28, dwarf_r28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r29",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r29, dwarf_r29, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r30",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r30, dwarf_r30, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r31",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r31, dwarf_r31, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_sr, dwarf_sr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lo",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_lo, dwarf_lo, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"hi",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_hi, dwarf_hi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"bad",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_bad, dwarf_bad, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cause",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_cause, dwarf_cause, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
 };
 
 static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_mips::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp

static const RegisterInfo g_register_infos_mips64[] = {
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r0, dwarf_r0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r1",
      "AT",
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r1, dwarf_r1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
+
     },
     {"r2",
      "v0",
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r2, dwarf_r2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r3",
      "v1",
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r3, dwarf_r3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r4",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r4, dwarf_r4, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r5",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r5, dwarf_r5, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r6",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r6, dwarf_r6, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r7",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r7, dwarf_r7, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r8, dwarf_r8, LLDB_REGNUM_GENERIC_ARG5, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r9, dwarf_r9, LLDB_REGNUM_GENERIC_ARG6, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r10, dwarf_r10, LLDB_REGNUM_GENERIC_ARG7, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r11, dwarf_r11, LLDB_REGNUM_GENERIC_ARG8, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r13",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r13, dwarf_r13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r14",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r14, dwarf_r14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r15",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r15, dwarf_r15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r16",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r16, dwarf_r16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r17",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r17, dwarf_r17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r18",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r18, dwarf_r18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r19",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r19, dwarf_r19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r20",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r20, dwarf_r20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r21",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r21, dwarf_r21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r22",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r22, dwarf_r22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r23",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r23, dwarf_r23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r24",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r24, dwarf_r24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r25",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r25, dwarf_r25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r26",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r26, dwarf_r26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r27",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r27, dwarf_r27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r28",
      "gp",
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r28, dwarf_r28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r29",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r29, dwarf_r29, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r30",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r30, dwarf_r30, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r31",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_r31, dwarf_r31, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sr",
      nullptr,
      4,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_sr, dwarf_sr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lo",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_lo, dwarf_lo, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"hi",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_hi, dwarf_hi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"bad",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_bad, dwarf_bad, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cause",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_cause, dwarf_cause, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
     },
 };
 
 static const uint32_t k_num_register_infos = std::size(g_register_infos_mips64);
 
 const lldb_private::RegisterInfo *
 ABISysV_mips64::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

enum dwarf_regnums {
   dwarf_pc,
   dwarf_cfa,
 };
 
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
     #reg, alt, 8, 0, eEncodingUint, eFormatHex, {kind1, kind2, kind3, kind4 }, \
-                                                 nullptr, nullptr,             \
+                                                 nullptr, nullptr, nullptr,    \
   }
 
 static const RegisterInfo g_register_infos[] = {
     // General purpose registers.             eh_frame,                 DWARF,
     // Generic,    Process Plugin
     DEFINE_GPR(r0, nullptr, dwarf_r0, dwarf_r0, LLDB_INVALID_REGNUM,
                LLDB_INVALID_REGNUM),
     DEFINE_GPR(r1, nullptr, dwarf_r1, dwarf_r1, LLDB_REGNUM_GENERIC_SP,
static const RegisterInfo g_register_infos[] = {
      nullptr,
      8,
      0,
      eEncodingUint,
      eFormatHex,
      {dwarf_cfa, dwarf_cfa, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
      nullptr,
      nullptr,
+     nullptr,
      }};
 
 static const uint32_t k_num_register_infos = std::size(g_register_infos);
 
 const lldb_private::RegisterInfo *
 ABISysV_ppc::GetRegisterInfoArray(uint32_t &count) {
   count = k_num_register_infos;
   return g_register_infos;

lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.cpp

 
 // RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB
 
 #define DEFINE_REG(name, size, alt, generic)                                   \
   {                                                                            \
     #name, alt, size, 0, eEncodingUint, eFormatHex,                            \
         {dwarf_##name##_s390x, dwarf_##name##_s390x, generic,                  \
          LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM },                           \
-         nullptr, nullptr,                                                     \
+         nullptr, nullptr, nullptr,                                            \
   }
 
 static const RegisterInfo g_register_infos[] = {
     DEFINE_REG(r0, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(r1, 8, nullptr, LLDB_INVALID_REGNUM),
     DEFINE_REG(r2, 8, nullptr, LLDB_REGNUM_GENERIC_ARG1),
     DEFINE_REG(r3, 8, nullptr, LLDB_REGNUM_GENERIC_ARG2),
     DEFINE_REG(r4, 8, nullptr, LLDB_REGNUM_GENERIC_ARG3),

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

 #define FPU_OFFSET_NAME(reg) 0
 #define EXC_OFFSET_NAME(reg) 0
 #define DBG_OFFSET_NAME(reg) 0
 #define DBG_OFFSET_NAME(reg) 0
 #define DEFINE_DBG(re, y)                                                      \
   "na", nullptr, 8, 0, lldb::eEncodingUint, lldb::eFormatHex,                  \
       {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,          \
        LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},                              \
-      nullptr, nullptr
+      nullptr, nullptr, nullptr
 
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 
 #include "Plugins/Process/Utility/RegisterInfos_arm64.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/MathExtras.h"
 

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm.cpp

((LLVM_EXTENSION offsetof(RegisterContextDarwin_arm::DBG, reg) +             \
     sizeof(RegisterContextDarwin_arm::EXC)))
 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL, sizeof(((RegisterContextDarwin_arm::DBG *) NULL)->reg[i]),       \
                       DBG_OFFSET(reg[i]), eEncodingUint, eFormatHex,           \
                                  {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    \
                                   LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    \
                                   LLDB_INVALID_REGNUM },                       \
-                                  nullptr, nullptr,
+                                  nullptr, nullptr, nullptr,
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterContextDarwin_arm::GPR) +                                    \
    sizeof(RegisterContextDarwin_arm::FPU) +                                    \
    sizeof(RegisterContextDarwin_arm::EXC))
 
 static RegisterInfo g_register_infos[] = {
     // General purpose registers
     //  NAME        ALT     SZ  OFFSET              ENCODING        FORMAT
     //  EH_FRAME                DWARF               GENERIC
     //  PROCESS PLUGIN          LLDB NATIVE
     //  ======      ======= ==  =============       =============   ============
     //  ===============         ===============     =========================
     //  =====================   =============
     {"r0",
      nullptr,
      4,
      GPR_OFFSET(0),
      eEncodingUint,
      eFormatHex,
      {ehframe_r0, dwarf_r0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r0},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r1",
      nullptr,
      4,
      GPR_OFFSET(1),
      eEncodingUint,
      eFormatHex,
      {ehframe_r1, dwarf_r1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r1},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r2",
      nullptr,
      4,
      GPR_OFFSET(2),
      eEncodingUint,
      eFormatHex,
      {ehframe_r2, dwarf_r2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r2},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r3",
      nullptr,
      4,
      GPR_OFFSET(3),
      eEncodingUint,
      eFormatHex,
      {ehframe_r3, dwarf_r3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r3},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r4",
      nullptr,
      4,
      GPR_OFFSET(4),
      eEncodingUint,
      eFormatHex,
      {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r4},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r5",
      nullptr,
      4,
      GPR_OFFSET(5),
      eEncodingUint,
      eFormatHex,
      {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r5},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r6",
      nullptr,
      4,
      GPR_OFFSET(6),
      eEncodingUint,
      eFormatHex,
      {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r6},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r7",
      nullptr,
      4,
      GPR_OFFSET(7),
      eEncodingUint,
      eFormatHex,
      {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
       gpr_r7},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r8",
      nullptr,
      4,
      GPR_OFFSET(8),
      eEncodingUint,
      eFormatHex,
      {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r8},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r9",
      nullptr,
      4,
      GPR_OFFSET(9),
      eEncodingUint,
      eFormatHex,
      {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_r9},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r10",
      nullptr,
      4,
      GPR_OFFSET(10),
      eEncodingUint,
      eFormatHex,
      {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_r10},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r11",
      nullptr,
      4,
      GPR_OFFSET(11),
      eEncodingUint,
      eFormatHex,
      {ehframe_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_r11},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"r12",
      nullptr,
      4,
      GPR_OFFSET(12),
      eEncodingUint,
      eFormatHex,
      {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_r12},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sp",
      "r13",
      4,
      GPR_OFFSET(13),
      eEncodingUint,
      eFormatHex,
      {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
       gpr_sp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lr",
      "r14",
      4,
      GPR_OFFSET(14),
      eEncodingUint,
      eFormatHex,
      {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
       gpr_lr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      "r15",
      4,
      GPR_OFFSET(15),
      eEncodingUint,
      eFormatHex,
      {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       gpr_pc},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cpsr",
      "psr",
      4,
      GPR_OFFSET(16),
      eEncodingUint,
      eFormatHex,
      {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
       gpr_cpsr},
      nullptr,
      nullptr,
+     nullptr,
     },
 
     {"s0",
      nullptr,
      4,
      FPU_OFFSET(0),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s0},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s1",
      nullptr,
      4,
      FPU_OFFSET(1),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s1},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s2",
      nullptr,
      4,
      FPU_OFFSET(2),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s2},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s3",
      nullptr,
      4,
      FPU_OFFSET(3),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s3},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s4",
      nullptr,
      4,
      FPU_OFFSET(4),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s4},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s5",
      nullptr,
      4,
      FPU_OFFSET(5),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s5},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s6",
      nullptr,
      4,
      FPU_OFFSET(6),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s6},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s7",
      nullptr,
      4,
      FPU_OFFSET(7),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s7},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s8",
      nullptr,
      4,
      FPU_OFFSET(8),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s8},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s9",
      nullptr,
      4,
      FPU_OFFSET(9),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s9},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s10",
      nullptr,
      4,
      FPU_OFFSET(10),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s10},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s11",
      nullptr,
      4,
      FPU_OFFSET(11),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s11},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s12",
      nullptr,
      4,
      FPU_OFFSET(12),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s12},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s13",
      nullptr,
      4,
      FPU_OFFSET(13),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s13},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s14",
      nullptr,
      4,
      FPU_OFFSET(14),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s14},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s15",
      nullptr,
      4,
      FPU_OFFSET(15),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s15},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s16",
      nullptr,
      4,
      FPU_OFFSET(16),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s16},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s17",
      nullptr,
      4,
      FPU_OFFSET(17),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s17},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s18",
      nullptr,
      4,
      FPU_OFFSET(18),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s18},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s19",
      nullptr,
      4,
      FPU_OFFSET(19),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s19},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s20",
      nullptr,
      4,
      FPU_OFFSET(20),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s20},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s21",
      nullptr,
      4,
      FPU_OFFSET(21),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s21},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s22",
      nullptr,
      4,
      FPU_OFFSET(22),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s22},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s23",
      nullptr,
      4,
      FPU_OFFSET(23),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s23},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s24",
      nullptr,
      4,
      FPU_OFFSET(24),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s24},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s25",
      nullptr,
      4,
      FPU_OFFSET(25),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s25},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s26",
      nullptr,
      4,
      FPU_OFFSET(26),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s26},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s27",
      nullptr,
      4,
      FPU_OFFSET(27),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s27},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s28",
      nullptr,
      4,
      FPU_OFFSET(28),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s28},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s29",
      nullptr,
      4,
      FPU_OFFSET(29),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s29, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s29},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s30",
      nullptr,
      4,
      FPU_OFFSET(30),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s30, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s30},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"s31",
      nullptr,
      4,
      FPU_OFFSET(31),
      eEncodingIEEE754,
      eFormatFloat,
      {LLDB_INVALID_REGNUM, dwarf_s31, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       fpu_s31},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fpscr",
      nullptr,
      4,
      FPU_OFFSET(32),
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fpscr},
      nullptr,
      nullptr,
+     nullptr,
     },
 
     {"exception",
      nullptr,
      4,
      EXC_OFFSET(0),
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_exception},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fsr",
      nullptr,
      4,
      EXC_OFFSET(1),
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_fsr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"far",
      nullptr,
      4,
      EXC_OFFSET(2),
      eEncodingUint,
      eFormatHex,
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_far},
      nullptr,
      nullptr,
+     nullptr,
     },
 
     {DEFINE_DBG(bvr, 0)},
     {DEFINE_DBG(bvr, 1)},
     {DEFINE_DBG(bvr, 2)},
     {DEFINE_DBG(bvr, 3)},
     {DEFINE_DBG(bvr, 4)},
     {DEFINE_DBG(bvr, 5)},

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL,                                                                  \
       sizeof(((RegisterContextDarwin_arm64::DBG *) NULL)->reg[i]),             \
               DBG_OFFSET_NAME(reg[i]), eEncodingUint, eFormatHex,              \
                               {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM },                          \
-                               NULL, NULL
+                               NULL, NULL, NULL
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterContextDarwin_arm64::GPR) +                                  \
    sizeof(RegisterContextDarwin_arm64::FPU) +                                  \
    sizeof(RegisterContextDarwin_arm64::EXC))
 
 // Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 #include "RegisterInfos_arm64.h"

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_i386.cpp

#reg, NULL, sizeof(((RegisterContextDarwin_i386::FPU *) NULL)->reg),         \
                      FPU_OFFSET(reg), eEncodingUint, eFormatHex
 #define DEFINE_FPU_VECT(reg, i)                                                \
   #reg #i, NULL,                                                               \
       sizeof(((RegisterContextDarwin_i386::FPU *) NULL)->reg[i].bytes),        \
               FPU_OFFSET(reg[i]), eEncodingVector, eFormatVectorOfUInt8,       \
                          {LLDB_INVALID_REGNUM, dwarf_##reg##i,                 \
                           LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,            \
                           fpu_##reg##i },                                      \
-                          nullptr, nullptr,
+                          nullptr, nullptr, nullptr,
 
 #define DEFINE_EXC(reg)                                                        \
   #reg, NULL, sizeof(((RegisterContextDarwin_i386::EXC *) NULL)->reg),         \
                      EXC_OFFSET(reg), eEncodingUint, eFormatHex
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterContextDarwin_i386::GPR) +                                   \
    sizeof(RegisterContextDarwin_i386::FPU) +                                   \
    sizeof(RegisterContextDarwin_i386::EXC))
 
 static RegisterInfo g_register_infos[] = {
     //  Macro auto defines most stuff   eh_frame                DWARF
     //  GENERIC                    PROCESS PLUGIN       LLDB
     //  =============================== =======================
     //  ===================   =========================  ==================
     //  =================
     {DEFINE_GPR(eax, nullptr),
      {ehframe_eax, dwarf_eax, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_eax},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ebx, nullptr),
      {ehframe_ebx, dwarf_ebx, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_ebx},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ecx, nullptr),
      {ehframe_ecx, dwarf_ecx, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_ecx},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(edx, nullptr),
      {ehframe_edx, dwarf_edx, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_edx},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(edi, nullptr),
      {ehframe_edi, dwarf_edi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_edi},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(esi, nullptr),
      {ehframe_esi, dwarf_esi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       gpr_esi},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ebp, "fp"),
      {ehframe_ebp, dwarf_ebp, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
       gpr_ebp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(esp, "sp"),
      {ehframe_esp, dwarf_esp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
       gpr_esp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ss, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_ss},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(eflags, "flags"),
      {ehframe_eflags, dwarf_eflags, LLDB_REGNUM_GENERIC_FLAGS,
       LLDB_INVALID_REGNUM, gpr_eflags},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(eip, "pc"),
      {ehframe_eip, dwarf_eip, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
       gpr_eip},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(cs, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_cs},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ds, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_ds},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(es, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_es},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(fs, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_fs},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(gs, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_gs},
      nullptr,
      nullptr,
+     nullptr,
     },
 
     {DEFINE_FPU_UINT(fcw),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fcw},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(fsw),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fsw},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(ftw),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_ftw},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(fop),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fop},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(ip),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_ip},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(cs),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_cs},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(dp),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_dp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(ds),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_ds},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(mxcsr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_mxcsr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(mxcsrmask),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_mxcsrmask},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_VECT(stmm, 0)},
     {DEFINE_FPU_VECT(stmm, 1)},
     {DEFINE_FPU_VECT(stmm, 2)},
     {DEFINE_FPU_VECT(stmm, 3)},
     {DEFINE_FPU_VECT(stmm, 4)},
     {DEFINE_FPU_VECT(stmm, 5)},
     {DEFINE_FPU_VECT(stmm, 6)},
     {DEFINE_FPU_VECT(stmm, 7)},
     {DEFINE_FPU_VECT(xmm, 0)},
     {DEFINE_FPU_VECT(xmm, 1)},
     {DEFINE_FPU_VECT(xmm, 2)},
     {DEFINE_FPU_VECT(xmm, 3)},
     {DEFINE_FPU_VECT(xmm, 4)},
     {DEFINE_FPU_VECT(xmm, 5)},
     {DEFINE_FPU_VECT(xmm, 6)},
     {DEFINE_FPU_VECT(xmm, 7)},
 
     {DEFINE_EXC(trapno),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_trapno},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_EXC(err),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_err},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_EXC(faultvaddr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_faultvaddr},
      nullptr,
      nullptr,
+     nullptr,
      }};
 
 static size_t k_num_register_infos = std::size(g_register_infos);
 
 RegisterContextDarwin_i386::RegisterContextDarwin_i386(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc() {
   uint32_t i;

lldb/source/Plugins/Process/Utility/RegisterContextDarwin_x86_64.cpp

#reg, NULL, sizeof(((RegisterContextDarwin_x86_64::FPU *) NULL)->reg),       \
                      FPU_OFFSET(reg), eEncodingUint, eFormatHex
 #define DEFINE_FPU_VECT(reg, i)                                                \
   #reg #i, NULL,                                                               \
       sizeof(((RegisterContextDarwin_x86_64::FPU *) NULL)->reg[i].bytes),      \
               FPU_OFFSET(reg[i]), eEncodingVector, eFormatVectorOfUInt8,       \
                          {ehframe_dwarf_fpu_##reg##i,                          \
                           ehframe_dwarf_fpu_##reg##i, LLDB_INVALID_REGNUM,     \
                           LLDB_INVALID_REGNUM, fpu_##reg##i },                 \
-                          nullptr, nullptr,           
+                          nullptr, nullptr, nullptr,
 #define DEFINE_EXC(reg)                                                        \
   #reg, NULL, sizeof(((RegisterContextDarwin_x86_64::EXC *) NULL)->reg),       \
                      EXC_OFFSET(reg), eEncodingUint, eFormatHex
 
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterContextDarwin_x86_64::GPR) +                                 \
    sizeof(RegisterContextDarwin_x86_64::FPU) +                                 \
    sizeof(RegisterContextDarwin_x86_64::EXC))
 
 // General purpose registers for 64 bit
 static RegisterInfo g_register_infos[] = {
     //  Macro auto defines most stuff   EH_FRAME                    DWARF
     //  GENERIC                    PROCESS PLUGIN       LLDB
     //  =============================== ======================
     //  ===================      ========================== ====================
     //  ===================
     {DEFINE_GPR(rax, nullptr),
      {ehframe_dwarf_gpr_rax, ehframe_dwarf_gpr_rax, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_rax},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rbx, nullptr),
      {ehframe_dwarf_gpr_rbx, ehframe_dwarf_gpr_rbx, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_rbx},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rcx, nullptr),
      {ehframe_dwarf_gpr_rcx, ehframe_dwarf_gpr_rcx, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_rcx},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rdx, nullptr),
      {ehframe_dwarf_gpr_rdx, ehframe_dwarf_gpr_rdx, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_rdx},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rdi, nullptr),
      {ehframe_dwarf_gpr_rdi, ehframe_dwarf_gpr_rdi, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_rdi},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rsi, nullptr),
      {ehframe_dwarf_gpr_rsi, ehframe_dwarf_gpr_rsi, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_rsi},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rbp, "fp"),
      {ehframe_dwarf_gpr_rbp, ehframe_dwarf_gpr_rbp, LLDB_REGNUM_GENERIC_FP,
       LLDB_INVALID_REGNUM, gpr_rbp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rsp, "sp"),
      {ehframe_dwarf_gpr_rsp, ehframe_dwarf_gpr_rsp, LLDB_REGNUM_GENERIC_SP,
       LLDB_INVALID_REGNUM, gpr_rsp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r8, nullptr),
      {ehframe_dwarf_gpr_r8, ehframe_dwarf_gpr_r8, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r8},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r9, nullptr),
      {ehframe_dwarf_gpr_r9, ehframe_dwarf_gpr_r9, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r9},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r10, nullptr),
      {ehframe_dwarf_gpr_r10, ehframe_dwarf_gpr_r10, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r10},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r11, nullptr),
      {ehframe_dwarf_gpr_r11, ehframe_dwarf_gpr_r11, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r11},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r12, nullptr),
      {ehframe_dwarf_gpr_r12, ehframe_dwarf_gpr_r12, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r12},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r13, nullptr),
      {ehframe_dwarf_gpr_r13, ehframe_dwarf_gpr_r13, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r13},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r14, nullptr),
      {ehframe_dwarf_gpr_r14, ehframe_dwarf_gpr_r14, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r14},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(r15, nullptr),
      {ehframe_dwarf_gpr_r15, ehframe_dwarf_gpr_r15, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_r15},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rip, "pc"),
      {ehframe_dwarf_gpr_rip, ehframe_dwarf_gpr_rip, LLDB_REGNUM_GENERIC_PC,
       LLDB_INVALID_REGNUM, gpr_rip},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(rflags, "flags"),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS,
       LLDB_INVALID_REGNUM, gpr_rflags},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(cs, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_cs},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(fs, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_fs},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(gs, nullptr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, gpr_gs},
      nullptr,
      nullptr,
+     nullptr,
     },
 
     {DEFINE_FPU_UINT(fcw),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fcw},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(fsw),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fsw},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(ftw),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_ftw},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(fop),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_fop},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(ip),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_ip},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(cs),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_cs},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(dp),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_dp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(ds),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_ds},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(mxcsr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_mxcsr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_UINT(mxcsrmask),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, fpu_mxcsrmask},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_FPU_VECT(stmm, 0)},
     {DEFINE_FPU_VECT(stmm, 1)},
     {DEFINE_FPU_VECT(stmm, 2)},
     {DEFINE_FPU_VECT(stmm, 3)},
     {DEFINE_FPU_VECT(stmm, 4)},
     {DEFINE_FPU_VECT(stmm, 5)},
     {DEFINE_FPU_VECT(stmm, 6)},
static RegisterInfo g_register_infos[] = {
     {DEFINE_FPU_VECT(xmm, 14)},
     {DEFINE_FPU_VECT(xmm, 15)},
 
     {DEFINE_EXC(trapno),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_trapno},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_EXC(err),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_err},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_EXC(faultvaddr),
      {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, exc_faultvaddr},
      nullptr,
      nullptr,
+     nullptr,
      }};
 
 static size_t k_num_register_infos = std::size(g_register_infos);
 
 RegisterContextDarwin_x86_64::RegisterContextDarwin_x86_64(
     Thread &thread, uint32_t concrete_frame_idx)
     : RegisterContext(thread, concrete_frame_idx), gpr(), fpu(), exc() {
   uint32_t i;

lldb/source/Plugins/Process/Utility/RegisterContextLinux_i386.cpp

: RegisterContextLinux_x86(
            nullptr,
            sizeof(((GPR *)nullptr)->orig_eax),
            (LLVM_EXTENSION offsetof(GPR, orig_eax)),
            eEncodingUint,
            eFormatHex,
            {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
             LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
            nullptr,
+           nullptr,
            nullptr}) {}
 
 size_t RegisterContextLinux_i386::GetGPRSizeStatic() { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextLinux_i386::GetRegisterInfo() const {
   switch (GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:

lldb/source/Plugins/Process/Utility/RegisterContextLinux_x86_64.cpp

: lldb_private::RegisterContextLinux_x86(
            nullptr,
            sizeof(((GPR *)nullptr)->orig_rax),
            (LLVM_EXTENSION offsetof(GPR, orig_rax)),
            eEncodingUint,
            eFormatHex,
            {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
             LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
            nullptr,
+           nullptr,
            nullptr}),
       m_register_info_p(GetRegisterInfoPtr(target_arch)),
       m_register_info_count(GetRegisterInfoCount(target_arch)),
       m_user_register_count(GetUserRegisterInfoCount(target_arch)) {}
 
 size_t RegisterContextLinux_x86_64::GetGPRSizeStatic() { return sizeof(GPR); }
 
 const RegisterInfo *RegisterContextLinux_x86_64::GetRegisterInfo() const {

lldb/source/Plugins/Process/Utility/RegisterContextWindows_i386.cpp

 
 #define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
 
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
 #reg, alt, sizeof(((GPR *)nullptr)->reg), GPR_OFFSET(reg), eEncodingUint,  \
         eFormatHex,                                                            \
         {kind1, kind2, kind3, kind4, lldb_##reg##_i386 }, nullptr, nullptr,    \
+        nullptr,                                                               \
   }
 
 // clang-format off
 static RegisterInfo g_register_infos_i386[] = {
 // General purpose registers     EH_Frame              DWARF                 Generic                     Process Plugin
 //  ===========================  ==================    ================      =========================   ====================
     DEFINE_GPR(eax,   nullptr,   ehframe_eax_i386,     dwarf_eax_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
     DEFINE_GPR(ebx,   nullptr,   ehframe_ebx_i386,     dwarf_ebx_i386,       LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),

lldb/source/Plugins/Process/Utility/RegisterContextWindows_x86_64.cpp

 } GPR;
 
 #define GPR_OFFSET(regname) (LLVM_EXTENSION offsetof(GPR, regname))
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
 #reg, alt, sizeof(((GPR *)nullptr)->reg), GPR_OFFSET(reg), eEncodingUint,  \
         eFormatHex,                                                            \
         {kind1, kind2, kind3, kind4, lldb_##reg##_x86_64 }, nullptr, nullptr,  \
+        nullptr,                                                               \
   }
 
 typedef struct _FPReg {
   XMMReg xmm0;
   XMMReg xmm1;
   XMMReg xmm2;
   XMMReg xmm3;
   XMMReg xmm4;
#define FPR_OFFSET(regname)                                                    \
   (sizeof(GPR) + LLVM_EXTENSION offsetof(FPReg, regname))
 
 #define DEFINE_XMM(reg)                                                        \
   {                                                                            \
 #reg, NULL, sizeof(((FPReg *)nullptr)->reg), FPR_OFFSET(reg),              \
         eEncodingUint, eFormatVectorOfUInt64,                                  \
         {dwarf_##reg##_x86_64, dwarf_##reg##_x86_64, LLDB_INVALID_REGNUM,      \
          LLDB_INVALID_REGNUM, lldb_##reg##_x86_64 },                           \
-         nullptr, nullptr,                                                     \
+         nullptr, nullptr, nullptr,                                            \
   }
 
 // clang-format off
 static RegisterInfo g_register_infos_x86_64[] = {
 // General purpose registers     EH_Frame              DWARF                 Generic                     Process Plugin
 //  ===========================  ==================    ================      =========================   ====================
     DEFINE_GPR(rax,    nullptr,  dwarf_rax_x86_64,     dwarf_rax_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
     DEFINE_GPR(rbx,    nullptr,  dwarf_rbx_x86_64,     dwarf_rbx_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm.cpp

((LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm::DBG, reg) +                 \
     sizeof(RegisterInfoPOSIX_arm::EXC)))
 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL, sizeof(((RegisterInfoPOSIX_arm::DBG *) NULL)->reg[i]),           \
                       DBG_OFFSET(reg[i]), eEncodingUint, eFormatHex,           \
                                  {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    \
                                   LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,    \
                                   dbg_##reg##i },                              \
-                                  NULL, NULL,
+                                  NULL, NULL, NULL,
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterInfoPOSIX_arm::GPR) + sizeof(RegisterInfoPOSIX_arm::FPU) +   \
    sizeof(RegisterInfoPOSIX_arm::EXC))
 
 // Include RegisterInfos_arm to declare our g_register_infos_arm structure.
 #define DECLARE_REGISTER_INFOS_ARM_STRUCT
 #include "RegisterInfos_arm.h"
 #undef DECLARE_REGISTER_INFOS_ARM_STRUCT

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL,                                                                  \
       sizeof(((RegisterInfoPOSIX_arm64::DBG *) NULL)->reg[i]),                 \
               DBG_OFFSET_NAME(reg[i]), lldb::eEncodingUint, lldb::eFormatHex,  \
                               {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                dbg_##reg##i },                                 \
-                               NULL, NULL,         
+                               NULL, NULL, NULL,
 #define REG_CONTEXT_SIZE                                                       \
   (sizeof(RegisterInfoPOSIX_arm64::GPR) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::FPU) +                                      \
    sizeof(RegisterInfoPOSIX_arm64::EXC))
 
 // Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 #include "RegisterInfos_arm64.h"

lldb/source/Plugins/Process/Utility/RegisterInfos_arm.h

 static uint32_t g_q14_contained[] = {fpu_q14, LLDB_INVALID_REGNUM};
 static uint32_t g_q15_contained[] = {fpu_q15, LLDB_INVALID_REGNUM};
 
 #define FPU_REG(name, size, offset, qreg)                                      \
   {                                                                            \
     #name, nullptr, size, FPU_OFFSET(offset), eEncodingIEEE754, eFormatFloat,  \
         {LLDB_INVALID_REGNUM, dwarf_##name, LLDB_INVALID_REGNUM,               \
          LLDB_INVALID_REGNUM, fpu_##name },                                    \
-         g_##qreg##_contained, g_##name##_invalidates,                         \
+         g_##qreg##_contained, g_##name##_invalidates, nullptr,                \
   }
 
 #define FPU_QREG(name, offset)                                                 \
   {                                                                            \
     #name, nullptr, 16, FPU_OFFSET(offset), eEncodingVector,                   \
         eFormatVectorOfUInt8,                                                  \
         {LLDB_INVALID_REGNUM, dwarf_##name, LLDB_INVALID_REGNUM,               \
          LLDB_INVALID_REGNUM, fpu_##name },                                    \
-         nullptr, g_##name##_invalidates,                                      \
+         nullptr, g_##name##_invalidates, nullptr,                             \
   }
 
 static RegisterInfo g_register_infos_arm[] = {
     //  NAME         ALT     SZ   OFFSET          ENCODING          FORMAT
     //  EH_FRAME             DWARF                GENERIC
     //  PROCESS PLUGIN       LLDB NATIVE      VALUE REGS      INVALIDATE REGS
     //  ===========  ======= ==   ==============  ================
     //  ====================    ===================  ===================
     //  ==========================  ===================  =============
     //  ==============  =================
     {
         "r0",
         nullptr,
         4,
         GPR_OFFSET(0),
         eEncodingUint,
         eFormatHex,
         {ehframe_r0, dwarf_r0, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
          gpr_r0},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r1",
         nullptr,
         4,
         GPR_OFFSET(1),
         eEncodingUint,
         eFormatHex,
         {ehframe_r1, dwarf_r1, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
          gpr_r1},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r2",
         nullptr,
         4,
         GPR_OFFSET(2),
         eEncodingUint,
         eFormatHex,
         {ehframe_r2, dwarf_r2, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
          gpr_r2},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r3",
         nullptr,
         4,
         GPR_OFFSET(3),
         eEncodingUint,
         eFormatHex,
         {ehframe_r3, dwarf_r3, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
          gpr_r3},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r4",
         nullptr,
         4,
         GPR_OFFSET(4),
         eEncodingUint,
         eFormatHex,
         {ehframe_r4, dwarf_r4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r4},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r5",
         nullptr,
         4,
         GPR_OFFSET(5),
         eEncodingUint,
         eFormatHex,
         {ehframe_r5, dwarf_r5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r5},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r6",
         nullptr,
         4,
         GPR_OFFSET(6),
         eEncodingUint,
         eFormatHex,
         {ehframe_r6, dwarf_r6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r6},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r7",
         nullptr,
         4,
         GPR_OFFSET(7),
         eEncodingUint,
         eFormatHex,
         {ehframe_r7, dwarf_r7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r7},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r8",
         nullptr,
         4,
         GPR_OFFSET(8),
         eEncodingUint,
         eFormatHex,
         {ehframe_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r8},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r9",
         nullptr,
         4,
         GPR_OFFSET(9),
         eEncodingUint,
         eFormatHex,
         {ehframe_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r9},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r10",
         nullptr,
         4,
         GPR_OFFSET(10),
         eEncodingUint,
         eFormatHex,
         {ehframe_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r10},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r11",
         nullptr,
         4,
         GPR_OFFSET(11),
         eEncodingUint,
         eFormatHex,
         {ehframe_r11, dwarf_r11, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
          gpr_r11},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "r12",
         nullptr,
         4,
         GPR_OFFSET(12),
         eEncodingUint,
         eFormatHex,
         {ehframe_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          gpr_r12},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "sp",
         "r13",
         4,
         GPR_OFFSET(13),
         eEncodingUint,
         eFormatHex,
         {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
          gpr_sp},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "lr",
         "r14",
         4,
         GPR_OFFSET(14),
         eEncodingUint,
         eFormatHex,
         {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
          gpr_lr},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "pc",
         "r15",
         4,
         GPR_OFFSET(15),
         eEncodingUint,
         eFormatHex,
         {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
          gpr_pc},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "cpsr",
         "psr",
         4,
         GPR_OFFSET(16),
         eEncodingUint,
         eFormatHex,
         {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS,
          LLDB_INVALID_REGNUM, gpr_cpsr},
         nullptr,
         nullptr,
+        nullptr,
     },
 
     FPU_REG(s0, 4, 0, q0),
     FPU_REG(s1, 4, 1, q0),
     FPU_REG(s2, 4, 2, q0),
     FPU_REG(s3, 4, 3, q0),
     FPU_REG(s4, 4, 4, q1),
     FPU_REG(s5, 4, 5, q1),
FPU_REG(s31, 4, 31, q7),
         4,
         FPSCR_OFFSET,
         eEncodingUint,
         eFormatHex,
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          LLDB_INVALID_REGNUM, fpu_fpscr},
         nullptr,
         nullptr,
+        nullptr,
     },
 
     FPU_REG(d0, 8, 0, q0),
     FPU_REG(d1, 8, 2, q0),
     FPU_REG(d2, 8, 4, q1),
     FPU_REG(d3, 8, 6, q1),
     FPU_REG(d4, 8, 8, q2),
     FPU_REG(d5, 8, 10, q2),
FPU_QREG(q15, 60),
         4,
         EXC_OFFSET(0),
         eEncodingUint,
         eFormatHex,
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          LLDB_INVALID_REGNUM, exc_exception},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "fsr",
         nullptr,
         4,
         EXC_OFFSET(1),
         eEncodingUint,
         eFormatHex,
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          LLDB_INVALID_REGNUM, exc_fsr},
         nullptr,
         nullptr,
+        nullptr,
     },
     {
         "far",
         nullptr,
         4,
         EXC_OFFSET(2),
         eEncodingUint,
         eFormatHex,
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
          LLDB_INVALID_REGNUM, exc_far},
         nullptr,
         nullptr,
+        nullptr,
     },
 
     {DEFINE_DBG(bvr, 0)},
     {DEFINE_DBG(bvr, 1)},
     {DEFINE_DBG(bvr, 2)},
     {DEFINE_DBG(bvr, 3)},
     {DEFINE_DBG(bvr, 4)},
     {DEFINE_DBG(bvr, 5)},

lldb/source/Plugins/Process/Utility/RegisterInfos_arm64.h

 
 // clang-format off
 
 // Defines a 64-bit general purpose register
 #define DEFINE_GPR64(reg, generic_kind)                                        \
   {                                                                            \
     #reg, nullptr, 8, GPR_OFFSET(gpr_##reg), lldb::eEncodingUint,              \
         lldb::eFormatHex, GPR64_KIND(reg, generic_kind), nullptr, nullptr,     \
+        nullptr,                                                               \
   }
 
 // Defines a 64-bit general purpose register
 #define DEFINE_GPR64_ALT(reg, alt, generic_kind)                               \
   {                                                                            \
     #reg, #alt, 8, GPR_OFFSET(gpr_##reg), lldb::eEncodingUint,                 \
         lldb::eFormatHex, GPR64_KIND(reg, generic_kind), nullptr, nullptr,     \
+        nullptr,                                                               \
   }
 
 // Defines a 32-bit general purpose pseudo register
 #define DEFINE_GPR32(wreg, xreg)                                               \
   {                                                                            \
     #wreg, nullptr, 4,                                                         \
         GPR_OFFSET(gpr_##xreg) + GPR_W_PSEUDO_REG_ENDIAN_OFFSET,               \
         lldb::eEncodingUint, lldb::eFormatHex, LLDB_KIND(gpr_##wreg),          \
-        g_contained_##xreg, g_##wreg##_invalidates,                            \
+        g_contained_##xreg, g_##wreg##_invalidates, nullptr,                   \
   }
 
 // Defines a vector register with 16-byte size
 #define DEFINE_VREG(reg)                                                       \
   {                                                                            \
     #reg, nullptr, 16, FPU_OFFSET(fpu_##reg - fpu_v0), lldb::eEncodingVector,  \
-        lldb::eFormatVectorOfUInt8, VREG_KIND(reg), nullptr, nullptr,          \
+        lldb::eFormatVectorOfUInt8, VREG_KIND(reg), nullptr, nullptr, nullptr, \
   }
 
 // Defines S and D pseudo registers mapping over corresponding vector register
 #define DEFINE_FPU_PSEUDO(reg, size, offset, vreg)                             \
   {                                                                            \
     #reg, nullptr, size, FPU_OFFSET(fpu_##vreg - fpu_v0) + offset,             \
         lldb::eEncodingIEEE754, lldb::eFormatFloat, LLDB_KIND(fpu_##reg),      \
-        g_contained_##vreg, g_##reg##_invalidates,                             \
+        g_contained_##vreg, g_##reg##_invalidates, nullptr,                    \
   }
 
 // Defines miscellaneous status and control registers like cpsr, fpsr etc
 #define DEFINE_MISC_REGS(reg, size, TYPE, lldb_kind)                           \
   {                                                                            \
     #reg, nullptr, size, TYPE##_OFFSET_NAME(reg), lldb::eEncodingUint,         \
         lldb::eFormatHex, MISC_##TYPE##_KIND(lldb_kind), nullptr, nullptr,     \
+        nullptr,                                                               \
   }
 
 // Defines pointer authentication mask registers
 #define DEFINE_EXTENSION_REG(reg)                                              \
   {                                                                            \
     #reg, nullptr, 8, 0, lldb::eEncodingUint, lldb::eFormatHex,                \
-        KIND_ALL_INVALID, nullptr, nullptr,                                    \
+        KIND_ALL_INVALID, nullptr, nullptr, nullptr,                           \
   }
 
 static lldb_private::RegisterInfo g_register_infos_arm64_le[] = {
     // DEFINE_GPR64(name, GENERIC KIND)
     DEFINE_GPR64(x0, LLDB_REGNUM_GENERIC_ARG1),
     DEFINE_GPR64(x1, LLDB_REGNUM_GENERIC_ARG2),
     DEFINE_GPR64(x2, LLDB_REGNUM_GENERIC_ARG3),
     DEFINE_GPR64(x3, LLDB_REGNUM_GENERIC_ARG4),

lldb/source/Plugins/Process/Utility/RegisterInfos_arm64_sve.h

 
 // clang-format off
 
 // Defines sve pseudo vector (V) register with 16-byte size
 #define DEFINE_VREG_SVE(vreg, zreg)                                            \
   {                                                                            \
     #vreg, nullptr, 16, 0, lldb::eEncodingVector, lldb::eFormatVectorOfUInt8,  \
         VREG_KIND(vreg), g_contained_##zreg, g_sve_##vreg##_invalidates,       \
+        nullptr,                                                               \
   }
 
 // Defines S and D pseudo registers mapping over corresponding vector register
 #define DEFINE_FPU_PSEUDO_SVE(reg, size, zreg)                                 \
   {                                                                            \
     #reg, nullptr, size, 0, lldb::eEncodingIEEE754, lldb::eFormatFloat,        \
         LLDB_KIND(fpu_##reg), g_contained_##zreg, g_sve_##reg##_invalidates,   \
+        nullptr,                                                               \
   }
 
 // Defines a Z vector register with 16-byte default size
 #define DEFINE_ZREG(reg)                                                       \
   {                                                                            \
     #reg, nullptr, 16, 0, lldb::eEncodingVector, lldb::eFormatVectorOfUInt8,   \
-        SVE_REG_KIND(reg), nullptr, nullptr,                                   \
+        SVE_REG_KIND(reg), nullptr, nullptr, nullptr,                          \
   }
 
 // Defines a P vector register with 2-byte default size
 #define DEFINE_PREG(reg)                                                       \
   {                                                                            \
     #reg, nullptr, 2, 0, lldb::eEncodingVector, lldb::eFormatVectorOfUInt8,    \
-        SVE_REG_KIND(reg), nullptr, nullptr,                                   \
+        SVE_REG_KIND(reg), nullptr, nullptr, nullptr,                          \
   }
 
 static lldb_private::RegisterInfo g_register_infos_arm64_sve_le[] = {
     // DEFINE_GPR64(name, GENERIC KIND)
     DEFINE_GPR64(x0, LLDB_REGNUM_GENERIC_ARG1),
     DEFINE_GPR64(x1, LLDB_REGNUM_GENERIC_ARG2),
     DEFINE_GPR64(x2, LLDB_REGNUM_GENERIC_ARG3),
     DEFINE_GPR64(x3, LLDB_REGNUM_GENERIC_ARG4),

lldb/source/Plugins/Process/Utility/RegisterInfos_i386.h

 
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
     #reg, alt, sizeof(((GPR *)nullptr)->reg),                                  \
                       GPR_OFFSET(reg), eEncodingUint, eFormatHex,              \
                                  {kind1, kind2, kind3, kind4,                  \
                                   lldb_##reg##_i386 },                         \
-                                  nullptr, nullptr,                            \
+                                  nullptr, nullptr, nullptr,                   \
   }
 
 #define DEFINE_FPR(name, reg, kind1, kind2, kind3, kind4)                      \
   {                                                                            \
     #name, nullptr, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, eFormatHex, \
                                            {kind1, kind2, kind3, kind4,        \
                                             lldb_##name##_i386 },              \
-                                            nullptr, nullptr,                  \
+                                            nullptr, nullptr, nullptr,         \
   }
 
 // RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB
 
 #define DEFINE_FP_ST(reg, i)                                                   \
   {                                                                            \
     #reg #i, nullptr, FP_SIZE,                                                 \
         LLVM_EXTENSION FPR_OFFSET(                                             \
             stmm[i]), eEncodingVector, eFormatVectorOfUInt8,                   \
             {ehframe_st##i##_i386, dwarf_st##i##_i386, LLDB_INVALID_REGNUM,    \
              LLDB_INVALID_REGNUM, lldb_st##i##_i386 },                         \
-             nullptr, nullptr,                                                 \
+             nullptr, nullptr, nullptr,                                        \
   }
 
 #define DEFINE_FP_MM(reg, i, streg)                                            \
   {                                                                            \
     #reg #i, nullptr, sizeof(uint64_t), LLVM_EXTENSION FPR_OFFSET(stmm[i]),    \
     eEncodingUint, eFormatHex,                                                 \
     {dwarf_mm##i##_i386, dwarf_mm##i##_i386, LLDB_INVALID_REGNUM,              \
      LLDB_INVALID_REGNUM, lldb_mm##i##_i386 },                                 \
     RegisterContextPOSIX_x86::g_contained_##streg##_32,                        \
     RegisterContextPOSIX_x86::g_invalidate_##streg##_32,                       \
+    nullptr,                                                                   \
   }
 
 #define DEFINE_XMM(reg, i)                                                     \
   {                                                                            \
     #reg #i, nullptr, XMM_SIZE,                                                \
         LLVM_EXTENSION FPR_OFFSET(                                             \
             reg[i]), eEncodingVector, eFormatVectorOfUInt8,                    \
             {ehframe_##reg##i##_i386, dwarf_##reg##i##_i386,                   \
              LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg##i##_i386 }, \
-             nullptr, nullptr,                                                 \
+             nullptr, nullptr, nullptr,                                        \
   }
 
 // I believe the YMM registers use dwarf_xmm_%_i386 register numbers and then
 // differentiate based on register size.
 #define DEFINE_YMM(reg, i)                                                     \
   {                                                                            \
     #reg #i, nullptr, YMM_SIZE,                                                \
         LLVM_EXTENSION YMM_OFFSET(i), eEncodingVector, eFormatVectorOfUInt8,   \
                                   {LLDB_INVALID_REGNUM, dwarf_xmm##i##_i386,   \
                                    LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,   \
                                    lldb_##reg##i##_i386 },                     \
-                                   nullptr, nullptr,                           \
+                                   nullptr, nullptr, nullptr,                  \
   }
 
 #define DEFINE_BNDR(reg, i)                                                    \
   {                                                                            \
     #reg #i, nullptr, BNDR_SIZE,                                               \
         LLVM_EXTENSION BNDR_OFFSET(i), eEncodingVector, eFormatVectorOfUInt64, \
         {dwarf_##reg##i##_i386, dwarf_##reg##i##_i386, LLDB_INVALID_REGNUM,    \
          LLDB_INVALID_REGNUM, lldb_##reg##i##_i386 },                          \
-         nullptr, nullptr,                                                     \
+         nullptr, nullptr, nullptr,                                            \
   }
 
 #define DEFINE_BNDC(name, i)                                                   \
   {                                                                            \
     #name, nullptr, BNDC_SIZE,                                                 \
            LLVM_EXTENSION BNDC_OFFSET(i), eEncodingVector,                     \
            eFormatVectorOfUInt8,                                               \
            {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,     \
             LLDB_INVALID_REGNUM, lldb_##name##_i386 },                         \
-            nullptr, nullptr,                                                  \
+            nullptr, nullptr, nullptr,                                         \
   }
 
 #define DEFINE_DR(reg, i)                                                      \
   {                                                                            \
     #reg #i, nullptr, DR_SIZE,                                                 \
         DR_OFFSET(i), eEncodingUint, eFormatHex,                               \
                   {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                   \
                    LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                   \
                    lldb_##reg##i##_i386 },                                     \
-                   nullptr, nullptr,                                           \
+                   nullptr, nullptr, nullptr,                                  \
   }
 
 #define DEFINE_GPR_PSEUDO_16(reg16, reg32)                                     \
   {                                                                            \
     #reg16, nullptr, 2,                                                        \
         GPR_OFFSET(reg32), eEncodingUint, eFormatHex,                          \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg16##_i386 },                                     \
                     RegisterContextPOSIX_x86::g_contained_##reg32,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg32,            \
+                    nullptr,                                                   \
   }
 
 #define DEFINE_GPR_PSEUDO_8H(reg8, reg32)                                      \
   {                                                                            \
     #reg8, nullptr, 1,                                                         \
         GPR_OFFSET(reg32) + 1, eEncodingUint, eFormatHex,                      \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg8##_i386 },                                      \
                     RegisterContextPOSIX_x86::g_contained_##reg32,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg32,            \
+                    nullptr,                                                   \
   }
 
 #define DEFINE_GPR_PSEUDO_8L(reg8, reg32)                                      \
   {                                                                            \
     #reg8, nullptr, 1,                                                         \
         GPR_OFFSET(reg32), eEncodingUint, eFormatHex,                          \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg8##_i386 },                                      \
                     RegisterContextPOSIX_x86::g_contained_##reg32,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg32,            \
+                    nullptr,                                                   \
   }
 
 static RegisterInfo g_register_infos_i386[] = {
     // General purpose registers.
     DEFINE_GPR(eax, nullptr, ehframe_eax_i386, dwarf_eax_i386,
                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),
     DEFINE_GPR(ebx, nullptr, ehframe_ebx_i386, dwarf_ebx_i386,
                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),

lldb/source/Plugins/Process/Utility/RegisterInfos_loongarch64.h

 #define FPR64_KIND(reg, generic_kind) KIND_HELPER(reg, generic_kind)
 
 // Defines a 64-bit general purpose register
 #define DEFINE_GPR64(reg, generic_kind) DEFINE_GPR64_ALT(reg, reg, generic_kind)
 #define DEFINE_GPR64_ALT(reg, alt, generic_kind)                               \
   {                                                                            \
     #reg, #alt, 8, GPR_OFFSET(gpr_##reg##_loongarch - gpr_first_loongarch),    \
     lldb::eEncodingUint, lldb::eFormatHex,                                     \
-    GPR64_KIND(gpr_##reg, generic_kind), nullptr, nullptr                      \
+    GPR64_KIND(gpr_##reg, generic_kind), nullptr, nullptr, nullptr,            \
   }
 
 // Defines a 64-bit floating point register
 #define DEFINE_FPR64(reg, generic_kind) DEFINE_FPR64_ALT(reg, reg, generic_kind)
 #define DEFINE_FPR64_ALT(reg, alt, generic_kind)                               \
   {                                                                            \
     #reg, #alt, 8, FPR_OFFSET(fpr_##reg##_loongarch - fpr_first_loongarch),    \
     lldb::eEncodingUint, lldb::eFormatHex,                                     \
-    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr                      \
+    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr, nullptr,            \
   }
 
 #define DEFINE_FCC(reg, generic_kind)                                          \
   {                                                                            \
     #reg, nullptr, 1, FCC_OFFSET(fpr_##reg##_loongarch - fpr_fcc0_loongarch),  \
     lldb::eEncodingUint, lldb::eFormatHex,                                     \
-    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr                      \
+    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr, nullptr,            \
   }
 
 #define DEFINE_FCSR(reg, generic_kind)                                         \
   {                                                                            \
     #reg, nullptr, 4, FCSR_OFFSET,                                             \
     lldb::eEncodingUint, lldb::eFormatHex,                                     \
-    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr                      \
+    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr, nullptr,            \
   }
 
 // clang-format on
 
 static lldb_private::RegisterInfo g_register_infos_loongarch64[] = {
     DEFINE_GPR64_ALT(r0, zero, LLDB_INVALID_REGNUM),
     DEFINE_GPR64_ALT(r1, ra, LLDB_REGNUM_GENERIC_RA),
     DEFINE_GPR64_ALT(r2, tp, LLDB_INVALID_REGNUM),

lldb/source/Plugins/Process/Utility/RegisterInfos_mips64.h

 
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
     #reg, alt, sizeof(((GPR_freebsd_mips *) 0)->reg),                          \
                       GPR_OFFSET(reg), eEncodingUint, eFormatHex,              \
                                  {kind1, kind2, kind3, kind4,                  \
                                   gpr_##reg##_mips64 },                        \
-                                  NULL, NULL                                   \
+                                  NULL, NULL, NULL,                            \
   }
 
 #define DEFINE_FPR(reg, alt, kind1, kind2, kind3)                              \
   {                                                                            \
     #reg, alt, sizeof(((FPR_freebsd_mips *) 0)->reg),                          \
                       FPR_OFFSET(reg), eEncodingIEEE754, eFormatFloat,         \
                                  {kind1, kind2, kind3, LLDB_INVALID_REGNUM,    \
                                   fpr_##reg##_mips64 },                        \
-                                  NULL, NULL,                                  \
+                                  NULL, NULL, NULL,                            \
   }
 
 #define DEFINE_FPR_INFO(reg, alt, kind1, kind2, kind3)                         \
   {                                                                            \
     #reg, alt, sizeof(((FPR_freebsd_mips *) 0)->reg),                          \
                       FPR_OFFSET(reg), eEncodingUint, eFormatHex,              \
                                  {kind1, kind2, kind3, LLDB_INVALID_REGNUM,    \
                                   fpr_##reg##_mips64 },                        \
-                                  NULL, NULL,                                  \
+                                  NULL, NULL, NULL,                            \
   }
 
 
 static RegisterInfo g_register_infos_mips64[] = {
 // General purpose registers.            EH_Frame,                  DWARF,
 // Generic,    Process Plugin
     DEFINE_GPR(zero, "r0", dwarf_zero_mips64, dwarf_zero_mips64,
                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM),

lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h

 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, lldb_kind)                                        \
   {                                                                            \
     #reg, alt, GPR_SIZE(reg), GPR_OFFSET(reg), eEncodingUint, eFormatHex,      \
                                          {dwarf_##reg##_powerpc,               \
                                           dwarf_##reg##_powerpc, lldb_kind,    \
                                           LLDB_INVALID_REGNUM,                 \
                                           gpr_##reg##_powerpc },               \
-                                          NULL, NULL,                          \
+                                          NULL, NULL, NULL,                    \
   }
 #define DEFINE_FPR(reg, lldb_kind)                                             \
   {                                                                            \
     #reg, NULL, 8, FPR_OFFSET(reg), eEncodingIEEE754, eFormatFloat,            \
                               {dwarf_##reg##_powerpc, dwarf_##reg##_powerpc,   \
                                lldb_kind, LLDB_INVALID_REGNUM,                 \
                                fpr_##reg##_powerpc },                          \
-                               NULL, NULL,                                     \
+                               NULL, NULL, NULL,                               \
   }
 #define DEFINE_VMX(reg, lldb_kind)                                             \
   {                                                                            \
     #reg, NULL, 16, VMX_OFFSET(reg), eEncodingVector, eFormatVectorOfUInt32,   \
                                {dwarf_##reg##_powerpc, dwarf_##reg##_powerpc,  \
                                 lldb_kind, LLDB_INVALID_REGNUM,                \
                                 vmx_##reg##_powerpc },                         \
-                                NULL, NULL,                                    \
+                                NULL, NULL, NULL,                              \
   }
 
 // General purpose registers.            EH_Frame,                  DWARF,
 // Generic,                Process Plugin
 #define POWERPC_REGS                                                           \
   DEFINE_GPR(r0, NULL, LLDB_INVALID_REGNUM)                                    \
   , DEFINE_GPR(r1, NULL, LLDB_REGNUM_GENERIC_SP),                              \
       DEFINE_GPR(r2, NULL, LLDB_INVALID_REGNUM),                               \
, DEFINE_GPR(r1, NULL, LLDB_REGNUM_GENERIC_SP),                              \
        8,                                                                      \
        FPR_OFFSET(fpscr),                                                      \
        eEncodingUint,                                                          \
        eFormatHex,                                                             \
        {dwarf_fpscr_powerpc, dwarf_fpscr_powerpc, LLDB_INVALID_REGNUM,         \
         LLDB_INVALID_REGNUM, fpr_fpscr_powerpc},                               \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
         },                                                                     \
       DEFINE_VMX(v0, LLDB_INVALID_REGNUM),                                     \
       DEFINE_VMX(v1, LLDB_INVALID_REGNUM),                                     \
       DEFINE_VMX(v2, LLDB_INVALID_REGNUM),                                     \
       DEFINE_VMX(v3, LLDB_INVALID_REGNUM),                                     \
       DEFINE_VMX(v4, LLDB_INVALID_REGNUM),                                     \
       DEFINE_VMX(v5, LLDB_INVALID_REGNUM),                                     \
       DEFINE_VMX(v6, LLDB_INVALID_REGNUM),                                     \
, DEFINE_GPR(r1, NULL, LLDB_REGNUM_GENERIC_SP),                              \
        4,                                                                      \
        VMX_OFFSET(vrsave),                                                     \
        eEncodingUint,                                                          \
        eFormatHex,                                                             \
        {dwarf_vrsave_powerpc, dwarf_vrsave_powerpc, LLDB_INVALID_REGNUM,       \
         LLDB_INVALID_REGNUM, vmx_vrsave_powerpc},                              \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
         },                                                                     \
       {"vscr",                                                                 \
        NULL,                                                                   \
        4,                                                                      \
        VMX_OFFSET(vscr),                                                       \
        eEncodingUint,                                                          \
        eFormatHex,                                                             \
        {dwarf_vscr_powerpc, dwarf_vscr_powerpc, LLDB_INVALID_REGNUM,           \
         LLDB_INVALID_REGNUM, vmx_vscr_powerpc},                                \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },
 
 static RegisterInfo g_register_infos_powerpc64[] = {
 #define GPR GPR64
     POWERPC_REGS
 #undef GPR
 };
 

lldb/source/Plugins/Process/Utility/RegisterInfos_ppc64.h

#define DEFINE_GPR_PPC64(reg, alt, lldb_kind)                                  \
   {                                                                            \
     #reg, alt, GPR_PPC64_SIZE(reg), GPR_PPC64_OFFSET(reg), lldb::eEncodingUint,\
                                          lldb::eFormatHex,                     \
                                          {ppc64_dwarf::dwarf_##reg##_ppc64,    \
                                           ppc64_dwarf::dwarf_##reg##_ppc64,    \
                                           lldb_kind,                           \
                                           LLDB_INVALID_REGNUM,                 \
                                           gpr_##reg##_ppc64 },                 \
-                                          NULL, NULL,                          \
+                                          NULL, NULL, NULL,                    \
   }
 #define DEFINE_FPR_PPC64(reg, alt, lldb_kind)                                  \
   {                                                                            \
 #reg, alt, 8, FPR_PPC64_OFFSET(reg), lldb::eEncodingIEEE754,                   \
         lldb::eFormatFloat,                                                    \
         {ppc64_dwarf::dwarf_##reg##_ppc64,                                     \
          ppc64_dwarf::dwarf_##reg##_ppc64, lldb_kind, LLDB_INVALID_REGNUM,     \
          fpr_##reg##_ppc64 },                                                  \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 #define DEFINE_VMX_PPC64(reg, lldb_kind)                                       \
   {                                                                            \
 #reg, NULL, 16, VMX_PPC64_OFFSET(reg), lldb::eEncodingVector,                  \
         lldb::eFormatVectorOfUInt32,                                           \
         {ppc64_dwarf::dwarf_##reg##_ppc64,                                     \
          ppc64_dwarf::dwarf_##reg##_ppc64, lldb_kind, LLDB_INVALID_REGNUM,     \
          vmx_##reg##_ppc64 },                                                  \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 
 // General purpose registers.
 // EH_Frame, Generic, Process Plugin
 #define PPC64_REGS                                                             \
   DEFINE_GPR_PPC64(r0, NULL, LLDB_INVALID_REGNUM)                              \
   , DEFINE_GPR_PPC64(r1, NULL, LLDB_REGNUM_GENERIC_SP),                        \
       DEFINE_GPR_PPC64(r2, NULL, LLDB_INVALID_REGNUM),                         \
, DEFINE_GPR_PPC64(r1, NULL, LLDB_REGNUM_GENERIC_SP),                        \
        FPR_PPC64_OFFSET(fpscr),                                                \
        lldb::eEncodingUint,                                                    \
        lldb::eFormatHex,                                                       \
        {ppc64_dwarf::dwarf_fpscr_ppc64,                                        \
         ppc64_dwarf::dwarf_fpscr_ppc64, LLDB_INVALID_REGNUM,                   \
         LLDB_INVALID_REGNUM, fpr_fpscr_ppc64},                                 \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },                                                                      \
       DEFINE_VMX_PPC64(vr0, LLDB_INVALID_REGNUM),                              \
       DEFINE_VMX_PPC64(vr1, LLDB_INVALID_REGNUM),                              \
       DEFINE_VMX_PPC64(vr2, LLDB_INVALID_REGNUM),                              \
       DEFINE_VMX_PPC64(vr3, LLDB_INVALID_REGNUM),                              \
       DEFINE_VMX_PPC64(vr4, LLDB_INVALID_REGNUM),                              \
       DEFINE_VMX_PPC64(vr5, LLDB_INVALID_REGNUM),                              \
       DEFINE_VMX_PPC64(vr6, LLDB_INVALID_REGNUM),                              \
, DEFINE_GPR_PPC64(r1, NULL, LLDB_REGNUM_GENERIC_SP),                        \
        4,                                                                      \
        VMX_PPC64_OFFSET(vscr),                                                 \
        lldb::eEncodingUint,                                                    \
        lldb::eFormatHex,                                                       \
        {ppc64_dwarf::dwarf_vscr_ppc64, ppc64_dwarf::dwarf_vscr_ppc64,          \
         LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, vmx_vscr_ppc64},             \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },                                                                      \
       {"vrsave",                                                               \
        NULL,                                                                   \
        4,                                                                      \
        VMX_PPC64_OFFSET(vrsave),                                               \
        lldb::eEncodingUint,                                                    \
        lldb::eFormatHex,                                                       \
        {ppc64_dwarf::dwarf_vrsave_ppc64,                                       \
         ppc64_dwarf::dwarf_vrsave_ppc64, LLDB_INVALID_REGNUM,                  \
         LLDB_INVALID_REGNUM, vmx_vrsave_ppc64},                                \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },  /* */
 
 typedef struct _GPR_PPC64 {
   uint64_t r0;
   uint64_t r1;
   uint64_t r2;
   uint64_t r3;
   uint64_t r4;

lldb/source/Plugins/Process/Utility/RegisterInfos_ppc64le.h

#define DEFINE_GPR(reg, alt, lldb_kind)                                        \
   {                                                                            \
     #reg, alt, GPR_SIZE(reg), GPR_OFFSET(reg), lldb::eEncodingUint,            \
                                          lldb::eFormatHex,                     \
                                          {ppc64le_dwarf::dwarf_##reg##_ppc64le,\
                                           ppc64le_dwarf::dwarf_##reg##_ppc64le,\
                                           lldb_kind,                           \
                                           LLDB_INVALID_REGNUM,                 \
                                           gpr_##reg##_ppc64le },               \
-                                          NULL, NULL,                          \
+                                          NULL, NULL, NULL,                    \
   }
 #define DEFINE_FPR(reg, alt, lldb_kind)                                        \
   {                                                                            \
 #reg, alt, 8, FPR_OFFSET(reg), lldb::eEncodingIEEE754, lldb::eFormatFloat, \
         {ppc64le_dwarf::dwarf_##reg##_ppc64le,                                 \
          ppc64le_dwarf::dwarf_##reg##_ppc64le, lldb_kind, LLDB_INVALID_REGNUM, \
          fpr_##reg##_ppc64le },                                                \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 #define DEFINE_VMX(reg, lldb_kind)                                             \
   {                                                                            \
 #reg, NULL, 16, VMX_OFFSET(reg), lldb::eEncodingVector,                    \
         lldb::eFormatVectorOfUInt32,                                           \
         {ppc64le_dwarf::dwarf_##reg##_ppc64le,                                 \
          ppc64le_dwarf::dwarf_##reg##_ppc64le, lldb_kind, LLDB_INVALID_REGNUM, \
          vmx_##reg##_ppc64le },                                                \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 #define DEFINE_VSX(reg, lldb_kind)                                             \
   {                                                                            \
 #reg, NULL, 16, VSX_OFFSET(reg), lldb::eEncodingVector,                    \
         lldb::eFormatVectorOfUInt32,                                           \
         {ppc64le_dwarf::dwarf_##reg##_ppc64le,                                 \
          ppc64le_dwarf::dwarf_##reg##_ppc64le, lldb_kind, LLDB_INVALID_REGNUM, \
          vsx_##reg##_ppc64le },                                                \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 
 // General purpose registers.
 // EH_Frame, Generic, Process Plugin
 #define POWERPC_REGS                                                           \
   DEFINE_GPR(r0, NULL, LLDB_INVALID_REGNUM)                                    \
   , DEFINE_GPR(r1, NULL, LLDB_REGNUM_GENERIC_SP),                              \
       DEFINE_GPR(r2, NULL, LLDB_INVALID_REGNUM),                               \
, DEFINE_GPR(r1, NULL, LLDB_REGNUM_GENERIC_SP),                              \
        FPR_OFFSET(fpscr),                                                      \
        lldb::eEncodingUint,                                                    \
        lldb::eFormatHex,                                                       \
        {ppc64le_dwarf::dwarf_fpscr_ppc64le,                                    \
         ppc64le_dwarf::dwarf_fpscr_ppc64le, LLDB_INVALID_REGNUM,               \
         LLDB_INVALID_REGNUM, fpr_fpscr_ppc64le},                               \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },                                                                     \
       DEFINE_VMX(vr0, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VMX(vr1, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VMX(vr2, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VMX(vr3, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VMX(vr4, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VMX(vr5, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VMX(vr6, LLDB_INVALID_REGNUM),                                    \
, DEFINE_GPR(r1, NULL, LLDB_REGNUM_GENERIC_SP),                              \
        4,                                                                      \
        VMX_OFFSET(vscr),                                                       \
        lldb::eEncodingUint,                                                    \
        lldb::eFormatHex,                                                       \
        {ppc64le_dwarf::dwarf_vscr_ppc64le, ppc64le_dwarf::dwarf_vscr_ppc64le,  \
         LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, vmx_vscr_ppc64le},           \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },                                                                     \
       {"vrsave",                                                               \
        NULL,                                                                   \
        4,                                                                      \
        VMX_OFFSET(vrsave),                                                     \
        lldb::eEncodingUint,                                                    \
        lldb::eFormatHex,                                                       \
        {ppc64le_dwarf::dwarf_vrsave_ppc64le,                                   \
         ppc64le_dwarf::dwarf_vrsave_ppc64le, LLDB_INVALID_REGNUM,              \
         LLDB_INVALID_REGNUM, vmx_vrsave_ppc64le},                              \
        NULL,                                                                   \
        NULL,                                                                   \
+       NULL,                                                                   \
        },                                                                     \
       DEFINE_VSX(vs0, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VSX(vs1, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VSX(vs2, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VSX(vs3, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VSX(vs4, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VSX(vs5, LLDB_INVALID_REGNUM),                                    \
       DEFINE_VSX(vs6, LLDB_INVALID_REGNUM),                                    \

lldb/source/Plugins/Process/Utility/RegisterInfos_riscv64.h

 // Defines a 64-bit general purpose register
 #define DEFINE_GPR64(reg, generic_kind) DEFINE_GPR64_ALT(reg, reg, generic_kind)
 
 // Defines a 64-bit general purpose register
 #define DEFINE_GPR64_ALT(reg, alt, generic_kind)                               \
   {                                                                            \
     #reg, #alt, 8, GPR_OFFSET(gpr_##reg##_riscv - gpr_first_riscv),            \
     lldb::eEncodingUint, lldb::eFormatHex,                                     \
-    GPR64_KIND(gpr_##reg, generic_kind), nullptr, nullptr                      \
+    GPR64_KIND(gpr_##reg, generic_kind), nullptr, nullptr, nullptr,            \
   }
 
 #define DEFINE_FPR64(reg, generic_kind) DEFINE_FPR64_ALT(reg, reg, generic_kind)
 
 #define DEFINE_FPR64_ALT(reg, alt, generic_kind) DEFINE_FPR_ALT(reg, alt, 8, generic_kind)
 
 #define DEFINE_FPR_ALT(reg, alt, size, generic_kind)                           \
   {                                                                            \
     #reg, #alt, size, FPR_OFFSET(fpr_##reg##_riscv - fpr_first_riscv),         \
     lldb::eEncodingUint, lldb::eFormatHex,                                     \
-    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr                      \
+    FPR64_KIND(fpr_##reg, generic_kind), nullptr, nullptr, nullptr,           \
   }
 
 // clang-format on
 
 static lldb_private::RegisterInfo g_register_infos_riscv64_le[] = {
     // DEFINE_GPR64(name, GENERIC KIND)
     DEFINE_GPR64(pc, LLDB_REGNUM_GENERIC_PC),
     DEFINE_GPR64_ALT(ra, x1, LLDB_REGNUM_GENERIC_RA),

lldb/source/Plugins/Process/Utility/RegisterInfos_s390x.h

 
 // RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB
 
 #define DEFINE_GPR(name, size, offset, alt, generic)                           \
   {                                                                            \
     #name, alt, size, offset, eEncodingUint, eFormatHex,                       \
         {dwarf_##name##_s390x, dwarf_##name##_s390x, generic,                  \
          LLDB_INVALID_REGNUM, lldb_##name##_s390x },                           \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 
 #define DEFINE_GPR_NODWARF(name, size, offset, alt, generic)                   \
   {                                                                            \
     #name, alt, size, offset, eEncodingUint, eFormatHex,                       \
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, generic,                    \
          LLDB_INVALID_REGNUM, lldb_##name##_s390x },                           \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 
 #define DEFINE_FPR(name, size, offset)                                         \
   {                                                                            \
     #name, NULL, size, offset, eEncodingUint, eFormatHex,                      \
         {dwarf_##name##_s390x, dwarf_##name##_s390x, LLDB_INVALID_REGNUM,      \
          LLDB_INVALID_REGNUM, lldb_##name##_s390x },                           \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 
 #define DEFINE_FPR_NODWARF(name, size, offset)                                 \
   {                                                                            \
     #name, NULL, size, offset, eEncodingUint, eFormatHex,                      \
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,        \
          LLDB_INVALID_REGNUM, lldb_##name##_s390x },                           \
-         NULL, NULL,                                                           \
+         NULL, NULL, NULL,                                                     \
   }
 
 static RegisterInfo g_register_infos_s390x[] = {
     // General purpose registers.
     DEFINE_GPR(r0, 8, GPR_OFFSET(0), nullptr, LLDB_INVALID_REGNUM),
     DEFINE_GPR(r1, 8, GPR_OFFSET(1), nullptr, LLDB_INVALID_REGNUM),
     DEFINE_GPR(r2, 8, GPR_OFFSET(2), nullptr, LLDB_REGNUM_GENERIC_ARG1),
     DEFINE_GPR(r3, 8, GPR_OFFSET(3), nullptr, LLDB_REGNUM_GENERIC_ARG2),

lldb/source/Plugins/Process/Utility/RegisterInfos_x86_64.h

 
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)                       \
   {                                                                            \
     #reg, alt, sizeof(((GPR *)nullptr)->reg),                                  \
                       GPR_OFFSET(reg), eEncodingUint, eFormatHex,              \
                                  {kind1, kind2, kind3, kind4,                  \
                                   lldb_##reg##_x86_64 },                       \
-                                  nullptr, nullptr,                            \
+                                  nullptr, nullptr, nullptr,                   \
   }
 
 #define DEFINE_FPR(name, reg, kind1, kind2, kind3, kind4)                      \
   {                                                                            \
     #name, nullptr, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, eFormatHex, \
                                            {kind1, kind2, kind3, kind4,        \
                                             lldb_##name##_x86_64 },            \
-                                            nullptr, nullptr,                  \
+                                            nullptr, nullptr, nullptr,         \
   }
 
 #define DEFINE_FP_ST(reg, i)                                                   \
   {                                                                            \
     #reg #i, nullptr, FP_SIZE,                                                 \
         LLVM_EXTENSION FPR_OFFSET(                                             \
             stmm[i]), eEncodingVector, eFormatVectorOfUInt8,                   \
             {dwarf_st##i##_x86_64, dwarf_st##i##_x86_64, LLDB_INVALID_REGNUM,  \
              LLDB_INVALID_REGNUM, lldb_st##i##_x86_64 },                       \
-             nullptr, nullptr,                                                 \
+             nullptr, nullptr, nullptr,                                        \
   }
 
 #define DEFINE_FP_MM(reg, i, streg)                                            \
   {                                                                            \
     #reg #i, nullptr, sizeof(uint64_t), LLVM_EXTENSION FPR_OFFSET(stmm[i]),    \
     eEncodingUint, eFormatHex,                                                 \
     {dwarf_mm##i##_x86_64, dwarf_mm##i##_x86_64, LLDB_INVALID_REGNUM,          \
      LLDB_INVALID_REGNUM, lldb_mm##i##_x86_64 },                               \
     RegisterContextPOSIX_x86::g_contained_##streg##_64,                        \
     RegisterContextPOSIX_x86::g_invalidate_##streg##_64,                       \
+    nullptr,                                                                   \
   }
 
 #define DEFINE_XMM(reg, i)                                                     \
   {                                                                            \
     #reg #i, nullptr, XMM_SIZE,                                                \
         LLVM_EXTENSION FPR_OFFSET(                                             \
             reg[i]), eEncodingVector, eFormatVectorOfUInt8,                    \
             {dwarf_##reg##i##_x86_64, dwarf_##reg##i##_x86_64,                 \
              LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                         \
              lldb_##reg##i##_x86_64 },                                         \
-             nullptr, nullptr,                                                 \
+             nullptr, nullptr, nullptr,                                        \
   }
 
 #define DEFINE_YMM(reg, i)                                                     \
   {                                                                            \
     #reg #i, nullptr, YMM_SIZE,                                                \
         LLVM_EXTENSION YMM_OFFSET(i), eEncodingVector, eFormatVectorOfUInt8,   \
                                   {dwarf_##reg##i##h_x86_64,                   \
                                    dwarf_##reg##i##h_x86_64,                   \
                                    LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,   \
                                    lldb_##reg##i##_x86_64 },                   \
-                                   nullptr, nullptr,                           \
+                                   nullptr, nullptr, nullptr,                  \
   }
 
 #define DEFINE_BNDR(reg, i)                                                    \
   {                                                                            \
     #reg #i, nullptr, BNDR_SIZE,                                               \
         LLVM_EXTENSION BNDR_OFFSET(i), eEncodingVector, eFormatVectorOfUInt64, \
                                    {dwarf_##reg##i##_x86_64,                   \
                                     dwarf_##reg##i##_x86_64,                   \
                                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,  \
                                     lldb_##reg##i##_x86_64 },                  \
-                                    nullptr, nullptr,                          \
+                                    nullptr, nullptr, nullptr,                 \
   }
 
 #define DEFINE_BNDC(name, i)                                                   \
   {                                                                            \
     #name, nullptr, BNDC_SIZE,                                                 \
         LLVM_EXTENSION BNDC_OFFSET(i), eEncodingVector, eFormatVectorOfUInt8,  \
         {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,        \
          LLDB_INVALID_REGNUM, lldb_##name##_x86_64 },                          \
-         nullptr, nullptr,                                                     \
+         nullptr, nullptr, nullptr,                                            \
   }
 
 #define DEFINE_DR(reg, i)                                                      \
   {                                                                            \
     #reg #i, nullptr, DR_SIZE,                                                 \
         DR_OFFSET(i), eEncodingUint, eFormatHex,                               \
                   {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                   \
                    LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                   \
                    lldb_##reg##i##_x86_64 },                                   \
-                   nullptr, nullptr,                                           \
+                   nullptr, nullptr, nullptr,                                  \
   }
 
 #define DEFINE_GPR_PSEUDO_32(reg32, reg64)                                     \
   {                                                                            \
     #reg32, nullptr, 4,                                                        \
         GPR_OFFSET(reg64), eEncodingUint, eFormatHex,                          \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg32##_x86_64 },                                   \
                     RegisterContextPOSIX_x86::g_contained_##reg64,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg64,            \
+                    nullptr,                                                   \
   }
 
 #define DEFINE_GPR_PSEUDO_16(reg16, reg64)                                     \
   {                                                                            \
     #reg16, nullptr, 2,                                                        \
         GPR_OFFSET(reg64), eEncodingUint, eFormatHex,                          \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg16##_x86_64 },                                   \
                     RegisterContextPOSIX_x86::g_contained_##reg64,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg64,            \
+                    nullptr,                                                   \
   }
 
 #define DEFINE_GPR_PSEUDO_8H(reg8, reg64)                                      \
   {                                                                            \
     #reg8, nullptr, 1,                                                         \
         GPR_OFFSET(reg64) + 1, eEncodingUint, eFormatHex,                      \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg8##_x86_64 },                                    \
                     RegisterContextPOSIX_x86::g_contained_##reg64,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg64,            \
+                    nullptr,                                                   \
   }
 
 #define DEFINE_GPR_PSEUDO_8L(reg8, reg64)                                      \
   {                                                                            \
     #reg8, nullptr, 1,                                                         \
         GPR_OFFSET(reg64), eEncodingUint, eFormatHex,                          \
                    {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,                  \
                     lldb_##reg8##_x86_64 },                                    \
                     RegisterContextPOSIX_x86::g_contained_##reg64,             \
                     RegisterContextPOSIX_x86::g_invalidate_##reg64,            \
+                    nullptr                                                    \
   }
 
 #define DEFINE_FPR_32(name, reg, kind1, kind2, kind3, kind4, reg64)            \
   {                                                                            \
     #name, nullptr, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, eFormatHex, \
     {kind1, kind2, kind3, kind4, lldb_##name##_x86_64 },                       \
     RegisterContextPOSIX_x86::g_contained_##reg64,                             \
     RegisterContextPOSIX_x86::g_invalidate_##reg64,                            \
+    nullptr,                                                                   \
   }
 
 // clang-format off
 static RegisterInfo g_register_infos_x86_64[] = {
 // General purpose registers     EH_Frame              DWARF                 Generic                     Process Plugin
 //  ===========================  ==================    ================      =========================   ====================
     DEFINE_GPR(rax,    nullptr,  dwarf_rax_x86_64,     dwarf_rax_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),
     DEFINE_GPR(rbx,    nullptr,  dwarf_rbx_x86_64,     dwarf_rbx_x86_64,     LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM),

lldb/source/Plugins/Process/Windows/Common/arm/RegisterContextWindows_arm.cpp

 #define DBG_OFFSET_NAME(reg) 0
 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL,                                                                  \
       0, DBG_OFFSET_NAME(reg[i]), eEncodingUint, eFormatHex,                   \
                               {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM },                          \
-                               NULL, NULL
+                               NULL, NULL, NULL
 
 // Include RegisterInfos_arm to declare our g_register_infos_arm structure.
 #define DECLARE_REGISTER_INFOS_ARM_STRUCT
 #include "Plugins/Process/Utility/RegisterInfos_arm.h"
 #undef DECLARE_REGISTER_INFOS_ARM_STRUCT
 
 static size_t k_num_register_infos = std::size(g_register_infos_arm);
 

lldb/source/Plugins/Process/Windows/Common/arm64/RegisterContextWindows_arm64.cpp

 #define DBG_OFFSET_NAME(reg) 0
 
 #define DEFINE_DBG(reg, i)                                                     \
   #reg, NULL,                                                                  \
       0, DBG_OFFSET_NAME(reg[i]), eEncodingUint, eFormatHex,                   \
                               {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,       \
                                LLDB_INVALID_REGNUM },                          \
-                               NULL, NULL
+                               NULL, NULL, NULL
 
 // Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure.
 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT
 #include "Plugins/Process/Utility/RegisterInfos_arm64.h"
 #undef DECLARE_REGISTER_INFOS_ARM64_STRUCT
 
 static size_t k_num_register_infos = std::size(g_register_infos_arm64_le);
 

lldb/source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

RegisterInfo g_register_infos[] = {
     //  ==============================  =======================
     //  ===================  =========================  ===================
     //  =================  ==========    ===============
     {DEFINE_GPR(eax, nullptr),
      {ehframe_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_eax_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ebx, nullptr),
      {ehframe_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_ebx_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ecx, nullptr),
      {ehframe_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_ecx_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(edx, nullptr),
      {ehframe_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_edx_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(edi, nullptr),
      {ehframe_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_edi_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(esi, nullptr),
      {ehframe_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_esi_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(ebp, "fp"),
      {ehframe_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP,
       LLDB_INVALID_REGNUM, lldb_ebp_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(esp, "sp"),
      {ehframe_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP,
       LLDB_INVALID_REGNUM, lldb_esp_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR(eip, "pc"),
      {ehframe_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC,
       LLDB_INVALID_REGNUM, lldb_eip_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
     {DEFINE_GPR_BIN(eflags, "flags"),
      {ehframe_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS,
       LLDB_INVALID_REGNUM, lldb_eflags_i386},
      nullptr,
      nullptr,
+     nullptr,
     },
 };
 static size_t k_num_register_infos = std::size(g_register_infos);
 
 // Array of lldb register numbers used to define the set of all General Purpose
 // Registers
 uint32_t g_gpr_reg_indices[] = {eRegisterIndexEax, eRegisterIndexEbx,
                                 eRegisterIndexEcx, eRegisterIndexEdx,

lldb/source/Plugins/Process/minidump/RegisterContextMinidump_ARM.cpp

 
 #define INV LLDB_INVALID_REGNUM
 #define OFFSET(r) (offsetof(RegisterContextMinidump_ARM::Context, r))
 
 #define DEF_R(i)                                                               \
   {                                                                            \
     "r" #i, nullptr, 4, OFFSET(r) + i * 4, eEncodingUint, eFormatHex,          \
         {ehframe_r##i, dwarf_r##i, INV, INV, reg_r##i}, nullptr, nullptr,      \
+        nullptr,                                                               \
   }
 
 #define DEF_R_ARG(i, n)                                                        \
   {                                                                            \
     "r" #i, "arg" #n, 4, OFFSET(r) + i * 4, eEncodingUint, eFormatHex,         \
         {ehframe_r##i, dwarf_r##i, LLDB_REGNUM_GENERIC_ARG1 + i, INV,          \
          reg_r##i},                                                            \
-        nullptr, nullptr,                                                      \
+        nullptr, nullptr, nullptr,                                             \
   }
 
 #define DEF_D(i)                                                               \
   {                                                                            \
     "d" #i, nullptr, 8, OFFSET(d) + i * 8, eEncodingVector,                    \
         eFormatVectorOfUInt8, {dwarf_d##i, dwarf_d##i, INV, INV, reg_d##i},    \
-        nullptr, nullptr,                                                      \
+        nullptr, nullptr, nullptr,                                             \
   }
 
 #define DEF_S(i)                                                               \
   {                                                                            \
     "s" #i, nullptr, 4, OFFSET(s) + i * 4, eEncodingIEEE754, eFormatFloat,     \
         {dwarf_s##i, dwarf_s##i, INV, INV, reg_s##i}, nullptr, nullptr,        \
+        nullptr,                                                               \
   }
 
 #define DEF_Q(i)                                                               \
   {                                                                            \
     "q" #i, nullptr, 16, OFFSET(q) + i * 16, eEncodingVector,                  \
         eFormatVectorOfUInt8, {dwarf_q##i, dwarf_q##i, INV, INV, reg_q##i},    \
-        nullptr, nullptr,                                                      \
+        nullptr, nullptr, nullptr,                                             \
   }
 
 // Zero based LLDB register numbers for this register context
 enum {
   // General Purpose Registers
   reg_r0,
   reg_r1,
   reg_r2,
static RegisterInfo g_reg_info_apple_fp = {
     "r7",
     4,
     OFFSET(r) + 7 * 4,
     eEncodingUint,
     eFormatHex,
     {ehframe_r7, dwarf_r7, LLDB_REGNUM_GENERIC_FP, INV, reg_r7},
     nullptr,
     nullptr,
+    nullptr,
 };
 
 static RegisterInfo g_reg_info_fp = {
     "fp",
     "r11",
     4,
     OFFSET(r) + 11 * 4,
     eEncodingUint,
     eFormatHex,
     {ehframe_r11, dwarf_r11, LLDB_REGNUM_GENERIC_FP, INV, reg_r11},
     nullptr,
     nullptr,
+    nullptr,
 };
 
 // Register info definitions for this register context
 static RegisterInfo g_reg_infos[] = {
     DEF_R_ARG(0, 1),
     DEF_R_ARG(1, 2),
     DEF_R_ARG(2, 3),
     DEF_R_ARG(3, 4),
static RegisterInfo g_reg_infos[] = {
      "r13",
      4,
      OFFSET(r) + 13 * 4,
      eEncodingUint,
      eFormatHex,
      {ehframe_sp, dwarf_sp, LLDB_REGNUM_GENERIC_SP, INV, reg_sp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lr",
      "r14",
      4,
      OFFSET(r) + 14 * 4,
      eEncodingUint,
      eFormatHex,
      {ehframe_lr, dwarf_lr, LLDB_REGNUM_GENERIC_RA, INV, reg_lr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      "r15",
      4,
      OFFSET(r) + 15 * 4,
      eEncodingUint,
      eFormatHex,
      {ehframe_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, INV, reg_pc},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"cpsr",
      "psr",
      4,
      OFFSET(cpsr),
      eEncodingUint,
      eFormatHex,
      {ehframe_cpsr, dwarf_cpsr, LLDB_REGNUM_GENERIC_FLAGS, INV, reg_cpsr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fpscr",
      nullptr,
      8,
      OFFSET(fpscr),
      eEncodingUint,
      eFormatHex,
      {INV, INV, INV, INV, reg_fpscr},
      nullptr,
      nullptr,
+     nullptr,
     },
     DEF_D(0),
     DEF_D(1),
     DEF_D(2),
     DEF_D(3),
     DEF_D(4),
     DEF_D(5),
     DEF_D(6),

lldb/source/Plugins/Process/minidump/RegisterContextMinidump_ARM64.cpp

 
 #define INV LLDB_INVALID_REGNUM
 #define OFFSET(r) (offsetof(RegisterContextMinidump_ARM64::Context, r))
 
 #define DEF_X(i)                                                               \
   {                                                                            \
     "x" #i, nullptr, 8, OFFSET(x) + i * 8, eEncodingUint, eFormatHex,          \
         {arm64_dwarf::x##i, arm64_dwarf::x##i, INV, INV, reg_x##i},            \
-        nullptr, nullptr,                                                      \
+        nullptr, nullptr, nullptr,                                             \
   }
 
 #define DEF_W(i)                                                               \
   {                                                                            \
     "w" #i, nullptr, 4, OFFSET(x) + i * 8, eEncodingUint, eFormatHex,          \
-        {INV, INV, INV, INV, reg_w##i}, nullptr, nullptr,                      \
+        {INV, INV, INV, INV, reg_w##i}, nullptr, nullptr, nullptr,             \
   }
 
 #define DEF_X_ARG(i, n)                                                        \
   {                                                                            \
     "x" #i, "arg" #n, 8, OFFSET(x) + i * 8, eEncodingUint, eFormatHex,         \
         {arm64_dwarf::x##i, arm64_dwarf::x##i, LLDB_REGNUM_GENERIC_ARG1 + i,   \
-         INV, reg_x##i}, nullptr, nullptr,                                     \
+         INV, reg_x##i}, nullptr, nullptr, nullptr,                            \
   }
 
 #define DEF_V(i)                                                               \
   {                                                                            \
     "v" #i, nullptr, 16, OFFSET(v) + i * 16, eEncodingVector,                  \
         eFormatVectorOfUInt8, {arm64_dwarf::v##i, arm64_dwarf::v##i, INV, INV, \
-        reg_v##i}, nullptr, nullptr,                                           \
+        reg_v##i}, nullptr, nullptr, nullptr,                                  \
   }
 
 #define DEF_D(i)                                                               \
   {                                                                            \
     "d" #i, nullptr, 8, OFFSET(v) + i * 16, eEncodingVector,                   \
         eFormatVectorOfUInt8, {INV, INV, INV, INV, reg_d##i}, nullptr,         \
-        nullptr,                                                               \
+        nullptr, nullptr,                                                      \
   }
 
 #define DEF_S(i)                                                               \
   {                                                                            \
     "s" #i, nullptr, 4, OFFSET(v) + i * 16, eEncodingVector,                   \
         eFormatVectorOfUInt8, {INV, INV, INV, INV, reg_s##i}, nullptr,         \
-        nullptr,                                                               \
+        nullptr, nullptr,                                                      \
   }
 
 #define DEF_H(i)                                                               \
   {                                                                            \
     "h" #i, nullptr, 2, OFFSET(v) + i * 16, eEncodingVector,                   \
         eFormatVectorOfUInt8, {INV, INV, INV, INV, reg_h##i}, nullptr,         \
-        nullptr,                                                               \
+        nullptr, nullptr,                                                      \
   }
 
 // Zero based LLDB register numbers for this register context
 enum {
   // General Purpose Registers
   reg_x0 = 0,
   reg_x1,
   reg_x2,
static RegisterInfo g_reg_infos[] = {
      "x29",
      8,
      OFFSET(x) + 29 * 8,
      eEncodingUint,
      eFormatHex,
      {arm64_dwarf::x29, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP, INV, reg_fp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"lr",
      "x30",
      8,
      OFFSET(x) + 30 * 8,
      eEncodingUint,
      eFormatHex,
      {arm64_dwarf::x30, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA, INV, reg_lr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"sp",
      "x31",
      8,
      OFFSET(x) + 31 * 8,
      eEncodingUint,
      eFormatHex,
      {arm64_dwarf::x31, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP, INV, reg_sp},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"pc",
      nullptr,
      8,
      OFFSET(pc),
      eEncodingUint,
      eFormatHex,
      {arm64_dwarf::pc, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC, INV, reg_pc},
      nullptr,
      nullptr,
+     nullptr,
     },
     // w0 - w31
     DEF_W(0),
     DEF_W(1),
     DEF_W(2),
     DEF_W(3),
     DEF_W(4),
     DEF_W(5),
static RegisterInfo g_reg_infos[] = {
      "psr",
      4,
      OFFSET(cpsr),
      eEncodingUint,
      eFormatHex,
      {INV, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS, INV, reg_cpsr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fpsr",
      nullptr,
      4,
      OFFSET(fpsr),
      eEncodingUint,
      eFormatHex,
      {INV, INV, INV, INV, reg_fpsr},
      nullptr,
      nullptr,
+     nullptr,
     },
     {"fpcr",
      nullptr,
      4,
      OFFSET(fpcr),
      eEncodingUint,
      eFormatHex,
      {INV, INV, INV, INV, reg_fpcr},
      nullptr,
      nullptr,
+     nullptr,
     },
     // v0 - v31
     DEF_V(0),
     DEF_V(1),
     DEF_V(2),
     DEF_V(3),
     DEF_V(4),
     DEF_V(5),

lldb/source/Target/DynamicRegisterInfo.cpp

for (auto it : llvm::enumerate(regs)) {
     }
 
     struct RegisterInfo reg_info {
       reg.name.AsCString(), reg.alt_name.AsCString(), reg.byte_size,
           reg.byte_offset, reg.encoding, reg.format,
           {reg.regnum_ehframe, reg.regnum_dwarf, reg.regnum_generic,
            reg.regnum_remote, local_regnum},
           // value_regs and invalidate_regs are filled by Finalize()
-          nullptr, nullptr
+          nullptr, nullptr, nullptr
     };
 
     m_regs.push_back(reg_info);
 
     uint32_t set = GetRegisterSetIndexByName(reg.set_name, true);
     assert(set < m_sets.size());
     assert(set < m_set_reg_nums.size());
     assert(set < m_set_names.size());

lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp

RegisterInfo Info = {
           LLDB_INVALID_REGNUM, // eh_frame reg num
           LLDB_INVALID_REGNUM, // DWARF reg num
           LLDB_INVALID_REGNUM, // generic reg num
           LLDB_INVALID_REGNUM, // process plugin reg num
           LLDB_INVALID_REGNUM  // native register number
       },
       nullptr,
       nullptr,
+      nullptr,
   };
   Info.name = ConstString(Elements["name"]).GetCString();
   if (!Info.name)
     return make_parsing_error("qRegisterInfo: name");
 
   Info.alt_name = ConstString(Elements["alt-name"]).GetCString();
 
   if (!to_integer(Elements["bitsize"], Info.byte_size, 10))