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