1 /* Convert a DWARF location expression to C 2 3 Copyright (C) 2014-2023 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 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, ®); 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, ®); 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, ®); 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 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 gdb_printf (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 gdb_printf (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 gdb_printf (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 gdb_printf (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 gdb_printf (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 gdb_printf (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> ®isters_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> ®isters_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> ®isters_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> ®isters_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 gdb_printf (stream, "%*s__attribute__ ((unused)) %s %s;\n", 618 indent, "", type_name, result_name); 619 gdb_printf (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 frame_info_ptr 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 gdb_printf (stream, "%*s%s = %s;\n", 656 indent, "", result_name, 657 core_addr_to_string (value_address (val))); 658 gdb_printf (stream, "%*s}\n", indent - 2, ""); 659 return; 660 } 661 662 gdb_printf (stream, "%*s" GCC_UINTPTR " __gdb_stack[%d];\n", 663 indent, "", stack_depth); 664 665 if (need_tempvar) 666 gdb_printf (stream, "%*s" GCC_UINTPTR " __gdb_tmp;\n", indent, ""); 667 gdb_printf (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 gdb_printf (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, ®); 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, ®); 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 gdb_printf (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 gdb_printf (stream, 937 "%*s__gdb_tmp = __gdb_stack[__gdb_tos - 1];\n", 938 indent, ""); 939 gdb_printf (stream, 940 "%*s__gdb_stack[__gdb_tos - 1] = " 941 "__gdb_stack[__gdb_tos];\n", 942 indent, ""); 943 gdb_printf (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 gdb_printf (stream, ("%*s__gdb_tmp = " 954 "__gdb_stack[__gdb_tos];\n"), 955 indent, ""); 956 gdb_printf (stream, 957 "%*s__gdb_stack[__gdb_tos] = " 958 "__gdb_stack[__gdb_tos - 1];\n", 959 indent, ""); 960 gdb_printf (stream, 961 "%*s__gdb_stack[__gdb_tos - 1] = " 962 "__gdb_stack[__gdb_tos -2];\n", 963 indent, ""); 964 gdb_printf (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 gdb_printf (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, ®); 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 ®num, &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 gdb_printf (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 gdb_printf (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 gdb_printf (stream, "%*s%s = __gdb_stack[__gdb_tos];\n", 1138 indent, "", result_name); 1139 gdb_printf (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> ®isters_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> ®isters_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 } 1178