gdb/compile/compile-loc2c.c

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