1 /* Parse expressions for GDB. 2 3 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 4 1998, 1999, 2000, 2001, 2004, 2005, 2007, 2008, 2009, 2010, 2011 5 Free Software Foundation, Inc. 6 7 Modified from expread.y by the Department of Computer Science at the 8 State University of New York at Buffalo, 1991. 9 10 This file is part of GDB. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 3 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 24 25 /* Parse an expression from text in a string, 26 and return the result as a struct expression pointer. 27 That structure contains arithmetic operations in reverse polish, 28 with constants represented by operations that are followed by special data. 29 See expression.h for the details of the format. 30 What is important here is that it can be built up sequentially 31 during the process of parsing; the lower levels of the tree always 32 come first in the result. */ 33 34 #include "defs.h" 35 #include <ctype.h> 36 #include "arch-utils.h" 37 #include "gdb_string.h" 38 #include "symtab.h" 39 #include "gdbtypes.h" 40 #include "frame.h" 41 #include "expression.h" 42 #include "value.h" 43 #include "command.h" 44 #include "language.h" 45 #include "f-lang.h" 46 #include "parser-defs.h" 47 #include "gdbcmd.h" 48 #include "symfile.h" /* for overlay functions */ 49 #include "inferior.h" 50 #include "doublest.h" 51 #include "gdb_assert.h" 52 #include "block.h" 53 #include "source.h" 54 #include "objfiles.h" 55 #include "exceptions.h" 56 #include "user-regs.h" 57 58 /* Standard set of definitions for printing, dumping, prefixifying, 59 * and evaluating expressions. */ 60 61 const struct exp_descriptor exp_descriptor_standard = 62 { 63 print_subexp_standard, 64 operator_length_standard, 65 operator_check_standard, 66 op_name_standard, 67 dump_subexp_body_standard, 68 evaluate_subexp_standard 69 }; 70 71 /* Global variables declared in parser-defs.h (and commented there). */ 72 struct expression *expout; 73 int expout_size; 74 int expout_ptr; 75 struct block *expression_context_block; 76 CORE_ADDR expression_context_pc; 77 struct block *innermost_block; 78 int arglist_len; 79 union type_stack_elt *type_stack; 80 int type_stack_depth, type_stack_size; 81 char *lexptr; 82 char *prev_lexptr; 83 int paren_depth; 84 int comma_terminates; 85 86 /* True if parsing an expression to find a field reference. This is 87 only used by completion. */ 88 int in_parse_field; 89 90 /* The index of the last struct expression directly before a '.' or 91 '->'. This is set when parsing and is only used when completing a 92 field name. It is -1 if no dereference operation was found. */ 93 static int expout_last_struct = -1; 94 95 /* A temporary buffer for identifiers, so we can null-terminate them. 96 97 We allocate this with xrealloc. parse_exp_1 used to allocate with 98 alloca, using the size of the whole expression as a conservative 99 estimate of the space needed. However, macro expansion can 100 introduce names longer than the original expression; there's no 101 practical way to know beforehand how large that might be. */ 102 char *namecopy; 103 size_t namecopy_size; 104 105 static int expressiondebug = 0; 106 static void 107 show_expressiondebug (struct ui_file *file, int from_tty, 108 struct cmd_list_element *c, const char *value) 109 { 110 fprintf_filtered (file, _("Expression debugging is %s.\n"), value); 111 } 112 113 114 /* Non-zero if an expression parser should set yydebug. */ 115 int parser_debug; 116 117 static void 118 show_parserdebug (struct ui_file *file, int from_tty, 119 struct cmd_list_element *c, const char *value) 120 { 121 fprintf_filtered (file, _("Parser debugging is %s.\n"), value); 122 } 123 124 125 static void free_funcalls (void *ignore); 126 127 static int prefixify_expression (struct expression *); 128 129 static int prefixify_subexp (struct expression *, struct expression *, int, 130 int); 131 132 static struct expression *parse_exp_in_context (char **, struct block *, int, 133 int, int *); 134 135 void _initialize_parse (void); 136 137 /* Data structure for saving values of arglist_len for function calls whose 138 arguments contain other function calls. */ 139 140 struct funcall 141 { 142 struct funcall *next; 143 int arglist_len; 144 }; 145 146 static struct funcall *funcall_chain; 147 148 /* Begin counting arguments for a function call, 149 saving the data about any containing call. */ 150 151 void 152 start_arglist (void) 153 { 154 struct funcall *new; 155 156 new = (struct funcall *) xmalloc (sizeof (struct funcall)); 157 new->next = funcall_chain; 158 new->arglist_len = arglist_len; 159 arglist_len = 0; 160 funcall_chain = new; 161 } 162 163 /* Return the number of arguments in a function call just terminated, 164 and restore the data for the containing function call. */ 165 166 int 167 end_arglist (void) 168 { 169 int val = arglist_len; 170 struct funcall *call = funcall_chain; 171 172 funcall_chain = call->next; 173 arglist_len = call->arglist_len; 174 xfree (call); 175 return val; 176 } 177 178 /* Free everything in the funcall chain. 179 Used when there is an error inside parsing. */ 180 181 static void 182 free_funcalls (void *ignore) 183 { 184 struct funcall *call, *next; 185 186 for (call = funcall_chain; call; call = next) 187 { 188 next = call->next; 189 xfree (call); 190 } 191 } 192 193 /* This page contains the functions for adding data to the struct expression 194 being constructed. */ 195 196 /* Add one element to the end of the expression. */ 197 198 /* To avoid a bug in the Sun 4 compiler, we pass things that can fit into 199 a register through here. */ 200 201 void 202 write_exp_elt (union exp_element expelt) 203 { 204 if (expout_ptr >= expout_size) 205 { 206 expout_size *= 2; 207 expout = (struct expression *) 208 xrealloc ((char *) expout, sizeof (struct expression) 209 + EXP_ELEM_TO_BYTES (expout_size)); 210 } 211 expout->elts[expout_ptr++] = expelt; 212 } 213 214 void 215 write_exp_elt_opcode (enum exp_opcode expelt) 216 { 217 union exp_element tmp; 218 219 memset (&tmp, 0, sizeof (union exp_element)); 220 tmp.opcode = expelt; 221 write_exp_elt (tmp); 222 } 223 224 void 225 write_exp_elt_sym (struct symbol *expelt) 226 { 227 union exp_element tmp; 228 229 memset (&tmp, 0, sizeof (union exp_element)); 230 tmp.symbol = expelt; 231 write_exp_elt (tmp); 232 } 233 234 void 235 write_exp_elt_block (struct block *b) 236 { 237 union exp_element tmp; 238 239 memset (&tmp, 0, sizeof (union exp_element)); 240 tmp.block = b; 241 write_exp_elt (tmp); 242 } 243 244 void 245 write_exp_elt_objfile (struct objfile *objfile) 246 { 247 union exp_element tmp; 248 249 memset (&tmp, 0, sizeof (union exp_element)); 250 tmp.objfile = objfile; 251 write_exp_elt (tmp); 252 } 253 254 void 255 write_exp_elt_longcst (LONGEST expelt) 256 { 257 union exp_element tmp; 258 259 memset (&tmp, 0, sizeof (union exp_element)); 260 tmp.longconst = expelt; 261 write_exp_elt (tmp); 262 } 263 264 void 265 write_exp_elt_dblcst (DOUBLEST expelt) 266 { 267 union exp_element tmp; 268 269 memset (&tmp, 0, sizeof (union exp_element)); 270 tmp.doubleconst = expelt; 271 write_exp_elt (tmp); 272 } 273 274 void 275 write_exp_elt_decfloatcst (gdb_byte expelt[16]) 276 { 277 union exp_element tmp; 278 int index; 279 280 for (index = 0; index < 16; index++) 281 tmp.decfloatconst[index] = expelt[index]; 282 283 write_exp_elt (tmp); 284 } 285 286 void 287 write_exp_elt_type (struct type *expelt) 288 { 289 union exp_element tmp; 290 291 memset (&tmp, 0, sizeof (union exp_element)); 292 tmp.type = expelt; 293 write_exp_elt (tmp); 294 } 295 296 void 297 write_exp_elt_intern (struct internalvar *expelt) 298 { 299 union exp_element tmp; 300 301 memset (&tmp, 0, sizeof (union exp_element)); 302 tmp.internalvar = expelt; 303 write_exp_elt (tmp); 304 } 305 306 /* Add a string constant to the end of the expression. 307 308 String constants are stored by first writing an expression element 309 that contains the length of the string, then stuffing the string 310 constant itself into however many expression elements are needed 311 to hold it, and then writing another expression element that contains 312 the length of the string. I.e. an expression element at each end of 313 the string records the string length, so you can skip over the 314 expression elements containing the actual string bytes from either 315 end of the string. Note that this also allows gdb to handle 316 strings with embedded null bytes, as is required for some languages. 317 318 Don't be fooled by the fact that the string is null byte terminated, 319 this is strictly for the convenience of debugging gdb itself. 320 Gdb does not depend up the string being null terminated, since the 321 actual length is recorded in expression elements at each end of the 322 string. The null byte is taken into consideration when computing how 323 many expression elements are required to hold the string constant, of 324 course. */ 325 326 327 void 328 write_exp_string (struct stoken str) 329 { 330 int len = str.length; 331 int lenelt; 332 char *strdata; 333 334 /* Compute the number of expression elements required to hold the string 335 (including a null byte terminator), along with one expression element 336 at each end to record the actual string length (not including the 337 null byte terminator). */ 338 339 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1); 340 341 /* Ensure that we have enough available expression elements to store 342 everything. */ 343 344 if ((expout_ptr + lenelt) >= expout_size) 345 { 346 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10); 347 expout = (struct expression *) 348 xrealloc ((char *) expout, (sizeof (struct expression) 349 + EXP_ELEM_TO_BYTES (expout_size))); 350 } 351 352 /* Write the leading length expression element (which advances the current 353 expression element index), then write the string constant followed by a 354 terminating null byte, and then write the trailing length expression 355 element. */ 356 357 write_exp_elt_longcst ((LONGEST) len); 358 strdata = (char *) &expout->elts[expout_ptr]; 359 memcpy (strdata, str.ptr, len); 360 *(strdata + len) = '\0'; 361 expout_ptr += lenelt - 2; 362 write_exp_elt_longcst ((LONGEST) len); 363 } 364 365 /* Add a vector of string constants to the end of the expression. 366 367 This adds an OP_STRING operation, but encodes the contents 368 differently from write_exp_string. The language is expected to 369 handle evaluation of this expression itself. 370 371 After the usual OP_STRING header, TYPE is written into the 372 expression as a long constant. The interpretation of this field is 373 up to the language evaluator. 374 375 Next, each string in VEC is written. The length is written as a 376 long constant, followed by the contents of the string. */ 377 378 void 379 write_exp_string_vector (int type, struct stoken_vector *vec) 380 { 381 int i, n_slots, len; 382 383 /* Compute the size. We compute the size in number of slots to 384 avoid issues with string padding. */ 385 n_slots = 0; 386 for (i = 0; i < vec->len; ++i) 387 { 388 /* One slot for the length of this element, plus the number of 389 slots needed for this string. */ 390 n_slots += 1 + BYTES_TO_EXP_ELEM (vec->tokens[i].length); 391 } 392 393 /* One more slot for the type of the string. */ 394 ++n_slots; 395 396 /* Now compute a phony string length. */ 397 len = EXP_ELEM_TO_BYTES (n_slots) - 1; 398 399 n_slots += 4; 400 if ((expout_ptr + n_slots) >= expout_size) 401 { 402 expout_size = max (expout_size * 2, expout_ptr + n_slots + 10); 403 expout = (struct expression *) 404 xrealloc ((char *) expout, (sizeof (struct expression) 405 + EXP_ELEM_TO_BYTES (expout_size))); 406 } 407 408 write_exp_elt_opcode (OP_STRING); 409 write_exp_elt_longcst (len); 410 write_exp_elt_longcst (type); 411 412 for (i = 0; i < vec->len; ++i) 413 { 414 write_exp_elt_longcst (vec->tokens[i].length); 415 memcpy (&expout->elts[expout_ptr], vec->tokens[i].ptr, 416 vec->tokens[i].length); 417 expout_ptr += BYTES_TO_EXP_ELEM (vec->tokens[i].length); 418 } 419 420 write_exp_elt_longcst (len); 421 write_exp_elt_opcode (OP_STRING); 422 } 423 424 /* Add a bitstring constant to the end of the expression. 425 426 Bitstring constants are stored by first writing an expression element 427 that contains the length of the bitstring (in bits), then stuffing the 428 bitstring constant itself into however many expression elements are 429 needed to hold it, and then writing another expression element that 430 contains the length of the bitstring. I.e. an expression element at 431 each end of the bitstring records the bitstring length, so you can skip 432 over the expression elements containing the actual bitstring bytes from 433 either end of the bitstring. */ 434 435 void 436 write_exp_bitstring (struct stoken str) 437 { 438 int bits = str.length; /* length in bits */ 439 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; 440 int lenelt; 441 char *strdata; 442 443 /* Compute the number of expression elements required to hold the bitstring, 444 along with one expression element at each end to record the actual 445 bitstring length in bits. */ 446 447 lenelt = 2 + BYTES_TO_EXP_ELEM (len); 448 449 /* Ensure that we have enough available expression elements to store 450 everything. */ 451 452 if ((expout_ptr + lenelt) >= expout_size) 453 { 454 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10); 455 expout = (struct expression *) 456 xrealloc ((char *) expout, (sizeof (struct expression) 457 + EXP_ELEM_TO_BYTES (expout_size))); 458 } 459 460 /* Write the leading length expression element (which advances the current 461 expression element index), then write the bitstring constant, and then 462 write the trailing length expression element. */ 463 464 write_exp_elt_longcst ((LONGEST) bits); 465 strdata = (char *) &expout->elts[expout_ptr]; 466 memcpy (strdata, str.ptr, len); 467 expout_ptr += lenelt - 2; 468 write_exp_elt_longcst ((LONGEST) bits); 469 } 470 471 /* Add the appropriate elements for a minimal symbol to the end of 472 the expression. */ 473 474 void 475 write_exp_msymbol (struct minimal_symbol *msymbol) 476 { 477 struct objfile *objfile = msymbol_objfile (msymbol); 478 struct gdbarch *gdbarch = get_objfile_arch (objfile); 479 480 CORE_ADDR addr = SYMBOL_VALUE_ADDRESS (msymbol); 481 struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol); 482 enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol); 483 CORE_ADDR pc; 484 485 /* The minimal symbol might point to a function descriptor; 486 resolve it to the actual code address instead. */ 487 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, ¤t_target); 488 if (pc != addr) 489 { 490 struct minimal_symbol *ifunc_msym = lookup_minimal_symbol_by_pc (pc); 491 492 /* In this case, assume we have a code symbol instead of 493 a data symbol. */ 494 495 if (ifunc_msym != NULL && MSYMBOL_TYPE (ifunc_msym) == mst_text_gnu_ifunc 496 && SYMBOL_VALUE_ADDRESS (ifunc_msym) == pc) 497 { 498 /* A function descriptor has been resolved but PC is still in the 499 STT_GNU_IFUNC resolver body (such as because inferior does not 500 run to be able to call it). */ 501 502 type = mst_text_gnu_ifunc; 503 } 504 else 505 type = mst_text; 506 section = NULL; 507 addr = pc; 508 } 509 510 if (overlay_debugging) 511 addr = symbol_overlayed_address (addr, section); 512 513 write_exp_elt_opcode (OP_LONG); 514 /* Let's make the type big enough to hold a 64-bit address. */ 515 write_exp_elt_type (objfile_type (objfile)->builtin_core_addr); 516 write_exp_elt_longcst ((LONGEST) addr); 517 write_exp_elt_opcode (OP_LONG); 518 519 if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL) 520 { 521 write_exp_elt_opcode (UNOP_MEMVAL_TLS); 522 write_exp_elt_objfile (objfile); 523 write_exp_elt_type (objfile_type (objfile)->nodebug_tls_symbol); 524 write_exp_elt_opcode (UNOP_MEMVAL_TLS); 525 return; 526 } 527 528 write_exp_elt_opcode (UNOP_MEMVAL); 529 switch (type) 530 { 531 case mst_text: 532 case mst_file_text: 533 case mst_solib_trampoline: 534 write_exp_elt_type (objfile_type (objfile)->nodebug_text_symbol); 535 break; 536 537 case mst_text_gnu_ifunc: 538 write_exp_elt_type (objfile_type (objfile) 539 ->nodebug_text_gnu_ifunc_symbol); 540 break; 541 542 case mst_data: 543 case mst_file_data: 544 case mst_bss: 545 case mst_file_bss: 546 write_exp_elt_type (objfile_type (objfile)->nodebug_data_symbol); 547 break; 548 549 case mst_slot_got_plt: 550 write_exp_elt_type (objfile_type (objfile)->nodebug_got_plt_symbol); 551 break; 552 553 default: 554 write_exp_elt_type (objfile_type (objfile)->nodebug_unknown_symbol); 555 break; 556 } 557 write_exp_elt_opcode (UNOP_MEMVAL); 558 } 559 560 /* Mark the current index as the starting location of a structure 561 expression. This is used when completing on field names. */ 562 563 void 564 mark_struct_expression (void) 565 { 566 expout_last_struct = expout_ptr; 567 } 568 569 570 /* Recognize tokens that start with '$'. These include: 571 572 $regname A native register name or a "standard 573 register name". 574 575 $variable A convenience variable with a name chosen 576 by the user. 577 578 $digits Value history with index <digits>, starting 579 from the first value which has index 1. 580 581 $$digits Value history with index <digits> relative 582 to the last value. I.e. $$0 is the last 583 value, $$1 is the one previous to that, $$2 584 is the one previous to $$1, etc. 585 586 $ | $0 | $$0 The last value in the value history. 587 588 $$ An abbreviation for the second to the last 589 value in the value history, I.e. $$1 */ 590 591 void 592 write_dollar_variable (struct stoken str) 593 { 594 struct symbol *sym = NULL; 595 struct minimal_symbol *msym = NULL; 596 struct internalvar *isym = NULL; 597 598 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1) 599 and $$digits (equivalent to $<-digits> if you could type that). */ 600 601 int negate = 0; 602 int i = 1; 603 /* Double dollar means negate the number and add -1 as well. 604 Thus $$ alone means -1. */ 605 if (str.length >= 2 && str.ptr[1] == '$') 606 { 607 negate = 1; 608 i = 2; 609 } 610 if (i == str.length) 611 { 612 /* Just dollars (one or two). */ 613 i = -negate; 614 goto handle_last; 615 } 616 /* Is the rest of the token digits? */ 617 for (; i < str.length; i++) 618 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9')) 619 break; 620 if (i == str.length) 621 { 622 i = atoi (str.ptr + 1 + negate); 623 if (negate) 624 i = -i; 625 goto handle_last; 626 } 627 628 /* Handle tokens that refer to machine registers: 629 $ followed by a register name. */ 630 i = user_reg_map_name_to_regnum (parse_gdbarch, 631 str.ptr + 1, str.length - 1); 632 if (i >= 0) 633 goto handle_register; 634 635 /* Any names starting with $ are probably debugger internal variables. */ 636 637 isym = lookup_only_internalvar (copy_name (str) + 1); 638 if (isym) 639 { 640 write_exp_elt_opcode (OP_INTERNALVAR); 641 write_exp_elt_intern (isym); 642 write_exp_elt_opcode (OP_INTERNALVAR); 643 return; 644 } 645 646 /* On some systems, such as HP-UX and hppa-linux, certain system routines 647 have names beginning with $ or $$. Check for those, first. */ 648 649 sym = lookup_symbol (copy_name (str), (struct block *) NULL, 650 VAR_DOMAIN, (int *) NULL); 651 if (sym) 652 { 653 write_exp_elt_opcode (OP_VAR_VALUE); 654 write_exp_elt_block (block_found); /* set by lookup_symbol */ 655 write_exp_elt_sym (sym); 656 write_exp_elt_opcode (OP_VAR_VALUE); 657 return; 658 } 659 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL); 660 if (msym) 661 { 662 write_exp_msymbol (msym); 663 return; 664 } 665 666 /* Any other names are assumed to be debugger internal variables. */ 667 668 write_exp_elt_opcode (OP_INTERNALVAR); 669 write_exp_elt_intern (create_internalvar (copy_name (str) + 1)); 670 write_exp_elt_opcode (OP_INTERNALVAR); 671 return; 672 handle_last: 673 write_exp_elt_opcode (OP_LAST); 674 write_exp_elt_longcst ((LONGEST) i); 675 write_exp_elt_opcode (OP_LAST); 676 return; 677 handle_register: 678 write_exp_elt_opcode (OP_REGISTER); 679 str.length--; 680 str.ptr++; 681 write_exp_string (str); 682 write_exp_elt_opcode (OP_REGISTER); 683 return; 684 } 685 686 687 char * 688 find_template_name_end (char *p) 689 { 690 int depth = 1; 691 int just_seen_right = 0; 692 int just_seen_colon = 0; 693 int just_seen_space = 0; 694 695 if (!p || (*p != '<')) 696 return 0; 697 698 while (*++p) 699 { 700 switch (*p) 701 { 702 case '\'': 703 case '\"': 704 case '{': 705 case '}': 706 /* In future, may want to allow these?? */ 707 return 0; 708 case '<': 709 depth++; /* start nested template */ 710 if (just_seen_colon || just_seen_right || just_seen_space) 711 return 0; /* but not after : or :: or > or space */ 712 break; 713 case '>': 714 if (just_seen_colon || just_seen_right) 715 return 0; /* end a (nested?) template */ 716 just_seen_right = 1; /* but not after : or :: */ 717 if (--depth == 0) /* also disallow >>, insist on > > */ 718 return ++p; /* if outermost ended, return */ 719 break; 720 case ':': 721 if (just_seen_space || (just_seen_colon > 1)) 722 return 0; /* nested class spec coming up */ 723 just_seen_colon++; /* we allow :: but not :::: */ 724 break; 725 case ' ': 726 break; 727 default: 728 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */ 729 (*p >= 'A' && *p <= 'Z') || 730 (*p >= '0' && *p <= '9') || 731 (*p == '_') || (*p == ',') || /* commas for template args */ 732 (*p == '&') || (*p == '*') || /* pointer and ref types */ 733 (*p == '(') || (*p == ')') || /* function types */ 734 (*p == '[') || (*p == ']'))) /* array types */ 735 return 0; 736 } 737 if (*p != ' ') 738 just_seen_space = 0; 739 if (*p != ':') 740 just_seen_colon = 0; 741 if (*p != '>') 742 just_seen_right = 0; 743 } 744 return 0; 745 } 746 747 748 749 /* Return a null-terminated temporary copy of the name 750 of a string token. */ 751 752 char * 753 copy_name (struct stoken token) 754 { 755 /* Make sure there's enough space for the token. */ 756 if (namecopy_size < token.length + 1) 757 { 758 namecopy_size = token.length + 1; 759 namecopy = xrealloc (namecopy, token.length + 1); 760 } 761 762 memcpy (namecopy, token.ptr, token.length); 763 namecopy[token.length] = 0; 764 765 return namecopy; 766 } 767 768 /* Reverse an expression from suffix form (in which it is constructed) 769 to prefix form (in which we can conveniently print or execute it). 770 Ordinarily this always returns -1. However, if EXPOUT_LAST_STRUCT 771 is not -1 (i.e., we are trying to complete a field name), it will 772 return the index of the subexpression which is the left-hand-side 773 of the struct operation at EXPOUT_LAST_STRUCT. */ 774 775 static int 776 prefixify_expression (struct expression *expr) 777 { 778 int len = sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts); 779 struct expression *temp; 780 int inpos = expr->nelts, outpos = 0; 781 782 temp = (struct expression *) alloca (len); 783 784 /* Copy the original expression into temp. */ 785 memcpy (temp, expr, len); 786 787 return prefixify_subexp (temp, expr, inpos, outpos); 788 } 789 790 /* Return the number of exp_elements in the postfix subexpression 791 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */ 792 793 int 794 length_of_subexp (struct expression *expr, int endpos) 795 { 796 int oplen, args; 797 798 operator_length (expr, endpos, &oplen, &args); 799 800 while (args > 0) 801 { 802 oplen += length_of_subexp (expr, endpos - oplen); 803 args--; 804 } 805 806 return oplen; 807 } 808 809 /* Sets *OPLENP to the length of the operator whose (last) index is 810 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that 811 operator takes. */ 812 813 void 814 operator_length (const struct expression *expr, int endpos, int *oplenp, 815 int *argsp) 816 { 817 expr->language_defn->la_exp_desc->operator_length (expr, endpos, 818 oplenp, argsp); 819 } 820 821 /* Default value for operator_length in exp_descriptor vectors. */ 822 823 void 824 operator_length_standard (const struct expression *expr, int endpos, 825 int *oplenp, int *argsp) 826 { 827 int oplen = 1; 828 int args = 0; 829 enum f90_range_type range_type; 830 int i; 831 832 if (endpos < 1) 833 error (_("?error in operator_length_standard")); 834 835 i = (int) expr->elts[endpos - 1].opcode; 836 837 switch (i) 838 { 839 /* C++ */ 840 case OP_SCOPE: 841 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 842 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1); 843 break; 844 845 case OP_LONG: 846 case OP_DOUBLE: 847 case OP_DECFLOAT: 848 case OP_VAR_VALUE: 849 oplen = 4; 850 break; 851 852 case OP_TYPE: 853 case OP_BOOL: 854 case OP_LAST: 855 case OP_INTERNALVAR: 856 oplen = 3; 857 break; 858 859 case OP_COMPLEX: 860 oplen = 3; 861 args = 2; 862 break; 863 864 case OP_FUNCALL: 865 case OP_F77_UNDETERMINED_ARGLIST: 866 oplen = 3; 867 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst); 868 break; 869 870 case TYPE_INSTANCE: 871 oplen = 4 + longest_to_int (expr->elts[endpos - 2].longconst); 872 args = 1; 873 break; 874 875 case OP_OBJC_MSGCALL: /* Objective C message (method) call. */ 876 oplen = 4; 877 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst); 878 break; 879 880 case UNOP_MAX: 881 case UNOP_MIN: 882 oplen = 3; 883 break; 884 885 case BINOP_VAL: 886 case UNOP_CAST: 887 case UNOP_DYNAMIC_CAST: 888 case UNOP_REINTERPRET_CAST: 889 case UNOP_MEMVAL: 890 oplen = 3; 891 args = 1; 892 break; 893 894 case UNOP_MEMVAL_TLS: 895 oplen = 4; 896 args = 1; 897 break; 898 899 case UNOP_ABS: 900 case UNOP_CAP: 901 case UNOP_CHR: 902 case UNOP_FLOAT: 903 case UNOP_HIGH: 904 case UNOP_ODD: 905 case UNOP_ORD: 906 case UNOP_TRUNC: 907 oplen = 1; 908 args = 1; 909 break; 910 911 case OP_ADL_FUNC: 912 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 913 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1); 914 oplen++; 915 oplen++; 916 break; 917 918 case OP_LABELED: 919 case STRUCTOP_STRUCT: 920 case STRUCTOP_PTR: 921 args = 1; 922 /* fall through */ 923 case OP_REGISTER: 924 case OP_M2_STRING: 925 case OP_STRING: 926 case OP_OBJC_NSSTRING: /* Objective C Foundation Class 927 NSString constant. */ 928 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op. */ 929 case OP_NAME: 930 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 931 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1); 932 break; 933 934 case OP_BITSTRING: 935 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 936 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; 937 oplen = 4 + BYTES_TO_EXP_ELEM (oplen); 938 break; 939 940 case OP_ARRAY: 941 oplen = 4; 942 args = longest_to_int (expr->elts[endpos - 2].longconst); 943 args -= longest_to_int (expr->elts[endpos - 3].longconst); 944 args += 1; 945 break; 946 947 case TERNOP_COND: 948 case TERNOP_SLICE: 949 case TERNOP_SLICE_COUNT: 950 args = 3; 951 break; 952 953 /* Modula-2 */ 954 case MULTI_SUBSCRIPT: 955 oplen = 3; 956 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst); 957 break; 958 959 case BINOP_ASSIGN_MODIFY: 960 oplen = 3; 961 args = 2; 962 break; 963 964 /* C++ */ 965 case OP_THIS: 966 case OP_OBJC_SELF: 967 oplen = 2; 968 break; 969 970 case OP_F90_RANGE: 971 oplen = 3; 972 973 range_type = longest_to_int (expr->elts[endpos - 2].longconst); 974 switch (range_type) 975 { 976 case LOW_BOUND_DEFAULT: 977 case HIGH_BOUND_DEFAULT: 978 args = 1; 979 break; 980 case BOTH_BOUND_DEFAULT: 981 args = 0; 982 break; 983 case NONE_BOUND_DEFAULT: 984 args = 2; 985 break; 986 } 987 988 break; 989 990 default: 991 args = 1 + (i < (int) BINOP_END); 992 } 993 994 *oplenp = oplen; 995 *argsp = args; 996 } 997 998 /* Copy the subexpression ending just before index INEND in INEXPR 999 into OUTEXPR, starting at index OUTBEG. 1000 In the process, convert it from suffix to prefix form. 1001 If EXPOUT_LAST_STRUCT is -1, then this function always returns -1. 1002 Otherwise, it returns the index of the subexpression which is the 1003 left-hand-side of the expression at EXPOUT_LAST_STRUCT. */ 1004 1005 static int 1006 prefixify_subexp (struct expression *inexpr, 1007 struct expression *outexpr, int inend, int outbeg) 1008 { 1009 int oplen; 1010 int args; 1011 int i; 1012 int *arglens; 1013 int result = -1; 1014 1015 operator_length (inexpr, inend, &oplen, &args); 1016 1017 /* Copy the final operator itself, from the end of the input 1018 to the beginning of the output. */ 1019 inend -= oplen; 1020 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend], 1021 EXP_ELEM_TO_BYTES (oplen)); 1022 outbeg += oplen; 1023 1024 if (expout_last_struct == inend) 1025 result = outbeg - oplen; 1026 1027 /* Find the lengths of the arg subexpressions. */ 1028 arglens = (int *) alloca (args * sizeof (int)); 1029 for (i = args - 1; i >= 0; i--) 1030 { 1031 oplen = length_of_subexp (inexpr, inend); 1032 arglens[i] = oplen; 1033 inend -= oplen; 1034 } 1035 1036 /* Now copy each subexpression, preserving the order of 1037 the subexpressions, but prefixifying each one. 1038 In this loop, inend starts at the beginning of 1039 the expression this level is working on 1040 and marches forward over the arguments. 1041 outbeg does similarly in the output. */ 1042 for (i = 0; i < args; i++) 1043 { 1044 int r; 1045 1046 oplen = arglens[i]; 1047 inend += oplen; 1048 r = prefixify_subexp (inexpr, outexpr, inend, outbeg); 1049 if (r != -1) 1050 { 1051 /* Return immediately. We probably have only parsed a 1052 partial expression, so we don't want to try to reverse 1053 the other operands. */ 1054 return r; 1055 } 1056 outbeg += oplen; 1057 } 1058 1059 return result; 1060 } 1061 1062 /* Read an expression from the string *STRINGPTR points to, 1063 parse it, and return a pointer to a struct expression that we malloc. 1064 Use block BLOCK as the lexical context for variable names; 1065 if BLOCK is zero, use the block of the selected stack frame. 1066 Meanwhile, advance *STRINGPTR to point after the expression, 1067 at the first nonwhite character that is not part of the expression 1068 (possibly a null character). 1069 1070 If COMMA is nonzero, stop if a comma is reached. */ 1071 1072 struct expression * 1073 parse_exp_1 (char **stringptr, struct block *block, int comma) 1074 { 1075 return parse_exp_in_context (stringptr, block, comma, 0, NULL); 1076 } 1077 1078 /* As for parse_exp_1, except that if VOID_CONTEXT_P, then 1079 no value is expected from the expression. 1080 OUT_SUBEXP is set when attempting to complete a field name; in this 1081 case it is set to the index of the subexpression on the 1082 left-hand-side of the struct op. If not doing such completion, it 1083 is left untouched. */ 1084 1085 static struct expression * 1086 parse_exp_in_context (char **stringptr, struct block *block, int comma, 1087 int void_context_p, int *out_subexp) 1088 { 1089 volatile struct gdb_exception except; 1090 struct cleanup *old_chain; 1091 const struct language_defn *lang = NULL; 1092 int subexp; 1093 1094 lexptr = *stringptr; 1095 prev_lexptr = NULL; 1096 1097 paren_depth = 0; 1098 type_stack_depth = 0; 1099 expout_last_struct = -1; 1100 1101 comma_terminates = comma; 1102 1103 if (lexptr == 0 || *lexptr == 0) 1104 error_no_arg (_("expression to compute")); 1105 1106 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/); 1107 funcall_chain = 0; 1108 1109 expression_context_block = block; 1110 1111 /* If no context specified, try using the current frame, if any. */ 1112 if (!expression_context_block) 1113 expression_context_block = get_selected_block (&expression_context_pc); 1114 else 1115 expression_context_pc = BLOCK_START (expression_context_block); 1116 1117 /* Fall back to using the current source static context, if any. */ 1118 1119 if (!expression_context_block) 1120 { 1121 struct symtab_and_line cursal = get_current_source_symtab_and_line (); 1122 if (cursal.symtab) 1123 expression_context_block 1124 = BLOCKVECTOR_BLOCK (BLOCKVECTOR (cursal.symtab), STATIC_BLOCK); 1125 if (expression_context_block) 1126 expression_context_pc = BLOCK_START (expression_context_block); 1127 } 1128 1129 if (language_mode == language_mode_auto && block != NULL) 1130 { 1131 /* Find the language associated to the given context block. 1132 Default to the current language if it can not be determined. 1133 1134 Note that using the language corresponding to the current frame 1135 can sometimes give unexpected results. For instance, this 1136 routine is often called several times during the inferior 1137 startup phase to re-parse breakpoint expressions after 1138 a new shared library has been loaded. The language associated 1139 to the current frame at this moment is not relevant for 1140 the breakpoint. Using it would therefore be silly, so it seems 1141 better to rely on the current language rather than relying on 1142 the current frame language to parse the expression. That's why 1143 we do the following language detection only if the context block 1144 has been specifically provided. */ 1145 struct symbol *func = block_linkage_function (block); 1146 1147 if (func != NULL) 1148 lang = language_def (SYMBOL_LANGUAGE (func)); 1149 if (lang == NULL || lang->la_language == language_unknown) 1150 lang = current_language; 1151 } 1152 else 1153 lang = current_language; 1154 1155 expout_size = 10; 1156 expout_ptr = 0; 1157 expout = (struct expression *) 1158 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size)); 1159 expout->language_defn = lang; 1160 expout->gdbarch = get_current_arch (); 1161 1162 TRY_CATCH (except, RETURN_MASK_ALL) 1163 { 1164 if (lang->la_parser ()) 1165 lang->la_error (NULL); 1166 } 1167 if (except.reason < 0) 1168 { 1169 if (! in_parse_field) 1170 { 1171 xfree (expout); 1172 throw_exception (except); 1173 } 1174 } 1175 1176 discard_cleanups (old_chain); 1177 1178 /* Record the actual number of expression elements, and then 1179 reallocate the expression memory so that we free up any 1180 excess elements. */ 1181 1182 expout->nelts = expout_ptr; 1183 expout = (struct expression *) 1184 xrealloc ((char *) expout, 1185 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr)); 1186 1187 /* Convert expression from postfix form as generated by yacc 1188 parser, to a prefix form. */ 1189 1190 if (expressiondebug) 1191 dump_raw_expression (expout, gdb_stdlog, 1192 "before conversion to prefix form"); 1193 1194 subexp = prefixify_expression (expout); 1195 if (out_subexp) 1196 *out_subexp = subexp; 1197 1198 lang->la_post_parser (&expout, void_context_p); 1199 1200 if (expressiondebug) 1201 dump_prefix_expression (expout, gdb_stdlog); 1202 1203 *stringptr = lexptr; 1204 return expout; 1205 } 1206 1207 /* Parse STRING as an expression, and complain if this fails 1208 to use up all of the contents of STRING. */ 1209 1210 struct expression * 1211 parse_expression (char *string) 1212 { 1213 struct expression *exp; 1214 1215 exp = parse_exp_1 (&string, 0, 0); 1216 if (*string) 1217 error (_("Junk after end of expression.")); 1218 return exp; 1219 } 1220 1221 /* Parse STRING as an expression. If parsing ends in the middle of a 1222 field reference, return the type of the left-hand-side of the 1223 reference; furthermore, if the parsing ends in the field name, 1224 return the field name in *NAME. If the parsing ends in the middle 1225 of a field reference, but the reference is somehow invalid, throw 1226 an exception. In all other cases, return NULL. Returned non-NULL 1227 *NAME must be freed by the caller. */ 1228 1229 struct type * 1230 parse_field_expression (char *string, char **name) 1231 { 1232 struct expression *exp = NULL; 1233 struct value *val; 1234 int subexp; 1235 volatile struct gdb_exception except; 1236 1237 TRY_CATCH (except, RETURN_MASK_ERROR) 1238 { 1239 in_parse_field = 1; 1240 exp = parse_exp_in_context (&string, 0, 0, 0, &subexp); 1241 } 1242 in_parse_field = 0; 1243 if (except.reason < 0 || ! exp) 1244 return NULL; 1245 if (expout_last_struct == -1) 1246 { 1247 xfree (exp); 1248 return NULL; 1249 } 1250 1251 *name = extract_field_op (exp, &subexp); 1252 if (!*name) 1253 { 1254 xfree (exp); 1255 return NULL; 1256 } 1257 1258 /* This might throw an exception. If so, we want to let it 1259 propagate. */ 1260 val = evaluate_subexpression_type (exp, subexp); 1261 /* (*NAME) is a part of the EXP memory block freed below. */ 1262 *name = xstrdup (*name); 1263 xfree (exp); 1264 1265 return value_type (val); 1266 } 1267 1268 /* A post-parser that does nothing. */ 1269 1270 void 1271 null_post_parser (struct expression **exp, int void_context_p) 1272 { 1273 } 1274 1275 /* Parse floating point value P of length LEN. 1276 Return 0 (false) if invalid, 1 (true) if valid. 1277 The successfully parsed number is stored in D. 1278 *SUFFIX points to the suffix of the number in P. 1279 1280 NOTE: This accepts the floating point syntax that sscanf accepts. */ 1281 1282 int 1283 parse_float (const char *p, int len, DOUBLEST *d, const char **suffix) 1284 { 1285 char *copy; 1286 char *s; 1287 int n, num; 1288 1289 copy = xmalloc (len + 1); 1290 memcpy (copy, p, len); 1291 copy[len] = 0; 1292 1293 num = sscanf (copy, "%" DOUBLEST_SCAN_FORMAT "%n", d, &n); 1294 xfree (copy); 1295 1296 /* The sscanf man page suggests not making any assumptions on the effect 1297 of %n on the result, so we don't. 1298 That is why we simply test num == 0. */ 1299 if (num == 0) 1300 return 0; 1301 1302 *suffix = p + n; 1303 return 1; 1304 } 1305 1306 /* Parse floating point value P of length LEN, using the C syntax for floats. 1307 Return 0 (false) if invalid, 1 (true) if valid. 1308 The successfully parsed number is stored in *D. 1309 Its type is taken from builtin_type (gdbarch) and is stored in *T. */ 1310 1311 int 1312 parse_c_float (struct gdbarch *gdbarch, const char *p, int len, 1313 DOUBLEST *d, struct type **t) 1314 { 1315 const char *suffix; 1316 int suffix_len; 1317 const struct builtin_type *builtin_types = builtin_type (gdbarch); 1318 1319 if (! parse_float (p, len, d, &suffix)) 1320 return 0; 1321 1322 suffix_len = p + len - suffix; 1323 1324 if (suffix_len == 0) 1325 *t = builtin_types->builtin_double; 1326 else if (suffix_len == 1) 1327 { 1328 /* Handle suffixes: 'f' for float, 'l' for long double. */ 1329 if (tolower (*suffix) == 'f') 1330 *t = builtin_types->builtin_float; 1331 else if (tolower (*suffix) == 'l') 1332 *t = builtin_types->builtin_long_double; 1333 else 1334 return 0; 1335 } 1336 else 1337 return 0; 1338 1339 return 1; 1340 } 1341 1342 /* Stuff for maintaining a stack of types. Currently just used by C, but 1343 probably useful for any language which declares its types "backwards". */ 1344 1345 static void 1346 check_type_stack_depth (void) 1347 { 1348 if (type_stack_depth == type_stack_size) 1349 { 1350 type_stack_size *= 2; 1351 type_stack = (union type_stack_elt *) 1352 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack)); 1353 } 1354 } 1355 1356 void 1357 push_type (enum type_pieces tp) 1358 { 1359 check_type_stack_depth (); 1360 type_stack[type_stack_depth++].piece = tp; 1361 } 1362 1363 void 1364 push_type_int (int n) 1365 { 1366 check_type_stack_depth (); 1367 type_stack[type_stack_depth++].int_val = n; 1368 } 1369 1370 void 1371 push_type_address_space (char *string) 1372 { 1373 push_type_int (address_space_name_to_int (parse_gdbarch, string)); 1374 } 1375 1376 enum type_pieces 1377 pop_type (void) 1378 { 1379 if (type_stack_depth) 1380 return type_stack[--type_stack_depth].piece; 1381 return tp_end; 1382 } 1383 1384 int 1385 pop_type_int (void) 1386 { 1387 if (type_stack_depth) 1388 return type_stack[--type_stack_depth].int_val; 1389 /* "Can't happen". */ 1390 return 0; 1391 } 1392 1393 /* Pop the type stack and return the type which corresponds to FOLLOW_TYPE 1394 as modified by all the stuff on the stack. */ 1395 struct type * 1396 follow_types (struct type *follow_type) 1397 { 1398 int done = 0; 1399 int make_const = 0; 1400 int make_volatile = 0; 1401 int make_addr_space = 0; 1402 int array_size; 1403 1404 while (!done) 1405 switch (pop_type ()) 1406 { 1407 case tp_end: 1408 done = 1; 1409 if (make_const) 1410 follow_type = make_cv_type (make_const, 1411 TYPE_VOLATILE (follow_type), 1412 follow_type, 0); 1413 if (make_volatile) 1414 follow_type = make_cv_type (TYPE_CONST (follow_type), 1415 make_volatile, 1416 follow_type, 0); 1417 if (make_addr_space) 1418 follow_type = make_type_with_address_space (follow_type, 1419 make_addr_space); 1420 make_const = make_volatile = 0; 1421 make_addr_space = 0; 1422 break; 1423 case tp_const: 1424 make_const = 1; 1425 break; 1426 case tp_volatile: 1427 make_volatile = 1; 1428 break; 1429 case tp_space_identifier: 1430 make_addr_space = pop_type_int (); 1431 break; 1432 case tp_pointer: 1433 follow_type = lookup_pointer_type (follow_type); 1434 if (make_const) 1435 follow_type = make_cv_type (make_const, 1436 TYPE_VOLATILE (follow_type), 1437 follow_type, 0); 1438 if (make_volatile) 1439 follow_type = make_cv_type (TYPE_CONST (follow_type), 1440 make_volatile, 1441 follow_type, 0); 1442 if (make_addr_space) 1443 follow_type = make_type_with_address_space (follow_type, 1444 make_addr_space); 1445 make_const = make_volatile = 0; 1446 make_addr_space = 0; 1447 break; 1448 case tp_reference: 1449 follow_type = lookup_reference_type (follow_type); 1450 if (make_const) 1451 follow_type = make_cv_type (make_const, 1452 TYPE_VOLATILE (follow_type), 1453 follow_type, 0); 1454 if (make_volatile) 1455 follow_type = make_cv_type (TYPE_CONST (follow_type), 1456 make_volatile, 1457 follow_type, 0); 1458 if (make_addr_space) 1459 follow_type = make_type_with_address_space (follow_type, 1460 make_addr_space); 1461 make_const = make_volatile = 0; 1462 make_addr_space = 0; 1463 break; 1464 case tp_array: 1465 array_size = pop_type_int (); 1466 /* FIXME-type-allocation: need a way to free this type when we are 1467 done with it. */ 1468 follow_type = 1469 lookup_array_range_type (follow_type, 1470 0, array_size >= 0 ? array_size - 1 : 0); 1471 if (array_size < 0) 1472 TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (follow_type) = 1; 1473 break; 1474 case tp_function: 1475 /* FIXME-type-allocation: need a way to free this type when we are 1476 done with it. */ 1477 follow_type = lookup_function_type (follow_type); 1478 break; 1479 } 1480 return follow_type; 1481 } 1482 1483 /* This function avoids direct calls to fprintf 1484 in the parser generated debug code. */ 1485 void 1486 parser_fprintf (FILE *x, const char *y, ...) 1487 { 1488 va_list args; 1489 1490 va_start (args, y); 1491 if (x == stderr) 1492 vfprintf_unfiltered (gdb_stderr, y, args); 1493 else 1494 { 1495 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n"); 1496 vfprintf_unfiltered (gdb_stderr, y, args); 1497 } 1498 va_end (args); 1499 } 1500 1501 /* Implementation of the exp_descriptor method operator_check. */ 1502 1503 int 1504 operator_check_standard (struct expression *exp, int pos, 1505 int (*objfile_func) (struct objfile *objfile, 1506 void *data), 1507 void *data) 1508 { 1509 const union exp_element *const elts = exp->elts; 1510 struct type *type = NULL; 1511 struct objfile *objfile = NULL; 1512 1513 /* Extended operators should have been already handled by exp_descriptor 1514 iterate method of its specific language. */ 1515 gdb_assert (elts[pos].opcode < OP_EXTENDED0); 1516 1517 /* Track the callers of write_exp_elt_type for this table. */ 1518 1519 switch (elts[pos].opcode) 1520 { 1521 case BINOP_VAL: 1522 case OP_COMPLEX: 1523 case OP_DECFLOAT: 1524 case OP_DOUBLE: 1525 case OP_LONG: 1526 case OP_SCOPE: 1527 case OP_TYPE: 1528 case UNOP_CAST: 1529 case UNOP_DYNAMIC_CAST: 1530 case UNOP_REINTERPRET_CAST: 1531 case UNOP_MAX: 1532 case UNOP_MEMVAL: 1533 case UNOP_MIN: 1534 type = elts[pos + 1].type; 1535 break; 1536 1537 case TYPE_INSTANCE: 1538 { 1539 LONGEST arg, nargs = elts[pos + 1].longconst; 1540 1541 for (arg = 0; arg < nargs; arg++) 1542 { 1543 struct type *type = elts[pos + 2 + arg].type; 1544 struct objfile *objfile = TYPE_OBJFILE (type); 1545 1546 if (objfile && (*objfile_func) (objfile, data)) 1547 return 1; 1548 } 1549 } 1550 break; 1551 1552 case UNOP_MEMVAL_TLS: 1553 objfile = elts[pos + 1].objfile; 1554 type = elts[pos + 2].type; 1555 break; 1556 1557 case OP_VAR_VALUE: 1558 { 1559 const struct block *const block = elts[pos + 1].block; 1560 const struct symbol *const symbol = elts[pos + 2].symbol; 1561 1562 /* Check objfile where the variable itself is placed. 1563 SYMBOL_OBJ_SECTION (symbol) may be NULL. */ 1564 if ((*objfile_func) (SYMBOL_SYMTAB (symbol)->objfile, data)) 1565 return 1; 1566 1567 /* Check objfile where is placed the code touching the variable. */ 1568 objfile = lookup_objfile_from_block (block); 1569 1570 type = SYMBOL_TYPE (symbol); 1571 } 1572 break; 1573 } 1574 1575 /* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */ 1576 1577 if (type && TYPE_OBJFILE (type) 1578 && (*objfile_func) (TYPE_OBJFILE (type), data)) 1579 return 1; 1580 if (objfile && (*objfile_func) (objfile, data)) 1581 return 1; 1582 1583 return 0; 1584 } 1585 1586 /* Call OBJFILE_FUNC for any TYPE and OBJFILE found being referenced by EXP. 1587 The functions are never called with NULL OBJFILE. Functions get passed an 1588 arbitrary caller supplied DATA pointer. If any of the functions returns 1589 non-zero value then (any other) non-zero value is immediately returned to 1590 the caller. Otherwise zero is returned after iterating through whole EXP. 1591 */ 1592 1593 static int 1594 exp_iterate (struct expression *exp, 1595 int (*objfile_func) (struct objfile *objfile, void *data), 1596 void *data) 1597 { 1598 int endpos; 1599 1600 for (endpos = exp->nelts; endpos > 0; ) 1601 { 1602 int pos, args, oplen = 0; 1603 1604 operator_length (exp, endpos, &oplen, &args); 1605 gdb_assert (oplen > 0); 1606 1607 pos = endpos - oplen; 1608 if (exp->language_defn->la_exp_desc->operator_check (exp, pos, 1609 objfile_func, data)) 1610 return 1; 1611 1612 endpos = pos; 1613 } 1614 1615 return 0; 1616 } 1617 1618 /* Helper for exp_uses_objfile. */ 1619 1620 static int 1621 exp_uses_objfile_iter (struct objfile *exp_objfile, void *objfile_voidp) 1622 { 1623 struct objfile *objfile = objfile_voidp; 1624 1625 if (exp_objfile->separate_debug_objfile_backlink) 1626 exp_objfile = exp_objfile->separate_debug_objfile_backlink; 1627 1628 return exp_objfile == objfile; 1629 } 1630 1631 /* Return 1 if EXP uses OBJFILE (and will become dangling when OBJFILE 1632 is unloaded), otherwise return 0. OBJFILE must not be a separate debug info 1633 file. */ 1634 1635 int 1636 exp_uses_objfile (struct expression *exp, struct objfile *objfile) 1637 { 1638 gdb_assert (objfile->separate_debug_objfile_backlink == NULL); 1639 1640 return exp_iterate (exp, exp_uses_objfile_iter, objfile); 1641 } 1642 1643 void 1644 _initialize_parse (void) 1645 { 1646 type_stack_size = 80; 1647 type_stack_depth = 0; 1648 type_stack = (union type_stack_elt *) 1649 xmalloc (type_stack_size * sizeof (*type_stack)); 1650 1651 add_setshow_zinteger_cmd ("expression", class_maintenance, 1652 &expressiondebug, 1653 _("Set expression debugging."), 1654 _("Show expression debugging."), 1655 _("When non-zero, the internal representation " 1656 "of expressions will be printed."), 1657 NULL, 1658 show_expressiondebug, 1659 &setdebuglist, &showdebuglist); 1660 add_setshow_boolean_cmd ("parser", class_maintenance, 1661 &parser_debug, 1662 _("Set parser debugging."), 1663 _("Show parser debugging."), 1664 _("When non-zero, expression parser " 1665 "tracing will be enabled."), 1666 NULL, 1667 show_parserdebug, 1668 &setdebuglist, &showdebuglist); 1669 } 1670