Templatize the "setDwarf" method

This allows more generic support for restoring registers from memory in
dwarf expressions

Author: peadar

CMakeLists.txt

@@ -114,7 +114,7 @@ add_library(dwelf ${LIBTYPE}
          )
 
 add_library(procman ${LIBTYPE} dead.cc self.cc live.cc process.cc proc_service.cc
-    dwarfproc.cc procdump.cc arch.cc ${stubsrc} ${pysrc})
+    dwarfproc.cc procdump.cc ${stubsrc} ${pysrc})
 
 add_executable(canal canal.cc)
 

arch.cc

@@ -4,24 +4,5 @@
 #include <cstdint>
 #include "libpstack/arch.h"
 
-#ifdef __x86_64__
-#include "x86_64.cc"
-#endif
-#ifdef __aarch64__
-#include "aarch64.cc"
-#endif
-#ifdef __i386__
-#include "i386.cc"
-#endif
-
 namespace pstack::Procman {
-void CoreRegisters::setDwarf(int regId, const RegisterValue &value) {
-   opReg(*this, Set{}, regId, value );
-};
-
-RegisterValue CoreRegisters::getDwarf(int regId) const {
-   RegisterValue value;
-   opReg(*this, Get{}, regId, value);
-   return value;
-};
 }

dwarfproc.cc

