libgoblin/drd64_libgoblin_dwarf_abbrev.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_ABBREV
  38 #include"drd64_libgoblin.h"
  39
  40 /*----------------------------------------------------------------------
  41 ----------------------------------------------------------------------*/
  42 LIBGOBLIN_DWARF_ABBREV_EXTERN
  43 void
  44         Debug_DWARF_Abbrev_Dump(
  45                 LibGoblin_BinaryInfo    *p_binfo,
  46                 Byte    b_level )
  47 {
  48         int                                             i_cnt;
  49         int                                             i_items;
  50         LibGoblin_BinaryFile    *p_bfile;
  51         DWARF_AbbrevEntry               *p_arvnow;
  52
  53         if( 0x00 < b_level )
  54                 { puts("[DEBUG] DWARF Abbrev ------------------------------------------------"); }
  55
  56         p_bfile = BinaryFile_GetBinaryFile( p_binfo->i_binfile );
  57         assert( NULL != p_bfile );
  58
  59         p_arvnow        = p_bfile->dwarf.p_abbrev;
  60         for( i_cnt = 0; i_cnt < p_bfile->dwarf.i_abbrevs; i_cnt++, p_arvnow++ ) {
  61
  62                 printf("  [ID= %2d] TAG= %02xh Child=%s\n",
  63                                                 p_arvnow->dw_id, p_arvnow->dw_tag,
  64                                                 ((0x00 == p_arvnow->b_children) ? "NO" : "YES") );
  65
  66                 for( i_items = 0; i_items < p_arvnow->i_items; i_items++ )      {
  67                         printf("      Attribute= %02xh , Format= %02xh\n",
  68                                                 p_arvnow->dw_attribute[ i_items ],
  69                                                 p_arvnow->dw_format[ i_items ] );
  70                 }
  71         }
  72
  73         if( 0x00 < b_level )    {
  74                 puts("-----------------------------------------------------------------------");
  75                 puts("");
  76         }
  77
  78         return;
  79 }
  80
  81
  82 /*----------------------------------------------------------------------
  83 ----------------------------------------------------------------------*/
  84 LIBGOBLIN_DWARF_ABBREV_EXTERN
  85 Byte *
  86         LibGoblin_DwarfAbbrev_ReadEntry(
  87                 LibGoblin_Dwarf_AbbrevEntry     *p_entry,
  88                 Byte    *pb_src,
  89                 QWord   *pqw_remain )
  90 {
  91         int             i_items;
  92         DWord   dw_attribute;
  93         DWord   dw_format;
  94         QWord   qw_temp;
  95
  96         assert( NULL != p_entry );
  97         assert( NULL != pb_src );
  98
  99         i_items = 0;
 100
 101         memset( p_entry, 0x00, sizeof( LibGoblin_Dwarf_AbbrevEntry ) );
 102
 103         /* Read Abbrev Number */
 104         pb_src  = DWARF_Common_DecodeULEB128( &qw_temp, pb_src, pqw_remain );
 105
 106         p_entry->dw_id  = (DWord)qw_temp;
 107         if( 0x00000000 == p_entry->dw_id )      {
 108                 return pb_src;
 109         }
 110
 111         /* Read TAG */
 112         pb_src  = DWARF_Common_DecodeULEB128( &qw_temp, pb_src, pqw_remain );
 113         p_entry->dw_tag = (DWord)qw_temp;
 114
 115         /* Read IsChildren */
 116         pb_src  = LibGoblin_DwarfCommon_Read_Byte(
 117                                         &(p_entry->b_children), pb_src, pqw_remain );
 118         if( NULL == pb_src )    { return NULL; }
 119
 120 /*
 121         printf("%04x : TAG=%04x (Children=%x) %ld\n",
 122                                 p_entry->dw_id, p_entry->dw_tag, p_entry->b_children, *pqw_remain);
 123 */
 124
 125         do      {
 126                 /* Read Attribute */
 127                 pb_src  = DWARF_Common_DecodeULEB128( &qw_temp, pb_src, pqw_remain );
 128                 dw_attribute    = (DWord)qw_temp;
 129                 p_entry->dw_attribute[i_items]  = dw_attribute;
 130
 131                 /* Read Format */
 132                 pb_src  = DWARF_Common_DecodeULEB128( &qw_temp, pb_src, pqw_remain );
 133                 dw_format               = (DWord)qw_temp;
 134                 p_entry->dw_format[i_items]     = dw_format;
 135
 136 /*
 137                 printf("    Attiribute=%02x Format=%02x\n",
 138                                         dw_attribute, dw_format);
 139 */
 140
 141                 i_items++;
 142
 143         }while((0x00 != dw_attribute) && (0x00 != dw_format)
 144                                         && (*pqw_remain > 0) );
 145
 146         p_entry->i_items        = i_items;
 147
 148         return pb_src;
 149 }
 150
 151
 152 /*----------------------------------------------------------------------
 153 ----------------------------------------------------------------------*/
 154 int
 155         DWARF_Abbrev_ReadAbbrevEntry(
 156                 LibGoblin_BinaryInfo    *p_binfo,
 157                 LibGoblin_BinaryFile    *p_bfile )
 158 {
 159         int             i_abbrevs;
 160         int             i_items;
 161         Byte    *pb_data;
 162         Byte    b_children;
 163         QWord   qw_temp;
 164         QWord   qw_remain;
 165         DWord   dw_abbrev_num;
 166         DWord   dw_tag;
 167         DWord   dw_attribute;
 168         DWord   dw_format;
 169         LibGoblin_SectionInfo           *psec_abbrev;
 170         DWARF_AbbrevEntry                       *p_arvnow;
 171
 172         assert( NULL != p_binfo );
 173         assert( NULL != p_bfile );
 174
 175         // Get .debug_abbrev section Info ---
 176         psec_abbrev     =       Section_GetSectionInfo( p_binfo, LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
 177         assert( NULL != psec_abbrev );
 178         if( NULL == psec_abbrev->pb_data )      {
 179                 return 0x01;
 180         }
 181         pb_data         = psec_abbrev->pb_data;
 182         qw_remain       = psec_abbrev->qw_size;
 183
 184         i_abbrevs       = p_bfile->dwarf.i_abbrevs;
 185         p_arvnow        = p_bfile->dwarf.p_abbrev;
 186
 187         do      {
 188                 // Read Abbrev Number ---
 189                 pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_remain );
 190                 dw_abbrev_num   = (DWord)qw_temp;
 191
 192                 /* Read TAG */
 193                 pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_remain );
 194                 dw_tag  = (DWord)qw_temp;
 195
 196                 /* Read IsChildren */
 197                 b_children      = *pb_data++;
 198                 qw_remain--;
 199
 200                 p_arvnow->dw_id                 = dw_abbrev_num;
 201                 p_arvnow->dw_tag                = dw_tag;
 202                 p_arvnow->b_children    = b_children;
 203
 204                 i_items = -1;
 205                 do      {
 206                         i_items++;
 207
 208                         /* Read Attribute */
 209                         pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_remain );
 210                         dw_attribute    = (DWord)qw_temp;
 211
 212                         /* Read Format */
 213                         pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_remain );
 214                         dw_format       = (DWord)qw_temp;
 215
 216                         p_arvnow->dw_attribute[ i_items ]       = dw_attribute;
 217                         p_arvnow->dw_format[ i_items ]          = dw_format;
 218
 219                 }while((0x00 != dw_attribute) && (0x00 != dw_format) && (qw_remain > 0) );
 220
 221                 p_arvnow->i_items       = i_items;
 222                 p_arvnow++;
 223
 224                 /* Skip Byte for Next Compile-Unit Abbrev. */
 225                 if( 0x00 == *pb_data )  {
 226                         pb_data++;
 227                         qw_remain--;
 228                 }
 229
 230         }while((qw_remain > 0) && (dw_tag != 0x00));
 231
 232         return 0x00;
 233 }
 234
 235
 236 /*----------------------------------------------------------------------
 237 ----------------------------------------------------------------------*/
 238 int
 239         DWARF_Abbrev_GetItems(
 240                 int             *pi_filenum,
 241                 int             *pi_abbrevs,
 242                 LibGoblin_BinaryInfo    *p_binfo )
 243 {
 244         Byte    *pb_data;
 245         Byte    b_children;
 246         QWord   qw_temp;
 247         QWord   qw_size;
 248         DWord   dw_abbrev_num;
 249         DWord   dw_tag;
 250         DWord   dw_attribute;
 251         DWord   dw_format;
 252         LibGoblin_SectionInfo           *psec_abbrev;
 253
 254         assert( NULL != p_binfo );
 255
 256         // Get .debug_abbrev section Info ---
 257         psec_abbrev     =       Section_GetSectionInfo( p_binfo, LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
 258         assert( NULL != psec_abbrev );
 259         if( NULL == psec_abbrev->pb_data )      {
 260                 return 0x01;
 261         }
 262         pb_data = psec_abbrev->pb_data;
 263         qw_size = psec_abbrev->qw_size;
 264
 265         *pi_filenum     = 0;
 266         *pi_abbrevs     = 0;
 267
 268         do      {
 269                 (*pi_abbrevs)++;
 270
 271                 /* Read Abbrev Number */
 272                 pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_size );
 273                 dw_abbrev_num   = (DWord)qw_temp;
 274
 275                 /* Read TAG */
 276                 pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_size );
 277                 dw_tag  = (DWord)qw_temp;
 278                 if( DW_TAG_compile_unit == dw_tag )             {
 279                         (*pi_filenum)++;
 280                 }
 281
 282                 /* Read IsChildren */
 283                 b_children      = *pb_data++;
 284                 qw_size--;
 285
 286                 do      {
 287                         /* Read Attribute */
 288                         pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_size );
 289                         dw_attribute    = (DWord)qw_temp;
 290
 291                         /* Read Format */
 292                         pb_data = DWARF_Common_DecodeULEB128( &qw_temp, pb_data, &qw_size );
 293                         dw_format       = (DWord)qw_temp;
 294
 295                 }while((0x00 != dw_attribute) && (0x00 != dw_format)
 296                                         && (qw_size > 0) );
 297
 298                 /* Skip Byte for Next Compile-Unit Abbrev. */
 299                 if( 0x00 == *pb_data )  {
 300                         pb_data++;
 301                         qw_size--;
 302                 }
 303
 304         }while((qw_size > 0) && (dw_tag != 0x00));
 305
 306         return 0x00;
 307 }
 308
 309
 310 /*----------------------------------------------------------------------
 311 ----------------------------------------------------------------------*/
 312 LIBGOBLIN_DWARF_ABBREV_EXTERN
 313 int
 314         DWARF_Abbrev_Read(
 315                 LibGoblin_BinaryInfo    *p_binfo )
 316 {
 317         int             i_result;
 318         int             i_filenums      = 0;
 319         int             i_abbrevs       = 0;
 320         DWARF_AbbrevEntry       *p_abbrev;
 321         LibGoblin_BinaryFile    *p_bfile;
 322
 323         p_bfile = BinaryFile_GetBinaryFile( p_binfo->i_binfile );
 324         assert( NULL != p_bfile );
 325
 326         // Count Abbrevs ---
 327         i_result        = DWARF_Abbrev_GetItems( &i_filenums, &i_abbrevs, p_binfo );
 328         if( 0x00 != i_result )  {
 329                 return 0x01;
 330         }
 331
 332         // Alloc Abbrev Memory ---
 333         p_abbrev        = (DWARF_AbbrevEntry *)malloc( sizeof( DWARF_AbbrevEntry ) * i_abbrevs );
 334         if( NULL == p_abbrev )  {
 335                 return 0x02;
 336         }
 337         p_bfile->dwarf.p_abbrev         = p_abbrev;
 338         p_bfile->dwarf.i_abbrevs        = i_abbrevs;
 339
 340         // Read Abbrev ---
 341         i_result        = DWARF_Abbrev_ReadAbbrevEntry( p_binfo, p_bfile );
 342         if( 0x00 != i_result )  {
 343                 return 0x01;
 344         }
 345
 346         return 0x00;
 347 }
 348
 349
 350 /* EOF of drd64_.c ----------------------------------- */