michael@0: // -*- mode: c++ -*- michael@0: michael@0: // Copyright (c) 2010 Google Inc. michael@0: // All rights reserved. michael@0: // michael@0: // Redistribution and use in source and binary forms, with or without michael@0: // modification, are permitted provided that the following conditions are michael@0: // met: michael@0: // michael@0: // * Redistributions of source code must retain the above copyright michael@0: // notice, this list of conditions and the following disclaimer. michael@0: // * Redistributions in binary form must reproduce the above michael@0: // copyright notice, this list of conditions and the following disclaimer michael@0: // in the documentation and/or other materials provided with the michael@0: // distribution. michael@0: // * Neither the name of Google Inc. nor the names of its michael@0: // contributors may be used to endorse or promote products derived from michael@0: // this software without specific prior written permission. michael@0: // michael@0: // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS michael@0: // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT michael@0: // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR michael@0: // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT michael@0: // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, michael@0: // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT michael@0: // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, michael@0: // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY michael@0: // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT michael@0: // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE michael@0: // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. michael@0: michael@0: // stackwalker_x86.h: x86-specific stackwalker. michael@0: // michael@0: // Provides stack frames given x86 register context and a memory region michael@0: // corresponding to an x86 stack. michael@0: // michael@0: // Author: Mark Mentovai michael@0: michael@0: michael@0: #ifndef PROCESSOR_STACKWALKER_X86_H__ michael@0: #define PROCESSOR_STACKWALKER_X86_H__ michael@0: michael@0: #include michael@0: michael@0: #include "google_breakpad/common/breakpad_types.h" michael@0: #include "google_breakpad/common/minidump_format.h" michael@0: #include "google_breakpad/processor/stackwalker.h" michael@0: #include "google_breakpad/processor/stack_frame_cpu.h" michael@0: #include "processor/cfi_frame_info.h" michael@0: michael@0: namespace google_breakpad { michael@0: michael@0: class CodeModules; michael@0: michael@0: michael@0: class StackwalkerX86 : public Stackwalker { michael@0: public: michael@0: // context is an x86 context object that gives access to x86-specific michael@0: // register state corresponding to the innermost called frame to be michael@0: // included in the stack. The other arguments are passed directly through michael@0: // to the base Stackwalker constructor. michael@0: StackwalkerX86(const SystemInfo* system_info, michael@0: const MDRawContextX86* context, michael@0: MemoryRegion* memory, michael@0: const CodeModules* modules, michael@0: StackFrameSymbolizer* frame_symbolizer); michael@0: michael@0: private: michael@0: // A STACK CFI-driven frame walker for the X86. michael@0: typedef SimpleCFIWalker CFIWalker; michael@0: michael@0: // Implementation of Stackwalker, using x86 context (%ebp, %esp, %eip) and michael@0: // stack conventions (saved %ebp at [%ebp], saved %eip at 4[%ebp], or michael@0: // alternate conventions as guided by any WindowsFrameInfo available for the michael@0: // code in question.). michael@0: virtual StackFrame* GetContextFrame(); michael@0: virtual StackFrame* GetCallerFrame(const CallStack* stack, michael@0: bool stack_scan_allowed); michael@0: michael@0: // Use windows_frame_info (derived from STACK WIN and FUNC records) michael@0: // to construct the frame that called frames.back(). The caller michael@0: // takes ownership of the returned frame. Return NULL on failure. michael@0: StackFrameX86* GetCallerByWindowsFrameInfo( michael@0: const vector &frames, michael@0: WindowsFrameInfo* windows_frame_info, michael@0: bool stack_scan_allowed); michael@0: michael@0: // Use cfi_frame_info (derived from STACK CFI records) to construct michael@0: // the frame that called frames.back(). The caller takes ownership michael@0: // of the returned frame. Return NULL on failure. michael@0: StackFrameX86* GetCallerByCFIFrameInfo(const vector &frames, michael@0: CFIFrameInfo* cfi_frame_info); michael@0: michael@0: // Assuming a traditional frame layout --- where the caller's %ebp michael@0: // has been pushed just after the return address and the callee's michael@0: // %ebp points to the saved %ebp --- construct the frame that called michael@0: // frames.back(). The caller takes ownership of the returned frame. michael@0: // Return NULL on failure. michael@0: StackFrameX86* GetCallerByEBPAtBase(const vector &frames, michael@0: bool stack_scan_allowed); michael@0: michael@0: // Stores the CPU context corresponding to the innermost stack frame to michael@0: // be returned by GetContextFrame. michael@0: const MDRawContextX86* context_; michael@0: michael@0: // Our register map, for cfi_walker_. michael@0: static const CFIWalker::RegisterSet cfi_register_map_[]; michael@0: michael@0: // Our CFI frame walker. michael@0: const CFIWalker cfi_walker_; michael@0: }; michael@0: michael@0: michael@0: } // namespace google_breakpad michael@0: michael@0: michael@0: #endif // PROCESSOR_STACKWALKER_X86_H__