1 // Copyright (c) 2013, 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 // Original author: Gordana Cmiljanovic <gordana.cmiljanovic@imgtec.com>
31 
32 // stackwalker_mips_unittest.cc: Unit tests for StackwalkerMIPS class.
33 
34 #include <string.h>
35 #include <string>
36 #include <vector>
37 
38 #include "breakpad_googletest_includes.h"
39 #include "common/test_assembler.h"
40 #include "common/using_std_string.h"
41 #include "google_breakpad/common/minidump_format.h"
42 #include "google_breakpad/processor/basic_source_line_resolver.h"
43 #include "google_breakpad/processor/call_stack.h"
44 #include "google_breakpad/processor/code_module.h"
45 #include "google_breakpad/processor/source_line_resolver_interface.h"
46 #include "google_breakpad/processor/stack_frame_cpu.h"
47 #include "processor/stackwalker_unittest_utils.h"
48 #include "processor/stackwalker_mips.h"
49 #include "processor/windows_frame_info.h"
50 
51 using google_breakpad::BasicSourceLineResolver;
52 using google_breakpad::CallStack;
53 using google_breakpad::CodeModule;
54 using google_breakpad::StackFrameSymbolizer;
55 using google_breakpad::StackFrame;
56 using google_breakpad::StackFrameMIPS;
57 using google_breakpad::Stackwalker;
58 using google_breakpad::StackwalkerMIPS;
59 using google_breakpad::SystemInfo;
60 using google_breakpad::WindowsFrameInfo;
61 using google_breakpad::test_assembler::kLittleEndian;
62 using google_breakpad::test_assembler::Label;
63 using google_breakpad::test_assembler::Section;
64 using std::vector;
65 using testing::_;
66 using testing::AnyNumber;
67 using testing::Return;
68 using testing::SetArgumentPointee;
69 using testing::Test;
70 
71 class StackwalkerMIPSFixture {
72  public:
StackwalkerMIPSFixture()73   StackwalkerMIPSFixture()
74     : stack_section(kLittleEndian),
75       // Give the two modules reasonable standard locations and names
76       // for tests to play with.
77       module1(0x00400000, 0x10000, "module1", "version1"),
78       module2(0x00500000, 0x10000, "module2", "version2") {
79     // Identify the system as a Linux system.
80     system_info.os = "Linux";
81     system_info.os_short = "linux";
82     system_info.os_version = "Observant Opossum";  // Jealous Jellyfish
83     system_info.cpu = "mips";
84     system_info.cpu_info = "";
85 
86     // Put distinctive values in the raw CPU context.
87     BrandContext(&raw_context);
88 
89     // Create some modules with some stock debugging information.
90     modules.Add(&module1);
91     modules.Add(&module2);
92 
93     // By default, none of the modules have symbol info; call
94     // SetModuleSymbols to override this.
95     EXPECT_CALL(supplier, GetCStringSymbolData(_, _, _, _, _))
96       .WillRepeatedly(Return(MockSymbolSupplier::NOT_FOUND));
97 
98     // Avoid GMOCK WARNING "Uninteresting mock function call - returning
99     // directly" for FreeSymbolData().
100     EXPECT_CALL(supplier, FreeSymbolData(_)).Times(AnyNumber());
101 
102     // Reset max_frames_scanned since it's static.
103     Stackwalker::set_max_frames_scanned(1024);
104   }
105 
106   // Set the Breakpad symbol information that supplier should return for
107   // MODULE to INFO.
SetModuleSymbols(MockCodeModule * module,const string & info)108   void SetModuleSymbols(MockCodeModule* module, const string& info) {
109     size_t buffer_size;
110     char* buffer = supplier.CopySymbolDataAndOwnTheCopy(info, &buffer_size);
111     EXPECT_CALL(supplier, GetCStringSymbolData(module, &system_info, _, _, _))
112       .WillRepeatedly(DoAll(SetArgumentPointee<3>(buffer),
113                             SetArgumentPointee<4>(buffer_size),
114                             Return(MockSymbolSupplier::FOUND)));
115   }
116 
117   // Populate stack_region with the contents of stack_section. Use
118   // stack_section.start() as the region's starting address.
RegionFromSection()119   void RegionFromSection() {
120     string contents;
121     ASSERT_TRUE(stack_section.GetContents(&contents));
122     stack_region.Init(stack_section.start().Value(), contents);
123   }
124 
125   // Fill RAW_CONTEXT with pseudo-random data, for round-trip checking.
BrandContext(MDRawContextMIPS * raw_context)126   void BrandContext(MDRawContextMIPS* raw_context) {
127     uint8_t x = 173;
128     for (size_t i = 0; i < sizeof(*raw_context); ++i)
129       reinterpret_cast<uint8_t*>(raw_context)[i] = (x += 17);
130   }
131 
132   SystemInfo system_info;
133   MDRawContextMIPS raw_context;
134   Section stack_section;
135   MockMemoryRegion stack_region;
136   MockCodeModule module1;
137   MockCodeModule module2;
138   MockCodeModules modules;
139   MockSymbolSupplier supplier;
140   BasicSourceLineResolver resolver;
141   CallStack call_stack;
142   const vector<StackFrame*>* frames;
143 };
144 
145 class SanityCheck: public StackwalkerMIPSFixture, public Test { };
146 
TEST_F(SanityCheck,NoResolver)147 TEST_F(SanityCheck, NoResolver) {
148   stack_section.start() = 0x80000000;
149   stack_section.D32(0).D32(0x0);
150   RegionFromSection();
151   raw_context.epc = 0x00400020;
152   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
153 
154   StackFrameSymbolizer frame_symbolizer(NULL, NULL);
155   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
156                         &frame_symbolizer);
157   // This should succeed, even without a resolver or supplier.
158   vector<const CodeModule*> modules_without_symbols;
159   vector<const CodeModule*> modules_with_corrupt_symbols;
160   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
161                           &modules_with_corrupt_symbols));
162   ASSERT_EQ(1U, modules_without_symbols.size());
163   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
164   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
165   frames = call_stack.frames();
166   ASSERT_EQ(1U, frames->size());
167   StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
168   // Check that the values from the original raw context made it
169   // through to the context in the stack frame.
170   EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
171 }
172 
173 class GetContextFrame: public StackwalkerMIPSFixture, public Test { };
174 
TEST_F(GetContextFrame,Simple)175 TEST_F(GetContextFrame, Simple) {
176   stack_section.start() = 0x80000000;
177   stack_section.D32(0).D32(0x0);
178   RegionFromSection();
179   raw_context.epc = 0x00400020;
180   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
181 
182   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
183   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
184                          &frame_symbolizer);
185   vector<const CodeModule*> modules_without_symbols;
186   vector<const CodeModule*> modules_with_corrupt_symbols;
187   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
188                           &modules_with_corrupt_symbols));
189   ASSERT_EQ(1U, modules_without_symbols.size());
190   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
191   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
192   frames = call_stack.frames();
193   StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
194   // Check that the values from the original raw context made it
195   // through to the context in the stack frame.
196   EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
197 }
198 
199 // The stackwalker should be able to produce the context frame even
200 // without stack memory present.
TEST_F(GetContextFrame,NoStackMemory)201 TEST_F(GetContextFrame, NoStackMemory) {
202   raw_context.epc = 0x00400020;
203   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
204 
205   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
206   StackwalkerMIPS walker(&system_info, &raw_context, NULL, &modules,
207                          &frame_symbolizer);
208   vector<const CodeModule*> modules_without_symbols;
209   vector<const CodeModule*> modules_with_corrupt_symbols;
210   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
211                           &modules_with_corrupt_symbols));
212   ASSERT_EQ(1U, modules_without_symbols.size());
213   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
214   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
215   frames = call_stack.frames();
216   StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
217   // Check that the values from the original raw context made it
218   // through to the context in the stack frame.
219   EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
220 }
221 
222 class GetCallerFrame: public StackwalkerMIPSFixture, public Test { };
223 
TEST_F(GetCallerFrame,ScanWithoutSymbols)224 TEST_F(GetCallerFrame, ScanWithoutSymbols) {
225   // When the stack walker resorts to scanning the stack,
226   // only addresses located within loaded modules are
227   // considered valid return addresses.
228   // Force scanning through three frames to ensure that the
229   // stack pointer is set properly in scan-recovered frames.
230   stack_section.start() = 0x80000000;
231   uint32_t return_address1 = 0x00400100;
232   uint32_t return_address2 = 0x00400900;
233   Label frame1_sp, frame2_sp;
234   stack_section
235     // frame 0
236     .Append(16, 0)                      // space
237 
238     .D32(0x00490000)                    // junk that's not
239     .D32(0x00600000)                    // a return address
240 
241     .D32(frame1_sp)                     // stack pointer
242     .D32(return_address1)               // actual return address
243     // frame 1
244     .Mark(&frame1_sp)
245     .Append(16, 0)                      // space
246 
247     .D32(0xF0000000)                    // more junk
248     .D32(0x0000000D)
249 
250     .D32(frame2_sp)                     // stack pointer
251     .D32(return_address2)               // actual return address
252     // frame 2
253     .Mark(&frame2_sp)
254     .Append(32, 0);                     // end of stack
255   RegionFromSection();
256 
257   raw_context.epc = 0x00405510;
258   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
259   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address1;
260 
261   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
262   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
263                          &frame_symbolizer);
264   vector<const CodeModule*> modules_without_symbols;
265   vector<const CodeModule*> modules_with_corrupt_symbols;
266   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
267                           &modules_with_corrupt_symbols));
268   ASSERT_EQ(1U, modules_without_symbols.size());
269   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
270   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
271   frames = call_stack.frames();
272   ASSERT_EQ(3U, frames->size());
273 
274   StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
275   EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
276   ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
277   EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
278 
279   StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
280   EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
281   ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
282              StackFrameMIPS::CONTEXT_VALID_SP |
283              StackFrameMIPS::CONTEXT_VALID_FP |
284              StackFrameMIPS::CONTEXT_VALID_RA),
285             frame1->context_validity);
286   EXPECT_EQ(return_address1 - 2 * sizeof(return_address1), frame1->context.epc);
287   EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
288 
289   StackFrameMIPS* frame2 = static_cast<StackFrameMIPS*>(frames->at(2));
290   EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame2->trust);
291   ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
292              StackFrameMIPS::CONTEXT_VALID_SP |
293              StackFrameMIPS::CONTEXT_VALID_FP |
294              StackFrameMIPS::CONTEXT_VALID_RA),
295             frame2->context_validity);
296   EXPECT_EQ(return_address2 - 2 * sizeof(return_address2), frame2->context.epc);
297   EXPECT_EQ(frame2_sp.Value(), frame2->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
298 }
299 
TEST_F(GetCallerFrame,ScanWithFunctionSymbols)300 TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
301   // During stack scanning, if a potential return address
302   // is located within a loaded module that has symbols,
303   // it is only considered a valid return address if it
304   // lies within a function's bounds.
305   stack_section.start() = 0x80000000;
306   uint32_t return_address = 0x00500200;
307   Label frame1_sp;
308   stack_section
309     // frame 0
310     .Append(16, 0)                      // space
311 
312     .D32(0x00490000)                    // junk that's not
313     .D32(0x00600000)                    // a return address
314 
315     .D32(0x00401000)                    // a couple of plausible addresses
316     .D32(0x0050F000)                    // that are not within functions
317 
318     .D32(frame1_sp)                     // stack pointer
319     .D32(return_address)                // actual return address
320     // frame 1
321     .Mark(&frame1_sp)
322     .Append(32, 0);                     // end of stack
323   RegionFromSection();
324 
325   raw_context.epc = 0x00400200;
326   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
327   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address;
328 
329   SetModuleSymbols(&module1,
330                    // The youngest frame's function.
331                    "FUNC 100 400 10 monotreme\n");
332   SetModuleSymbols(&module2,
333                    // The calling frame's function.
334                    "FUNC 100 400 10 marsupial\n");
335 
336   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
337   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
338                          &frame_symbolizer);
339   vector<const CodeModule*> modules_without_symbols;
340   vector<const CodeModule*> modules_with_corrupt_symbols;
341   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
342                           &modules_with_corrupt_symbols));
343   ASSERT_EQ(0U, modules_without_symbols.size());
344   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
345   frames = call_stack.frames();
346   ASSERT_EQ(2U, frames->size());
347 
348   StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
349   EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
350   ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
351   EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
352   EXPECT_EQ("monotreme", frame0->function_name);
353   EXPECT_EQ(0x00400100U, frame0->function_base);
354 
355   StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
356   EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
357   ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
358              StackFrameMIPS::CONTEXT_VALID_SP |
359              StackFrameMIPS::CONTEXT_VALID_FP |
360              StackFrameMIPS::CONTEXT_VALID_RA),
361             frame1->context_validity);
362   EXPECT_EQ(return_address - 2 * sizeof(return_address), frame1->context.epc);
363   EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
364   EXPECT_EQ("marsupial", frame1->function_name);
365   EXPECT_EQ(0x00500100U, frame1->function_base);
366 }
367 
TEST_F(GetCallerFrame,CheckStackFrameSizeLimit)368 TEST_F(GetCallerFrame, CheckStackFrameSizeLimit) {
369   // If the stackwalker resorts to stack scanning, it will scan only
370   // 1024 bytes of stack which correspondes to maximum size of stack frame.
371   stack_section.start() = 0x80000000;
372   uint32_t return_address1 = 0x00500100;
373   uint32_t return_address2 = 0x00500900;
374   Label frame1_sp, frame2_sp;
375   stack_section
376     // frame 0
377     .Append(32, 0)                      // space
378 
379     .D32(0x00490000)                    // junk that's not
380     .D32(0x00600000)                    // a return address
381 
382     .Append(96, 0)                      // more space
383 
384     .D32(frame1_sp)                     // stack pointer
385     .D32(return_address1)               // actual return address
386     // frame 1
387     .Mark(&frame1_sp)
388     .Append(128 * 4, 0)                 // space
389 
390     .D32(0x00F00000)                    // more junk
391     .D32(0x0000000D)
392 
393     .Append(128 * 4, 0)                 // more space
394 
395     .D32(frame2_sp)                     // stack pointer
396     .D32(return_address2)               // actual return address
397                                         // (won't be found)
398     // frame 2
399     .Mark(&frame2_sp)
400     .Append(32, 0);                     // end of stack
401   RegionFromSection();
402 
403   raw_context.epc = 0x00405510;
404   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
405   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address1;
406 
407   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
408   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
409                          &frame_symbolizer);
410   vector<const CodeModule*> modules_without_symbols;
411   vector<const CodeModule*> modules_with_corrupt_symbols;
412   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
413                           &modules_with_corrupt_symbols));
414   ASSERT_EQ(2U, modules_without_symbols.size());
415   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
416   ASSERT_EQ("module2", modules_without_symbols[1]->debug_file());
417   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
418   frames = call_stack.frames();
419   ASSERT_EQ(2U, frames->size());
420 
421   StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
422   EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
423   ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
424   EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
425 
426   StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
427   EXPECT_EQ(StackFrame::FRAME_TRUST_SCAN, frame1->trust);
428   ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
429              StackFrameMIPS::CONTEXT_VALID_SP |
430              StackFrameMIPS::CONTEXT_VALID_FP |
431              StackFrameMIPS::CONTEXT_VALID_RA),
432             frame1->context_validity);
433   EXPECT_EQ(return_address1 - 2 * sizeof(return_address1), frame1->context.epc);
434   EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
435 }
436 
437 // Test that set_max_frames_scanned prevents using stack scanning
438 // to find caller frames.
TEST_F(GetCallerFrame,ScanningNotAllowed)439 TEST_F(GetCallerFrame, ScanningNotAllowed) {
440   // When the stack walker resorts to scanning the stack,
441   // only fixed number of frames are allowed to be scanned out from stack
442   stack_section.start() = 0x80000000;
443   uint32_t return_address1 = 0x00500100;
444   uint32_t return_address2 = 0x00500900;
445   Label frame1_sp, frame2_sp;
446   stack_section
447     // frame 0
448     .Append(32, 0)                      // space
449 
450     .D32(0x00490000)                    // junk that's not
451     .D32(0x00600000)                    // a return address
452 
453     .Append(96, 0)                      // more space
454 
455     .D32(frame1_sp)                     // stack pointer
456     .D32(return_address1)               // actual return address
457     // frame 1
458     .Mark(&frame1_sp)
459     .Append(128 * 4, 0)                 // space
460 
461     .D32(0x00F00000)                    // more junk
462     .D32(0x0000000D)
463 
464     .Append(128 * 4, 0)                 // more space
465 
466     .D32(frame2_sp)                     // stack pointer
467     .D32(return_address2)               // actual return address
468                                         // (won't be found)
469     // frame 2
470     .Mark(&frame2_sp)
471     .Append(32, 0);                     // end of stack
472   RegionFromSection();
473 
474   raw_context.epc = 0x00405510;
475   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
476   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = return_address1;
477 
478   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
479   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
480                          &frame_symbolizer);
481   Stackwalker::set_max_frames_scanned(0);
482 
483   vector<const CodeModule*> modules_without_symbols;
484   vector<const CodeModule*> modules_with_corrupt_symbols;
485   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
486                           &modules_with_corrupt_symbols));
487   ASSERT_EQ(1U, modules_without_symbols.size());
488   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
489   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
490   frames = call_stack.frames();
491   ASSERT_EQ(1U, frames->size());
492 
493   StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
494   EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
495   ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
496   EXPECT_EQ(0, memcmp(&raw_context, &frame0->context, sizeof(raw_context)));
497 }
498 
499 struct CFIFixture: public StackwalkerMIPSFixture {
CFIFixtureCFIFixture500   CFIFixture() {
501     // Provide some STACK CFI records;
502     SetModuleSymbols(&module1,
503                      // The youngest frame's function.
504                      "FUNC 4000 1000 0 enchiridion\n"
505                      // Initially, nothing has been pushed on the stack,
506                      // and the return address is still in the $ra register.
507                      "STACK CFI INIT 4000 1000 .cfa: $sp 0 + .ra: $ra\n"
508                      // Move stack pointer.
509                      "STACK CFI 4004 .cfa: $sp 32 +\n"
510                      // store $fp and ra
511                      "STACK CFI 4008 $fp: .cfa -8 + ^ .ra: .cfa -4 + ^\n"
512                      // restore $fp
513                      "STACK CFI 400c .cfa: $fp 32 +\n"
514                      // restore $sp
515                      "STACK CFI 4018 .cfa: $sp 32 +\n"
516 
517                      "STACK CFI 4020 $fp: $fp .cfa: $sp 0 + .ra: .ra\n"
518 
519                      // The calling function.
520                      "FUNC 5000 1000 0 epictetus\n"
521                      // Initially, nothing has been pushed on the stack,
522                      // and the return address is still in the $ra register.
523                      "STACK CFI INIT 5000 1000 .cfa: $sp .ra: $ra\n"
524                      // Mark it as end of stack.
525                      "STACK CFI INIT 5000 8 .cfa: $sp 0 + .ra: $ra\n"
526 
527                      // A function whose CFI makes the stack pointer
528                      // go backwards.
529                      "FUNC 6000 1000 20 palinal\n"
530                      "STACK CFI INIT 6000 1000 .cfa: $sp 4 - .ra: $ra\n"
531 
532                      // A function with CFI expressions that can't be
533                      // evaluated.
534                      "FUNC 7000 1000 20 rhetorical\n"
535                      "STACK CFI INIT 7000 1000 .cfa: moot .ra: ambiguous\n"
536                    );
537 
538     // Provide some distinctive values for the caller's registers.
539     expected.epc = 0x00405508;
540     expected.iregs[MD_CONTEXT_MIPS_REG_S0] = 0x0;
541     expected.iregs[MD_CONTEXT_MIPS_REG_S1] = 0x1;
542     expected.iregs[MD_CONTEXT_MIPS_REG_S2] = 0x2;
543     expected.iregs[MD_CONTEXT_MIPS_REG_S3] = 0x3;
544     expected.iregs[MD_CONTEXT_MIPS_REG_S4] = 0x4;
545     expected.iregs[MD_CONTEXT_MIPS_REG_S5] = 0x5;
546     expected.iregs[MD_CONTEXT_MIPS_REG_S6] = 0x6;
547     expected.iregs[MD_CONTEXT_MIPS_REG_S7] = 0x7;
548     expected.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
549     expected.iregs[MD_CONTEXT_MIPS_REG_FP] = 0x80000000;
550     expected.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
551 
552     // Expect CFI to recover all callee-save registers. Since CFI is the
553     // only stack frame construction technique we have, aside from the
554     // context frame itself, there's no way for us to have a set of valid
555     // registers smaller than this.
556     expected_validity = (StackFrameMIPS::CONTEXT_VALID_PC |
557                          StackFrameMIPS::CONTEXT_VALID_S0 |
558                          StackFrameMIPS::CONTEXT_VALID_S1 |
559                          StackFrameMIPS::CONTEXT_VALID_S2 |
560                          StackFrameMIPS::CONTEXT_VALID_S3 |
561                          StackFrameMIPS::CONTEXT_VALID_S4 |
562                          StackFrameMIPS::CONTEXT_VALID_S5 |
563                          StackFrameMIPS::CONTEXT_VALID_S6 |
564                          StackFrameMIPS::CONTEXT_VALID_S7 |
565                          StackFrameMIPS::CONTEXT_VALID_SP |
566                          StackFrameMIPS::CONTEXT_VALID_FP |
567                          StackFrameMIPS::CONTEXT_VALID_RA);
568 
569     // By default, context frames provide all registers, as normal.
570     context_frame_validity = StackFrameMIPS::CONTEXT_VALID_ALL;
571 
572     // By default, registers are unchanged.
573     raw_context = expected;
574   }
575 
576   // Walk the stack, using stack_section as the contents of the stack
577   // and raw_context as the current register values. (Set the stack
578   // pointer to the stack's starting address.) Expect two stack
579   // frames; in the older frame, expect the callee-saves registers to
580   // have values matching those in 'expected'.
CheckWalkCFIFixture581   void CheckWalk() {
582     RegionFromSection();
583     raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = stack_section.start().Value();
584 
585     StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
586     StackwalkerMIPS walker(&system_info, &raw_context, &stack_region,
587                            &modules, &frame_symbolizer);
588     vector<const CodeModule*> modules_without_symbols;
589     vector<const CodeModule*> modules_with_corrupt_symbols;
590     ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
591                             &modules_with_corrupt_symbols));
592     ASSERT_EQ(0U, modules_without_symbols.size());
593     ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
594     frames = call_stack.frames();
595     ASSERT_EQ(2U, frames->size());
596 
597     StackFrameMIPS* frame0 = static_cast<StackFrameMIPS*>(frames->at(0));
598     EXPECT_EQ(StackFrame::FRAME_TRUST_CONTEXT, frame0->trust);
599     ASSERT_EQ(StackFrameMIPS::CONTEXT_VALID_ALL, frame0->context_validity);
600     EXPECT_EQ("enchiridion", frame0->function_name);
601     EXPECT_EQ(0x00404000U, frame0->function_base);
602 
603     StackFrameMIPS* frame1 = static_cast<StackFrameMIPS*>(frames->at(1));
604     EXPECT_EQ(StackFrame::FRAME_TRUST_CFI, frame1->trust);
605     ASSERT_EQ(expected_validity, frame1->context_validity);
606     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S0],
607               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S0]);
608     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S1],
609               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S1]);
610     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S2],
611               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S2]);
612     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S3],
613               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S3]);
614     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S4],
615               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S4]);
616     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S5],
617               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S5]);
618     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S6],
619               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S6]);
620     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_S7],
621               frame1->context.iregs[MD_CONTEXT_MIPS_REG_S7]);
622     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_FP],
623               frame1->context.iregs[MD_CONTEXT_MIPS_REG_FP]);
624     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_RA],
625               frame1->context.iregs[MD_CONTEXT_MIPS_REG_RA]);
626     EXPECT_EQ(expected.iregs[MD_CONTEXT_MIPS_REG_SP],
627               frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
628     EXPECT_EQ(expected.epc, frame1->context.epc);
629     EXPECT_EQ(expected.epc, frame1->instruction);
630     EXPECT_EQ("epictetus", frame1->function_name);
631     EXPECT_EQ(0x00405000U, frame1->function_base);
632   }
633 
634   // The values we expect to find for the caller's registers.
635   MDRawContextMIPS expected;
636 
637   // The validity mask for expected.
638   int expected_validity;
639 
640   // The validity mask to impose on the context frame.
641   int context_frame_validity;
642 };
643 
644 class CFI: public CFIFixture, public Test { };
645 
646 // TODO(gordanac): add CFI tests
647 
TEST_F(CFI,At4004)648 TEST_F(CFI, At4004) {
649   Label frame1_sp = expected.iregs[MD_CONTEXT_MIPS_REG_SP];
650   stack_section
651     // frame0
652     .Append(24, 0)               // space
653     .D32(frame1_sp)              // stack pointer
654     .D32(0x00405510)             // return address
655     .Mark(&frame1_sp);           // This effectively sets stack_section.start().
656   raw_context.epc = 0x00404004;
657   CheckWalk();
658 }
659 
660 // Check that we reject rules that would cause the stack pointer to
661 // move in the wrong direction.
TEST_F(CFI,RejectBackwards)662 TEST_F(CFI, RejectBackwards) {
663   raw_context.epc = 0x40005000;
664   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
665   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
666 
667   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
668   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
669                          &frame_symbolizer);
670   vector<const CodeModule*> modules_without_symbols;
671   vector<const CodeModule*> modules_with_corrupt_symbols;
672   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
673                           &modules_with_corrupt_symbols));
674   ASSERT_EQ(0U, modules_without_symbols.size());
675   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
676   frames = call_stack.frames();
677   ASSERT_EQ(1U, frames->size());
678 }
679 
680 // Check that we reject rules whose expressions' evaluation fails.
TEST_F(CFI,RejectBadExpressions)681 TEST_F(CFI, RejectBadExpressions) {
682   raw_context.epc = 0x00407000;
683   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
684   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
685 
686   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
687   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
688                          &frame_symbolizer);
689   vector<const CodeModule*> modules_without_symbols;
690   vector<const CodeModule*> modules_with_corrupt_symbols;
691   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
692                           &modules_with_corrupt_symbols));
693   ASSERT_EQ(0U, modules_without_symbols.size());
694   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
695   frames = call_stack.frames();
696   ASSERT_EQ(1U, frames->size());
697 }
698