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 /*
 119 LIBGOBLIN_DWARF_COMMON_EXTERN
 120 Byte *
 121         LibGoblin_DwarfCommon_Read_CUHeader(
 122                 LibGoblin_DwarfCommon_CUHeader  *p_cuhead,
 123                 Byte    *pb_data,
 124                 QWord   qw_size_info )
 125 {
 126         int             i_bitflag;
 127         int             i_readbytes;
 128         DWord   dw_dword;
 129         QWord   qw_qword;
 130
 131         assert( NULL != p_cuhead );
 132         assert( NULL != pb_data );
 133
 134         i_readbytes     = 0;
 135         i_bitflag       = 32;
 136
 137         //   Read unit_length (4Byte + 8Byte(64bit))
 138         pb_data = LibGoblin_DwarfCommon_Read_DWord(
 139                                 &dw_dword, pb_data, &qw_size_info );
 140         if( NULL == pb_data )   { return NULL; }
 141
 142         if( ((DWord)0xffffffff) == dw_dword )   {
 143                 pb_data = LibGoblin_DwarfCommon_Read_QWord(
 144                                         &qw_qword, pb_data, &qw_size_info );
 145                 if( NULL == pb_data )   { return NULL; }
 146
 147                 p_cuhead->qw_unitsize   = (QWord)qw_qword;
 148                 i_bitflag                               = 64;
 149                 p_cuhead->b_bits                = 64;
 150         }
 151         else    {
 152                 p_cuhead->qw_unitsize   = (QWord)dw_dword;
 153                 p_cuhead->b_bits                = 32;
 154         }
 155
 156         //  Read version (2Byte)
 157         pb_data = LibGoblin_DwarfCommon_Read_Word(
 158                                 &(p_cuhead->w_version), pb_data, &qw_size_info );
 159         if( NULL == pb_data )   { return NULL; }
 160         i_readbytes     = 2;
 161
 162         //  Read abbrev_offset (4Byte(32bit), 8Byte(64bit))
 163         if( 64 == i_bitflag )   {
 164                 pb_data = LibGoblin_DwarfCommon_Read_QWord(
 165                                         &qw_qword, pb_data, &qw_size_info );
 166                 if( NULL == pb_data )   { return NULL; }
 167                 i_readbytes     += 8;
 168
 169                 p_cuhead->qw_abbrev_offset      = qw_qword;
 170         }
 171         else    {
 172                 pb_data = LibGoblin_DwarfCommon_Read_DWord(
 173                                         &dw_dword, pb_data, &qw_size_info );
 174                 if( NULL == pb_data )   { return NULL; }
 175                 i_readbytes     += 4;
 176
 177                 p_cuhead->qw_abbrev_offset      = (QWord)dw_dword;
 178         }
 179
 180         //  Read address_size (1Byte)
 181         pb_data = LibGoblin_DwarfCommon_Read_Byte(
 182                                 &(p_cuhead->b_pointersize), pb_data, &qw_size_info);
 183         if( NULL == pb_data )   { return NULL; }
 184         i_readbytes     += 1;
 185
 186         p_cuhead->qw_unitsize   -= i_readbytes;
 187
 188         return pb_data;
 189 }
 190 */
 191
 192 /*----------------------------------------------------------------------
 193 ----------------------------------------------------------------------*/
 194 LIBGOBLIN_DWARF_COMMON_EXTERN
 195 Byte *
 196         DWARF_Common_DecodeULEB128(
 197                 QWord   *qw_result,
 198                 Byte    *pb_data,
 199                 QWord   *pqw_remain )
 200 {
 201         Byte    b_value;
 202         int             i_shift;
 203
 204         *qw_result      = 0x00;
 205         i_shift         = 0;
 206         b_value         = 0x80;
 207         while( (0x00 != (b_value & 0x80)) && (0 < *pqw_remain) )        {
 208                 b_value         = *pb_data++;
 209                 *qw_result      = *qw_result | ((QWord)(b_value & 0x7f) << i_shift);
 210                 (*pqw_remain)--;
 211                 i_shift         += 7;
 212         }
 213
 214         return  pb_data;
 215 }
 216
 217
 218 /*----------------------------------------------------------------------
 219 ----------------------------------------------------------------------*/
 220 LIBGOBLIN_DWARF_COMMON_EXTERN
 221 Byte *
 222         DWARF_Common_DecodeLEB128(
 223                 Int64   *ii_result,
 224                 Byte    *pb_data,
 225                 QWord   *pqw_remain )
 226 {
 227         Byte    b_value;
 228         int             i_shift;
 229
 230         *ii_result      = 0x00;
 231         i_shift         = 0;
 232         b_value         = 0x80;
 233         while( (0x00 != (b_value & 0x80)) && (0 < *pqw_remain) )        {
 234                 b_value         = *pb_data++;
 235                 *ii_result      = *ii_result | ((Int64)(b_value & 0x7f) << i_shift);
 236                 (*pqw_remain)--;
 237                 i_shift         += 7;
 238         }
 239
 240         if((i_shift < 64) && ( 0x00 != (b_value & 0x40)))       {
 241                 *ii_result      |= -1 * (0x01 << i_shift);
 242         }
 243
 244         return  pb_data;
 245 }
 246
 247
 248 /* EOF of drd64_.c ----------------------------------- */