| /* |
| * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include <stdio.h> |
| #include <sys/mman.h> |
| #include <dlfcn.h> |
| #include <libelf.h> |
| #include <strings.h> |
| #include <fcntl.h> |
| #include <sys/param.h> |
| #include <stdlib.h> |
| #include <thread.h> |
| #include <synch.h> |
| #include <stdarg.h> |
| #include <unistd.h> |
| |
| #define TRUE 1 |
| #define FALSE 0 |
| |
| /* 32/64 bit build issues. */ |
| |
| #ifdef _LP64 |
| #define ElfXX_Sym Elf64_Sym |
| #define ElfXX_Ehdr Elf64_Ehdr |
| #define ElfXX_Shdr Elf64_Shdr |
| #define elfXX_getehdr elf64_getehdr |
| #define ElfXX_Addr Elf64_Addr |
| #define ELFXX_ST_TYPE ELF64_ST_TYPE |
| #define ELFXX_ST_BIND ELF64_ST_BIND |
| #define elfXX_getshdr elf64_getshdr |
| #else |
| #define ElfXX_Sym Elf32_Sym |
| #define ElfXX_Ehdr Elf32_Ehdr |
| #define ElfXX_Shdr Elf32_Shdr |
| #define elfXX_getehdr elf32_getehdr |
| #define ElfXX_Addr Elf32_Addr |
| #define ELFXX_ST_TYPE ELF32_ST_TYPE |
| #define ELFXX_ST_BIND ELF32_ST_BIND |
| #define elfXX_getshdr elf32_getshdr |
| #endif |
| |
| extern void *_getReturnAddr(void); |
| |
| |
| |
| typedef struct StabEntry { |
| unsigned n_strx; |
| unsigned char n_type; |
| char n_other; |
| short n_desc; |
| unsigned n_value; |
| } StabEntry; |
| |
| |
| typedef struct SymChain { |
| struct SymChain *next; |
| ElfXX_Sym *sym; |
| } SymChain; |
| |
| |
| typedef struct ObjFileList { |
| struct ObjFileList *next; |
| const char *objFileName; |
| int nameLen; |
| } ObjFileList; |
| |
| |
| typedef struct ElfInfo { |
| const char *fullName; |
| const char *baseName; |
| FILE *outFile; |
| int fd; |
| Elf *elf; |
| Elf_Data *sectionStringData; |
| Elf_Data *symData; |
| Elf_Data *symStringData; |
| int symCount; |
| SymChain *symChainHead; |
| Elf_Data *stabData; |
| Elf_Data *stabStringData; |
| int stabCount; |
| ObjFileList *objFileList; |
| } ElfInfo; |
| |
| |
| |
| #define COUNT_BUF_SIZE (16*1024*1024) |
| |
| #define ENTRY_CHAIN_BUCKETS 4999 |
| |
| static int *countBuf; |
| static void *textOffset; |
| static const char *libFileName; |
| |
| |
| |
| static void fail(const char *err, ...) |
| { |
| va_list ap; |
| va_start(ap, err); |
| vfprintf(stderr, err, ap); |
| fflush(stderr); |
| va_end(ap); |
| } |
| |
| |
| |
| static const char *getSymString(ElfInfo *elfInfo, int index) |
| { |
| return (const char *)elfInfo->symStringData->d_buf + index; |
| } |
| |
| |
| static const char *getStabString(ElfInfo *elfInfo, int index) |
| { |
| return (const char *)elfInfo->stabStringData->d_buf + index; |
| } |
| |
| |
| static const char *getSectionString(ElfInfo *elfInfo, int index) |
| { |
| return (const char *)elfInfo->sectionStringData->d_buf + index; |
| } |
| |
| |
| static const char *makeObjFileList(ElfInfo *elfInfo) |
| { |
| int i; |
| const char *file; |
| unsigned offset, lastOffset; |
| ObjFileList *objFileList; |
| |
| file = NULL; |
| offset = lastOffset = 0; |
| for (i = 0; i < elfInfo->stabCount; ++i) { |
| StabEntry *stab = ((StabEntry *)elfInfo->stabData->d_buf) + i; |
| |
| if (stab->n_type == 0 /* N_UNDEF */) { |
| offset = lastOffset; |
| lastOffset += stab-> n_value; |
| } |
| else if (stab->n_type == 0x38 /* N_OBJ */) { |
| file = getStabString(elfInfo, stab->n_strx + offset); |
| objFileList = (ObjFileList *)malloc(sizeof (ObjFileList)); |
| objFileList->objFileName = file; |
| /*fprintf(stderr,"new obj file %s.\n", file);*/ |
| objFileList->nameLen = strlen(file); |
| objFileList->next = elfInfo->objFileList; |
| elfInfo->objFileList = objFileList; |
| } |
| } |
| return NULL; |
| } |
| |
| |
| static ElfInfo *createElfInfo(const char *fullName) |
| { |
| ElfInfo *elfInfo; |
| ElfXX_Ehdr *ehdr; |
| Elf_Scn *sectionStringSection; |
| Elf_Scn *stringSection; |
| Elf_Scn *symSection; |
| ElfXX_Shdr *symHeader; |
| Elf_Scn *stabSection; |
| ElfXX_Shdr *stabHeader; |
| ElfXX_Shdr *stringHeader; |
| Elf *elf; |
| const char *p; |
| |
| /*fprintf(stderr, "# mapfile info for %s.\n", fullName);*/ |
| elfInfo = (ElfInfo *)malloc(sizeof (ElfInfo)); |
| memset(elfInfo, 0, sizeof (ElfInfo)); |
| elfInfo->fullName = strdup(fullName); |
| p = rindex(elfInfo->fullName, '/'); |
| elfInfo->baseName = (p == NULL) ? elfInfo->fullName : p + 1; |
| |
| /* Open the ELF file. Get section headers. */ |
| |
| elf_version(EV_CURRENT); |
| elfInfo->fd = open(fullName, O_RDONLY); |
| if (elfInfo->fd < 0) |
| fail("Unable to open ELF file %s.\n", fullName); |
| elf = elf_begin(elfInfo->fd, ELF_C_READ, (Elf *)0); |
| if (elf == NULL) |
| fail("elf_begin failed.\n"); |
| ehdr = elfXX_getehdr(elf); |
| sectionStringSection = elf_getscn(elf, ehdr->e_shstrndx); |
| elfInfo->sectionStringData = elf_getdata(sectionStringSection, NULL); |
| |
| /* Find the symbol table section. */ |
| |
| symSection = NULL; |
| while ((symSection = elf_nextscn(elf, symSection)) != NULL) { |
| symHeader = elfXX_getshdr(symSection); |
| p = getSectionString(elfInfo, symHeader->sh_name); |
| if (strcmp(p, ".symtab") == 0) |
| break; |
| } |
| if (symSection == NULL) |
| fail("Unable to find symbol table.\n"); |
| |
| elfInfo->symData = elf_getdata(symSection, NULL); |
| elfInfo->symCount = elfInfo->symData->d_size / sizeof (ElfXX_Sym); |
| |
| /* Find the string section. */ |
| |
| stringSection = NULL; |
| while ((stringSection = elf_nextscn(elf, stringSection)) != NULL) { |
| stringHeader = elfXX_getshdr(stringSection); |
| p = getSectionString(elfInfo, stringHeader->sh_name); |
| if (strcmp(p, ".strtab") == 0) |
| break; |
| } |
| if (stringSection == NULL) |
| fail("Unable to find string table.\n"); |
| |
| elfInfo->symStringData = elf_getdata(stringSection, NULL); |
| elfInfo->symChainHead = NULL; |
| |
| /* Find the stab section. */ |
| |
| stabSection = NULL; |
| while ((stabSection = elf_nextscn(elf, stabSection)) != NULL) { |
| stabHeader = elfXX_getshdr(stabSection); |
| p = getSectionString(elfInfo, stabHeader->sh_name); |
| if (strcmp(p, ".stab.index") == 0) |
| break; |
| } |
| if (stabSection == NULL) |
| fail("Unable to find .stab.index.\n"); |
| |
| elfInfo->stabData = elf_getdata(stabSection, NULL); |
| elfInfo->stabCount = elfInfo->stabData->d_size / sizeof (StabEntry); |
| |
| /* Find the string section. */ |
| |
| stringSection = NULL; |
| while ((stringSection = elf_nextscn(elf, stringSection)) != NULL) { |
| stringHeader = elfXX_getshdr(stringSection); |
| p = getSectionString(elfInfo, stringHeader->sh_name); |
| if (strcmp(p, ".stab.indexstr") == 0) |
| break; |
| } |
| if (stringSection == NULL) |
| fail("Unable to find .stab.indexstr table.\n"); |
| |
| elfInfo->stabStringData = elf_getdata(stringSection, NULL); |
| makeObjFileList(elfInfo); |
| |
| return elfInfo; |
| } |
| |
| |
| static const char *identifyFile(ElfInfo *elfInfo, const char *name) |
| { |
| int i; |
| const char *file; |
| const char *sourceFile; |
| unsigned offset, lastOffset; |
| const char *lastOptions; |
| char *buf; |
| |
| file = NULL; |
| lastOptions = NULL; |
| offset = lastOffset = 0; |
| for (i = 0; i < elfInfo->stabCount; ++i) { |
| StabEntry *stab = ((StabEntry *)elfInfo->stabData->d_buf) + i; |
| |
| if (stab->n_type == 0 /* N_UNDEF */) { |
| offset = lastOffset; |
| lastOffset += stab-> n_value; |
| file = NULL; /* C++ output files seem not to have N_OBJ fields.*/ |
| lastOptions = NULL; |
| sourceFile = getStabString(elfInfo, stab->n_strx + offset); |
| } |
| else if (stab->n_type == 0x24 /* N_FUN */) { |
| const char *stabName; |
| char *p1, *p2; |
| |
| stabName = getStabString(elfInfo, stab->n_strx + offset); |
| if (strcmp (stabName, name) == 0) { |
| |
| if (file != NULL) |
| return file; |
| |
| if (lastOptions == NULL) |
| return NULL; |
| |
| p1 = strstr(lastOptions, ";ptr"); |
| if (p1 == NULL) |
| return NULL; |
| p1 += 4; |
| p2 = index(p1, ';'); |
| if (p2 == NULL) |
| return NULL; |
| |
| buf = (char *)malloc(p2 - p1 + strlen(sourceFile) + 10); |
| strncpy(buf, p1, p2 - p1); |
| buf[p2-p1] = '/'; |
| strcpy(buf + (p2 - p1) + 1, sourceFile); |
| p1 = rindex(buf, '.'); |
| if (p1 == NULL) |
| return NULL; |
| p1[1] = 'o'; |
| p1[2] = '\0'; |
| return buf; |
| } |
| } |
| else if (stab->n_type == 0x3c /* N_OPT */) { |
| lastOptions = getStabString(elfInfo, stab->n_strx + offset); |
| } |
| else if (stab->n_type == 0x38 /* N_OBJ */) { |
| file = getStabString(elfInfo, stab->n_strx + offset); |
| } |
| } |
| return NULL; |
| } |
| |
| |
| static const char *checkObjFileList(ElfInfo *elfInfo, const char *file) { |
| ObjFileList *objFileList; |
| int len = strlen(file); |
| int nameLen; |
| const char *objFileName; |
| |
| /*fprintf(stderr, "checkObjFileList(%s).\n", file);*/ |
| for (objFileList = elfInfo->objFileList; objFileList != NULL; |
| objFileList = objFileList->next) { |
| |
| objFileName = objFileList->objFileName; |
| nameLen = objFileList->nameLen; |
| if (strcmp(objFileName +nameLen - len, file) != 0) |
| continue; |
| |
| if (len == nameLen) |
| return file; |
| |
| if (len > nameLen) |
| continue; |
| |
| if (*(objFileName + nameLen - len - 1) == '/') |
| return objFileName; |
| } |
| return file; |
| } |
| |
| |
| static void identifySymbol(ElfInfo *elfInfo, ElfXX_Addr value, int count) |
| { |
| int i; |
| ElfXX_Sym *bestFunc = NULL; |
| ElfXX_Sym *bestFile = NULL; |
| ElfXX_Sym *lastFile = NULL; |
| char fileName[MAXPATHLEN]; |
| char buf[4096]; |
| const char *file; |
| SymChain *chain; |
| const char *format; |
| |
| for (i = 0; i < elfInfo->symCount; ++i) { |
| ElfXX_Sym *sym = ((ElfXX_Sym *)elfInfo->symData->d_buf) + i; |
| if (ELFXX_ST_TYPE(sym->st_info) == STT_FUNC) { |
| |
| if (sym->st_shndx == SHN_UNDEF) |
| continue; |
| |
| if (sym->st_value > value) |
| continue; |
| |
| if (bestFunc != NULL) { |
| |
| if (sym->st_value < bestFunc->st_value) |
| continue; |
| |
| /* |
| * If we have two symbols of equal value, we have a problem - |
| * we must pick the "right" one, which is the one the compiler |
| * used to generate the section name with -xF. |
| * |
| * The compiler has the nasty habit of generating two |
| * mangled names for some C++ functions. |
| * |
| * Try - picking the shortest name. |
| */ |
| |
| if (sym->st_value == bestFunc->st_value) { |
| if (strlen(getSymString(elfInfo, bestFunc->st_name)) < |
| strlen(getSymString(elfInfo, sym->st_name))) |
| continue; |
| } |
| |
| } |
| bestFunc = sym; |
| bestFile = lastFile; |
| } |
| else if (ELFXX_ST_TYPE(sym->st_info) == STT_FILE) { |
| lastFile = sym; |
| } |
| } |
| |
| if (bestFunc == NULL) |
| fail("Unable to find symbol for address 0x%x.\n", value); |
| |
| for (chain = elfInfo->symChainHead; chain != NULL; chain = chain->next) { |
| if (chain->sym == bestFunc) |
| return; |
| } |
| chain = (SymChain *)malloc(sizeof (SymChain)); |
| chain->sym = bestFunc; |
| chain->next = elfInfo->symChainHead; |
| elfInfo->symChainHead = chain; |
| |
| |
| if (ELFXX_ST_BIND(bestFunc->st_info) == STB_GLOBAL) |
| file = ""; |
| else { |
| const char *name = getSymString(elfInfo, bestFunc->st_name); |
| file = identifyFile(elfInfo, name); |
| if (file == NULL) { |
| if (bestFile == NULL) { |
| file = "notFound"; |
| fail("Failed to identify %s.\n", name); |
| } else { |
| char *suffix; |
| fileName[0] = ':'; |
| fileName[1] = ' '; |
| file = getSymString(elfInfo, bestFile->st_name); |
| strncpy(fileName+2, file, MAXPATHLEN-3); |
| suffix = rindex(fileName, '.'); |
| if (suffix == NULL) |
| fail("no file name suffix?"); |
| suffix[1] = 'o'; |
| suffix[2] = '\0'; |
| |
| file = checkObjFileList(elfInfo, fileName+2); |
| if (file != fileName+2) |
| strncpy(fileName+2, file, MAXPATHLEN-3); |
| |
| file = fileName; |
| } |
| } else { |
| fileName[0] = ':'; |
| fileName[1] = ' '; |
| strncpy(fileName + 2, file, MAXPATHLEN-3); |
| file = fileName; |
| } |
| } |
| format = "text: .text%%%s%s;\n"; |
| i = snprintf(buf, sizeof buf, format, |
| bestFunc ? getSymString(elfInfo, bestFunc->st_name) : "notFound", |
| file); |
| write(2, buf, i); |
| } |
| |
| |
| static mutex_t mutex; |
| static int orderByCount = FALSE; |
| |
| |
| static void init_mcount(void) |
| { |
| mutex_init(&mutex, USYNC_THREAD, NULL); |
| } |
| |
| #pragma init(init_mcount) |
| |
| |
| typedef struct CountAddrPair { |
| int count; |
| unsigned int addr; |
| } CountAddrPair; |
| |
| |
| static int compareCounts(const void *a, const void *b) { |
| return ((CountAddrPair *)b)->count - ((CountAddrPair *)a)->count; |
| } |
| |
| static int compareCountsReverse(const void *a, const void *b) { |
| return ((CountAddrPair *)a)->count - ((CountAddrPair *)b)->count; |
| } |
| |
| |
| static void doCounts(void) { |
| unsigned int i; |
| int n; |
| int nMethods; |
| int nMethods2; |
| CountAddrPair *pairs; |
| ElfInfo *elfInfo; |
| |
| elfInfo = createElfInfo(libFileName); |
| |
| nMethods = 0; |
| for (i = 0; i < COUNT_BUF_SIZE >> 2; ++i) { |
| n = countBuf[i]; |
| if (n > 0) |
| ++nMethods; |
| } |
| pairs = (CountAddrPair *)malloc(sizeof(CountAddrPair) * nMethods); |
| nMethods2 = 0; |
| for (i = 0; i < COUNT_BUF_SIZE >> 2; ++i) { |
| n = countBuf[i]; |
| if (n > 0) { |
| pairs[nMethods2].count = n; |
| pairs[nMethods2].addr = i << 2; |
| ++nMethods2; |
| if (nMethods2 > nMethods) { |
| fprintf(stderr, "Number of methods detected increased after" |
| " the atexit call.\n"); |
| break; |
| } |
| } |
| } |
| if (orderByCount) { |
| qsort(pairs, nMethods, sizeof pairs[0], &compareCounts); |
| for (i = 0; i < nMethods; ++i) { |
| identifySymbol(elfInfo, pairs[i].addr, pairs[i].count); |
| } |
| } |
| else { |
| qsort(pairs, nMethods, sizeof pairs[0], &compareCountsReverse); |
| for (i = 0; i < nMethods; ++i) { |
| identifySymbol(elfInfo, pairs[i].addr, 0); |
| } |
| } |
| } |
| |
| |
| static void __mcount(void *i0) |
| { |
| Dl_info info; |
| unsigned int offset; |
| int *p; |
| static int callsCounted = 0; |
| static int initialized = FALSE; |
| |
| if (!initialized) { |
| dladdr(i0, &info); |
| libFileName = info.dli_fname; |
| #if 0 |
| fprintf(stderr, "Profiling %s\n", libFileName); |
| #endif |
| textOffset = info.dli_fbase; |
| if (getenv("MCOUNT_ORDER_BY_COUNT") != NULL) { |
| orderByCount = TRUE; |
| } |
| countBuf = (int *)malloc(COUNT_BUF_SIZE); |
| memset(countBuf, 0, COUNT_BUF_SIZE); |
| atexit(&doCounts); |
| initialized = TRUE; |
| } |
| |
| if ((uintptr_t)i0 < (uintptr_t)textOffset) { |
| fprintf(stderr, "mcount: function being profiled out of range????\n"); |
| fprintf(stderr, " profiling more than one library at once????\n"); |
| #if 0 |
| dladdr(i0, &info); |
| fprintf(stderr, "Problem with %s in %s ???\n", |
| info.dli_sname, info.dli_fname); |
| #endif |
| fflush(stderr); |
| exit(666); |
| } |
| offset = ((uintptr_t)i0) - ((uintptr_t)textOffset); |
| if (offset > COUNT_BUF_SIZE) { |
| fprintf(stderr, "mcount: internal buffer too small for test.\n"); |
| fprintf(stderr, " or function being profiled out of range????\n"); |
| fprintf(stderr, " or profiling more than one library at once????\n"); |
| #if 0 |
| dladdr(i0, &info); |
| fprintf(stderr, "Problem with %s in %s ???\n", |
| info.dli_sname, info.dli_fname); |
| #endif |
| fflush(stderr); |
| exit(666); |
| } |
| |
| p = &countBuf[offset >>2]; |
| if (orderByCount) { |
| ++*p; |
| } |
| else { |
| if (*p == 0) { |
| *p = ++callsCounted; |
| } |
| } |
| } |
| |
| |
| void _mcount(void) |
| { |
| __mcount(_getReturnAddr()); |
| } |
| |
| |
| void mcount(void) |
| { |
| __mcount(_getReturnAddr()); |
| } |
