michael@0: /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* vim: set ts=8 sts=2 et sw=2 tw=80: */
michael@0: 
michael@0: /* libunwind - a platform-independent unwind library
michael@0:    Copyright 2011 Linaro Limited
michael@0: 
michael@0: This file is part of libunwind.
michael@0: 
michael@0: Permission is hereby granted, free of charge, to any person obtaining
michael@0: a copy of this software and associated documentation files (the
michael@0: "Software"), to deal in the Software without restriction, including
michael@0: without limitation the rights to use, copy, modify, merge, publish,
michael@0: distribute, sublicense, and/or sell copies of the Software, and to
michael@0: permit persons to whom the Software is furnished to do so, subject to
michael@0: the following conditions:
michael@0: 
michael@0: The above copyright notice and this permission notice shall be
michael@0: included in all copies or substantial portions of the Software.
michael@0: 
michael@0: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
michael@0: EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
michael@0: MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
michael@0: NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
michael@0: LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
michael@0: OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
michael@0: WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
michael@0: 
michael@0: 
michael@0: // Copyright (c) 2010, 2011 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: 
michael@0: // Derived from libunwind, with extensive modifications.
michael@0: // This file is derived from the following files in
michael@0: // toolkit/crashreporter/google-breakpad:
michael@0: //   src/common/arm_ex_to_module.h
michael@0: //   src/common/memory_range.h
michael@0: //   src/common/arm_ex_reader.h
michael@0: 
michael@0: #ifndef LulExidxExt_h
michael@0: #define LulExidxExt_h
michael@0: 
michael@0: #include "LulMainInt.h"
michael@0: 
michael@0: using lul::LExpr;
michael@0: using lul::RuleSet;
michael@0: using lul::SecMap;
michael@0: 
michael@0: namespace lul {
michael@0: 
michael@0: typedef enum extab_cmd {
michael@0:   ARM_EXIDX_CMD_FINISH,
michael@0:   ARM_EXIDX_CMD_SUB_FROM_VSP,
michael@0:   ARM_EXIDX_CMD_ADD_TO_VSP,
michael@0:   ARM_EXIDX_CMD_REG_POP,
michael@0:   ARM_EXIDX_CMD_REG_TO_SP,
michael@0:   ARM_EXIDX_CMD_VFP_POP,
michael@0:   ARM_EXIDX_CMD_WREG_POP,
michael@0:   ARM_EXIDX_CMD_WCGR_POP,
michael@0:   ARM_EXIDX_CMD_RESERVED,
michael@0:   ARM_EXIDX_CMD_REFUSED,
michael@0: } extab_cmd_t;
michael@0: 
michael@0: struct exidx_entry {
michael@0:   uint32_t addr;
michael@0:   uint32_t data;
michael@0: };
michael@0: 
michael@0: struct extab_data {
michael@0:   extab_cmd_t cmd;
michael@0:   uint32_t data;
michael@0: };
michael@0: 
michael@0: enum extab_cmd_flags {
michael@0:   ARM_EXIDX_VFP_SHIFT_16 = 1 << 16,
michael@0:   ARM_EXIDX_VFP_FSTMD = 1 << 17, // distinguishes FSTMxxD from FSTMxxX
michael@0: };
michael@0: 
michael@0: // Receives information from arm_ex_reader::ExceptionTableInfo
michael@0: // and adds it to the SecMap object
michael@0: // This is in effect the EXIDX summariser.
michael@0: class ARMExToModule {
michael@0:  public:
michael@0:    ARMExToModule(SecMap* smap, void(*log)(const char*)) : smap_(smap)
michael@0:                                                         , log_(log) { }
michael@0:   ~ARMExToModule() { }
michael@0:   void AddStackFrame(uintptr_t addr, size_t size);
michael@0:   int  ImproveStackFrame(const struct extab_data* edata);
michael@0:   void DeleteStackFrame();
michael@0:   void SubmitStackFrame();
michael@0:  private:
michael@0:   SecMap* smap_;
michael@0:   LExpr   vsp_;        // Always appears to be of the form "sp + offset"
michael@0:   RuleSet curr_rules_; // Also holds the address range being summarised
michael@0:   // debugging message sink
michael@0:   void (*log_)(const char*);
michael@0:   int TranslateCmd(const struct extab_data* edata, LExpr& vsp);
michael@0: };
michael@0: 
michael@0: 
michael@0: // (derived from)
michael@0: // memory_range.h: Define the google_breakpad::MemoryRange class, which
michael@0: // is a lightweight wrapper with a pointer and a length to encapsulate
michael@0: // a contiguous range of memory.
michael@0: 
michael@0: // A lightweight wrapper with a pointer and a length to encapsulate a
michael@0: // contiguous range of memory. It provides helper methods for checked
michael@0: // access of a subrange of the memory. Its implemementation does not
michael@0: // allocate memory or call into libc functions, and is thus safer to use
michael@0: // in a crashed environment.
michael@0: class MemoryRange {
michael@0:  public:
michael@0: 
michael@0:   MemoryRange(const void* data, size_t length) {
michael@0:     Set(data, length);
michael@0:   }
michael@0: 
michael@0:   // Sets this memory range to point to |data| and its length to |length|.
michael@0:   void Set(const void* data, size_t length) {
michael@0:     data_ = reinterpret_cast<const uint8_t*>(data);
michael@0:     // Always set |length_| to zero if |data_| is NULL.
michael@0:     length_ = data ? length : 0;
michael@0:   }
michael@0: 
michael@0:   // Returns true if this range covers a subrange of |sub_length| bytes
michael@0:   // at |sub_offset| bytes of this memory range, or false otherwise.
michael@0:   bool Covers(size_t sub_offset, size_t sub_length) const {
michael@0:     // The following checks verify that:
michael@0:     // 1. sub_offset is within [ 0 .. length_ - 1 ]
michael@0:     // 2. sub_offset + sub_length is within
michael@0:     //    [ sub_offset .. length_ ]
michael@0:     return sub_offset < length_ &&
michael@0:            sub_offset + sub_length >= sub_offset &&
michael@0:            sub_offset + sub_length <= length_;
michael@0:   }
michael@0: 
michael@0:   // Returns a pointer to the beginning of this memory range.
michael@0:   const uint8_t* data() const { return data_; }
michael@0: 
michael@0:   // Returns the length, in bytes, of this memory range.
michael@0:   size_t length() const { return length_; }
michael@0: 
michael@0:  private:
michael@0:   // Pointer to the beginning of this memory range.
michael@0:   const uint8_t* data_;
michael@0: 
michael@0:   // Length, in bytes, of this memory range.
michael@0:   size_t length_;
michael@0: };
michael@0: 
michael@0: 
michael@0: // This class is a reader for ARM unwind information
michael@0: // from .ARM.exidx and .ARM.extab sections.
michael@0: class ExceptionTableInfo {
michael@0:  public:
michael@0:   ExceptionTableInfo(const char* exidx, size_t exidx_size,
michael@0:                      const char* extab, size_t extab_size,
michael@0:                      uint32_t text_last_svma,
michael@0:                      lul::ARMExToModule* handler,
michael@0:                      const char* mapping_addr,
michael@0:                      uint32_t loading_addr,
michael@0:                      uintptr_t text_bias,
michael@0:                      void (*log)(const char*))
michael@0:       : mr_exidx_(lul::MemoryRange(exidx, exidx_size)),
michael@0:         mr_extab_(lul::MemoryRange(extab, extab_size)),
michael@0:         text_last_svma_(text_last_svma),
michael@0:         handler_(handler), mapping_addr_(mapping_addr),
michael@0:         loading_addr_(loading_addr),
michael@0:         text_bias_(text_bias),
michael@0:         log_(log) { }
michael@0: 
michael@0:   ~ExceptionTableInfo() { }
michael@0: 
michael@0:   // Parses the entries in .ARM.exidx and possibly
michael@0:   // in .ARM.extab tables, reports what we find to
michael@0:   // arm_ex_to_module::ARMExToModule.
michael@0:   void Start();
michael@0: 
michael@0:  private:
michael@0:   lul::MemoryRange mr_exidx_;
michael@0:   lul::MemoryRange mr_extab_;
michael@0:   uint32_t text_last_svma_;
michael@0:   lul::ARMExToModule* handler_;
michael@0:   const char* mapping_addr_;
michael@0:   uint32_t loading_addr_;
michael@0:   uintptr_t text_bias_;
michael@0:   // debugging message sink
michael@0:   void (*log_)(const char*);
michael@0:   enum ExExtractResult {
michael@0:     ExSuccess,        // success
michael@0:     ExInBufOverflow,  // out-of-range while reading .exidx
michael@0:     ExOutBufOverflow, // output buffer is too small
michael@0:     ExCantUnwind,     // this function is marked CANT_UNWIND
michael@0:     ExCantRepresent,  // entry valid, but we can't represent it
michael@0:     ExInvalid         // entry is invalid
michael@0:   };
michael@0:   ExExtractResult
michael@0:     ExtabEntryExtract(const struct lul::exidx_entry* entry,
michael@0:                       uint8_t* buf, size_t buf_size,
michael@0:                       /*OUT*/size_t* buf_used);
michael@0: 
michael@0:   int ExtabEntryDecode(const uint8_t* buf, size_t buf_size);
michael@0: };
michael@0: 
michael@0: } // namespace lul
michael@0: 
michael@0: #endif // LulExidxExt_h