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 Byte *
  44         LibGoblin_DwarfAbbrev_ReadEntry(
  45                 LibGoblin_Dwarf_AbbrevEntry     *p_entry,
  46                 Byte    *pb_src,
  47                 QWord   *pqw_remain )
  48 {
  49         int             i_items;
  50         DWord   dw_attribute;
  51         DWord   dw_format;
  52         QWord   qw_temp;
  53
  54         assert( NULL != p_entry );
  55         assert( NULL != pb_src );
  56
  57         i_items = 0;
  58
  59         memset( p_entry, 0x00, sizeof( LibGoblin_Dwarf_AbbrevEntry ) );
  60
  61         /* Read Abbrev Number */
  62         pb_src  = LibGoblin_DwarfCommon_Decode_ULEB128(
  63                                         &qw_temp, pb_src, pqw_remain );
  64
  65         p_entry->dw_id  = (DWord)qw_temp;
  66         if( 0x00000000 == p_entry->dw_id )      {
  67                 return pb_src;
  68         }
  69
  70         /* Read TAG */
  71         pb_src  = LibGoblin_DwarfCommon_Decode_ULEB128(
  72                                         &qw_temp, pb_src, pqw_remain );
  73         p_entry->dw_tag = (DWord)qw_temp;
  74
  75         /* Read IsChildren */
  76         pb_src  = LibGoblin_DwarfCommon_Read_Byte(
  77                                         &(p_entry->b_children), pb_src, pqw_remain );
  78         if( NULL == pb_src )    { return NULL; }
  79
  80 /*
  81         printf("%04x : TAG=%04x (Children=%x) %ld\n",
  82                                 p_entry->dw_id, p_entry->dw_tag, p_entry->b_children, *pqw_remain);
  83 */
  84
  85         do      {
  86                 /* Read Attribute */
  87                 pb_src  = LibGoblin_DwarfCommon_Decode_ULEB128(
  88                                                 &qw_temp, pb_src, pqw_remain );
  89                 dw_attribute    = (DWord)qw_temp;
  90                 p_entry->dw_attribute[i_items]  = dw_attribute;
  91
  92                 /* Read Format */
  93                 pb_src  = LibGoblin_DwarfCommon_Decode_ULEB128(
  94                                                 &qw_temp, pb_src, pqw_remain );
  95                 dw_format               = (DWord)qw_temp;
  96                 p_entry->dw_format[i_items]     = dw_format;
  97
  98 /*
  99                 printf("    Attiribute=%02x Format=%02x\n",
 100                                         dw_attribute, dw_format);
 101 */
 102
 103                 i_items++;
 104
 105         }while((0x00 != dw_attribute) && (0x00 != dw_format)
 106                                         && (*pqw_remain > 0) );
 107
 108         p_entry->i_items        = i_items;
 109
 110         return pb_src;
 111 }
 112
 113
 114 /*----------------------------------------------------------------------
 115 ----------------------------------------------------------------------*/
 116 LIBGOBLIN_DWARF_ABBREV_EXTERN
 117 int
 118         LibGoblin_DwarfAbbrev_GetItems(
 119                 int             *pi_filenum,
 120                 int             *pi_abbrevs,
 121                 LibGoblin_BinaryInfo    *p_bin )
 122 {
 123         Byte    *pb_data;
 124         Byte    b_children;
 125         QWord   qw_temp;
 126         QWord   qw_size_abbrev;
 127         DWord   dw_abbrev_num;
 128         DWord   dw_tag;
 129         DWord   dw_attribute;
 130         DWord   dw_format;
 131         LibGoblin_Debug_Dwarf           *p_dwarf;
 132
 133         assert( NULL != p_bin );
 134
 135         p_dwarf = (LibGoblin_Debug_Dwarf *)p_bin->p_debug;
 136         assert( NULL != p_dwarf );
 137
 138         /* Get .debug_abbrev section Info */
 139         pb_data = LibGoblin_Elf_GetSection(
 140                                         &qw_size_abbrev, p_bin, 0,
 141                                         LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
 142         if( NULL == pb_data )   { return 0x01; }
 143
 144         *pi_filenum     = 0;
 145         *pi_abbrevs     = 0;
 146
 147         do      {
 148                 (*pi_abbrevs)++;
 149
 150                 /* Read Abbrev Number */
 151                 pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 152                                         &qw_temp, pb_data, &qw_size_abbrev );
 153                 dw_abbrev_num   = (DWord)qw_temp;
 154
 155                 /* Read TAG */
 156                 pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 157                                         &qw_temp, pb_data, &qw_size_abbrev );
 158                 dw_tag  = (DWord)qw_temp;
 159                 if( DW_TAG_compile_unit == dw_tag )             {
 160                         (*pi_filenum)++;
 161                 }
 162
 163                 /* Read IsChildren */
 164                 b_children      = *pb_data++;
 165                 qw_size_abbrev--;
 166
 167                 do      {
 168                         /* Read Attribute */
 169                         pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 170                                                 &qw_temp, pb_data, &qw_size_abbrev );
 171                         dw_attribute    = (DWord)qw_temp;
 172
 173                         /* Read Format */
 174                         pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 175                                                 &qw_temp, pb_data, &qw_size_abbrev );
 176                         dw_format       = (DWord)qw_temp;
 177
 178                 }while((0x00 != dw_attribute) && (0x00 != dw_format)
 179                                         && (qw_size_abbrev > 0) );
 180
 181                 /* Skip Byte for Next Compile-Unit Abbrev. */
 182                 if( 0x00 == *pb_data )  {
 183                         pb_data++;
 184                         qw_size_abbrev--;
 185                 }
 186
 187         }while((qw_size_abbrev > 0) && (dw_tag != 0x00));
 188
 189         return 0x00;
 190 }
 191
 192
 193 /*----------------------------------------------------------------------
 194 ----------------------------------------------------------------------*/
 195 LIBGOBLIN_DWARF_ABBREV_EXTERN
 196 int
 197         LibGoblin_DwarfAbbrev_Read(
 198                 LibGoblin_BinaryInfo    *p_bin,
 199                 int                                             i_abbrevs )
 200 {
 201         Byte    *pb_data;
 202         Byte    b_children;
 203         QWord   qw_temp;
 204         QWord   qw_size_abbrev;
 205         QWord   qw_remain;
 206         DWord   dw_abbrev_num;
 207         DWord   dw_tag;
 208         DWord   dw_attribute;
 209         DWord   dw_format;
 210         LibGoblin_Dwarf_AbbrevInfo      *p_abbrev;
 211         LibGoblin_Dwarf_SourceFile      *p_src;
 212         LibGoblin_Dwarf_SourceFile      *p_nowsrc;
 213         LibGoblin_Debug_Dwarf           *p_dwarf;
 214
 215         assert( NULL != p_bin );
 216
 217         p_dwarf = (LibGoblin_Debug_Dwarf *)p_bin->p_debug;
 218         assert( NULL != p_dwarf );
 219
 220         p_src   = p_dwarf->p_src;
 221         assert( NULL != p_src );
 222
 223         /* Get .debug_abbrev section Info */
 224         pb_data = LibGoblin_Elf_GetSection(
 225                                         &qw_size_abbrev, p_bin, 0,
 226                                         LIBGOBLIN_SECTION_ID_DEBUG_ABBREV );
 227         if( NULL == pb_data )   { return 0x01; }
 228
 229         /* Alloc Abbrev Info. for debug_dwarf_info struct */
 230         p_abbrev        = (LibGoblin_Dwarf_AbbrevInfo *)malloc(
 231                                         sizeof(LibGoblin_Dwarf_AbbrevInfo) * i_abbrevs );
 232         if( NULL == p_abbrev )  { return 0x02; }
 233         memset( p_abbrev, 0x00,
 234                                 sizeof(LibGoblin_Dwarf_AbbrevInfo) * i_abbrevs );
 235
 236
 237         do      {
 238                 /* Set Abbrev Data to AbbrevInfo Struct - Phase 1*/
 239                 p_abbrev->pb_pos        = pb_data;
 240                 qw_remain                       = qw_size_abbrev;
 241
 242                 /* Read Abbrev Number */
 243                 pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 244                                         &qw_temp, pb_data, &qw_remain );
 245                 dw_abbrev_num   = (DWord)qw_temp;
 246
 247                 /* Read TAG */
 248                 pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 249                                         &qw_temp, pb_data, &qw_remain );
 250                 dw_tag  = (DWord)qw_temp;
 251
 252                 /* Read IsChildren */
 253                 b_children      = *pb_data++;
 254                 qw_remain--;
 255
 256                 /* Set Abbrev Data to AbbrevInfo Struct */
 257                 p_abbrev->dw_tag        = dw_tag;
 258                 p_abbrev->dw_id         = dw_abbrev_num;
 259
 260                 if( DW_TAG_compile_unit == dw_tag )             {
 261                         p_nowsrc        = p_src++;
 262                         p_nowsrc->p_abbrev_info = p_abbrev;
 263                 }
 264
 265                 /*printf("%04x : TAG=%04x (Children=%x) %ld\n",
 266                                         dw_abbrev_num, dw_tag, b_children, qw_size_abbrev);*/
 267
 268                 do      {
 269                         /* Read Attribute */
 270                         pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 271                                                 &qw_temp, pb_data, &qw_remain );
 272                         dw_attribute    = (DWord)qw_temp;
 273
 274                         /* Read Format */
 275                         pb_data = LibGoblin_DwarfCommon_Decode_ULEB128(
 276                                                 &qw_temp, pb_data, &qw_remain );
 277                         dw_format       = (DWord)qw_temp;
 278
 279                         /*printf("    Attiribute=%02x Format=%02x\n",
 280                                                 dw_attribute, dw_format);*/
 281
 282                 }while((0x00 != dw_attribute) && (0x00 != dw_format)
 283                                         && (qw_remain > 0) );
 284
 285                 p_abbrev->w_size        = (Word)(qw_size_abbrev - qw_remain);
 286                 p_abbrev++;
 287
 288                 /* Skip Byte for Next Compile-Unit Abbrev. */
 289                 if( 0x00 == *pb_data )  {
 290                         pb_data++;
 291                         qw_remain--;
 292                 }
 293
 294         }while((qw_remain > 0) && (dw_tag != 0x00));
 295
 296         return 0x00;
 297 }
 298
 299
 300
 301 /* EOF of drd64_.c ----------------------------------- */