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 ()
  39 {
  40   struct dwarf_expr_context *retval;
  41   retval = xcalloc (1, sizeof (struct dwarf_expr_context));
  42   retval->stack_len = 10;
  43   retval->stack = xmalloc (10 * sizeof (CORE_ADDR));
  44   return retval;
  45 }
  46
  47 /* Release the memory allocated to CTX.  */
  48
  49 void
  50 free_dwarf_expr_context (struct dwarf_expr_context *ctx)
  51 {
  52   xfree (ctx->stack);
  53   xfree (ctx);
  54 }
  55
  56 /* Expand the memory allocated to CTX's stack to contain at least
  57    NEED more elements than are currently used.  */
  58
  59 static void
  60 dwarf_expr_grow_stack (struct dwarf_expr_context *ctx, size_t need)
  61 {
  62   if (ctx->stack_len + need > ctx->stack_allocated)
  63     {
  64       size_t templen = ctx->stack_len * 2;
  65       while (templen < (ctx->stack_len + need))
  66            templen *= 2;
  67       ctx->stack = xrealloc (ctx->stack,
  68                              templen * sizeof (CORE_ADDR));
  69       ctx->stack_allocated = templen;
  70     }
  71 }
  72
  73 /* Push VALUE onto CTX's stack.  */
  74
  75 void
  76 dwarf_expr_push (struct dwarf_expr_context *ctx, CORE_ADDR value)
  77 {
  78   dwarf_expr_grow_stack (ctx, 1);
  79   ctx->stack[ctx->stack_len++] = value;
  80 }
  81
  82 /* Pop the top item off of CTX's stack.  */
  83
  84 void
  85 dwarf_expr_pop (struct dwarf_expr_context *ctx)
  86 {
  87   if (ctx->stack_len <= 0)
  88     error ("dwarf expression stack underflow");
  89   ctx->stack_len--;
  90 }
  91
  92 /* Retrieve the N'th item on CTX's stack.  */
  93
  94 CORE_ADDR
  95 dwarf_expr_fetch (struct dwarf_expr_context *ctx, int n)
  96 {
  97   if (ctx->stack_len < n)
  98      error ("Asked for position %d of stack, stack only has %d elements on it\n",
  99             n, ctx->stack_len);
 100   return ctx->stack[ctx->stack_len - (1 + n)];
 101
 102 }
 103
 104 /* Evaluate the expression at ADDR (LEN bytes long) using the context
 105    CTX.  */
 106
 107 void
 108 dwarf_expr_eval (struct dwarf_expr_context *ctx, unsigned char *addr,
 109                  size_t len)
 110 {
 111   execute_stack_op (ctx, addr, addr + len);
 112 }
 113
 114 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 115    by R, and return the new value of BUF.  Verify that it doesn't extend
 116    past BUF_END.  */
 117
 118 unsigned char *
 119 read_uleb128 (unsigned char *buf, unsigned char *buf_end, ULONGEST * r)
 120 {
 121   unsigned shift = 0;
 122   ULONGEST result = 0;
 123   unsigned char byte;
 124
 125   while (1)
 126     {
 127       if (buf >= buf_end)
 128         error ("read_uleb128: Corrupted DWARF expression.");
 129
 130       byte = *buf++;
 131       result |= (byte & 0x7f) << shift;
 132       if ((byte & 0x80) == 0)
 133         break;
 134       shift += 7;
 135     }
 136   *r = result;
 137   return buf;
 138 }
 139
 140 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 141    by R, and return the new value of BUF.  Verify that it doesn't extend
 142    past BUF_END.  */
 143
 144 unsigned char *
 145 read_sleb128 (unsigned char *buf, unsigned char *buf_end, LONGEST * r)
 146 {
 147   unsigned shift = 0;
 148   LONGEST result = 0;
 149   unsigned char byte;
 150
 151   while (1)
 152     {
 153       if (buf >= buf_end)
 154         error ("read_sleb128: Corrupted DWARF expression.");
 155
 156       byte = *buf++;
 157       result |= (byte & 0x7f) << shift;
 158       shift += 7;
 159       if ((byte & 0x80) == 0)
 160         break;
 161     }
 162   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 163     result |= -(1 << shift);
 164
 165   *r = result;
 166   return buf;
 167 }
 168
 169 /* Read an address from BUF, and verify that it doesn't extend past
 170    BUF_END.  The address is returned, and *BYTES_READ is set to the
 171    number of bytes read from BUF.  */
 172
 173 static CORE_ADDR
 174 read_address (unsigned char *buf, unsigned char *buf_end, int *bytes_read)
 175 {
 176   CORE_ADDR result;
 177
 178   if (buf_end - buf < TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 179     error ("read_address: Corrupted DWARF expression.");
 180
 181   *bytes_read = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
 182   result = extract_address (buf, TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 183   return result;
 184 }
 185
 186 /* Return the type of an address, for unsigned arithmetic.  */
 187
 188 static struct type *
 189 unsigned_address_type (void)
 190 {
 191   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 192     {
 193     case 2:
 194       return builtin_type_uint16;
 195     case 4:
 196       return builtin_type_uint32;
 197     case 8:
 198       return builtin_type_uint64;
 199     default:
 200       internal_error (__FILE__, __LINE__,
 201                       "Unsupported address size.\n");
 202     }
 203 }
 204
 205 /* Return the type of an address, for signed arithmetic.  */
 206
 207 static struct type *
 208 signed_address_type (void)
 209 {
 210   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 211     {
 212     case 2:
 213       return builtin_type_int16;
 214     case 4:
 215       return builtin_type_int32;
 216     case 8:
 217       return builtin_type_int64;
 218     default:
 219       internal_error (__FILE__, __LINE__,
 220                       "Unsupported address size.\n");
 221     }
 222 }
 223 \f
 224 /* The engine for the expression evaluator.  Using the context in CTX,
 225    evaluate the expression between OP_PTR and OP_END.  */
 226
 227 static void
 228 execute_stack_op (struct dwarf_expr_context *ctx, unsigned char *op_ptr,
 229                   unsigned char *op_end)
 230 {
 231   while (op_ptr < op_end)
 232     {
 233       enum dwarf_location_atom op = *op_ptr++;
 234       CORE_ADDR result, memaddr;
 235       ULONGEST uoffset, reg;
 236       LONGEST offset;
 237       int bytes_read;
 238       enum lval_type expr_lval;
 239
 240       ctx->in_reg = 0;
 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 = 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           /* NOTE: in the presence of DW_OP_piece this check is incorrect.  */
 360           if (op_ptr != op_end)
 361             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 362                    "used alone.");
 363
 364           /* FIXME drow/2003-02-21: This call to read_reg could be pushed
 365              into the evaluator's caller by changing the semantics for in_reg.
 366              Then we wouldn't need to return an lval_type and a memaddr.  */
 367           result = (ctx->read_reg) (ctx->baton, op - DW_OP_reg0, &expr_lval,
 368                                     &memaddr);
 369
 370           if (expr_lval == lval_register)
 371             {
 372               ctx->regnum = op - DW_OP_reg0;
 373               ctx->in_reg = 1;
 374             }
 375           else
 376             result = memaddr;
 377
 378           break;
 379
 380         case DW_OP_regx:
 381           op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 382           if (op_ptr != op_end)
 383             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 384                    "used alone.");
 385
 386           result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
 387
 388           if (expr_lval == lval_register)
 389             {
 390               ctx->regnum = reg;
 391               ctx->in_reg = 1;
 392             }
 393           else
 394             result = memaddr;
 395
 396           break;
 397
 398         case DW_OP_breg0:
 399         case DW_OP_breg1:
 400         case DW_OP_breg2:
 401         case DW_OP_breg3:
 402         case DW_OP_breg4:
 403         case DW_OP_breg5:
 404         case DW_OP_breg6:
 405         case DW_OP_breg7:
 406         case DW_OP_breg8:
 407         case DW_OP_breg9:
 408         case DW_OP_breg10:
 409         case DW_OP_breg11:
 410         case DW_OP_breg12:
 411         case DW_OP_breg13:
 412         case DW_OP_breg14:
 413         case DW_OP_breg15:
 414         case DW_OP_breg16:
 415         case DW_OP_breg17:
 416         case DW_OP_breg18:
 417         case DW_OP_breg19:
 418         case DW_OP_breg20:
 419         case DW_OP_breg21:
 420         case DW_OP_breg22:
 421         case DW_OP_breg23:
 422         case DW_OP_breg24:
 423         case DW_OP_breg25:
 424         case DW_OP_breg26:
 425         case DW_OP_breg27:
 426         case DW_OP_breg28:
 427         case DW_OP_breg29:
 428         case DW_OP_breg30:
 429         case DW_OP_breg31:
 430           {
 431             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 432             result = (ctx->read_reg) (ctx->baton, op - DW_OP_breg0,
 433                                       &expr_lval, &memaddr);
 434             result += offset;
 435           }
 436           break;
 437         case DW_OP_bregx:
 438           {
 439             op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 440             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 441             result = (ctx->read_reg) (ctx->baton, reg, &expr_lval, &memaddr);
 442             result += offset;
 443           }
 444           break;
 445         case DW_OP_fbreg:
 446           {
 447             unsigned char *datastart;
 448             size_t datalen;
 449             unsigned int before_stack_len;
 450
 451             op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 452             /* Rather than create a whole new context, we simply
 453                record the stack length before execution, then reset it
 454                afterwards, effectively erasing whatever the recursive
 455                call put there.  */
 456             before_stack_len = ctx->stack_len;
 457             (ctx->get_frame_base) (ctx->baton, &datastart, &datalen);
 458             dwarf_expr_eval (ctx, datastart, datalen);
 459             result = dwarf_expr_fetch (ctx, 0);
 460             if (! ctx->in_reg)
 461               {
 462                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 463                 int bytes_read;
 464
 465                 (ctx->read_mem) (ctx->baton, buf, result,
 466                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 467                 result = read_address (buf,
 468                                        buf + TARGET_ADDR_BIT / TARGET_CHAR_BIT,
 469                                        &bytes_read);
 470               }
 471             result = result + offset;
 472             ctx->stack_len = before_stack_len;
 473             ctx->in_reg = 0;
 474           }
 475           break;
 476         case DW_OP_dup:
 477           result = dwarf_expr_fetch (ctx, 0);
 478           break;
 479
 480         case DW_OP_drop:
 481           dwarf_expr_pop (ctx);
 482           goto no_push;
 483
 484         case DW_OP_pick:
 485           offset = *op_ptr++;
 486           result = dwarf_expr_fetch (ctx, offset);
 487           break;
 488
 489         case DW_OP_over:
 490           result = dwarf_expr_fetch (ctx, 1);
 491           break;
 492
 493         case DW_OP_rot:
 494           {
 495             CORE_ADDR t1, t2, t3;
 496
 497             if (ctx->stack_len < 3)
 498                error ("Not enough elements for DW_OP_rot. Need 3, have %d\n",
 499                       ctx->stack_len);
 500             t1 = ctx->stack[ctx->stack_len - 1];
 501             t2 = ctx->stack[ctx->stack_len - 2];
 502             t3 = ctx->stack[ctx->stack_len - 3];
 503             ctx->stack[ctx->stack_len - 1] = t2;
 504             ctx->stack[ctx->stack_len - 2] = t3;
 505             ctx->stack[ctx->stack_len - 3] = t1;
 506             goto no_push;
 507           }
 508
 509         case DW_OP_deref:
 510         case DW_OP_deref_size:
 511         case DW_OP_abs:
 512         case DW_OP_neg:
 513         case DW_OP_not:
 514         case DW_OP_plus_uconst:
 515           /* Unary operations.  */
 516           result = dwarf_expr_fetch (ctx, 0);
 517           dwarf_expr_pop (ctx);
 518
 519           switch (op)
 520             {
 521             case DW_OP_deref:
 522               {
 523                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 524                 int bytes_read;
 525
 526                 (ctx->read_mem) (ctx->baton, buf, result,
 527                                  TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 528                 result = read_address (buf,
 529                                        buf + TARGET_ADDR_BIT / TARGET_CHAR_BIT,
 530                                        &bytes_read);
 531               }
 532               break;
 533
 534             case DW_OP_deref_size:
 535               {
 536                 char *buf = alloca (TARGET_ADDR_BIT / TARGET_CHAR_BIT);
 537                 int bytes_read;
 538
 539                 (ctx->read_mem) (ctx->baton, buf, result, *op_ptr++);
 540                 result = read_address (buf,
 541                                        buf + TARGET_ADDR_BIT / TARGET_CHAR_BIT,
 542                                        &bytes_read);
 543               }
 544               break;
 545
 546             case DW_OP_abs:
 547               if ((signed int) result < 0)
 548                 result = -result;
 549               break;
 550             case DW_OP_neg:
 551               result = -result;
 552               break;
 553             case DW_OP_not:
 554               result = ~result;
 555               break;
 556             case DW_OP_plus_uconst:
 557               op_ptr = read_uleb128 (op_ptr, op_end, &reg);
 558               result += reg;
 559               break;
 560             }
 561           break;
 562
 563         case DW_OP_and:
 564         case DW_OP_div:
 565         case DW_OP_minus:
 566         case DW_OP_mod:
 567         case DW_OP_mul:
 568         case DW_OP_or:
 569         case DW_OP_plus:
 570         case DW_OP_shl:
 571         case DW_OP_shr:
 572         case DW_OP_shra:
 573         case DW_OP_xor:
 574         case DW_OP_le:
 575         case DW_OP_ge:
 576         case DW_OP_eq:
 577         case DW_OP_lt:
 578         case DW_OP_gt:
 579         case DW_OP_ne:
 580           {
 581             /* Binary operations.  Use the value engine to do computations in
 582                the right width.  */
 583             CORE_ADDR first, second;
 584             enum exp_opcode binop;
 585             struct value *val1, *val2;
 586
 587             second = dwarf_expr_fetch (ctx, 0);
 588             dwarf_expr_pop (ctx);
 589
 590             first = dwarf_expr_fetch (ctx, 1);
 591             dwarf_expr_pop (ctx);
 592
 593             val1 = value_from_longest (unsigned_address_type (), first);
 594             val2 = value_from_longest (unsigned_address_type (), second);
 595
 596             switch (op)
 597               {
 598               case DW_OP_and:
 599                 binop = BINOP_BITWISE_AND;
 600                 break;
 601               case DW_OP_div:
 602                 binop = BINOP_DIV;
 603               case DW_OP_minus:
 604                 binop = BINOP_SUB;
 605                 break;
 606               case DW_OP_mod:
 607                 binop = BINOP_MOD;
 608                 break;
 609               case DW_OP_mul:
 610                 binop = BINOP_MUL;
 611                 break;
 612               case DW_OP_or:
 613                 binop = BINOP_BITWISE_IOR;
 614                 break;
 615               case DW_OP_plus:
 616                 binop = BINOP_ADD;
 617                 break;
 618               case DW_OP_shl:
 619                 binop = BINOP_LSH;
 620                 break;
 621               case DW_OP_shr:
 622                 binop = BINOP_RSH;
 623               case DW_OP_shra:
 624                 binop = BINOP_RSH;
 625                 val1 = value_from_longest (signed_address_type (), first);
 626                 break;
 627               case DW_OP_xor:
 628                 binop = BINOP_BITWISE_XOR;
 629                 break;
 630               case DW_OP_le:
 631                 binop = BINOP_LEQ;
 632                 break;
 633               case DW_OP_ge:
 634                 binop = BINOP_GEQ;
 635                 break;
 636               case DW_OP_eq:
 637                 binop = BINOP_EQUAL;
 638                 break;
 639               case DW_OP_lt:
 640                 binop = BINOP_LESS;
 641                 break;
 642               case DW_OP_gt:
 643                 binop = BINOP_GTR;
 644                 break;
 645               case DW_OP_ne:
 646                 binop = BINOP_NOTEQUAL;
 647                 break;
 648               default:
 649                 internal_error (__FILE__, __LINE__,
 650                                 "Can't be reached.");
 651               }
 652             result = value_as_long (value_binop (val1, val2, binop));
 653           }
 654           break;
 655
 656         case DW_OP_GNU_push_tls_address:
 657           result = dwarf_expr_fetch (ctx, 0);
 658           dwarf_expr_pop (ctx);
 659           result = (ctx->get_tls_address) (ctx->baton, result);
 660           break;
 661
 662         case DW_OP_skip:
 663           offset = extract_signed_integer (op_ptr, 2);
 664           op_ptr += 2;
 665           op_ptr += offset;
 666           goto no_push;
 667
 668         case DW_OP_bra:
 669           offset = extract_signed_integer (op_ptr, 2);
 670           op_ptr += 2;
 671           if (dwarf_expr_fetch (ctx, 0) != 0)
 672             op_ptr += offset;
 673           dwarf_expr_pop (ctx);
 674           goto no_push;
 675
 676         case DW_OP_nop:
 677           goto no_push;
 678
 679         default:
 680           error ("Unhandled dwarf expression opcode");
 681         }
 682
 683       /* Most things push a result value.  */
 684       dwarf_expr_push (ctx, result);
 685     no_push:;
 686     }
 687 }