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