Better support for registers beyond those in user_regs_struct

Include the other register sets we care about in the CoreRegisters in
general - I started this for aarch64, and it made sense to homogenize it
for other platforms, and make the support more sane.

The use of archreg.h has just become too cumbersome, so retire that, and
actually do the register get/set for DWARF register numbers in C++ code
rather than macro hacks, with separate functions for each platform

We no longer mark all the registers we know about in the call frame
info, so when unwinding, we just now copy the entire register set as a
struct copy, then just apply the non-default changes on top of that, so
it's simpler, and likely faster

I need to add better support for dealing with registers bigger than
uintmax_t, but this is still strictly an improvement over what was there
before, I think

Author: peadar

.gitignore

@@ -17,3 +17,4 @@ build
 .clang-tidy
 py311
 compile_commands.json
+arm

arch.cc

@@ -0,0 +1,8 @@
+// Copyright (c) 2025 Arista Networks, Inc.  All rights reserved.
+// Arista Networks, Inc. Confidential and Proprietary.
+
+#include <cstdint>
+#include "libpstack/arch.h"
+
+namespace pstack::Procman {
+}

dwarf_frame.cc

@@ -274,11 +274,6 @@ CallFrame::CallFrame()
 {
     cfaReg = 0;
     cfaValue.type = UNDEF;
-#define REGMAP(number, field) registers[number].type = ARCH;
-#include "libpstack/archreg.h"
-#undef REGMAP
-#ifdef CFA_RESTORE_REGNO
-#endif
 }
 
 CallFrame

dwarf_info.cc

@@ -218,6 +218,8 @@ Abbreviation::Abbreviation(DWARFReader &r)
     , sorted(false)
     , nextSibIdx(-1)
 {
+    forms.reserve(4);
+    attrName2Idx.reserve(4);
     for (size_t i = 0;; ++i) {
         auto name = AttrName(r.getuleb128());
         auto form = Form(r.getuleb128());
@@ -229,6 +231,8 @@ Abbreviation::Abbreviation(DWARFReader &r)
         forms.emplace_back(form, value);
         attrName2Idx.emplace_back(name, i);
     }
+    attrName2Idx.shrink_to_fit();
+    forms.shrink_to_fit();
 }
 
 std::unique_ptr<LineInfo>

dwarfproc.cc

@@ -1,3 +1,4 @@
+#include "libpstack/arch.h"
 #include "libpstack/dwarf.h"
 #include "libpstack/elf.h"
 #include "libpstack/proc.h"