@@ -9,6 +9,19 @@ extern std::ostream & operator << (std::ostream &os, const pstack::Dwarf::DIE &)
 
 namespace pstack::Procman {
 
+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;
+}
+
 gpreg
 StackFrame::rawIP() const
 {
@@ -556,17 +569,20 @@ std::optional<CoreRegisters> StackFrame::unwind(Process &p) {
     }
     auto rarInfo = dcf.registers.find(cie->rar);
 
+
     out = regs;
 #ifdef CFA_RESTORE_REGNO
     // "The CFA is defined to be the stack pointer in the calling frame."
-    out.setDwarf(CFA_RESTORE_REGNO, cfa );
+    out.setDwarf(CFA_RESTORE_REGNO, RegisterValue{cfa} );
 #endif
     for (const auto &[regno, unwind] : dcf.registers) {
         try {
            switch (unwind.type) {
-               case OFFSET: // XXX: assume addrLen = sizeof (general purpos reg)
-                   out.setDwarf(regno, p.io->readObj<gpreg>(cfa + unwind.u.offset));
+               case OFFSET: {
+                   RegisterFromReader rfr(*p.io, cfa + unwind.u.offset);
+                   out.setDwarf(regno, rfr);
                    break;
+               }
 
                case REG:
                    out.setDwarf(regno, regs.getDwarf(unwind.u.reg));
@@ -582,7 +598,7 @@ std::optional<CoreRegisters> StackFrame::unwind(Process &p) {
                    // EXPRESSIONs give an address, VAL_EXPRESSION gives a literal.
                    if (unwind.type == EXPRESSION)
                        p.io->readObj(val, &val);
-                   out.setDwarf(regno, val);
+                   out.setDwarf(regno, RegisterValue{val});
                    break;
                }
 

aarch64.cc libpstack/arch-aarch64.haarch64.cc renamed to libpstack/arch-aarch64.h

@@ -3,7 +3,7 @@
 
 #include <cstdint>
 #include <type_traits>
-#include "libpstack/elf.h"
+#include "libpstack/stringify.h"
 namespace pstack::Procman {
 
 // see https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf

i386.cc libpstack/arch-i386.hi386.cc renamed to libpstack/arch-i386.h

@@ -25,7 +25,6 @@ using gpreg = long;
 
 using gpreg = unsigned long long;
 
-
 #elif defined( __ARM_ARCH )
 #ifdef __aarch64__
 using gpreg = unsigned long long;
@@ -110,8 +109,8 @@ struct CoreRegisters {
 #elif defined(__i386__)
    user_fpxregs_struct fpx;
 #endif
-   RegisterValue getDwarf(int reg) const;
-   void setDwarf(int reg, const RegisterValue &val);
+   inline RegisterValue getDwarf(int reg) const;
+   template <typename RV> void setDwarf(int reg, const RV &val);
 };
 
 // Maps a name to its dwarf register index.
@@ -120,7 +119,6 @@ using DwarfNames = std::vector<std::pair<int, std::string_view>>;
 // Sets of registers for an architecture. Each architecture supports at least
 // "general" registers.
 using ArchRegs = std::unordered_map<std::string_view, DwarfNames>;
-extern const ArchRegs registers;
 
 #ifndef __aarch64__
 void gregset2user(user_regs_struct &core, const gregset_t greg);
@@ -141,45 +139,75 @@ inline void regop(Set, T &reg, const T &val) { reg = val; }
 template <typename T>
 inline void regop(Get, const T &reg, T &val) { val = reg; }
 
-template <typename T> void regop(Set, T &reg, const RegisterValue &val) {
-   regop(Set{}, reg, std::get<T>(val));
+template <typename T, typename RV> void regop(Set, T &reg, const RV &rv) {
+   const T branch = get<T>(rv);
+   regop(Set{}, reg, branch);
 }
-template <typename T> void regop(Get, const T &reg, RegisterValue &val) {
+template <typename T, typename RV> void regop(Get, const T &reg, RV &val) {
    T newval;
    regop(Get{}, reg, newval);
    val = newval;
 }
 
-inline void regop(Set, Simd128 &simd, const RegisterValue &v) {
-   std::memcpy((void *)&simd, (void *)&std::get<Simd128>(v), sizeof simd);
+template <typename RV>
+inline void regop(Set, Simd128 &simd, const RV &v) {
+   Simd128 value = get<Simd128>(v);
+   std::memcpy((void *)&simd, (void *)&value, sizeof simd);
 }
 
-inline void regop(Get, const Simd128 &simd, RegisterValue &v) {
+template <typename RV>
+inline void regop(Get, const Simd128 &simd, RV &v) {
    v = Simd128{};
-   std::memcpy((void *)&std::get<Simd128>(v), (void *)&simd, sizeof simd);
+   std::memcpy((void *)&get<Simd128>(v), (void *)&simd, sizeof simd);
 }
 
-inline void regop(Set, i387Float &simd, const RegisterValue &v) {
-   std::memcpy((void *)&simd, (void *)&std::get<i387Float>(v), sizeof simd);
+template <typename RV>
+inline void regop(Set, i387Float &simd, const RV &v) {
+   auto fp = get<i387Float>( v );
+   std::memcpy((void *)&simd, (void *)&fp, sizeof simd);
 }
 
-inline void regop(Get, const i387Float &simd, RegisterValue &v) {
+template <typename RV>
+inline void regop(Get, const i387Float &simd, RV &v) {
    v = i387Float{};
-   std::memcpy((void *)&std::get<i387Float>(v), (void *)&simd, sizeof simd);
+   std::memcpy((void *)&get<i387Float>(v), (void *)&simd, sizeof simd);
 }
 
 
-inline void regop(Set, Simd64 &simd, const RegisterValue &v) {
-   std::memcpy((void *)&simd, (void *)&std::get<Simd64>(v), sizeof simd);
+template <typename RV>
+inline void regop(Set, Simd64 &simd, const RV &v) {
+   auto branch = get<Simd64>(v);
+   std::memcpy((void *)&simd, (void *)&branch, sizeof simd);
 }
 
-inline void regop(Get, const Simd64 &simd, RegisterValue &v) {
+template <typename RV>
+inline void regop(Get, const Simd64 &simd, RV &v) {
    v = Simd64{};
-   std::memcpy((void *)&std::get<Simd64>(v), (void *)&simd, sizeof simd);
+   std::memcpy((void *)&get<Simd64>(v), (void *)&simd, sizeof simd);
+}
+
 }
 
+#ifdef __x86_64__
+#include "libpstack/arch-x86_64.h"
+#endif
+#ifdef __aarch64__
+#include "libpstack/arch-aarch64.h"
+#endif
+#ifdef __i386__
+#include "libpstack/arch-i386.h"
+#endif
 
+namespace pstack::Procman {
+template <typename RV> void CoreRegisters::setDwarf(int regId, const RV &value) {
+   opReg(*this, Set{}, regId, value );
+};
 
+RegisterValue CoreRegisters::getDwarf(int regId) const {
+   RegisterValue value;
+   opReg(*this, Get{}, regId, value);
+   return value;
+};
 
 }
 #endif