• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2010 Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 //     * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 //     * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 //     * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 
30 // stackwalk_common.cc: Module shared by the {micro,mini}dump_stackwalck
31 // executables to print the content of dumps (w/ stack traces) on the console.
32 //
33 // Author: Mark Mentovai
34 
35 #include "processor/stackwalk_common.h"
36 
37 #include <assert.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 
42 #include <string>
43 #include <vector>
44 
45 #include "common/using_std_string.h"
46 #include "google_breakpad/processor/call_stack.h"
47 #include "google_breakpad/processor/code_module.h"
48 #include "google_breakpad/processor/code_modules.h"
49 #include "google_breakpad/processor/process_state.h"
50 #include "google_breakpad/processor/source_line_resolver_interface.h"
51 #include "google_breakpad/processor/stack_frame_cpu.h"
52 #include "processor/logging.h"
53 #include "processor/pathname_stripper.h"
54 
55 namespace google_breakpad {
56 
57 namespace {
58 
59 using std::vector;
60 
61 // Separator character for machine readable output.
62 static const char kOutputSeparator = '|';
63 
64 // PrintRegister prints a register's name and value to stdout.  It will
65 // print four registers on a line.  For the first register in a set,
66 // pass 0 for |start_col|.  For registers in a set, pass the most recent
67 // return value of PrintRegister.
68 // The caller is responsible for printing the final newline after a set
69 // of registers is completely printed, regardless of the number of calls
70 // to PrintRegister.
71 static const int kMaxWidth = 80;  // optimize for an 80-column terminal
PrintRegister(const char * name,uint32_t value,int start_col)72 static int PrintRegister(const char *name, uint32_t value, int start_col) {
73   char buffer[64];
74   snprintf(buffer, sizeof(buffer), " %5s = 0x%08x", name, value);
75 
76   if (start_col + static_cast<ssize_t>(strlen(buffer)) > kMaxWidth) {
77     start_col = 0;
78     printf("\n ");
79   }
80   fputs(buffer, stdout);
81 
82   return start_col + strlen(buffer);
83 }
84 
85 // PrintRegister64 does the same thing, but for 64-bit registers.
PrintRegister64(const char * name,uint64_t value,int start_col)86 static int PrintRegister64(const char *name, uint64_t value, int start_col) {
87   char buffer[64];
88   snprintf(buffer, sizeof(buffer), " %5s = 0x%016" PRIx64 , name, value);
89 
90   if (start_col + static_cast<ssize_t>(strlen(buffer)) > kMaxWidth) {
91     start_col = 0;
92     printf("\n ");
93   }
94   fputs(buffer, stdout);
95 
96   return start_col + strlen(buffer);
97 }
98 
99 // StripSeparator takes a string |original| and returns a copy
100 // of the string with all occurences of |kOutputSeparator| removed.
StripSeparator(const string & original)101 static string StripSeparator(const string &original) {
102   string result = original;
103   string::size_type position = 0;
104   while ((position = result.find(kOutputSeparator, position)) != string::npos) {
105     result.erase(position, 1);
106   }
107   position = 0;
108   while ((position = result.find('\n', position)) != string::npos) {
109     result.erase(position, 1);
110   }
111   return result;
112 }
113 
114 // PrintStackContents prints the stack contents of the current frame to stdout.
PrintStackContents(const std::string & indent,const StackFrame * frame,const StackFrame * prev_frame,const std::string & cpu,const MemoryRegion * memory,const CodeModules * modules,SourceLineResolverInterface * resolver)115 static void PrintStackContents(const std::string &indent,
116                                const StackFrame *frame,
117                                const StackFrame *prev_frame,
118                                const std::string &cpu,
119                                const MemoryRegion *memory,
120                                const CodeModules* modules,
121                                SourceLineResolverInterface *resolver) {
122   // Find stack range.
123   int word_length = 0;
124   uint64_t stack_begin = 0, stack_end = 0;
125   if (cpu == "x86") {
126     word_length = 4;
127     const StackFrameX86 *frame_x86 = static_cast<const StackFrameX86*>(frame);
128     const StackFrameX86 *prev_frame_x86 =
129         static_cast<const StackFrameX86*>(prev_frame);
130     if ((frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESP) &&
131         (prev_frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESP)) {
132       stack_begin = frame_x86->context.esp;
133       stack_end = prev_frame_x86->context.esp;
134     }
135   } else if (cpu == "amd64") {
136     word_length = 8;
137     const StackFrameAMD64 *frame_amd64 =
138         static_cast<const StackFrameAMD64*>(frame);
139     const StackFrameAMD64 *prev_frame_amd64 =
140         static_cast<const StackFrameAMD64*>(prev_frame);
141     if ((frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RSP) &&
142         (prev_frame_amd64->context_validity &
143          StackFrameAMD64::CONTEXT_VALID_RSP)) {
144       stack_begin = frame_amd64->context.rsp;
145       stack_end = prev_frame_amd64->context.rsp;
146     }
147   } else if (cpu == "arm") {
148     word_length = 4;
149     const StackFrameARM *frame_arm = static_cast<const StackFrameARM*>(frame);
150     const StackFrameARM *prev_frame_arm =
151         static_cast<const StackFrameARM*>(prev_frame);
152     if ((frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_SP) &&
153         (prev_frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_SP)) {
154       stack_begin = frame_arm->context.iregs[13];
155       stack_end = prev_frame_arm->context.iregs[13];
156     }
157   } else if (cpu == "arm64") {
158     word_length = 8;
159     const StackFrameARM64 *frame_arm64 =
160         static_cast<const StackFrameARM64*>(frame);
161     const StackFrameARM64 *prev_frame_arm64 =
162         static_cast<const StackFrameARM64*>(prev_frame);
163     if ((frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_SP) &&
164         (prev_frame_arm64->context_validity &
165          StackFrameARM64::CONTEXT_VALID_SP)) {
166       stack_begin = frame_arm64->context.iregs[31];
167       stack_end = prev_frame_arm64->context.iregs[31];
168     }
169   }
170   if (!word_length || !stack_begin || !stack_end)
171     return;
172 
173   // Print stack contents.
174   printf("\n%sStack contents:", indent.c_str());
175   for(uint64_t address = stack_begin; address < stack_end; ) {
176     // Print the start address of this row.
177     if (word_length == 4)
178       printf("\n%s %08x", indent.c_str(), static_cast<uint32_t>(address));
179     else
180       printf("\n%s %016" PRIx64, indent.c_str(), address);
181 
182     // Print data in hex.
183     const int kBytesPerRow = 16;
184     std::string data_as_string;
185     for (int i = 0; i < kBytesPerRow; ++i, ++address) {
186       uint8_t value = 0;
187       if (address < stack_end &&
188           memory->GetMemoryAtAddress(address, &value)) {
189         printf(" %02x", value);
190         data_as_string.push_back(isprint(value) ? value : '.');
191       } else {
192         printf("   ");
193         data_as_string.push_back(' ');
194       }
195     }
196     // Print data as string.
197     printf("  %s", data_as_string.c_str());
198   }
199 
200   // Try to find instruction pointers from stack.
201   printf("\n%sPossible instruction pointers:\n", indent.c_str());
202   for (uint64_t address = stack_begin; address < stack_end;
203        address += word_length) {
204     StackFrame pointee_frame;
205 
206     // Read a word (possible instruction pointer) from stack.
207     if (word_length == 4) {
208       uint32_t data32 = 0;
209       memory->GetMemoryAtAddress(address, &data32);
210       pointee_frame.instruction = data32;
211     } else {
212       uint64_t data64 = 0;
213       memory->GetMemoryAtAddress(address, &data64);
214       pointee_frame.instruction = data64;
215     }
216     pointee_frame.module =
217         modules->GetModuleForAddress(pointee_frame.instruction);
218 
219     // Try to look up the function name.
220     if (pointee_frame.module)
221       resolver->FillSourceLineInfo(&pointee_frame);
222 
223     // Print function name.
224     if (!pointee_frame.function_name.empty()) {
225       if (word_length == 4) {
226         printf("%s *(0x%08x) = 0x%08x", indent.c_str(),
227                static_cast<uint32_t>(address),
228                static_cast<uint32_t>(pointee_frame.instruction));
229       } else {
230         printf("%s *(0x%016" PRIx64 ") = 0x%016" PRIx64,
231                indent.c_str(), address, pointee_frame.instruction);
232       }
233       printf(" <%s> [%s : %d + 0x%" PRIx64 "]\n",
234              pointee_frame.function_name.c_str(),
235              PathnameStripper::File(pointee_frame.source_file_name).c_str(),
236              pointee_frame.source_line,
237              pointee_frame.instruction - pointee_frame.source_line_base);
238     }
239   }
240   printf("\n");
241 }
242 
243 // PrintStack prints the call stack in |stack| to stdout, in a reasonably
244 // useful form.  Module, function, and source file names are displayed if
245 // they are available.  The code offset to the base code address of the
246 // source line, function, or module is printed, preferring them in that
247 // order.  If no source line, function, or module information is available,
248 // an absolute code offset is printed.
249 //
250 // If |cpu| is a recognized CPU name, relevant register state for each stack
251 // frame printed is also output, if available.
PrintStack(const CallStack * stack,const string & cpu,bool output_stack_contents,const MemoryRegion * memory,const CodeModules * modules,SourceLineResolverInterface * resolver)252 static void PrintStack(const CallStack *stack,
253                        const string &cpu,
254                        bool output_stack_contents,
255                        const MemoryRegion* memory,
256                        const CodeModules* modules,
257                        SourceLineResolverInterface* resolver) {
258   int frame_count = stack->frames()->size();
259   if (frame_count == 0) {
260     printf(" <no frames>\n");
261   }
262   for (int frame_index = 0; frame_index < frame_count; ++frame_index) {
263     const StackFrame *frame = stack->frames()->at(frame_index);
264     printf("%2d  ", frame_index);
265 
266     uint64_t instruction_address = frame->ReturnAddress();
267 
268     if (frame->module) {
269       printf("%s", PathnameStripper::File(frame->module->code_file()).c_str());
270       if (!frame->function_name.empty()) {
271         printf("!%s", frame->function_name.c_str());
272         if (!frame->source_file_name.empty()) {
273           string source_file = PathnameStripper::File(frame->source_file_name);
274           printf(" [%s : %d + 0x%" PRIx64 "]",
275                  source_file.c_str(),
276                  frame->source_line,
277                  instruction_address - frame->source_line_base);
278         } else {
279           printf(" + 0x%" PRIx64, instruction_address - frame->function_base);
280         }
281       } else {
282         printf(" + 0x%" PRIx64,
283                instruction_address - frame->module->base_address());
284       }
285     } else {
286       printf("0x%" PRIx64, instruction_address);
287     }
288     printf("\n ");
289 
290     int sequence = 0;
291     if (cpu == "x86") {
292       const StackFrameX86 *frame_x86 =
293         reinterpret_cast<const StackFrameX86*>(frame);
294 
295       if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EIP)
296         sequence = PrintRegister("eip", frame_x86->context.eip, sequence);
297       if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESP)
298         sequence = PrintRegister("esp", frame_x86->context.esp, sequence);
299       if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EBP)
300         sequence = PrintRegister("ebp", frame_x86->context.ebp, sequence);
301       if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EBX)
302         sequence = PrintRegister("ebx", frame_x86->context.ebx, sequence);
303       if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_ESI)
304         sequence = PrintRegister("esi", frame_x86->context.esi, sequence);
305       if (frame_x86->context_validity & StackFrameX86::CONTEXT_VALID_EDI)
306         sequence = PrintRegister("edi", frame_x86->context.edi, sequence);
307       if (frame_x86->context_validity == StackFrameX86::CONTEXT_VALID_ALL) {
308         sequence = PrintRegister("eax", frame_x86->context.eax, sequence);
309         sequence = PrintRegister("ecx", frame_x86->context.ecx, sequence);
310         sequence = PrintRegister("edx", frame_x86->context.edx, sequence);
311         sequence = PrintRegister("efl", frame_x86->context.eflags, sequence);
312       }
313     } else if (cpu == "ppc") {
314       const StackFramePPC *frame_ppc =
315         reinterpret_cast<const StackFramePPC*>(frame);
316 
317       if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_SRR0)
318         sequence = PrintRegister("srr0", frame_ppc->context.srr0, sequence);
319       if (frame_ppc->context_validity & StackFramePPC::CONTEXT_VALID_GPR1)
320         sequence = PrintRegister("r1", frame_ppc->context.gpr[1], sequence);
321     } else if (cpu == "amd64") {
322       const StackFrameAMD64 *frame_amd64 =
323         reinterpret_cast<const StackFrameAMD64*>(frame);
324 
325       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RAX)
326         sequence = PrintRegister64("rax", frame_amd64->context.rax, sequence);
327       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RDX)
328         sequence = PrintRegister64("rdx", frame_amd64->context.rdx, sequence);
329       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RCX)
330         sequence = PrintRegister64("rcx", frame_amd64->context.rcx, sequence);
331       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RBX)
332         sequence = PrintRegister64("rbx", frame_amd64->context.rbx, sequence);
333       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RSI)
334         sequence = PrintRegister64("rsi", frame_amd64->context.rsi, sequence);
335       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RDI)
336         sequence = PrintRegister64("rdi", frame_amd64->context.rdi, sequence);
337       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RBP)
338         sequence = PrintRegister64("rbp", frame_amd64->context.rbp, sequence);
339       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RSP)
340         sequence = PrintRegister64("rsp", frame_amd64->context.rsp, sequence);
341       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R8)
342         sequence = PrintRegister64("r8", frame_amd64->context.r8, sequence);
343       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R9)
344         sequence = PrintRegister64("r9", frame_amd64->context.r9, sequence);
345       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R10)
346         sequence = PrintRegister64("r10", frame_amd64->context.r10, sequence);
347       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R11)
348         sequence = PrintRegister64("r11", frame_amd64->context.r11, sequence);
349       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R12)
350         sequence = PrintRegister64("r12", frame_amd64->context.r12, sequence);
351       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R13)
352         sequence = PrintRegister64("r13", frame_amd64->context.r13, sequence);
353       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R14)
354         sequence = PrintRegister64("r14", frame_amd64->context.r14, sequence);
355       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_R15)
356         sequence = PrintRegister64("r15", frame_amd64->context.r15, sequence);
357       if (frame_amd64->context_validity & StackFrameAMD64::CONTEXT_VALID_RIP)
358         sequence = PrintRegister64("rip", frame_amd64->context.rip, sequence);
359     } else if (cpu == "sparc") {
360       const StackFrameSPARC *frame_sparc =
361         reinterpret_cast<const StackFrameSPARC*>(frame);
362 
363       if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_SP)
364         sequence = PrintRegister("sp", frame_sparc->context.g_r[14], sequence);
365       if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_FP)
366         sequence = PrintRegister("fp", frame_sparc->context.g_r[30], sequence);
367       if (frame_sparc->context_validity & StackFrameSPARC::CONTEXT_VALID_PC)
368         sequence = PrintRegister("pc", frame_sparc->context.pc, sequence);
369     } else if (cpu == "arm") {
370       const StackFrameARM *frame_arm =
371         reinterpret_cast<const StackFrameARM*>(frame);
372 
373       // Argument registers (caller-saves), which will likely only be valid
374       // for the youngest frame.
375       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R0)
376         sequence = PrintRegister("r0", frame_arm->context.iregs[0], sequence);
377       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R1)
378         sequence = PrintRegister("r1", frame_arm->context.iregs[1], sequence);
379       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R2)
380         sequence = PrintRegister("r2", frame_arm->context.iregs[2], sequence);
381       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R3)
382         sequence = PrintRegister("r3", frame_arm->context.iregs[3], sequence);
383 
384       // General-purpose callee-saves registers.
385       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R4)
386         sequence = PrintRegister("r4", frame_arm->context.iregs[4], sequence);
387       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R5)
388         sequence = PrintRegister("r5", frame_arm->context.iregs[5], sequence);
389       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R6)
390         sequence = PrintRegister("r6", frame_arm->context.iregs[6], sequence);
391       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R7)
392         sequence = PrintRegister("r7", frame_arm->context.iregs[7], sequence);
393       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R8)
394         sequence = PrintRegister("r8", frame_arm->context.iregs[8], sequence);
395       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R9)
396         sequence = PrintRegister("r9", frame_arm->context.iregs[9], sequence);
397       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R10)
398         sequence = PrintRegister("r10", frame_arm->context.iregs[10], sequence);
399       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_R12)
400         sequence = PrintRegister("r12", frame_arm->context.iregs[12], sequence);
401 
402       // Registers with a dedicated or conventional purpose.
403       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_FP)
404         sequence = PrintRegister("fp", frame_arm->context.iregs[11], sequence);
405       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_SP)
406         sequence = PrintRegister("sp", frame_arm->context.iregs[13], sequence);
407       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_LR)
408         sequence = PrintRegister("lr", frame_arm->context.iregs[14], sequence);
409       if (frame_arm->context_validity & StackFrameARM::CONTEXT_VALID_PC)
410         sequence = PrintRegister("pc", frame_arm->context.iregs[15], sequence);
411     } else if (cpu == "arm64") {
412       const StackFrameARM64 *frame_arm64 =
413         reinterpret_cast<const StackFrameARM64*>(frame);
414 
415       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X0) {
416         sequence =
417             PrintRegister64("x0", frame_arm64->context.iregs[0], sequence);
418       }
419       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X1) {
420         sequence =
421             PrintRegister64("x1", frame_arm64->context.iregs[1], sequence);
422       }
423       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X2) {
424         sequence =
425             PrintRegister64("x2", frame_arm64->context.iregs[2], sequence);
426       }
427       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X3) {
428         sequence =
429             PrintRegister64("x3", frame_arm64->context.iregs[3], sequence);
430       }
431       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X4) {
432         sequence =
433             PrintRegister64("x4", frame_arm64->context.iregs[4], sequence);
434       }
435       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X5) {
436         sequence =
437             PrintRegister64("x5", frame_arm64->context.iregs[5], sequence);
438       }
439       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X6) {
440         sequence =
441             PrintRegister64("x6", frame_arm64->context.iregs[6], sequence);
442       }
443       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X7) {
444         sequence =
445             PrintRegister64("x7", frame_arm64->context.iregs[7], sequence);
446       }
447       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X8) {
448         sequence =
449             PrintRegister64("x8", frame_arm64->context.iregs[8], sequence);
450       }
451       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X9) {
452         sequence =
453             PrintRegister64("x9", frame_arm64->context.iregs[9], sequence);
454       }
455       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X10) {
456         sequence =
457             PrintRegister64("x10", frame_arm64->context.iregs[10], sequence);
458       }
459       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X11) {
460         sequence =
461             PrintRegister64("x11", frame_arm64->context.iregs[11], sequence);
462       }
463       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X12) {
464         sequence =
465             PrintRegister64("x12", frame_arm64->context.iregs[12], sequence);
466       }
467       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X13) {
468         sequence =
469             PrintRegister64("x13", frame_arm64->context.iregs[13], sequence);
470       }
471       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X14) {
472         sequence =
473             PrintRegister64("x14", frame_arm64->context.iregs[14], sequence);
474       }
475       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X15) {
476         sequence =
477             PrintRegister64("x15", frame_arm64->context.iregs[15], sequence);
478       }
479       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X16) {
480         sequence =
481             PrintRegister64("x16", frame_arm64->context.iregs[16], sequence);
482       }
483       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X17) {
484         sequence =
485             PrintRegister64("x17", frame_arm64->context.iregs[17], sequence);
486       }
487       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X18) {
488         sequence =
489             PrintRegister64("x18", frame_arm64->context.iregs[18], sequence);
490       }
491       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X19) {
492         sequence =
493             PrintRegister64("x19", frame_arm64->context.iregs[19], sequence);
494       }
495       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X20) {
496         sequence =
497             PrintRegister64("x20", frame_arm64->context.iregs[20], sequence);
498       }
499       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X21) {
500         sequence =
501             PrintRegister64("x21", frame_arm64->context.iregs[21], sequence);
502       }
503       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X22) {
504         sequence =
505             PrintRegister64("x22", frame_arm64->context.iregs[22], sequence);
506       }
507       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X23) {
508         sequence =
509             PrintRegister64("x23", frame_arm64->context.iregs[23], sequence);
510       }
511       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X24) {
512         sequence =
513             PrintRegister64("x24", frame_arm64->context.iregs[24], sequence);
514       }
515       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X25) {
516         sequence =
517             PrintRegister64("x25", frame_arm64->context.iregs[25], sequence);
518       }
519       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X26) {
520         sequence =
521             PrintRegister64("x26", frame_arm64->context.iregs[26], sequence);
522       }
523       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X27) {
524         sequence =
525             PrintRegister64("x27", frame_arm64->context.iregs[27], sequence);
526       }
527       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_X28) {
528         sequence =
529             PrintRegister64("x28", frame_arm64->context.iregs[28], sequence);
530       }
531 
532       // Registers with a dedicated or conventional purpose.
533       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_FP) {
534         sequence =
535             PrintRegister64("fp", frame_arm64->context.iregs[29], sequence);
536       }
537       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_LR) {
538         sequence =
539             PrintRegister64("lr", frame_arm64->context.iregs[30], sequence);
540       }
541       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_SP) {
542         sequence =
543             PrintRegister64("sp", frame_arm64->context.iregs[31], sequence);
544       }
545       if (frame_arm64->context_validity & StackFrameARM64::CONTEXT_VALID_PC) {
546         sequence =
547             PrintRegister64("pc", frame_arm64->context.iregs[32], sequence);
548       }
549     } else if (cpu == "mips") {
550       const StackFrameMIPS* frame_mips =
551         reinterpret_cast<const StackFrameMIPS*>(frame);
552 
553       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_GP)
554         sequence = PrintRegister64("gp",
555                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_GP],
556                      sequence);
557       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_SP)
558         sequence = PrintRegister64("sp",
559                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_SP],
560                      sequence);
561       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_FP)
562         sequence = PrintRegister64("fp",
563                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_FP],
564                      sequence);
565       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_RA)
566         sequence = PrintRegister64("ra",
567                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_RA],
568                      sequence);
569       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_PC)
570         sequence = PrintRegister64("pc", frame_mips->context.epc, sequence);
571 
572       // Save registers s0-s7
573       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S0)
574         sequence = PrintRegister64("s0",
575                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S0],
576                      sequence);
577       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S1)
578         sequence = PrintRegister64("s1",
579                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S1],
580                      sequence);
581       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S2)
582         sequence = PrintRegister64("s2",
583                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S2],
584                      sequence);
585       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S3)
586         sequence = PrintRegister64("s3",
587                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S3],
588                      sequence);
589       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S4)
590         sequence = PrintRegister64("s4",
591                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S4],
592                      sequence);
593       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S5)
594         sequence = PrintRegister64("s5",
595                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S5],
596                      sequence);
597       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S6)
598         sequence = PrintRegister64("s6",
599                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S6],
600                      sequence);
601       if (frame_mips->context_validity & StackFrameMIPS::CONTEXT_VALID_S7)
602         sequence = PrintRegister64("s7",
603                      frame_mips->context.iregs[MD_CONTEXT_MIPS_REG_S7],
604                      sequence);
605     }
606     printf("\n    Found by: %s\n", frame->trust_description().c_str());
607 
608     // Print stack contents.
609     if (output_stack_contents && frame_index + 1 < frame_count) {
610       const std::string indent("    ");
611       PrintStackContents(indent, frame, stack->frames()->at(frame_index + 1),
612                          cpu, memory, modules, resolver);
613     }
614   }
615 }
616 
617 // PrintStackMachineReadable prints the call stack in |stack| to stdout,
618 // in the following machine readable pipe-delimited text format:
619 // thread number|frame number|module|function|source file|line|offset
620 //
621 // Module, function, source file, and source line may all be empty
622 // depending on availability.  The code offset follows the same rules as
623 // PrintStack above.
PrintStackMachineReadable(int thread_num,const CallStack * stack)624 static void PrintStackMachineReadable(int thread_num, const CallStack *stack) {
625   int frame_count = stack->frames()->size();
626   for (int frame_index = 0; frame_index < frame_count; ++frame_index) {
627     const StackFrame *frame = stack->frames()->at(frame_index);
628     printf("%d%c%d%c", thread_num, kOutputSeparator, frame_index,
629            kOutputSeparator);
630 
631     uint64_t instruction_address = frame->ReturnAddress();
632 
633     if (frame->module) {
634       assert(!frame->module->code_file().empty());
635       printf("%s", StripSeparator(PathnameStripper::File(
636                      frame->module->code_file())).c_str());
637       if (!frame->function_name.empty()) {
638         printf("%c%s", kOutputSeparator,
639                StripSeparator(frame->function_name).c_str());
640         if (!frame->source_file_name.empty()) {
641           printf("%c%s%c%d%c0x%" PRIx64,
642                  kOutputSeparator,
643                  StripSeparator(frame->source_file_name).c_str(),
644                  kOutputSeparator,
645                  frame->source_line,
646                  kOutputSeparator,
647                  instruction_address - frame->source_line_base);
648         } else {
649           printf("%c%c%c0x%" PRIx64,
650                  kOutputSeparator,  // empty source file
651                  kOutputSeparator,  // empty source line
652                  kOutputSeparator,
653                  instruction_address - frame->function_base);
654         }
655       } else {
656         printf("%c%c%c%c0x%" PRIx64,
657                kOutputSeparator,  // empty function name
658                kOutputSeparator,  // empty source file
659                kOutputSeparator,  // empty source line
660                kOutputSeparator,
661                instruction_address - frame->module->base_address());
662       }
663     } else {
664       // the printf before this prints a trailing separator for module name
665       printf("%c%c%c%c0x%" PRIx64,
666              kOutputSeparator,  // empty function name
667              kOutputSeparator,  // empty source file
668              kOutputSeparator,  // empty source line
669              kOutputSeparator,
670              instruction_address);
671     }
672     printf("\n");
673   }
674 }
675 
676 // ContainsModule checks whether a given |module| is in the vector
677 // |modules_without_symbols|.
ContainsModule(const vector<const CodeModule * > * modules,const CodeModule * module)678 static bool ContainsModule(
679     const vector<const CodeModule*> *modules,
680     const CodeModule *module) {
681   assert(modules);
682   assert(module);
683   vector<const CodeModule*>::const_iterator iter;
684   for (iter = modules->begin(); iter != modules->end(); ++iter) {
685     if (module->debug_file().compare((*iter)->debug_file()) == 0 &&
686         module->debug_identifier().compare((*iter)->debug_identifier()) == 0) {
687       return true;
688     }
689   }
690   return false;
691 }
692 
693 // PrintModule prints a single |module| to stdout.
694 // |modules_without_symbols| should contain the list of modules that were
695 // confirmed to be missing their symbols during the stack walk.
PrintModule(const CodeModule * module,const vector<const CodeModule * > * modules_without_symbols,const vector<const CodeModule * > * modules_with_corrupt_symbols,uint64_t main_address)696 static void PrintModule(
697     const CodeModule *module,
698     const vector<const CodeModule*> *modules_without_symbols,
699     const vector<const CodeModule*> *modules_with_corrupt_symbols,
700     uint64_t main_address) {
701   string symbol_issues;
702   if (ContainsModule(modules_without_symbols, module)) {
703     symbol_issues = "  (WARNING: No symbols, " +
704         PathnameStripper::File(module->debug_file()) + ", " +
705         module->debug_identifier() + ")";
706   } else if (ContainsModule(modules_with_corrupt_symbols, module)) {
707     symbol_issues = "  (WARNING: Corrupt symbols, " +
708         PathnameStripper::File(module->debug_file()) + ", " +
709         module->debug_identifier() + ")";
710   }
711   uint64_t base_address = module->base_address();
712   printf("0x%08" PRIx64 " - 0x%08" PRIx64 "  %s  %s%s%s\n",
713          base_address, base_address + module->size() - 1,
714          PathnameStripper::File(module->code_file()).c_str(),
715          module->version().empty() ? "???" : module->version().c_str(),
716          main_address != 0 && base_address == main_address ? "  (main)" : "",
717          symbol_issues.c_str());
718 }
719 
720 // PrintModules prints the list of all loaded |modules| to stdout.
721 // |modules_without_symbols| should contain the list of modules that were
722 // confirmed to be missing their symbols during the stack walk.
PrintModules(const CodeModules * modules,const vector<const CodeModule * > * modules_without_symbols,const vector<const CodeModule * > * modules_with_corrupt_symbols)723 static void PrintModules(
724     const CodeModules *modules,
725     const vector<const CodeModule*> *modules_without_symbols,
726     const vector<const CodeModule*> *modules_with_corrupt_symbols) {
727   if (!modules)
728     return;
729 
730   printf("\n");
731   printf("Loaded modules:\n");
732 
733   uint64_t main_address = 0;
734   const CodeModule *main_module = modules->GetMainModule();
735   if (main_module) {
736     main_address = main_module->base_address();
737   }
738 
739   unsigned int module_count = modules->module_count();
740   for (unsigned int module_sequence = 0;
741        module_sequence < module_count;
742        ++module_sequence) {
743     const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
744     PrintModule(module, modules_without_symbols, modules_with_corrupt_symbols,
745                 main_address);
746   }
747 }
748 
749 // PrintModulesMachineReadable outputs a list of loaded modules,
750 // one per line, in the following machine-readable pipe-delimited
751 // text format:
752 // Module|{Module Filename}|{Version}|{Debug Filename}|{Debug Identifier}|
753 // {Base Address}|{Max Address}|{Main}
PrintModulesMachineReadable(const CodeModules * modules)754 static void PrintModulesMachineReadable(const CodeModules *modules) {
755   if (!modules)
756     return;
757 
758   uint64_t main_address = 0;
759   const CodeModule *main_module = modules->GetMainModule();
760   if (main_module) {
761     main_address = main_module->base_address();
762   }
763 
764   unsigned int module_count = modules->module_count();
765   for (unsigned int module_sequence = 0;
766        module_sequence < module_count;
767        ++module_sequence) {
768     const CodeModule *module = modules->GetModuleAtSequence(module_sequence);
769     uint64_t base_address = module->base_address();
770     printf("Module%c%s%c%s%c%s%c%s%c0x%08" PRIx64 "%c0x%08" PRIx64 "%c%d\n",
771            kOutputSeparator,
772            StripSeparator(PathnameStripper::File(module->code_file())).c_str(),
773            kOutputSeparator, StripSeparator(module->version()).c_str(),
774            kOutputSeparator,
775            StripSeparator(PathnameStripper::File(module->debug_file())).c_str(),
776            kOutputSeparator,
777            StripSeparator(module->debug_identifier()).c_str(),
778            kOutputSeparator, base_address,
779            kOutputSeparator, base_address + module->size() - 1,
780            kOutputSeparator,
781            main_module != NULL && base_address == main_address ? 1 : 0);
782   }
783 }
784 
785 }  // namespace
786 
PrintProcessState(const ProcessState & process_state,bool output_stack_contents,SourceLineResolverInterface * resolver)787 void PrintProcessState(const ProcessState& process_state,
788                        bool output_stack_contents,
789                        SourceLineResolverInterface* resolver) {
790   // Print OS and CPU information.
791   string cpu = process_state.system_info()->cpu;
792   string cpu_info = process_state.system_info()->cpu_info;
793   printf("Operating system: %s\n", process_state.system_info()->os.c_str());
794   printf("                  %s\n",
795          process_state.system_info()->os_version.c_str());
796   printf("CPU: %s\n", cpu.c_str());
797   if (!cpu_info.empty()) {
798     // This field is optional.
799     printf("     %s\n", cpu_info.c_str());
800   }
801   printf("     %d CPU%s\n",
802          process_state.system_info()->cpu_count,
803          process_state.system_info()->cpu_count != 1 ? "s" : "");
804   printf("\n");
805 
806   // Print crash information.
807   if (process_state.crashed()) {
808     printf("Crash reason:  %s\n", process_state.crash_reason().c_str());
809     printf("Crash address: 0x%" PRIx64 "\n", process_state.crash_address());
810   } else {
811     printf("No crash\n");
812   }
813 
814   string assertion = process_state.assertion();
815   if (!assertion.empty()) {
816     printf("Assertion: %s\n", assertion.c_str());
817   }
818 
819   // Compute process uptime if the process creation and crash times are
820   // available in the dump.
821   if (process_state.time_date_stamp() != 0 &&
822       process_state.process_create_time() != 0 &&
823       process_state.time_date_stamp() >= process_state.process_create_time()) {
824     printf("Process uptime: %d seconds\n",
825            process_state.time_date_stamp() -
826                process_state.process_create_time());
827   } else {
828     printf("Process uptime: not available\n");
829   }
830 
831   // If the thread that requested the dump is known, print it first.
832   int requesting_thread = process_state.requesting_thread();
833   if (requesting_thread != -1) {
834     printf("\n");
835     printf("Thread %d (%s)\n",
836           requesting_thread,
837           process_state.crashed() ? "crashed" :
838                                     "requested dump, did not crash");
839     PrintStack(process_state.threads()->at(requesting_thread), cpu,
840                output_stack_contents,
841                process_state.thread_memory_regions()->at(requesting_thread),
842                process_state.modules(), resolver);
843   }
844 
845   // Print all of the threads in the dump.
846   int thread_count = process_state.threads()->size();
847   for (int thread_index = 0; thread_index < thread_count; ++thread_index) {
848     if (thread_index != requesting_thread) {
849       // Don't print the crash thread again, it was already printed.
850       printf("\n");
851       printf("Thread %d\n", thread_index);
852       PrintStack(process_state.threads()->at(thread_index), cpu,
853                  output_stack_contents,
854                  process_state.thread_memory_regions()->at(thread_index),
855                  process_state.modules(), resolver);
856     }
857   }
858 
859   PrintModules(process_state.modules(),
860                process_state.modules_without_symbols(),
861                process_state.modules_with_corrupt_symbols());
862 }
863 
PrintProcessStateMachineReadable(const ProcessState & process_state)864 void PrintProcessStateMachineReadable(const ProcessState& process_state) {
865   // Print OS and CPU information.
866   // OS|{OS Name}|{OS Version}
867   // CPU|{CPU Name}|{CPU Info}|{Number of CPUs}
868   printf("OS%c%s%c%s\n", kOutputSeparator,
869          StripSeparator(process_state.system_info()->os).c_str(),
870          kOutputSeparator,
871          StripSeparator(process_state.system_info()->os_version).c_str());
872   printf("CPU%c%s%c%s%c%d\n", kOutputSeparator,
873          StripSeparator(process_state.system_info()->cpu).c_str(),
874          kOutputSeparator,
875          // this may be empty
876          StripSeparator(process_state.system_info()->cpu_info).c_str(),
877          kOutputSeparator,
878          process_state.system_info()->cpu_count);
879 
880   int requesting_thread = process_state.requesting_thread();
881 
882   // Print crash information.
883   // Crash|{Crash Reason}|{Crash Address}|{Crashed Thread}
884   printf("Crash%c", kOutputSeparator);
885   if (process_state.crashed()) {
886     printf("%s%c0x%" PRIx64 "%c",
887            StripSeparator(process_state.crash_reason()).c_str(),
888            kOutputSeparator, process_state.crash_address(), kOutputSeparator);
889   } else {
890     // print assertion info, if available, in place of crash reason,
891     // instead of the unhelpful "No crash"
892     string assertion = process_state.assertion();
893     if (!assertion.empty()) {
894       printf("%s%c%c", StripSeparator(assertion).c_str(),
895              kOutputSeparator, kOutputSeparator);
896     } else {
897       printf("No crash%c%c", kOutputSeparator, kOutputSeparator);
898     }
899   }
900 
901   if (requesting_thread != -1) {
902     printf("%d\n", requesting_thread);
903   } else {
904     printf("\n");
905   }
906 
907   PrintModulesMachineReadable(process_state.modules());
908 
909   // blank line to indicate start of threads
910   printf("\n");
911 
912   // If the thread that requested the dump is known, print it first.
913   if (requesting_thread != -1) {
914     PrintStackMachineReadable(requesting_thread,
915                               process_state.threads()->at(requesting_thread));
916   }
917 
918   // Print all of the threads in the dump.
919   int thread_count = process_state.threads()->size();
920   for (int thread_index = 0; thread_index < thread_count; ++thread_index) {
921     if (thread_index != requesting_thread) {
922       // Don't print the crash thread again, it was already printed.
923       PrintStackMachineReadable(thread_index,
924                                 process_state.threads()->at(thread_index));
925     }
926   }
927 }
928 
929 }  // namespace google_breakpad
930