1 #!/usr/bin/python 2 # 3 # Copyright (C) 2013 The Android Open Source Project 4 # 5 # Licensed under the Apache License, Version 2.0 (the "License"); 6 # you may not use this file except in compliance with the License. 7 # You may obtain a copy of the License at 8 # 9 # http://www.apache.org/licenses/LICENSE-2.0 10 # 11 # Unless required by applicable law or agreed to in writing, software 12 # distributed under the License is distributed on an "AS IS" BASIS, 13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 # See the License for the specific language governing permissions and 15 # limitations under the License. 16 17 """Module for looking up symbolic debugging information. 18 19 The information can include symbol names, offsets, and source locations. 20 """ 21 22 import os 23 import re 24 import subprocess 25 26 CHROME_SRC = os.path.join(os.path.realpath(os.path.dirname(__file__)), 27 os.pardir, os.pardir, os.pardir, os.pardir) 28 ANDROID_BUILD_TOP = CHROME_SRC 29 SYMBOLS_DIR = CHROME_SRC 30 CHROME_SYMBOLS_DIR = CHROME_SRC 31 32 ARCH = "arm" 33 34 TOOLCHAIN_INFO = None 35 36 def Uname(): 37 """'uname' for constructing prebuilt/<...> and out/host/<...> paths.""" 38 uname = os.uname()[0] 39 if uname == "Darwin": 40 proc = os.uname()[-1] 41 if proc == "i386" or proc == "x86_64": 42 return "darwin-x86" 43 return "darwin-ppc" 44 if uname == "Linux": 45 return "linux-x86" 46 return uname 47 48 def ToolPath(tool, toolchain_info=None): 49 """Return a full qualified path to the specified tool""" 50 # ToolPath looks for the tools in the completely incorrect directory. 51 # This looks in the checked in android_tools. 52 if ARCH == "arm": 53 toolchain_source = "arm-linux-androideabi-4.6" 54 toolchain_prefix = "arm-linux-androideabi" 55 ndk = "ndk" 56 elif ARCH == "arm64": 57 toolchain_source = "aarch64-linux-android-4.9" 58 toolchain_prefix = "aarch64-linux-android" 59 ndk = "ndk" 60 elif ARCH == "x86": 61 toolchain_source = "x86-4.6" 62 toolchain_prefix = "i686-android-linux" 63 ndk = "ndk" 64 elif ARCH == "x86_64": 65 toolchain_source = "x86_64-4.9" 66 toolchain_prefix = "x86_64-linux-android" 67 ndk = "ndk" 68 elif ARCH == "mips": 69 toolchain_source = "mipsel-linux-android-4.6" 70 toolchain_prefix = "mipsel-linux-android" 71 ndk = "ndk" 72 else: 73 raise Exception("Could not find tool chain") 74 75 toolchain_subdir = ( 76 "third_party/android_tools/%s/toolchains/%s/prebuilt/linux-x86_64/bin" % 77 (ndk, toolchain_source)) 78 79 return os.path.join(CHROME_SRC, 80 toolchain_subdir, 81 toolchain_prefix + "-" + tool) 82 83 def FindToolchain(): 84 """Look for the latest available toolchain 85 86 Args: 87 None 88 89 Returns: 90 A pair of strings containing toolchain label and target prefix. 91 """ 92 global TOOLCHAIN_INFO 93 if TOOLCHAIN_INFO is not None: 94 return TOOLCHAIN_INFO 95 96 ## Known toolchains, newer ones in the front. 97 if ARCH == "arm64": 98 gcc_version = "4.9" 99 known_toolchains = [ 100 ("aarch64-linux-android-" + gcc_version, "aarch64", "aarch64-linux-android") 101 ] 102 elif ARCH == "arm": 103 gcc_version = "4.6" 104 known_toolchains = [ 105 ("arm-linux-androideabi-" + gcc_version, "arm", "arm-linux-androideabi"), 106 ] 107 elif ARCH =="x86": 108 known_toolchains = [ 109 ("i686-android-linux-4.4.3", "x86", "i686-android-linux") 110 ] 111 elif ARCH =="x86_64": 112 known_toolchains = [ 113 ("x86_64-linux-android-4.9", "x86_64", "x86_64-linux-android") 114 ] 115 elif ARCH == "mips": 116 gcc_version = "4.6" 117 known_toolchains = [ 118 ("mipsel-linux-android-" + gcc_version, "mips", "mipsel-linux-android") 119 ] 120 else: 121 known_toolchains = [] 122 123 # Look for addr2line to check for valid toolchain path. 124 for (label, platform, target) in known_toolchains: 125 toolchain_info = (label, platform, target); 126 if os.path.exists(ToolPath("addr2line", toolchain_info)): 127 TOOLCHAIN_INFO = toolchain_info 128 print "Using toolchain from :" + ToolPath("", TOOLCHAIN_INFO) 129 return toolchain_info 130 131 raise Exception("Could not find tool chain") 132 133 def TranslateLibPath(lib): 134 # SymbolInformation(lib, addr) receives lib as the path from symbols 135 # root to the symbols file. This needs to be translated to point to the 136 # correct .so path. If the user doesn't explicitly specify which directory to 137 # use, then use the most recently updated one in one of the known directories. 138 # If the .so is not found somewhere in CHROME_SYMBOLS_DIR, leave it 139 # untranslated in case it is an Android symbol in SYMBOLS_DIR. 140 library_name = os.path.basename(lib) 141 out_dir = os.environ.get('CHROMIUM_OUT_DIR', 'out') 142 candidate_dirs = ['.', 143 os.path.join(out_dir, 'Debug', 'lib'), 144 os.path.join(out_dir, 'Debug', 'lib.target'), 145 os.path.join(out_dir, 'Release', 'lib'), 146 os.path.join(out_dir, 'Release', 'lib.target'), 147 ] 148 149 candidate_libraries = map( 150 lambda d: ('%s/%s/%s' % (CHROME_SYMBOLS_DIR, d, library_name)), 151 candidate_dirs) 152 candidate_libraries = filter(os.path.exists, candidate_libraries) 153 candidate_libraries = sorted(candidate_libraries, 154 key=os.path.getmtime, reverse=True) 155 156 if not candidate_libraries: 157 return lib 158 159 library_path = os.path.relpath(candidate_libraries[0], SYMBOLS_DIR) 160 return '/' + library_path 161 162 def SymbolInformation(lib, addr, get_detailed_info): 163 """Look up symbol information about an address. 164 165 Args: 166 lib: library (or executable) pathname containing symbols 167 addr: string hexidecimal address 168 169 Returns: 170 A list of the form [(source_symbol, source_location, 171 object_symbol_with_offset)]. 172 173 If the function has been inlined then the list may contain 174 more than one element with the symbols for the most deeply 175 nested inlined location appearing first. The list is 176 always non-empty, even if no information is available. 177 178 Usually you want to display the source_location and 179 object_symbol_with_offset from the last element in the list. 180 """ 181 lib = TranslateLibPath(lib) 182 info = SymbolInformationForSet(lib, set([addr]), get_detailed_info) 183 return (info and info.get(addr)) or [(None, None, None)] 184 185 186 def SymbolInformationForSet(lib, unique_addrs, get_detailed_info): 187 """Look up symbol information for a set of addresses from the given library. 188 189 Args: 190 lib: library (or executable) pathname containing symbols 191 unique_addrs: set of hexidecimal addresses 192 193 Returns: 194 A dictionary of the form {addr: [(source_symbol, source_location, 195 object_symbol_with_offset)]} where each address has a list of 196 associated symbols and locations. The list is always non-empty. 197 198 If the function has been inlined then the list may contain 199 more than one element with the symbols for the most deeply 200 nested inlined location appearing first. The list is 201 always non-empty, even if no information is available. 202 203 Usually you want to display the source_location and 204 object_symbol_with_offset from the last element in the list. 205 """ 206 if not lib: 207 return None 208 209 addr_to_line = CallAddr2LineForSet(lib, unique_addrs) 210 if not addr_to_line: 211 return None 212 213 if get_detailed_info: 214 addr_to_objdump = CallObjdumpForSet(lib, unique_addrs) 215 if not addr_to_objdump: 216 return None 217 else: 218 addr_to_objdump = dict((addr, ("", 0)) for addr in unique_addrs) 219 220 result = {} 221 for addr in unique_addrs: 222 source_info = addr_to_line.get(addr) 223 if not source_info: 224 source_info = [(None, None)] 225 if addr in addr_to_objdump: 226 (object_symbol, object_offset) = addr_to_objdump.get(addr) 227 object_symbol_with_offset = FormatSymbolWithOffset(object_symbol, 228 object_offset) 229 else: 230 object_symbol_with_offset = None 231 result[addr] = [(source_symbol, source_location, object_symbol_with_offset) 232 for (source_symbol, source_location) in source_info] 233 234 return result 235 236 237 class MemoizedForSet(object): 238 def __init__(self, fn): 239 self.fn = fn 240 self.cache = {} 241 242 def __call__(self, lib, unique_addrs): 243 lib_cache = self.cache.setdefault(lib, {}) 244 245 no_cache = filter(lambda x: x not in lib_cache, unique_addrs) 246 if no_cache: 247 lib_cache.update((k, None) for k in no_cache) 248 result = self.fn(lib, no_cache) 249 if result: 250 lib_cache.update(result) 251 252 return dict((k, lib_cache[k]) for k in unique_addrs if lib_cache[k]) 253 254 255 @MemoizedForSet 256 def CallAddr2LineForSet(lib, unique_addrs): 257 """Look up line and symbol information for a set of addresses. 258 259 Args: 260 lib: library (or executable) pathname containing symbols 261 unique_addrs: set of string hexidecimal addresses look up. 262 263 Returns: 264 A dictionary of the form {addr: [(symbol, file:line)]} where 265 each address has a list of associated symbols and locations 266 or an empty list if no symbol information was found. 267 268 If the function has been inlined then the list may contain 269 more than one element with the symbols for the most deeply 270 nested inlined location appearing first. 271 """ 272 if not lib: 273 return None 274 275 276 symbols = SYMBOLS_DIR + lib 277 if not os.path.isfile(symbols): 278 return None 279 280 (label, platform, target) = FindToolchain() 281 cmd = [ToolPath("addr2line"), "--functions", "--inlines", 282 "--demangle", "--exe=" + symbols] 283 child = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE) 284 285 result = {} 286 addrs = sorted(unique_addrs) 287 for addr in addrs: 288 child.stdin.write("0x%s\n" % addr) 289 child.stdin.flush() 290 records = [] 291 first = True 292 while True: 293 symbol = child.stdout.readline().strip() 294 if symbol == "??": 295 symbol = None 296 location = child.stdout.readline().strip() 297 if location == "??:0": 298 location = None 299 if symbol is None and location is None: 300 break 301 records.append((symbol, location)) 302 if first: 303 # Write a blank line as a sentinel so we know when to stop 304 # reading inlines from the output. 305 # The blank line will cause addr2line to emit "??\n??:0\n". 306 child.stdin.write("\n") 307 first = False 308 result[addr] = records 309 child.stdin.close() 310 child.stdout.close() 311 return result 312 313 314 def StripPC(addr): 315 """Strips the Thumb bit a program counter address when appropriate. 316 317 Args: 318 addr: the program counter address 319 320 Returns: 321 The stripped program counter address. 322 """ 323 global ARCH 324 325 if ARCH == "arm": 326 return addr & ~1 327 return addr 328 329 @MemoizedForSet 330 def CallObjdumpForSet(lib, unique_addrs): 331 """Use objdump to find out the names of the containing functions. 332 333 Args: 334 lib: library (or executable) pathname containing symbols 335 unique_addrs: set of string hexidecimal addresses to find the functions for. 336 337 Returns: 338 A dictionary of the form {addr: (string symbol, offset)}. 339 """ 340 if not lib: 341 return None 342 343 symbols = SYMBOLS_DIR + lib 344 if not os.path.exists(symbols): 345 return None 346 347 symbols = SYMBOLS_DIR + lib 348 if not os.path.exists(symbols): 349 return None 350 351 result = {} 352 353 # Function lines look like: 354 # 000177b0 <android::IBinder::~IBinder()+0x2c>: 355 # We pull out the address and function first. Then we check for an optional 356 # offset. This is tricky due to functions that look like "operator+(..)+0x2c" 357 func_regexp = re.compile("(^[a-f0-9]*) \<(.*)\>:$") 358 offset_regexp = re.compile("(.*)\+0x([a-f0-9]*)") 359 360 # A disassembly line looks like: 361 # 177b2: b510 push {r4, lr} 362 asm_regexp = re.compile("(^[ a-f0-9]*):[ a-f0-0]*.*$") 363 364 for target_addr in unique_addrs: 365 start_addr_dec = str(StripPC(int(target_addr, 16))) 366 stop_addr_dec = str(StripPC(int(target_addr, 16)) + 8) 367 cmd = [ToolPath("objdump"), 368 "--section=.text", 369 "--demangle", 370 "--disassemble", 371 "--start-address=" + start_addr_dec, 372 "--stop-address=" + stop_addr_dec, 373 symbols] 374 375 current_symbol = None # The current function symbol in the disassembly. 376 current_symbol_addr = 0 # The address of the current function. 377 378 stream = subprocess.Popen(cmd, stdout=subprocess.PIPE).stdout 379 for line in stream: 380 # Is it a function line like: 381 # 000177b0 <android::IBinder::~IBinder()>: 382 components = func_regexp.match(line) 383 if components: 384 # This is a new function, so record the current function and its address. 385 current_symbol_addr = int(components.group(1), 16) 386 current_symbol = components.group(2) 387 388 # Does it have an optional offset like: "foo(..)+0x2c"? 389 components = offset_regexp.match(current_symbol) 390 if components: 391 current_symbol = components.group(1) 392 offset = components.group(2) 393 if offset: 394 current_symbol_addr -= int(offset, 16) 395 396 # Is it an disassembly line like: 397 # 177b2: b510 push {r4, lr} 398 components = asm_regexp.match(line) 399 if components: 400 addr = components.group(1) 401 i_addr = int(addr, 16) 402 i_target = StripPC(int(target_addr, 16)) 403 if i_addr == i_target: 404 result[target_addr] = (current_symbol, i_target - current_symbol_addr) 405 stream.close() 406 407 return result 408 409 410 def CallCppFilt(mangled_symbol): 411 cmd = [ToolPath("c++filt")] 412 process = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE) 413 process.stdin.write(mangled_symbol) 414 process.stdin.write("\n") 415 process.stdin.close() 416 demangled_symbol = process.stdout.readline().strip() 417 process.stdout.close() 418 return demangled_symbol 419 420 def FormatSymbolWithOffset(symbol, offset): 421 if offset == 0: 422 return symbol 423 return "%s+%d" % (symbol, offset) 424
