gdb/compile/compile-loc2c.c

   1 /* Convert a DWARF location expression to C
   2
   3    Copyright (C) 2014-2019 Free Software Foundation, Inc.
   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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "dwarf2.h"
  22 #include "dwarf2expr.h"
  23 #include "dwarf2loc.h"
  24 #include "ui-file.h"
  25 #include "utils.h"
  26 #include "compile-internal.h"
  27 #include "compile-c.h"
  28 #include "compile.h"
  29 #include "block.h"
  30 #include "dwarf2-frame.h"
  31 #include "common/gdb_vecs.h"
  32 #include "value.h"
  33
  34 \f
  35
  36 /* Information about a given instruction.  */
  37
  38 struct insn_info
  39 {
  40   /* Stack depth at entry.  */
  41
  42   unsigned int depth;
  43
  44   /* Whether this instruction has been visited.  */
  45
  46   unsigned int visited : 1;
  47
  48   /* Whether this instruction needs a label.  */
  49
  50   unsigned int label : 1;
  51
  52   /* Whether this instruction is DW_OP_GNU_push_tls_address or
  53      DW_OP_form_tls_address.  This is a hack until we can add a
  54      feature to glibc to let us properly generate code for TLS.  */
  55
  56   unsigned int is_tls : 1;
  57 };
  58
  59 /* A helper function for compute_stack_depth that does the work.  This
  60    examines the DWARF expression starting from START and computes
  61    stack effects.
  62
  63    NEED_TEMPVAR is an out parameter which is set if this expression
  64    needs a special temporary variable to be emitted (see the code
  65    generator).
  66    INFO is a vector of insn_info objects, indexed by offset from the
  67    start of the DWARF expression.
  68    TO_DO is a list of bytecodes which must be examined; it may be
  69    added to by this function.
  70    BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
  71    OP_PTR and OP_END are the bounds of the DWARF expression.  */
  72
  73 static void
  74 compute_stack_depth_worker (int start, int *need_tempvar,
  75                             std::vector<struct insn_info> *info,
  76                             std::vector<int> *to_do,
  77                             enum bfd_endian byte_order, unsigned int addr_size,
  78                             const gdb_byte *op_ptr, const gdb_byte *op_end)
  79 {
  80   const gdb_byte * const base = op_ptr;
  81   int stack_depth;
  82
  83   op_ptr += start;
  84   gdb_assert ((*info)[start].visited);
  85   stack_depth = (*info)[start].depth;
  86
  87   while (op_ptr < op_end)
  88     {
  89       enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
  90       uint64_t reg;
  91       int64_t offset;
  92       int ndx = op_ptr - base;
  93
  94 #define SET_CHECK_DEPTH(WHERE)                          \
  95       if ((*info)[WHERE].visited)                               \
  96         {                                               \
  97           if ((*info)[WHERE].depth != stack_depth)              \
  98             error (_("inconsistent stack depths"));     \
  99         }                                               \
 100       else                                              \
 101         {                                               \
 102           /* Stack depth not set, so set it.  */        \
 103           (*info)[WHERE].visited = 1;                   \
 104           (*info)[WHERE].depth = stack_depth;           \
 105         }
 106
 107       SET_CHECK_DEPTH (ndx);
 108
 109       ++op_ptr;
 110
 111       switch (op)
 112         {
 113         case DW_OP_lit0:
 114         case DW_OP_lit1:
 115         case DW_OP_lit2:
 116         case DW_OP_lit3:
 117         case DW_OP_lit4:
 118         case DW_OP_lit5:
 119         case DW_OP_lit6:
 120         case DW_OP_lit7:
 121         case DW_OP_lit8:
 122         case DW_OP_lit9:
 123         case DW_OP_lit10:
 124         case DW_OP_lit11:
 125         case DW_OP_lit12:
 126         case DW_OP_lit13:
 127         case DW_OP_lit14:
 128         case DW_OP_lit15:
 129         case DW_OP_lit16:
 130         case DW_OP_lit17:
 131         case DW_OP_lit18:
 132         case DW_OP_lit19:
 133         case DW_OP_lit20:
 134         case DW_OP_lit21:
 135         case DW_OP_lit22:
 136         case DW_OP_lit23:
 137         case DW_OP_lit24:
 138         case DW_OP_lit25:
 139         case DW_OP_lit26:
 140         case DW_OP_lit27:
 141         case DW_OP_lit28:
 142         case DW_OP_lit29:
 143         case DW_OP_lit30:
 144         case DW_OP_lit31:
 145           ++stack_depth;
 146           break;
 147
 148         case DW_OP_addr:
 149           op_ptr += addr_size;
 150           ++stack_depth;
 151           break;
 152
 153         case DW_OP_const1u:
 154         case DW_OP_const1s:
 155           op_ptr += 1;
 156           ++stack_depth;
 157           break;
 158         case DW_OP_const2u:
 159         case DW_OP_const2s:
 160           op_ptr += 2;
 161           ++stack_depth;
 162           break;
 163         case DW_OP_const4u:
 164         case DW_OP_const4s:
 165           op_ptr += 4;
 166           ++stack_depth;
 167           break;
 168         case DW_OP_const8u:
 169         case DW_OP_const8s:
 170           op_ptr += 8;
 171           ++stack_depth;
 172           break;
 173         case DW_OP_constu:
 174         case DW_OP_consts:
 175           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 176           ++stack_depth;
 177           break;
 178
 179         case DW_OP_reg0:
 180         case DW_OP_reg1:
 181         case DW_OP_reg2:
 182         case DW_OP_reg3:
 183         case DW_OP_reg4:
 184         case DW_OP_reg5:
 185         case DW_OP_reg6:
 186         case DW_OP_reg7:
 187         case DW_OP_reg8:
 188         case DW_OP_reg9:
 189         case DW_OP_reg10:
 190         case DW_OP_reg11:
 191         case DW_OP_reg12:
 192         case DW_OP_reg13:
 193         case DW_OP_reg14:
 194         case DW_OP_reg15:
 195         case DW_OP_reg16:
 196         case DW_OP_reg17:
 197         case DW_OP_reg18:
 198         case DW_OP_reg19:
 199         case DW_OP_reg20:
 200         case DW_OP_reg21:
 201         case DW_OP_reg22:
 202         case DW_OP_reg23:
 203         case DW_OP_reg24:
 204         case DW_OP_reg25:
 205         case DW_OP_reg26:
 206         case DW_OP_reg27:
 207         case DW_OP_reg28:
 208         case DW_OP_reg29:
 209         case DW_OP_reg30:
 210         case DW_OP_reg31:
 211           ++stack_depth;
 212           break;
 213
 214         case DW_OP_regx:
 215           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 216           ++stack_depth;
 217           break;
 218
 219         case DW_OP_breg0:
 220         case DW_OP_breg1:
 221         case DW_OP_breg2:
 222         case DW_OP_breg3:
 223         case DW_OP_breg4:
 224         case DW_OP_breg5:
 225         case DW_OP_breg6:
 226         case DW_OP_breg7:
 227         case DW_OP_breg8:
 228         case DW_OP_breg9:
 229         case DW_OP_breg10:
 230         case DW_OP_breg11:
 231         case DW_OP_breg12:
 232         case DW_OP_breg13:
 233         case DW_OP_breg14:
 234         case DW_OP_breg15:
 235         case DW_OP_breg16:
 236         case DW_OP_breg17:
 237         case DW_OP_breg18:
 238         case DW_OP_breg19:
 239         case DW_OP_breg20:
 240         case DW_OP_breg21:
 241         case DW_OP_breg22:
 242         case DW_OP_breg23:
 243         case DW_OP_breg24:
 244         case DW_OP_breg25:
 245         case DW_OP_breg26:
 246         case DW_OP_breg27:
 247         case DW_OP_breg28:
 248         case DW_OP_breg29:
 249         case DW_OP_breg30:
 250         case DW_OP_breg31:
 251           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 252           ++stack_depth;
 253           break;
 254         case DW_OP_bregx:
 255           {
 256             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 257             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 258             ++stack_depth;
 259           }
 260           break;
 261         case DW_OP_fbreg:
 262           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 263           ++stack_depth;
 264           break;
 265
 266         case DW_OP_dup:
 267           ++stack_depth;
 268           break;
 269
 270         case DW_OP_drop:
 271           --stack_depth;
 272           break;
 273
 274         case DW_OP_pick:
 275           ++op_ptr;
 276           ++stack_depth;
 277           break;
 278
 279         case DW_OP_rot:
 280         case DW_OP_swap:
 281           *need_tempvar = 1;
 282           break;
 283
 284         case DW_OP_over:
 285           ++stack_depth;
 286           break;
 287
 288         case DW_OP_abs:
 289         case DW_OP_neg:
 290         case DW_OP_not:
 291         case DW_OP_deref:
 292           break;
 293
 294         case DW_OP_deref_size:
 295           ++op_ptr;
 296           break;
 297
 298         case DW_OP_plus_uconst:
 299           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 300           break;
 301
 302         case DW_OP_div:
 303         case DW_OP_shra:
 304         case DW_OP_and:
 305         case DW_OP_minus:
 306         case DW_OP_mod:
 307         case DW_OP_mul:
 308         case DW_OP_or:
 309         case DW_OP_plus:
 310         case DW_OP_shl:
 311         case DW_OP_shr:
 312         case DW_OP_xor:
 313         case DW_OP_le:
 314         case DW_OP_ge:
 315         case DW_OP_eq:
 316         case DW_OP_lt:
 317         case DW_OP_gt:
 318         case DW_OP_ne:
 319           --stack_depth;
 320           break;
 321
 322         case DW_OP_call_frame_cfa:
 323           ++stack_depth;
 324           break;
 325
 326         case DW_OP_GNU_push_tls_address:
 327         case DW_OP_form_tls_address:
 328           (*info)[ndx].is_tls = 1;
 329           break;
 330
 331         case DW_OP_skip:
 332           offset = extract_signed_integer (op_ptr, 2, byte_order);
 333           op_ptr += 2;
 334           offset = op_ptr + offset - base;
 335           /* If the destination has not been seen yet, add it to the
 336              to-do list.  */
 337           if (!(*info)[offset].visited)
 338             to_do->push_back (offset);
 339           SET_CHECK_DEPTH (offset);
 340           (*info)[offset].label = 1;
 341           /* We're done with this line of code.  */
 342           return;
 343
 344         case DW_OP_bra:
 345           offset = extract_signed_integer (op_ptr, 2, byte_order);
 346           op_ptr += 2;
 347           offset = op_ptr + offset - base;
 348           --stack_depth;
 349           /* If the destination has not been seen yet, add it to the
 350              to-do list.  */
 351           if (!(*info)[offset].visited)
 352             to_do->push_back (offset);
 353           SET_CHECK_DEPTH (offset);
 354           (*info)[offset].label = 1;
 355           break;
 356
 357         case DW_OP_nop:
 358           break;
 359
 360         default:
 361           error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
 362         }
 363     }
 364
 365   gdb_assert (op_ptr == op_end);
 366
 367 #undef SET_CHECK_DEPTH
 368 }
 369
 370 /* Compute the maximum needed stack depth of a DWARF expression, and
 371    some other information as well.
 372
 373    BYTE_ORDER and ADDR_SIZE describe this bytecode in the obvious way.
 374    NEED_TEMPVAR is an out parameter which is set if this expression
 375    needs a special temporary variable to be emitted (see the code
 376    generator).
 377    IS_TLS is an out parameter which is set if this expression refers
 378    to a TLS variable.
 379    OP_PTR and OP_END are the bounds of the DWARF expression.
 380    INITIAL_DEPTH is the initial depth of the DWARF expression stack.
 381    INFO is an array of insn_info objects, indexed by offset from the
 382    start of the DWARF expression.
 383
 384    This returns the maximum stack depth.  */
 385
 386 static int
 387 compute_stack_depth (enum bfd_endian byte_order, unsigned int addr_size,
 388                      int *need_tempvar, int *is_tls,
 389                      const gdb_byte *op_ptr, const gdb_byte *op_end,
 390                      int initial_depth,
 391                      std::vector<struct insn_info> *info)
 392 {
 393   std::vector<int> to_do;
 394   int stack_depth, i;
 395
 396   info->resize (op_end - op_ptr);
 397
 398   to_do.push_back (0);
 399   (*info)[0].depth = initial_depth;
 400   (*info)[0].visited = 1;
 401
 402   while (!to_do.empty ())
 403     {
 404       int ndx = to_do.back ();
 405       to_do.pop_back ();
 406
 407       compute_stack_depth_worker (ndx, need_tempvar, info, &to_do,
 408                                   byte_order, addr_size,
 409                                   op_ptr, op_end);
 410     }
 411
 412   stack_depth = 0;
 413   *is_tls = 0;
 414   for (i = 0; i < op_end - op_ptr; ++i)
 415     {
 416       if ((*info)[i].depth > stack_depth)
 417         stack_depth = (*info)[i].depth;
 418       if ((*info)[i].is_tls)
 419         *is_tls = 1;
 420     }
 421
 422   return stack_depth + 1;
 423 }
 424
 425 \f
 426
 427 #define GCC_UINTPTR "__gdb_uintptr"
 428 #define GCC_INTPTR "__gdb_intptr"
 429
 430 /* Emit code to push a constant.  */
 431
 432 static void
 433 push (int indent, string_file *stream, ULONGEST l)
 434 {
 435   fprintfi_filtered (indent, stream,
 436                      "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
 437                      hex_string (l));
 438 }
 439
 440 /* Emit code to push an arbitrary expression.  This works like
 441    printf.  */
 442
 443 static void pushf (int indent, string_file *stream, const char *format, ...)
 444   ATTRIBUTE_PRINTF (3, 4);
 445
 446 static void
 447 pushf (int indent, string_file *stream, const char *format, ...)
 448 {
 449   va_list args;
 450
 451   fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
 452   va_start (args, format);
 453   stream->vprintf (format, args);
 454   va_end (args);
 455   stream->puts (";\n");
 456
 457   fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
 458 }
 459
 460 /* Emit code for a unary expression -- one which operates in-place on
 461    the top-of-stack.  This works like printf.  */
 462
 463 static void unary (int indent, string_file *stream, const char *format, ...)
 464   ATTRIBUTE_PRINTF (3, 4);
 465
 466 static void
 467 unary (int indent, string_file *stream, const char *format, ...)
 468 {
 469   va_list args;
 470
 471   fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
 472   va_start (args, format);
 473   stream->vprintf (format, args);
 474   va_end (args);
 475   stream->puts (";\n");
 476 }
 477
 478 /* Emit code for a unary expression -- one which uses the top two
 479    stack items, popping the topmost one.  This works like printf.  */
 480 static void binary (int indent, string_file *stream, const char *format, ...)
 481   ATTRIBUTE_PRINTF (3, 4);
 482
 483 static void
 484 binary (int indent, string_file *stream, const char *format, ...)
 485 {
 486   va_list args;
 487
 488   fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
 489   va_start (args, format);
 490   stream->vprintf (format, args);
 491   va_end (args);
 492   stream->puts (";\n");
 493   fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
 494 }
 495
 496 /* Print the name of a label given its "SCOPE", an arbitrary integer
 497    used for uniqueness, and its TARGET, the bytecode offset
 498    corresponding to the label's point of definition.  */
 499
 500 static void
 501 print_label (string_file *stream, unsigned int scope, int target)
 502 {
 503   stream->printf ("__label_%u_%s", scope, pulongest (target));
 504 }
 505
 506 /* Emit code that pushes a register's address on the stack.
 507    REGISTERS_USED is an out parameter which is updated to note which
 508    register was needed by this expression.  */
 509
 510 static void
 511 pushf_register_address (int indent, string_file *stream,
 512                         unsigned char *registers_used,
 513                         struct gdbarch *gdbarch, int regnum)
 514 {
 515   std::string regname = compile_register_name_mangled (gdbarch, regnum);
 516
 517   registers_used[regnum] = 1;
 518   pushf (indent, stream,
 519          "(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
 520          regname.c_str ());
 521 }
 522
 523 /* Emit code that pushes a register's value on the stack.
 524    REGISTERS_USED is an out parameter which is updated to note which
 525    register was needed by this expression.  OFFSET is added to the
 526    register's value before it is pushed.  */
 527
 528 static void
 529 pushf_register (int indent, string_file *stream,
 530                 unsigned char *registers_used,
 531                 struct gdbarch *gdbarch, int regnum, uint64_t offset)
 532 {
 533   std::string regname = compile_register_name_mangled (gdbarch, regnum);
 534
 535   registers_used[regnum] = 1;
 536   if (offset == 0)
 537     pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
 538            regname.c_str ());
 539   else
 540     pushf (indent, stream,
 541            COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
 542            regname.c_str (), hex_string (offset));
 543 }
 544
 545 /* Compile a DWARF expression to C code.
 546
 547    INDENT is the indentation level to use.
 548    STREAM is the stream where the code should be written.
 549
 550    TYPE_NAME names the type of the result of the DWARF expression.
 551    For locations this is "void *" but for array bounds it will be an
 552    integer type.
 553
 554    RESULT_NAME is the name of a variable in the resulting C code.  The
 555    result of the expression will be assigned to this variable.
 556
 557    SYM is the symbol corresponding to this expression.
 558    PC is the location at which the expression is being evaluated.
 559    ARCH is the architecture to use.
 560
 561    REGISTERS_USED is an out parameter which is updated to note which
 562    registers were needed by this expression.
 563
 564    ADDR_SIZE is the DWARF address size to use.
 565
 566    OPT_PTR and OP_END are the bounds of the DWARF expression.
 567
 568    If non-NULL, INITIAL points to an initial value to write to the
 569    stack.  If NULL, no initial value is written.
 570
 571    PER_CU is the per-CU object used for looking up various other
 572    things.  */
 573
 574 static void
 575 do_compile_dwarf_expr_to_c (int indent, string_file *stream,
 576                             const char *type_name,
 577                             const char *result_name,
 578                             struct symbol *sym, CORE_ADDR pc,
 579                             struct gdbarch *arch,
 580                             unsigned char *registers_used,
 581                             unsigned int addr_size,
 582                             const gdb_byte *op_ptr, const gdb_byte *op_end,
 583                             CORE_ADDR *initial,
 584                             struct dwarf2_per_cu_data *per_cu)
 585 {
 586   /* We keep a counter so that labels and other objects we create have
 587      unique names.  */
 588   static unsigned int scope;
 589
 590   enum bfd_endian byte_order = gdbarch_byte_order (arch);
 591   const gdb_byte * const base = op_ptr;
 592   int need_tempvar = 0;
 593   int is_tls = 0;
 594   std::vector<struct insn_info> info;
 595   int stack_depth;
 596
 597   ++scope;
 598
 599   fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
 600                      type_name, result_name);
 601   fprintfi_filtered (indent, stream, "{\n");
 602   indent += 2;
 603
 604   stack_depth = compute_stack_depth (byte_order, addr_size,
 605                                      &need_tempvar, &is_tls,
 606                                      op_ptr, op_end, initial != NULL,
 607                                      &info);
 608
 609   /* This is a hack until we can add a feature to glibc to let us
 610      properly generate code for TLS.  You might think we could emit
 611      the address in the ordinary course of translating
 612      DW_OP_GNU_push_tls_address, but since the operand appears on the
 613      stack, it is relatively hard to find, and the idea of calling
 614      target_translate_tls_address with OFFSET==0 and then adding the
 615      offset by hand seemed too hackish.  */
 616   if (is_tls)
 617     {
 618       struct frame_info *frame = get_selected_frame (NULL);
 619       struct value *val;
 620
 621       if (frame == NULL)
 622         error (_("Symbol \"%s\" cannot be used because "
 623                  "there is no selected frame"),
 624                SYMBOL_PRINT_NAME (sym));
 625
 626       val = read_var_value (sym, NULL, frame);
 627       if (VALUE_LVAL (val) != lval_memory)
 628         error (_("Symbol \"%s\" cannot be used for compilation evaluation "
 629                  "as its address has not been found."),
 630                SYMBOL_PRINT_NAME (sym));
 631
 632       warning (_("Symbol \"%s\" is thread-local and currently can only "
 633                  "be referenced from the current thread in "
 634                  "compiled code."),
 635                SYMBOL_PRINT_NAME (sym));
 636
 637       fprintfi_filtered (indent, stream, "%s = %s;\n",
 638                          result_name,
 639                          core_addr_to_string (value_address (val)));
 640       fprintfi_filtered (indent - 2, stream, "}\n");
 641       return;
 642     }
 643
 644   fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
 645                      stack_depth);
 646
 647   if (need_tempvar)
 648     fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
 649   fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
 650
 651   if (initial != NULL)
 652     pushf (indent, stream, "%s", core_addr_to_string (*initial));
 653
 654   while (op_ptr < op_end)
 655     {
 656       enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
 657       uint64_t uoffset, reg;
 658       int64_t offset;
 659
 660       print_spaces (indent - 2, stream);
 661       if (info[op_ptr - base].label)
 662         {
 663           print_label (stream, scope, op_ptr - base);
 664           stream->puts (":;");
 665         }
 666       stream->printf ("/* %s */\n", get_DW_OP_name (op));
 667
 668       /* This is handy for debugging the generated code:
 669       fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
 670                         (int) info[op_ptr - base].depth - 1);
 671       */
 672
 673       ++op_ptr;
 674
 675       switch (op)
 676         {
 677         case DW_OP_lit0:
 678         case DW_OP_lit1:
 679         case DW_OP_lit2:
 680         case DW_OP_lit3:
 681         case DW_OP_lit4:
 682         case DW_OP_lit5:
 683         case DW_OP_lit6:
 684         case DW_OP_lit7:
 685         case DW_OP_lit8:
 686         case DW_OP_lit9:
 687         case DW_OP_lit10:
 688         case DW_OP_lit11:
 689         case DW_OP_lit12:
 690         case DW_OP_lit13:
 691         case DW_OP_lit14:
 692         case DW_OP_lit15:
 693         case DW_OP_lit16:
 694         case DW_OP_lit17:
 695         case DW_OP_lit18:
 696         case DW_OP_lit19:
 697         case DW_OP_lit20:
 698         case DW_OP_lit21:
 699         case DW_OP_lit22:
 700         case DW_OP_lit23:
 701         case DW_OP_lit24:
 702         case DW_OP_lit25:
 703         case DW_OP_lit26:
 704         case DW_OP_lit27:
 705         case DW_OP_lit28:
 706         case DW_OP_lit29:
 707         case DW_OP_lit30:
 708         case DW_OP_lit31:
 709           push (indent, stream, op - DW_OP_lit0);
 710           break;
 711
 712         case DW_OP_addr:
 713           uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
 714           op_ptr += addr_size;
 715           /* Some versions of GCC emit DW_OP_addr before
 716              DW_OP_GNU_push_tls_address.  In this case the value is an
 717              index, not an address.  We don't support things like
 718              branching between the address and the TLS op.  */
 719           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 720             uoffset += dwarf2_per_cu_text_offset (per_cu);
 721           push (indent, stream, uoffset);
 722           break;
 723
 724         case DW_OP_const1u:
 725           push (indent, stream,
 726                 extract_unsigned_integer (op_ptr, 1, byte_order));
 727           op_ptr += 1;
 728           break;
 729         case DW_OP_const1s:
 730           push (indent, stream,
 731                 extract_signed_integer (op_ptr, 1, byte_order));
 732           op_ptr += 1;
 733           break;
 734         case DW_OP_const2u:
 735           push (indent, stream,
 736                 extract_unsigned_integer (op_ptr, 2, byte_order));
 737           op_ptr += 2;
 738           break;
 739         case DW_OP_const2s:
 740           push (indent, stream,
 741                 extract_signed_integer (op_ptr, 2, byte_order));
 742           op_ptr += 2;
 743           break;
 744         case DW_OP_const4u:
 745           push (indent, stream,
 746                 extract_unsigned_integer (op_ptr, 4, byte_order));
 747           op_ptr += 4;
 748           break;
 749         case DW_OP_const4s:
 750           push (indent, stream,
 751                 extract_signed_integer (op_ptr, 4, byte_order));
 752           op_ptr += 4;
 753           break;
 754         case DW_OP_const8u:
 755           push (indent, stream,
 756                 extract_unsigned_integer (op_ptr, 8, byte_order));
 757           op_ptr += 8;
 758           break;
 759         case DW_OP_const8s:
 760           push (indent, stream,
 761                 extract_signed_integer (op_ptr, 8, byte_order));
 762           op_ptr += 8;
 763           break;
 764         case DW_OP_constu:
 765           op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 766           push (indent, stream, uoffset);
 767           break;
 768         case DW_OP_consts:
 769           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 770           push (indent, stream, offset);
 771           break;
 772
 773         case DW_OP_reg0:
 774         case DW_OP_reg1:
 775         case DW_OP_reg2:
 776         case DW_OP_reg3:
 777         case DW_OP_reg4:
 778         case DW_OP_reg5:
 779         case DW_OP_reg6:
 780         case DW_OP_reg7:
 781         case DW_OP_reg8:
 782         case DW_OP_reg9:
 783         case DW_OP_reg10:
 784         case DW_OP_reg11:
 785         case DW_OP_reg12:
 786         case DW_OP_reg13:
 787         case DW_OP_reg14:
 788         case DW_OP_reg15:
 789         case DW_OP_reg16:
 790         case DW_OP_reg17:
 791         case DW_OP_reg18:
 792         case DW_OP_reg19:
 793         case DW_OP_reg20:
 794         case DW_OP_reg21:
 795         case DW_OP_reg22:
 796         case DW_OP_reg23:
 797         case DW_OP_reg24:
 798         case DW_OP_reg25:
 799         case DW_OP_reg26:
 800         case DW_OP_reg27:
 801         case DW_OP_reg28:
 802         case DW_OP_reg29:
 803         case DW_OP_reg30:
 804         case DW_OP_reg31:
 805           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 806           pushf_register_address (indent, stream, registers_used, arch,
 807                                   dwarf_reg_to_regnum_or_error
 808                                     (arch, op - DW_OP_reg0));
 809           break;
 810
 811         case DW_OP_regx:
 812           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 813           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 814           pushf_register_address (indent, stream, registers_used, arch,
 815                                   dwarf_reg_to_regnum_or_error (arch, reg));
 816           break;
 817
 818         case DW_OP_breg0:
 819         case DW_OP_breg1:
 820         case DW_OP_breg2:
 821         case DW_OP_breg3:
 822         case DW_OP_breg4:
 823         case DW_OP_breg5:
 824         case DW_OP_breg6:
 825         case DW_OP_breg7:
 826         case DW_OP_breg8:
 827         case DW_OP_breg9:
 828         case DW_OP_breg10:
 829         case DW_OP_breg11:
 830         case DW_OP_breg12:
 831         case DW_OP_breg13:
 832         case DW_OP_breg14:
 833         case DW_OP_breg15:
 834         case DW_OP_breg16:
 835         case DW_OP_breg17:
 836         case DW_OP_breg18:
 837         case DW_OP_breg19:
 838         case DW_OP_breg20:
 839         case DW_OP_breg21:
 840         case DW_OP_breg22:
 841         case DW_OP_breg23:
 842         case DW_OP_breg24:
 843         case DW_OP_breg25:
 844         case DW_OP_breg26:
 845         case DW_OP_breg27:
 846         case DW_OP_breg28:
 847         case DW_OP_breg29:
 848         case DW_OP_breg30:
 849         case DW_OP_breg31:
 850           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 851           pushf_register (indent, stream, registers_used, arch,
 852                           dwarf_reg_to_regnum_or_error (arch,
 853                                                         op - DW_OP_breg0),
 854                           offset);
 855           break;
 856         case DW_OP_bregx:
 857           {
 858             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 859             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 860             pushf_register (indent, stream, registers_used, arch,
 861                             dwarf_reg_to_regnum_or_error (arch, reg), offset);
 862           }
 863           break;
 864         case DW_OP_fbreg:
 865           {
 866             const gdb_byte *datastart;
 867             size_t datalen;
 868             const struct block *b;
 869             struct symbol *framefunc;
 870             char fb_name[50];
 871
 872             b = block_for_pc (pc);
 873
 874             if (!b)
 875               error (_("No block found for address"));
 876
 877             framefunc = block_linkage_function (b);
 878
 879             if (!framefunc)
 880               error (_("No function found for block"));
 881
 882             func_get_frame_base_dwarf_block (framefunc, pc,
 883                                              &datastart, &datalen);
 884
 885             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 886
 887             /* Generate a unique-enough name, in case the frame base
 888                is computed multiple times in this expression.  */
 889             xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
 890                        (long) (op_ptr - base));
 891
 892             do_compile_dwarf_expr_to_c (indent, stream,
 893                                         GCC_UINTPTR, fb_name,
 894                                         sym, pc,
 895                                         arch, registers_used, addr_size,
 896                                         datastart, datastart + datalen,
 897                                         NULL, per_cu);
 898
 899             pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
 900           }
 901           break;
 902
 903         case DW_OP_dup:
 904           pushf (indent, stream, "__gdb_stack[__gdb_tos]");
 905           break;
 906
 907         case DW_OP_drop:
 908           fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
 909           break;
 910
 911         case DW_OP_pick:
 912           offset = *op_ptr++;
 913           pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
 914                  plongest (offset));
 915           break;
 916
 917         case DW_OP_swap:
 918           fprintfi_filtered (indent, stream,
 919                              "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
 920           fprintfi_filtered (indent, stream,
 921                              "__gdb_stack[__gdb_tos - 1] = "
 922                              "__gdb_stack[__gdb_tos];\n");
 923           fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
 924                                               "__gdb_tmp;\n"));
 925           break;
 926
 927         case DW_OP_over:
 928           pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
 929           break;
 930
 931         case DW_OP_rot:
 932           fprintfi_filtered (indent, stream, ("__gdb_tmp = "
 933                                               "__gdb_stack[__gdb_tos];\n"));
 934           fprintfi_filtered (indent, stream,
 935                              "__gdb_stack[__gdb_tos] = "
 936                              "__gdb_stack[__gdb_tos - 1];\n");
 937           fprintfi_filtered (indent, stream,
 938                              "__gdb_stack[__gdb_tos - 1] = "
 939                              "__gdb_stack[__gdb_tos -2];\n");
 940           fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
 941                              "__gdb_tmp;\n");
 942           break;
 943
 944         case DW_OP_deref:
 945         case DW_OP_deref_size:
 946           {
 947             int size;
 948             const char *mode;
 949
 950             if (op == DW_OP_deref_size)
 951               size = *op_ptr++;
 952             else
 953               size = addr_size;
 954
 955             mode = c_get_mode_for_size (size);
 956             if (mode == NULL)
 957               error (_("Unsupported size %d in %s"),
 958                      size, get_DW_OP_name (op));
 959
 960             /* Cast to a pointer of the desired type, then
 961                dereference.  */
 962             fprintfi_filtered (indent, stream,
 963                                "__gdb_stack[__gdb_tos] = "
 964                                "*((__gdb_int_%s *) "
 965                                "__gdb_stack[__gdb_tos]);\n",
 966                                mode);
 967           }
 968           break;
 969
 970         case DW_OP_abs:
 971           unary (indent, stream,
 972                  "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
 973                  "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
 974           break;
 975
 976         case DW_OP_neg:
 977           unary (indent, stream, "-__gdb_stack[__gdb_tos]");
 978           break;
 979
 980         case DW_OP_not:
 981           unary (indent, stream, "~__gdb_stack[__gdb_tos]");
 982           break;
 983
 984         case DW_OP_plus_uconst:
 985           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 986           unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
 987                  hex_string (reg));
 988           break;
 989
 990         case DW_OP_div:
 991           binary (indent, stream, ("((" GCC_INTPTR
 992                                    ") __gdb_stack[__gdb_tos-1]) / (("
 993                                    GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
 994           break;
 995
 996         case DW_OP_shra:
 997           binary (indent, stream,
 998                   "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
 999                   "__gdb_stack[__gdb_tos]");
1000           break;
1001
1002 #define BINARY(OP)                                                      \
1003           binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1004                                    " __gdb_stack[__gdb_tos]");  \
1005           break
1006
1007         case DW_OP_and:
1008           BINARY (&);
1009         case DW_OP_minus:
1010           BINARY (-);
1011         case DW_OP_mod:
1012           BINARY (%);
1013         case DW_OP_mul:
1014           BINARY (*);
1015         case DW_OP_or:
1016           BINARY (|);
1017         case DW_OP_plus:
1018           BINARY (+);
1019         case DW_OP_shl:
1020           BINARY (<<);
1021         case DW_OP_shr:
1022           BINARY (>>);
1023         case DW_OP_xor:
1024           BINARY (^);
1025 #undef BINARY
1026
1027 #define COMPARE(OP)                                                     \
1028           binary (indent, stream,                                       \
1029                   "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP   \
1030                   " ((" GCC_INTPTR                                      \
1031                   ") __gdb_stack[__gdb_tos]))");                        \
1032           break
1033
1034         case DW_OP_le:
1035           COMPARE (<=);
1036         case DW_OP_ge:
1037           COMPARE (>=);
1038         case DW_OP_eq:
1039           COMPARE (==);
1040         case DW_OP_lt:
1041           COMPARE (<);
1042         case DW_OP_gt:
1043           COMPARE (>);
1044         case DW_OP_ne:
1045           COMPARE (!=);
1046 #undef COMPARE
1047
1048         case DW_OP_call_frame_cfa:
1049           {
1050             int regnum;
1051             CORE_ADDR text_offset;
1052             LONGEST off;
1053             const gdb_byte *cfa_start, *cfa_end;
1054
1055             if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1056                                        &regnum, &off,
1057                                        &text_offset, &cfa_start, &cfa_end))
1058               {
1059                 /* Register.  */
1060                 pushf_register (indent, stream, registers_used, arch, regnum,
1061                                 off);
1062               }
1063             else
1064               {
1065                 /* Another expression.  */
1066                 char cfa_name[50];
1067
1068                 /* Generate a unique-enough name, in case the CFA is
1069                    computed multiple times in this expression.  */
1070                 xsnprintf (cfa_name, sizeof (cfa_name),
1071                            "__cfa_%ld", (long) (op_ptr - base));
1072
1073                 do_compile_dwarf_expr_to_c (indent, stream,
1074                                             GCC_UINTPTR, cfa_name,
1075                                             sym, pc, arch, registers_used,
1076                                             addr_size,
1077                                             cfa_start, cfa_end,
1078                                             &text_offset, per_cu);
1079                 pushf (indent, stream, "%s", cfa_name);
1080               }
1081           }
1082
1083           break;
1084
1085         case DW_OP_skip:
1086           offset = extract_signed_integer (op_ptr, 2, byte_order);
1087           op_ptr += 2;
1088           fprintfi_filtered (indent, stream, "goto ");
1089           print_label (stream, scope, op_ptr + offset - base);
1090           stream->puts (";\n");
1091           break;
1092
1093         case DW_OP_bra:
1094           offset = extract_signed_integer (op_ptr, 2, byte_order);
1095           op_ptr += 2;
1096           fprintfi_filtered (indent, stream,
1097                              "if ((( " GCC_INTPTR
1098                              ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1099           print_label (stream, scope, op_ptr + offset - base);
1100           stream->puts (";\n");
1101           break;
1102
1103         case DW_OP_nop:
1104           break;
1105
1106         default:
1107           error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1108         }
1109     }
1110
1111   fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
1112                      result_name);
1113   fprintfi_filtered (indent - 2, stream, "}\n");
1114 }
1115
1116 /* See compile.h.  */
1117
1118 void
1119 compile_dwarf_expr_to_c (string_file *stream, const char *result_name,
1120                          struct symbol *sym, CORE_ADDR pc,
1121                          struct gdbarch *arch, unsigned char *registers_used,
1122                          unsigned int addr_size,
1123                          const gdb_byte *op_ptr, const gdb_byte *op_end,
1124                          struct dwarf2_per_cu_data *per_cu)
1125 {
1126   do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
1127                               arch, registers_used, addr_size, op_ptr, op_end,
1128                               NULL, per_cu);
1129 }
1130
1131 /* See compile.h.  */
1132
1133 void
1134 compile_dwarf_bounds_to_c (string_file *stream,
1135                            const char *result_name,
1136                            const struct dynamic_prop *prop,
1137                            struct symbol *sym, CORE_ADDR pc,
1138                            struct gdbarch *arch, unsigned char *registers_used,
1139                            unsigned int addr_size,
1140                            const gdb_byte *op_ptr, const gdb_byte *op_end,
1141                            struct dwarf2_per_cu_data *per_cu)
1142 {
1143   do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1144                               sym, pc, arch, registers_used,
1145                               addr_size, op_ptr, op_end, NULL, per_cu);
1146 }