[mips64] Support for mips n64

src/processor/stackwalker_mips_unittest.cc

 // Copyright (c) 2013, 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 127 matching lines @@
   MockCodeModules modules;
   MockSymbolSupplier supplier;
   BasicSourceLineResolver resolver;
   CallStack call_stack;
   const vector<StackFrame*>* frames;
 };
 
 class SanityCheck: public StackwalkerMIPSFixture, public Test { };
 
 TEST_F(SanityCheck, NoResolver) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   stack_section.start() = 0x80000000;
   stack_section.D32(0).D32(0x0);
   RegionFromSection();
   raw_context.epc = 0x00400020;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
 
   StackFrameSymbolizer frame_symbolizer(NULL, NULL);
   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
                         &frame_symbolizer);
   // This should succeed, even without a resolver or supplier.
   vector<const CodeModule*> modules_without_symbols;
   vector<const CodeModule*> modules_with_corrupt_symbols;
   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                           &modules_with_corrupt_symbols));
   ASSERT_EQ(1U, modules_without_symbols.size());
   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
   frames = call_stack.frames();
   ASSERT_EQ(1U, frames->size());
   StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
   // Check that the values from the original raw context made it
   // through to the context in the stack frame.
   EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
 }
 
 class GetContextFrame: public StackwalkerMIPSFixture, public Test { };
 
 TEST_F(GetContextFrame, Simple) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   stack_section.start() = 0x80000000;
   stack_section.D32(0).D32(0x0);
   RegionFromSection();
   raw_context.epc = 0x00400020;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
 
   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
                          &frame_symbolizer);
   vector<const CodeModule*> modules_without_symbols;
   vector<const CodeModule*> modules_with_corrupt_symbols;
   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                           &modules_with_corrupt_symbols));
   ASSERT_EQ(1U, modules_without_symbols.size());
   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
   frames = call_stack.frames();
   StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
   // Check that the values from the original raw context made it
   // through to the context in the stack frame.
   EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
 }
 
 // The stackwalker should be able to produce the context frame even
 // without stack memory present.
 TEST_F(GetContextFrame, NoStackMemory) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   raw_context.epc = 0x00400020;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
 
   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
   StackwalkerMIPS walker(&system_info, &raw_context, NULL, &modules,
                          &frame_symbolizer);
   vector<const CodeModule*> modules_without_symbols;
   vector<const CodeModule*> modules_with_corrupt_symbols;
   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                           &modules_with_corrupt_symbols));
   ASSERT_EQ(1U, modules_without_symbols.size());
   ASSERT_EQ("module1", modules_without_symbols[0]->debug_file());
   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
   frames = call_stack.frames();
   StackFrameMIPS* frame = static_cast<StackFrameMIPS*>(frames->at(0));
   // Check that the values from the original raw context made it
   // through to the context in the stack frame.
   EXPECT_EQ(0, memcmp(&raw_context, &frame->context, sizeof(raw_context)));
 }
 
 class GetCallerFrame: public StackwalkerMIPSFixture, public Test { };
 
 TEST_F(GetCallerFrame, ScanWithoutSymbols) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   // When the stack walker resorts to scanning the stack,
   // only addresses located within loaded modules are
   // considered valid return addresses.
   // Force scanning through three frames to ensure that the
   // stack pointer is set properly in scan-recovered frames.
   stack_section.start() = 0x80000000;
   uint32_t return_address1 = 0x00400100;
   uint32_t return_address2 = 0x00400900;
   Label frame1_sp, frame2_sp;
   stack_section
@@ skipping 56 matching lines @@
   ASSERT_EQ((StackFrameMIPS::CONTEXT_VALID_PC |
              StackFrameMIPS::CONTEXT_VALID_SP |
              StackFrameMIPS::CONTEXT_VALID_FP |
              StackFrameMIPS::CONTEXT_VALID_RA),
             frame2->context_validity);
   EXPECT_EQ(return_address2 - 2 * sizeof(return_address2), frame2->context.epc);
   EXPECT_EQ(frame2_sp.Value(), frame2->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
 }
 
 TEST_F(GetCallerFrame, ScanWithFunctionSymbols) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   // During stack scanning, if a potential return address
   // is located within a loaded module that has symbols,
   // it is only considered a valid return address if it
   // lies within a function's bounds.
   stack_section.start() = 0x80000000;
   uint32_t return_address = 0x00500200;
   Label frame1_sp;
   stack_section
     // frame 0
     .Append(16, 0)                      // space