@@ -7,31 +8,28 @@
 extern std::ostream & operator << (std::ostream &os, const pstack::Dwarf::DIE &);
 
 namespace pstack::Procman {
-void
-StackFrame::setCoreRegs(const Elf::CoreRegisters &sys)
-{
-#define REGMAP(number, field) Elf::setReg(regs, number, sys.field);
-#include "libpstack/archreg.h"
-#undef REGMAP
-}
 
-void
-StackFrame::getCoreRegs(Elf::CoreRegisters &core) const
-{
-#define REGMAP(number, field) core.field = Elf::getReg(regs, number);
-#include "libpstack/archreg.h"
-#undef REGMAP
+struct RegisterFromReader {
+   const Reader &reader;
+   off_t offset;
+public:
+   explicit RegisterFromReader(const Reader &reader, off_t offset) : reader(reader), offset(offset) { }
+};
+
+template <typename T>
+auto get( const RegisterFromReader &rfr ) -> T {
+   T t = rfr.reader.readObj<T>(rfr.offset);
+   return t;
 }
 
-Elf::Addr
+gpreg
 StackFrame::rawIP() const
 {
+    return
 #ifdef __aarch64__
-    // remove RA signing artefacts.
-    return 0xffffffffffff & Elf::getReg(regs, IPREG);
-#else
-    return Elf::getReg(regs, IPREG);
+       0xffffffffffff &
 #endif
+       std::get<gpreg>(regs.getDwarf(IPREG));
 }
 
 ProcessLocation
@@ -57,7 +55,7 @@ StackFrame::scopeIP(Process &proc) const
     // Finally, for the function that was running when the signal was invoked -
     // The signal was invoked asynchronously, so again, we have no call
     // instruction to walk back into.
-    auto raw = rawIP();
+    auto raw = Elf::Addr(rawIP());
     if (raw == 0)
        return { proc, raw };
     if (mechanism == UnwindMechanism::MACHINEREGS
@@ -283,7 +281,7 @@ ExpressionStack::eval(Process &proc, Dwarf::DWARFReader &r, const StackFrame *fr
             case DW_OP_breg24: case DW_OP_breg25: case DW_OP_breg26: case DW_OP_breg27:
             case DW_OP_breg28: case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: {
                 auto offset = r.getsleb128();
-                push(Elf::getReg(frame->regs, op - DW_OP_breg0) + offset);
+                push(std::get<gpreg>(frame->regs.getDwarf(op - DW_OP_breg0)) + offset);
                 break;
             }
 
@@ -444,10 +442,10 @@ ExpressionStack::eval(Process &proc, Dwarf::DWARFReader &r, const StackFrame *fr
             case DW_OP_reg28: case DW_OP_reg29: case DW_OP_reg30: case DW_OP_reg31:
                 isValue = true;
                 inReg = op - DW_OP_reg0;
-                push(Elf::getReg(frame->regs, op - DW_OP_reg0));
+                push(std::get<gpreg>(frame->regs.getDwarf(op - DW_OP_reg0)));
                 break;
             case DW_OP_regx:
-                push(Elf::getReg(frame->regs, int(r.getsleb128())));
+                push(std::get<gpreg>(frame->regs.getDwarf(size_t(r.getsleb128()))));
                 break;
 
             case DW_OP_entry_value:
@@ -505,14 +503,14 @@ ExpressionStack::eval(Process &proc, Dwarf::DWARFReader &r, const StackFrame *fr
 }
 
 
-StackFrame::StackFrame(UnwindMechanism mechanism, const Elf::CoreRegisters &regs_)
+StackFrame::StackFrame(UnwindMechanism mechanism, const CoreRegisters &regs_)
     : regs(regs_)
     , cfa(0)
     , mechanism(mechanism)
 {
 }
 
-std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
+std::optional<CoreRegisters> StackFrame::unwind(Process &p) {
     ProcessLocation location = scopeIP(p);
 
     const Dwarf::CFI *cfi = location.cfi();
@@ -541,20 +539,20 @@ std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
 
     // Given the registers available, and the state of the call unwind data,
     // calculate the CFA at this point.
-    Elf::CoreRegisters out;
+    CoreRegisters out;
     switch (dcf.cfaValue.type) {
         case SAME:
         case UNDEF:
         case ARCH:
-            cfa = Elf::getReg(regs, dcf.cfaReg);
+            cfa = std::get<gpreg>(regs.getDwarf(dcf.cfaReg));
             break;
         case VAL_OFFSET:
         case VAL_EXPRESSION:
         case REG:
             throw (Exception() << "unhandled CFA value type " << dcf.cfaValue.type);
 
         case OFFSET:
-            cfa = Elf::getReg(regs, dcf.cfaReg) + dcf.cfaValue.u.offset;
+            cfa = std::get<gpreg>(regs.getDwarf(dcf.cfaReg)) + dcf.cfaValue.u.offset;
             break;
 
         case EXPRESSION: {
@@ -567,48 +565,51 @@ std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
         }
         default:
             cfa = -1;
+            break;
     }
     auto rarInfo = dcf.registers.find(cie->rar);
 
-    for (const auto &entry : dcf.registers) {
-        const RegisterUnwind &unwind = entry.second;
-        int regno = entry.first;
-        try {
-           switch (unwind.type) {
-               case ARCH:
+
+    out = regs;
 #ifdef CFA_RESTORE_REGNO
-                   // "The CFA is defined to be the stack pointer in the calling frame."
-                   if (regno == CFA_RESTORE_REGNO)
-                      Elf::setReg(out, regno, cfa);
-                   else
-                      Elf::setReg(out, regno, Elf::getReg(regs, regno));
-                   break;
+    // "The CFA is defined to be the stack pointer in the calling frame."
+    out.setDwarf(CFA_RESTORE_REGNO, RegisterValue{cfa} );
 #endif
-               case UNDEF:
-               case SAME:
-                   Elf::setReg(out, regno, Elf::getReg(regs, regno));
-                   break;
-               case OFFSET: // XXX: assume addrLen = sizeof Elf_Addr
-                   Elf::setReg(out, regno, p.io->readObj<Elf::Addr>(cfa + unwind.u.offset));
+    for (const auto &[regno, unwind] : dcf.registers) {
+        try {
+           switch (unwind.type) {
+               case OFFSET: {
+                   RegisterFromReader rfr(*p.io, cfa + unwind.u.offset);
+                   out.setDwarf(regno, rfr);
                    break;
+               }
+
                case REG:
-                   Elf::setReg(out, regno, Elf::getReg(out,unwind.u.reg));
+                   out.setDwarf(regno, regs.getDwarf(unwind.u.reg));
                    break;
+
                case VAL_EXPRESSION:
                case EXPRESSION: {
                    ExpressionStack stack;
                    stack.push(cfa);
                    DWARFReader reader(cfi->io, unwind.u.expression.offset,
                          unwind.u.expression.offset + unwind.u.expression.length);
-                   auto val = stack.eval(p, reader, this, location.elfReloc());
+                   auto val = gpreg(stack.eval(p, reader, this, location.elfReloc()));
                    // EXPRESSIONs give an address, VAL_EXPRESSION gives a literal.
                    if (unwind.type == EXPRESSION)
                        p.io->readObj(val, &val);
-                   Elf::setReg(out, regno, val);
+                   out.setDwarf(regno, RegisterValue{val});
                    break;
                }
+
+               case SAME:
+                   out.setDwarf(regno, regs.getDwarf(regno));
+                   break;
+
+               case ARCH:
                default:
                    break;
+
            }
         }
         catch (const Exception &ex) {
@@ -620,13 +621,12 @@ std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
     }
 
     // If the return address isn't defined, then we can't unwind.
-    if (rarInfo == dcf.registers.end() || rarInfo->second.type == UNDEF || cfa == 0) {
+    if ((rarInfo != dcf.registers.end() && rarInfo->second.type == UNDEF) || cfa == 0) {
         if (p.context.verbose > 1) {
            *p.context.debug << "DWARF unwinding stopped at "
               << std::hex << location.location() << std::dec
               << ": " <<
-              (rarInfo == dcf.registers.end() ? "no RAR register found"
-               : rarInfo->second.type == UNDEF ? "RAR register undefined"
+              (rarInfo == dcf.registers.end() ? "RAR register undefined"
                : "null CFA for frame")
               << std::endl;
         }
@@ -636,7 +636,7 @@ std::optional<Elf::CoreRegisters> StackFrame::unwind(Process &p) {
     // We know the RAR is defined, so make that the instruction pointer in the
     // new frame.
     if (cie && cie->rar != IPREG)
-       Elf::setReg(out, IPREG, Elf::getReg(out, cie->rar));
+       out.setDwarf(IPREG, out.getDwarf(cie->rar));
     return out;
 }
 

heap.c

@@ -351,6 +351,8 @@ getframe(void ***bp, void  ***ip) {
 void
 getframe(void ***bp, void  ***ip) {
    //XXX: TODO: support aarch64
+   (void)bp;
+   (void)ip;
 }
 #else