gdb/compile/compile-loc2c.c

   1 /* Convert a DWARF location expression to C
   2
   3    Copyright (C) 2014-2016 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                             VEC (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             VEC_safe_push (int, *to_do, 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             VEC_safe_push (int, *to_do, 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, *cleanup;
 394   VEC (int) *to_do = NULL;
 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   cleanup = make_cleanup (VEC_cleanup (int), &to_do);
 401
 402   VEC_safe_push (int, to_do, 0);
 403   (*info)[0].depth = initial_depth;
 404   (*info)[0].visited = 1;
 405
 406   while (!VEC_empty (int, to_do))
 407     {
 408       int ndx = VEC_pop (int, to_do);
 409
 410       compute_stack_depth_worker (ndx, need_tempvar, *info, &to_do,
 411                                   byte_order, addr_size,
 412                                   op_ptr, op_end);
 413     }
 414
 415   stack_depth = 0;
 416   *is_tls = 0;
 417   for (i = 0; i < op_end - op_ptr; ++i)
 418     {
 419       if ((*info)[i].depth > stack_depth)
 420         stack_depth = (*info)[i].depth;
 421       if ((*info)[i].is_tls)
 422         *is_tls = 1;
 423     }
 424
 425   do_cleanups (cleanup);
 426   discard_cleanups (outer_cleanup);
 427   return stack_depth + 1;
 428 }
 429
 430 \f
 431
 432 #define GCC_UINTPTR "__gdb_uintptr"
 433 #define GCC_INTPTR "__gdb_intptr"
 434
 435 /* Emit code to push a constant.  */
 436
 437 static void
 438 push (int indent, struct ui_file *stream, ULONGEST l)
 439 {
 440   fprintfi_filtered (indent, stream,
 441                      "__gdb_stack[++__gdb_tos] = (" GCC_UINTPTR ") %s;\n",
 442                      hex_string (l));
 443 }
 444
 445 /* Emit code to push an arbitrary expression.  This works like
 446    printf.  */
 447
 448 static void pushf (int indent, struct ui_file *stream, const char *format, ...)
 449   ATTRIBUTE_PRINTF (3, 4);
 450
 451 static void
 452 pushf (int indent, struct ui_file *stream, const char *format, ...)
 453 {
 454   va_list args;
 455
 456   fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos + 1] = ");
 457   va_start (args, format);
 458   vfprintf_filtered (stream, format, args);
 459   va_end (args);
 460   fprintf_filtered (stream, ";\n");
 461
 462   fprintfi_filtered (indent, stream, "++__gdb_tos;\n");
 463 }
 464
 465 /* Emit code for a unary expression -- one which operates in-place on
 466    the top-of-stack.  This works like printf.  */
 467
 468 static void unary (int indent, struct ui_file *stream, const char *format, ...)
 469   ATTRIBUTE_PRINTF (3, 4);
 470
 471 static void
 472 unary (int indent, struct ui_file *stream, const char *format, ...)
 473 {
 474   va_list args;
 475
 476   fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos] = ");
 477   va_start (args, format);
 478   vfprintf_filtered (stream, format, args);
 479   va_end (args);
 480   fprintf_filtered (stream, ";\n");
 481 }
 482
 483 /* Emit code for a unary expression -- one which uses the top two
 484    stack items, popping the topmost one.  This works like printf.  */
 485 static void binary (int indent, struct ui_file *stream, const char *format, ...)
 486   ATTRIBUTE_PRINTF (3, 4);
 487
 488 static void
 489 binary (int indent, struct ui_file *stream, const char *format, ...)
 490 {
 491   va_list args;
 492
 493   fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 1] = ");
 494   va_start (args, format);
 495   vfprintf_filtered (stream, format, args);
 496   va_end (args);
 497   fprintf_filtered (stream, ";\n");
 498   fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
 499 }
 500
 501 /* Print the name of a label given its "SCOPE", an arbitrary integer
 502    used for uniqueness, and its TARGET, the bytecode offset
 503    corresponding to the label's point of definition.  */
 504
 505 static void
 506 print_label (struct ui_file *stream, unsigned int scope, int target)
 507 {
 508   fprintf_filtered (stream, "__label_%u_%s",
 509                     scope, pulongest (target));
 510 }
 511
 512 /* Emit code that pushes a register's address on the stack.
 513    REGISTERS_USED is an out parameter which is updated to note which
 514    register was needed by this expression.  */
 515
 516 static void
 517 pushf_register_address (int indent, struct ui_file *stream,
 518                         unsigned char *registers_used,
 519                         struct gdbarch *gdbarch, int regnum)
 520 {
 521   char *regname = compile_register_name_mangled (gdbarch, regnum);
 522   struct cleanup *cleanups = make_cleanup (xfree, regname);
 523
 524   registers_used[regnum] = 1;
 525   pushf (indent, stream,
 526          "(" GCC_UINTPTR ") &" COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
 527          regname);
 528
 529   do_cleanups (cleanups);
 530 }
 531
 532 /* Emit code that pushes a register's value on the stack.
 533    REGISTERS_USED is an out parameter which is updated to note which
 534    register was needed by this expression.  OFFSET is added to the
 535    register's value before it is pushed.  */
 536
 537 static void
 538 pushf_register (int indent, struct ui_file *stream,
 539                 unsigned char *registers_used,
 540                 struct gdbarch *gdbarch, int regnum, uint64_t offset)
 541 {
 542   char *regname = compile_register_name_mangled (gdbarch, regnum);
 543   struct cleanup *cleanups = make_cleanup (xfree, regname);
 544
 545   registers_used[regnum] = 1;
 546   if (offset == 0)
 547     pushf (indent, stream, COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s",
 548            regname);
 549   else
 550     pushf (indent, stream,
 551            COMPILE_I_SIMPLE_REGISTER_ARG_NAME "->%s + (" GCC_UINTPTR ") %s",
 552            regname, hex_string (offset));
 553
 554   do_cleanups (cleanups);
 555 }
 556
 557 /* Compile a DWARF expression to C code.
 558
 559    INDENT is the indentation level to use.
 560    STREAM is the stream where the code should be written.
 561
 562    TYPE_NAME names the type of the result of the DWARF expression.
 563    For locations this is "void *" but for array bounds it will be an
 564    integer type.
 565
 566    RESULT_NAME is the name of a variable in the resulting C code.  The
 567    result of the expression will be assigned to this variable.
 568
 569    SYM is the symbol corresponding to this expression.
 570    PC is the location at which the expression is being evaluated.
 571    ARCH is the architecture to use.
 572
 573    REGISTERS_USED is an out parameter which is updated to note which
 574    registers were needed by this expression.
 575
 576    ADDR_SIZE is the DWARF address size to use.
 577
 578    OPT_PTR and OP_END are the bounds of the DWARF expression.
 579
 580    If non-NULL, INITIAL points to an initial value to write to the
 581    stack.  If NULL, no initial value is written.
 582
 583    PER_CU is the per-CU object used for looking up various other
 584    things.  */
 585
 586 static void
 587 do_compile_dwarf_expr_to_c (int indent, struct ui_file *stream,
 588                             const char *type_name,
 589                             const char *result_name,
 590                             struct symbol *sym, CORE_ADDR pc,
 591                             struct gdbarch *arch,
 592                             unsigned char *registers_used,
 593                             unsigned int addr_size,
 594                             const gdb_byte *op_ptr, const gdb_byte *op_end,
 595                             CORE_ADDR *initial,
 596                             struct dwarf2_per_cu_data *per_cu)
 597 {
 598   /* We keep a counter so that labels and other objects we create have
 599      unique names.  */
 600   static unsigned int scope;
 601
 602   enum bfd_endian byte_order = gdbarch_byte_order (arch);
 603   const gdb_byte * const base = op_ptr;
 604   int need_tempvar = 0;
 605   int is_tls = 0;
 606   struct cleanup *cleanup;
 607   struct insn_info *info;
 608   int stack_depth;
 609
 610   ++scope;
 611
 612   fprintfi_filtered (indent, stream, "__attribute__ ((unused)) %s %s;\n",
 613                      type_name, result_name);
 614   fprintfi_filtered (indent, stream, "{\n");
 615   indent += 2;
 616
 617   stack_depth = compute_stack_depth (byte_order, addr_size,
 618                                      &need_tempvar, &is_tls,
 619                                      op_ptr, op_end, initial != NULL,
 620                                      &info);
 621   cleanup = make_cleanup (xfree, info);
 622
 623   /* This is a hack until we can add a feature to glibc to let us
 624      properly generate code for TLS.  You might think we could emit
 625      the address in the ordinary course of translating
 626      DW_OP_GNU_push_tls_address, but since the operand appears on the
 627      stack, it is relatively hard to find, and the idea of calling
 628      target_translate_tls_address with OFFSET==0 and then adding the
 629      offset by hand seemed too hackish.  */
 630   if (is_tls)
 631     {
 632       struct frame_info *frame = get_selected_frame (NULL);
 633       struct value *val;
 634
 635       if (frame == NULL)
 636         error (_("Symbol \"%s\" cannot be used because "
 637                  "there is no selected frame"),
 638                SYMBOL_PRINT_NAME (sym));
 639
 640       val = read_var_value (sym, NULL, frame);
 641       if (VALUE_LVAL (val) != lval_memory)
 642         error (_("Symbol \"%s\" cannot be used for compilation evaluation "
 643                  "as its address has not been found."),
 644                SYMBOL_PRINT_NAME (sym));
 645
 646       warning (_("Symbol \"%s\" is thread-local and currently can only "
 647                  "be referenced from the current thread in "
 648                  "compiled code."),
 649                SYMBOL_PRINT_NAME (sym));
 650
 651       fprintfi_filtered (indent, stream, "%s = %s;\n",
 652                          result_name,
 653                          core_addr_to_string (value_address (val)));
 654       fprintfi_filtered (indent - 2, stream, "}\n");
 655       do_cleanups (cleanup);
 656       return;
 657     }
 658
 659   fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_stack[%d];\n",
 660                      stack_depth);
 661
 662   if (need_tempvar)
 663     fprintfi_filtered (indent, stream, GCC_UINTPTR " __gdb_tmp;\n");
 664   fprintfi_filtered (indent, stream, "int __gdb_tos = -1;\n");
 665
 666   if (initial != NULL)
 667     pushf (indent, stream, "%s", core_addr_to_string (*initial));
 668
 669   while (op_ptr < op_end)
 670     {
 671       enum dwarf_location_atom op = (enum dwarf_location_atom) *op_ptr;
 672       uint64_t uoffset, reg;
 673       int64_t offset;
 674
 675       print_spaces (indent - 2, stream);
 676       if (info[op_ptr - base].label)
 677         {
 678           print_label (stream, scope, op_ptr - base);
 679           fprintf_filtered (stream, ":;");
 680         }
 681       fprintf_filtered (stream, "/* %s */\n", get_DW_OP_name (op));
 682
 683       /* This is handy for debugging the generated code:
 684       fprintf_filtered (stream, "if (__gdb_tos != %d) abort ();\n",
 685                         (int) info[op_ptr - base].depth - 1);
 686       */
 687
 688       ++op_ptr;
 689
 690       switch (op)
 691         {
 692         case DW_OP_lit0:
 693         case DW_OP_lit1:
 694         case DW_OP_lit2:
 695         case DW_OP_lit3:
 696         case DW_OP_lit4:
 697         case DW_OP_lit5:
 698         case DW_OP_lit6:
 699         case DW_OP_lit7:
 700         case DW_OP_lit8:
 701         case DW_OP_lit9:
 702         case DW_OP_lit10:
 703         case DW_OP_lit11:
 704         case DW_OP_lit12:
 705         case DW_OP_lit13:
 706         case DW_OP_lit14:
 707         case DW_OP_lit15:
 708         case DW_OP_lit16:
 709         case DW_OP_lit17:
 710         case DW_OP_lit18:
 711         case DW_OP_lit19:
 712         case DW_OP_lit20:
 713         case DW_OP_lit21:
 714         case DW_OP_lit22:
 715         case DW_OP_lit23:
 716         case DW_OP_lit24:
 717         case DW_OP_lit25:
 718         case DW_OP_lit26:
 719         case DW_OP_lit27:
 720         case DW_OP_lit28:
 721         case DW_OP_lit29:
 722         case DW_OP_lit30:
 723         case DW_OP_lit31:
 724           push (indent, stream, op - DW_OP_lit0);
 725           break;
 726
 727         case DW_OP_addr:
 728           op_ptr += addr_size;
 729           /* Some versions of GCC emit DW_OP_addr before
 730              DW_OP_GNU_push_tls_address.  In this case the value is an
 731              index, not an address.  We don't support things like
 732              branching between the address and the TLS op.  */
 733           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
 734             uoffset += dwarf2_per_cu_text_offset (per_cu);
 735           push (indent, stream, uoffset);
 736           break;
 737
 738         case DW_OP_const1u:
 739           push (indent, stream,
 740                 extract_unsigned_integer (op_ptr, 1, byte_order));
 741           op_ptr += 1;
 742           break;
 743         case DW_OP_const1s:
 744           push (indent, stream,
 745                 extract_signed_integer (op_ptr, 1, byte_order));
 746           op_ptr += 1;
 747           break;
 748         case DW_OP_const2u:
 749           push (indent, stream,
 750                 extract_unsigned_integer (op_ptr, 2, byte_order));
 751           op_ptr += 2;
 752           break;
 753         case DW_OP_const2s:
 754           push (indent, stream,
 755                 extract_signed_integer (op_ptr, 2, byte_order));
 756           op_ptr += 2;
 757           break;
 758         case DW_OP_const4u:
 759           push (indent, stream,
 760                 extract_unsigned_integer (op_ptr, 4, byte_order));
 761           op_ptr += 4;
 762           break;
 763         case DW_OP_const4s:
 764           push (indent, stream,
 765                 extract_signed_integer (op_ptr, 4, byte_order));
 766           op_ptr += 4;
 767           break;
 768         case DW_OP_const8u:
 769           push (indent, stream,
 770                 extract_unsigned_integer (op_ptr, 8, byte_order));
 771           op_ptr += 8;
 772           break;
 773         case DW_OP_const8s:
 774           push (indent, stream,
 775                 extract_signed_integer (op_ptr, 8, byte_order));
 776           op_ptr += 8;
 777           break;
 778         case DW_OP_constu:
 779           op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
 780           push (indent, stream, uoffset);
 781           break;
 782         case DW_OP_consts:
 783           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 784           push (indent, stream, offset);
 785           break;
 786
 787         case DW_OP_reg0:
 788         case DW_OP_reg1:
 789         case DW_OP_reg2:
 790         case DW_OP_reg3:
 791         case DW_OP_reg4:
 792         case DW_OP_reg5:
 793         case DW_OP_reg6:
 794         case DW_OP_reg7:
 795         case DW_OP_reg8:
 796         case DW_OP_reg9:
 797         case DW_OP_reg10:
 798         case DW_OP_reg11:
 799         case DW_OP_reg12:
 800         case DW_OP_reg13:
 801         case DW_OP_reg14:
 802         case DW_OP_reg15:
 803         case DW_OP_reg16:
 804         case DW_OP_reg17:
 805         case DW_OP_reg18:
 806         case DW_OP_reg19:
 807         case DW_OP_reg20:
 808         case DW_OP_reg21:
 809         case DW_OP_reg22:
 810         case DW_OP_reg23:
 811         case DW_OP_reg24:
 812         case DW_OP_reg25:
 813         case DW_OP_reg26:
 814         case DW_OP_reg27:
 815         case DW_OP_reg28:
 816         case DW_OP_reg29:
 817         case DW_OP_reg30:
 818         case DW_OP_reg31:
 819           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 820           pushf_register_address (indent, stream, registers_used, arch,
 821                                   dwarf_reg_to_regnum_or_error
 822                                     (arch, op - DW_OP_reg0));
 823           break;
 824
 825         case DW_OP_regx:
 826           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 827           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
 828           pushf_register_address (indent, stream, registers_used, arch,
 829                                   dwarf_reg_to_regnum_or_error (arch, reg));
 830           break;
 831
 832         case DW_OP_breg0:
 833         case DW_OP_breg1:
 834         case DW_OP_breg2:
 835         case DW_OP_breg3:
 836         case DW_OP_breg4:
 837         case DW_OP_breg5:
 838         case DW_OP_breg6:
 839         case DW_OP_breg7:
 840         case DW_OP_breg8:
 841         case DW_OP_breg9:
 842         case DW_OP_breg10:
 843         case DW_OP_breg11:
 844         case DW_OP_breg12:
 845         case DW_OP_breg13:
 846         case DW_OP_breg14:
 847         case DW_OP_breg15:
 848         case DW_OP_breg16:
 849         case DW_OP_breg17:
 850         case DW_OP_breg18:
 851         case DW_OP_breg19:
 852         case DW_OP_breg20:
 853         case DW_OP_breg21:
 854         case DW_OP_breg22:
 855         case DW_OP_breg23:
 856         case DW_OP_breg24:
 857         case DW_OP_breg25:
 858         case DW_OP_breg26:
 859         case DW_OP_breg27:
 860         case DW_OP_breg28:
 861         case DW_OP_breg29:
 862         case DW_OP_breg30:
 863         case DW_OP_breg31:
 864           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 865           pushf_register (indent, stream, registers_used, arch,
 866                           dwarf_reg_to_regnum_or_error (arch,
 867                                                         op - DW_OP_breg0),
 868                           offset);
 869           break;
 870         case DW_OP_bregx:
 871           {
 872             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
 873             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 874             pushf_register (indent, stream, registers_used, arch,
 875                             dwarf_reg_to_regnum_or_error (arch, reg), offset);
 876           }
 877           break;
 878         case DW_OP_fbreg:
 879           {
 880             const gdb_byte *datastart;
 881             size_t datalen;
 882             const struct block *b;
 883             struct symbol *framefunc;
 884             char fb_name[50];
 885
 886             b = block_for_pc (pc);
 887
 888             if (!b)
 889               error (_("No block found for address"));
 890
 891             framefunc = block_linkage_function (b);
 892
 893             if (!framefunc)
 894               error (_("No function found for block"));
 895
 896             func_get_frame_base_dwarf_block (framefunc, pc,
 897                                              &datastart, &datalen);
 898
 899             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
 900
 901             /* Generate a unique-enough name, in case the frame base
 902                is computed multiple times in this expression.  */
 903             xsnprintf (fb_name, sizeof (fb_name), "__frame_base_%ld",
 904                        (long) (op_ptr - base));
 905
 906             do_compile_dwarf_expr_to_c (indent, stream,
 907                                         GCC_UINTPTR, fb_name,
 908                                         sym, pc,
 909                                         arch, registers_used, addr_size,
 910                                         datastart, datastart + datalen,
 911                                         NULL, per_cu);
 912
 913             pushf (indent, stream, "%s + %s", fb_name, hex_string (offset));
 914           }
 915           break;
 916
 917         case DW_OP_dup:
 918           pushf (indent, stream, "__gdb_stack[__gdb_tos]");
 919           break;
 920
 921         case DW_OP_drop:
 922           fprintfi_filtered (indent, stream, "--__gdb_tos;\n");
 923           break;
 924
 925         case DW_OP_pick:
 926           offset = *op_ptr++;
 927           pushf (indent, stream, "__gdb_stack[__gdb_tos - %s]",
 928                  plongest (offset));
 929           break;
 930
 931         case DW_OP_swap:
 932           fprintfi_filtered (indent, stream,
 933                              "__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n");
 934           fprintfi_filtered (indent, stream,
 935                              "__gdb_stack[__gdb_tos - 1] = "
 936                              "__gdb_stack[__gdb_tos];\n");
 937           fprintfi_filtered (indent, stream, ("__gdb_stack[__gdb_tos] = "
 938                                               "__gdb_tmp;\n"));
 939           break;
 940
 941         case DW_OP_over:
 942           pushf (indent, stream, "__gdb_stack[__gdb_tos - 1]");
 943           break;
 944
 945         case DW_OP_rot:
 946           fprintfi_filtered (indent, stream, ("__gdb_tmp = "
 947                                               "__gdb_stack[__gdb_tos];\n"));
 948           fprintfi_filtered (indent, stream,
 949                              "__gdb_stack[__gdb_tos] = "
 950                              "__gdb_stack[__gdb_tos - 1];\n");
 951           fprintfi_filtered (indent, stream,
 952                              "__gdb_stack[__gdb_tos - 1] = "
 953                              "__gdb_stack[__gdb_tos -2];\n");
 954           fprintfi_filtered (indent, stream, "__gdb_stack[__gdb_tos - 2] = "
 955                              "__gdb_tmp;\n");
 956           break;
 957
 958         case DW_OP_deref:
 959         case DW_OP_deref_size:
 960           {
 961             int size;
 962             const char *mode;
 963
 964             if (op == DW_OP_deref_size)
 965               size = *op_ptr++;
 966             else
 967               size = addr_size;
 968
 969             mode = c_get_mode_for_size (size);
 970             if (mode == NULL)
 971               error (_("Unsupported size %d in %s"),
 972                      size, get_DW_OP_name (op));
 973
 974             /* Cast to a pointer of the desired type, then
 975                dereference.  */
 976             fprintfi_filtered (indent, stream,
 977                                "__gdb_stack[__gdb_tos] = "
 978                                "*((__gdb_int_%s *) "
 979                                "__gdb_stack[__gdb_tos]);\n",
 980                                mode);
 981           }
 982           break;
 983
 984         case DW_OP_abs:
 985           unary (indent, stream,
 986                  "((" GCC_INTPTR ") __gdb_stack[__gdb_tos]) < 0 ? "
 987                  "-__gdb_stack[__gdb_tos] : __gdb_stack[__gdb_tos]");
 988           break;
 989
 990         case DW_OP_neg:
 991           unary (indent, stream, "-__gdb_stack[__gdb_tos]");
 992           break;
 993
 994         case DW_OP_not:
 995           unary (indent, stream, "~__gdb_stack[__gdb_tos]");
 996           break;
 997
 998         case DW_OP_plus_uconst:
 999           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
1000           unary (indent, stream, "__gdb_stack[__gdb_tos] + %s",
1001                  hex_string (reg));
1002           break;
1003
1004         case DW_OP_div:
1005           binary (indent, stream, ("((" GCC_INTPTR
1006                                    ") __gdb_stack[__gdb_tos-1]) / (("
1007                                    GCC_INTPTR ") __gdb_stack[__gdb_tos])"));
1008           break;
1009
1010         case DW_OP_shra:
1011           binary (indent, stream,
1012                   "((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) >> "
1013                   "__gdb_stack[__gdb_tos]");
1014           break;
1015
1016 #define BINARY(OP)                                                      \
1017           binary (indent, stream, "%s", "__gdb_stack[__gdb_tos-1] " #OP \
1018                                    " __gdb_stack[__gdb_tos]");  \
1019           break
1020
1021         case DW_OP_and:
1022           BINARY (&);
1023         case DW_OP_minus:
1024           BINARY (-);
1025         case DW_OP_mod:
1026           BINARY (%);
1027         case DW_OP_mul:
1028           BINARY (*);
1029         case DW_OP_or:
1030           BINARY (|);
1031         case DW_OP_plus:
1032           BINARY (+);
1033         case DW_OP_shl:
1034           BINARY (<<);
1035         case DW_OP_shr:
1036           BINARY (>>);
1037         case DW_OP_xor:
1038           BINARY (^);
1039 #undef BINARY
1040
1041 #define COMPARE(OP)                                                     \
1042           binary (indent, stream,                                       \
1043                   "(((" GCC_INTPTR ") __gdb_stack[__gdb_tos-1]) " #OP   \
1044                   " ((" GCC_INTPTR                                      \
1045                   ") __gdb_stack[__gdb_tos]))");                        \
1046           break
1047
1048         case DW_OP_le:
1049           COMPARE (<=);
1050         case DW_OP_ge:
1051           COMPARE (>=);
1052         case DW_OP_eq:
1053           COMPARE (==);
1054         case DW_OP_lt:
1055           COMPARE (<);
1056         case DW_OP_gt:
1057           COMPARE (>);
1058         case DW_OP_ne:
1059           COMPARE (!=);
1060 #undef COMPARE
1061
1062         case DW_OP_call_frame_cfa:
1063           {
1064             int regnum;
1065             CORE_ADDR text_offset;
1066             LONGEST off;
1067             const gdb_byte *cfa_start, *cfa_end;
1068
1069             if (dwarf2_fetch_cfa_info (arch, pc, per_cu,
1070                                        &regnum, &off,
1071                                        &text_offset, &cfa_start, &cfa_end))
1072               {
1073                 /* Register.  */
1074                 pushf_register (indent, stream, registers_used, arch, regnum,
1075                                 off);
1076               }
1077             else
1078               {
1079                 /* Another expression.  */
1080                 char cfa_name[50];
1081
1082                 /* Generate a unique-enough name, in case the CFA is
1083                    computed multiple times in this expression.  */
1084                 xsnprintf (cfa_name, sizeof (cfa_name),
1085                            "__cfa_%ld", (long) (op_ptr - base));
1086
1087                 do_compile_dwarf_expr_to_c (indent, stream,
1088                                             GCC_UINTPTR, cfa_name,
1089                                             sym, pc, arch, registers_used,
1090                                             addr_size,
1091                                             cfa_start, cfa_end,
1092                                             &text_offset, per_cu);
1093                 pushf (indent, stream, "%s", cfa_name);
1094               }
1095           }
1096
1097           break;
1098
1099         case DW_OP_skip:
1100           offset = extract_signed_integer (op_ptr, 2, byte_order);
1101           op_ptr += 2;
1102           fprintfi_filtered (indent, stream, "goto ");
1103           print_label (stream, scope, op_ptr + offset - base);
1104           fprintf_filtered (stream, ";\n");
1105           break;
1106
1107         case DW_OP_bra:
1108           offset = extract_signed_integer (op_ptr, 2, byte_order);
1109           op_ptr += 2;
1110           fprintfi_filtered (indent, stream,
1111                              "if ((( " GCC_INTPTR
1112                              ") __gdb_stack[__gdb_tos--]) != 0) goto ");
1113           print_label (stream, scope, op_ptr + offset - base);
1114           fprintf_filtered (stream, ";\n");
1115           break;
1116
1117         case DW_OP_nop:
1118           break;
1119
1120         default:
1121           error (_("unhandled DWARF op: %s"), get_DW_OP_name (op));
1122         }
1123     }
1124
1125   fprintfi_filtered (indent, stream, "%s = __gdb_stack[__gdb_tos];\n",
1126                      result_name);
1127   fprintfi_filtered (indent - 2, stream, "}\n");
1128
1129   do_cleanups (cleanup);
1130 }
1131
1132 /* See compile.h.  */
1133
1134 void
1135 compile_dwarf_expr_to_c (struct ui_file *stream, const char *result_name,
1136                          struct symbol *sym, CORE_ADDR pc,
1137                          struct gdbarch *arch, unsigned char *registers_used,
1138                          unsigned int addr_size,
1139                          const gdb_byte *op_ptr, const gdb_byte *op_end,
1140                          struct dwarf2_per_cu_data *per_cu)
1141 {
1142   do_compile_dwarf_expr_to_c (2, stream, GCC_UINTPTR, result_name, sym, pc,
1143                               arch, registers_used, addr_size, op_ptr, op_end,
1144                               NULL, per_cu);
1145 }
1146
1147 /* See compile.h.  */
1148
1149 void
1150 compile_dwarf_bounds_to_c (struct ui_file *stream,
1151                            const char *result_name,
1152                            const struct dynamic_prop *prop,
1153                            struct symbol *sym, CORE_ADDR pc,
1154                            struct gdbarch *arch, unsigned char *registers_used,
1155                            unsigned int addr_size,
1156                            const gdb_byte *op_ptr, const gdb_byte *op_end,
1157                            struct dwarf2_per_cu_data *per_cu)
1158 {
1159   do_compile_dwarf_expr_to_c (2, stream, "unsigned long ", result_name,
1160                               sym, pc, arch, registers_used,
1161                               addr_size, op_ptr, op_end, NULL, per_cu);
1162 }