gdb/compile/compile-loc2c.c

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