libgoblin/drd64_libgoblin_dwarf_info.c

   1 /*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
   2
   3                          D r . D e a m o n  6 4
   4                         for INTEL64(R), AMD64(R)
   5
   6    Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10
  11  1. Redistributions of source code must retain the above copyright notice,
  12     this list of conditions and the following disclaimer.
  13  2. Redistributions in binary form must reproduce the above copyright
  14     notice, this list of conditions and the following disclaimer in the
  15     documentation and/or other materials provided with the distribution.
  16
  17 THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  27 OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
  30
  31 /* File Info -----------------------------------------------------------
  32 File: drd64_.c
  33 Function:
  34 Comment:
  35 ----------------------------------------------------------------------*/
  36
  37 #define DRD64_SRC_LIBGOBLIN_DWARF_INFO
  38 #include"drd64_libgoblin.h"
  39
  40 /*----------------------------------------------------------------------
  41 ----------------------------------------------------------------------*/
  42 Byte *
  43         DWARF_Info_ReadFormat_Ref_inCU(
  44                 LibGoblin_DWARF_DIEValue        *p_val,
  45                 Byte    *pb_src,
  46                 QWord   *pqw_remain,
  47                 Byte    b_bytes,
  48                 Byte    *pb_custart )
  49 {
  50         Byte    *pb_link;
  51         Byte    b_size;
  52         Word    w_size;
  53         DWord   dw_size;
  54         QWord   qw_size;
  55
  56         assert( NULL != pb_src );
  57         assert( NULL != p_val );
  58
  59         if( 1 == b_bytes )      {
  60                 pb_src  = DWARF_Common_Read_Byte( &b_size, pb_src, pqw_remain );
  61                 qw_size = (QWord)b_size;
  62         }
  63         else if( 2 == b_bytes ) {
  64                 pb_src  = DWARF_Common_Read_Word( &w_size, pb_src, pqw_remain );
  65                 qw_size = (QWord)w_size;
  66         }
  67         else if( 4 == b_bytes ) {
  68                 pb_src  = DWARF_Common_Read_DWord( &dw_size, pb_src, pqw_remain );
  69                 qw_size = (QWord)dw_size;
  70         }
  71         else if( 8 == b_bytes ) {
  72                 pb_src  = DWARF_Common_Read_QWord( &qw_size, pb_src, pqw_remain );
  73         }
  74         else    {
  75                 pb_src  = DWARF_Common_DecodeULEB128( &qw_size, pb_src, pqw_remain );
  76         }
  77         if( NULL == pb_src )    { return NULL; }
  78
  79         p_val->value.pb_link    = pb_custart + qw_size;
  80         p_val->b_type                   = LIBGOBLIN_DWARF_INFO_TYPE_LINK;
  81         p_val->qw_size                  = (QWord)b_bytes;
  82
  83         return pb_src;
  84 }
  85
  86
  87 /*----------------------------------------------------------------------
  88 ----------------------------------------------------------------------*/
  89 Byte *
  90         DWARF_Info_ReadFormat_Block(
  91                 LibGoblin_DWARF_DIEValue        *p_val,
  92                 Byte    *pb_src,
  93                 QWord   *pqw_remain,
  94                 int             i_sizebytes )
  95 {
  96         Byte    b_size;
  97         Word    w_size;
  98         DWord   dw_size;
  99         QWord   qw_size;
 100
 101         assert( NULL != pb_src );
 102         assert( NULL != p_val );
 103
 104         if( 1 == i_sizebytes )  {
 105                 pb_src  = DWARF_Common_Read_Byte( &b_size, pb_src, pqw_remain );
 106                 qw_size = (QWord)b_size;
 107         }
 108         else if( 2 == i_sizebytes )     {
 109                 pb_src  = DWARF_Common_Read_Word( &w_size, pb_src, pqw_remain );
 110                 qw_size = (QWord)w_size;
 111         }
 112         else if( 4 == i_sizebytes )     {
 113                 pb_src  = DWARF_Common_Read_DWord( &dw_size, pb_src, pqw_remain );
 114                 qw_size = (QWord)dw_size;
 115         }
 116         else if( 8 == i_sizebytes )     {
 117                 pb_src  = DWARF_Common_Read_QWord( &qw_size, pb_src, pqw_remain );
 118         }
 119         else    {
 120                 pb_src  = DWARF_Common_DecodeULEB128( &qw_size, pb_src, pqw_remain );
 121         }
 122
 123         if( *pqw_remain >= qw_size )    {
 124                 p_val->qw_size                  = qw_size;
 125                 p_val->value.pb_data    = pb_src;
 126                 p_val->b_type                   = LIBGOBLIN_DWARF_INFO_TYPE_BLOCK;
 127                 pb_src                                  += qw_size;
 128                 *pqw_remain                             -= qw_size;
 129         }
 130         else    { pb_src        = NULL; }
 131
 132         return pb_src;
 133 }
 134
 135 /*----------------------------------------------------------------------
 136 ----------------------------------------------------------------------*/
 137 Byte *
 138         DWARF_Info_ReadFormat_Strp(
 139                 LibGoblin_DWARF_DIEValue        *p_val,
 140                 Byte    *pb_src,
 141                 QWord   *pqw_remain,
 142                 LibGoblin_BinaryInfo    *p_binfo,
 143                 Byte    b_bits )
 144 {
 145         Byte    *pb_string      = NULL;
 146         QWord   qw_offset;
 147         DWord   dw_offset;
 148         LibGoblin_SectionInfo   *psec_dbgstr;
 149
 150         assert( NULL != pb_src );
 151         assert( NULL != p_val );
 152
 153         psec_dbgstr     = Section_GetSectionInfo( p_binfo, LIBGOBLIN_SECTION_ID_DEBUG_STR );
 154         assert( NULL != psec_dbgstr );
 155         assert( NULL != psec_dbgstr->pb_data );
 156
 157         if( 8 == b_bits )       {
 158                 pb_src          = DWARF_Common_Read_QWord( &qw_offset, pb_src, pqw_remain );
 159                 pb_string       = psec_dbgstr->pb_data + qw_offset;
 160         }
 161         else if( 4 == b_bits )  {
 162                 pb_src  = DWARF_Common_Read_DWord( &dw_offset, pb_src, pqw_remain );
 163                 pb_string       = psec_dbgstr->pb_data + dw_offset;
 164         }
 165
 166         p_val->value.pstr_value = (char *)pb_string;
 167         p_val->b_type                   = LIBGOBLIN_DWARF_INFO_TYPE_STRING;
 168         p_val->qw_size                  = 0;
 169
 170         return pb_src;
 171 }
 172
 173
 174 /*----------------------------------------------------------------------
 175 ----------------------------------------------------------------------*/
 176 Byte *
 177         DWARF_Info_ReadFormat_String(
 178                 LibGoblin_DWARF_DIEValue        *p_val,
 179                 Byte    *pb_src,
 180                 QWord   *pqw_remain )
 181 {
 182         Byte    *pb_now;
 183         QWord   qw_size = 0;
 184
 185         assert( NULL != pb_src );
 186         assert( NULL != p_val );
 187
 188         pb_now  = pb_src;
 189
 190         while( (0 < *pqw_remain) && ('\0' != *pb_now) ) {
 191                 pb_now++;
 192                 qw_size++;
 193                 (*pqw_remain)--;
 194         }
 195
 196         if( 0 < *pqw_remain )   {
 197                 p_val->value.pstr_value = (char *)pb_src;
 198                 p_val->b_type                   = LIBGOBLIN_DWARF_INFO_TYPE_STRING;
 199                 p_val->qw_size                  = qw_size;
 200
 201                 pb_now++;
 202                 (*pqw_remain)--;
 203         }
 204
 205         return pb_now;
 206 }
 207
 208
 209 /*----------------------------------------------------------------------
 210 ----------------------------------------------------------------------*/
 211 Byte *
 212         DWARF_Info_ReadFormat_Address(
 213                 LibGoblin_DWARF_DIEValue        *p_val,
 214                 Byte    *pb_src,
 215                 QWord   *pqw_remain,
 216                 Byte    b_pointersize )
 217 {
 218         assert( NULL != pb_src );
 219         assert( NULL != p_val );
 220
 221         if( 8 == b_pointersize )        {
 222                 pb_src  = DWARF_Common_Read_QWord(
 223                                                 &(p_val->value.qw_value), pb_src, pqw_remain );
 224                 p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_QWORD;
 225                 p_val->qw_size  = 8;
 226         }
 227         else if( 4 == b_pointersize )   {
 228                 pb_src  = DWARF_Common_Read_DWord(
 229                                                 &(p_val->value.dw_value), pb_src, pqw_remain );
 230                 p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_DWORD;
 231                 p_val->qw_size  = 4;
 232         }
 233         else if( 2 == b_pointersize )   {
 234                 pb_src  = DWARF_Common_Read_Word(
 235                                                 &(p_val->value.w_value), pb_src, pqw_remain );
 236                 p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_WORD;
 237                 p_val->qw_size  = 2;
 238         }
 239
 240         return pb_src;
 241 }
 242
 243
 244 /*----------------------------------------------------------------------
 245 ----------------------------------------------------------------------*/
 246 Byte *
 247         DWARF_Info_ReadFormat_InDirect(
 248                 LibGoblin_DWARF_DIEValue        *p_val,
 249                 Byte    *pb_info,
 250                 QWord   *pqw_remains,
 251                 LibGoblin_BinaryInfo    *p_binfo,
 252                 LibGoblin_DWARF_Info_CUHeader   *p_cuheader )
 253 {
 254         QWord   qw_size;
 255         DWord   dw_form;
 256
 257         // Get InDirect DW_FORM_*** value. ---
 258         pb_info = DWARF_Common_DecodeULEB128( &qw_size, pb_info, pqw_remains );
 259         dw_form = (DWord)qw_size;
 260
 261         // Re-Call Read FormatData Function ---
 262         pb_info = DWARF_Info_ReadFormat_Data(
 263                                                 p_val, pb_info, pqw_remains, dw_form, p_binfo, p_cuheader );
 264
 265         return pb_info;
 266 }
 267
 268
 269 /*----------------------------------------------------------------------
 270 ----------------------------------------------------------------------*/
 271 Byte *
 272         DWARF_Info_ReadFormat_Data(
 273                 LibGoblin_DWARF_DIEValue        *p_val,
 274                 Byte    *pb_info,
 275                 QWord   *pqw_remains,
 276                 DWord   dw_format,
 277                 LibGoblin_BinaryInfo    *p_binfo,
 278                 LibGoblin_DWARF_Info_CUHeader   *p_cuheader )
 279 {
 280         QWord   qw_cnt;
 281
 282         switch( dw_format )     {
 283                 case DW_FORM_addr:              // 0x01: address
 284                         pb_info = DWARF_Info_ReadFormat_Address(
 285                                                                 p_val, pb_info, pqw_remains, p_cuheader->b_pointersize );
 286                         break;
 287                 case DW_FORM_block2:    // 0x03: block
 288                         pb_info = DWARF_Info_ReadFormat_Block( p_val, pb_info, pqw_remains, 2);
 289                         break;
 290                 case DW_FORM_block4:    // 0x04: block
 291                         pb_info = DWARF_Info_ReadFormat_Block( p_val, pb_info, pqw_remains, 4);
 292                         break;
 293                 case DW_FORM_data2:             // 0x05: const.
 294                         pb_info = DWARF_Common_Read_Word( &(p_val->value.w_value), pb_info, pqw_remains );
 295                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_WORD;
 296                         p_val->qw_size  = 2;
 297                         break;
 298                 case DW_FORM_data4:             // 0x06: const. line/loc/mac/rng-ptr
 299                         pb_info = DWARF_Common_Read_DWord( &(p_val->value.dw_value), pb_info, pqw_remains );
 300                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_DWORD;
 301                         p_val->qw_size  = 4;
 302                         break;
 303                 case DW_FORM_data8:             // 0x07: const. line/loc/mac/rng-ptr
 304                         pb_info = DWARF_Common_Read_QWord( &(p_val->value.qw_value), pb_info, pqw_remains );
 305                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_QWORD;
 306                         p_val->qw_size  = 4;
 307                         break;
 308                 case DW_FORM_string:    // 0x08: string
 309                         pb_info = DWARF_Info_ReadFormat_String( p_val, pb_info, pqw_remains );
 310                         break;
 311                 case DW_FORM_block:             // 0x09: block
 312                         pb_info = DWARF_Info_ReadFormat_Block( p_val, pb_info, pqw_remains, -1);
 313                         break;
 314                 case DW_FORM_block1:    // 0x0a: block
 315                         pb_info = DWARF_Info_ReadFormat_Block( p_val, pb_info, pqw_remains, 1);
 316                         break;
 317                 case DW_FORM_data1:             // 0x0b: const.
 318                         pb_info = DWARF_Common_Read_Byte( &(p_val->value.b_value), pb_info, pqw_remains );
 319                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_BYTE;
 320                         p_val->qw_size  = 1;
 321                         break;
 322                 case DW_FORM_flag:              // 0x0c: flag
 323                         pb_info = DWARF_Common_Read_Byte( &(p_val->value.b_value), pb_info, pqw_remains );
 324                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_BYTE;
 325                         p_val->qw_size  = 1;
 326                         break;
 327                 case DW_FORM_sdata:             // 0x0d: sdata
 328                         pb_info = DWARF_Common_DecodeLEB128( &(p_val->value.ii_value), pb_info, pqw_remains );
 329                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_INT64;
 330                         p_val->qw_size  = 8;
 331                         break;
 332                 case DW_FORM_strp:              // 0x0e: string (in .debug_str section)
 333                         pb_info = DWARF_Info_ReadFormat_Strp(
 334                                                                 p_val, pb_info, pqw_remains, p_binfo, p_cuheader->b_offsetsize );
 335                         break;
 336                 case DW_FORM_udata:             // 0x0f: const.
 337                         pb_info = DWARF_Common_DecodeULEB128( &(p_val->value.qw_value), pb_info, pqw_remains );
 338                         p_val->b_type   = LIBGOBLIN_DWARF_INFO_TYPE_QWORD;
 339                         p_val->qw_size  = 8;
 340                         break;
 341                 case DW_FORM_ref_addr:  // 0x10: ref.
 342                         pb_info = DWARF_Info_ReadFormat_Address(
 343                                                                 p_val, pb_info, pqw_remains, p_cuheader->b_pointersize );
 344                         break;
 345                 case DW_FORM_ref1:              // 0x11: ref.
 346                         pb_info = DWARF_Info_ReadFormat_Ref_inCU(
 347                                                                 p_val, pb_info, pqw_remains, 1, p_cuheader->pb_custart );
 348                         break;
 349                 case DW_FORM_ref2:              // 0x12: ref.
 350                         pb_info = DWARF_Info_ReadFormat_Ref_inCU(
 351                                                                 p_val, pb_info, pqw_remains, 2, p_cuheader->pb_custart );
 352                         break;
 353                 case DW_FORM_ref4:              // 0x13: ref.
 354                         pb_info = DWARF_Info_ReadFormat_Ref_inCU(
 355                                                                 p_val, pb_info, pqw_remains, 4, p_cuheader->pb_custart );
 356                         break;
 357                 case DW_FORM_ref8:              // 0x14: ref.
 358                         pb_info = DWARF_Info_ReadFormat_Ref_inCU(
 359                                                                 p_val, pb_info, pqw_remains, 8, p_cuheader->pb_custart );
 360                         break;
 361                 case DW_FORM_ref_udata: // 0x15: ref.
 362                         pb_info = DWARF_Info_ReadFormat_Ref_inCU(
 363                                                                 p_val, pb_info, pqw_remains, -1, p_cuheader->pb_custart );
 364                         break;
 365                 case DW_FORM_indirect:  // 0x16: ref.
 366                         pb_info = DWARF_Info_ReadFormat_InDirect(
 367                                                                 p_val, pb_info, pqw_remains, p_binfo, p_cuheader );
 368                         break;
 369                 case DW_FORM_sec_offset:        // 0x17:
 370                         break;
 371                 case DW_FORM_exprloc:           // 0x18:
 372                         break;
 373                 case DW_FORM_flag_present:      // 0x19:
 374                         break;
 375                 case DW_FORM_ref_sig8:          // 0x20:
 376                         break;
 377                 case DW_FORM_GNU_ref_alt:       // 0x1f20:
 378                         break;
 379                 case DW_FORM_GNU_strp_alt:      // 0x1f21:
 380                         break;
 381                 default:
 382                         break;
 383         }
 384
 385         return pb_info;
 386 }
 387
 388
 389 /*----------------------------------------------------------------------
 390 ----------------------------------------------------------------------*/
 391 Byte *
 392         DWARF_Info_ReadCUHeader(
 393                 LibGoblin_DWARF_Info_CUHeader   *p_cuhead,
 394                 Byte    *pb_info,
 395                 QWord   *pqw_size_info )
 396 {
 397         int             i_bitflag;
 398         int             i_readbytes;
 399         DWord   dw_dword;
 400         QWord   qw_qword;
 401
 402         assert( NULL != p_cuhead );
 403         assert( NULL != pb_info );
 404
 405         i_readbytes     = 0;
 406         i_bitflag       = 32;
 407
 408         // Read unit_length (4Byte + 8Byte(64bit)) ---
 409         pb_info = DWARF_Common_Read_DWord( &dw_dword, pb_info, pqw_size_info );
 410         if( NULL == pb_info )   { return NULL; }
 411
 412         //     64bit - First 4Byte = 0xffffffff
 413         if( ((DWord)0xffffffff) == dw_dword )   {
 414                 pb_info = DWARF_Common_Read_QWord( &qw_qword, pb_info, pqw_size_info );
 415                 if( NULL == pb_info )   { return NULL; }
 416
 417                 p_cuhead->qw_unitsize   = (QWord)qw_qword;
 418                 i_bitflag                               = 64;
 419                 p_cuhead->b_bits                = 64;
 420                 p_cuhead->b_offsetsize  = 8;
 421         }
 422         //     32bit - First 4Byte = value.
 423         else    {
 424                 p_cuhead->qw_unitsize   = (QWord)dw_dword;
 425                 p_cuhead->b_bits                = 32;
 426                 p_cuhead->b_offsetsize  = 4;
 427         }
 428
 429         // Read version (2Byte) ---
 430         pb_info = DWARF_Common_Read_Word( &(p_cuhead->w_version), pb_info, pqw_size_info );
 431         if( NULL == pb_info )   { return NULL; }
 432         i_readbytes     = 2;
 433
 434         // Read abbrev_offset (4Byte(32bit), 8Byte(64bit)) ---
 435         if( 64 == i_bitflag )   {
 436                 pb_info = DWARF_Common_Read_QWord( &qw_qword, pb_info, pqw_size_info );
 437                 if( NULL == pb_info )   { return NULL; }
 438                 i_readbytes     += 8;
 439
 440                 p_cuhead->qw_abbrev_offset      = qw_qword;
 441         }
 442         else    {
 443                 pb_info = DWARF_Common_Read_DWord( &dw_dword, pb_info, pqw_size_info );
 444                 if( NULL == pb_info )   { return NULL; }
 445                 i_readbytes     += 4;
 446
 447                 p_cuhead->qw_abbrev_offset      = (QWord)dw_dword;
 448         }
 449
 450         // Read address_size (1Byte) ---
 451         pb_info = DWARF_Common_Read_Byte( &(p_cuhead->b_pointersize), pb_info, pqw_size_info);
 452         if( NULL == pb_info )   { return NULL; }
 453         i_readbytes     += 1;
 454
 455         p_cuhead->qw_unitsize   -= i_readbytes;
 456
 457         return pb_info;
 458 }
 459
 460
 461 /*----------------------------------------------------------------------
 462 ----------------------------------------------------------------------*/
 463 LIBGOBLIN_DWARF_INFO_EXTERN
 464 int
 465         DWARF_Info_Read(
 466                 LibGoblin_BinaryInfo    *p_binfo )
 467 {
 468         int                                                     i_childlv;
 469         int                                                     i_result;
 470         int                                                     i_srcfiles;
 471         int                                                     i_abbrevs;
 472         int                                                     i_cnt;
 473         Byte                                            *pb_info;
 474         Byte                                            *pb_custart;
 475         DWord                                           dw_arvid;
 476         DWord                                           dw_attribute;
 477         DWord                                           dw_format;
 478         QWord                                           qw_temp;
 479         QWord                                           qw_size_cu;
 480         QWord                                           qw_size_info;
 481         LibGoblin_SectionInfo           *psec_info;
 482         LibGoblin_BinaryFile            *p_bfile;
 483         DWARF_AbbrevEntry                       *p_abbrev;
 484         DWARF_AbbrevEntry                       *p_arvnow;
 485         LibGoblin_DWARF_DIEValue        *p_infoval;
 486         LibGoblin_DWARF_DIEValue        *p_val;
 487         LibGoblin_DWARF_Info_CUHeader   t_cuheader;
 488
 489         assert( NULL != p_binfo );
 490
 491         p_bfile = BinaryFile_GetBinaryFile( p_binfo->i_binfile );
 492         assert( NULL != p_bfile );
 493
 494         i_srcfiles      = p_bfile->dwarf.i_srcfiles;
 495
 496         p_infoval       = p_bfile->dwarf.p_infoval;
 497
 498         // Get section Info ---
 499         psec_info       = Section_GetSectionInfo( p_binfo, LIBGOBLIN_SECTION_ID_DEBUG_INFO );
 500         assert( NULL != psec_info );
 501         if( NULL == psec_info->pb_data )        {
 502                 return 0x01;
 503         }
 504         pb_info                 = psec_info->pb_data;
 505         qw_size_info    = psec_info->qw_size;
 506
 507         //do    {
 508                 // Read Compile Unit Header ---
 509                 pb_custart      = pb_info;
 510                 pb_info = DWARF_Info_ReadCUHeader( &t_cuheader, pb_info, &qw_size_info );
 511                 if( NULL == pb_info )   {
 512                         return 0x02;
 513                 }
 514
 515                 t_cuheader.pb_custart   = pb_custart;
 516                 qw_size_cu                              = t_cuheader.qw_unitsize;
 517
 518                 printf( "size: %ld, ver:%d, abbrev off.:%ld, addr.size: %d\n",
 519                         t_cuheader.qw_unitsize,
 520                         t_cuheader.w_version,
 521                         t_cuheader.qw_abbrev_offset,
 522                         t_cuheader.b_pointersize);
 523
 524                 // Read Abbrev ---
 525                 i_result        = DWARF_Abbrev_ReadAbbrevEntry(
 526                                                                 &p_abbrev, &i_abbrevs,
 527                                                                 p_binfo, p_bfile, t_cuheader.qw_abbrev_offset );
 528
 529                 i_childlv       = 0;
 530                 do      {
 531                         // Read Reference Abbrev-ID ---
 532                         pb_info = DWARF_Common_DecodeULEB128( &qw_temp, pb_info, &qw_size_cu );
 533                         dw_arvid        = (DWord)qw_temp;
 534
 535                         if( 0 == dw_arvid )     {
 536                                 i_childlv--;
 537                                 continue;
 538                         }
 539
 540                         p_arvnow        = p_abbrev + (dw_arvid - 1);
 541
 542                         // Read Debug Information Entry (DIE) ---
 543                         memset( p_infoval, 0x00, sizeof( LibGoblin_DWARF_DIEValue ) * p_arvnow->i_items );
 544                         p_val   = p_infoval;
 545
 546                         for( i_cnt = 0; i_cnt < p_arvnow->i_items; i_cnt++, p_val++ )   {
 547                                 dw_attribute    = p_arvnow->dw_attribute[ i_cnt ];
 548                                 dw_format               = p_arvnow->dw_format[ i_cnt ];
 549
 550                                 pb_info = DWARF_Info_ReadFormat_Data(
 551                                                                 p_val, pb_info, &qw_size_cu, dw_format, p_binfo, &t_cuheader );
 552                         }
 553
 554                         if( 0x00 != p_arvnow->b_children )      { i_childlv++; }
 555
 556                         // Dispatch for generate Rapid-Access Table by DIE-tag
 557
 558                         Debug_DWARF_PrintDIE( p_bfile, p_abbrev, dw_arvid, i_childlv );
 559
 560                 }while( 0 != qw_size_cu );
 561                 qw_size_info    -= t_cuheader.qw_unitsize;
 562
 563         //}while((qw_size_info > 0) && (i_srcfiles > 0));
 564
 565
 566
 567         return 0x00;
 568 }
 569
 570
 571
 572 /* EOF of drd64_.c ----------------------------------- */