Update XRay to support x86-64 (RDTSC), use dladdr() as an optional way to

native_client_sdk/src/libraries/xray/symtable.c

 /* Copyright (c) 2013 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* XRay symbol table */
 
+#define _GNU_SOURCE
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#if defined(__GLIBC__)
+#include <dlfcn.h>
+#endif
+
 #include "xray/xray_priv.h"
 
 #if defined(XRAY)
 
 bool g_symtable_debug = false;
 
 struct XRayFrameInfo {
   int times_called;
   int total_ticks;
 };
@@ skipping 82 matching lines @@
 int XRaySymbolTableGetSize(struct XRaySymbolTable* symtab) {
   return XRayHashTableGetSize(symtab->hash_table);
 }
 
 
 struct XRaySymbol* XRaySymbolTableAtIndex(struct XRaySymbolTable* symtab,
                                           int i) {
   return (struct XRaySymbol*)XRayHashTableAtIndex(symtab->hash_table, i);
 }
 
-
-struct XRaySymbol* XRaySymbolTableLookup(struct XRaySymbolTable* symtab,
-                                         uint32_t addr) {
-  void *x = XRayHashTableLookup(symtab->hash_table, addr);
-  struct XRaySymbol* r = (struct XRaySymbol*)x;
-  return r;
-}
-
-
 struct XRaySymbol* XRaySymbolTableAdd(struct XRaySymbolTable* symtab,
                                       struct XRaySymbol* symbol,
                                       uint32_t addr) {
   return (struct XRaySymbol*)
     XRayHashTableInsert(symtab->hash_table, symbol, addr);
 }
 
+struct XRaySymbol* XRaySymbolTableAddByName(struct XRaySymbolTable* symtab,
+                                            const char* name, uint32_t addr) {
+  char* recorded_symbol;
+  struct XRaySymbol* symbol;
+  /* copy the symbol name into the string pool */
+  recorded_symbol = XRayStringPoolAppend(symtab->string_pool, name);
+  if (g_symtable_debug)
+    printf("adding symbol %s\n", recorded_symbol);
+  /* construct a symbol and put it in the symbol table */
+  symbol = XRaySymbolCreate(symtab->symbol_pool, recorded_symbol);
+  return XRaySymbolTableAdd(symtab, symbol, addr);
+}
+
+struct XRaySymbol* XRaySymbolTableLookup(struct XRaySymbolTable* symtab,
+                                         uint32_t addr) {
+  void *x = XRayHashTableLookup(symtab->hash_table, addr);
+  struct XRaySymbol* r = (struct XRaySymbol*)x;
+#if defined(__GLIBC__)
+  if (r == NULL) {
+    Dl_info info;
+    if (dladdr((const void*)addr, &info) != 0)
+      if (info.dli_sname)
+        r = XRaySymbolTableAddByName(symtab, info.dli_sname, addr);

[bradn, 2013/06/27 23:01:24]

Why cache these in your hashtable?
Worried dladdr is slow?
Did you also want to demangle here?
You can do it at runtime with:
abi::__cxa_demangle from cxxabi.h
Of course that'd be your first C++ file here :-)

[nfullagar1, 2013/06/27 23:41:55]

dladdr (as I understand it) can take any address and return nearest symbol.  For
xray, I only need address of the function -> symbol name, and the xray symbol
table is fast for this, and can also be populated via other means (map files,
etc)

For demangling, agree, talked with Roland yesterday about this, and yes, c++
would get pulled in.  Still considering it, just not for this CL :)

+  }
+#endif
+  return r;
+}
 
 struct XRaySymbol* XRaySymbolTableCreateEntry(struct XRaySymbolTable* symtab,
                                               const char* line) {
   uint32_t addr;
   unsigned int uiaddr;
   char symbol_text[XRAY_LINE_SIZE];
   char* parsed_symbol;
   char* newln;
-  struct XRaySymbol* symbol;
-  char* recorded_symbol;
   sscanf(line,"%x %s", &uiaddr, symbol_text);
   if (uiaddr > 0x07FFFFFF) {
     printf("While parsing the mapfile, XRay encountered:\n");
     printf("%s\n", line);
     printf("XRay only works with code addresses 0x00000000 - 0x07FFFFFF\n");
     printf("All functions must reside in this address space.\n");
     exit(-1);
   }
   addr = (uint32_t)uiaddr;
   parsed_symbol = strstr(line, symbol_text);
   newln = strstr(parsed_symbol, "\n");
   if (NULL != newln) {
     *newln = 0;
   }
-  /* copy the parsed symbol name into the string pool */
-  recorded_symbol = XRayStringPoolAppend(symtab->string_pool, parsed_symbol);
-  if (g_symtable_debug)
-    printf("adding symbol %s\n", recorded_symbol);
-  /* construct a symbol and put it in the symbol table */
-  symbol = XRaySymbolCreate(symtab->symbol_pool, recorded_symbol);
-  return XRaySymbolTableAdd(symtab, symbol, addr);
+  return XRaySymbolTableAddByName(symtab, parsed_symbol, addr);
 }
 
 
 void XRaySymbolTableParseMapfile(struct XRaySymbolTable* symtab,
                                  const char* mapfile)
 {
   FILE* f;
   char line[XRAY_LINE_SIZE];
   bool in_text = false;
   bool in_link_once = false;
@@ skipping 67 matching lines @@
 void XRaySymbolTableFree(struct XRaySymbolTable* symtab) {
   XRayStringPoolFree(symtab->string_pool);
   XRaySymbolPoolFree(symtab->symbol_pool);
   XRayHashTableFree(symtab->hash_table);
   symtab->num_symbols = 0;
   XRayFree(symtab);
 }
 
 #endif  /* XRAY */