Simplifies the printing of registers

Change-Id: Ibf6b17258bbb6e108f896db5ca3f4b50db7dde36

diff --git a/src/crash-stack/crash-stack-aarch64.c b/src/crash-stack/crash-stack-aarch64.c
index 5b11332..c7ae893 100644 (file)
--- a/src/crash-stack/crash-stack-aarch64.c
+++ b/src/crash-stack/crash-stack-aarch64.c
@@ -21,6 +21,8 @@
  * @brief unwinding call stacks, functions specific for aarch64
  */
 #include "crash-stack.h"
+#include "shared/util.h"
+
 #include <sys/user.h>
 #include <string.h>
 
@@ -95,14 +97,26 @@ void _crash_stack_print_regs(FILE* outputfile)
                        fprintf(outputfile, "\n");
        }
        fprintf(outputfile, "\n");
-       fprintf(outputfile, "xr   = 0x%016llx, ip0  = 0x%016llx\nip1  = 0x%016llx, pr   = 0x%016llx\n",
-               g_registers.regs[8],   /* Indirect result location register */
-               g_registers.regs[16],  /* Intra-procedure call scratch register 0 */
-               g_registers.regs[17],  /* Intra-procedure call scratch register 1 */
-               g_registers.regs[18]); /* Platform register */
-       fprintf(outputfile, "fp   = 0x%016llx, lr   = 0x%016llx\npc   = 0x%016llx, sp   = 0x%016llx\n",
-               g_registers.regs[29],  /* Frame register */
-               g_registers.regs[30],  /* Procedure link register */
-               g_registers.pc,        /* Program counter */
-               g_registers.sp);       /* Stack pointer */
+
+       struct reg {
+               const char *name;
+               unsigned long long int value;
+       } regs[] = {{"xr", g_registers.regs[8]},
+                   {"ip0", g_registers.regs[16]},
+                   {"ip1", g_registers.regs[17]},
+                   {"pr", g_registers.regs[18]},
+                   {"fp", g_registers.regs[29]},
+                   {"lr", g_registers.regs[30]},
+                   {"pc", g_registers.pc},
+                   {"sp", g_registers.sp}};
+
+       const size_t regs_count = ARRAY_SIZE(regs);
+
+       for (size_t i = 0; i < regs_count; i++) {
+               fprintf(outputfile,
+                       "%-4s = 0x%016llx%s",
+                       regs[i].name,
+                       regs[i].value,
+                       (i + 1) % 4 == 0 || i == regs_count - 1 ? "\n" : ", ");
+       }
 }

diff --git a/src/crash-stack/crash-stack-arm.c b/src/crash-stack/crash-stack-arm.c
index 1876b80..308fddf 100644 (file)
--- a/src/crash-stack/crash-stack-arm.c
+++ b/src/crash-stack/crash-stack-arm.c
@@ -23,6 +23,7 @@
  * @brief unwinding call stacks, functions specific for ARM
  */
 #include "crash-stack.h"
+#include "shared/util.h"
 
 #include <string.h>
 #include <sys/user.h>
@@ -93,18 +94,34 @@ unsigned long _get_register_value(int n)
 void _crash_stack_print_regs(FILE* outputfile)
 {
        fprintf(outputfile, "\nRegister Information\n");
-       fprintf(outputfile, "r0   = 0x%08lx, r1   = 0x%08lx\nr2   = 0x%08lx, r3   = 0x%08lx\n",
-              g_registers.uregs[0], g_registers.uregs[1],
-              g_registers.uregs[2], g_registers.uregs[3]);
-       fprintf(outputfile, "r4   = 0x%08lx, r5   = 0x%08lx\nr6   = 0x%08lx, r7   = 0x%08lx\n",
-              g_registers.uregs[4], g_registers.uregs[5],
-              g_registers.uregs[6], g_registers.uregs[7]);
-       fprintf(outputfile, "r8   = 0x%08lx, r9   = 0x%08lx\nr10  = 0x%08lx, fp   = 0x%08lx\n",
-              g_registers.uregs[8], g_registers.uregs[9],
-              g_registers.uregs[10], g_registers.uregs[REG_FP]);
-       fprintf(outputfile, "ip   = 0x%08lx, sp   = 0x%08lx\nlr   = 0x%08lx, pc   = 0x%08lx\n",
-              g_registers.uregs[REG_IP], g_registers.uregs[REG_SP],
-              g_registers.uregs[REG_LR], g_registers.uregs[REG_PC]);
-       /* XXX the label should probably write "spsr" */
-       fprintf(outputfile, "cpsr = 0x%08lx\n", g_registers.uregs[REG_SPSR]);
+       static struct reg {
+               const char *name;
+               int index;
+       } regs[] = {{"r0", 0},
+                   {"r1", 1},
+                   {"r2", 2},
+                   {"r3", 3},
+                   {"r4", 4},
+                   {"r5", 5},
+                   {"r6", 6},
+                   {"r7", 7},
+                   {"r8", 8},
+                   {"r9", 9},
+                   {"r10", 10},
+                   {"fp", REG_FP},
+                   {"ip", REG_IP},
+                   {"sp", REG_SP},
+                   {"lr", REG_LR},
+                   {"pc", REG_PC},
+                   {"cpsr", REG_SPSR}}; // [> XXX the label should probably write "spsr" <]
+
+       const size_t regs_count = ARRAY_SIZE(regs);
+
+       for (size_t i = 0; i < regs_count; i++) {
+               fprintf(outputfile,
+                       "%-4s = 0x%08lx%s",
+                       regs[i].name,
+                       g_registers.uregs[regs[i].index],
+                       ((i + 1) % 2 == 0 || i == regs_count - 1) ? "\n" : ", ");
+       }
 }

