gdb/compile/compile-loc2c.c

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