libgoblin/drd64_libgoblin_dwarf_expression.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_EXPRESSION
  38 #include"drd64_libgoblin.h"
  39
  40 /*----------------------------------------------------------------------
  41 ----------------------------------------------------------------------*/
  42 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
  43 void
  44         DWARF_Expression_ClearValue(
  45                         LibGoblin_DWARF_Expression      *p_exp )
  46 {
  47         int             i_id;
  48         LibGoblin_DWARF_Expression      *p_next;
  49
  50         assert( NULL != p_exp );
  51
  52         i_id                            = p_exp->i_id;
  53         p_next                          = p_exp->p_next;
  54         memset( p_exp, 0x00, sizeof( LibGoblin_DWARF_Expression ) );
  55         p_exp->i_id                     = i_id;
  56         p_exp->p_next           = p_next;
  57
  58         p_exp->dw_status        = LIBGOBLIN_DWARF_STATUS_NOTEVALUATE;
  59         p_exp->dw_depth         = 0;
  60
  61         return;
  62 }
  63
  64
  65 /*----------------------------------------------------------------------
  66 ----------------------------------------------------------------------*/
  67 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
  68 int
  69         DWARF_Expression_SetDefaultValue(
  70                         LibGoblin_DWARF_Expression      *p_exp,
  71                         LibGoblin_BinaryInfo            *p_binfo )
  72 {
  73         if( NULL == p_exp )     {
  74                 return -0x01;
  75         }
  76
  77         if( NULL == p_binfo )   {
  78                 return -0x02;
  79         }
  80
  81         p_exp->dw_setdata       = LIBGOBLIN_DWARF_REQUEST_NONE;
  82
  83         if( LIBGOBLIN_BINFO_TYPE_ELF32 == p_binfo->b_type )
  84                 { p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_ADDRSIZE ]  = 4; }
  85         else    // LIBGOBLIN_BINFO_TYPE_ELF64
  86                 { p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_ADDRSIZE ]  = 8; }
  87         p_exp->dw_setdata       |= LIBGOBLIN_DWARF_REQUEST_ADDRSIZE;
  88
  89         return 0x00;
  90 }
  91
  92
  93 /*----------------------------------------------------------------------
  94 ----------------------------------------------------------------------*/
  95 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
  96 DWord
  97         DWARF_Expression_Evaluate(
  98                         LibGoblin_DWARF_Expression      *p_exp,
  99                         Byte    *pb_data,
 100                         DWord   dw_size )
 101 {
 102         Byte    b_opcode;
 103         Byte    b_value;
 104         Byte    b_reg;
 105         Byte    *pb_resume;
 106         Byte    *pb_skip;
 107         Byte    *pb_now;
 108         short   s_value;
 109         Word    w_value;
 110         DWord   dw_depth_resume;
 111         DWord   dw_value;
 112         DWord   dw_bitoffset;
 113         QWord   qw_resume;
 114         QWord   qw_remain;
 115         QWord   qw_value;
 116         QWord   qw_temp;
 117         QWord   qw_pop[4];
 118         Int64   ii_value;
 119         Int64   ii_temp;
 120
 121 #define PUSH_DWARF(m,n) \
 122                 { (m)->t_stack[(m)->dw_depth].value.qw_value = (n); \
 123                   (m)->t_stack[(m)->dw_depth].b_flag = LIBGOBLIN_DWARF_FLAG_LOCATION; \
 124                   (m)->dw_depth++; }
 125 #define PUSH_DWARF_SIGN(m,n)    \
 126                 { (m)->t_stack[(m)->dw_depth].value.ii_value = (n); \
 127                   (m)->t_stack[(m)->dw_depth].b_flag \
 128                         = (LIBGOBLIN_DWARF_FLAG_SIGN | LIBGOBLIN_DWARF_FLAG_LOCATION); \
 129                   (m)->dw_depth++; }
 130 #define POP_DWARF(m)            (m)->t_stack[--((m)->dw_depth)].value.qw_value
 131 #define POP_DWARF_SIGN(m)       (m)->t_stack[--((m)->dw_depth)].value.ii_value
 132
 133         // ------------------------
 134         if( NULL == p_exp )     {
 135                 return  (LIBGOBLIN_DWARF_STATUS_ERROR | 0x01);
 136         }
 137
 138         if( NULL == pb_data )   {
 139                 return  (LIBGOBLIN_DWARF_STATUS_ERROR | 0x01);
 140         }
 141
 142         if( 0 == dw_size )      {
 143                 return  (LIBGOBLIN_DWARF_STATUS_ERROR | 0x02);
 144         }
 145
 146         if( 0 == p_exp->b_dwsize )      { p_exp->b_dwsize       = 8; }
 147
 148         // ------------------------
 149         if( NULL != p_exp->resume.pb_resume )   {
 150                 // XXX Position Check!!
 151                 pb_now          = p_exp->resume.pb_resume;
 152                 qw_remain       = p_exp->resume.qw_remain;
 153
 154                 p_exp->resume.pb_resume = NULL;
 155                 p_exp->resume.qw_remain = 0;
 156         }
 157         else if( LIBGOBLIN_DWARF_STATUS_RETCALL == p_exp->dw_status )   {
 158                 // XXX Position Check!!
 159                 if( 0 == p_exp->b_callers )
 160                         { goto  goto_DWARF_Expression_Evaluate_post; }
 161
 162                 p_exp->b_callers--;
 163
 164                 assert(  NULL != p_exp->caller[ p_exp->b_callers ].pb_return );
 165                 pb_now          = p_exp->caller[ p_exp->b_callers ].pb_return;
 166                 qw_remain       = p_exp->caller[ p_exp->b_callers ].qw_retremain;
 167
 168                 p_exp->caller[ p_exp->b_callers ].pb_return             = NULL;
 169                 p_exp->caller[ p_exp->b_callers ].qw_retremain  = 0;
 170         }
 171         else    {
 172                 pb_now                                  = pb_data;
 173                 qw_remain                               = (QWord)dw_size;
 174
 175                 if( 0 == p_exp->b_callers )     {
 176                         p_exp->dw_depth                 = 0;
 177                         memset( &((p_exp)->t_stack), 0x00,
 178                                 sizeof( LibGoblin_DWARF_Expression_Stack ) * LIBGOBLIN_DWARF_EXPRESSION_STACK_DEPTH );
 179                 }
 180         }
 181         qw_value                                = 0x00000000;
 182         dw_bitoffset                    = 0;
 183         p_exp->dw_requested             = LIBGOBLIN_DWARF_REQUEST_NONE;
 184         p_exp->dw_status                = LIBGOBLIN_DWARF_STATUS_ERROR;
 185         if( LIBGOBLIN_DWARF_REQUEST_NONE != p_exp->dw_setdata )
 186                 { p_exp->dw_reqsize             = 0; }
 187
 188         do      {
 189                 pb_resume               = pb_now;
 190                 qw_resume               = qw_remain;
 191                 dw_depth_resume = p_exp->dw_depth;
 192
 193                 b_opcode        = *pb_now++;
 194                 qw_remain--;
 195
 196                 switch( b_opcode )      {
 197                         // Constant Opcodes ----
 198                         case DW_OP_lit0:                                // 0x30
 199                         case DW_OP_lit1:                                // 0x31
 200                         case DW_OP_lit2:                                // 0x32
 201                         case DW_OP_lit3:                                // 0x33
 202                         case DW_OP_lit4:                                // 0x34
 203                         case DW_OP_lit5:                                // 0x35
 204                         case DW_OP_lit6:                                // 0x36
 205                         case DW_OP_lit7:                                // 0x37
 206                         case DW_OP_lit8:                                // 0x38
 207                         case DW_OP_lit9:                                // 0x39
 208                         case DW_OP_lit10:                               // 0x3a
 209                         case DW_OP_lit11:                               // 0x3b
 210                         case DW_OP_lit12:                               // 0x3c
 211                         case DW_OP_lit13:                               // 0x3d
 212                         case DW_OP_lit14:                               // 0x3e
 213                         case DW_OP_lit15:                               // 0x3f
 214                         case DW_OP_lit16:                               // 0x40
 215                         case DW_OP_lit17:                               // 0x41
 216                         case DW_OP_lit18:                               // 0x42
 217                         case DW_OP_lit19:                               // 0x43
 218                         case DW_OP_lit20:                               // 0x44
 219                         case DW_OP_lit21:                               // 0x45
 220                         case DW_OP_lit22:                               // 0x46
 221                         case DW_OP_lit23:                               // 0x47
 222                         case DW_OP_lit24:                               // 0x48
 223                         case DW_OP_lit25:                               // 0x49
 224                         case DW_OP_lit26:                               // 0x4a
 225                         case DW_OP_lit27:                               // 0x4b
 226                         case DW_OP_lit28:                               // 0x4c
 227                         case DW_OP_lit29:                               // 0x4d
 228                         case DW_OP_lit30:                               // 0x4e
 229                         case DW_OP_lit31:                               // 0x4f
 230                                 b_value = b_opcode - DW_OP_lit0;
 231                                 PUSH_DWARF( p_exp, (QWord)b_value );
 232                                 break;
 233
 234                         case DW_OP_addr:                                // 0x03
 235                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_ADDRSIZE )      {
 236                                         PUSH_DWARF( p_exp,  p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_ADDRSIZE ] );
 237                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_ADDRSIZE);
 238                                 }
 239                                 else    {
 240                                         p_exp->dw_requested |= LIBGOBLIN_DWARF_REQUEST_ADDRSIZE;
 241                                         qw_remain       = 0;    // for Loop-Break
 242                                 }
 243                                 break;
 244
 245                         case DW_OP_const1u:                             // 0x08
 246                                 if( 1 > qw_remain )
 247                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 248                                 qw_value        = (QWord)*pb_now++;
 249                                 qw_remain--;
 250                                 PUSH_DWARF( p_exp, qw_value );
 251                                 break;
 252                         case DW_OP_const1s:                             // 0x09
 253                                 if( 1 > qw_remain )
 254                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 255                                 ii_value        = (Int64)*((char *)pb_now);
 256                                 pb_now++;
 257                                 qw_remain--;
 258                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 259                                 break;
 260                         case DW_OP_const2u:                             // 0x0a
 261                                 if( 2 > qw_remain )
 262                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 263                                 qw_value        = (QWord)*((Word *)pb_now);
 264                                 pb_now          += 2;
 265                                 qw_remain       -= 2;
 266                                 PUSH_DWARF( p_exp, qw_value );
 267                                 break;
 268                         case DW_OP_const2s:                             // 0x0b
 269                                 if( 2 > qw_remain )
 270                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 271                                 ii_value        = (Int64)*((short *)pb_now);
 272                                 pb_now          += 2;
 273                                 qw_remain       -= 2;
 274                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 275                                 break;
 276                         case DW_OP_const4u:                             // 0x0c
 277                                 if( 4 > qw_remain )
 278                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 279                                 qw_value        = (QWord)*((DWord *)pb_now);
 280                                 pb_now          += 4;
 281                                 qw_remain       -= 4;
 282                                 PUSH_DWARF( p_exp, qw_value );
 283                                 break;
 284                         case DW_OP_const4s:                             // 0x0d
 285                                 if( 4 > qw_remain )
 286                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 287                                 ii_value        = (Int64)*((int *)pb_now);
 288                                 pb_now          += 4;
 289                                 qw_remain       -= 4;
 290                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 291                                 break;
 292                         case DW_OP_const8u:                             // 0x0e
 293                                 if( 8 > qw_remain )
 294                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 295                                 qw_value        = (QWord)*((QWord *)pb_now);
 296                                 pb_now          += 8;
 297                                 qw_remain       -= 8;
 298                                 PUSH_DWARF( p_exp, qw_value );
 299                                 break;
 300                         case DW_OP_const8s:                             // 0x0f
 301                                 if( 8 > qw_remain )
 302                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 303                                 ii_value        = (Int64)*((Int64 *)pb_now);
 304                                 pb_now          += 8;
 305                                 qw_remain       -= 8;
 306                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 307                                 break;
 308                         case DW_OP_constu:                              // 0x10
 309                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_value, pb_now, &qw_remain );
 310                                 PUSH_DWARF( p_exp, qw_value );
 311                                 break;
 312                         case DW_OP_consts:                              // 0x11
 313                                 pb_now  = DWARF_Common_DecodeLEB128( &ii_value, pb_now, &qw_remain );
 314                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 315                                 break;
 316
 317                         // Register-Base Opcodes ----
 318                         case DW_OP_fbreg:                               // 0x91
 319                                 pb_now  = DWARF_Common_DecodeLEB128( &ii_value, pb_now, &qw_remain );
 320                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_FRAME_BASE )    {
 321
 322                                         if( 0 > ii_value )      {
 323                                                 qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_FRAME_BASE ]
 324                                                                                         - (QWord)(-1 * ii_value);
 325                                         }
 326                                         else    {
 327                                                 qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_FRAME_BASE ]
 328                                                                                         + (QWord)ii_value;
 329                                         }
 330
 331                                         PUSH_DWARF( p_exp, qw_value );
 332                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_FRAME_BASE);
 333                                 }
 334                                 else    {
 335                                         p_exp->dw_requested |= LIBGOBLIN_DWARF_REQUEST_FRAME_BASE;
 336                                         qw_remain       = 0;    // for Loop-Break
 337                                 }
 338                                 break;
 339                         case DW_OP_breg0:                               // 0x70
 340                         case DW_OP_breg1:                               // 0x71
 341                         case DW_OP_breg2:                               // 0x72
 342                         case DW_OP_breg3:                               // 0x73
 343                         case DW_OP_breg4:                               // 0x74
 344                         case DW_OP_breg5:                               // 0x75
 345                         case DW_OP_breg6:                               // 0x76
 346                         case DW_OP_breg7:                               // 0x77
 347                         case DW_OP_breg8:                               // 0x78
 348                         case DW_OP_breg9:                               // 0x79
 349                         case DW_OP_breg10:                              // 0x7a
 350                         case DW_OP_breg11:                              // 0x7b
 351                         case DW_OP_breg12:                              // 0x7c
 352                         case DW_OP_breg13:                              // 0x7d
 353                         case DW_OP_breg14:                              // 0x7e
 354                         case DW_OP_breg15:                              // 0x7f
 355                         case DW_OP_breg16:                              // 0x80
 356                         case DW_OP_breg17:                              // 0x81
 357                         case DW_OP_breg18:                              // 0x82
 358                         case DW_OP_breg19:                              // 0x83
 359                         case DW_OP_breg20:                              // 0x84
 360                         case DW_OP_breg21:                              // 0x85
 361                         case DW_OP_breg22:                              // 0x86
 362                         case DW_OP_breg23:                              // 0x87
 363                         case DW_OP_breg24:                              // 0x88
 364                         case DW_OP_breg25:                              // 0x89
 365                         case DW_OP_breg26:                              // 0x8a
 366                         case DW_OP_breg27:                              // 0x8b
 367                         case DW_OP_breg28:                              // 0x8c
 368                         case DW_OP_breg29:                              // 0x8d
 369                         case DW_OP_breg30:                              // 0x8e
 370                         case DW_OP_breg31:                              // 0x8f
 371                                 b_reg   = b_opcode - DW_OP_breg0;
 372                                 pb_now  = DWARF_Common_DecodeLEB128( &ii_value, pb_now, &qw_remain );
 373
 374                                 if( p_exp->dw_setdata & (LIBGOBLIN_DWARF_REQUEST_REG | b_reg) ) {
 375                                         if( 0 > ii_value )
 376                                                 { qw_value      = p_exp->qw_reqdata[b_reg] - (QWord)(-1 * ii_value); }
 377                                         else
 378                                                 { qw_value      = p_exp->qw_reqdata[b_reg] + (QWord)ii_value; }
 379
 380                                         PUSH_DWARF( p_exp, qw_value );
 381                                         p_exp->dw_setdata       &= (~(LIBGOBLIN_DWARF_REQUEST_REG | b_reg));
 382                                 }
 383                                 else    {
 384                                         p_exp->dw_requested |= (LIBGOBLIN_DWARF_REQUEST_REG | b_reg);
 385                                         qw_remain       = 0;    // for Loop-Break
 386                                 }
 387                                 break;
 388                         case DW_OP_bregx:                               // 0x92
 389                                 // Get RegID
 390                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_value, pb_now, &qw_remain );
 391                                 p_exp->dw_regid = (DWord)(qw_value & 0xffffffff);
 392
 393                                 // Get Offset
 394                                 pb_now  = DWARF_Common_DecodeLEB128( &ii_value, pb_now, &qw_remain );
 395
 396                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_REGX )  {
 397                                         if( 0 > ii_value )
 398                                                 { qw_value      = p_exp->qw_reqdata[LIBGOBLIN_DWARF_DATAID_REGX]
 399                                                                                                         - (QWord)(-1 * ii_value); }
 400                                         else
 401                                                 { qw_value      = p_exp->qw_reqdata[LIBGOBLIN_DWARF_DATAID_REGX]
 402                                                                                                         + (QWord)ii_value; }
 403
 404                                         PUSH_DWARF( p_exp, qw_value );
 405                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_REGX);
 406                                 }
 407                                 else    {
 408                                         p_exp->dw_requested |= LIBGOBLIN_DWARF_REQUEST_REGX;
 409                                         qw_remain       = 0;    // for Loop-Break
 410                                 }
 411                                 break;
 412
 413
 414                         // Stack Opcodes ----
 415                         case DW_OP_dup:                                 // 0x12
 416                                 if( 0 == p_exp->dw_depth )
 417                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 418
 419                                 qw_value        = p_exp->t_stack[p_exp->dw_depth - 1].value.qw_value;
 420                                 PUSH_DWARF( p_exp, qw_value );
 421                                 break;
 422                         case DW_OP_drop:                                // 0x13
 423                                 if( 0 == p_exp->dw_depth )
 424                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 425                                 qw_pop[0]       = POP_DWARF( p_exp );
 426                                 break;
 427                         case DW_OP_pick:                                // 0x15
 428                                 if( 1 > qw_remain )
 429                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 430                                 b_value = *pb_now++;
 431                                 qw_remain--;
 432
 433                                 if( p_exp->dw_depth <= (DWord)b_value )
 434                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 435
 436                                 dw_value        = p_exp->dw_depth - (DWord)b_value - 1;
 437                                 qw_value        = p_exp->t_stack[dw_value].value.qw_value;
 438                                 PUSH_DWARF( p_exp, qw_value );
 439                                 break;
 440                         case DW_OP_over:                                // 0x14
 441                                 if( 2 > p_exp->dw_depth )
 442                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 443
 444                                 dw_value        = p_exp->dw_depth - 2;
 445                                 qw_value        = p_exp->t_stack[dw_value].value.qw_value;
 446                                 PUSH_DWARF( p_exp, qw_value );
 447                                 break;
 448                         case DW_OP_swap:                                // 0x16
 449                                 if( 2 > p_exp->dw_depth )
 450                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 451                                 qw_value        = p_exp->t_stack[p_exp->dw_depth - 2].value.qw_value;
 452                                 p_exp->t_stack[p_exp->dw_depth - 2].value.qw_value
 453                                                         = p_exp->t_stack[p_exp->dw_depth - 1].value.qw_value;
 454                                 p_exp->t_stack[p_exp->dw_depth - 1].value.qw_value      = qw_value;
 455                                 break;
 456                         case DW_OP_rot:                                 // 0x17
 457                                 if( 3 > p_exp->dw_depth )
 458                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 459                                 qw_value        = p_exp->t_stack[p_exp->dw_depth - 1].value.qw_value;
 460                                 p_exp->t_stack[p_exp->dw_depth - 1].value.qw_value
 461                                                         = p_exp->t_stack[p_exp->dw_depth - 2].value.qw_value;
 462                                 p_exp->t_stack[p_exp->dw_depth - 2].value.qw_value
 463                                                         = p_exp->t_stack[p_exp->dw_depth - 3].value.qw_value;
 464                                 p_exp->t_stack[p_exp->dw_depth - 3].value.qw_value      = qw_value;
 465                                 break;
 466                         case DW_OP_deref:                               // 0x06
 467                                 if( 0 == p_exp->dw_depth )
 468                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 469                                 qw_pop[0]       = POP_DWARF( p_exp );
 470
 471                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_DEREF ) {
 472                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_DEREF ];
 473                                         PUSH_DWARF( p_exp, qw_value );
 474                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_DEREF);
 475                                 }
 476                                 else    {
 477                                         p_exp->ptr_reference.value      = (PtrValue)qw_pop[0];
 478                                         p_exp->dw_requested             |= LIBGOBLIN_DWARF_REQUEST_DEREF;
 479                                         qw_remain       = 0;    // for Loop-Break
 480                                 }
 481                                 break;
 482                         case DW_OP_deref_size:                  // 0x94
 483                                 if( 0 == p_exp->dw_depth )
 484                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 485                                 if( 1 > qw_remain )
 486                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 487                                 qw_pop[0]       = POP_DWARF( p_exp );
 488
 489                                 b_value = *pb_now++;
 490                                 qw_remain--;
 491
 492                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_DEREF ) {
 493                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_DEREF ];
 494                                         PUSH_DWARF( p_exp, qw_value );
 495                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_DEREF);
 496                                 }
 497                                 else    {
 498                                         p_exp->dw_reqsize                       = (DWord)b_value;
 499                                         p_exp->ptr_reference.value      = (PtrValue)qw_pop[0];
 500                                         p_exp->dw_requested             |= LIBGOBLIN_DWARF_REQUEST_DEREF;
 501                                         qw_remain       = 0;    // for Loop-Break
 502                                 }
 503                                 break;
 504                         case DW_OP_xderef:                              // 0x18
 505                                 if( 2 > p_exp->dw_depth )
 506                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 507                                 qw_pop[0]       = POP_DWARF( p_exp );
 508                                 qw_pop[1]       = POP_DWARF( p_exp );
 509
 510                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_XDEREF )        {
 511                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_XDEREF ];
 512                                         PUSH_DWARF( p_exp, qw_value );
 513                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_XDEREF);
 514                                 }
 515                                 else    {
 516                                         p_exp->ptr_reference.value      = (PtrValue)qw_pop[0];
 517                                         p_exp->qw_ident_addrspace       = qw_pop[1];
 518                                         p_exp->dw_requested             |= LIBGOBLIN_DWARF_REQUEST_XDEREF;
 519                                         qw_remain       = 0;    // for Loop-Break
 520                                 }
 521                                 break;
 522                         case DW_OP_xderef_size:                 // 0x95
 523                                 if( 2 > p_exp->dw_depth )
 524                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 525                                 qw_pop[0]       = POP_DWARF( p_exp );
 526                                 qw_pop[1]       = POP_DWARF( p_exp );
 527
 528                                 b_value = *pb_now++;
 529                                 qw_remain--;
 530
 531                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_XDEREF )        {
 532                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_XDEREF ];
 533                                         PUSH_DWARF( p_exp, qw_value );
 534                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_XDEREF);
 535                                 }
 536                                 else    {
 537                                         p_exp->dw_reqsize                       = (DWord)b_value;
 538                                         p_exp->ptr_reference.value      = (PtrValue)qw_pop[0];
 539                                         p_exp->qw_ident_addrspace       = qw_pop[1];
 540                                         p_exp->dw_requested             |= LIBGOBLIN_DWARF_REQUEST_XDEREF;
 541                                         qw_remain       = 0;    // for Loop-Break
 542                                 }
 543                                 break;
 544                         case DW_OP_push_object_address: // 0x97
 545                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_OBJADDR )       {
 546                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_OBJADDR ];
 547                                         PUSH_DWARF( p_exp, qw_value );
 548                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_OBJADDR);
 549                                 }
 550                                 else    {
 551                                         p_exp->dw_requested     |= LIBGOBLIN_DWARF_REQUEST_OBJADDR;
 552                                         qw_remain       = 0;    // for Loop-Break
 553                                 }
 554                                 break;
 555                         case DW_OP_form_tls_address:    // 0x9b
 556                                 if( 1 > p_exp->dw_depth )
 557                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 558                                 qw_pop[0]       = POP_DWARF( p_exp );
 559
 560                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_TLSADDR )       {
 561                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_TLSADDR ];
 562                                         PUSH_DWARF( p_exp, qw_value );
 563                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_TLSADDR);
 564                                 }
 565                                 else    {
 566                                         p_exp->ptr_tlsbase.value        = (PtrValue)qw_pop[0];
 567                                         p_exp->dw_requested                     |= LIBGOBLIN_DWARF_REQUEST_TLSADDR;
 568                                         qw_remain       = 0;    // for Loop-Break
 569                                 }
 570                                 break;
 571                         case DW_OP_call_frame_cfa:              // 0x9c
 572                                 if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_CFAADDR )       {
 573                                         qw_value        = p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_CFAADDR ];
 574                                         PUSH_DWARF( p_exp, qw_value );
 575                                         p_exp->dw_setdata       &= (~LIBGOBLIN_DWARF_REQUEST_CFAADDR);
 576                                 }
 577                                 else    {
 578                                         p_exp->dw_requested     |= LIBGOBLIN_DWARF_REQUEST_CFAADDR;
 579                                         qw_remain       = 0;    // for Loop-Break
 580                                 }
 581                                 break;
 582
 583                         // Arithmetic & Logical Operation ----
 584                         case DW_OP_abs:                                 // 0x19
 585                                 if( 0 == p_exp->dw_depth )
 586                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 587                                 ii_value        = POP_DWARF_SIGN( p_exp );
 588
 589                                 if( LIBGOBLIN_DWARF_FLAG_SIGN & p_exp->t_stack[p_exp->dw_depth].b_flag )        {
 590                                         if( 0 > ii_value )      { ii_value      *= -1; }
 591                                         PUSH_DWARF_SIGN( p_exp, ii_value );
 592                                 }
 593                                 break;
 594
 595                         case DW_OP_and:                                 // 0x1a
 596                                 if( 2 > p_exp->dw_depth )
 597                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 598
 599                                 qw_value        = POP_DWARF( p_exp );
 600                                 qw_temp         = POP_DWARF( p_exp );
 601                                 qw_value        &= qw_temp;
 602                                 PUSH_DWARF( p_exp, qw_value );
 603                                 break;
 604
 605                         case DW_OP_div:                                 // 0x1b
 606                                 if( 2 > p_exp->dw_depth )
 607                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 608
 609                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 610                                 ii_value        = POP_DWARF_SIGN( p_exp );
 611                                 if( 0 == ii_temp )
 612                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 613
 614                                 ii_value        /= ii_temp;
 615                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 616                                 break;
 617
 618                         case DW_OP_minus:                               // 0x1c
 619                                 if( 2 > p_exp->dw_depth )
 620                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 621
 622                                 qw_temp         = POP_DWARF( p_exp );
 623                                 qw_value        = POP_DWARF( p_exp );
 624                                 qw_value        -= qw_temp;
 625                                 PUSH_DWARF( p_exp, qw_value );
 626                                 break;
 627                         case DW_OP_mod:                                 // 0x1d
 628                                 if( 2 > p_exp->dw_depth )
 629                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 630
 631                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 632                                 ii_value        = POP_DWARF_SIGN( p_exp );
 633                                 if( 0 == ii_temp )
 634                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 635
 636                                 ii_value        %= ii_temp;
 637                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 638                                 break;
 639                         case DW_OP_mul:                                 // 0x1e
 640                                 if( 2 > p_exp->dw_depth )
 641                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 642
 643                                 qw_temp         = POP_DWARF( p_exp );
 644                                 qw_value        = POP_DWARF( p_exp );
 645                                 qw_value        *= qw_temp;
 646                                 PUSH_DWARF( p_exp, qw_value );
 647                                 break;
 648                         case DW_OP_neg:                                 // 0x1f
 649                                 if( 1 > p_exp->dw_depth )
 650                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 651
 652                                 ii_value        = POP_DWARF_SIGN( p_exp );
 653                                 ii_value        *= -1;
 654                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 655                                 break;
 656                         case DW_OP_not:                                 // 0x20
 657                                 if( 1 > p_exp->dw_depth )
 658                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 659
 660                                 qw_value        = POP_DWARF( p_exp );
 661                                 qw_value        = ~qw_value;
 662                                 PUSH_DWARF( p_exp, qw_value );
 663                                 break;
 664                         case DW_OP_or:                                  // 0x21
 665                                 if( 2 > p_exp->dw_depth )
 666                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 667
 668                                 qw_value        = POP_DWARF( p_exp );
 669                                 qw_temp         = POP_DWARF( p_exp );
 670                                 qw_value        |= qw_temp;
 671                                 PUSH_DWARF( p_exp, qw_value );
 672                                 break;
 673                         case DW_OP_plus:                                // 0x22
 674                                 if( 2 > p_exp->dw_depth )
 675                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 676
 677                                 qw_temp         = POP_DWARF( p_exp );
 678                                 qw_value        = POP_DWARF( p_exp );
 679                                 qw_value        += qw_temp;
 680                                 PUSH_DWARF( p_exp, qw_value );
 681                                 break;
 682                         case DW_OP_plus_uconst:                 // 0x23
 683                                 if( 1 > p_exp->dw_depth )
 684                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 685
 686                                 qw_value        = POP_DWARF( p_exp );
 687                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_temp, pb_now, &qw_remain );
 688
 689                                 qw_value        += qw_temp;
 690                                 PUSH_DWARF( p_exp, qw_value );
 691                                 break;
 692                         case DW_OP_shl:                                 // 0x24
 693                                 if( 2 > p_exp->dw_depth )
 694                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 695
 696                                 qw_temp         = POP_DWARF( p_exp );
 697                                 qw_value        = POP_DWARF( p_exp );
 698                                 qw_value        <<= qw_temp;
 699                                 PUSH_DWARF( p_exp, qw_value );
 700                                 break;
 701                         case DW_OP_shr:                                 // 0x25
 702                                 if( 2 > p_exp->dw_depth )
 703                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 704
 705                                 qw_temp         = POP_DWARF( p_exp );
 706                                 qw_value        = POP_DWARF( p_exp );
 707                                 qw_value        >>= qw_temp;
 708                                 PUSH_DWARF( p_exp, qw_value );
 709                                 break;
 710                         case DW_OP_shra:                                // 0x26
 711                                 if( 2 > p_exp->dw_depth )
 712                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 713
 714                                 qw_temp         = POP_DWARF( p_exp );
 715                                 ii_value        = POP_DWARF_SIGN( p_exp );
 716                                 ii_value        >>= qw_temp;
 717                                 PUSH_DWARF_SIGN( p_exp, ii_value );
 718                                 break;
 719                         case DW_OP_xor:                                 // 0x27
 720                                 if( 2 > p_exp->dw_depth )
 721                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 722
 723                                 qw_temp         = POP_DWARF( p_exp );
 724                                 qw_value        = POP_DWARF( p_exp );
 725                                 qw_value        ^= qw_temp;
 726                                 PUSH_DWARF( p_exp, qw_value );
 727                                 break;
 728
 729                         // Flow Control Operation ----
 730                         case DW_OP_eq:                                  // 0x29
 731                                 if( 2 > p_exp->dw_depth )
 732                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 733
 734                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 735                                 ii_value        = POP_DWARF_SIGN( p_exp );
 736                                 if( ii_value == ii_temp )       { PUSH_DWARF( p_exp, 0x01 ); }
 737                                 else                                            { PUSH_DWARF( p_exp, 0x00 ); }
 738                                 break;
 739                         case DW_OP_ge:                                  // 0x2a
 740                                 if( 2 > p_exp->dw_depth )
 741                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 742
 743                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 744                                 ii_value        = POP_DWARF_SIGN( p_exp );
 745                                 if( ii_value >= ii_temp )       { PUSH_DWARF( p_exp, 0x01 ); }
 746                                 else                                            { PUSH_DWARF( p_exp, 0x00 ); }
 747                                 break;
 748                         case DW_OP_gt:                                  // 0x2b
 749                                 if( 2 > p_exp->dw_depth )
 750                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 751
 752                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 753                                 ii_value        = POP_DWARF_SIGN( p_exp );
 754                                 if( ii_value > ii_temp )        { PUSH_DWARF( p_exp, 0x01 ); }
 755                                 else                                            { PUSH_DWARF( p_exp, 0x00 ); }
 756                                 break;
 757                         case DW_OP_le:                                  // 0x2c
 758                                 if( 2 > p_exp->dw_depth )
 759                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 760
 761                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 762                                 ii_value        = POP_DWARF_SIGN( p_exp );
 763                                 if( ii_value <= ii_temp )       { PUSH_DWARF( p_exp, 0x01 ); }
 764                                 else                                            { PUSH_DWARF( p_exp, 0x00 ); }
 765                                 break;
 766                         case DW_OP_lt:                                  // 0x2d
 767                                 if( 2 > p_exp->dw_depth )
 768                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 769
 770                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 771                                 ii_value        = POP_DWARF_SIGN( p_exp );
 772                                 if( ii_value < ii_temp )        { PUSH_DWARF( p_exp, 0x01 ); }
 773                                 else                                            { PUSH_DWARF( p_exp, 0x00 ); }
 774                                 break;
 775                         case DW_OP_ne:                                  // 0x2e
 776                                 if( 2 > p_exp->dw_depth )
 777                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 778
 779                                 ii_temp         = POP_DWARF_SIGN( p_exp );
 780                                 ii_value        = POP_DWARF_SIGN( p_exp );
 781                                 if( ii_value != ii_temp )       { PUSH_DWARF( p_exp, 0x01 ); }
 782                                 else                                            { PUSH_DWARF( p_exp, 0x00 ); }
 783                                 break;
 784                         case DW_OP_skip:                                // 0x2f
 785                                 if( 2 > qw_remain )
 786                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 787                                 s_value         = *((short *)pb_now);
 788                                 pb_now          += 2;
 789                                 qw_remain       -= 2;
 790
 791                                 if( 0 > s_value )       {
 792                                         pb_now          -= (-1 * s_value);
 793                                         qw_remain       += (-1 * s_value);
 794                                 }
 795                                 else    {
 796                                         pb_now          += s_value;
 797                                         qw_remain       -= s_value;
 798                                 }
 799                                 break;
 800                         case DW_OP_bra:                                 // 0x28
 801                                 if( 2 > qw_remain )
 802                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 803                                 qw_temp         = POP_DWARF( p_exp );
 804
 805                                 s_value         = *((short *)pb_now);
 806                                 pb_now          += 2;
 807                                 qw_remain       -= 2;
 808
 809                                 if( 0 != qw_temp )      {
 810                                         if( 0 > s_value )       {
 811                                                 pb_now          -= (-1 * s_value);
 812                                                 qw_remain       += (-1 * s_value);
 813                                         }
 814                                         else    {
 815                                                 pb_now          += s_value;
 816                                                 qw_remain       -= s_value;
 817                                         }
 818                                 }
 819                                 break;
 820
 821                         case DW_OP_call2:                               // 0x98
 822                                 if( 2 > qw_remain )
 823                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 824                                 w_value = *((Word *)pb_now);
 825                                 pb_now          += 2;
 826                                 qw_remain       -= 2;
 827
 828                                 p_exp->qw_calloffset    = (QWord)w_value;
 829                                 p_exp->caller[ p_exp->b_callers ].pb_return             = pb_now;
 830                                 p_exp->caller[ p_exp->b_callers ].qw_retremain  = qw_remain;
 831                                 p_exp->b_callers++;
 832                                 p_exp->dw_status        = LIBGOBLIN_DWARF_STATUS_CALLING;
 833
 834                                 goto    goto_DWARF_Expression_Evaluate_post;
 835                                 break;  // NOT reach.
 836                         case DW_OP_call4:                               // 0x99
 837                                 if( 4 > qw_remain )
 838                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 839                                 dw_value        = *((DWord *)pb_now);
 840                                 pb_now          += 4;
 841                                 qw_remain       -= 4;
 842
 843                                 p_exp->qw_calloffset    = (QWord)dw_value;
 844                                 p_exp->caller[ p_exp->b_callers ].pb_return             = pb_now;
 845                                 p_exp->caller[ p_exp->b_callers ].qw_retremain  = qw_remain;
 846                                 p_exp->b_callers++;
 847                                 p_exp->dw_status        = LIBGOBLIN_DWARF_STATUS_CALLING;
 848
 849                                 goto    goto_DWARF_Expression_Evaluate_post;
 850                                 break;  // NOT reach.
 851                         case DW_OP_call_ref:                    // 0x9a
 852                                 if( p_exp->b_dwsize > qw_remain )
 853                                         { goto  goto_DWARF_Expression_Evaluate_post; }
 854                                 if( 8 == p_exp->b_dwsize )      { qw_value      = *((QWord *)pb_now); }
 855                                 else                                            { qw_value      = (QWord)(*((DWord *)pb_now)); }
 856                                 pb_now          += p_exp->b_dwsize;
 857                                 qw_remain       -= p_exp->b_dwsize;
 858
 859                                 p_exp->qw_calloffset    = qw_value;
 860                                 p_exp->caller[ p_exp->b_callers ].pb_return             = pb_now;
 861                                 p_exp->caller[ p_exp->b_callers ].qw_retremain  = qw_remain;
 862                                 p_exp->b_callers++;
 863                                 p_exp->dw_status        = LIBGOBLIN_DWARF_STATUS_CALLING;
 864
 865                                 goto    goto_DWARF_Expression_Evaluate_post;
 866                                 break;  // NOT reach.
 867
 868                         // Special Operation ----
 869                         case DW_OP_nop:                                 // 0x96
 870                                 // XXX: Not TESTED!!
 871                                 // NONE operation .
 872                                 break;
 873
 874                         case DW_OP_reg0:                                // 0x50
 875                         case DW_OP_reg1:                                // 0x51
 876                         case DW_OP_reg2:                                // 0x52
 877                         case DW_OP_reg3:                                // 0x53
 878                         case DW_OP_reg4:                                // 0x54
 879                         case DW_OP_reg5:                                // 0x55
 880                         case DW_OP_reg6:                                // 0x56
 881                         case DW_OP_reg7:                                // 0x57
 882                         case DW_OP_reg8:                                // 0x58
 883                         case DW_OP_reg9:                                // 0x59
 884                         case DW_OP_reg10:                               // 0x5a
 885                         case DW_OP_reg11:                               // 0x5b
 886                         case DW_OP_reg12:                               // 0x5c
 887                         case DW_OP_reg13:                               // 0x5d
 888                         case DW_OP_reg14:                               // 0x5e
 889                         case DW_OP_reg15:                               // 0x5f
 890                         case DW_OP_reg16:                               // 0x60
 891                         case DW_OP_reg17:                               // 0x61
 892                         case DW_OP_reg18:                               // 0x62
 893                         case DW_OP_reg19:                               // 0x63
 894                         case DW_OP_reg20:                               // 0x64
 895                         case DW_OP_reg21:                               // 0x65
 896                         case DW_OP_reg22:                               // 0x66
 897                         case DW_OP_reg23:                               // 0x67
 898                         case DW_OP_reg24:                               // 0x68
 899                         case DW_OP_reg25:                               // 0x69
 900                         case DW_OP_reg26:                               // 0x6a
 901                         case DW_OP_reg27:                               // 0x6b
 902                         case DW_OP_reg28:                               // 0x6c
 903                         case DW_OP_reg29:                               // 0x6d
 904                         case DW_OP_reg30:                               // 0x6e
 905                         case DW_OP_reg31:                               // 0x6f
 906                                 // XXX: Not TESTED!!
 907                                 b_reg   = b_opcode - DW_OP_reg0;
 908                                 p_exp->result[ p_exp->b_results ].b_type                        = b_reg;
 909                                 p_exp->result[ p_exp->b_results ].value.qw_value        = b_reg;        // reg.id
 910                                 //p_exp->b_results++;
 911                                 break;
 912                         case DW_OP_regx:                                // 0x90
 913                                 // XXX: Not TESTED!!
 914                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_temp, pb_now, &qw_remain );
 915                                 p_exp->result[ p_exp->b_results ].b_type        = LIBGOBLIN_DWARF_FLAG_REGX;
 916                                 p_exp->result[ p_exp->b_results ].value.qw_value        = qw_temp;      // reg.id
 917                                 //p_exp->b_results++;
 918                                 break;
 919
 920                         case DW_OP_piece:                               // 0x93
 921                                 // XXX: Not TESTED!!
 922                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_temp, pb_now, &qw_remain );
 923                                 dw_value        = (DWord)(qw_temp & 0xffffffff);
 924
 925                                 b_value         = p_exp->result[ p_exp->b_results ].b_type;
 926                                 if( !(LIBGOBLIN_DWARF_FLAG_REG & b_value)
 927                                                         && !(LIBGOBLIN_DWARF_FLAG_REGX & b_value))      {
 928                                         if( 0 < p_exp->dw_depth )       {
 929                                                 p_exp->result[p_exp->b_results].b_type
 930                                                                 = p_exp->t_stack[ p_exp->dw_depth - 1 ].b_flag;
 931                                                 p_exp->result[p_exp->b_results].value.qw_value
 932                                                                 = p_exp->t_stack[ p_exp->dw_depth - 1 ].value.qw_value;
 933                                         }
 934                                 }
 935                                 p_exp->result[p_exp->b_results].dw_bytes        = dw_value;
 936                                 p_exp->b_results++;
 937
 938                                 break;
 939                         case DW_OP_bit_piece:                   // 0x9d
 940                                 // XXX: Not TESTED!!
 941                                 // 1st Operand: bit size
 942                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_temp, pb_now, &qw_remain );
 943                                 // 2nd Operand: bit offset from prev-bit-piece (under-bits)
 944                                 pb_now  = DWARF_Common_DecodeULEB128( &qw_value, pb_now, &qw_remain );
 945                                 dw_bitoffset    += (DWord)(qw_value & 0xffffffff);
 946
 947                                 b_value         = p_exp->result[ p_exp->b_results ].b_type;
 948                                 if( (LIBGOBLIN_DWARF_FLAG_REG & b_value)
 949                                                         || (LIBGOBLIN_DWARF_FLAG_REGX & b_value) )      {
 950
 951                                         p_exp->result[ p_exp->b_results ].dw_bit_offset = dw_bitoffset;
 952                                         p_exp->result[ p_exp->b_results ].dw_bit_size   = (DWord)(qw_temp & 0xffffffff);
 953                                         p_exp->result[p_exp->b_results].dw_bytes                = 0;
 954                                         p_exp->b_results++;
 955                                 }
 956                                 else if( 0 < p_exp->dw_depth )  {
 957                                         p_exp->result[p_exp->b_results].b_type
 958                                                                 = p_exp->t_stack[ p_exp->dw_depth - 1 ].b_flag;
 959                                         p_exp->result[p_exp->b_results].value.qw_value
 960                                                                 = p_exp->t_stack[ p_exp->dw_depth - 1 ].value.qw_value;
 961
 962                                         p_exp->result[ p_exp->b_results ].dw_bit_offset = dw_bitoffset;
 963                                         p_exp->result[ p_exp->b_results ].dw_bit_size   = (DWord)(qw_temp & 0xffffffff);
 964                                         p_exp->result[p_exp->b_results].dw_bytes                = 0;
 965                                         p_exp->b_results++;
 966                                 }
 967                                 break;
 968                         case DW_OP_implicit_value:              // 0x9e
 969                                 break;
 970                         case DW_OP_stack_value:                 // 0x9f
 971                                 break;
 972                 //      case DW_OP_lo_user:                             // 0xe0
 973                 //              break;
 974                 //      case DW_OP_hi_user:                             // 0xff
 975                 //              break;
 976                         case DW_OP_GNU_push_tls_address:        // 0xe0
 977                                 break;
 978                         case DW_OP_GNU_uninit:                  // 0xf0
 979                                 break;
 980                         case DW_OP_GNU_encoded_addr:    // 0xf1
 981                                 break;
 982                         case DW_OP_GNU_implicit_pointer:        // 0xf2
 983                                 break;
 984                         case DW_OP_GNU_entry_value:             // 0xf3
 985                                 break;
 986                         case DW_OP_GNU_const_type:              // 0xf4
 987                                 break;
 988                         case DW_OP_GNU_regval_type:             // 0xf5
 989                                 break;
 990                         case DW_OP_GNU_deref_type:              // 0xf6
 991                                 break;
 992                         case DW_OP_GNU_convert:                 // 0xf7
 993                                 break;
 994                         case DW_OP_GNU_reinterpret:             // 0xf9
 995                                 break;
 996                         case DW_OP_GNU_parameter_ref:   // 0xfa
 997                                 break;
 998                         case DW_OP_GNU_addr_index:              // 0xfb
 999                                 break;
