expprint.c revision 1.5
1/* Print in infix form a struct expression. 2 3 Copyright (C) 1986-2015 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 "symtab.h" 22#include "gdbtypes.h" 23#include "expression.h" 24#include "value.h" 25#include "language.h" 26#include "parser-defs.h" 27#include "user-regs.h" /* For user_reg_map_regnum_to_name. */ 28#include "target.h" 29#include "block.h" 30#include "objfiles.h" 31#include "valprint.h" 32 33#include <ctype.h> 34 35void 36print_expression (struct expression *exp, struct ui_file *stream) 37{ 38 int pc = 0; 39 40 print_subexp (exp, &pc, stream, PREC_NULL); 41} 42 43/* Print the subexpression of EXP that starts in position POS, on STREAM. 44 PREC is the precedence of the surrounding operator; 45 if the precedence of the main operator of this subexpression is less, 46 parentheses are needed here. */ 47 48void 49print_subexp (struct expression *exp, int *pos, 50 struct ui_file *stream, enum precedence prec) 51{ 52 exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec); 53} 54 55/* Standard implementation of print_subexp for use in language_defn 56 vectors. */ 57void 58print_subexp_standard (struct expression *exp, int *pos, 59 struct ui_file *stream, enum precedence prec) 60{ 61 unsigned tem; 62 const struct op_print *op_print_tab; 63 int pc; 64 unsigned nargs; 65 char *op_str; 66 int assign_modify = 0; 67 enum exp_opcode opcode; 68 enum precedence myprec = PREC_NULL; 69 /* Set to 1 for a right-associative operator. */ 70 int assoc = 0; 71 struct value *val; 72 char *tempstr = NULL; 73 74 op_print_tab = exp->language_defn->la_op_print_tab; 75 pc = (*pos)++; 76 opcode = exp->elts[pc].opcode; 77 switch (opcode) 78 { 79 /* Common ops */ 80 81 case OP_TYPE: 82 (*pos) += 2; 83 type_print (exp->elts[pc + 1].type, "", stream, 0); 84 return; 85 86 case OP_SCOPE: 87 myprec = PREC_PREFIX; 88 assoc = 0; 89 fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream); 90 fputs_filtered ("::", stream); 91 nargs = longest_to_int (exp->elts[pc + 2].longconst); 92 (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1); 93 fputs_filtered (&exp->elts[pc + 3].string, stream); 94 return; 95 96 case OP_LONG: 97 { 98 struct value_print_options opts; 99 100 get_no_prettyformat_print_options (&opts); 101 (*pos) += 3; 102 value_print (value_from_longest (exp->elts[pc + 1].type, 103 exp->elts[pc + 2].longconst), 104 stream, &opts); 105 } 106 return; 107 108 case OP_DOUBLE: 109 { 110 struct value_print_options opts; 111 112 get_no_prettyformat_print_options (&opts); 113 (*pos) += 3; 114 value_print (value_from_double (exp->elts[pc + 1].type, 115 exp->elts[pc + 2].doubleconst), 116 stream, &opts); 117 } 118 return; 119 120 case OP_VAR_VALUE: 121 { 122 const struct block *b; 123 124 (*pos) += 3; 125 b = exp->elts[pc + 1].block; 126 if (b != NULL 127 && BLOCK_FUNCTION (b) != NULL 128 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL) 129 { 130 fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream); 131 fputs_filtered ("::", stream); 132 } 133 fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream); 134 } 135 return; 136 137 case OP_VAR_ENTRY_VALUE: 138 { 139 (*pos) += 2; 140 fprintf_filtered (stream, "%s@entry", 141 SYMBOL_PRINT_NAME (exp->elts[pc + 1].symbol)); 142 } 143 return; 144 145 case OP_LAST: 146 (*pos) += 2; 147 fprintf_filtered (stream, "$%d", 148 longest_to_int (exp->elts[pc + 1].longconst)); 149 return; 150 151 case OP_REGISTER: 152 { 153 const char *name = &exp->elts[pc + 2].string; 154 155 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1); 156 fprintf_filtered (stream, "$%s", name); 157 return; 158 } 159 160 case OP_BOOL: 161 (*pos) += 2; 162 fprintf_filtered (stream, "%s", 163 longest_to_int (exp->elts[pc + 1].longconst) 164 ? "TRUE" : "FALSE"); 165 return; 166 167 case OP_INTERNALVAR: 168 (*pos) += 2; 169 fprintf_filtered (stream, "$%s", 170 internalvar_name (exp->elts[pc + 1].internalvar)); 171 return; 172 173 case OP_FUNCALL: 174 (*pos) += 2; 175 nargs = longest_to_int (exp->elts[pc + 1].longconst); 176 print_subexp (exp, pos, stream, PREC_SUFFIX); 177 fputs_filtered (" (", stream); 178 for (tem = 0; tem < nargs; tem++) 179 { 180 if (tem != 0) 181 fputs_filtered (", ", stream); 182 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 183 } 184 fputs_filtered (")", stream); 185 return; 186 187 case OP_NAME: 188 nargs = longest_to_int (exp->elts[pc + 1].longconst); 189 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1); 190 fputs_filtered (&exp->elts[pc + 2].string, stream); 191 return; 192 193 case OP_STRING: 194 { 195 struct value_print_options opts; 196 197 nargs = longest_to_int (exp->elts[pc + 1].longconst); 198 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1); 199 /* LA_PRINT_STRING will print using the current repeat count threshold. 200 If necessary, we can temporarily set it to zero, or pass it as an 201 additional parameter to LA_PRINT_STRING. -fnf */ 202 get_user_print_options (&opts); 203 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char, 204 (gdb_byte *) &exp->elts[pc + 2].string, nargs, 205 NULL, 0, &opts); 206 } 207 return; 208 209 case OP_OBJC_NSSTRING: /* Objective-C Foundation Class 210 NSString constant. */ 211 { 212 struct value_print_options opts; 213 214 nargs = longest_to_int (exp->elts[pc + 1].longconst); 215 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1); 216 fputs_filtered ("@\"", stream); 217 get_user_print_options (&opts); 218 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char, 219 (gdb_byte *) &exp->elts[pc + 2].string, nargs, 220 NULL, 0, &opts); 221 fputs_filtered ("\"", stream); 222 } 223 return; 224 225 case OP_OBJC_MSGCALL: 226 { /* Objective C message (method) call. */ 227 char *selector; 228 229 (*pos) += 3; 230 nargs = longest_to_int (exp->elts[pc + 2].longconst); 231 fprintf_unfiltered (stream, "["); 232 print_subexp (exp, pos, stream, PREC_SUFFIX); 233 if (0 == target_read_string (exp->elts[pc + 1].longconst, 234 &selector, 1024, NULL)) 235 { 236 error (_("bad selector")); 237 return; 238 } 239 if (nargs) 240 { 241 char *s, *nextS; 242 243 s = alloca (strlen (selector) + 1); 244 strcpy (s, selector); 245 for (tem = 0; tem < nargs; tem++) 246 { 247 nextS = strchr (s, ':'); 248 gdb_assert (nextS); /* Make sure we found ':'. */ 249 *nextS = '\0'; 250 fprintf_unfiltered (stream, " %s: ", s); 251 s = nextS + 1; 252 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 253 } 254 } 255 else 256 { 257 fprintf_unfiltered (stream, " %s", selector); 258 } 259 fprintf_unfiltered (stream, "]"); 260 /* "selector" was malloc'd by target_read_string. Free it. */ 261 xfree (selector); 262 return; 263 } 264 265 case OP_ARRAY: 266 (*pos) += 3; 267 nargs = longest_to_int (exp->elts[pc + 2].longconst); 268 nargs -= longest_to_int (exp->elts[pc + 1].longconst); 269 nargs++; 270 tem = 0; 271 if (exp->elts[pc + 4].opcode == OP_LONG 272 && exp->elts[pc + 5].type 273 == builtin_type (exp->gdbarch)->builtin_char 274 && exp->language_defn->la_language == language_c) 275 { 276 /* Attempt to print C character arrays using string syntax. 277 Walk through the args, picking up one character from each 278 of the OP_LONG expression elements. If any array element 279 does not match our expection of what we should find for 280 a simple string, revert back to array printing. Note that 281 the last expression element is an explicit null terminator 282 byte, which doesn't get printed. */ 283 tempstr = alloca (nargs); 284 pc += 4; 285 while (tem < nargs) 286 { 287 if (exp->elts[pc].opcode != OP_LONG 288 || exp->elts[pc + 1].type 289 != builtin_type (exp->gdbarch)->builtin_char) 290 { 291 /* Not a simple array of char, use regular array 292 printing. */ 293 tem = 0; 294 break; 295 } 296 else 297 { 298 tempstr[tem++] = 299 longest_to_int (exp->elts[pc + 2].longconst); 300 pc += 4; 301 } 302 } 303 } 304 if (tem > 0) 305 { 306 struct value_print_options opts; 307 308 get_user_print_options (&opts); 309 LA_PRINT_STRING (stream, builtin_type (exp->gdbarch)->builtin_char, 310 (gdb_byte *) tempstr, nargs - 1, NULL, 0, &opts); 311 (*pos) = pc; 312 } 313 else 314 { 315 fputs_filtered (" {", stream); 316 for (tem = 0; tem < nargs; tem++) 317 { 318 if (tem != 0) 319 { 320 fputs_filtered (", ", stream); 321 } 322 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 323 } 324 fputs_filtered ("}", stream); 325 } 326 return; 327 328 case TERNOP_COND: 329 if ((int) prec > (int) PREC_COMMA) 330 fputs_filtered ("(", stream); 331 /* Print the subexpressions, forcing parentheses 332 around any binary operations within them. 333 This is more parentheses than are strictly necessary, 334 but it looks clearer. */ 335 print_subexp (exp, pos, stream, PREC_HYPER); 336 fputs_filtered (" ? ", stream); 337 print_subexp (exp, pos, stream, PREC_HYPER); 338 fputs_filtered (" : ", stream); 339 print_subexp (exp, pos, stream, PREC_HYPER); 340 if ((int) prec > (int) PREC_COMMA) 341 fputs_filtered (")", stream); 342 return; 343 344 case TERNOP_SLICE: 345 print_subexp (exp, pos, stream, PREC_SUFFIX); 346 fputs_filtered ("(", stream); 347 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 348 fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream); 349 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 350 fputs_filtered (")", stream); 351 return; 352 353 case STRUCTOP_STRUCT: 354 tem = longest_to_int (exp->elts[pc + 1].longconst); 355 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); 356 print_subexp (exp, pos, stream, PREC_SUFFIX); 357 fputs_filtered (".", stream); 358 fputs_filtered (&exp->elts[pc + 2].string, stream); 359 return; 360 361 /* Will not occur for Modula-2. */ 362 case STRUCTOP_PTR: 363 tem = longest_to_int (exp->elts[pc + 1].longconst); 364 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1); 365 print_subexp (exp, pos, stream, PREC_SUFFIX); 366 fputs_filtered ("->", stream); 367 fputs_filtered (&exp->elts[pc + 2].string, stream); 368 return; 369 370 case STRUCTOP_MEMBER: 371 print_subexp (exp, pos, stream, PREC_SUFFIX); 372 fputs_filtered (".*", stream); 373 print_subexp (exp, pos, stream, PREC_SUFFIX); 374 return; 375 376 case STRUCTOP_MPTR: 377 print_subexp (exp, pos, stream, PREC_SUFFIX); 378 fputs_filtered ("->*", stream); 379 print_subexp (exp, pos, stream, PREC_SUFFIX); 380 return; 381 382 case BINOP_SUBSCRIPT: 383 print_subexp (exp, pos, stream, PREC_SUFFIX); 384 fputs_filtered ("[", stream); 385 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 386 fputs_filtered ("]", stream); 387 return; 388 389 case UNOP_POSTINCREMENT: 390 print_subexp (exp, pos, stream, PREC_SUFFIX); 391 fputs_filtered ("++", stream); 392 return; 393 394 case UNOP_POSTDECREMENT: 395 print_subexp (exp, pos, stream, PREC_SUFFIX); 396 fputs_filtered ("--", stream); 397 return; 398 399 case UNOP_CAST: 400 (*pos) += 2; 401 if ((int) prec > (int) PREC_PREFIX) 402 fputs_filtered ("(", stream); 403 fputs_filtered ("(", stream); 404 type_print (exp->elts[pc + 1].type, "", stream, 0); 405 fputs_filtered (") ", stream); 406 print_subexp (exp, pos, stream, PREC_PREFIX); 407 if ((int) prec > (int) PREC_PREFIX) 408 fputs_filtered (")", stream); 409 return; 410 411 case UNOP_CAST_TYPE: 412 if ((int) prec > (int) PREC_PREFIX) 413 fputs_filtered ("(", stream); 414 fputs_filtered ("(", stream); 415 print_subexp (exp, pos, stream, PREC_PREFIX); 416 fputs_filtered (") ", stream); 417 print_subexp (exp, pos, stream, PREC_PREFIX); 418 if ((int) prec > (int) PREC_PREFIX) 419 fputs_filtered (")", stream); 420 return; 421 422 case UNOP_DYNAMIC_CAST: 423 case UNOP_REINTERPRET_CAST: 424 fputs_filtered (opcode == UNOP_DYNAMIC_CAST ? "dynamic_cast" 425 : "reinterpret_cast", stream); 426 fputs_filtered ("<", stream); 427 print_subexp (exp, pos, stream, PREC_PREFIX); 428 fputs_filtered ("> (", stream); 429 print_subexp (exp, pos, stream, PREC_PREFIX); 430 fputs_filtered (")", stream); 431 return; 432 433 case UNOP_MEMVAL: 434 (*pos) += 2; 435 if ((int) prec > (int) PREC_PREFIX) 436 fputs_filtered ("(", stream); 437 if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC 438 && exp->elts[pc + 3].opcode == OP_LONG) 439 { 440 struct value_print_options opts; 441 442 /* We have a minimal symbol fn, probably. It's encoded 443 as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address). 444 Swallow the OP_LONG (including both its opcodes); ignore 445 its type; print the value in the type of the MEMVAL. */ 446 (*pos) += 4; 447 val = value_at_lazy (exp->elts[pc + 1].type, 448 (CORE_ADDR) exp->elts[pc + 5].longconst); 449 get_no_prettyformat_print_options (&opts); 450 value_print (val, stream, &opts); 451 } 452 else 453 { 454 fputs_filtered ("{", stream); 455 type_print (exp->elts[pc + 1].type, "", stream, 0); 456 fputs_filtered ("} ", stream); 457 print_subexp (exp, pos, stream, PREC_PREFIX); 458 } 459 if ((int) prec > (int) PREC_PREFIX) 460 fputs_filtered (")", stream); 461 return; 462 463 case UNOP_MEMVAL_TYPE: 464 if ((int) prec > (int) PREC_PREFIX) 465 fputs_filtered ("(", stream); 466 fputs_filtered ("{", stream); 467 print_subexp (exp, pos, stream, PREC_PREFIX); 468 fputs_filtered ("} ", stream); 469 print_subexp (exp, pos, stream, PREC_PREFIX); 470 if ((int) prec > (int) PREC_PREFIX) 471 fputs_filtered (")", stream); 472 return; 473 474 case UNOP_MEMVAL_TLS: 475 (*pos) += 3; 476 if ((int) prec > (int) PREC_PREFIX) 477 fputs_filtered ("(", stream); 478 fputs_filtered ("{", stream); 479 type_print (exp->elts[pc + 2].type, "", stream, 0); 480 fputs_filtered ("} ", stream); 481 print_subexp (exp, pos, stream, PREC_PREFIX); 482 if ((int) prec > (int) PREC_PREFIX) 483 fputs_filtered (")", stream); 484 return; 485 486 case BINOP_ASSIGN_MODIFY: 487 opcode = exp->elts[pc + 1].opcode; 488 (*pos) += 2; 489 myprec = PREC_ASSIGN; 490 assoc = 1; 491 assign_modify = 1; 492 op_str = "???"; 493 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++) 494 if (op_print_tab[tem].opcode == opcode) 495 { 496 op_str = op_print_tab[tem].string; 497 break; 498 } 499 if (op_print_tab[tem].opcode != opcode) 500 /* Not found; don't try to keep going because we don't know how 501 to interpret further elements. */ 502 error (_("Invalid expression")); 503 break; 504 505 /* C++ ops */ 506 507 case OP_THIS: 508 ++(*pos); 509 if (exp->language_defn->la_name_of_this) 510 fputs_filtered (exp->language_defn->la_name_of_this, stream); 511 else 512 fprintf_filtered (stream, _("<language %s has no 'this'>"), 513 exp->language_defn->la_name); 514 return; 515 516 /* Modula-2 ops */ 517 518 case MULTI_SUBSCRIPT: 519 (*pos) += 2; 520 nargs = longest_to_int (exp->elts[pc + 1].longconst); 521 print_subexp (exp, pos, stream, PREC_SUFFIX); 522 fprintf_unfiltered (stream, " ["); 523 for (tem = 0; tem < nargs; tem++) 524 { 525 if (tem != 0) 526 fprintf_unfiltered (stream, ", "); 527 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); 528 } 529 fprintf_unfiltered (stream, "]"); 530 return; 531 532 case BINOP_VAL: 533 (*pos) += 2; 534 fprintf_unfiltered (stream, "VAL("); 535 type_print (exp->elts[pc + 1].type, "", stream, 0); 536 fprintf_unfiltered (stream, ","); 537 print_subexp (exp, pos, stream, PREC_PREFIX); 538 fprintf_unfiltered (stream, ")"); 539 return; 540 541 case TYPE_INSTANCE: 542 { 543 LONGEST count = exp->elts[pc + 1].longconst; 544 545 /* The COUNT. */ 546 (*pos)++; 547 fputs_unfiltered ("TypesInstance(", stream); 548 while (count-- > 0) 549 { 550 type_print (exp->elts[(*pos)++].type, "", stream, 0); 551 if (count > 0) 552 fputs_unfiltered (",", stream); 553 } 554 fputs_unfiltered (",", stream); 555 /* Ending COUNT and ending TYPE_INSTANCE. */ 556 (*pos) += 2; 557 print_subexp (exp, pos, stream, PREC_PREFIX); 558 fputs_unfiltered (")", stream); 559 return; 560 } 561 562 /* Default ops */ 563 564 default: 565 op_str = "???"; 566 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++) 567 if (op_print_tab[tem].opcode == opcode) 568 { 569 op_str = op_print_tab[tem].string; 570 myprec = op_print_tab[tem].precedence; 571 assoc = op_print_tab[tem].right_assoc; 572 break; 573 } 574 if (op_print_tab[tem].opcode != opcode) 575 /* Not found; don't try to keep going because we don't know how 576 to interpret further elements. For example, this happens 577 if opcode is OP_TYPE. */ 578 error (_("Invalid expression")); 579 } 580 581 /* Note that PREC_BUILTIN will always emit parentheses. */ 582 if ((int) myprec < (int) prec) 583 fputs_filtered ("(", stream); 584 if ((int) opcode > (int) BINOP_END) 585 { 586 if (assoc) 587 { 588 /* Unary postfix operator. */ 589 print_subexp (exp, pos, stream, PREC_SUFFIX); 590 fputs_filtered (op_str, stream); 591 } 592 else 593 { 594 /* Unary prefix operator. */ 595 fputs_filtered (op_str, stream); 596 if (myprec == PREC_BUILTIN_FUNCTION) 597 fputs_filtered ("(", stream); 598 print_subexp (exp, pos, stream, PREC_PREFIX); 599 if (myprec == PREC_BUILTIN_FUNCTION) 600 fputs_filtered (")", stream); 601 } 602 } 603 else 604 { 605 /* Binary operator. */ 606 /* Print left operand. 607 If operator is right-associative, 608 increment precedence for this operand. */ 609 print_subexp (exp, pos, stream, 610 (enum precedence) ((int) myprec + assoc)); 611 /* Print the operator itself. */ 612 if (assign_modify) 613 fprintf_filtered (stream, " %s= ", op_str); 614 else if (op_str[0] == ',') 615 fprintf_filtered (stream, "%s ", op_str); 616 else 617 fprintf_filtered (stream, " %s ", op_str); 618 /* Print right operand. 619 If operator is left-associative, 620 increment precedence for this operand. */ 621 print_subexp (exp, pos, stream, 622 (enum precedence) ((int) myprec + !assoc)); 623 } 624 625 if ((int) myprec < (int) prec) 626 fputs_filtered (")", stream); 627} 628 629/* Return the operator corresponding to opcode OP as 630 a string. NULL indicates that the opcode was not found in the 631 current language table. */ 632char * 633op_string (enum exp_opcode op) 634{ 635 int tem; 636 const struct op_print *op_print_tab; 637 638 op_print_tab = current_language->la_op_print_tab; 639 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++) 640 if (op_print_tab[tem].opcode == op) 641 return op_print_tab[tem].string; 642 return NULL; 643} 644 645/* Support for dumping the raw data from expressions in a human readable 646 form. */ 647 648static int dump_subexp_body (struct expression *exp, struct ui_file *, int); 649 650/* Name for OPCODE, when it appears in expression EXP. */ 651 652char * 653op_name (struct expression *exp, enum exp_opcode opcode) 654{ 655 return exp->language_defn->la_exp_desc->op_name (opcode); 656} 657 658/* Default name for the standard operator OPCODE (i.e., one defined in 659 the definition of enum exp_opcode). */ 660 661char * 662op_name_standard (enum exp_opcode opcode) 663{ 664 switch (opcode) 665 { 666 default: 667 { 668 static char buf[30]; 669 670 xsnprintf (buf, sizeof (buf), "<unknown %d>", opcode); 671 return buf; 672 } 673#define OP(name) \ 674 case name: \ 675 return #name ; 676#include "std-operator.def" 677#undef OP 678 } 679} 680 681/* Print a raw dump of expression EXP to STREAM. 682 NOTE, if non-NULL, is printed as extra explanatory text. */ 683 684void 685dump_raw_expression (struct expression *exp, struct ui_file *stream, 686 char *note) 687{ 688 int elt; 689 char *opcode_name; 690 char *eltscan; 691 int eltsize; 692 693 fprintf_filtered (stream, "Dump of expression @ "); 694 gdb_print_host_address (exp, stream); 695 if (note) 696 fprintf_filtered (stream, ", %s:", note); 697 fprintf_filtered (stream, "\n\tLanguage %s, %d elements, %ld bytes each.\n", 698 exp->language_defn->la_name, exp->nelts, 699 (long) sizeof (union exp_element)); 700 fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode", 701 "Hex Value", "String Value"); 702 for (elt = 0; elt < exp->nelts; elt++) 703 { 704 fprintf_filtered (stream, "\t%5d ", elt); 705 opcode_name = op_name (exp, exp->elts[elt].opcode); 706 707 fprintf_filtered (stream, "%20s ", opcode_name); 708 print_longest (stream, 'd', 0, exp->elts[elt].longconst); 709 fprintf_filtered (stream, " "); 710 711 for (eltscan = (char *) &exp->elts[elt], 712 eltsize = sizeof (union exp_element); 713 eltsize-- > 0; 714 eltscan++) 715 { 716 fprintf_filtered (stream, "%c", 717 isprint (*eltscan) ? (*eltscan & 0xFF) : '.'); 718 } 719 fprintf_filtered (stream, "\n"); 720 } 721} 722 723/* Dump the subexpression of prefix expression EXP whose operator is at 724 position ELT onto STREAM. Returns the position of the next 725 subexpression in EXP. */ 726 727int 728dump_subexp (struct expression *exp, struct ui_file *stream, int elt) 729{ 730 static int indent = 0; 731 int i; 732 733 fprintf_filtered (stream, "\n"); 734 fprintf_filtered (stream, "\t%5d ", elt); 735 736 for (i = 1; i <= indent; i++) 737 fprintf_filtered (stream, " "); 738 indent += 2; 739 740 fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode)); 741 742 elt = dump_subexp_body (exp, stream, elt); 743 744 indent -= 2; 745 746 return elt; 747} 748 749/* Dump the operands of prefix expression EXP whose opcode is at 750 position ELT onto STREAM. Returns the position of the next 751 subexpression in EXP. */ 752 753static int 754dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt) 755{ 756 return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt); 757} 758 759/* Default value for subexp_body in exp_descriptor vector. */ 760 761int 762dump_subexp_body_standard (struct expression *exp, 763 struct ui_file *stream, int elt) 764{ 765 int opcode = exp->elts[elt++].opcode; 766 767 switch (opcode) 768 { 769 case TERNOP_COND: 770 case TERNOP_SLICE: 771 elt = dump_subexp (exp, stream, elt); 772 /* FALL THROUGH */ 773 case BINOP_ADD: 774 case BINOP_SUB: 775 case BINOP_MUL: 776 case BINOP_DIV: 777 case BINOP_REM: 778 case BINOP_MOD: 779 case BINOP_LSH: 780 case BINOP_RSH: 781 case BINOP_LOGICAL_AND: 782 case BINOP_LOGICAL_OR: 783 case BINOP_BITWISE_AND: 784 case BINOP_BITWISE_IOR: 785 case BINOP_BITWISE_XOR: 786 case BINOP_EQUAL: 787 case BINOP_NOTEQUAL: 788 case BINOP_LESS: 789 case BINOP_GTR: 790 case BINOP_LEQ: 791 case BINOP_GEQ: 792 case BINOP_REPEAT: 793 case BINOP_ASSIGN: 794 case BINOP_COMMA: 795 case BINOP_SUBSCRIPT: 796 case BINOP_EXP: 797 case BINOP_MIN: 798 case BINOP_MAX: 799 case BINOP_INTDIV: 800 case BINOP_ASSIGN_MODIFY: 801 case BINOP_VAL: 802 case BINOP_CONCAT: 803 case BINOP_END: 804 case STRUCTOP_MEMBER: 805 case STRUCTOP_MPTR: 806 elt = dump_subexp (exp, stream, elt); 807 /* FALL THROUGH */ 808 case UNOP_NEG: 809 case UNOP_LOGICAL_NOT: 810 case UNOP_COMPLEMENT: 811 case UNOP_IND: 812 case UNOP_ADDR: 813 case UNOP_PREINCREMENT: 814 case UNOP_POSTINCREMENT: 815 case UNOP_PREDECREMENT: 816 case UNOP_POSTDECREMENT: 817 case UNOP_SIZEOF: 818 case UNOP_PLUS: 819 case UNOP_CAP: 820 case UNOP_CHR: 821 case UNOP_ORD: 822 case UNOP_ABS: 823 case UNOP_FLOAT: 824 case UNOP_HIGH: 825 case UNOP_MAX: 826 case UNOP_MIN: 827 case UNOP_ODD: 828 case UNOP_TRUNC: 829 elt = dump_subexp (exp, stream, elt); 830 break; 831 case OP_LONG: 832 fprintf_filtered (stream, "Type @"); 833 gdb_print_host_address (exp->elts[elt].type, stream); 834 fprintf_filtered (stream, " ("); 835 type_print (exp->elts[elt].type, NULL, stream, 0); 836 fprintf_filtered (stream, "), value %ld (0x%lx)", 837 (long) exp->elts[elt + 1].longconst, 838 (long) exp->elts[elt + 1].longconst); 839 elt += 3; 840 break; 841 case OP_DOUBLE: 842 fprintf_filtered (stream, "Type @"); 843 gdb_print_host_address (exp->elts[elt].type, stream); 844 fprintf_filtered (stream, " ("); 845 type_print (exp->elts[elt].type, NULL, stream, 0); 846 fprintf_filtered (stream, "), value %g", 847 (double) exp->elts[elt + 1].doubleconst); 848 elt += 3; 849 break; 850 case OP_VAR_VALUE: 851 fprintf_filtered (stream, "Block @"); 852 gdb_print_host_address (exp->elts[elt].block, stream); 853 fprintf_filtered (stream, ", symbol @"); 854 gdb_print_host_address (exp->elts[elt + 1].symbol, stream); 855 fprintf_filtered (stream, " (%s)", 856 SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol)); 857 elt += 3; 858 break; 859 case OP_VAR_ENTRY_VALUE: 860 fprintf_filtered (stream, "Entry value of symbol @"); 861 gdb_print_host_address (exp->elts[elt].symbol, stream); 862 fprintf_filtered (stream, " (%s)", 863 SYMBOL_PRINT_NAME (exp->elts[elt].symbol)); 864 elt += 2; 865 break; 866 case OP_LAST: 867 fprintf_filtered (stream, "History element %ld", 868 (long) exp->elts[elt].longconst); 869 elt += 2; 870 break; 871 case OP_REGISTER: 872 fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string); 873 elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1); 874 break; 875 case OP_INTERNALVAR: 876 fprintf_filtered (stream, "Internal var @"); 877 gdb_print_host_address (exp->elts[elt].internalvar, stream); 878 fprintf_filtered (stream, " (%s)", 879 internalvar_name (exp->elts[elt].internalvar)); 880 elt += 2; 881 break; 882 case OP_FUNCALL: 883 { 884 int i, nargs; 885 886 nargs = longest_to_int (exp->elts[elt].longconst); 887 888 fprintf_filtered (stream, "Number of args: %d", nargs); 889 elt += 2; 890 891 for (i = 1; i <= nargs + 1; i++) 892 elt = dump_subexp (exp, stream, elt); 893 } 894 break; 895 case OP_ARRAY: 896 { 897 int lower, upper; 898 int i; 899 900 lower = longest_to_int (exp->elts[elt].longconst); 901 upper = longest_to_int (exp->elts[elt + 1].longconst); 902 903 fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper); 904 elt += 3; 905 906 for (i = 1; i <= upper - lower + 1; i++) 907 elt = dump_subexp (exp, stream, elt); 908 } 909 break; 910 case UNOP_DYNAMIC_CAST: 911 case UNOP_REINTERPRET_CAST: 912 case UNOP_CAST_TYPE: 913 case UNOP_MEMVAL_TYPE: 914 fprintf_filtered (stream, " ("); 915 elt = dump_subexp (exp, stream, elt); 916 fprintf_filtered (stream, ")"); 917 elt = dump_subexp (exp, stream, elt); 918 break; 919 case UNOP_MEMVAL: 920 case UNOP_CAST: 921 fprintf_filtered (stream, "Type @"); 922 gdb_print_host_address (exp->elts[elt].type, stream); 923 fprintf_filtered (stream, " ("); 924 type_print (exp->elts[elt].type, NULL, stream, 0); 925 fprintf_filtered (stream, ")"); 926 elt = dump_subexp (exp, stream, elt + 2); 927 break; 928 case UNOP_MEMVAL_TLS: 929 fprintf_filtered (stream, "TLS type @"); 930 gdb_print_host_address (exp->elts[elt + 1].type, stream); 931 fprintf_filtered (stream, " (__thread /* \"%s\" */ ", 932 (exp->elts[elt].objfile == NULL ? "(null)" 933 : objfile_name (exp->elts[elt].objfile))); 934 type_print (exp->elts[elt + 1].type, NULL, stream, 0); 935 fprintf_filtered (stream, ")"); 936 elt = dump_subexp (exp, stream, elt + 3); 937 break; 938 case OP_TYPE: 939 fprintf_filtered (stream, "Type @"); 940 gdb_print_host_address (exp->elts[elt].type, stream); 941 fprintf_filtered (stream, " ("); 942 type_print (exp->elts[elt].type, NULL, stream, 0); 943 fprintf_filtered (stream, ")"); 944 elt += 2; 945 break; 946 case OP_TYPEOF: 947 case OP_DECLTYPE: 948 fprintf_filtered (stream, "Typeof ("); 949 elt = dump_subexp (exp, stream, elt); 950 fprintf_filtered (stream, ")"); 951 break; 952 case OP_TYPEID: 953 fprintf_filtered (stream, "typeid ("); 954 elt = dump_subexp (exp, stream, elt); 955 fprintf_filtered (stream, ")"); 956 break; 957 case STRUCTOP_STRUCT: 958 case STRUCTOP_PTR: 959 { 960 char *elem_name; 961 int len; 962 963 len = longest_to_int (exp->elts[elt].longconst); 964 elem_name = &exp->elts[elt + 1].string; 965 966 fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name); 967 elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1)); 968 } 969 break; 970 case OP_SCOPE: 971 { 972 char *elem_name; 973 int len; 974 975 fprintf_filtered (stream, "Type @"); 976 gdb_print_host_address (exp->elts[elt].type, stream); 977 fprintf_filtered (stream, " ("); 978 type_print (exp->elts[elt].type, NULL, stream, 0); 979 fprintf_filtered (stream, ") "); 980 981 len = longest_to_int (exp->elts[elt + 1].longconst); 982 elem_name = &exp->elts[elt + 2].string; 983 984 fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name); 985 elt += 4 + BYTES_TO_EXP_ELEM (len + 1); 986 } 987 break; 988 case TYPE_INSTANCE: 989 { 990 LONGEST len; 991 992 len = exp->elts[elt++].longconst; 993 fprintf_filtered (stream, "%s TypeInstance: ", plongest (len)); 994 while (len-- > 0) 995 { 996 fprintf_filtered (stream, "Type @"); 997 gdb_print_host_address (exp->elts[elt].type, stream); 998 fprintf_filtered (stream, " ("); 999 type_print (exp->elts[elt].type, NULL, stream, 0); 1000 fprintf_filtered (stream, ")"); 1001 elt++; 1002 if (len > 0) 1003 fputs_filtered (", ", stream); 1004 } 1005 /* Ending LEN and ending TYPE_INSTANCE. */ 1006 elt += 2; 1007 elt = dump_subexp (exp, stream, elt); 1008 } 1009 break; 1010 case OP_STRING: 1011 { 1012 LONGEST len = exp->elts[elt].longconst; 1013 LONGEST type = exp->elts[elt + 1].longconst; 1014 1015 fprintf_filtered (stream, "Language-specific string type: %s", 1016 plongest (type)); 1017 1018 /* Skip length. */ 1019 elt += 1; 1020 1021 /* Skip string content. */ 1022 elt += BYTES_TO_EXP_ELEM (len); 1023 1024 /* Skip length and ending OP_STRING. */ 1025 elt += 2; 1026 } 1027 break; 1028 default: 1029 case OP_NULL: 1030 case MULTI_SUBSCRIPT: 1031 case OP_F77_UNDETERMINED_ARGLIST: 1032 case OP_COMPLEX: 1033 case OP_BOOL: 1034 case OP_M2_STRING: 1035 case OP_THIS: 1036 case OP_NAME: 1037 fprintf_filtered (stream, "Unknown format"); 1038 } 1039 1040 return elt; 1041} 1042 1043void 1044dump_prefix_expression (struct expression *exp, struct ui_file *stream) 1045{ 1046 int elt; 1047 1048 fprintf_filtered (stream, "Dump of expression @ "); 1049 gdb_print_host_address (exp, stream); 1050 fputs_filtered (", after conversion to prefix form:\nExpression: `", stream); 1051 print_expression (exp, stream); 1052 fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n", 1053 exp->language_defn->la_name, exp->nelts, 1054 (long) sizeof (union exp_element)); 1055 fputs_filtered ("\n", stream); 1056 1057 for (elt = 0; elt < exp->nelts;) 1058 elt = dump_subexp (exp, stream, elt); 1059 fputs_filtered ("\n", stream); 1060} 1061