1 /*-
2 * Copyright (c) 2009,2014 Kai Wang
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include "_libdwarf.h"
28
29 ELFTC_VCSID("$Id: dwarf_loclist.c 3066 2014-06-06 19:36:06Z kaiwang27 $");
30
31 static int
copy_locdesc(Dwarf_Debug dbg,Dwarf_Locdesc * dst,Dwarf_Locdesc * src,Dwarf_Error * error)32 copy_locdesc(Dwarf_Debug dbg, Dwarf_Locdesc *dst, Dwarf_Locdesc *src,
33 Dwarf_Error *error)
34 {
35
36 assert(src != NULL && dst != NULL);
37
38 dst->ld_lopc = src->ld_lopc;
39 dst->ld_hipc = src->ld_hipc;
40 dst->ld_cents = src->ld_cents;
41
42 if (dst->ld_cents > 0) {
43 dst->ld_s = calloc(dst->ld_cents, sizeof(Dwarf_Loc));
44 if (dst->ld_s == NULL) {
45 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
46 return (DW_DLE_MEMORY);
47 }
48 memcpy(dst->ld_s, src->ld_s, src->ld_cents *
49 sizeof(Dwarf_Loc));
50 } else
51 dst->ld_s = NULL;
52
53 return (DW_DLE_NONE);
54 }
55
56 int
dwarf_loclist_n(Dwarf_Attribute at,Dwarf_Locdesc *** llbuf,Dwarf_Signed * listlen,Dwarf_Error * error)57 dwarf_loclist_n(Dwarf_Attribute at, Dwarf_Locdesc ***llbuf,
58 Dwarf_Signed *listlen, Dwarf_Error *error)
59 {
60 Dwarf_Debug dbg;
61 int ret;
62
63 dbg = at != NULL ? at->at_die->die_dbg : NULL;
64
65 if (at == NULL || llbuf == NULL || listlen == NULL) {
66 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);
67 return (DW_DLV_ERROR);
68 }
69
70 switch (at->at_attrib) {
71 case DW_AT_location:
72 case DW_AT_string_length:
73 case DW_AT_return_addr:
74 case DW_AT_data_member_location:
75 case DW_AT_frame_base:
76 case DW_AT_segment:
77 case DW_AT_static_link:
78 case DW_AT_use_location:
79 case DW_AT_vtable_elem_location:
80 switch (at->at_form) {
81 case DW_FORM_data4:
82 case DW_FORM_data8:
83 /*
84 * DW_FORM_data[48] can not be used as section offset
85 * since DWARF4. For DWARF[23], the application needs
86 * to determine if DW_FORM_data[48] is representing
87 * a constant or a section offset.
88 */
89 if (at->at_die->die_cu->cu_version >= 4) {
90 DWARF_SET_ERROR(dbg, error, DW_DLE_NO_ENTRY);
91 return (DW_DLV_NO_ENTRY);
92 }
93 /* FALLTHROUGH */
94 case DW_FORM_sec_offset:
95 ret = _dwarf_loclist_find(dbg, at->at_die->die_cu,
96 at->u[0].u64, llbuf, listlen, NULL, error);
97 if (ret == DW_DLE_NO_ENTRY) {
98 DWARF_SET_ERROR(dbg, error, ret);
99 return (DW_DLV_NO_ENTRY);
100 }
101 if (ret != DW_DLE_NONE)
102 return (DW_DLV_ERROR);
103 return (DW_DLV_OK);
104 case DW_FORM_block:
105 case DW_FORM_block1:
106 case DW_FORM_block2:
107 case DW_FORM_block4:
108 case DW_FORM_exprloc:
109 if (at->at_ld == NULL) {
110 ret = _dwarf_loc_add(at->at_die, at, error);
111 if (ret != DW_DLE_NONE)
112 return (DW_DLV_ERROR);
113 }
114 *llbuf = calloc(1, sizeof(Dwarf_Locdesc *));
115 if (*llbuf == NULL) {
116 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
117 return (DW_DLV_ERROR);
118 }
119 (*llbuf)[0] = calloc(1, sizeof(Dwarf_Locdesc));
120 if ((*llbuf)[0] == NULL) {
121 free(*llbuf);
122 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
123 return (DW_DLV_ERROR);
124 }
125 if (copy_locdesc(dbg, (*llbuf)[0], at->at_ld, error) !=
126 DW_DLE_NONE) {
127 free((*llbuf)[0]);
128 free(*llbuf);
129 return (DW_DLV_ERROR);
130 }
131 *listlen = 1;
132 return (DW_DLV_OK);
133 default:
134 /* Malformed Attr? */
135 DWARF_SET_ERROR(dbg, error, DW_DLE_ATTR_FORM_BAD);
136 return (DW_DLV_NO_ENTRY);
137 }
138 default:
139 /* Wrong attr supplied. */
140 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);
141 return (DW_DLV_ERROR);
142 }
143 }
144
145 int
dwarf_loclist(Dwarf_Attribute at,Dwarf_Locdesc ** llbuf,Dwarf_Signed * listlen,Dwarf_Error * error)146 dwarf_loclist(Dwarf_Attribute at, Dwarf_Locdesc **llbuf,
147 Dwarf_Signed *listlen, Dwarf_Error *error)
148 {
149 Dwarf_Locdesc **_llbuf;
150 int i, ret;
151
152 ret = dwarf_loclist_n(at, &_llbuf, listlen, error);
153 if (ret != DW_DLV_OK)
154 return (ret);
155
156 /* Only return the first location description of the list. */
157 *llbuf = _llbuf[0];
158
159 /* Free the rest of the list. */
160 for (i = 1; i < *listlen; i++) {
161 if (_llbuf[i]->ld_s)
162 free(_llbuf[i]->ld_s);
163 free(_llbuf[i]);
164 }
165 free(_llbuf);
166
167 *listlen = 1;
168
169 return (DW_DLV_OK);
170 }
171
172 int
dwarf_get_loclist_entry(Dwarf_Debug dbg,Dwarf_Unsigned offset,Dwarf_Addr * hipc,Dwarf_Addr * lopc,Dwarf_Ptr * data,Dwarf_Unsigned * entry_len,Dwarf_Unsigned * next_entry,Dwarf_Error * error)173 dwarf_get_loclist_entry(Dwarf_Debug dbg, Dwarf_Unsigned offset,
174 Dwarf_Addr *hipc, Dwarf_Addr *lopc, Dwarf_Ptr *data,
175 Dwarf_Unsigned *entry_len, Dwarf_Unsigned *next_entry,
176 Dwarf_Error *error)
177 {
178 Dwarf_Locdesc *ld, **llbuf;
179 Dwarf_Section *ds;
180 Dwarf_Signed listlen;
181 int i, ret;
182
183 /*
184 * Note that this API sometimes will not work correctly because
185 * it assumes that all units have the same pointer size and offset
186 * size.
187 */
188
189 if (dbg == NULL || hipc == NULL || lopc == NULL || data == NULL ||
190 entry_len == NULL || next_entry == NULL) {
191 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);
192 return (DW_DLV_ERROR);
193 }
194
195 ret = _dwarf_loclist_find(dbg, STAILQ_FIRST(&dbg->dbg_cu), offset,
196 &llbuf, &listlen, entry_len, error);
197 if (ret == DW_DLE_NO_ENTRY) {
198 DWARF_SET_ERROR(dbg, error, DW_DLV_NO_ENTRY);
199 return (DW_DLV_NO_ENTRY);
200 } else if (ret != DW_DLE_NONE)
201 return (DW_DLV_ERROR);
202
203 *hipc = *lopc = 0;
204 for (i = 0; i < listlen; i++) {
205 ld = llbuf[i];
206 if (i == 0) {
207 *hipc = ld->ld_hipc;
208 *lopc = ld->ld_lopc;
209 } else {
210 if (ld->ld_lopc < *lopc)
211 *lopc = ld->ld_lopc;
212 if (ld->ld_hipc > *hipc)
213 *hipc = ld->ld_hipc;
214 }
215 }
216
217 ds = _dwarf_find_section(dbg, ".debug_loc");
218 assert(ds != NULL);
219 *data = (uint8_t *) ds->ds_data + offset;
220 *next_entry = offset + *entry_len;
221
222 return (DW_DLV_OK);
223 }
224
225 int
dwarf_loclist_from_expr(Dwarf_Debug dbg,Dwarf_Ptr bytes_in,Dwarf_Unsigned bytes_len,Dwarf_Locdesc ** llbuf,Dwarf_Signed * listlen,Dwarf_Error * error)226 dwarf_loclist_from_expr(Dwarf_Debug dbg, Dwarf_Ptr bytes_in,
227 Dwarf_Unsigned bytes_len, Dwarf_Locdesc **llbuf, Dwarf_Signed *listlen,
228 Dwarf_Error *error)
229 {
230
231 return (dwarf_loclist_from_expr_a(dbg, bytes_in, bytes_len,
232 dbg->dbg_pointer_size, llbuf, listlen, error));
233 }
234
235 int
dwarf_loclist_from_expr_a(Dwarf_Debug dbg,Dwarf_Ptr bytes_in,Dwarf_Unsigned bytes_len,Dwarf_Half addr_size,Dwarf_Locdesc ** llbuf,Dwarf_Signed * listlen,Dwarf_Error * error)236 dwarf_loclist_from_expr_a(Dwarf_Debug dbg, Dwarf_Ptr bytes_in,
237 Dwarf_Unsigned bytes_len, Dwarf_Half addr_size, Dwarf_Locdesc **llbuf,
238 Dwarf_Signed *listlen, Dwarf_Error *error)
239 {
240 Dwarf_Half offset_size;
241 Dwarf_Small version;
242
243 /*
244 * Obtain offset size and DWARF version from the current
245 * Compilation Unit or Type Unit. These values are needed
246 * for correctly parsing DW_OP_GNU_implicit_pointer operator.
247 *
248 * Note that dwarf_loclist_from_expr_b() should be used instead
249 * if the application knows correct values for offset size
250 * and DWARF version.
251 */
252 if (dbg->dbg_cu_current) {
253 offset_size = dbg->dbg_cu_current->cu_length_size == 4 ? 4 : 8;
254 version = dbg->dbg_cu_current->cu_version;
255 } else if (dbg->dbg_tu_current) {
256 offset_size = dbg->dbg_tu_current->cu_length_size == 4 ? 4 : 8;
257 version = dbg->dbg_tu_current->cu_version;
258 } else {
259 /* Default values if no CU/TU context. */
260 offset_size = 4;
261 version = 2; /* DWARF2 */
262 }
263
264 return (dwarf_loclist_from_expr_b(dbg, bytes_in, bytes_len, addr_size,
265 offset_size, version, llbuf, listlen, error));
266 }
267
268 int
dwarf_loclist_from_expr_b(Dwarf_Debug dbg,Dwarf_Ptr bytes_in,Dwarf_Unsigned bytes_len,Dwarf_Half addr_size,Dwarf_Half offset_size,Dwarf_Small version,Dwarf_Locdesc ** llbuf,Dwarf_Signed * listlen,Dwarf_Error * error)269 dwarf_loclist_from_expr_b(Dwarf_Debug dbg, Dwarf_Ptr bytes_in,
270 Dwarf_Unsigned bytes_len, Dwarf_Half addr_size, Dwarf_Half offset_size,
271 Dwarf_Small version, Dwarf_Locdesc **llbuf, Dwarf_Signed *listlen,
272 Dwarf_Error *error)
273 {
274 Dwarf_Locdesc *ld;
275 int ret;
276
277 if (dbg == NULL || bytes_in == NULL || bytes_len == 0 ||
278 llbuf == NULL || listlen == NULL) {
279 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);
280 return (DW_DLV_ERROR);
281 }
282
283 if (addr_size != 4 && addr_size != 8) {
284 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);
285 return (DW_DLV_ERROR);
286 }
287
288 if (offset_size != 4 && offset_size != 8) {
289 DWARF_SET_ERROR(dbg, error, DW_DLE_ARGUMENT);
290 return (DW_DLV_ERROR);
291 }
292
293 ret = _dwarf_loc_fill_locexpr(dbg, &ld, bytes_in, bytes_len, addr_size,
294 offset_size, version, error);
295 if (ret != DW_DLE_NONE)
296 return (DW_DLV_ERROR);
297
298 *llbuf = ld;
299 *listlen = 1;
300
301 return (DW_DLV_OK);
302 }
303