1000                         case DW_OP_GNU_const_index:             // 0xfc
1001                                 break;
1002                         default:
1003                                 break;
1004                 }
1005
1006         }while( 0 < qw_remain );
1007
1008         if( LIBGOBLIN_DWARF_REQUEST_NONE != p_exp->dw_requested )       {
1009                 if( 0 == p_exp->dw_reqsize )    {
1010                         if( p_exp->dw_setdata & LIBGOBLIN_DWARF_REQUEST_ADDRSIZE )
1011                                 { p_exp->dw_reqsize     = (DWord)p_exp->qw_reqdata[ LIBGOBLIN_DWARF_DATAID_ADDRSIZE ]; }
1012                         else    { p_exp->dw_reqsize     = 8; }
1013                 }
1014                 p_exp->resume.pb_resume = pb_resume;
1015                 p_exp->resume.qw_remain = qw_resume;
1016                 p_exp->dw_depth                 = dw_depth_resume;
1017                 p_exp->dw_status                = LIBGOBLIN_DWARF_STATUS_REQUESTED;
1018                 goto    goto_DWARF_Expression_Evaluate_post;
1019         }
1020
1021         if( 0 < p_exp->b_callers )      {
1022                 assert( NULL != p_exp->caller[ p_exp->b_callers - 1 ].pb_return );
1023                 p_exp->dw_status        = LIBGOBLIN_DWARF_STATUS_RETCALL;
1024                 goto    goto_DWARF_Expression_Evaluate_post;
1025         }
1026
1027         if( 0 < p_exp->dw_depth )       {
1028                 p_exp->dw_status                = LIBGOBLIN_DWARF_STATUS_EVALUATED;
1029                 p_exp->result[p_exp->b_results].b_type
1030                                                 = p_exp->t_stack[ p_exp->dw_depth - 1 ].b_flag;
1031                 p_exp->result[p_exp->b_results].value.qw_value
1032                                                 = p_exp->t_stack[ p_exp->dw_depth - 1 ].value.qw_value;
1033                 p_exp->b_results++;
1034         }
1035
1036 goto_DWARF_Expression_Evaluate_post:
1037         return p_exp->dw_status;
1038 }
1039
1040
1041 /*----------------------------------------------------------------------
1042 ----------------------------------------------------------------------*/
1043 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
1044 LibGoblin_DWARF_Expression *
1045         DWARF_Expression_Alloc(
1046                         void )
1047 {
1048         int             i_id;
1049         LibGoblin_DWARF_Expression      *p_exp;
1050
1051         if( NULL == gp_dweempty )       {
1052                 return NULL;
1053         }
1054
1055         p_exp           = gp_dweempty;
1056         gp_dweempty     = p_exp->p_next;
1057
1058         i_id            = p_exp->i_id;
1059         memset( p_exp, 0x00, sizeof( LibGoblin_DWARF_Expression ) );
1060         p_exp->i_id             = i_id;
1061         p_exp->p_next   = NULL;
1062
1063         return p_exp;
1064 }
1065
1066
1067 /*----------------------------------------------------------------------
1068 ----------------------------------------------------------------------*/
1069 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
1070 int
1071         DWARF_Expression_Free(
1072                         LibGoblin_DWARF_Expression *p_exp )
1073 {
1074         LibGoblin_DWARF_Expression      *p_next;
1075
1076         if( NULL == p_exp )     {
1077                 return -0x01;
1078         }
1079
1080         assert( NULL == p_exp->p_next );
1081
1082         p_next                  = gp_dweempty;
1083         gp_dweempty             = p_exp;
1084         p_exp->p_next   = p_next;
1085
1086         return 0x00;
1087 }
1088
1089
1090 /*----------------------------------------------------------------------
1091 ----------------------------------------------------------------------*/
1092 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
1093 int
1094         DWARF_Expression_Init(
1095                         void )
1096 {
1097         int             i_cnt;
1098         DWord   dw_size;
1099         LibGoblin_DWARF_Expression      *p_exp;
1100
1101         if( NULL != gp_dwexpression )   {
1102                 return -0x01;
1103         }
1104
1105         dw_size = sizeof( LibGoblin_DWARF_Expression )
1106                                                 * LIBGOBLIN_DWARF_EXPRESSION_UNITS;
1107         gp_dwexpression = (LibGoblin_DWARF_Expression *)malloc( dw_size );
1108         if( NULL == gp_dwexpression )   {
1109                 return -0x02;
1110         }
1111         memset( gp_dwexpression, 0x00, dw_size );
1112
1113         for( i_cnt = 0; i_cnt < LIBGOBLIN_DWARF_EXPRESSION_UNITS; i_cnt++ )     {
1114                 p_exp                   = gp_dwexpression + i_cnt;
1115                 p_exp->i_id             = i_cnt;
1116                 p_exp->p_next   = gp_dwexpression + i_cnt + 1;
1117         }
1118         p_exp->p_next           = NULL;
1119
1120         gp_dweempty                             = gp_dwexpression;
1121
1122         return 0x00;
1123 }
1124
1125
1126 /*----------------------------------------------------------------------
1127 ----------------------------------------------------------------------*/
1128 LIBGOBLIN_DWARF_EXPRESSION_EXTERN
1129 int
1130         DWARF_Expression_Term(
1131                         void )
1132 {
1133         assert( NULL != gp_dwexpression );
1134         free( gp_dwexpression );
1135
1136         gp_dwexpression                 = NULL;
1137
1138         return 0x00;
1139 }
1140
1141
1142 /* EOF of drd64_.c ----------------------------------- */