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