Fix printing of x86_64 registers in minidump_stackwalk

src/processor/minidump_stackwalk.cc

 // Copyright (c) 2010 Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 71 matching lines @@
 // return value of PrintRegister.  Note that PrintRegister will print a
 // newline before the first register (with |sequence| set to 0) is printed.
 // The caller is responsible for printing the final newline after a set
 // of registers is completely printed, regardless of the number of calls
 // to PrintRegister.
 static int PrintRegister(const char *name, u_int32_t value, int sequence) {
   if (sequence % 4 == 0) {
     printf("\n ");
   }
   printf(" %5s = 0x%08x", name, value);
+
+  return ++sequence;
+}
+
+// PrintRegister64 does the same thing, but for 64-bit registers.
+static int PrintRegister64(const char *name, u_int64_t value, int sequence) {
+  if (sequence % 2 == 0) {

[Mark Mentovai, 2011/01/28 19:45:28]

Maybe you should leave this at sequence % 4, and…

+    printf("\n ");
+  }
+  printf(" %5s = 0x%016" PRIx64 , name, value);
+
   return ++sequence;

[Mark Mentovai, 2011/01/28 19:45:28]

make this return sequence + 2.

Would that properly handle cases where 32-bit and 16-bit registers were printed
on the same line?

 }
 
 // StripSeparator takes a string |original| and returns a copy
 // of the string with all occurences of |kOutputSeparator| removed.
 static string StripSeparator(const string &original) {
   string result = original;
   string::size_type position = 0;
   while ((position = result.find(kOutputSeparator, position)) != string::npos) {
     result.erase(position, 1);
   }
@@ skipping 69 matching lines @@
 
       if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_SRR0)
         sequence = PrintRegister("srr0", frame_ppc->context.srr0, sequence);
       if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_GPR1)
         sequence = PrintRegister("r1", frame_ppc->context.gpr[1], sequence);
     } else if (cpu == "amd64") {
       const StackFrameAMD64 *frame_amd64 =
         reinterpret_cast<const StackFrameAMD64*>(frame);
 
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RBX)
-        sequence = PrintRegister("rbx", frame_amd64->context.rbx, sequence);
+        sequence = PrintRegister64("rbx", frame_amd64->context.rbx, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R12)
-        sequence = PrintRegister("r12", frame_amd64->context.r12, sequence);
+        sequence = PrintRegister64("r12", frame_amd64->context.r12, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R13)
-        sequence = PrintRegister("r13", frame_amd64->context.r13, sequence);
+        sequence = PrintRegister64("r13", frame_amd64->context.r13, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R14)
-        sequence = PrintRegister("r14", frame_amd64->context.r14, sequence);
+        sequence = PrintRegister64("r14", frame_amd64->context.r14, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R15)
-        sequence = PrintRegister("r15", frame_amd64->context.r15, sequence);
+        sequence = PrintRegister64("r15", frame_amd64->context.r15, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RIP)
-        sequence = PrintRegister("rip", frame_amd64->context.rip, sequence);
+        sequence = PrintRegister64("rip", frame_amd64->context.rip, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RSP)
-        sequence = PrintRegister("rsp", frame_amd64->context.rsp, sequence);
+        sequence = PrintRegister64("rsp", frame_amd64->context.rsp, sequence);
       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RBP)
-        sequence = PrintRegister("rbp", frame_amd64->context.rbp, sequence);
+        sequence = PrintRegister64("rbp", frame_amd64->context.rbp, sequence);
     } else if (cpu == "sparc") {
       const StackFrameSPARC *frame_sparc =
         reinterpret_cast<const StackFrameSPARC*>(frame);
 
       if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_SP)
         sequence = PrintRegister("sp", frame_sparc->context.g_r[14], sequence);
       if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_FP)
         sequence = PrintRegister("fp", frame_sparc->context.g_r[30], sequence);
       if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_PC)
         sequence = PrintRegister("pc", frame_sparc->context.pc, sequence);
@@ skipping 351 matching lines @@
   std::vector<std::string> symbol_paths;
   if (argc > symbol_path_arg) {
     for (int argi = symbol_path_arg; argi < argc; ++argi)
       symbol_paths.push_back(argv[argi]);
   }
 
   return PrintMinidumpProcess(minidump_file,
                               symbol_paths,
                               machine_readable) ? 0 : 1;
 }