xref: /netbsd-src/external/bsd/elftoolchain/dist/libdwarf/libdwarf_reloc.c (revision 97a4ef43945bbf8f80b8784adfc42a9fd831997f)
1 /*	$NetBSD: libdwarf_reloc.c,v 1.7 2024/03/31 03:20:38 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 2010 Kai Wang
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include "_libdwarf.h"
30 
31 __RCSID("$NetBSD: libdwarf_reloc.c,v 1.7 2024/03/31 03:20:38 christos Exp $");
32 ELFTC_VCSID("Id: libdwarf_reloc.c 3741 2019-06-07 06:32:01Z jkoshy");
33 
34 Dwarf_Unsigned
_dwarf_get_reloc_type(Dwarf_P_Debug dbg,int is64)35 _dwarf_get_reloc_type(Dwarf_P_Debug dbg, int is64)
36 {
37 
38 	assert(dbg != NULL);
39 
40 	switch (dbg->dbgp_isa) {
41 	case DW_ISA_AARCH64:
42 		return (is64 ? R_AARCH64_ABS64 : R_AARCH64_ABS32);
43 	case DW_ISA_X86:
44 		return (R_386_32);
45 	case DW_ISA_X86_64:
46 		return (is64 ? R_X86_64_64 : R_X86_64_32);
47 	case DW_ISA_SPARC:
48 		return (is64 ? R_SPARC_UA64 : R_SPARC_UA32);
49 	case DW_ISA_PPC:
50 		return (is64 ? R_PPC64_ADDR64 : R_PPC_ADDR32);
51 	case DW_ISA_ARM:
52 		return (R_ARM_ABS32);
53 	case DW_ISA_MIPS:
54 		return (is64 ? R_MIPS_64 : R_MIPS_32);
55 	case DW_ISA_RISCV:
56 		return (is64 ? R_RISCV_64 : R_RISCV_32);
57 	case DW_ISA_IA64:
58 		return (is64 ? R_IA_64_DIR64LSB : R_IA_64_DIR32LSB);
59 	default:
60 		break;
61 	}
62 	return (0);		/* NOT REACHED */
63 }
64 
65 int
_dwarf_get_reloc_size(Dwarf_Debug dbg,Dwarf_Unsigned rel_type)66 _dwarf_get_reloc_size(Dwarf_Debug dbg, Dwarf_Unsigned rel_type)
67 {
68 
69 	switch (dbg->dbg_machine) {
70 	case EM_NONE:
71 		break;
72 	case EM_AARCH64:
73 		if (rel_type == R_AARCH64_ABS32)
74 			return (4);
75 		else if (rel_type == R_AARCH64_ABS64)
76 			return (8);
77 		break;
78 	case EM_ARM:
79 		if (rel_type == R_ARM_ABS32)
80 			return (4);
81 		break;
82 	case EM_386:
83 	case EM_IAMCU:
84 		if (rel_type == R_386_32)
85 			return (4);
86 		break;
87 	case EM_X86_64:
88 		if (rel_type == R_X86_64_32)
89 			return (4);
90 		else if (rel_type == R_X86_64_64)
91 			return (8);
92 		break;
93 	case EM_SPARC:
94 		if (rel_type == R_SPARC_UA32)
95 			return (4);
96 		else if (rel_type == R_SPARC_UA64)
97 			return (8);
98 		break;
99 	case EM_PPC:
100 		if (rel_type == R_PPC_ADDR32)
101 			return (4);
102 		break;
103 	case EM_PPC64:
104 		if (rel_type == R_PPC_ADDR32)
105 			return (4);
106 		else if (rel_type == R_PPC64_ADDR64)
107 			return (8);
108 		break;
109 	case EM_MIPS:
110 		if (rel_type == R_MIPS_32)
111 			return (4);
112 		else if (rel_type == R_MIPS_64)
113 			return (8);
114 		break;
115 	case EM_RISCV:
116 		if (rel_type == R_RISCV_32)
117 			return (4);
118 		else if (rel_type == R_RISCV_64)
119 			return (8);
120 		break;
121 	case EM_IA_64:
122 		if (rel_type == R_IA_64_SECREL32LSB)
123 			return (4);
124 		else if (rel_type == R_IA_64_DIR64LSB)
125 			return (8);
126 		break;
127 	default:
128 		break;
129 	}
130 
131 	/* unknown relocation. */
132 	return (0);
133 }
134 
135 int
_dwarf_reloc_section_init(Dwarf_P_Debug dbg,Dwarf_Rel_Section * drsp,Dwarf_P_Section ref,Dwarf_Error * error)136 _dwarf_reloc_section_init(Dwarf_P_Debug dbg, Dwarf_Rel_Section *drsp,
137     Dwarf_P_Section ref, Dwarf_Error *error)
138 {
139 	Dwarf_Rel_Section drs;
140 	char name[128];
141 	int pseudo;
142 
143 	assert(dbg != NULL && drsp != NULL && ref != NULL);
144 
145 	if ((drs = calloc(1, sizeof(struct _Dwarf_Rel_Section))) == NULL) {
146 		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
147 		return (DW_DLE_MEMORY);
148 	}
149 
150 	drs->drs_ref = ref;
151 
152 	/*
153 	 * FIXME The logic here is most likely wrong. It should
154 	 * be the ISA that determines relocation type.
155 	 */
156 	if (dbg->dbgp_flags & DW_DLC_SIZE_64)
157 		drs->drs_addend = 1;
158 	else
159 		drs->drs_addend = 0;
160 
161 	if (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS)
162 		pseudo = 1;
163 	else
164 		pseudo = 0;
165 
166 	snprintf(name, sizeof(name), "%s%s",
167 	    drs->drs_addend ? ".rela" : ".rel", ref->ds_name);
168 	if (_dwarf_section_init(dbg, &drs->drs_ds, name, pseudo, error) !=
169 	    DW_DLE_NONE) {
170 		free(drs);
171 		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
172 		return (DW_DLE_MEMORY);
173 	}
174 
175 	STAILQ_INIT(&drs->drs_dre);
176 	STAILQ_INSERT_TAIL(&dbg->dbgp_drslist, drs, drs_next);
177 	dbg->dbgp_drscnt++;
178 	*drsp = drs;
179 
180 	return (DW_DLE_NONE);
181 }
182 
183 void
_dwarf_reloc_section_free(Dwarf_P_Debug dbg,Dwarf_Rel_Section * drsp)184 _dwarf_reloc_section_free(Dwarf_P_Debug dbg, Dwarf_Rel_Section *drsp)
185 {
186 	Dwarf_Rel_Section drs, tdrs;
187 	Dwarf_Rel_Entry dre, tdre;
188 
189 	assert(dbg != NULL && drsp != NULL);
190 
191 	if (*drsp == NULL)
192 		return;
193 
194 	STAILQ_FOREACH_SAFE(drs, &dbg->dbgp_drslist, drs_next, tdrs) {
195 		if (drs != *drsp)
196 			continue;
197 		STAILQ_REMOVE(&dbg->dbgp_drslist, drs, _Dwarf_Rel_Section,
198 		    drs_next);
199 		STAILQ_FOREACH_SAFE(dre, &drs->drs_dre, dre_next, tdre) {
200 			STAILQ_REMOVE(&drs->drs_dre, dre, _Dwarf_Rel_Entry,
201 			    dre_next);
202 			free(dre);
203 		}
204 		if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0)
205 			_dwarf_section_free(dbg, &drs->drs_ds);
206 		else {
207 			if (drs->drs_ds->ds_name)
208 				free(drs->drs_ds->ds_name);
209 			free(drs->drs_ds);
210 		}
211 		free(drs);
212 		*drsp = NULL;
213 		dbg->dbgp_drscnt--;
214 		break;
215 	}
216 }
217 
218 int
_dwarf_reloc_entry_add(Dwarf_P_Debug dbg,Dwarf_Rel_Section drs,Dwarf_P_Section ds,unsigned char type,unsigned char length,Dwarf_Unsigned offset,Dwarf_Unsigned symndx,Dwarf_Unsigned addend,const char * secname,Dwarf_Error * error)219 _dwarf_reloc_entry_add(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
220     Dwarf_P_Section ds, unsigned char type, unsigned char length,
221     Dwarf_Unsigned offset, Dwarf_Unsigned symndx, Dwarf_Unsigned addend,
222     const char *secname, Dwarf_Error *error)
223 {
224 	Dwarf_Rel_Entry dre;
225 	Dwarf_Unsigned reloff;
226 	int ret;
227 
228 	assert(drs != NULL);
229 	assert(offset <= ds->ds_size);
230 	reloff = offset;
231 
232 	/*
233 	 * If the DW_DLC_SYMBOLIC_RELOCATIONS flag is set or ElfXX_Rel
234 	 * is used instead of ELfXX_Rela, we need to write the addend
235 	 * in the storage unit to be relocated. Otherwise write 0 in the
236 	 * storage unit and the addend will be written into relocation
237 	 * section later.
238 	 */
239 	if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) ||
240 	    drs->drs_addend == 0)
241 		ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset,
242 		    addend, length, error);
243 	else
244 		ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset,
245 		    0, length, error);
246 	if (ret != DW_DLE_NONE)
247 		return (ret);
248 	if (offset > ds->ds_size)
249 		ds->ds_size = offset;
250 
251 	if ((dre = calloc(1, sizeof(struct _Dwarf_Rel_Entry))) == NULL) {
252 		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
253 		return (DW_DLE_MEMORY);
254 	}
255 	STAILQ_INSERT_TAIL(&drs->drs_dre, dre, dre_next);
256 	dre->dre_type = type;
257 	dre->dre_length = length;
258 	dre->dre_offset = reloff;
259 	dre->dre_symndx = symndx;
260 	dre->dre_addend = addend;
261 	dre->dre_secname = secname;
262 	drs->drs_drecnt++;
263 
264 	return (DW_DLE_NONE);
265 }
266 
267 int
_dwarf_reloc_entry_add_pair(Dwarf_P_Debug dbg,Dwarf_Rel_Section drs,Dwarf_P_Section ds,unsigned char length,Dwarf_Unsigned offset,Dwarf_Unsigned symndx,Dwarf_Unsigned esymndx,Dwarf_Unsigned symoff,Dwarf_Unsigned esymoff,Dwarf_Error * error)268 _dwarf_reloc_entry_add_pair(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
269     Dwarf_P_Section ds, unsigned char length, Dwarf_Unsigned offset,
270     Dwarf_Unsigned symndx, Dwarf_Unsigned esymndx, Dwarf_Unsigned symoff,
271     Dwarf_Unsigned esymoff, Dwarf_Error *error)
272 {
273 	Dwarf_Rel_Entry dre;
274 	Dwarf_Unsigned reloff;
275 	int ret;
276 
277 	assert(drs != NULL);
278 	assert(offset <= ds->ds_size);
279 	assert(dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS);
280 	reloff = offset;
281 
282 	/* Write net offset into section stream. */
283 	ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap, &offset,
284 	    esymoff - symoff, length, error);
285 	if (ret != DW_DLE_NONE)
286 		return (ret);
287 	if (offset > ds->ds_size)
288 		ds->ds_size = offset;
289 
290 	if ((dre = calloc(2, sizeof(struct _Dwarf_Rel_Entry))) == NULL) {
291 		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
292 		return (DW_DLE_MEMORY);
293 	}
294 	STAILQ_INSERT_TAIL(&drs->drs_dre, &dre[0], dre_next);
295 	STAILQ_INSERT_TAIL(&drs->drs_dre, &dre[1], dre_next);
296 	dre[0].dre_type = dwarf_drt_first_of_length_pair;
297 	dre[0].dre_length = length;
298 	dre[0].dre_offset = reloff;
299 	dre[0].dre_symndx = symndx;
300 	dre[0].dre_addend = 0;
301 	dre[0].dre_secname = NULL;
302 	dre[1].dre_type = dwarf_drt_second_of_length_pair;
303 	dre[1].dre_length = length;
304 	dre[1].dre_offset = reloff;
305 	dre[1].dre_symndx = esymndx;
306 	dre[1].dre_addend = 0;
307 	dre[1].dre_secname = NULL;
308 	drs->drs_drecnt += 2;
309 
310 	return (DW_DLE_NONE);
311 }
312 
313 int
_dwarf_reloc_section_finalize(Dwarf_P_Debug dbg,Dwarf_Rel_Section drs,Dwarf_Error * error)314 _dwarf_reloc_section_finalize(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
315     Dwarf_Error *error)
316 {
317 	Dwarf_P_Section ds;
318 	Dwarf_Unsigned unit;
319 	int ret, size;
320 
321 	assert(dbg != NULL && drs != NULL && drs->drs_ds != NULL &&
322 	    drs->drs_ref != NULL);
323 
324 	ds = drs->drs_ds;
325 
326 	/*
327 	 * Calculate the size (in bytes) of the relocation section.
328 	 */
329 	if (dbg->dbgp_flags & DW_DLC_SIZE_64)
330 		unit = drs->drs_addend ? sizeof(Elf64_Rela) : sizeof(Elf64_Rel);
331 	else
332 		unit = drs->drs_addend ? sizeof(Elf32_Rela) : sizeof(Elf32_Rel);
333 	assert(ds->ds_size == 0);
334 	size = drs->drs_drecnt * unit;
335 
336 	/*
337 	 * Discard this relocation section if there is no entry in it.
338 	 */
339 	if (size == 0) {
340 		_dwarf_reloc_section_free(dbg, &drs);
341 		return (DW_DLE_NONE);
342 	}
343 
344 	/*
345 	 * If we are under stream mode, realloc the section data block to
346 	 * this size.
347 	 */
348 	if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) {
349 		ds->ds_cap = size;
350 		if ((ds->ds_data = realloc(ds->ds_data, (size_t) ds->ds_cap)) ==
351 		    NULL) {
352 			DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
353 			return (DW_DLE_MEMORY);
354 		}
355 	}
356 
357 	/*
358 	 * Notify the application the creation of this relocation section.
359 	 * Note that the section link here should point to the .symtab
360 	 * section, we set it to 0 since we have no way to know .symtab
361 	 * section index.
362 	 */
363 	ret = _dwarf_pro_callback(dbg, ds->ds_name, size,
364 	    drs->drs_addend ? SHT_RELA : SHT_REL, 0, 0, drs->drs_ref->ds_ndx,
365 	    &ds->ds_symndx, NULL);
366 	if (ret < 0) {
367 		DWARF_SET_ERROR(dbg, error, DW_DLE_ELF_SECT_ERR);
368 		return (DW_DLE_ELF_SECT_ERR);
369 	}
370 	ds->ds_ndx = ret;
371 
372 	return (DW_DLE_NONE);
373 }
374 
375 int
_dwarf_reloc_section_gen(Dwarf_P_Debug dbg,Dwarf_Rel_Section drs,Dwarf_Error * error)376 _dwarf_reloc_section_gen(Dwarf_P_Debug dbg, Dwarf_Rel_Section drs,
377     Dwarf_Error *error)
378 {
379 	Dwarf_Rel_Entry dre;
380 	Dwarf_P_Section ds;
381 	Dwarf_Unsigned type;
382 	int ret;
383 
384 	assert((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0);
385 	assert(drs->drs_ds != NULL && drs->drs_ds->ds_size == 0);
386 	assert(!STAILQ_EMPTY(&drs->drs_dre));
387 	ds = drs->drs_ds;
388 
389 	STAILQ_FOREACH(dre, &drs->drs_dre, dre_next) {
390 		assert(dre->dre_length == 4 || dre->dre_length == 8);
391 		type = _dwarf_get_reloc_type(dbg, dre->dre_length == 8);
392 		if (dbg->dbgp_flags & DW_DLC_SIZE_64) {
393 			/* Write r_offset (8 bytes) */
394 			ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
395 			    &ds->ds_size, dre->dre_offset, 8, error);
396 			if (ret != DW_DLE_NONE)
397 				return (ret);
398 			/* Write r_info (8 bytes) */
399 			ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
400 			    &ds->ds_size, ELF64_R_INFO(dre->dre_symndx, type),
401 			    8, error);
402 			if (ret != DW_DLE_NONE)
403 				return (ret);
404 			/* Write r_addend (8 bytes) */
405 			if (drs->drs_addend) {
406 				ret = dbg->write_alloc(&ds->ds_data,
407 				    &ds->ds_cap, &ds->ds_size, dre->dre_addend,
408 				    8, error);
409 				if (ret != DW_DLE_NONE)
410 					return (ret);
411 			}
412 		} else {
413 			/* Write r_offset (4 bytes) */
414 			ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
415 			    &ds->ds_size, dre->dre_offset, 4, error);
416 			if (ret != DW_DLE_NONE)
417 				return (ret);
418 			/* Write r_info (4 bytes) */
419 			ret = dbg->write_alloc(&ds->ds_data, &ds->ds_cap,
420 			    &ds->ds_size, ELF32_R_INFO(dre->dre_symndx, type),
421 			    4, error);
422 			if (ret != DW_DLE_NONE)
423 				return (ret);
424 			/* Write r_addend (4 bytes) */
425 			if (drs->drs_addend) {
426 				ret = dbg->write_alloc(&ds->ds_data,
427 				    &ds->ds_cap, &ds->ds_size, dre->dre_addend,
428 				    4, error);
429 				if (ret != DW_DLE_NONE)
430 					return (ret);
431 			}
432 		}
433 	}
434 	assert(ds->ds_size == ds->ds_cap);
435 
436 	return (DW_DLE_NONE);
437 }
438 
439 int
_dwarf_reloc_gen(Dwarf_P_Debug dbg,Dwarf_Error * error)440 _dwarf_reloc_gen(Dwarf_P_Debug dbg, Dwarf_Error *error)
441 {
442 	Dwarf_Rel_Section drs;
443 	Dwarf_Rel_Entry dre;
444 	Dwarf_P_Section ds;
445 	int ret;
446 
447 	STAILQ_FOREACH(drs, &dbg->dbgp_drslist, drs_next) {
448 		/*
449 		 * Update relocation entries: translate any section name
450 		 * reference to section symbol index.
451 		 */
452 		STAILQ_FOREACH(dre, &drs->drs_dre, dre_next) {
453 			if (dre->dre_secname == NULL)
454 				continue;
455 			ds = _dwarf_pro_find_section(dbg, dre->dre_secname);
456 			assert(ds != NULL && ds->ds_symndx != 0);
457 			dre->dre_symndx = ds->ds_symndx;
458 		}
459 
460 		/*
461 		 * Generate ELF relocation section if we are under stream
462 		 * mode.
463 		 */
464 		if ((dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) == 0) {
465 			ret = _dwarf_reloc_section_gen(dbg, drs, error);
466 			if (ret != DW_DLE_NONE)
467 				return (ret);
468 		}
469 	}
470 
471 	return (DW_DLE_NONE);
472 }
473 
474 void
_dwarf_reloc_cleanup(Dwarf_P_Debug dbg)475 _dwarf_reloc_cleanup(Dwarf_P_Debug dbg)
476 {
477 	Dwarf_Rel_Section drs, tdrs;
478 	Dwarf_Rel_Entry dre, tdre;
479 
480 	assert(dbg != NULL && dbg->dbg_mode == DW_DLC_WRITE);
481 
482 	STAILQ_FOREACH_SAFE(drs, &dbg->dbgp_drslist, drs_next, tdrs) {
483 		STAILQ_REMOVE(&dbg->dbgp_drslist, drs, _Dwarf_Rel_Section,
484 		    drs_next);
485 		free(drs->drs_drd);
486 		STAILQ_FOREACH_SAFE(dre, &drs->drs_dre, dre_next, tdre) {
487 			STAILQ_REMOVE(&drs->drs_dre, dre, _Dwarf_Rel_Entry,
488 			    dre_next);
489 			free(dre);
490 		}
491 		if (dbg->dbgp_flags & DW_DLC_SYMBOLIC_RELOCATIONS) {
492 			if (drs->drs_ds) {
493 				if (drs->drs_ds->ds_name)
494 					free(drs->drs_ds->ds_name);
495 				free(drs->drs_ds);
496 			}
497 		}
498 		free(drs);
499 	}
500 	dbg->dbgp_drscnt = 0;
501 	dbg->dbgp_drspos = NULL;
502 }
503