1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* Copyright (c) 1988 AT&T */ 28 /* All Rights Reserved */ 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 /* 33 * File: symintLoad.c 34 * Date: 12/15/88 35 * 36 * This file provides code to build the profiling symbol array 37 * (array of PROF_SYMBOL). This array contains all of the 38 * symbol table information plus selected debug information for 39 * each file and each function that has a coverage array. 40 * 41 * The symbol table contains entries for every file, every 42 * function, and every coverage array. The debug information 43 * has corresponding entries except that there are no entries 44 * for the coverage arrays. (This may change later.) 45 * 46 * The algorithm for building the profiling symbol array 47 * consists of scanning the symbol table for file, function, 48 * and coverage array entries and building an entry for each. 49 * The construction of an entry is constrained by the 50 * following factors: 51 * 52 * - An entry is built for every file. 53 * 54 * - An entry is built for a function only if there 55 * is a corresponding coverage array for the function. 56 * 57 * - Entries must be ordered in the sense that each 58 * non-file entry points to its owner file and each 59 * file entry points to the next file (or null). 60 * 61 * - The assembler specification (see C Issue 5 3B2 62 * Assembler System Test Specification by Howe, p. 28) 63 * states that all local symbols follow their file 64 * symbol in the symbol table. This allows us to relate 65 * a function and its coverage array to the file that 66 * contains it. 67 * 68 * - For each symbol included in the profiling symbol 69 * array, all corresponding symbol table information must 70 * be present together with selected debug information. 71 * Therefore, the correspondence between a symbol table 72 * entry and a debug entry must be established. 73 * 74 * - Although duplicate (static) function names may appear, 75 * the names are unique within a given file. Also, the 76 * value (address) of each function is included in both 77 * the symbol table information and the debug information. 78 * This provides a verifable correspondence between these 79 * information sets. 80 * 81 */ 82 83 #include "string.h" 84 #include "symint.h" 85 #include "debug.h" 86 87 static PROF_FILE *profPtr; 88 89 /* LINTED: set but not used */ 90 static int prstsym_size; /* size of a symbol table symbol */ 91 92 static PROF_SYMBOL *prsym_list_p = 0; /* the list to return. */ 93 94 /* 95 * _symintLoad(proffilePtr) 96 * proffilePtr - PROF_FILE pointer returned by _symintOpen(). 97 * 98 * returns PROF_SYMBOL * - pointer to the malloc-ed array of 99 * symbol information entries, or 100 * NULL if fails. 101 * 102 * 103 * This routine builds the interface data structure from the data 104 * already loaded during _symintOpen(). 105 * 106 * Prof: 107 * 108 * 1. Allocate a duplicate copy of the symbol table 109 * data. (For Prof, a PROF_SYMBOL is just 110 * a structure containing an Elf32_Sym!) 111 * 112 * 2. Set internal parameters to reflect this. 113 * 114 * 115 * Problems are dealt with by issuing an _err_exit(). 116 * 117 */ 118 PROF_SYMBOL * 119 _symintLoad(PROF_FILE *proffilePtr) 120 { 121 Elf_Data *symdat_pri_p; 122 Elf_Data *symdat_aux_p; 123 PROF_SYMBOL *symlist; 124 125 DEBUG_LOC("_symintLoad: top"); 126 127 profPtr = proffilePtr; 128 129 /* 130 * sanity checks. 131 */ 132 DEBUG_EXP(printf("profPtr = %x\n", profPtr)); 133 DEBUG_EXP(printf("profPtr->pf_symdat_p = %x\n", 134 profPtr->pf_symdat_pri_p)); 135 DEBUG_EXP(printf("profPtr->pf_nstsyms = %x\n", profPtr->pf_nstsyms)); 136 137 assert(profPtr != 0); 138 assert(profPtr->pf_symdat_pri_p != 0); 139 assert(profPtr->pf_nstsyms != 0); 140 141 symdat_pri_p = profPtr->pf_symdat_pri_p; 142 symdat_aux_p = profPtr->pf_symdat_aux_p; 143 DEBUG_EXP(printf("symdat_pri_p->d_size = %x\n", symdat_pri_p->d_size)); 144 145 prstsym_size = (symdat_pri_p->d_size / profPtr->pf_nstsyms); 146 DEBUG_EXP(printf("_symintLoad: prstsym_size = %d\n", 147 prstsym_size)); 148 149 /* 150 * alloc a new copy of the array, and 151 * do a bit-wise copy since the structures 152 * ARE THE SAME SIZE & (effectively) HAVE THE SAME FIELDS! 153 * Set the descriptive `parameters' accordingly. 154 * 155 * If there is an auxiliary symbol table (.SUNW_ldynsym) augmenting 156 * the dynamic symbol table (.dynsym), then we copy both tables 157 * into our copy, with the auxiliary coming first. 158 * 159 * (We'll take a copy, to simplify the 'Drop' logic.) 160 */ 161 162 { 163 size_t st_size; /* size of symbol table data */ 164 165 st_size = symdat_pri_p->d_size; 166 if (profPtr->pf_nstsyms_aux != 0) 167 st_size += symdat_aux_p->d_size; 168 169 NO_DEBUG_LOC("_symintLoad: before malloc for symbol list (PROF)"); 170 prsym_list_p = symlist = (PROF_SYMBOL *)_Malloc(st_size, 1); 171 NO_DEBUG_LOC("_symintLoad: after malloc for symbol list (PROF)"); 172 173 if (profPtr->pf_nstsyms_aux > 0) { 174 NO_DEBUG_LOC("_symintLoad: before memcpy for " 175 "auxiliary symbol list (PROF)"); 176 (void) memcpy(symlist, symdat_aux_p->d_buf, 177 symdat_aux_p->d_size); 178 symlist += profPtr->pf_nstsyms_aux; 179 } 180 181 NO_DEBUG_LOC("_symintLoad: before memcpy for symbol list (PROF)"); 182 (void) memcpy(symlist, symdat_pri_p->d_buf, symdat_pri_p->d_size); 183 184 profPtr->pf_nsyms = profPtr->pf_nstsyms; 185 } 186 187 DEBUG_LOC("_symintLoad: bottom"); 188 return (prsym_list_p); 189 } 190