libgoblin/drd64_libgoblin_dwarf_common.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_COMMON
  38 #include"drd64_libgoblin.h"
  39
  40 /*----------------------------------------------------------------------
  41 ----------------------------------------------------------------------*/
  42 LIBGOBLIN_DWARF_COMMON_EXTERN
  43 Byte *
  44         LibGoblin_DwarfCommon_Read_Byte(
  45                 Byte    *pb_value,
  46                 Byte    *pb_src,
  47                 QWord   *pqw_size )
  48 {
  49         if( 1 > *pqw_size )             { return NULL; }
  50
  51         *pb_value       = *(pb_src);
  52         pb_src          += 1;
  53         *pqw_size       -= 1;
  54
  55         return pb_src;
  56 }
  57
  58
  59 /*----------------------------------------------------------------------
  60 ----------------------------------------------------------------------*/
  61 LIBGOBLIN_DWARF_COMMON_EXTERN
  62 Byte *
  63         LibGoblin_DwarfCommon_Read_Word(
  64                 Word    *pw_value,
  65                 Byte    *pb_src,
  66                 QWord   *pqw_size )
  67 {
  68         if( 2 > *pqw_size )             { return NULL; }
  69
  70         *pw_value       = *((Word *)pb_src);
  71         pb_src          += 2;
  72         *pqw_size       -= 2;
  73
  74         return pb_src;
  75 }
  76
  77
  78 /*----------------------------------------------------------------------
  79 ----------------------------------------------------------------------*/
  80 LIBGOBLIN_DWARF_COMMON_EXTERN
  81 Byte *
  82         LibGoblin_DwarfCommon_Read_DWord(
  83                 DWord   *pdw_value,
  84                 Byte    *pb_src,
  85                 QWord   *pqw_size )
  86 {
  87         if( 4 > *pqw_size )             { return NULL; }
  88
  89         *pdw_value      = *((DWord *)pb_src);
  90         pb_src          += 4;
  91         *pqw_size       -= 4;
  92
  93         return pb_src;
  94 }
  95
  96
  97 /*----------------------------------------------------------------------
  98 ----------------------------------------------------------------------*/
  99 LIBGOBLIN_DWARF_COMMON_EXTERN
 100 Byte *
 101         LibGoblin_DwarfCommon_Read_QWord(
 102                 QWord   *pqw_value,
 103                 Byte    *pb_src,
 104                 QWord   *pqw_size )
 105 {
 106         if( 8 > *pqw_size )             { return NULL; }
 107
 108         *pqw_value      = *((QWord *)pb_src);
 109         pb_src          += 8;
 110         *pqw_size       -= 8;
 111
 112         return pb_src;
 113 }
 114
 115
 116 /*----------------------------------------------------------------------
 117 ----------------------------------------------------------------------*/
 118 LIBGOBLIN_DWARF_COMMON_EXTERN
 119 Byte *
 120         LibGoblin_DwarfCommon_Read_CUHeader(
 121                 LibGoblin_DwarfCommon_CUHeader  *p_cuhead,
 122                 Byte    *pb_data,
 123                 QWord   qw_size_info )
 124 {
 125         int             i_bitflag;
 126         int             i_readbytes;
 127         DWord   dw_dword;
 128         QWord   qw_qword;
 129
 130         assert( NULL != p_cuhead );
 131         assert( NULL != pb_data );
 132
 133         i_readbytes     = 0;
 134         i_bitflag       = 32;
 135
 136         /*   Read unit_length (4Byte + 8Byte(64bit)) */
 137         pb_data = LibGoblin_DwarfCommon_Read_DWord(
 138                                 &dw_dword, pb_data, &qw_size_info );
 139         if( NULL == pb_data )   { return NULL; }
 140
 141         if( ((DWord)0xffffffff) == dw_dword )   {
 142                 pb_data = LibGoblin_DwarfCommon_Read_QWord(
 143                                         &qw_qword, pb_data, &qw_size_info );
 144                 if( NULL == pb_data )   { return NULL; }
 145
 146                 p_cuhead->qw_unitsize   = (QWord)qw_qword;
 147                 i_bitflag                               = 64;
 148                 p_cuhead->b_bits                = 64;
 149         }
 150         else    {
 151                 p_cuhead->qw_unitsize   = (QWord)dw_dword;
 152                 p_cuhead->b_bits                = 32;
 153         }
 154
 155         /*   Read version (2Byte) */
 156         pb_data = LibGoblin_DwarfCommon_Read_Word(
 157                                 &(p_cuhead->w_version), pb_data, &qw_size_info );
 158         if( NULL == pb_data )   { return NULL; }
 159         i_readbytes     = 2;
 160
 161         /*   Read abbrev_offset (4Byte(32bit), 8Byte(64bit)) */
 162         if( 64 == i_bitflag )   {
 163                 pb_data = LibGoblin_DwarfCommon_Read_QWord(
 164                                         &qw_qword, pb_data, &qw_size_info );
 165                 if( NULL == pb_data )   { return NULL; }
 166                 i_readbytes     += 8;
 167
 168                 p_cuhead->qw_abbrev_offset      = qw_qword;
 169         }
 170         else    {
 171                 pb_data = LibGoblin_DwarfCommon_Read_DWord(
 172                                         &dw_dword, pb_data, &qw_size_info );
 173                 if( NULL == pb_data )   { return NULL; }
 174                 i_readbytes     += 4;
 175
 176                 p_cuhead->qw_abbrev_offset      = (QWord)dw_dword;
 177         }
 178
 179         /*   Read address_size (1Byte) */
 180         pb_data = LibGoblin_DwarfCommon_Read_Byte(
 181                                 &(p_cuhead->b_pointersize), pb_data, &qw_size_info);
 182         if( NULL == pb_data )   { return NULL; }
 183         i_readbytes     += 1;
 184
 185         p_cuhead->qw_unitsize   -= i_readbytes;
 186
 187         return pb_data;
 188 }
 189
 190
 191 /*----------------------------------------------------------------------
 192 ----------------------------------------------------------------------*/
 193 LIBGOBLIN_DWARF_COMMON_EXTERN
 194 Byte *
 195         LibGoblin_DwarfCommon_Decode_ULEB128(
 196                 QWord   *qw_result,
 197                 Byte    *pb_data,
 198                 QWord   *pqw_remain )
 199 {
 200         Byte    b_value;
 201         int             i_shift;
 202
 203         *qw_result      = 0x00;
 204         i_shift         = 0;
 205         b_value         = 0x80;
 206         while( (0x00 != (b_value & 0x80)) && (0 < *pqw_remain) )        {
 207                 b_value         = *pb_data++;
 208                 *qw_result      = *qw_result | ((QWord)(b_value & 0x7f) << i_shift);
 209                 (*pqw_remain)--;
 210                 i_shift         += 7;
 211         }
 212
 213         return  pb_data;
 214 }
 215
 216
 217 /*----------------------------------------------------------------------
 218 ----------------------------------------------------------------------*/
 219 LIBGOBLIN_DWARF_COMMON_EXTERN
 220 Byte *
 221         LibGoblin_DwarfCommon_Decode_LEB128(
 222                 Int64   *ii_result,
 223                 Byte    *pb_data,
 224                 QWord   *pqw_remain )
 225 {
 226         Byte    b_value;
 227         int             i_shift;
 228
 229         *ii_result      = 0x00;
 230         i_shift         = 0;
 231         b_value         = 0x80;
 232         while( (0x00 != (b_value & 0x80)) && (0 < *pqw_remain) )        {
 233                 b_value         = *pb_data++;
 234                 *ii_result      = *ii_result | ((Int64)(b_value & 0x7f) << i_shift);
 235                 (*pqw_remain)--;
 236                 i_shift         += 7;
 237         }
 238
 239         if((i_shift < 64) && ( 0x00 != (b_value & 0x40)))       {
 240                 *ii_result      |= -1 * (0x01 << i_shift);
 241         }
 242
 243         return  pb_data;
 244 }
 245
 246
 247 /* EOF of drd64_.c ----------------------------------- */