gdb/dwarf2expr.c

   1 /* Dwarf2 Expression Evaluator
   2    Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Daniel Berlin (dan@dberlin.org)
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "value.h"
  26 #include "gdbcore.h"
  27 #include "elf/dwarf2.h"
  28 #include "dwarf2expr.h"
  29
  30 /* Local prototypes.  */
  31
  32 static void execute_stack_op (struct dwarf_expr_context *,
  33                               unsigned char *, unsigned char *);
  34
  35 /* Create a new context for the expression evaluator.  */
  36
  37 struct dwarf_expr_context *
  38 new_dwarf_expr_context (void)
  39 {
  40   struct dwarf_expr_context *retval;
  41   retval = xcalloc (1, sizeof (struct dwarf_expr_context));
  42   retval->stack_len = 0;
  43   retval->stack_allocated = 10;
  44   retval->stack = xmalloc (retval->stack_allocated * sizeof (CORE_ADDR));
  45   return retval;
  46 }
  47
  48 /* Release the memory allocated to CTX.  */
  49
  50 void
  51 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
  52 {
  53   xfree (ctx->stack);
  54   xfree (ctx);
  55 }
  56
  57 /* Expand the memory allocated to CTX's stack to contain at least
  58    NEED more elements than are currently used.  */
  59
  60 static void
  61 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
  62 {
  63   if (ctx->stack_len + need > ctx->stack_allocated)
  64     {
  65       size_t newlen = ctx->stack_len + need + 10;
  66       ctx->stack = xrealloc (ctx->stack,
  67                              newlen * sizeof (CORE_ADDR));
  68       ctx->stack_allocated = newlen;
  69     }
  70 }
  71
  72 /* Push VALUE onto CTX's stack.  */
  73
  74 void
  75 dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
  76 {
  77   dwarf_expr_grow_stack (ctx, 1);
  78   ctx->stack[ctx->stack_len++] = value;
  79 }
  80
  81 /* Pop the top item off of CTX's stack.  */
  82
  83 void
  84 dwarf_expr_pop (struct dwarf_expr_context *ctx)
  85 {
  86   if (ctx->stack_len <= 0)
  87     error ("dwarf expression stack underflow");
  88   ctx->stack_len--;
  89 }
  90
  91 /* Retrieve the N'th item on CTX's stack.  */
  92
  93 CORE_ADDR
  94 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
  95 {
  96   if (ctx->stack_len < n)
  97      error ("Asked for position %d of stack, stack only has %d elements on it\n",
  98             n, ctx->stack_len);
  99   return ctx->stack[ctx->stack_len - (1 + n)];
 100
 101 }
 102
 103 /* Evaluate the expression at ADDR (LEN bytes long) using the context
 104    CTX.  */
 105
 106 void
 107 dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
 108                  size_t len)
 109 {
 110   execute_stack_op (ctx, addr, addr + len);
 111 }
 112
 113 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 114    by R, and return the new value of BUF.  Verify that it doesn't extend
 115    past BUF_END.  */
 116
 117 unsigned char *
 118 read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
 119 {
 120   unsigned shift = 0;
 121   ULONGEST result = 0;
 122   unsigned char byte;
 123
 124   while (1)
 125     {
 126       if (buf >= buf_end)
 127         error ("read_uleb128: Corrupted DWARF expression.");
 128
 129       byte = *buf++;
 130       result |= (byte & 0x7f) << shift;
 131       if ((byte & 0x80) == 0)
 132         break;
 133       shift += 7;
 134     }
 135   *r = result;
 136   return buf;
 137 }
 138
 139 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 140    by R, and return the new value of BUF.  Verify that it doesn't extend
 141    past BUF_END.  */
 142
 143 unsigned char *
 144 read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
 145 {
 146   unsigned shift = 0;
 147   LONGEST result = 0;
 148   unsigned char byte;
 149
 150   while (1)
 151     {
 152       if (buf >= buf_end)
 153         error ("read_sleb128: Corrupted DWARF expression.");
 154
 155       byte = *buf++;
 156       result |= (byte & 0x7f) << shift;
 157       shift += 7;
 158       if ((byte & 0x80) == 0)
 159         break;
 160     }
 161   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 162     result |= -(1 << shift);
 163
 164   *r = result;
 165   return buf;
 166 }
 167
 168 /* Read an address from BUF, and verify that it doesn't extend past
 169    BUF_END.  The address is returned, and *BYTES_READ is set to the
 170    number of bytes read from BUF.  */
 171
 172 CORE_ADDR
 173 dwarf2_read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
 174 {
 175   CORE_ADDR result;
 176
 177   if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 178     error ("dwarf2_read_address: Corrupted DWARF expression.");
 179
 180   *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
 181   result = extract_address (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 182   return result;
 183 }
 184
 185 /* Return the type of an address, for unsigned arithmetic.  */
 186
 187 static struct type *
 188 unsigned_address_type (void)
 189 {
 190   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 191     {
 192     case 2:
 193       return builtin_type_uint16;
 194     case 4:
 195       return builtin_type_uint32;
 196     case 8:
 197       return builtin_type_uint64;
 198     default:
 199       internal_error (__FILE__, __LINE__,
 200                       "Unsupported address size.\n");
 201     }
 202 }
 203
 204 /* Return the type of an address, for signed arithmetic.  */
 205
 206 static struct type *
 207 signed_address_type (void)
 208 {
 209   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 210     {
 211     case 2:
 212       return builtin_type_int16;
 213     case 4:
 214       return builtin_type_int32;
 215     case 8:
 216       return builtin_type_int64;
 217     default:
 218       internal_error (__FILE__, __LINE__,
 219                       "Unsupported address size.\n");
 220     }
 221 }
 222 \f
 223 /* The engine for the expression evaluator.  Using the context in CTX,
 224    evaluate the expression between OP_PTR and OP_END.  */
 225
 226 static void
 227 execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
 228                   unsigned char *op_end)
 229 {
 230   ctx->in_reg = 0;
 231
 232   while (op_ptr < op_end)
 233     {
 234       enum dwarf_location_atom op = *op_ptr++;
 235       CORE_ADDR result;
 236       ULONGEST uoffset, reg;
 237       LONGEST offset;
 238       int bytes_read;
 239
 240       switch (op)
 241         {
 242         case DW_OP_lit0:
 243         case DW_OP_lit1:
 244         case DW_OP_lit2:
 245         case DW_OP_lit3:
 246         case DW_OP_lit4:
 247         case DW_OP_lit5:
 248         case DW_OP_lit6:
 249         case DW_OP_lit7:
 250         case DW_OP_lit8:
 251         case DW_OP_lit9:
 252         case DW_OP_lit10:
 253         case DW_OP_lit11:
 254         case DW_OP_lit12:
 255         case DW_OP_lit13:
 256         case DW_OP_lit14:
 257         case DW_OP_lit15:
 258         case DW_OP_lit16:
 259         case DW_OP_lit17:
 260         case DW_OP_lit18:
 261         case DW_OP_lit19:
 262         case DW_OP_lit20:
 263         case DW_OP_lit21:
 264         case DW_OP_lit22:
 265         case DW_OP_lit23:
 266         case DW_OP_lit24:
 267         case DW_OP_lit25:
 268         case DW_OP_lit26:
 269         case DW_OP_lit27:
 270         case DW_OP_lit28:
 271         case DW_OP_lit29:
 272         case DW_OP_lit30:
 273         case DW_OP_lit31:
 274           result = op - DW_OP_lit0;
 275           break;
 276
 277         case DW_OP_addr:
 278           result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
 279           op_ptr += bytes_read;
 280           break;
 281
 282         case DW_OP_const1u:
 283           result = extract_unsigned_integer (op_ptr, 1);
 284           op_ptr += 1;
 285           break;
 286         case DW_OP_const1s:
 287           result = extract_signed_integer (op_ptr, 1);
 288           op_ptr += 1;
 289           break;
 290         case DW_OP_const2u:
 291           result = extract_unsigned_integer (op_ptr, 2);
 292           op_ptr += 2;
 293           break;
 294         case DW_OP_const2s:
 295           result = extract_signed_integer (op_ptr, 2);
 296           op_ptr += 2;
 297           break;
 298         case DW_OP_const4u:
 299           result = extract_unsigned_integer (op_ptr, 4);
 300           op_ptr += 4;
 301           break;
 302         case DW_OP_const4s:
 303           result = extract_signed_integer (op_ptr, 4);
 304           op_ptr += 4;
 305           break;
 306         case DW_OP_const8u:
 307           result = extract_unsigned_integer (op_ptr, 8);
 308           op_ptr += 8;
 309           break;
 310         case DW_OP_const8s:
 311           result = extract_signed_integer (op_ptr, 8);
 312           op_ptr += 8;
 313           break;
 314         case DW_OP_constu:
 315           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 316           result = uoffset;
 317           break;
 318         case DW_OP_consts:
 319           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 320           result = offset;
 321           break;
 322
 323         /* The DW_OP_reg operations are required to occur alone in
 324            location expressions.  */
 325         case DW_OP_reg0:
 326         case DW_OP_reg1:
 327         case DW_OP_reg2:
 328         case DW_OP_reg3:
 329         case DW_OP_reg4:
 330         case DW_OP_reg5:
 331         case DW_OP_reg6:
 332         case DW_OP_reg7:
 333         case DW_OP_reg8:
 334         case DW_OP_reg9:
 335         case DW_OP_reg10:
 336         case DW_OP_reg11:
 337         case DW_OP_reg12:
 338         case DW_OP_reg13:
 339         case DW_OP_reg14:
 340         case DW_OP_reg15:
 341         case DW_OP_reg16:
 342         case DW_OP_reg17:
 343         case DW_OP_reg18:
 344         case DW_OP_reg19:
 345         case DW_OP_reg20:
 346         case DW_OP_reg21:
 347         case DW_OP_reg22:
 348         case DW_OP_reg23:
 349         case DW_OP_reg24:
 350         case DW_OP_reg25:
 351         case DW_OP_reg26:
 352         case DW_OP_reg27:
 353         case DW_OP_reg28:
 354         case DW_OP_reg29:
 355         case DW_OP_reg30:
 356         case DW_OP_reg31:
 357           if (op_ptr != op_end && *op_ptr != DW_OP_piece)
 358             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 359                    "used either alone or in conjuction with DW_OP_piece.");
 360
 361           result = op - DW_OP_reg0;
 362           ctx->in_reg = 1;
 363
 364           break;
 365
 366         case DW_OP_regx:
 367           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 368           if (op_ptr != op_end && *op_ptr != DW_OP_piece)
 369             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 370                    "used either alone or in conjuction with DW_OP_piece.");
 371
 372           result = reg;
 373           ctx->in_reg = 1;
 374           break;
 375
 376         case DW_OP_breg0:
 377         case DW_OP_breg1:
 378         case DW_OP_breg2:
 379         case DW_OP_breg3:
 380         case DW_OP_breg4:
 381         case DW_OP_breg5:
 382         case DW_OP_breg6:
 383         case DW_OP_breg7:
 384         case DW_OP_breg8:
 385         case DW_OP_breg9:
 386         case DW_OP_breg10:
 387         case DW_OP_breg11:
 388         case DW_OP_breg12:
 389         case DW_OP_breg13:
 390         case DW_OP_breg14:
 391         case DW_OP_breg15:
 392         case DW_OP_breg16:
 393         case DW_OP_breg17:
 394         case DW_OP_breg18:
 395         case DW_OP_breg19:
 396         case DW_OP_breg20:
 397         case DW_OP_breg21:
 398         case DW_OP_breg22:
 399         case DW_OP_breg23:
 400         case DW_OP_breg24:
 401         case DW_OP_breg25:
 402         case DW_OP_breg26:
 403         case DW_OP_breg27:
 404         case DW_OP_breg28:
 405         case DW_OP_breg29:
 406         case DW_OP_breg30:
 407         case DW_OP_breg31:
 408           {
 409             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 410             result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
 411             result += offset;
 412           }
 413           break;
 414         case DW_OP_bregx:
 415           {
 416             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 417             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 418             result = (ctx->read_reg) (ctx->baton, reg);
 419             result += offset;
 420           }
 421           break;
 422         case DW_OP_fbreg:
 423           {
 424             unsigned char *datastart;
 425             size_t datalen;
 426             unsigned int before_stack_len;
 427
 428             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 429             /* Rather than create a whole new context, we simply
 430                record the stack length before execution, then reset it
 431                afterwards, effectively erasing whatever the recursive
 432                call put there.  */
 433             before_stack_len = ctx->stack_len;
 434             /* FIXME: cagney/2003-03-26: This code should be using
 435                get_frame_base_address(), and then implement a dwarf2
 436                specific this_base method.  */
 437             (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
 438             dwarf_expr_eval (ctx, datastart, datalen);
 439             result = dwarf_expr_fetch (ctx, 0);
 440             if (ctx->in_reg)
 441               result = (ctx->read_reg) (ctx->baton, result);
 442             else
 443               {
 444                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 445                 int bytes_read;
 446
 447                 (ctx->read_mem) (ctx->baton, buf, result,
 448                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 449                 result = dwarf2_read_address (buf,
 450                                               buf + (TARGET_ADDR_BIT
 451                                                      / TARGET_CHAR_BIT),
 452                                               &bytes_read);
 453               }
 454             result = result + offset;
 455             ctx->stack_len = before_stack_len;
 456             ctx->in_reg = 0;
 457           }
 458           break;
 459         case DW_OP_dup:
 460           result = dwarf_expr_fetch (ctx, 0);
 461           break;
 462
 463         case DW_OP_drop:
 464           dwarf_expr_pop (ctx);
 465           goto no_push;
 466
 467         case DW_OP_pick:
 468           offset = *op_ptr++;
 469           result = dwarf_expr_fetch (ctx, offset);
 470           break;
 471
 472         case DW_OP_over:
 473           result = dwarf_expr_fetch (ctx, 1);
 474           break;
 475
 476         case DW_OP_rot:
 477           {
 478             CORE_ADDR t1, t2, t3;
 479
 480             if (ctx->stack_len < 3)
 481                error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
 482                       ctx->stack_len);
 483             t1 = ctx->stack[ctx->stack_len - 1];
 484             t2 = ctx->stack[ctx->stack_len - 2];
 485             t3 = ctx->stack[ctx->stack_len - 3];
 486             ctx->stack[ctx->stack_len - 1] = t2;
 487             ctx->stack[ctx->stack_len - 2] = t3;
 488             ctx->stack[ctx->stack_len - 3] = t1;
 489             goto no_push;
 490           }
 491
 492         case DW_OP_deref:
 493         case DW_OP_deref_size:
 494         case DW_OP_abs:
 495         case DW_OP_neg:
 496         case DW_OP_not:
 497         case DW_OP_plus_uconst:
 498           /* Unary operations.  */
 499           result = dwarf_expr_fetch (ctx, 0);
 500           dwarf_expr_pop (ctx);
 501
 502           switch (op)
 503             {
 504             case DW_OP_deref:
 505               {
 506                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 507                 int bytes_read;
 508
 509                 (ctx->read_mem) (ctx->baton, buf, result,
 510                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 511                 result = dwarf2_read_address (buf,
 512                                               buf + (TARGET_ADDR_BIT
 513                                                      / TARGET_CHAR_BIT),
 514                                               &bytes_read);
 515               }
 516               break;
 517
 518             case DW_OP_deref_size:
 519               {
 520                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 521                 int bytes_read;
 522
 523                 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
 524                 result = dwarf2_read_address (buf,
 525                                               buf + (TARGET_ADDR_BIT
 526                                                      / TARGET_CHAR_BIT),
 527                                               &bytes_read);
 528               }
 529               break;
 530
 531             case DW_OP_abs:
 532               if ((signed int) result < 0)
 533                 result = -result;
 534               break;
 535             case DW_OP_neg:
 536               result = -result;
 537               break;
 538             case DW_OP_not:
 539               result = ~result;
 540               break;
 541             case DW_OP_plus_uconst:
 542               op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 543               result += reg;
 544               break;
 545             }
 546           break;
 547
 548         case DW_OP_and:
 549         case DW_OP_div:
 550         case DW_OP_minus:
 551         case DW_OP_mod:
 552         case DW_OP_mul:
 553         case DW_OP_or:
 554         case DW_OP_plus:
 555         case DW_OP_shl:
 556         case DW_OP_shr:
 557         case DW_OP_shra:
 558         case DW_OP_xor:
 559         case DW_OP_le:
 560         case DW_OP_ge:
 561         case DW_OP_eq:
 562         case DW_OP_lt:
 563         case DW_OP_gt:
 564         case DW_OP_ne:
 565           {
 566             /* Binary operations.  Use the value engine to do computations in
 567                the right width.  */
 568             CORE_ADDR first, second;
 569             enum exp_opcode binop;
 570             struct value *val1, *val2;
 571
 572             second = dwarf_expr_fetch (ctx, 0);
 573             dwarf_expr_pop (ctx);
 574
 575             first = dwarf_expr_fetch (ctx, 1);
 576             dwarf_expr_pop (ctx);
 577
 578             val1 = value_from_longest (unsigned_address_type (), first);
 579             val2 = value_from_longest (unsigned_address_type (), second);
 580
 581             switch (op)
 582               {
 583               case DW_OP_and:
 584                 binop = BINOP_BITWISE_AND;
 585                 break;
 586               case DW_OP_div:
 587                 binop = BINOP_DIV;
 588               case DW_OP_minus:
 589                 binop = BINOP_SUB;
 590                 break;
 591               case DW_OP_mod:
 592                 binop = BINOP_MOD;
 593                 break;
 594               case DW_OP_mul:
 595                 binop = BINOP_MUL;
 596                 break;
 597               case DW_OP_or:
 598                 binop = BINOP_BITWISE_IOR;
 599                 break;
 600               case DW_OP_plus:
 601                 binop = BINOP_ADD;
 602                 break;
 603               case DW_OP_shl:
 604                 binop = BINOP_LSH;
 605                 break;
 606               case DW_OP_shr:
 607                 binop = BINOP_RSH;
 608               case DW_OP_shra:
 609                 binop = BINOP_RSH;
 610                 val1 = value_from_longest (signed_address_type (), first);
 611                 break;
 612               case DW_OP_xor:
 613                 binop = BINOP_BITWISE_XOR;
 614                 break;
 615               case DW_OP_le:
 616                 binop = BINOP_LEQ;
 617                 break;
 618               case DW_OP_ge:
 619                 binop = BINOP_GEQ;
 620                 break;
 621               case DW_OP_eq:
 622                 binop = BINOP_EQUAL;
 623                 break;
 624               case DW_OP_lt:
 625                 binop = BINOP_LESS;
 626                 break;
 627               case DW_OP_gt:
 628                 binop = BINOP_GTR;
 629                 break;
 630               case DW_OP_ne:
 631                 binop = BINOP_NOTEQUAL;
 632                 break;
 633               default:
 634                 internal_error (__FILE__, __LINE__,
 635                                 "Can't be reached.");
 636               }
 637             result = value_as_long (value_binop (val1, val2, binop));
 638           }
 639           break;
 640
 641         case DW_OP_GNU_push_tls_address:
 642           result = dwarf_expr_fetch (ctx, 0);
 643           dwarf_expr_pop (ctx);
 644           result = (ctx->get_tls_address) (ctx->baton, result);
 645           break;
 646
 647         case DW_OP_skip:
 648           offset = extract_signed_integer (op_ptr, 2);
 649           op_ptr += 2;
 650           op_ptr += offset;
 651           goto no_push;
 652
 653         case DW_OP_bra:
 654           offset = extract_signed_integer (op_ptr, 2);
 655           op_ptr += 2;
 656           if (dwarf_expr_fetch (ctx, 0) != 0)
 657             op_ptr += offset;
 658           dwarf_expr_pop (ctx);
 659           goto no_push;
 660
 661         case DW_OP_nop:
 662           goto no_push;
 663
 664         default:
 665           error ("Unhandled dwarf expression opcode");
 666         }
 667
 668       /* Most things push a result value.  */
 669       dwarf_expr_push (ctx, result);
 670     no_push:;
 671     }
 672 }