@@ skipping 48 matching lines @@
              StackFrameMIPS::CONTEXT_VALID_FP |
              StackFrameMIPS::CONTEXT_VALID_RA),
             frame1->context_validity);
   EXPECT_EQ(return_address - 2 * sizeof(return_address), frame1->context.epc);
   EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
   EXPECT_EQ("marsupial", frame1->function_name);
   EXPECT_EQ(0x00500100U, frame1->function_base);
 }
 
 TEST_F(GetCallerFrame, CheckStackFrameSizeLimit) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   // If the stackwalker resorts to stack scanning, it will scan only
   // 1024 bytes of stack which correspondes to maximum size of stack frame.
   stack_section.start() = 0x80000000;
   uint32_t return_address1 = 0x00500100;
   uint32_t return_address2 = 0x00500900;
   Label frame1_sp, frame2_sp;
   stack_section
     // frame 0
     .Append(32, 0)                      // space
 
@@ skipping 51 matching lines @@
              StackFrameMIPS::CONTEXT_VALID_FP |
              StackFrameMIPS::CONTEXT_VALID_RA),
             frame1->context_validity);
   EXPECT_EQ(return_address1 - 2 * sizeof(return_address1), frame1->context.epc);
   EXPECT_EQ(frame1_sp.Value(), frame1->context.iregs[MD_CONTEXT_MIPS_REG_SP]);
 }
 
 // Test that set_max_frames_scanned prevents using stack scanning
 // to find caller frames.
 TEST_F(GetCallerFrame, ScanningNotAllowed) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   // When the stack walker resorts to scanning the stack,
   // only fixed number of frames are allowed to be scanned out from stack
   stack_section.start() = 0x80000000;
   uint32_t return_address1 = 0x00500100;
   uint32_t return_address2 = 0x00500900;
   Label frame1_sp, frame2_sp;
   stack_section
     // frame 0
     .Append(32, 0)                      // space
 
@@ skipping 189 matching lines @@
 
   // The validity mask to impose on the context frame.
   int context_frame_validity;
 };
 
 class CFI: public CFIFixture, public Test { };
 
 // TODO(gordanac): add CFI tests
 
 TEST_F(CFI, At4004) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   Label frame1_sp = expected.iregs[MD_CONTEXT_MIPS_REG_SP];
   stack_section
     // frame0
     .Append(24, 0)               // space
     .D32(frame1_sp)              // stack pointer
     .D32(0x00405510)             // return address
     .Mark(&frame1_sp);           // This effectively sets stack_section.start().
   raw_context.epc = 0x00404004;
   CheckWalk();
 }
 
 // Check that we reject rules that would cause the stack pointer to
 // move in the wrong direction.
 TEST_F(CFI, RejectBackwards) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   raw_context.epc = 0x40005000;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
   
   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
                          &frame_symbolizer);
   vector<const CodeModule*> modules_without_symbols;
   vector<const CodeModule*> modules_with_corrupt_symbols;
   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                           &modules_with_corrupt_symbols));
   ASSERT_EQ(0U, modules_without_symbols.size());
   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
   frames = call_stack.frames();
   ASSERT_EQ(1U, frames->size());
 }
 
 // Check that we reject rules whose expressions' evaluation fails.
 TEST_F(CFI, RejectBadExpressions) {
+  raw_context.context_flags = raw_context.context_flags | MD_CONTEXT_MIPS_FULL;
   raw_context.epc = 0x00407000;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_SP] = 0x80000000;
   raw_context.iregs[MD_CONTEXT_MIPS_REG_RA] = 0x00405510;
   
   StackFrameSymbolizer frame_symbolizer(&supplier, &resolver);
   StackwalkerMIPS walker(&system_info, &raw_context, &stack_region, &modules,
                          &frame_symbolizer);
   vector<const CodeModule*> modules_without_symbols;
   vector<const CodeModule*> modules_with_corrupt_symbols;
   ASSERT_TRUE(walker.Walk(&call_stack, &modules_without_symbols,
                           &modules_with_corrupt_symbols));
   ASSERT_EQ(0U, modules_without_symbols.size());
   ASSERT_EQ(0U, modules_with_corrupt_symbols.size());
   frames = call_stack.frames();
   ASSERT_EQ(1U, frames->size());
 }