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   /* NOTE: cagney/2003-05-22: This extract is assuming that a DWARF 2
 182      address is always unsigned.  That may or may not be true.  */
 183   result = extract_unsigned_integer (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 184   return result;
 185 }
 186
 187 /* Return the type of an address, for unsigned arithmetic.  */
 188
 189 static struct type *
 190 unsigned_address_type (void)
 191 {
 192   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 193     {
 194     case 2:
 195       return builtin_type_uint16;
 196     case 4:
 197       return builtin_type_uint32;
 198     case 8:
 199       return builtin_type_uint64;
 200     default:
 201       internal_error (__FILE__, __LINE__,
 202                       "Unsupported address size.\n");
 203     }
 204 }
 205
 206 /* Return the type of an address, for signed arithmetic.  */
 207
 208 static struct type *
 209 signed_address_type (void)
 210 {
 211   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 212     {
 213     case 2:
 214       return builtin_type_int16;
 215     case 4:
 216       return builtin_type_int32;
 217     case 8:
 218       return builtin_type_int64;
 219     default:
 220       internal_error (__FILE__, __LINE__,
 221                       "Unsupported address size.\n");
 222     }
 223 }
 224 \f
 225 /* The engine for the expression evaluator.  Using the context in CTX,
 226    evaluate the expression between OP_PTR and OP_END.  */
 227
 228 static void
 229 execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
 230                   unsigned char *op_end)
 231 {
 232   ctx->in_reg = 0;
 233
 234   while (op_ptr < op_end)
 235     {
 236       enum dwarf_location_atom op = *op_ptr++;
 237       CORE_ADDR result;
 238       ULONGEST uoffset, reg;
 239       LONGEST offset;
 240       int bytes_read;
 241
 242       switch (op)
 243         {
 244         case DW_OP_lit0:
 245         case DW_OP_lit1:
 246         case DW_OP_lit2:
 247         case DW_OP_lit3:
 248         case DW_OP_lit4:
 249         case DW_OP_lit5:
 250         case DW_OP_lit6:
 251         case DW_OP_lit7:
 252         case DW_OP_lit8:
 253         case DW_OP_lit9:
 254         case DW_OP_lit10:
 255         case DW_OP_lit11:
 256         case DW_OP_lit12:
 257         case DW_OP_lit13:
 258         case DW_OP_lit14:
 259         case DW_OP_lit15:
 260         case DW_OP_lit16:
 261         case DW_OP_lit17:
 262         case DW_OP_lit18:
 263         case DW_OP_lit19:
 264         case DW_OP_lit20:
 265         case DW_OP_lit21:
 266         case DW_OP_lit22:
 267         case DW_OP_lit23:
 268         case DW_OP_lit24:
 269         case DW_OP_lit25:
 270         case DW_OP_lit26:
 271         case DW_OP_lit27:
 272         case DW_OP_lit28:
 273         case DW_OP_lit29:
 274         case DW_OP_lit30:
 275         case DW_OP_lit31:
 276           result = op - DW_OP_lit0;
 277           break;
 278
 279         case DW_OP_addr:
 280           result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
 281           op_ptr += bytes_read;
 282           break;
 283
 284         case DW_OP_const1u:
 285           result = extract_unsigned_integer (op_ptr, 1);
 286           op_ptr += 1;
 287           break;
 288         case DW_OP_const1s:
 289           result = extract_signed_integer (op_ptr, 1);
 290           op_ptr += 1;
 291           break;
 292         case DW_OP_const2u:
 293           result = extract_unsigned_integer (op_ptr, 2);
 294           op_ptr += 2;
 295           break;
 296         case DW_OP_const2s:
 297           result = extract_signed_integer (op_ptr, 2);
 298           op_ptr += 2;
 299           break;
 300         case DW_OP_const4u:
 301           result = extract_unsigned_integer (op_ptr, 4);
 302           op_ptr += 4;
 303           break;
 304         case DW_OP_const4s:
 305           result = extract_signed_integer (op_ptr, 4);
 306           op_ptr += 4;
 307           break;
 308         case DW_OP_const8u:
 309           result = extract_unsigned_integer (op_ptr, 8);
 310           op_ptr += 8;
 311           break;
 312         case DW_OP_const8s:
 313           result = extract_signed_integer (op_ptr, 8);
 314           op_ptr += 8;
 315           break;
 316         case DW_OP_constu:
 317           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 318           result = uoffset;
 319           break;
 320         case DW_OP_consts:
 321           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 322           result = offset;
 323           break;
 324
 325         /* The DW_OP_reg operations are required to occur alone in
 326            location expressions.  */
 327         case DW_OP_reg0:
 328         case DW_OP_reg1:
 329         case DW_OP_reg2:
 330         case DW_OP_reg3:
 331         case DW_OP_reg4:
 332         case DW_OP_reg5:
 333         case DW_OP_reg6:
 334         case DW_OP_reg7:
 335         case DW_OP_reg8:
 336         case DW_OP_reg9:
 337         case DW_OP_reg10:
 338         case DW_OP_reg11:
 339         case DW_OP_reg12:
 340         case DW_OP_reg13:
 341         case DW_OP_reg14:
 342         case DW_OP_reg15:
 343         case DW_OP_reg16:
 344         case DW_OP_reg17:
 345         case DW_OP_reg18:
 346         case DW_OP_reg19:
 347         case DW_OP_reg20:
 348         case DW_OP_reg21:
 349         case DW_OP_reg22:
 350         case DW_OP_reg23:
 351         case DW_OP_reg24:
 352         case DW_OP_reg25:
 353         case DW_OP_reg26:
 354         case DW_OP_reg27:
 355         case DW_OP_reg28:
 356         case DW_OP_reg29:
 357         case DW_OP_reg30:
 358         case DW_OP_reg31:
 359           if (op_ptr != op_end && *op_ptr != DW_OP_piece)
 360             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 361                    "used either alone or in conjuction with DW_OP_piece.");
 362
 363           result = op - DW_OP_reg0;
 364           ctx->in_reg = 1;
 365
 366           break;
 367
 368         case DW_OP_regx:
 369           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 370           if (op_ptr != op_end && *op_ptr != DW_OP_piece)
 371             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 372                    "used either alone or in conjuction with DW_OP_piece.");
 373
 374           result = reg;
 375           ctx->in_reg = 1;
 376           break;
 377
 378         case DW_OP_breg0:
 379         case DW_OP_breg1:
 380         case DW_OP_breg2:
 381         case DW_OP_breg3:
 382         case DW_OP_breg4:
 383         case DW_OP_breg5:
 384         case DW_OP_breg6:
 385         case DW_OP_breg7:
 386         case DW_OP_breg8:
 387         case DW_OP_breg9:
 388         case DW_OP_breg10:
 389         case DW_OP_breg11:
 390         case DW_OP_breg12:
 391         case DW_OP_breg13:
 392         case DW_OP_breg14:
 393         case DW_OP_breg15:
 394         case DW_OP_breg16:
 395         case DW_OP_breg17:
 396         case DW_OP_breg18:
 397         case DW_OP_breg19:
 398         case DW_OP_breg20:
 399         case DW_OP_breg21:
 400         case DW_OP_breg22:
 401         case DW_OP_breg23:
 402         case DW_OP_breg24:
 403         case DW_OP_breg25:
 404         case DW_OP_breg26:
 405         case DW_OP_breg27:
 406         case DW_OP_breg28:
 407         case DW_OP_breg29:
 408         case DW_OP_breg30:
 409         case DW_OP_breg31:
 410           {
 411             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 412             result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0);
 413             result += offset;
 414           }
 415           break;
 416         case DW_OP_bregx:
 417           {
 418             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 419             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 420             result = (ctx->read_reg) (ctx->baton, reg);
 421             result += offset;
 422           }
 423           break;
 424         case DW_OP_fbreg:
 425           {
 426             unsigned char *datastart;
 427             size_t datalen;
 428             unsigned int before_stack_len;
 429
 430             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 431             /* Rather than create a whole new context, we simply
 432                record the stack length before execution, then reset it
 433                afterwards, effectively erasing whatever the recursive
 434                call put there.  */
 435             before_stack_len = ctx->stack_len;
 436             /* FIXME: cagney/2003-03-26: This code should be using
 437                get_frame_base_address(), and then implement a dwarf2
 438                specific this_base method.  */
 439             (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
 440             dwarf_expr_eval (ctx, datastart, datalen);
 441             result = dwarf_expr_fetch (ctx, 0);
 442             if (ctx->in_reg)
 443               result = (ctx->read_reg) (ctx->baton, result);
 444             else
 445               {
 446                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 447                 int bytes_read;
 448
 449                 (ctx->read_mem) (ctx->baton, buf, result,
 450                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 451                 result = dwarf2_read_address (buf,
 452                                               buf + (TARGET_ADDR_BIT
 453                                                      / TARGET_CHAR_BIT),
 454                                               &bytes_read);
 455               }
 456             result = result + offset;
 457             ctx->stack_len = before_stack_len;
 458             ctx->in_reg = 0;
 459           }
 460           break;
 461         case DW_OP_dup:
 462           result = dwarf_expr_fetch (ctx, 0);
 463           break;
 464
 465         case DW_OP_drop:
 466           dwarf_expr_pop (ctx);
 467           goto no_push;
 468
 469         case DW_OP_pick:
 470           offset = *op_ptr++;
 471           result = dwarf_expr_fetch (ctx, offset);
 472           break;
 473
 474         case DW_OP_over:
 475           result = dwarf_expr_fetch (ctx, 1);
 476           break;
 477
 478         case DW_OP_rot:
 479           {
 480             CORE_ADDR t1, t2, t3;
 481
 482             if (ctx->stack_len < 3)
 483                error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
 484                       ctx->stack_len);
 485             t1 = ctx->stack[ctx->stack_len - 1];
 486             t2 = ctx->stack[ctx->stack_len - 2];
 487             t3 = ctx->stack[ctx->stack_len - 3];
 488             ctx->stack[ctx->stack_len - 1] = t2;
 489             ctx->stack[ctx->stack_len - 2] = t3;
 490             ctx->stack[ctx->stack_len - 3] = t1;
 491             goto no_push;
 492           }
 493
 494         case DW_OP_deref:
 495         case DW_OP_deref_size:
 496         case DW_OP_abs:
 497         case DW_OP_neg:
 498         case DW_OP_not:
 499         case DW_OP_plus_uconst:
 500           /* Unary operations.  */
 501           result = dwarf_expr_fetch (ctx, 0);
 502           dwarf_expr_pop (ctx);
 503
 504           switch (op)
 505             {
 506             case DW_OP_deref:
 507               {
 508                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 509                 int bytes_read;
 510
 511                 (ctx->read_mem) (ctx->baton, buf, result,
 512                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 513                 result = dwarf2_read_address (buf,
 514                                               buf + (TARGET_ADDR_BIT
 515                                                      / TARGET_CHAR_BIT),
 516                                               &bytes_read);
 517               }
 518               break;
 519
 520             case DW_OP_deref_size:
 521               {
 522                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 523                 int bytes_read;
 524
 525                 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
 526                 result = dwarf2_read_address (buf,
 527                                               buf + (TARGET_ADDR_BIT
 528                                                      / TARGET_CHAR_BIT),
 529                                               &bytes_read);
 530               }
 531               break;
 532
 533             case DW_OP_abs:
 534               if ((signed int) result < 0)
 535                 result = -result;
 536               break;
 537             case DW_OP_neg:
 538               result = -result;
 539               break;
 540             case DW_OP_not:
 541               result = ~result;
 542               break;
 543             case DW_OP_plus_uconst:
 544               op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 545               result += reg;
 546               break;
 547             }
 548           break;
 549
 550         case DW_OP_and:
 551         case DW_OP_div:
 552         case DW_OP_minus:
 553         case DW_OP_mod:
 554         case DW_OP_mul:
 555         case DW_OP_or:
 556         case DW_OP_plus:
 557         case DW_OP_shl:
 558         case DW_OP_shr:
 559         case DW_OP_shra:
 560         case DW_OP_xor:
 561         case DW_OP_le:
 562         case DW_OP_ge:
 563         case DW_OP_eq:
 564         case DW_OP_lt:
 565         case DW_OP_gt:
 566         case DW_OP_ne:
 567           {
 568             /* Binary operations.  Use the value engine to do computations in
 569                the right width.  */
 570             CORE_ADDR first, second;
 571             enum exp_opcode binop;
 572             struct value *val1, *val2;
 573
 574             second = dwarf_expr_fetch (ctx, 0);
 575             dwarf_expr_pop (ctx);
 576
 577             first = dwarf_expr_fetch (ctx, 1);
 578             dwarf_expr_pop (ctx);
 579
 580             val1 = value_from_longest (unsigned_address_type (), first);
 581             val2 = value_from_longest (unsigned_address_type (), second);
 582
 583             switch (op)
 584               {
 585               case DW_OP_and:
 586                 binop = BINOP_BITWISE_AND;
 587                 break;
 588               case DW_OP_div:
 589                 binop = BINOP_DIV;
 590               case DW_OP_minus:
 591                 binop = BINOP_SUB;
 592                 break;
 593               case DW_OP_mod:
 594                 binop = BINOP_MOD;
 595                 break;
 596               case DW_OP_mul:
 597                 binop = BINOP_MUL;
 598                 break;
 599               case DW_OP_or:
 600                 binop = BINOP_BITWISE_IOR;
 601                 break;
 602               case DW_OP_plus:
 603                 binop = BINOP_ADD;
 604                 break;
 605               case DW_OP_shl:
 606                 binop = BINOP_LSH;
 607                 break;
 608               case DW_OP_shr:
 609                 binop = BINOP_RSH;
 610               case DW_OP_shra:
 611                 binop = BINOP_RSH;
 612                 val1 = value_from_longest (signed_address_type (), first);
 613                 break;
 614               case DW_OP_xor:
 615                 binop = BINOP_BITWISE_XOR;
 616                 break;
 617               case DW_OP_le:
 618                 binop = BINOP_LEQ;
 619                 break;
 620               case DW_OP_ge:
 621                 binop = BINOP_GEQ;
 622                 break;
 623               case DW_OP_eq:
 624                 binop = BINOP_EQUAL;
 625                 break;
 626               case DW_OP_lt:
 627                 binop = BINOP_LESS;
 628                 break;
 629               case DW_OP_gt:
 630                 binop = BINOP_GTR;
 631                 break;
 632               case DW_OP_ne:
 633                 binop = BINOP_NOTEQUAL;
 634                 break;
 635               default:
 636                 internal_error (__FILE__, __LINE__,
 637                                 "Can't be reached.");
 638               }
 639             result = value_as_long (value_binop (val1, val2, binop));
 640           }
 641           break;
 642
 643         case DW_OP_GNU_push_tls_address:
 644           result = dwarf_expr_fetch (ctx, 0);
 645           dwarf_expr_pop (ctx);
 646           result = (ctx->get_tls_address) (ctx->baton, result);
 647           break;
 648
 649         case DW_OP_skip:
 650           offset = extract_signed_integer (op_ptr, 2);
 651           op_ptr += 2;
 652           op_ptr += offset;
 653           goto no_push;
 654
 655         case DW_OP_bra:
 656           offset = extract_signed_integer (op_ptr, 2);
 657           op_ptr += 2;
 658           if (dwarf_expr_fetch (ctx, 0) != 0)
 659             op_ptr += offset;
 660           dwarf_expr_pop (ctx);
 661           goto no_push;
 662
 663         case DW_OP_nop:
 664           goto no_push;
 665
 666         default:
 667           error ("Unhandled dwarf expression opcode");
 668         }
 669
 670       /* Most things push a result value.  */
 671       dwarf_expr_push (ctx, result);
 672     no_push:;
 673     }
 674 }