1 /*-
2 * Copyright (c) 2009-2011 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: libdwarf_arange.c 3029 2014-04-21 23:26:02Z kaiwang27 $");
30
31 void
_dwarf_arange_cleanup(Dwarf_Debug dbg)32 _dwarf_arange_cleanup(Dwarf_Debug dbg)
33 {
34 Dwarf_ArangeSet as, tas;
35 Dwarf_Arange ar, tar;
36
37 STAILQ_FOREACH_SAFE(as, &dbg->dbg_aslist, as_next, tas) {
38 STAILQ_FOREACH_SAFE(ar, &as->as_arlist, ar_next, tar) {
39 STAILQ_REMOVE(&as->as_arlist, ar, _Dwarf_Arange,
40 ar_next);
41 free(ar);
42 }
43 STAILQ_REMOVE(&dbg->dbg_aslist, as, _Dwarf_ArangeSet, as_next);
44 free(as);
45 }
46
47 if (dbg->dbg_arange_array)
48 free(dbg->dbg_arange_array);
49
50 dbg->dbg_arange_array = NULL;
51 dbg->dbg_arange_cnt = 0;
52 }
53
54 int
_dwarf_arange_init(Dwarf_Debug dbg,Dwarf_Error * error)55 _dwarf_arange_init(Dwarf_Debug dbg, Dwarf_Error *error)
56 {
57 Dwarf_CU cu;
58 Dwarf_ArangeSet as;
59 Dwarf_Arange ar;
60 Dwarf_Section *ds;
61 uint64_t offset, dwarf_size, length, addr, range;
62 int i, ret;
63
64 ret = DW_DLE_NONE;
65
66 if ((ds = _dwarf_find_section(dbg, ".debug_aranges")) == NULL)
67 return (DW_DLE_NONE);
68
69 if (!dbg->dbg_info_loaded) {
70 ret = _dwarf_info_load(dbg, 1, 1, error);
71 if (ret != DW_DLE_NONE)
72 return (ret);
73 }
74
75 offset = 0;
76 while (offset < ds->ds_size) {
77
78 if ((as = malloc(sizeof(struct _Dwarf_ArangeSet))) == NULL) {
79 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
80 return (DW_DLE_MEMORY);
81 }
82 STAILQ_INIT(&as->as_arlist);
83 STAILQ_INSERT_TAIL(&dbg->dbg_aslist, as, as_next);
84
85 /* Read in the table header. */
86 length = dbg->read(ds->ds_data, &offset, 4);
87 if (length == 0xffffffff) {
88 dwarf_size = 8;
89 length = dbg->read(ds->ds_data, &offset, 8);
90 } else
91 dwarf_size = 4;
92
93 as->as_length = length;
94 as->as_version = dbg->read(ds->ds_data, &offset, 2);
95 if (as->as_version != 2) {
96 DWARF_SET_ERROR(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
97 ret = DW_DLE_VERSION_STAMP_ERROR;
98 goto fail_cleanup;
99 }
100
101 as->as_cu_offset = dbg->read(ds->ds_data, &offset, dwarf_size);
102 STAILQ_FOREACH(cu, &dbg->dbg_cu, cu_next) {
103 if (cu->cu_offset == as->as_cu_offset)
104 break;
105 }
106 if (cu == NULL) {
107 DWARF_SET_ERROR(dbg, error, DW_DLE_ARANGE_OFFSET_BAD);
108 ret = DW_DLE_ARANGE_OFFSET_BAD;
109 goto fail_cleanup;
110 }
111 as->as_cu = cu;
112
113 as->as_addrsz = dbg->read(ds->ds_data, &offset, 1);
114 as->as_segsz = dbg->read(ds->ds_data, &offset, 1);
115
116 /* Skip the padding bytes. */
117 offset = roundup(offset, 2 * as->as_addrsz);
118
119 /* Read in address range descriptors. */
120 while (offset < ds->ds_size) {
121 addr = dbg->read(ds->ds_data, &offset, as->as_addrsz);
122 range = dbg->read(ds->ds_data, &offset, as->as_addrsz);
123 if (addr == 0 && range == 0)
124 break;
125 if ((ar = calloc(1, sizeof(struct _Dwarf_Arange))) ==
126 NULL) {
127 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
128 goto fail_cleanup;
129 }
130 ar->ar_as = as;
131 ar->ar_address = addr;
132 ar->ar_range = range;
133 STAILQ_INSERT_TAIL(&as->as_arlist, ar, ar_next);
134 dbg->dbg_arange_cnt++;
135 }
136 }
137
138 /* Build arange array. */
139 if (dbg->dbg_arange_cnt > 0) {
140 if ((dbg->dbg_arange_array = malloc(dbg->dbg_arange_cnt *
141 sizeof(Dwarf_Arange))) == NULL) {
142 DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
143 ret = DW_DLE_MEMORY;
144 goto fail_cleanup;
145 }
146
147 i = 0;
148 STAILQ_FOREACH(as, &dbg->dbg_aslist, as_next) {
149 STAILQ_FOREACH(ar, &as->as_arlist, ar_next)
150 dbg->dbg_arange_array[i++] = ar;
151 }
152 assert((Dwarf_Unsigned)i == dbg->dbg_arange_cnt);
153 }
154
155 return (DW_DLE_NONE);
156
157 fail_cleanup:
158
159 _dwarf_arange_cleanup(dbg);
160
161 return (ret);
162 }
163
164 int
_dwarf_arange_gen(Dwarf_P_Debug dbg,Dwarf_Error * error)165 _dwarf_arange_gen(Dwarf_P_Debug dbg, Dwarf_Error *error)
166 {
167 Dwarf_P_Section ds;
168 Dwarf_Rel_Section drs;
169 Dwarf_ArangeSet as;
170 Dwarf_Arange ar;
171 uint64_t offset;
172 int ret;
173
174 as = dbg->dbgp_as;
175 assert(as != NULL);
176 if (STAILQ_EMPTY(&as->as_arlist))
177 return (DW_DLE_NONE);
178
179 as->as_length = 0;
180 as->as_version = 2;
181 as->as_cu_offset = 0; /* We have only one CU. */
182 as->as_addrsz = dbg->dbg_pointer_size;
183 as->as_segsz = 0; /* XXX */
184
185 /* Create .debug_arange section. */
186 if ((ret = _dwarf_section_init(dbg, &ds, ".debug_aranges", 0, error)) !=
187 DW_DLE_NONE)
188 goto gen_fail0;
189
190 /* Create relocation section for .debug_aranges */
191 RCHECK(_dwarf_reloc_section_init(dbg, &drs, ds, error));
192
193 /* Write section header. */
194 RCHECK(WRITE_VALUE(as->as_length, 4));
195 RCHECK(WRITE_VALUE(as->as_version, 2));
196 RCHECK(_dwarf_reloc_entry_add(dbg, drs, ds, dwarf_drt_data_reloc, 4,
197 ds->ds_size, 0, as->as_cu_offset, ".debug_info", error));
198 RCHECK(WRITE_VALUE(as->as_addrsz, 1));
199 RCHECK(WRITE_VALUE(as->as_segsz, 1));
200
201 /* Pad to (2 * address_size) */
202 offset = roundup(ds->ds_size, 2 * as->as_addrsz);
203 if (offset > ds->ds_size)
204 RCHECK(WRITE_PADDING(0, offset - ds->ds_size));
205
206 /* Write tuples. */
207 STAILQ_FOREACH(ar, &as->as_arlist, ar_next) {
208 RCHECK(_dwarf_reloc_entry_add(dbg, drs, ds,
209 dwarf_drt_data_reloc, dbg->dbg_pointer_size, ds->ds_size,
210 ar->ar_symndx, ar->ar_address, NULL, error));
211 if (ar->ar_esymndx > 0)
212 RCHECK(_dwarf_reloc_entry_add_pair(dbg, drs, ds,
213 dbg->dbg_pointer_size, ds->ds_size, ar->ar_symndx,
214 ar->ar_esymndx, ar->ar_address, ar->ar_eoff, error));
215 else
216 RCHECK(WRITE_VALUE(ar->ar_range, dbg->dbg_pointer_size));
217 }
218 RCHECK(WRITE_VALUE(0, dbg->dbg_pointer_size));
219 RCHECK(WRITE_VALUE(0, dbg->dbg_pointer_size));
220
221 /* Fill in the length field. */
222 as->as_length = ds->ds_size - 4;
223 offset = 0;
224 dbg->write(ds->ds_data, &offset, as->as_length, 4);
225
226 /* Inform application the creation of .debug_aranges ELF section. */
227 RCHECK(_dwarf_section_callback(dbg, ds, SHT_PROGBITS, 0, 0, 0, error));
228
229 /* Finalize relocation section for .debug_aranges */
230 RCHECK(_dwarf_reloc_section_finalize(dbg, drs, error));
231
232 return (DW_DLE_NONE);
233
234 gen_fail:
235 _dwarf_reloc_section_free(dbg, &drs);
236
237 gen_fail0:
238 _dwarf_section_free(dbg, &ds);
239
240 return (ret);
241 }
242
243 void
_dwarf_arange_pro_cleanup(Dwarf_P_Debug dbg)244 _dwarf_arange_pro_cleanup(Dwarf_P_Debug dbg)
245 {
246 Dwarf_ArangeSet as;
247 Dwarf_Arange ar, tar;
248
249 assert(dbg != NULL && dbg->dbg_mode == DW_DLC_WRITE);
250 if (dbg->dbgp_as == NULL)
251 return;
252
253 as = dbg->dbgp_as;
254 STAILQ_FOREACH_SAFE(ar, &as->as_arlist, ar_next, tar) {
255 STAILQ_REMOVE(&as->as_arlist, ar, _Dwarf_Arange, ar_next);
256 free(ar);
257 }
258 free(as);
259 dbg->dbgp_as = NULL;
260 }
261