1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef _BACKTRACE_BACKTRACE_MAP_H 18 #define _BACKTRACE_BACKTRACE_MAP_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 #ifdef USE_MINGW 23 // MINGW does not define these constants. 24 #define PROT_NONE 0 25 #define PROT_READ 0x1 26 #define PROT_WRITE 0x2 27 #define PROT_EXEC 0x4 28 #else 29 #include <sys/mman.h> 30 #endif 31 32 #include <deque> 33 #include <string> 34 35 struct backtrace_map_t { 36 uintptr_t start = 0; 37 uintptr_t end = 0; 38 uintptr_t offset = 0; 39 uintptr_t load_base = 0; 40 int flags = 0; 41 std::string name; 42 }; 43 44 class BacktraceMap { 45 public: 46 // If uncached is true, then parse the current process map as of the call. 47 // Passing a map created with uncached set to true to Backtrace::Create() 48 // is unsupported. 49 static BacktraceMap* Create(pid_t pid, bool uncached = false); 50 51 virtual ~BacktraceMap(); 52 53 // Fill in the map data structure for the given address. 54 virtual void FillIn(uintptr_t addr, backtrace_map_t* map); 55 56 // The flags returned are the same flags as used by the mmap call. 57 // The values are PROT_*. GetFlags(uintptr_t pc)58 int GetFlags(uintptr_t pc) { 59 backtrace_map_t map; 60 FillIn(pc, &map); 61 if (IsValid(map)) { 62 return map.flags; 63 } 64 return PROT_NONE; 65 } 66 IsReadable(uintptr_t pc)67 bool IsReadable(uintptr_t pc) { return GetFlags(pc) & PROT_READ; } IsWritable(uintptr_t pc)68 bool IsWritable(uintptr_t pc) { return GetFlags(pc) & PROT_WRITE; } IsExecutable(uintptr_t pc)69 bool IsExecutable(uintptr_t pc) { return GetFlags(pc) & PROT_EXEC; } 70 71 typedef std::deque<backtrace_map_t>::iterator iterator; begin()72 iterator begin() { return maps_.begin(); } end()73 iterator end() { return maps_.end(); } 74 75 typedef std::deque<backtrace_map_t>::const_iterator const_iterator; begin()76 const_iterator begin() const { return maps_.begin(); } end()77 const_iterator end() const { return maps_.end(); } 78 79 virtual bool Build(); 80 IsValid(const backtrace_map_t & map)81 static inline bool IsValid(const backtrace_map_t& map) { 82 return map.end > 0; 83 } 84 GetRelativePc(const backtrace_map_t & map,uintptr_t pc)85 static uintptr_t GetRelativePc(const backtrace_map_t& map, uintptr_t pc) { 86 if (IsValid(map)) { 87 return pc - map.start + map.load_base; 88 } else { 89 return pc; 90 } 91 } 92 93 protected: 94 BacktraceMap(pid_t pid); 95 96 virtual bool ParseLine(const char* line, backtrace_map_t* map); 97 98 std::deque<backtrace_map_t> maps_; 99 pid_t pid_; 100 }; 101 102 #endif // _BACKTRACE_BACKTRACE_MAP_H 103