1 /*

     2 

     3   Copyright (C) 2000,2003,2004 Silicon Graphics, Inc.  All Rights Reserved.

     4   Portions Copyright (C) 2007 David Anderson. All Rights Reserved.

     5 

     6   This program is free software; you can redistribute it and/or modify it

     7   under the terms of version 2.1 of the GNU Lesser General Public License 

     8   as published by the Free Software Foundation.

     9 

    10   This program is distributed in the hope that it would be useful, but

    11   WITHOUT ANY WARRANTY; without even the implied warranty of

    12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

    13 

    14   Further, this software is distributed without any warranty that it is

    15   free of the rightful claim of any third person regarding infringement 

    16   or the like.  Any license provided herein, whether implied or 

    17   otherwise, applies only to this software file.  Patent licenses, if

    18   any, provided herein do not apply to combinations of this program with 

    19   other software, or any other product whatsoever.  

    20 

    21   You should have received a copy of the GNU Lesser General Public

    22   License along with this program; if not, write the Free Software

    23   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,

    24   USA.

    25 

    26   Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,

    27   Mountain View, CA 94043, or:

    28 

    29   http://www.sgi.com

    30 

    31   For further information regarding this notice, see:

    32 

    33   http://oss.sgi.com/projects/GenInfo/NoticeExplan

    34 

    35 */

    36 /* The address of the Free Software Foundation is

    37    Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, 

    38    Boston, MA 02110-1301, USA.

    39    SGI has moved from the Crittenden Lane address.

    40 */

    41 

    42 

    43 

    44 

    45 /*

    46     Decodes unsigned leb128 encoded numbers.

    47     Make sure ptr is a pointer to a 1-byte type.  

    48     In 2003 and earlier this was a hand-inlined

    49     version of _dwarf_decode_u_leb128() which did

    50     not work correctly if Dwarf_Word was 64 bits.

    51 */

    52 #define DECODE_LEB128_UWORD(ptr, value) \

    53     do { \

    54        Dwarf_Word uleblen; \

    55 	value = _dwarf_decode_u_leb128(ptr,&uleblen); \

    56         ptr += uleblen; \

    57     } while (0)

    58 

    59 /*

    60     Decodes signed leb128 encoded numbers.

    61     Make sure ptr is a pointer to a 1-byte type.

    62     In 2003 and earlier this was a hand-inlined

    63     version of _dwarf_decode_s_leb128() which did

    64     not work correctly if Dwarf_Word was 64 bits.

    65 

    66 */

    67 #define DECODE_LEB128_SWORD(ptr, value) \

    68     do { \

    69        Dwarf_Word sleblen; \

    70 	value = _dwarf_decode_s_leb128(ptr,&sleblen); \

    71         ptr += sleblen; \

    72     } while(0)

    73 

    74 

    75 /*

    76     Skips leb128_encoded numbers that are guaranteed 

    77     to be no more than 4 bytes long.  Same for both

    78     signed and unsigned numbers.

    79 */

    80 #define SKIP_LEB128_WORD(ptr) \

    81     do{ if ((*(ptr++) & 0x80) != 0) { \

    82         if ((*(ptr++) & 0x80) != 0) { \

    83             if ((*(ptr++) & 0x80) != 0) { \

    84 	        if ((*(ptr++) & 0x80) != 0) { \

    85 	        } \

    86 	    } \

    87         } \

    88     } } while (0)

    89 

    90 

    91 #define CHECK_DIE(die, error_ret_value) \

    92 do {if (die == NULL) { \

    93 	_dwarf_error(NULL, error, DW_DLE_DIE_NULL); \

    94 	return(error_ret_value); \

    95     } \

    96     if (die->di_cu_context == NULL) { \

    97 	_dwarf_error(NULL, error, DW_DLE_DIE_NO_CU_CONTEXT); \

    98 	return(error_ret_value); \

    99     } \

   100     if (die->di_cu_context->cc_dbg == NULL) { \

   101 	_dwarf_error(NULL, error, DW_DLE_DBG_NULL); \

   102 	return(error_ret_value); \

   103     }  \

   104 } while (0)

   105 

   106 

   107 /* 

   108    Reads 'source' for 'length' bytes from unaligned addr.

   109 

   110    Avoids any constant-in-conditional warnings and

   111    avoids a test in the generated code (for non-const cases,

   112 	which are in the majority.)

   113    Uses a temp to avoid the test.

   114    The decl here should avoid any problem of size in the temp.

   115    This code is ENDIAN DEPENDENT

   116    The memcpy args are the endian issue.

   117 */

   118 typedef Dwarf_Unsigned BIGGEST_UINT;

   119 

   120 #ifdef WORDS_BIGENDIAN

   121 #define READ_UNALIGNED(dbg,dest,desttype, source, length) \

   122     do { \

   123       BIGGEST_UINT _ltmp = 0;  \

   124       dbg->de_copy_word( (((char *)(&_ltmp)) + sizeof(_ltmp) - length), \

   125 			source, length) ; \

   126       dest = (desttype)_ltmp;  \

   127     } while (0)

   128 

   129 

   130 /*

   131     This macro sign-extends a variable depending on the length.

   132     It fills the bytes between the size of the destination and

   133     the length with appropriate padding.

   134     This code is ENDIAN DEPENDENT but dependent only

   135     on host endianness, not object file endianness.

   136     The memcpy args are the issue.

   137 */

   138 #define SIGN_EXTEND(dest, length) \

   139     do {if (*(Dwarf_Sbyte *)((char *)&dest + sizeof(dest) - length) < 0) {\

   140 	memcpy((char *)&dest, "\xff\xff\xff\xff\xff\xff\xff\xff", \

   141 	    sizeof(dest) - length);  \

   142         } \

   143      } while (0)

   144 #else /* LITTLE ENDIAN */

   145 

   146 #define READ_UNALIGNED(dbg,dest,desttype, source, length) \

   147     do  { \

   148       BIGGEST_UINT _ltmp = 0;  \

   149       dbg->de_copy_word( (char *)(&_ltmp) , \

   150                         source, length) ; \

   151       dest = (desttype)_ltmp;  \

   152      } while (0)

   153 

   154 

   155 /*

   156     This macro sign-extends a variable depending on the length.

   157     It fills the bytes between the size of the destination and

   158     the length with appropriate padding.

   159     This code is ENDIAN DEPENDENT but dependent only

   160     on host endianness, not object file endianness.

   161     The memcpy args are the issue.

   162 */

   163 #define SIGN_EXTEND(dest, length) \

   164     do {if (*(Dwarf_Sbyte *)((char *)&dest + (length-1)) < 0) {\

   165         memcpy((char *)&dest+length,    \

   166                 "\xff\xff\xff\xff\xff\xff\xff\xff", \

   167             sizeof(dest) - length); \

   168         }  \

   169     } while (0)

   170 

   171 #endif /* ! LITTLE_ENDIAN */

   172 

   173 

   174 

   175 /*

   176    READ_AREA LENGTH reads the length (the older way

   177    of pure 32 or 64 bit

   178    or the new proposed dwarfv2.1 64bit-extension way)

   179 

   180    It reads the bits from where rw_src_data_p  points to 

   181    and updates the rw_src_data_p to point past what was just read.

   182 

   183    It updates w_length_size and w_exten_size (which

   184 	are really issues only for the dwarfv2.1  64bit extension).

   185 

   186    r_dbg is just the current dbg pointer.

   187    w_target is the output length field.

   188    r_targtype is the output type. Always Dwarf_Unsigned so far.

   189   

   190 */

   191 /* This one handles the v2.1 64bit extension  

   192    and 32bit (and   MIPS fixed 64  bit via the

   193 	dwarf_init-set r_dbg->de_length_size)..

   194    It does not recognize any but the one distingushed value

   195    (the only one with defined meaning).

   196    It assumes that no CU will have a length

   197 	0xffffffxx  (32bit length)

   198 	or

   199 	0xffffffxx xxxxxxxx (64bit length)

   200    which makes possible auto-detection of the extension.

   201 

   202    This depends on knowing that only a non-zero length

   203    is legitimate (AFAICT), and for IRIX non-standard -64 

   204    dwarf that the first 32 bits of the 64bit offset will be

   205    zero (because the compiler could not handle a truly large 

   206    value as of Jan 2003 and because no app has that much debug 

   207    info anyway (yet)).

   208 

   209    At present not testing for '64bit elf' here as that

   210    does not seem necessary (none of the 64bit length seems 

   211    appropriate unless it's  ident[EI_CLASS] == ELFCLASS64).

   212    Might be a good idea though.

   213 

   214 */

   215 #   define    READ_AREA_LENGTH(r_dbg,w_target,r_targtype,         \

   216 	rw_src_data_p,w_length_size,w_exten_size)                 \

   217 do {    READ_UNALIGNED(r_dbg,w_target,r_targtype,                     \

   218                 rw_src_data_p, ORIGINAL_DWARF_OFFSET_SIZE);       \

   219     if(w_target == DISTINGUISHED_VALUE) {                         \

   220 	     /* dwarf3 64bit extension */                         \

   221              w_length_size  = DISTINGUISHED_VALUE_OFFSET_SIZE;    \

   222              rw_src_data_p += ORIGINAL_DWARF_OFFSET_SIZE;         \

   223              w_exten_size   = ORIGINAL_DWARF_OFFSET_SIZE;         \

   224              READ_UNALIGNED(r_dbg,w_target,r_targtype,            \

   225                   rw_src_data_p, DISTINGUISHED_VALUE_OFFSET_SIZE);\

   226              rw_src_data_p += DISTINGUISHED_VALUE_OFFSET_SIZE;    \

   227     } else {                                                      \

   228 	if(w_target == 0 && r_dbg->de_big_endian_object) {        \

   229 	     /* IRIX 64 bit, big endian */                        \

   230              READ_UNALIGNED(r_dbg,w_target,r_targtype,            \

   231                 rw_src_data_p, DISTINGUISHED_VALUE_OFFSET_SIZE);  \

   232 	     w_length_size  = DISTINGUISHED_VALUE_OFFSET_SIZE;    \

   233 	     rw_src_data_p += DISTINGUISHED_VALUE_OFFSET_SIZE;    \

   234 	     w_exten_size = 0;                                    \

   235 	} else {                                                  \

   236 	     /* standard 32 bit dwarf2/dwarf3 */                  \

   237 	     w_exten_size   = 0;                                  \

   238              w_length_size  = ORIGINAL_DWARF_OFFSET_SIZE;         \

   239              rw_src_data_p += w_length_size;                      \

   240 	}                                                         \

   241     } } while(0)

   242 

   243 

   244 

   245 Dwarf_Unsigned

   246 _dwarf_decode_u_leb128(Dwarf_Small * leb128,

   247 		       Dwarf_Word * leb128_length);

   248 

   249 Dwarf_Signed

   250 _dwarf_decode_s_leb128(Dwarf_Small * leb128,

   251 		       Dwarf_Word * leb128_length);

   252 

   253 Dwarf_Unsigned

   254 _dwarf_get_size_of_val(Dwarf_Debug dbg,

   255 		       Dwarf_Unsigned form,

   256 		       Dwarf_Small * val_ptr, int v_length_size);

   257 

   258 /*

   259     This struct is used to build a hash table for the

   260     abbreviation codes for a compile-unit.  

   261 */

   262 struct Dwarf_Hash_Table_s {

   263     Dwarf_Abbrev_List at_head;

   264     Dwarf_Abbrev_List at_tail;

   265 };

   266 

   267 Dwarf_Abbrev_List

   268 _dwarf_get_abbrev_for_code(Dwarf_CU_Context cu_context,

   269 			   Dwarf_Word code);

   270 

   271 

   272 /* return 1 if string ends before 'endptr' else

   273 ** return 0 meaning string is not properly terminated.

   274 ** Presumption is the 'endptr' pts to end of some dwarf section data.

   275 */

   276 int _dwarf_string_valid(void *startptr, void *endptr);

   277 

   278 Dwarf_Unsigned _dwarf_length_of_cu_header(Dwarf_Debug,

   279 					  Dwarf_Unsigned offset);

   280 Dwarf_Unsigned _dwarf_length_of_cu_header_simple(Dwarf_Debug);

   281 

   282 int _dwarf_load_debug_info(Dwarf_Debug dbg, Dwarf_Error *error);