gdb/compile/compile-loc2c.c

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