libdwarf_loc.c revision 260697 
1/*-
2 * Copyright (c) 2007 John Birrell (jb@freebsd.org)
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
29ELFTC_VCSID("$Id: libdwarf_loc.c 2070 2011-10-27 03:05:32Z jkoshy $");
30
31/*
32 * Given an array of bytes of length 'len' representing a
33 * DWARF expression, compute the number of operations based
34 * on there being one byte describing the operation and
35 * zero or more bytes of operands as defined in the standard
36 * for each operation type. Also, if lbuf is non-null, store
37 * the opcode and oprand in it.
38 */
39static int
40_dwarf_loc_fill_loc(Dwarf_Debug dbg, Dwarf_Locdesc *lbuf, uint8_t pointer_size,
41    uint8_t *p, int len)
42{
43	int count;
44	uint64_t operand1;
45	uint64_t operand2;
46	uint8_t *ps, *pe;
47
48	count = 0;
49	ps = p;
50	pe = p + len;
51
52	/*
53	 * Process each byte. If an error occurs, then the
54	 * count will be set to -1.
55	 */
56	while (p < pe) {
57
58		operand1 = 0;
59		operand2 = 0;
60
61		if (lbuf != NULL) {
62			lbuf->ld_s[count].lr_atom = *p;
63			lbuf->ld_s[count].lr_offset = p - ps;
64		}
65
66		switch (*p++) {
67		/* Operations with no operands. */
68		case DW_OP_deref:
69		case DW_OP_reg0:
70		case DW_OP_reg1:
71		case DW_OP_reg2:
72		case DW_OP_reg3:
73		case DW_OP_reg4:
74		case DW_OP_reg5:
75		case DW_OP_reg6:
76		case DW_OP_reg7:
77		case DW_OP_reg8:
78		case DW_OP_reg9:
79		case DW_OP_reg10:
80		case DW_OP_reg11:
81		case DW_OP_reg12:
82		case DW_OP_reg13:
83		case DW_OP_reg14:
84		case DW_OP_reg15:
85		case DW_OP_reg16:
86		case DW_OP_reg17:
87		case DW_OP_reg18:
88		case DW_OP_reg19:
89		case DW_OP_reg20:
90		case DW_OP_reg21:
91		case DW_OP_reg22:
92		case DW_OP_reg23:
93		case DW_OP_reg24:
94		case DW_OP_reg25:
95		case DW_OP_reg26:
96		case DW_OP_reg27:
97		case DW_OP_reg28:
98		case DW_OP_reg29:
99		case DW_OP_reg30:
100		case DW_OP_reg31:
101
102		case DW_OP_lit0:
103		case DW_OP_lit1:
104		case DW_OP_lit2:
105		case DW_OP_lit3:
106		case DW_OP_lit4:
107		case DW_OP_lit5:
108		case DW_OP_lit6:
109		case DW_OP_lit7:
110		case DW_OP_lit8:
111		case DW_OP_lit9:
112		case DW_OP_lit10:
113		case DW_OP_lit11:
114		case DW_OP_lit12:
115		case DW_OP_lit13:
116		case DW_OP_lit14:
117		case DW_OP_lit15:
118		case DW_OP_lit16:
119		case DW_OP_lit17:
120		case DW_OP_lit18:
121		case DW_OP_lit19:
122		case DW_OP_lit20:
123		case DW_OP_lit21:
124		case DW_OP_lit22:
125		case DW_OP_lit23:
126		case DW_OP_lit24:
127		case DW_OP_lit25:
128		case DW_OP_lit26:
129		case DW_OP_lit27:
130		case DW_OP_lit28:
131		case DW_OP_lit29:
132		case DW_OP_lit30:
133		case DW_OP_lit31:
134
135		case DW_OP_dup:
136		case DW_OP_drop:
137
138		case DW_OP_over:
139
140		case DW_OP_swap:
141		case DW_OP_rot:
142		case DW_OP_xderef:
143
144		case DW_OP_abs:
145		case DW_OP_and:
146		case DW_OP_div:
147		case DW_OP_minus:
148		case DW_OP_mod:
149		case DW_OP_mul:
150		case DW_OP_neg:
151		case DW_OP_not:
152		case DW_OP_or:
153		case DW_OP_plus:
154
155		case DW_OP_shl:
156		case DW_OP_shr:
157		case DW_OP_shra:
158		case DW_OP_xor:
159
160		case DW_OP_eq:
161		case DW_OP_ge:
162		case DW_OP_gt:
163		case DW_OP_le:
164		case DW_OP_lt:
165		case DW_OP_ne:
166
167		case DW_OP_nop:
168		case DW_OP_form_tls_address:
169		case DW_OP_call_frame_cfa:
170		case DW_OP_stack_value:
171		case DW_OP_GNU_push_tls_address:
172			break;
173
174		/* Operations with 1-byte operands. */
175		case DW_OP_const1u:
176		case DW_OP_const1s:
177		case DW_OP_pick:
178		case DW_OP_deref_size:
179		case DW_OP_xderef_size:
180			operand1 = *p++;
181			break;
182
183		/* Operations with 2-byte operands. */
184		case DW_OP_call2:
185		case DW_OP_const2u:
186		case DW_OP_const2s:
187		case DW_OP_bra:
188		case DW_OP_skip:
189			operand1 = dbg->decode(&p, 2);
190			break;
191
192		/* Operations with 4-byte operands. */
193		case DW_OP_call4:
194		case DW_OP_const4u:
195		case DW_OP_const4s:
196			operand1 = dbg->decode(&p, 4);
197			break;
198
199		/* Operations with 8-byte operands. */
200		case DW_OP_const8u:
201		case DW_OP_const8s:
202			operand1 = dbg->decode(&p, 8);
203			break;
204
205		/* Operations with an unsigned LEB128 operand. */
206		case DW_OP_constu:
207		case DW_OP_plus_uconst:
208		case DW_OP_regx:
209		case DW_OP_piece:
210			operand1 = _dwarf_decode_uleb128(&p);
211			break;
212
213		/* Operations with a signed LEB128 operand. */
214		case DW_OP_consts:
215		case DW_OP_breg0:
216		case DW_OP_breg1:
217		case DW_OP_breg2:
218		case DW_OP_breg3:
219		case DW_OP_breg4:
220		case DW_OP_breg5:
221		case DW_OP_breg6:
222		case DW_OP_breg7:
223		case DW_OP_breg8:
224		case DW_OP_breg9:
225		case DW_OP_breg10:
226		case DW_OP_breg11:
227		case DW_OP_breg12:
228		case DW_OP_breg13:
229		case DW_OP_breg14:
230		case DW_OP_breg15:
231		case DW_OP_breg16:
232		case DW_OP_breg17:
233		case DW_OP_breg18:
234		case DW_OP_breg19:
235		case DW_OP_breg20:
236		case DW_OP_breg21:
237		case DW_OP_breg22:
238		case DW_OP_breg23:
239		case DW_OP_breg24:
240		case DW_OP_breg25:
241		case DW_OP_breg26:
242		case DW_OP_breg27:
243		case DW_OP_breg28:
244		case DW_OP_breg29:
245		case DW_OP_breg30:
246		case DW_OP_breg31:
247		case DW_OP_fbreg:
248			operand1 = _dwarf_decode_sleb128(&p);
249			break;
250
251		/*
252		 * Oeration with two unsigned LEB128 operands.
253		 */
254		case DW_OP_bit_piece:
255			operand1 = _dwarf_decode_uleb128(&p);
256			operand2 = _dwarf_decode_uleb128(&p);
257			break;
258
259		/*
260		 * Operations with an unsigned LEB128 operand
261		 * followed by a signed LEB128 operand.
262		 */
263		case DW_OP_bregx:
264			operand1 = _dwarf_decode_uleb128(&p);
265			operand2 = _dwarf_decode_sleb128(&p);
266			break;
267
268		/*
269		 * Operation with an unsigned LEB128 operand
270		 * followed by a block. Store a pointer to the
271		 * block in the operand2.
272		 */
273		case DW_OP_implicit_value:
274			operand1 = _dwarf_decode_uleb128(&p);
275			operand2 = (Dwarf_Unsigned) (uintptr_t) p;
276			p += operand1;
277			break;
278
279		/* Target address size operand. */
280		case DW_OP_addr:
281			operand1 = dbg->decode(&p, pointer_size);
282			break;
283
284		/*
285		 * XXX Opcode DW_OP_call_ref has an operand with size
286		 * "dwarf_size". Here we use dbg->dbg_offset_size
287		 * as "dwarf_size" to be compatible with SGI libdwarf.
288		 * However note that dbg->dbg_offset_size is just
289		 * a "guess" value so the parsing result of
290		 * DW_OP_call_ref might not be correct at all. XXX
291		 */
292		case DW_OP_call_ref:
293			operand1 = dbg->decode(&p, dbg->dbg_offset_size);
294			break;
295
296		/* All other operations cause an error. */
297		default:
298			count = -1;
299			break;
300		}
301
302		if (lbuf != NULL) {
303			lbuf->ld_s[count].lr_number = operand1;
304			lbuf->ld_s[count].lr_number2 = operand2;
305		}
306
307		count++;
308	}
309
310	return (count);
311}
312
313int
314_dwarf_loc_expr_add_atom(Dwarf_Debug dbg, uint8_t *out, uint8_t *end,
315    Dwarf_Small atom, Dwarf_Unsigned operand1, Dwarf_Unsigned operand2,
316    int *length, Dwarf_Error *error)
317{
318	uint8_t buf[64];
319	uint8_t *p, *pe;
320	uint64_t offset;
321	int len;
322
323	if (out != NULL && end != NULL) {
324		p = out;
325		pe = end;
326	} else {
327		p = out = buf;
328		pe = &buf[sizeof(buf)];
329	}
330
331	switch (atom) {
332	/* Operations with no operands. */
333	case DW_OP_deref:
334	case DW_OP_reg0:
335	case DW_OP_reg1:
336	case DW_OP_reg2:
337	case DW_OP_reg3:
338	case DW_OP_reg4:
339	case DW_OP_reg5:
340	case DW_OP_reg6:
341	case DW_OP_reg7:
342	case DW_OP_reg8:
343	case DW_OP_reg9:
344	case DW_OP_reg10:
345	case DW_OP_reg11:
346	case DW_OP_reg12:
347	case DW_OP_reg13:
348	case DW_OP_reg14:
349	case DW_OP_reg15:
350	case DW_OP_reg16:
351	case DW_OP_reg17:
352	case DW_OP_reg18:
353	case DW_OP_reg19:
354	case DW_OP_reg20:
355	case DW_OP_reg21:
356	case DW_OP_reg22:
357	case DW_OP_reg23:
358	case DW_OP_reg24:
359	case DW_OP_reg25:
360	case DW_OP_reg26:
361	case DW_OP_reg27:
362	case DW_OP_reg28:
363	case DW_OP_reg29:
364	case DW_OP_reg30:
365	case DW_OP_reg31:
366
367	case DW_OP_lit0:
368	case DW_OP_lit1:
369	case DW_OP_lit2:
370	case DW_OP_lit3:
371	case DW_OP_lit4:
372	case DW_OP_lit5:
373	case DW_OP_lit6:
374	case DW_OP_lit7:
375	case DW_OP_lit8:
376	case DW_OP_lit9:
377	case DW_OP_lit10:
378	case DW_OP_lit11:
379	case DW_OP_lit12:
380	case DW_OP_lit13:
381	case DW_OP_lit14:
382	case DW_OP_lit15:
383	case DW_OP_lit16:
384	case DW_OP_lit17:
385	case DW_OP_lit18:
386	case DW_OP_lit19:
387	case DW_OP_lit20:
388	case DW_OP_lit21:
389	case DW_OP_lit22:
390	case DW_OP_lit23:
391	case DW_OP_lit24:
392	case DW_OP_lit25:
393	case DW_OP_lit26:
394	case DW_OP_lit27:
395	case DW_OP_lit28:
396	case DW_OP_lit29:
397	case DW_OP_lit30:
398	case DW_OP_lit31:
399
400	case DW_OP_dup:
401	case DW_OP_drop:
402
403	case DW_OP_over:
404
405	case DW_OP_swap:
406	case DW_OP_rot:
407	case DW_OP_xderef:
408
409	case DW_OP_abs:
410	case DW_OP_and:
411	case DW_OP_div:
412	case DW_OP_minus:
413	case DW_OP_mod:
414	case DW_OP_mul:
415	case DW_OP_neg:
416	case DW_OP_not:
417	case DW_OP_or:
418	case DW_OP_plus:
419
420	case DW_OP_shl:
421	case DW_OP_shr:
422	case DW_OP_shra:
423	case DW_OP_xor:
424
425	case DW_OP_eq:
426	case DW_OP_ge:
427	case DW_OP_gt:
428	case DW_OP_le:
429	case DW_OP_lt:
430	case DW_OP_ne:
431
432	case DW_OP_nop:
433	case DW_OP_GNU_push_tls_address:
434		*p++ = atom;
435		break;
436
437	/* Operations with 1-byte operands. */
438	case DW_OP_const1u:
439	case DW_OP_const1s:
440	case DW_OP_pick:
441	case DW_OP_deref_size:
442	case DW_OP_xderef_size:
443		*p++ = atom;
444		*p++ = (uint8_t) operand1;
445		break;
446
447	/* Operations with 2-byte operands. */
448	case DW_OP_const2u:
449	case DW_OP_const2s:
450	case DW_OP_bra:
451	case DW_OP_skip:
452		*p++ = atom;
453		offset = 0;
454		dbg->write(p, &offset, operand1, 2);
455		p += 2;
456		break;
457
458	/* Operations with 4-byte operands. */
459	case DW_OP_const4u:
460	case DW_OP_const4s:
461		*p++ = atom;
462		offset = 0;
463		dbg->write(p, &offset, operand1, 4);
464		p += 4;
465		break;
466
467	/* Operations with 8-byte operands. */
468	case DW_OP_const8u:
469	case DW_OP_const8s:
470		*p++ = atom;
471		offset = 0;
472		dbg->write(p, &offset, operand1, 8);
473		p += 8;
474		break;
475
476	/* Operations with an unsigned LEB128 operand. */
477	case DW_OP_constu:
478	case DW_OP_plus_uconst:
479	case DW_OP_regx:
480	case DW_OP_piece:
481		*p++ = atom;
482		len = _dwarf_write_uleb128(p, pe, operand1);
483		assert(len > 0);
484		p += len;
485		break;
486
487	/* Operations with a signed LEB128 operand. */
488	case DW_OP_consts:
489	case DW_OP_breg0:
490	case DW_OP_breg1:
491	case DW_OP_breg2:
492	case DW_OP_breg3:
493	case DW_OP_breg4:
494	case DW_OP_breg5:
495	case DW_OP_breg6:
496	case DW_OP_breg7:
497	case DW_OP_breg8:
498	case DW_OP_breg9:
499	case DW_OP_breg10:
500	case DW_OP_breg11:
501	case DW_OP_breg12:
502	case DW_OP_breg13:
503	case DW_OP_breg14:
504	case DW_OP_breg15:
505	case DW_OP_breg16:
506	case DW_OP_breg17:
507	case DW_OP_breg18:
508	case DW_OP_breg19:
509	case DW_OP_breg20:
510	case DW_OP_breg21:
511	case DW_OP_breg22:
512	case DW_OP_breg23:
513	case DW_OP_breg24:
514	case DW_OP_breg25:
515	case DW_OP_breg26:
516	case DW_OP_breg27:
517	case DW_OP_breg28:
518	case DW_OP_breg29:
519	case DW_OP_breg30:
520	case DW_OP_breg31:
521	case DW_OP_fbreg:
522		*p++ = atom;
523		len = _dwarf_write_sleb128(p, pe, operand1);
524		assert(len > 0);
525		p += len;
526		break;
527
528	/*
529	 * Operations with an unsigned LEB128 operand
530	 * followed by a signed LEB128 operand.
531	 */
532	case DW_OP_bregx:
533		*p++ = atom;
534		len = _dwarf_write_uleb128(p, pe, operand1);
535		assert(len > 0);
536		p += len;
537		len = _dwarf_write_sleb128(p, pe, operand2);
538		assert(len > 0);
539		p += len;
540		break;
541
542	/* Target address size operand. */
543	case DW_OP_addr:
544		*p++ = atom;
545		offset = 0;
546		dbg->write(p, &offset, operand1, dbg->dbg_pointer_size);
547		p += dbg->dbg_pointer_size;
548		break;
549
550	/* All other operations cause an error. */
551	default:
552		DWARF_SET_ERROR(dbg, error, DW_DLE_LOC_EXPR_BAD);
553		return (DW_DLE_LOC_EXPR_BAD);
554	}
555
556	if (length)
557		*length = p - out;
558
559	return (DW_DLE_NONE);
560}
561
562int
563_dwarf_loc_fill_locdesc(Dwarf_Debug dbg, Dwarf_Locdesc *llbuf, uint8_t *in,
564    uint64_t in_len, uint8_t pointer_size, Dwarf_Error *error)
565{
566	int num;
567
568	assert(llbuf != NULL);
569	assert(in != NULL);
570	assert(in_len > 0);
571
572	/* Compute the number of locations. */
573	if ((num = _dwarf_loc_fill_loc(dbg, NULL, pointer_size, in, in_len)) <
574	    0) {
575		DWARF_SET_ERROR(dbg, error, DW_DLE_LOC_EXPR_BAD);
576		return (DW_DLE_LOC_EXPR_BAD);
577	}
578
579	llbuf->ld_cents = num;
580	if (num <= 0)
581		return (DW_DLE_NONE);
582
583	if ((llbuf->ld_s = calloc(num, sizeof(Dwarf_Loc))) == NULL) {
584		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
585		return (DW_DLE_MEMORY);
586	}
587
588	(void) _dwarf_loc_fill_loc(dbg, llbuf, pointer_size, in, in_len);
589
590	return (DW_DLE_NONE);
591}
592
593int
594_dwarf_loc_fill_locexpr(Dwarf_Debug dbg, Dwarf_Locdesc **ret_llbuf, uint8_t *in,
595    uint64_t in_len, uint8_t pointer_size, Dwarf_Error *error)
596{
597	Dwarf_Locdesc *llbuf;
598	int ret;
599
600	if ((llbuf = malloc(sizeof(Dwarf_Locdesc))) == NULL) {
601		DWARF_SET_ERROR(dbg, error, DW_DLE_MEMORY);
602		return (DW_DLE_MEMORY);
603	}
604	llbuf->ld_lopc = 0;
605	llbuf->ld_hipc = ~0ULL;
606	llbuf->ld_s = NULL;
607
608	ret = _dwarf_loc_fill_locdesc(dbg, llbuf, in, in_len, pointer_size,
609	    error);
610	if (ret != DW_DLE_NONE) {
611		free(llbuf);
612		return (ret);
613	}
614
615	*ret_llbuf = llbuf;
616
617	return (ret);
618}
619
620int
621_dwarf_loc_add(Dwarf_Die die, Dwarf_Attribute at, Dwarf_Error *error)
622{
623	Dwarf_Debug dbg;
624	Dwarf_CU cu;
625	int ret;
626
627	assert(at->at_ld == NULL);
628	assert(at->u[1].u8p != NULL);
629	assert(at->u[0].u64 > 0);
630
631	cu = die->die_cu;
632	assert(cu != NULL);
633
634	dbg = cu->cu_dbg;
635	assert(dbg != NULL);
636
637	ret = _dwarf_loc_fill_locexpr(dbg, &at->at_ld, at->u[1].u8p,
638	    at->u[0].u64, cu->cu_pointer_size, error);
639
640	return (ret);
641}
642