gdb/compile/compile-loc2c.c

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