gdb/dwarf2expr.c

   1 /* Dwarf2 Expression Evaluator
   2    Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Daniel Berlin ([email protected])
   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           /* Variable is at a constant offset in the thread-local
 645           storage block into the objfile for the current thread and
 646           the dynamic linker module containing this expression. Here
 647           we return returns the offset from that base.  The top of the
 648           stack has the offset from the beginning of the thread
 649           control block at which the variable is located.  Nothing
 650           should follow this operator, so the top of stack would be
 651           returned.  */
 652           result = dwarf_expr_fetch (ctx, 0);
 653           dwarf_expr_pop (ctx);
 654           result = (ctx->get_tls_address) (ctx->baton, result);
 655           break;
 656
 657         case DW_OP_skip:
 658           offset = extract_signed_integer (op_ptr, 2);
 659           op_ptr += 2;
 660           op_ptr += offset;
 661           goto no_push;
 662
 663         case DW_OP_bra:
 664           offset = extract_signed_integer (op_ptr, 2);
 665           op_ptr += 2;
 666           if (dwarf_expr_fetch (ctx, 0) != 0)
 667             op_ptr += offset;
 668           dwarf_expr_pop (ctx);
 669           goto no_push;
 670
 671         case DW_OP_nop:
 672           goto no_push;
 673
 674         default:
 675           error ("Unhandled dwarf expression opcode");
 676         }
 677
 678       /* Most things push a result value.  */
 679       dwarf_expr_push (ctx, result);
 680     no_push:;
 681     }
 682 }