diff --git a/src/crash-stack/crash-stack-x86.c b/src/crash-stack/crash-stack-x86.c
index 454848e..8827ab5 100644 (file)
--- a/src/crash-stack/crash-stack-x86.c
+++ b/src/crash-stack/crash-stack-x86.c
@@ -21,6 +21,8 @@
  * @brief unwinding call stacks, functions specific for x86_64
  */
 #include "crash-stack.h"
+#include "shared/util.h"
+
 #include <sys/user.h>
 #include <string.h>
 
@@ -84,50 +86,61 @@ void _crash_stack_print_regs(FILE* outputfile)
 {
        fprintf(outputfile, "\nRegister Information\n");
 #if defined(__x86_64__)
-       fprintf(outputfile, "gs  = 0x%016llx, fs  = 0x%016llx\nes  = 0x%016llx, ds  = 0x%016llx\n",
-               g_registers.gs,
-               g_registers.fs,
-               g_registers.es,
-               g_registers.ds);
-       fprintf(outputfile, "rdi = 0x%016llx, rsi = 0x%016llx\nrbp = 0x%016llx, rsp = 0x%016llx\n",
-               g_registers.rdi,
-               g_registers.rsi,
-               g_registers.rbp,
-               g_registers.rsp);
-       fprintf(outputfile, "rax = 0x%016llx, rbx = 0x%016llx\nrcx = 0x%016llx, rdx = 0x%016llx\n",
-               g_registers.rax,
-               g_registers.rbx,
-               g_registers.rcx,
-               g_registers.rdx);
-       fprintf(outputfile, "r8  = 0x%016llx, r9  = 0x%016llx\nr10 = 0x%016llx, r11 = 0x%016llx\n",
-               g_registers.r8,
-               g_registers.r9,
-               g_registers.r10,
-               g_registers.r11);
-       fprintf(outputfile, "r12 = 0x%016llx, r13 = 0x%016llx\nr14 = 0x%016llx, r15 = 0x%016llx\n",
-               g_registers.r12,
-               g_registers.r13,
-               g_registers.r14,
-               g_registers.r15);
-       fprintf(outputfile, "rip = 0x%016llx\n",
-               g_registers.rip);
+       struct reg {
+               const char *name;
+               unsigned long long int value;
+       } regs[] = {{"gs", g_registers.gs},
+                   {"fs", g_registers.fs},
+                   {"es", g_registers.es},
+                   {"ds", g_registers.ds},
+                   {"rdi", g_registers.rdi},
+                   {"rsi", g_registers.rsi},
+                   {"rbp", g_registers.rbp},
+                   {"rsp", g_registers.rsp},
+                   {"rax", g_registers.rax},
+                   {"rbx", g_registers.rbx},
+                   {"rcx", g_registers.rcx},
+                   {"rdx", g_registers.rdx},
+                   {"r8", g_registers.r8},
+                   {"r9", g_registers.r9},
+                   {"r10", g_registers.r10},
+                   {"r11", g_registers.r11},
+                   {"r12", g_registers.r12},
+                   {"r13", g_registers.r13},
+                   {"r14", g_registers.r14},
+                   {"r15", g_registers.r15},
+                   {"rip", g_registers.rip}};
+
+#define ADDR_FORMAT "0x%016llx"
 #else
-       fprintf(outputfile, "gs  = 0x%08lx, fs  = 0x%08lx\nes  = 0x%08lx, ds  = 0x%08lx\n",
-              g_registers.xgs,
-              g_registers.xfs,
-              g_registers.xes,
-              g_registers.xds);
-       fprintf(outputfile, "edi = 0x%08lx, esi = 0x%08lx\nebp = 0x%08lx, esp = 0x%08lx\n",
-              g_registers.edi,
-              g_registers.esi,
-              g_registers.ebp,
-              g_registers.esp);
-       fprintf(outputfile, "eax = 0x%08lx, ebx = 0x%08lx\necx = 0x%08lx, edx = 0x%08lx\n",
-              g_registers.eax,
-              g_registers.ebx,
-              g_registers.ecx,
-              g_registers.edx);
-       fprintf(outputfile, "eip = 0x%08lx\n",
-              g_registers.eip);
+       struct reg {
+               const char *name;
+               unsigned long int value;
+       } regs[] = {{"gs", g_registers.xgs},
+                   {"fs", g_registers.xfs},
+                   {"es", g_registers.xes},
+                   {"ds", g_registers.xds},
+                   {"edi", g_registers.edi},
+                   {"esi", g_registers.esi},
+                   {"ebp", g_registers.ebp},
+                   {"esp", g_registers.esp},
+                   {"eax", g_registers.eax},
+                   {"ebx", g_registers.ebx},
+                   {"ecx", g_registers.ecx},
+                   {"edx", g_registers.edx},
+                   {"eip", g_registers.eip}};
+
+#define ADDR_FORMAT "0x%08lx"
 #endif
+
+       const size_t regs_count = ARRAY_SIZE(regs);
+
+       for (size_t i = 0; i < regs_count; i++) {
+               fprintf(outputfile,
+                       "%-3s = " ADDR_FORMAT "%s",
+                       regs[i].name,
+                       regs[i].value,
+                       ((i + 1) % 4 == 0 || i == regs_count - 1) ? "\n" : ", ");
+       }
+#undef ADDR_FORMAT
 }