1 /*
2 
3   Copyright (C) 2000,2002,2004,2005 Silicon Graphics, Inc. All Rights Reserved.
4   Portions Copyright 2007-2010 Sun Microsystems, Inc. All rights reserved.
5   Portions Copyright 2008-2010 David Anderson. All rights reserved.
6 
7   This program is free software; you can redistribute it and/or modify it
8   under the terms of version 2.1 of the GNU Lesser General Public License
9   as published by the Free Software Foundation.
10 
11   This program is distributed in the hope that it would be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 
15   Further, this software is distributed without any warranty that it is
16   free of the rightful claim of any third person regarding infringement
17   or the like.  Any license provided herein, whether implied or
18   otherwise, applies only to this software file.  Patent licenses, if
19   any, provided herein do not apply to combinations of this program with
20   other software, or any other product whatsoever.
21 
22   You should have received a copy of the GNU Lesser General Public
23   License along with this program; if not, write the Free Software
24   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
25   USA.
26 
27   Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,
28   Mountain View, CA 94043, or:
29 
30   http://www.sgi.com
31 
32   For further information regarding this notice, see:
33 
34   http://oss.sgi.com/projects/GenInfo/NoticeExplan
35 
36 */
37 
38 
39 
40 #include "config.h"
41 #include "dwarf_incl.h"
42 #include "dwarf_die_deliv.h"
43 
44 int
45 dwarf_hasform(Dwarf_Attribute attr,
46               Dwarf_Half form,
47               Dwarf_Bool * return_bool, Dwarf_Error * error)
48 {
49     Dwarf_CU_Context cu_context = 0;
50 
51     if (attr == NULL) {
52         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
53         return (DW_DLV_ERROR);
54     }
55 
56     cu_context = attr->ar_cu_context;
57     if (cu_context == NULL) {
58         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
59         return (DW_DLV_ERROR);
60     }
61 
62     if (cu_context->cc_dbg == NULL) {
63         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
64         return (DW_DLV_ERROR);
65     }
66 
67     *return_bool = (attr->ar_attribute_form == form);
68     return DW_DLV_OK;
69 }
70 
71 /* Not often called, we do not worry about efficiency here.
72    The dwarf_whatform() call does the sanity checks for us.
73 */
74 int
75 dwarf_whatform_direct(Dwarf_Attribute attr,
76                       Dwarf_Half * return_form, Dwarf_Error * error)
77 {
78     int res = dwarf_whatform(attr, return_form, error);
79 
80     if (res != DW_DLV_OK) {
81         return res;
82     }
83 
84     *return_form = attr->ar_attribute_form_direct;
85     return (DW_DLV_OK);
86 }
87 void *
88 dwarf_uncompress_integer_block(
89     Dwarf_Debug      dbg,
90     Dwarf_Bool       unit_is_signed,
91     Dwarf_Small      unit_length_in_bits,
92     void*            input_block,
93     Dwarf_Unsigned   input_length_in_bytes,
94     Dwarf_Unsigned*  output_length_in_units_ptr,
95     Dwarf_Error*     error
96 )
97 {
98     Dwarf_Unsigned output_length_in_units = 0;
99     void * output_block = 0;
100     int i = 0;
101     char * ptr = 0;
102     int remain = 0;
103     Dwarf_sfixed * array = 0;
104 
105     if (dbg == NULL) {
106         _dwarf_error(NULL, error, DW_DLE_DBG_NULL);
107         return((void *)DW_DLV_BADADDR);
108     }
109 
110     if (unit_is_signed == false ||
111         unit_length_in_bits != 32 ||
112         input_block == NULL ||
113         input_length_in_bytes == 0 ||
114         output_length_in_units_ptr == NULL) {
115 
116         _dwarf_error(NULL, error, DW_DLE_BADBITC);
117         return ((void *) DW_DLV_BADADDR);
118     }
119 
120     /* At this point we assume the format is: signed 32 bit */
121 
122     /* first uncompress everything to find the total size. */
123 
124     output_length_in_units = 0;
125     remain = input_length_in_bytes;
126     ptr = input_block;
127     while (remain > 0) {
128         Dwarf_Signed num;
129         Dwarf_Word len;
130         num = _dwarf_decode_s_leb128((unsigned char *)ptr, &len);
131         ptr += len;
132         remain -= len;
133         output_length_in_units++;
134     }
135 
136     if (remain != 0) {
137         _dwarf_error(NULL, error, DW_DLE_ALLOC_FAIL);
138         return((void *)DW_DLV_BADADDR);
139     }
140 
141     /* then alloc */
142 
143     output_block = (void *)
144         _dwarf_get_alloc(dbg,
145                          DW_DLA_STRING,
146                          output_length_in_units * (unit_length_in_bits / 8));
147     if (output_block == NULL) {
148         _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
149         return((void*)DW_DLV_BADADDR);
150     }
151 
152     /* then uncompress again and copy into new buffer */
153 
154     array = (Dwarf_sfixed *) output_block;
155     remain = input_length_in_bytes;
156     ptr = input_block;
157     for (i=0; i<output_length_in_units && remain>0; i++) {
158         Dwarf_Signed num;
159         Dwarf_Word len;
160         num = _dwarf_decode_s_leb128((unsigned char *)ptr, &len);
161         ptr += len;
162         remain -= len;
163         array[i] = num;
164     }
165 
166     if (remain != 0) {
167         dwarf_dealloc(dbg, (unsigned char *)output_block, DW_DLA_STRING);
168         _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
169         return((Dwarf_P_Attribute)DW_DLV_BADADDR);
170     }
171 
172     *output_length_in_units_ptr = output_length_in_units;
173     return output_block;
174 }
175 
176 void
177 dwarf_dealloc_uncompressed_block(Dwarf_Debug dbg, void * space)
178 {
179     dwarf_dealloc(dbg, space, DW_DLA_STRING);
180 }
181 
182 
183 int
184 dwarf_whatform(Dwarf_Attribute attr,
185                Dwarf_Half * return_form, Dwarf_Error * error)
186 {
187     Dwarf_CU_Context cu_context = 0;
188 
189     if (attr == NULL) {
190         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
191         return (DW_DLV_ERROR);
192     }
193 
194     cu_context = attr->ar_cu_context;
195     if (cu_context == NULL) {
196         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
197         return (DW_DLV_ERROR);
198     }
199 
200     if (cu_context->cc_dbg == NULL) {
201         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
202         return (DW_DLV_ERROR);
203     }
204 
205     *return_form = attr->ar_attribute_form;
206     return (DW_DLV_OK);
207 }
208 
209 
210 /*
211     This function is analogous to dwarf_whatform.
212     It returns the attribute in attr instead of
213     the form.
214 */
215 int
216 dwarf_whatattr(Dwarf_Attribute attr,
217                Dwarf_Half * return_attr, Dwarf_Error * error)
218 {
219     Dwarf_CU_Context cu_context = 0;
220 
221     if (attr == NULL) {
222         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
223         return (DW_DLV_ERROR);
224     }
225 
226     cu_context = attr->ar_cu_context;
227     if (cu_context == NULL) {
228         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
229         return (DW_DLV_ERROR);
230     }
231 
232     if (cu_context->cc_dbg == NULL) {
233         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
234         return (DW_DLV_ERROR);
235     }
236 
237     *return_attr = (attr->ar_attribute);
238     return DW_DLV_OK;
239 }
240 
241 
242 /*
243     A global offset cannot be returned by this interface:
244     see dwarf_global_formref().
245 
246     DW_FORM_ref_addr is considered an incorrect form
247     for this call because DW_FORM_ref_addr is a global-offset into
248     the debug_info section.
249 
250     For the same reason DW_FORM_data4/data8 are not returned
251     from this function.
252 
253     For the same reason DW_FORM_sec_offset is not returned
254     from this function, DW_FORM_sec_offset is a global offset
255     (to various sections, not a CU relative offset.
256 
257     DW_FORM_ref_addr has a value which was documented in
258     DWARF2 as address-size but which was always an offset
259     so should have always been offset size (wording
260     corrected in DWARF3).
261 
262 
263 */
264 int
265 dwarf_formref(Dwarf_Attribute attr,
266               Dwarf_Off * ret_offset, Dwarf_Error * error)
267 {
268     Dwarf_Debug dbg = 0;
269     Dwarf_Unsigned offset = 0;
270     Dwarf_CU_Context cu_context = 0;
271 
272 
273     if (attr == NULL) {
274         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
275         return (DW_DLV_ERROR);
276     }
277 
278     cu_context = attr->ar_cu_context;
279     if (cu_context == NULL) {
280         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
281         return (DW_DLV_ERROR);
282     }
283 
284     if (cu_context->cc_dbg == NULL) {
285         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
286         return (DW_DLV_ERROR);
287     }
288     dbg = cu_context->cc_dbg;
289 
290     switch (attr->ar_attribute_form) {
291 
292     case DW_FORM_ref1:
293         offset = *(Dwarf_Small *) attr->ar_debug_info_ptr;
294         break;
295 
296     case DW_FORM_ref2:
297         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
298                        attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
299         break;
300 
301     case DW_FORM_ref4:
302         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
303                        attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
304         break;
305 
306     case DW_FORM_ref8:
307         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
308                        attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
309         break;
310 
311     case DW_FORM_ref_udata:
312         offset = _dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL);
313         break;
314 
315     default:
316         _dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
317         return (DW_DLV_ERROR);
318     }
319 
320     /* Check that offset is within current cu portion of .debug_info. */
321     if (offset >= cu_context->cc_length +
322         cu_context->cc_length_size + cu_context->cc_extension_size) {
323         _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
324         return (DW_DLV_ERROR);
325     }
326 
327     *ret_offset = (offset);
328     return DW_DLV_OK;
329 }
330 
331 /*  dwarf_formsig8 returns in the caller-provided 8 byte area
332     the 8 bytes of a DW_FORM_ref_sig8 (copying the bytes
333     directly to the caller).  Not a string, an 8 byte
334     MD5 hash.  This function is new in DWARF4 libdwarf.
335 */
336 int dwarf_formsig8(Dwarf_Attribute attr,
337     Dwarf_Sig8 * returned_sig_bytes,
338     Dwarf_Error*     error)
339 {
340     Dwarf_Debug dbg = 0;
341     Dwarf_Unsigned field_end_offset = 0;
342     Dwarf_CU_Context cu_context = 0;
343 
344 
345     if (attr == NULL) {
346         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
347         return (DW_DLV_ERROR);
348     }
349 
350     cu_context = attr->ar_cu_context;
351     if (cu_context == NULL) {
352         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
353         return (DW_DLV_ERROR);
354     }
355 
356     if (cu_context->cc_dbg == NULL) {
357         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
358         return (DW_DLV_ERROR);
359     }
360     dbg = cu_context->cc_dbg;
361 
362     if(attr->ar_attribute_form != DW_FORM_ref_sig8 ) {
363         _dwarf_error(dbg, error, DW_DLE_BAD_REF_SIG8_FORM);
364         return (DW_DLV_ERROR);
365     }
366 
367     field_end_offset = attr->ar_debug_info_ptr + sizeof(Dwarf_Sig8) -
368         (dbg->de_debug_info.dss_data + cu_context->cc_debug_info_offset);
369     /* Check that offset is within current cu portion of .debug_info. */
370     if (field_end_offset > cu_context->cc_length +
371         cu_context->cc_length_size + cu_context->cc_extension_size) {
372         _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
373         return (DW_DLV_ERROR);
374     }
375 
376     memcpy(returned_sig_bytes, attr->ar_debug_info_ptr,
377         sizeof(Dwarf_Sig8));
378     return DW_DLV_OK;
379 }
380 
381 
382 /*
383     Since this returns section-relative debug_info offsets,
384     this can represent all REFERENCE forms correctly
385     and allows all applicable forms.
386 
387     DW_FORM_ref_addr has a value which was documented in
388     DWARF2 as address-size but which was always an offset
389     so should have always been offset size (wording
390     corrected in DWARF3).
391 
392     See the DWARF4 document for the 3 cases fitting
393     reference forms.  The caller must determine which section the
394     reference 'points' to.  The function added in November 2009,
395     dwarf_get_form_class(), helps in this regard.
396 
397 */
398 int
399 dwarf_global_formref(Dwarf_Attribute attr,
400                      Dwarf_Off * ret_offset, Dwarf_Error * error)
401 {
402     Dwarf_Debug dbg = 0;
403     Dwarf_Unsigned offset = 0;
404     Dwarf_Addr ref_addr = 0;
405     Dwarf_CU_Context cu_context = 0;
406     Dwarf_Half context_version = 0;
407 
408     if (attr == NULL) {
409         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
410         return (DW_DLV_ERROR);
411     }
412 
413     cu_context = attr->ar_cu_context;
414     if (cu_context == NULL) {
415         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
416         return (DW_DLV_ERROR);
417     }
418     context_version = cu_context->cc_version_stamp;
419 
420     if (cu_context->cc_dbg == NULL) {
421         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
422         return (DW_DLV_ERROR);
423     }
424     dbg = cu_context->cc_dbg;
425 
426     switch (attr->ar_attribute_form) {
427 
428     case DW_FORM_ref1:
429         offset = *(Dwarf_Small *) attr->ar_debug_info_ptr;
430         goto fixoffset;
431 
432     case DW_FORM_ref2:
433         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
434                        attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
435         goto fixoffset;
436 
437     case DW_FORM_ref4:
438         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
439                        attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
440         goto fixoffset;
441 
442     case DW_FORM_ref8:
443         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
444                        attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
445         goto fixoffset;
446 
447     case DW_FORM_ref_udata:
448         offset = _dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL);
449 
450       fixoffset:                /* we have a local offset, make it
451                                    global */
452 
453         /* check legality of offset */
454         if (offset >= cu_context->cc_length +
455             cu_context->cc_length_size +
456             cu_context->cc_extension_size) {
457             _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
458             return (DW_DLV_ERROR);
459         }
460 
461         /* globalize the offset */
462         offset += cu_context->cc_debug_info_offset;
463         break;
464     /* The DWARF2 document did not make clear that
465        DW_FORM_data4( and 8) were references with
466        global offsets to some section.
467        That was first clearly documented in DWARF3.
468        In DWARF4 these two forms are no longer references. */
469     case DW_FORM_data4:
470         if(context_version == DW_CU_VERSION4) {
471             _dwarf_error(dbg, error, DW_DLE_NOT_REF_FORM);
472             return (DW_DLV_ERROR);
473         }
474         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
475                        attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
476         /* The offset is global. */
477         break;
478     case DW_FORM_data8:
479         if(context_version == DW_CU_VERSION4) {
480             _dwarf_error(dbg, error, DW_DLE_NOT_REF_FORM);
481             return (DW_DLV_ERROR);
482         }
483         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
484                        attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
485         /* The offset is global. */
486         break;
487     case DW_FORM_ref_addr:
488     case DW_FORM_sec_offset:
489         {
490             /* DW_FORM_sec_offset first exists in DWARF4.*/
491             /* It is up to the caller to know what the offset
492                of DW_FORM_sec_offset refers to,
493                the offset is not going to refer to .debug_info! */
494             unsigned length_size = cu_context->cc_length_size;
495             if(length_size == 4) {
496                 READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
497                        attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
498             } else if (length_size == 8) {
499                 READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
500                        attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
501             } else {
502                 _dwarf_error(dbg, error, DW_DLE_FORM_SEC_OFFSET_LENGTH_BAD);
503                 return (DW_DLV_ERROR);
504             }
505         }
506         break;
507 
508     default:
509         _dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
510         return (DW_DLV_ERROR);
511     }
512 
513     /* We do not know what section the offset refers to, so
514        we have no way to check it for correctness. */
515     *ret_offset = offset;
516     return DW_DLV_OK;
517 }
518 
519 
520 int
521 dwarf_formaddr(Dwarf_Attribute attr,
522                Dwarf_Addr * return_addr, Dwarf_Error * error)
523 {
524     Dwarf_Debug dbg = 0;
525     Dwarf_Addr ret_addr = 0;
526     Dwarf_CU_Context cu_context = 0;
527 
528     if (attr == NULL) {
529         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
530         return (DW_DLV_ERROR);
531     }
532 
533     cu_context = attr->ar_cu_context;
534     if (cu_context == NULL) {
535         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
536         return (DW_DLV_ERROR);
537     }
538 
539     if (cu_context->cc_dbg == NULL) {
540         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
541         return (DW_DLV_ERROR);
542     }
543     dbg = cu_context->cc_dbg;
544 
545     if (attr->ar_attribute_form == DW_FORM_addr
546         /* || attr->ar_attribute_form == DW_FORM_ref_addr Allowance of
547            DW_FORM_ref_addr was a mistake. The value returned in that
548            case is NOT an address it is a global debug_info offset (ie,
549            not CU-relative offset within the CU in debug_info). The
550            Dwarf document refers to it as an address (misleadingly) in
551            sec 6.5.4 where it describes the reference form. It is
552            address-sized so that the linker can easily update it, but
553            it is a reference inside the debug_info section. No longer
554            allowed. */
555         ) {
556 
557         READ_UNALIGNED(dbg, ret_addr, Dwarf_Addr,
558                        attr->ar_debug_info_ptr,
559                        cu_context->cc_address_size);
560         *return_addr = ret_addr;
561         return (DW_DLV_OK);
562     }
563 
564     _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
565     return (DW_DLV_ERROR);
566 }
567 
568 
569 int
570 dwarf_formflag(Dwarf_Attribute attr,
571                Dwarf_Bool * ret_bool, Dwarf_Error * error)
572 {
573     Dwarf_CU_Context cu_context = 0;
574 
575     if (attr == NULL) {
576         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
577         return (DW_DLV_ERROR);
578     }
579 
580     cu_context = attr->ar_cu_context;
581     if (cu_context == NULL) {
582         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
583         return (DW_DLV_ERROR);
584     }
585 
586     if (cu_context->cc_dbg == NULL) {
587         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
588         return (DW_DLV_ERROR);
589     }
590     if (attr->ar_attribute_form == DW_FORM_flag_present) {
591         /* Implicit means we don't read any data at all. Just
592            the existence of the Form does it. DWARF4. */
593         *ret_bool = 1;
594         return (DW_DLV_OK);
595     }
596 
597     if (attr->ar_attribute_form == DW_FORM_flag) {
598         *ret_bool = (*(Dwarf_Small *) attr->ar_debug_info_ptr != 0);
599         return (DW_DLV_OK);
600     }
601     _dwarf_error(cu_context->cc_dbg, error, DW_DLE_ATTR_FORM_BAD);
602     return (DW_DLV_ERROR);
603 }
604 
605 
606 int
607 dwarf_formudata(Dwarf_Attribute attr,
608                 Dwarf_Unsigned * return_uval, Dwarf_Error * error)
609 {
610     Dwarf_Unsigned ret_value = 0;
611     Dwarf_Debug dbg = 0;
612     Dwarf_CU_Context cu_context = 0;
613 
614     if (attr == NULL) {
615         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
616         return (DW_DLV_ERROR);
617     }
618 
619 
620     cu_context = attr->ar_cu_context;
621     if (cu_context == NULL) {
622         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
623         return (DW_DLV_ERROR);
624     }
625 
626     dbg = cu_context->cc_dbg;
627     if (dbg == NULL) {
628         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
629         return (DW_DLV_ERROR);
630     }
631 
632     switch (attr->ar_attribute_form) {
633 
634     case DW_FORM_data1:
635         READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
636                        attr->ar_debug_info_ptr, sizeof(Dwarf_Small));
637         *return_uval = ret_value;
638         return DW_DLV_OK;
639 
640     /* READ_UNALIGNED does the right thing as it reads
641        the right number bits and generates host order.
642        So we can just assign to *return_uval. */
643     case DW_FORM_data2:{
644             READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
645                            attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
646             *return_uval = ret_value;
647             return DW_DLV_OK;
648         }
649 
650     case DW_FORM_data4:{
651             READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
652                            attr->ar_debug_info_ptr,
653                            sizeof(Dwarf_ufixed));
654             *return_uval = ret_value;
655             return DW_DLV_OK;
656         }
657 
658     case DW_FORM_data8:{
659             READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
660                            attr->ar_debug_info_ptr,
661                            sizeof(Dwarf_Unsigned));
662             *return_uval = ret_value;
663             return DW_DLV_OK;
664         }
665         break;
666     case DW_FORM_udata:
667         ret_value =
668             (_dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL));
669         *return_uval = ret_value;
670         return DW_DLV_OK;
671 
672 
673         /* see bug 583450. We do not allow reading sdata from a udata
674            value. Caller can retry, calling sdata */
675 
676 
677     default:
678         break;
679     }
680     _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
681     return (DW_DLV_ERROR);
682 }
683 
684 
685 int
686 dwarf_formsdata(Dwarf_Attribute attr,
687                 Dwarf_Signed * return_sval, Dwarf_Error * error)
688 {
689     Dwarf_Signed ret_value = 0;
690     Dwarf_Debug dbg = 0;
691     Dwarf_CU_Context cu_context = 0;
692 
693     if (attr == NULL) {
694         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
695         return (DW_DLV_ERROR);
696     }
697 
698     cu_context = attr->ar_cu_context;
699     if (cu_context == NULL) {
700         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
701         return (DW_DLV_ERROR);
702     }
703 
704     dbg = cu_context->cc_dbg;
705     if (dbg == NULL) {
706         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
707         return (DW_DLV_ERROR);
708     }
709 
710     switch (attr->ar_attribute_form) {
711 
712     case DW_FORM_data1:
713         *return_sval = (*(Dwarf_Sbyte *) attr->ar_debug_info_ptr);
714         return DW_DLV_OK;
715 
716     /* READ_UNALIGNED does not sign extend.
717        So we have to use a cast to get the
718        value sign extended in the right way for each case. */
719     case DW_FORM_data2:{
720             READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
721                            attr->ar_debug_info_ptr,
722                            sizeof(Dwarf_Shalf));
723             *return_sval = (Dwarf_Shalf) ret_value;
724             return DW_DLV_OK;
725 
726         }
727 
728     case DW_FORM_data4:{
729             READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
730                            attr->ar_debug_info_ptr,
731                            sizeof(Dwarf_sfixed));
732             *return_sval = (Dwarf_sfixed) ret_value;
733             return DW_DLV_OK;
734         }
735 
736     case DW_FORM_data8:{
737             READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
738                            attr->ar_debug_info_ptr,
739                            sizeof(Dwarf_Signed));
740             *return_sval = (Dwarf_Signed) ret_value;
741             return DW_DLV_OK;
742         }
743 
744     case DW_FORM_sdata:
745         ret_value =
746             (_dwarf_decode_s_leb128(attr->ar_debug_info_ptr, NULL));
747         *return_sval = ret_value;
748         return DW_DLV_OK;
749 
750 
751         /* see bug 583450. We do not allow reading sdata from a udata
752            value. Caller can retry, calling sdata */
753 
754 
755     default:
756         break;
757     }
758     _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
759     return (DW_DLV_ERROR);
760 }
761 
762 
763 int
764 dwarf_formblock(Dwarf_Attribute attr,
765                 Dwarf_Block ** return_block, Dwarf_Error * error)
766 {
767     Dwarf_CU_Context cu_context = 0;
768     Dwarf_Debug dbg = 0;
769     Dwarf_Unsigned length = 0;
770     Dwarf_Small *data = 0;
771     Dwarf_Word leb128_length = 0;
772     Dwarf_Block *ret_block = 0;
773 
774     if (attr == NULL) {
775         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
776         return (DW_DLV_ERROR);
777     }
778 
779     cu_context = attr->ar_cu_context;
780     if (cu_context == NULL) {
781         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
782         return (DW_DLV_ERROR);
783     }
784 
785     if (cu_context->cc_dbg == NULL) {
786         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
787         return (DW_DLV_ERROR);
788     }
789     dbg = cu_context->cc_dbg;
790 
791     switch (attr->ar_attribute_form) {
792 
793     case DW_FORM_block1:
794         length = *(Dwarf_Small *) attr->ar_debug_info_ptr;
795         data = attr->ar_debug_info_ptr + sizeof(Dwarf_Small);
796         break;
797 
798     case DW_FORM_block2:
799         READ_UNALIGNED(dbg, length, Dwarf_Unsigned,
800                        attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
801         data = attr->ar_debug_info_ptr + sizeof(Dwarf_Half);
802         break;
803 
804     case DW_FORM_block4:
805         READ_UNALIGNED(dbg, length, Dwarf_Unsigned,
806                        attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
807         data = attr->ar_debug_info_ptr + sizeof(Dwarf_ufixed);
808         break;
809 
810     case DW_FORM_block:
811         length = _dwarf_decode_u_leb128(attr->ar_debug_info_ptr,
812                                         &leb128_length);
813         data = attr->ar_debug_info_ptr + leb128_length;
814         break;
815 
816     default:
817         _dwarf_error(cu_context->cc_dbg, error, DW_DLE_ATTR_FORM_BAD);
818         return (DW_DLV_ERROR);
819     }
820 
821     /* Check that block lies within current cu in .debug_info. */
822     if (attr->ar_debug_info_ptr + length >=
823         dbg->de_debug_info.dss_data + cu_context->cc_debug_info_offset +
824         cu_context->cc_length + cu_context->cc_length_size +
825         cu_context->cc_extension_size) {
826         _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_SIZE_BAD);
827         return (DW_DLV_ERROR);
828     }
829 
830     ret_block = (Dwarf_Block *) _dwarf_get_alloc(dbg, DW_DLA_BLOCK, 1);
831     if (ret_block == NULL) {
832         _dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
833         return (DW_DLV_ERROR);
834     }
835 
836     ret_block->bl_len = length;
837     ret_block->bl_data = (Dwarf_Ptr) data;
838     ret_block->bl_from_loclist = 0;
839     ret_block->bl_section_offset = data - dbg->de_debug_info.dss_data;
840 
841 
842     *return_block = ret_block;
843     return (DW_DLV_OK);
844 }
845 
846 
847 /* Contrary to long standing documentation,
848    The string pointer returned thru return_str must
849    never have dwarf_dealloc() applied to it.
850    Documentation fixed July 2005.
851 */
852 int
853 dwarf_formstring(Dwarf_Attribute attr,
854                  char **return_str, Dwarf_Error * error)
855 {
856     Dwarf_CU_Context cu_context = 0;
857     Dwarf_Debug dbg = 0;
858     Dwarf_Unsigned offset = 0;
859     int res = DW_DLV_ERROR;
860 
861     if (attr == NULL) {
862         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
863         return (DW_DLV_ERROR);
864     }
865 
866     cu_context = attr->ar_cu_context;
867     if (cu_context == NULL) {
868         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
869         return (DW_DLV_ERROR);
870     }
871 
872     if (cu_context->cc_dbg == NULL) {
873         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
874         return (DW_DLV_ERROR);
875     }
876     dbg = cu_context->cc_dbg;
877 
878     if (attr->ar_attribute_form == DW_FORM_string) {
879 
880         void *begin = attr->ar_debug_info_ptr;
881 
882         if (0 == dbg->de_assume_string_in_bounds) {
883             /* Check that string lies within current cu in .debug_info.
884              */
885             void *end = dbg->de_debug_info.dss_data +
886                 cu_context->cc_debug_info_offset +
887                 cu_context->cc_length + cu_context->cc_length_size +
888                 cu_context->cc_extension_size;
889             if (0 == _dwarf_string_valid(begin, end)) {
890                 _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_SIZE_BAD);
891                 return (DW_DLV_ERROR);
892             }
893         }
894         *return_str = (char *) (begin);
895         return DW_DLV_OK;
896     }
897 
898     if (attr->ar_attribute_form == DW_FORM_strp) {
899         READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
900                        attr->ar_debug_info_ptr,
901                        cu_context->cc_length_size);
902 
903         res = _dwarf_load_section(dbg, &dbg->de_debug_str,error);
904         if (res != DW_DLV_OK) {
905             return res;
906         }
907         if (0 == dbg->de_assume_string_in_bounds) {
908             /* Check that string lies within current cu in .debug_info.
909              */
910             void *end = dbg->de_debug_str.dss_data +
911                 dbg->de_debug_str.dss_size;
912             void*begin = dbg->de_debug_str.dss_data + offset;
913             if (0 == _dwarf_string_valid(begin, end)) {
914                 _dwarf_error(dbg, error, DW_DLE_STRP_OFFSET_BAD);
915                 return (DW_DLV_ERROR);
916             }
917         }
918         *return_str = (char *) (dbg->de_debug_str.dss_data + offset);
919         return DW_DLV_OK;
920     }
921 
922     _dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
923     return (DW_DLV_ERROR);
924 }
925 
926 int
927 dwarf_formexprloc(Dwarf_Attribute attr,
928     Dwarf_Unsigned * return_exprlen,
929     Dwarf_Ptr  * block_ptr,
930     Dwarf_Error * error)
931 {
932     Dwarf_Debug dbg = 0;
933     Dwarf_CU_Context cu_context = 0;
934 
935     if (attr == NULL) {
936         _dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
937         return (DW_DLV_ERROR);
938     }
939 
940     cu_context = attr->ar_cu_context;
941     if (cu_context == NULL) {
942         _dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
943         return (DW_DLV_ERROR);
944     }
945 
946     dbg = cu_context->cc_dbg;
947     if (dbg == NULL) {
948         _dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
949         return (DW_DLV_ERROR);
950     }
951 
952     if (attr->ar_attribute_form == DW_FORM_exprloc ) {
953         Dwarf_Unsigned exprlen =
954             (_dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL));
955         Dwarf_Small * addr = attr->ar_debug_info_ptr;
956         *return_exprlen = exprlen;
957         *block_ptr = addr + exprlen;
958         return DW_DLV_OK;
959 
960     }
961     _dwarf_error(dbg, error, DW_DLE_ATTR_EXPRLOC_FORM_BAD);
962     return (DW_DLV_ERROR);
963 }
964