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 = 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 CORE_ADDR
 174 dwarf2_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 ("dwarf2_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;
 235       ULONGEST uoffset, reg;
 236       LONGEST offset;
 237       int bytes_read;
 238
 239       ctx->in_reg = 0;
 240
 241       switch (op)
 242         {
 243         case DW_OP_lit0:
 244         case DW_OP_lit1:
 245         case DW_OP_lit2:
 246         case DW_OP_lit3:
 247         case DW_OP_lit4:
 248         case DW_OP_lit5:
 249         case DW_OP_lit6:
 250         case DW_OP_lit7:
 251         case DW_OP_lit8:
 252         case DW_OP_lit9:
 253         case DW_OP_lit10:
 254         case DW_OP_lit11:
 255         case DW_OP_lit12:
 256         case DW_OP_lit13:
 257         case DW_OP_lit14:
 258         case DW_OP_lit15:
 259         case DW_OP_lit16:
 260         case DW_OP_lit17:
 261         case DW_OP_lit18:
 262         case DW_OP_lit19:
 263         case DW_OP_lit20:
 264         case DW_OP_lit21:
 265         case DW_OP_lit22:
 266         case DW_OP_lit23:
 267         case DW_OP_lit24:
 268         case DW_OP_lit25:
 269         case DW_OP_lit26:
 270         case DW_OP_lit27:
 271         case DW_OP_lit28:
 272         case DW_OP_lit29:
 273         case DW_OP_lit30:
 274         case DW_OP_lit31:
 275           result = op - DW_OP_lit0;
 276           break;
 277
 278         case DW_OP_addr:
 279           result = dwarf2_read_address (op_ptr, op_end, &bytes_read);
 280           op_ptr += bytes_read;
 281           break;
 282
 283         case DW_OP_const1u:
 284           result = extract_unsigned_integer (op_ptr, 1);
 285           op_ptr += 1;
 286           break;
 287         case DW_OP_const1s:
 288           result = extract_signed_integer (op_ptr, 1);
 289           op_ptr += 1;
 290           break;
 291         case DW_OP_const2u:
 292           result = extract_unsigned_integer (op_ptr, 2);
 293           op_ptr += 2;
 294           break;
 295         case DW_OP_const2s:
 296           result = extract_signed_integer (op_ptr, 2);
 297           op_ptr += 2;
 298           break;
 299         case DW_OP_const4u:
 300           result = extract_unsigned_integer (op_ptr, 4);
 301           op_ptr += 4;
 302           break;
 303         case DW_OP_const4s:
 304           result = extract_signed_integer (op_ptr, 4);
 305           op_ptr += 4;
 306           break;
 307         case DW_OP_const8u:
 308           result = extract_unsigned_integer (op_ptr, 8);
 309           op_ptr += 8;
 310           break;
 311         case DW_OP_const8s:
 312           result = extract_signed_integer (op_ptr, 8);
 313           op_ptr += 8;
 314           break;
 315         case DW_OP_constu:
 316           op_ptr = read_uleb128 (op_ptr, op_end, &uoffset);
 317           result = uoffset;
 318           break;
 319         case DW_OP_consts:
 320           op_ptr = read_sleb128 (op_ptr, op_end, &offset);
 321           result = offset;
 322           break;
 323
 324         /* The DW_OP_reg operations are required to occur alone in
 325            location expressions.  */
 326         case DW_OP_reg0:
 327         case DW_OP_reg1:
 328         case DW_OP_reg2:
 329         case DW_OP_reg3:
 330         case DW_OP_reg4:
 331         case DW_OP_reg5:
 332         case DW_OP_reg6:
 333         case DW_OP_reg7:
 334         case DW_OP_reg8:
 335         case DW_OP_reg9:
 336         case DW_OP_reg10:
 337         case DW_OP_reg11:
 338         case DW_OP_reg12:
 339         case DW_OP_reg13:
 340         case DW_OP_reg14:
 341         case DW_OP_reg15:
 342         case DW_OP_reg16:
 343         case DW_OP_reg17:
 344         case DW_OP_reg18:
 345         case DW_OP_reg19:
 346         case DW_OP_reg20:
 347         case DW_OP_reg21:
 348         case DW_OP_reg22:
 349         case DW_OP_reg23:
 350         case DW_OP_reg24:
 351         case DW_OP_reg25:
 352         case DW_OP_reg26:
 353         case DW_OP_reg27:
 354         case DW_OP_reg28:
 355         case DW_OP_reg29:
 356         case DW_OP_reg30:
 357         case DW_OP_reg31:
 358           /* NOTE: in the presence of DW_OP_piece this check is incorrect.  */
 359           if (op_ptr != op_end)
 360             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 361                    "used alone.");
 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)
 371             error ("DWARF-2 expression error: DW_OP_reg operations must be "
 372                    "used alone.");
 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 }