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