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           uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
 726           op_ptr += addr_size;
 727           /* Some versions of GCC emit DW_OP_addr before
 728              DW_OP_GNU_push_tls_address.  In this case the value is an
 729              index, not an address.  We don't support things like
 730              branching between the address and the TLS op.  */
 731           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 732             uoffset += dwarf2_per_cu_text_offset (per_cu);
 733           push (indent, stream, uoffset);
 734           break;
 735
 736         case DW_OP_const1u:
 737           push (indent, stream,
 738                 extract_unsigned_integer (op_ptr, 1, byte_order));
 739           op_ptr += 1;
 740           break;
 741         case DW_OP_const1s:
 742           push (indent, stream,
 743                 extract_signed_integer (op_ptr, 1, byte_order));
 744           op_ptr += 1;
 745           break;
 746         case DW_OP_const2u:
 747           push (indent, stream,
 748                 extract_unsigned_integer (op_ptr, 2, byte_order));
 749           op_ptr += 2;
 750           break;
 751         case DW_OP_const2s:
 752           push (indent, stream,
 753                 extract_signed_integer (op_ptr, 2, byte_order));
 754           op_ptr += 2;
 755           break;
 756         case DW_OP_const4u:
 757           push (indent, stream,
 758                 extract_unsigned_integer (op_ptr, 4, byte_order));
 759           op_ptr += 4;
 760           break;
 761         case DW_OP_const4s:
 762           push (indent, stream,
 763                 extract_signed_integer (op_ptr, 4, byte_order));
 764           op_ptr += 4;
 765           break;
 766         case DW_OP_const8u:
 767           push (indent, stream,
 768                 extract_unsigned_integer (op_ptr, 8, byte_order));
 769           op_ptr += 8;
 770           break;
 771         case DW_OP_const8s:
 772           push (indent, stream,
 773                 extract_signed_integer (op_ptr, 8, byte_order));
 774           op_ptr += 8;
 775           break;
 776         case DW_OP_constu:
 777           op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 778           push (indent, stream, uoffset);
 779           break;
 780         case DW_OP_consts:
 781           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 782           push (indent, stream, offset);
 783           break;
 784
 785         case DW_OP_reg0:
 786         case DW_OP_reg1:
 787         case DW_OP_reg2:
 788         case DW_OP_reg3:
 789         case DW_OP_reg4:
 790         case DW_OP_reg5:
 791         case DW_OP_reg6:
 792         case DW_OP_reg7:
 793         case DW_OP_reg8:
 794         case DW_OP_reg9:
 795         case DW_OP_reg10:
 796         case DW_OP_reg11:
 797         case DW_OP_reg12:
 798         case DW_OP_reg13:
 799         case DW_OP_reg14:
 800         case DW_OP_reg15:
 801         case DW_OP_reg16:
 802         case DW_OP_reg17:
 803         case DW_OP_reg18:
 804         case DW_OP_reg19:
 805         case DW_OP_reg20:
 806         case DW_OP_reg21:
 807         case DW_OP_reg22:
 808         case DW_OP_reg23:
 809         case DW_OP_reg24:
 810         case DW_OP_reg25:
 811         case DW_OP_reg26:
 812         case DW_OP_reg27:
 813         case DW_OP_reg28:
 814         case DW_OP_reg29:
 815         case DW_OP_reg30:
 816         case DW_OP_reg31:
 817           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 818           pushf_register_address (indent, stream, registers_used, arch,
 819                                   dwarf_reg_to_regnum_or_error
 820                                     (arch, op - DW_OP_reg0));
 821           break;
 822
 823         case DW_OP_regx:
 824           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 825           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 826           pushf_register_address (indent, stream, registers_used, arch,
 827                                   dwarf_reg_to_regnum_or_error (arch, reg));
 828           break;
 829
 830         case DW_OP_breg0:
 831         case DW_OP_breg1:
 832         case DW_OP_breg2:
 833         case DW_OP_breg3:
 834         case DW_OP_breg4:
 835         case DW_OP_breg5:
 836         case DW_OP_breg6:
 837         case DW_OP_breg7:
 838         case DW_OP_breg8:
 839         case DW_OP_breg9:
 840         case DW_OP_breg10:
 841         case DW_OP_breg11:
 842         case DW_OP_breg12:
 843         case DW_OP_breg13:
 844         case DW_OP_breg14:
 845         case DW_OP_breg15:
 846         case DW_OP_breg16:
 847         case DW_OP_breg17:
 848         case DW_OP_breg18:
 849         case DW_OP_breg19:
 850         case DW_OP_breg20:
 851         case DW_OP_breg21:
 852         case DW_OP_breg22:
 853         case DW_OP_breg23:
 854         case DW_OP_breg24:
 855         case DW_OP_breg25:
 856         case DW_OP_breg26:
 857         case DW_OP_breg27:
 858         case DW_OP_breg28:
 859         case DW_OP_breg29:
 860         case DW_OP_breg30:
 861         case DW_OP_breg31:
 862           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 863           pushf_register (indent, stream, registers_used, arch,
 864                           dwarf_reg_to_regnum_or_error (arch,
 865                                                         op - DW_OP_breg0),
 866                           offset);
 867           break;
 868         case DW_OP_bregx:
 869           {
 870             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 871             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 872             pushf_register (indent, stream, registers_used, arch,
 873                             dwarf_reg_to_regnum_or_error (arch, reg), offset);
 874           }
 875           break;
 876         case DW_OP_fbreg:
 877           {
 878             const gdb_byte *datastart;
 879             size_t datalen;
 880             const struct block *b;
 881             struct symbol *framefunc;
 882             char fb_name[50];
 883
 884             b = block_for_pc (pc);
 885
 886             if (!b)
 887               error (_("No block found for address"));
 888
 889             framefunc = block_linkage_function (b);
 890
 891             if (!framefunc)
 892               error (_("No function found for block"));
 893
 894             func_get_frame_base_dwarf_block (framefunc, pc,
 895                                              &datastart, &datalen);
 896
 897             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 898
 899             /* Generate a unique-enough name, in case the frame base
 900                is computed multiple times in this expression.  */
 901             xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
 902                        (long) (op_ptr - base));
 903
 904             do_compile_dwarf_expr_to_c (indent, stream,
 905                                         GCC_UINTPTR, fb_name,
 906                                         sym, pc,
 907                                         arch, registers_used, addr_size,
 908                                         datastart, datastart + datalen,
 909                                         NULL, per_cu);
 910
 911             pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
 912           }
 913           break;
 914
 915         case DW_OP_dup:
 916           pushf (indent, stream, "__gdb_stack[__gdb_tos]");
 917           break;
 918
 919         case DW_OP_drop:
 920           fprintfi_filtered (indent, &stream, "--__gdb_tos;\n");
 921           break;
 922
 923         case DW_OP_pick:
 924           offset = *op_ptr++;
 925           pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
 926                  plongest (offset));
 927           break;
 928
 929         case DW_OP_swap:
 930           fprintfi_filtered (indent, &stream,
 931                              "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
 932           fprintfi_filtered (indent, &stream,
 933                              "__gdb_stack[__gdb_tos - 1] = "
 934                              "__gdb_stack[__gdb_tos];\n");
 935           fprintfi_filtered (indent, &stream, ("__gdb_stack[__gdb_tos] = "
 936                                                "__gdb_tmp;\n"));
 937           break;
 938
 939         case DW_OP_over:
 940           pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
 941           break;
 942
 943         case DW_OP_rot:
 944           fprintfi_filtered (indent, &stream, ("__gdb_tmp = "
 945                                                "__gdb_stack[__gdb_tos];\n"));
 946           fprintfi_filtered (indent, &stream,
 947                              "__gdb_stack[__gdb_tos] = "
 948                              "__gdb_stack[__gdb_tos - 1];\n");
 949           fprintfi_filtered (indent, &stream,
 950                              "__gdb_stack[__gdb_tos - 1] = "
 951                              "__gdb_stack[__gdb_tos -2];\n");
 952           fprintfi_filtered (indent, &stream, "__gdb_stack[__gdb_tos - 2] = "
 953                              "__gdb_tmp;\n");
 954           break;
 955
 956         case DW_OP_deref:
 957         case DW_OP_deref_size:
 958           {
 959             int size;
 960             const char *mode;
 961
 962             if (op == DW_OP_deref_size)
 963               size = *op_ptr++;
 964             else
 965               size = addr_size;
 966
 967             mode = c_get_mode_for_size (size);
 968             if (mode == NULL)
 969               error (_("Unsupported size %d in %s"),
 970                      size, get_DW_OP_name (op));
 971
 972             /* Cast to a pointer of the desired type, then
 973                dereference.  */
 974             fprintfi_filtered (indent, &stream,
 975                                "__gdb_stack[__gdb_tos] = "
 976                                "*((__gdb_int_%s *) "
 977                                "__gdb_stack[__gdb_tos]);\n",
 978                                mode);
 979           }
 980           break;
 981
 982         case DW_OP_abs:
 983           unary (indent, stream,
 984                  "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
 985                  "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
 986           break;
 987
 988         case DW_OP_neg:
 989           unary (indent, stream, "-__gdb_stack[__gdb_tos]");
 990           break;
 991
 992         case DW_OP_not:
 993           unary (indent, stream, "~__gdb_stack[__gdb_tos]");
 994           break;
 995
 996         case DW_OP_plus_uconst:
 997           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 998           unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
 999                  hex_string (reg));
1000           break;
1001
1002         case DW_OP_div:
1003           binary (indent, stream, ("((" GCC_INTPTR
1004                                    ") __gdb_stack[__gdb_tos-1]) / (("
1005                                    GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
1006           break;
1007
1008         case DW_OP_shra:
1009           binary (indent, stream,
1010                   "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
1011                   "__gdb_stack[__gdb_tos]");
1012           break;
1013
1014 #define BINARY(OP)                                                      \
1015           binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1016                                    " __gdb_stack[__gdb_tos]");  \
1017           break
1018
1019         case DW_OP_and:
1020           BINARY (&);
1021         case DW_OP_minus:
1022           BINARY (-);
1023         case DW_OP_mod:
1024           BINARY (%);
1025         case DW_OP_mul:
1026           BINARY (*);
1027         case DW_OP_or:
1028           BINARY (|);
1029         case DW_OP_plus:
1030           BINARY (+);
1031         case DW_OP_shl:
1032           BINARY (<<);
1033         case DW_OP_shr:
1034           BINARY (>>);
1035         case DW_OP_xor:
1036           BINARY (^);
1037 #undef BINARY
1038
1039 #define COMPARE(OP)                                                     \
1040           binary (indent, stream,                                       \
1041                   "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP   \
1042                   " ((" GCC_INTPTR                                      \
1043                   ") __gdb_stack[__gdb_tos]))");                        \
1044           break
1045
1046         case DW_OP_le:
1047           COMPARE (<=);
1048         case DW_OP_ge:
1049           COMPARE (>=);
1050         case DW_OP_eq:
1051           COMPARE (==);
1052         case DW_OP_lt:
1053           COMPARE (<);
1054         case DW_OP_gt:
1055           COMPARE (>);
1056         case DW_OP_ne:
1057           COMPARE (!=);
1058 #undef COMPARE
1059
1060         case DW_OP_call_frame_cfa:
1061           {
1062             int regnum;
1063             CORE_ADDR text_offset;
1064             LONGEST off;
1065             const gdb_byte *cfa_start, *cfa_end;
1066
1067             if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1068                                        &regnum, &off,
1069                                        &text_offset, &cfa_start, &cfa_end))
1070               {
1071                 /* Register.  */
1072                 pushf_register (indent, stream, registers_used, arch, regnum,
1073                                 off);
1074               }
1075             else
1076               {
1077                 /* Another expression.  */
1078                 char cfa_name[50];
1079
1080                 /* Generate a unique-enough name, in case the CFA is
1081                    computed multiple times in this expression.  */
1082                 xsnprintf (cfa_name, sizeof (cfa_name),
1083                            "__cfa_%ld", (long) (op_ptr - base));
1084
1085                 do_compile_dwarf_expr_to_c (indent, stream,
1086                                             GCC_UINTPTR, cfa_name,
1087                                             sym, pc, arch, registers_used,
1088                                             addr_size,
1089                                             cfa_start, cfa_end,
1090                                             &text_offset, per_cu);
1091                 pushf (indent, stream, "%s", cfa_name);
1092               }
1093           }
1094
1095           break;
1096
1097         case DW_OP_skip:
1098           offset = extract_signed_integer (op_ptr, 2, byte_order);
1099           op_ptr += 2;
1100           fprintfi_filtered (indent, &stream, "goto ");
1101           print_label (stream, scope, op_ptr + offset - base);
1102           stream.puts (";\n");
1103           break;
1104
1105         case DW_OP_bra:
1106           offset = extract_signed_integer (op_ptr, 2, byte_order);
1107           op_ptr += 2;
1108           fprintfi_filtered (indent, &stream,
1109                              "if ((( " GCC_INTPTR
1110                              ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1111           print_label (stream, scope, op_ptr + offset - base);
1112           stream.puts (";\n");
1113           break;
1114
1115         case DW_OP_nop:
1116           break;
1117
1118         default:
1119           error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1120         }
1121     }
1122
1123   fprintfi_filtered (indent, &stream, "%s = __gdb_stack[__gdb_tos];\n",
1124                      result_name);
1125   fprintfi_filtered (indent - 2, &stream, "}\n");
1126
1127   do_cleanups (cleanup);
1128 }
1129
1130 /* See compile.h.  */
1131
1132 void
1133 compile_dwarf_expr_to_c (string_file &stream, const char *result_name,
1134                          struct symbol *sym, CORE_ADDR pc,
1135                          struct gdbarch *arch, unsigned char *registers_used,
1136                          unsigned int addr_size,
1137                          const gdb_byte *op_ptr, const gdb_byte *op_end,
1138                          struct dwarf2_per_cu_data *per_cu)
1139 {
1140   do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
1141                               arch, registers_used, addr_size, op_ptr, op_end,
1142                               NULL, per_cu);
1143 }
1144
1145 /* See compile.h.  */
1146
1147 void
1148 compile_dwarf_bounds_to_c (string_file &stream,
1149                            const char *result_name,
1150                            const struct dynamic_prop *prop,
1151                            struct symbol *sym, CORE_ADDR pc,
1152                            struct gdbarch *arch, unsigned char *registers_used,
1153                            unsigned int addr_size,
1154                            const gdb_byte *op_ptr, const gdb_byte *op_end,
1155                            struct dwarf2_per_cu_data *per_cu)
1156 {
1157   do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1158                               sym, pc, arch, registers_used,
1159                               addr_size, op_ptr, op_end, NULL, per_cu);
1160 }