1 /* Get public symbol information. 2 Copyright (C) 2002, 2003, 2004, 2005, 2008 Red Hat, Inc. 3 This file is part of elfutils. 4 Written by Ulrich Drepper <drepper (at) redhat.com>, 2002. 5 6 This file is free software; you can redistribute it and/or modify 7 it under the terms of either 8 9 * the GNU Lesser General Public License as published by the Free 10 Software Foundation; either version 3 of the License, or (at 11 your option) any later version 12 13 or 14 15 * the GNU General Public License as published by the Free 16 Software Foundation; either version 2 of the License, or (at 17 your option) any later version 18 19 or both in parallel, as here. 20 21 elfutils is distributed in the hope that it will be useful, but 22 WITHOUT ANY WARRANTY; without even the implied warranty of 23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 24 General Public License for more details. 25 26 You should have received copies of the GNU General Public License and 27 the GNU Lesser General Public License along with this program. If 28 not, see <http://www.gnu.org/licenses/>. */ 29 30 #ifdef HAVE_CONFIG_H 31 # include <config.h> 32 #endif 33 34 #include <assert.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <sys/param.h> 38 39 #include <libdwP.h> 40 #include <dwarf.h> 41 42 43 static int 44 get_offsets (Dwarf *dbg) 45 { 46 size_t allocated = 0; 47 size_t cnt = 0; 48 struct pubnames_s *mem = NULL; 49 const size_t entsize = sizeof (struct pubnames_s); 50 unsigned char *const startp = dbg->sectiondata[IDX_debug_pubnames]->d_buf; 51 unsigned char *readp = startp; 52 unsigned char *endp = readp + dbg->sectiondata[IDX_debug_pubnames]->d_size; 53 54 while (readp + 14 < endp) 55 { 56 /* If necessary, allocate more entries. */ 57 if (cnt >= allocated) 58 { 59 allocated = MAX (10, 2 * allocated); 60 struct pubnames_s *newmem 61 = (struct pubnames_s *) realloc (mem, allocated * entsize); 62 if (newmem == NULL) 63 { 64 __libdw_seterrno (DWARF_E_NOMEM); 65 err_return: 66 free (mem); 67 return -1; 68 } 69 70 mem = newmem; 71 } 72 73 /* Read the set header. */ 74 int len_bytes = 4; 75 Dwarf_Off len = read_4ubyte_unaligned_inc (dbg, readp); 76 if (len == DWARF3_LENGTH_64_BIT) 77 { 78 len = read_8ubyte_unaligned_inc (dbg, readp); 79 len_bytes = 8; 80 } 81 else if (unlikely (len >= DWARF3_LENGTH_MIN_ESCAPE_CODE 82 && len <= DWARF3_LENGTH_MAX_ESCAPE_CODE)) 83 { 84 __libdw_seterrno (DWARF_E_INVALID_DWARF); 85 goto err_return; 86 } 87 88 /* Now we know the offset of the first offset/name pair. */ 89 mem[cnt].set_start = readp + 2 + 2 * len_bytes - startp; 90 mem[cnt].address_len = len_bytes; 91 size_t max_size = dbg->sectiondata[IDX_debug_pubnames]->d_size; 92 if (mem[cnt].set_start >= max_size 93 || len - (2 + 2 * len_bytes) > max_size - mem[cnt].set_start) 94 /* Something wrong, the first entry is beyond the end of 95 the section. Or the length of the whole unit is too big. */ 96 break; 97 98 /* Read the version. It better be two for now. */ 99 uint16_t version = read_2ubyte_unaligned (dbg, readp); 100 if (unlikely (version != 2)) 101 { 102 __libdw_seterrno (DWARF_E_INVALID_VERSION); 103 goto err_return; 104 } 105 106 /* Get the CU offset. */ 107 if (__libdw_read_offset (dbg, dbg, IDX_debug_pubnames, 108 readp + 2, len_bytes, 109 &mem[cnt].cu_offset, IDX_debug_info, 3)) 110 /* Error has been already set in reader. */ 111 goto err_return; 112 113 /* Determine the size of the CU header. */ 114 unsigned char *infop 115 = ((unsigned char *) dbg->sectiondata[IDX_debug_info]->d_buf 116 + mem[cnt].cu_offset); 117 if (read_4ubyte_unaligned_noncvt (infop) == DWARF3_LENGTH_64_BIT) 118 mem[cnt].cu_header_size = 23; 119 else 120 mem[cnt].cu_header_size = 11; 121 122 ++cnt; 123 124 /* Advance to the next set. */ 125 readp += len; 126 } 127 128 if (mem == NULL || cnt == 0) 129 { 130 free (mem); 131 __libdw_seterrno (DWARF_E_NO_ENTRY); 132 return -1; 133 } 134 135 dbg->pubnames_sets = (struct pubnames_s *) realloc (mem, cnt * entsize); 136 dbg->pubnames_nsets = cnt; 137 138 return 0; 139 } 140 141 142 ptrdiff_t 143 dwarf_getpubnames (Dwarf *dbg, 144 int (*callback) (Dwarf *, Dwarf_Global *, void *), 145 void *arg, ptrdiff_t offset) 146 { 147 if (dbg == NULL) 148 return -1l; 149 150 if (unlikely (offset < 0)) 151 { 152 __libdw_seterrno (DWARF_E_INVALID_OFFSET); 153 return -1l; 154 } 155 156 /* Make sure it is a valid offset. */ 157 if (unlikely (dbg->sectiondata[IDX_debug_pubnames] == NULL 158 || ((size_t) offset 159 >= dbg->sectiondata[IDX_debug_pubnames]->d_size))) 160 /* No (more) entry. */ 161 return 0; 162 163 /* If necessary read the set information. */ 164 if (dbg->pubnames_nsets == 0 && unlikely (get_offsets (dbg) != 0)) 165 return -1l; 166 167 /* Find the place where to start. */ 168 size_t cnt; 169 if (offset == 0) 170 { 171 cnt = 0; 172 offset = dbg->pubnames_sets[0].set_start; 173 } 174 else 175 { 176 for (cnt = 0; cnt + 1 < dbg->pubnames_nsets; ++cnt) 177 if ((Dwarf_Off) offset >= dbg->pubnames_sets[cnt].set_start) 178 { 179 assert ((Dwarf_Off) offset 180 < dbg->pubnames_sets[cnt + 1].set_start); 181 break; 182 } 183 assert (cnt + 1 < dbg->pubnames_nsets); 184 } 185 186 unsigned char *startp 187 = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf; 188 unsigned char *endp 189 = startp + dbg->sectiondata[IDX_debug_pubnames]->d_size; 190 unsigned char *readp = startp + offset; 191 while (1) 192 { 193 Dwarf_Global gl; 194 195 gl.cu_offset = (dbg->pubnames_sets[cnt].cu_offset 196 + dbg->pubnames_sets[cnt].cu_header_size); 197 198 while (1) 199 { 200 /* READP points to the next offset/name pair. */ 201 if (readp + dbg->pubnames_sets[cnt].address_len > endp) 202 goto invalid_dwarf; 203 if (dbg->pubnames_sets[cnt].address_len == 4) 204 gl.die_offset = read_4ubyte_unaligned_inc (dbg, readp); 205 else 206 gl.die_offset = read_8ubyte_unaligned_inc (dbg, readp); 207 208 /* If the offset is zero we reached the end of the set. */ 209 if (gl.die_offset == 0) 210 break; 211 212 /* Add the CU offset. */ 213 gl.die_offset += dbg->pubnames_sets[cnt].cu_offset; 214 215 gl.name = (char *) readp; 216 readp = (unsigned char *) memchr (gl.name, '\0', endp - readp); 217 if (unlikely (readp == NULL)) 218 { 219 invalid_dwarf: 220 __libdw_seterrno (DWARF_E_INVALID_DWARF); 221 return -1l; 222 } 223 readp++; 224 225 /* We found name and DIE offset. Report it. */ 226 if (callback (dbg, &gl, arg) != DWARF_CB_OK) 227 { 228 /* The user wants us to stop. Return the offset of the 229 next entry. */ 230 return readp - startp; 231 } 232 } 233 234 if (++cnt == dbg->pubnames_nsets) 235 /* This was the last set. */ 236 break; 237 238 startp = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf; 239 readp = startp + dbg->pubnames_sets[cnt].set_start; 240 } 241 242 /* We are done. No more entries. */ 243 return 0; 244 } 245
