1/* Symbol table lookup for the GNU debugger, GDB. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 5 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25#include "symtab.h" 26#include "gdbtypes.h" 27#include "gdbcore.h" 28#include "frame.h" 29#include "target.h" 30#include "value.h" 31#include "symfile.h" 32#include "objfiles.h" 33#include "gdbcmd.h" 34#include "call-cmds.h" 35#include "gdb_regex.h" 36#include "expression.h" 37#include "language.h" 38#include "demangle.h" 39#include "inferior.h" 40#include "linespec.h" 41#include "source.h" 42#include "filenames.h" /* for FILENAME_CMP */ 43#include "objc-lang.h" 44 45#include "hashtab.h" 46 47#include "gdb_obstack.h" 48#include "block.h" 49#include "dictionary.h" 50 51#include <sys/types.h> 52#include <fcntl.h> 53#include "gdb_string.h" 54#include "gdb_stat.h" 55#include <ctype.h> 56#include "cp-abi.h" 57 58/* Prototypes for local functions */ 59 60static void completion_list_add_name (char *, char *, int, char *, char *); 61 62static void rbreak_command (char *, int); 63 64static void types_info (char *, int); 65 66static void functions_info (char *, int); 67 68static void variables_info (char *, int); 69 70static void sources_info (char *, int); 71 72static void output_source_filename (char *, int *); 73 74static int find_line_common (struct linetable *, int, int *); 75 76/* This one is used by linespec.c */ 77 78char *operator_chars (char *p, char **end); 79 80static struct symbol *lookup_symbol_aux (const char *name, 81 const char *linkage_name, 82 const struct block *block, 83 const domain_enum domain, 84 int *is_a_field_of_this, 85 struct symtab **symtab); 86 87static 88struct symbol *lookup_symbol_aux_local (const char *name, 89 const char *linkage_name, 90 const struct block *block, 91 const domain_enum domain, 92 struct symtab **symtab); 93 94static 95struct symbol *lookup_symbol_aux_symtabs (int block_index, 96 const char *name, 97 const char *linkage_name, 98 const domain_enum domain, 99 struct symtab **symtab); 100 101static 102struct symbol *lookup_symbol_aux_psymtabs (int block_index, 103 const char *name, 104 const char *linkage_name, 105 const domain_enum domain, 106 struct symtab **symtab); 107 108#if 0 109static 110struct symbol *lookup_symbol_aux_minsyms (const char *name, 111 const char *linkage_name, 112 const domain_enum domain, 113 int *is_a_field_of_this, 114 struct symtab **symtab); 115#endif 116 117/* This flag is used in hppa-tdep.c, and set in hp-symtab-read.c */ 118/* Signals the presence of objects compiled by HP compilers */ 119int hp_som_som_object_present = 0; 120 121static void fixup_section (struct general_symbol_info *, struct objfile *); 122 123static int file_matches (char *, char **, int); 124 125static void print_symbol_info (domain_enum, 126 struct symtab *, struct symbol *, int, char *); 127 128static void print_msymbol_info (struct minimal_symbol *); 129 130static void symtab_symbol_info (char *, domain_enum, int); 131 132void _initialize_symtab (void); 133 134/* */ 135 136/* The single non-language-specific builtin type */ 137struct type *builtin_type_error; 138 139/* Block in which the most recently searched-for symbol was found. 140 Might be better to make this a parameter to lookup_symbol and 141 value_of_this. */ 142 143const struct block *block_found; 144 145/* Check for a symtab of a specific name; first in symtabs, then in 146 psymtabs. *If* there is no '/' in the name, a match after a '/' 147 in the symtab filename will also work. */ 148 149struct symtab * 150lookup_symtab (const char *name) 151{ 152 struct symtab *s; 153 struct partial_symtab *ps; 154 struct objfile *objfile; 155 char *real_path = NULL; 156 char *full_path = NULL; 157 158 /* Here we are interested in canonicalizing an absolute path, not 159 absolutizing a relative path. */ 160 if (IS_ABSOLUTE_PATH (name)) 161 { 162 full_path = xfullpath (name); 163 make_cleanup (xfree, full_path); 164 real_path = gdb_realpath (name); 165 make_cleanup (xfree, real_path); 166 } 167 168got_symtab: 169 170 /* First, search for an exact match */ 171 172 ALL_SYMTABS (objfile, s) 173 { 174 if (FILENAME_CMP (name, s->filename) == 0) 175 { 176 return s; 177 } 178 179 /* If the user gave us an absolute path, try to find the file in 180 this symtab and use its absolute path. */ 181 182 if (full_path != NULL) 183 { 184 const char *fp = symtab_to_filename (s); 185 if (FILENAME_CMP (full_path, fp) == 0) 186 { 187 return s; 188 } 189 } 190 191 if (real_path != NULL) 192 { 193 char *rp = gdb_realpath (symtab_to_filename (s)); 194 make_cleanup (xfree, rp); 195 if (FILENAME_CMP (real_path, rp) == 0) 196 { 197 return s; 198 } 199 } 200 } 201 202 /* Now, search for a matching tail (only if name doesn't have any dirs) */ 203 204 if (lbasename (name) == name) 205 ALL_SYMTABS (objfile, s) 206 { 207 if (FILENAME_CMP (lbasename (s->filename), name) == 0) 208 return s; 209 } 210 211 /* Same search rules as above apply here, but now we look thru the 212 psymtabs. */ 213 214 ps = lookup_partial_symtab (name); 215 if (!ps) 216 return (NULL); 217 218 if (ps->readin) 219 error ("Internal: readin %s pst for `%s' found when no symtab found.", 220 ps->filename, name); 221 222 s = PSYMTAB_TO_SYMTAB (ps); 223 224 if (s) 225 return s; 226 227 /* At this point, we have located the psymtab for this file, but 228 the conversion to a symtab has failed. This usually happens 229 when we are looking up an include file. In this case, 230 PSYMTAB_TO_SYMTAB doesn't return a symtab, even though one has 231 been created. So, we need to run through the symtabs again in 232 order to find the file. 233 XXX - This is a crock, and should be fixed inside of the the 234 symbol parsing routines. */ 235 goto got_symtab; 236} 237 238/* Lookup the partial symbol table of a source file named NAME. 239 *If* there is no '/' in the name, a match after a '/' 240 in the psymtab filename will also work. */ 241 242struct partial_symtab * 243lookup_partial_symtab (const char *name) 244{ 245 struct partial_symtab *pst; 246 struct objfile *objfile; 247 char *full_path = NULL; 248 char *real_path = NULL; 249 250 /* Here we are interested in canonicalizing an absolute path, not 251 absolutizing a relative path. */ 252 if (IS_ABSOLUTE_PATH (name)) 253 { 254 full_path = xfullpath (name); 255 make_cleanup (xfree, full_path); 256 real_path = gdb_realpath (name); 257 make_cleanup (xfree, real_path); 258 } 259 260 ALL_PSYMTABS (objfile, pst) 261 { 262 if (FILENAME_CMP (name, pst->filename) == 0) 263 { 264 return (pst); 265 } 266 267 /* If the user gave us an absolute path, try to find the file in 268 this symtab and use its absolute path. */ 269 if (full_path != NULL) 270 { 271 if (pst->fullname == NULL) 272 source_full_path_of (pst->filename, &pst->fullname); 273 if (pst->fullname != NULL 274 && FILENAME_CMP (full_path, pst->fullname) == 0) 275 { 276 return pst; 277 } 278 } 279 280 if (real_path != NULL) 281 { 282 char *rp = NULL; 283 if (pst->fullname == NULL) 284 source_full_path_of (pst->filename, &pst->fullname); 285 if (pst->fullname != NULL) 286 { 287 rp = gdb_realpath (pst->fullname); 288 make_cleanup (xfree, rp); 289 } 290 if (rp != NULL && FILENAME_CMP (real_path, rp) == 0) 291 { 292 return pst; 293 } 294 } 295 } 296 297 /* Now, search for a matching tail (only if name doesn't have any dirs) */ 298 299 if (lbasename (name) == name) 300 ALL_PSYMTABS (objfile, pst) 301 { 302 if (FILENAME_CMP (lbasename (pst->filename), name) == 0) 303 return (pst); 304 } 305 306 return (NULL); 307} 308 309/* Mangle a GDB method stub type. This actually reassembles the pieces of the 310 full method name, which consist of the class name (from T), the unadorned 311 method name from METHOD_ID, and the signature for the specific overload, 312 specified by SIGNATURE_ID. Note that this function is g++ specific. */ 313 314char * 315gdb_mangle_name (struct type *type, int method_id, int signature_id) 316{ 317 int mangled_name_len; 318 char *mangled_name; 319 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, method_id); 320 struct fn_field *method = &f[signature_id]; 321 char *field_name = TYPE_FN_FIELDLIST_NAME (type, method_id); 322 char *physname = TYPE_FN_FIELD_PHYSNAME (f, signature_id); 323 char *newname = type_name_no_tag (type); 324 325 /* Does the form of physname indicate that it is the full mangled name 326 of a constructor (not just the args)? */ 327 int is_full_physname_constructor; 328 329 int is_constructor; 330 int is_destructor = is_destructor_name (physname); 331 /* Need a new type prefix. */ 332 char *const_prefix = method->is_const ? "C" : ""; 333 char *volatile_prefix = method->is_volatile ? "V" : ""; 334 char buf[20]; 335 int len = (newname == NULL ? 0 : strlen (newname)); 336 337 /* Nothing to do if physname already contains a fully mangled v3 abi name 338 or an operator name. */ 339 if ((physname[0] == '_' && physname[1] == 'Z') 340 || is_operator_name (field_name)) 341 return xstrdup (physname); 342 343 is_full_physname_constructor = is_constructor_name (physname); 344 345 is_constructor = 346 is_full_physname_constructor || (newname && strcmp (field_name, newname) == 0); 347 348 if (!is_destructor) 349 is_destructor = (strncmp (physname, "__dt", 4) == 0); 350 351 if (is_destructor || is_full_physname_constructor) 352 { 353 mangled_name = (char *) xmalloc (strlen (physname) + 1); 354 strcpy (mangled_name, physname); 355 return mangled_name; 356 } 357 358 if (len == 0) 359 { 360 sprintf (buf, "__%s%s", const_prefix, volatile_prefix); 361 } 362 else if (physname[0] == 't' || physname[0] == 'Q') 363 { 364 /* The physname for template and qualified methods already includes 365 the class name. */ 366 sprintf (buf, "__%s%s", const_prefix, volatile_prefix); 367 newname = NULL; 368 len = 0; 369 } 370 else 371 { 372 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len); 373 } 374 mangled_name_len = ((is_constructor ? 0 : strlen (field_name)) 375 + strlen (buf) + len + strlen (physname) + 1); 376 377 { 378 mangled_name = (char *) xmalloc (mangled_name_len); 379 if (is_constructor) 380 mangled_name[0] = '\0'; 381 else 382 strcpy (mangled_name, field_name); 383 } 384 strcat (mangled_name, buf); 385 /* If the class doesn't have a name, i.e. newname NULL, then we just 386 mangle it using 0 for the length of the class. Thus it gets mangled 387 as something starting with `::' rather than `classname::'. */ 388 if (newname != NULL) 389 strcat (mangled_name, newname); 390 391 strcat (mangled_name, physname); 392 return (mangled_name); 393} 394 395 396/* Initialize the language dependent portion of a symbol 397 depending upon the language for the symbol. */ 398void 399symbol_init_language_specific (struct general_symbol_info *gsymbol, 400 enum language language) 401{ 402 gsymbol->language = language; 403 if (gsymbol->language == language_cplus 404 || gsymbol->language == language_java 405 || gsymbol->language == language_objc) 406 { 407 gsymbol->language_specific.cplus_specific.demangled_name = NULL; 408 } 409 else 410 { 411 memset (&gsymbol->language_specific, 0, 412 sizeof (gsymbol->language_specific)); 413 } 414} 415 416/* Functions to initialize a symbol's mangled name. */ 417 418/* Create the hash table used for demangled names. Each hash entry is 419 a pair of strings; one for the mangled name and one for the demangled 420 name. The entry is hashed via just the mangled name. */ 421 422static void 423create_demangled_names_hash (struct objfile *objfile) 424{ 425 /* Choose 256 as the starting size of the hash table, somewhat arbitrarily. 426 The hash table code will round this up to the next prime number. 427 Choosing a much larger table size wastes memory, and saves only about 428 1% in symbol reading. */ 429 430 objfile->demangled_names_hash = htab_create_alloc_ex 431 (256, htab_hash_string, (int (*) (const void *, const void *)) streq, 432 NULL, objfile->md, xmcalloc, xmfree); 433} 434 435/* Try to determine the demangled name for a symbol, based on the 436 language of that symbol. If the language is set to language_auto, 437 it will attempt to find any demangling algorithm that works and 438 then set the language appropriately. The returned name is allocated 439 by the demangler and should be xfree'd. */ 440 441static char * 442symbol_find_demangled_name (struct general_symbol_info *gsymbol, 443 const char *mangled) 444{ 445 char *demangled = NULL; 446 447 if (gsymbol->language == language_unknown) 448 gsymbol->language = language_auto; 449 450 if (gsymbol->language == language_objc 451 || gsymbol->language == language_auto) 452 { 453 demangled = 454 objc_demangle (mangled, 0); 455 if (demangled != NULL) 456 { 457 gsymbol->language = language_objc; 458 return demangled; 459 } 460 } 461 if (gsymbol->language == language_cplus 462 || gsymbol->language == language_auto) 463 { 464 demangled = 465 cplus_demangle (mangled, DMGL_PARAMS | DMGL_ANSI); 466 if (demangled != NULL) 467 { 468 gsymbol->language = language_cplus; 469 return demangled; 470 } 471 } 472 if (gsymbol->language == language_java) 473 { 474 demangled = 475 cplus_demangle (mangled, 476 DMGL_PARAMS | DMGL_ANSI | DMGL_JAVA); 477 if (demangled != NULL) 478 { 479 gsymbol->language = language_java; 480 return demangled; 481 } 482 } 483 return NULL; 484} 485 486/* Set both the mangled and demangled (if any) names for GSYMBOL based 487 on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE 488 is used, and the memory comes from that objfile's objfile_obstack. 489 LINKAGE_NAME is copied, so the pointer can be discarded after 490 calling this function. */ 491 492/* We have to be careful when dealing with Java names: when we run 493 into a Java minimal symbol, we don't know it's a Java symbol, so it 494 gets demangled as a C++ name. This is unfortunate, but there's not 495 much we can do about it: but when demangling partial symbols and 496 regular symbols, we'd better not reuse the wrong demangled name. 497 (See PR gdb/1039.) We solve this by putting a distinctive prefix 498 on Java names when storing them in the hash table. */ 499 500/* FIXME: carlton/2003-03-13: This is an unfortunate situation. I 501 don't mind the Java prefix so much: different languages have 502 different demangling requirements, so it's only natural that we 503 need to keep language data around in our demangling cache. But 504 it's not good that the minimal symbol has the wrong demangled name. 505 Unfortunately, I can't think of any easy solution to that 506 problem. */ 507 508#define JAVA_PREFIX "##JAVA$$" 509#define JAVA_PREFIX_LEN 8 510 511void 512symbol_set_names (struct general_symbol_info *gsymbol, 513 const char *linkage_name, int len, struct objfile *objfile) 514{ 515 char **slot; 516 /* A 0-terminated copy of the linkage name. */ 517 const char *linkage_name_copy; 518 /* A copy of the linkage name that might have a special Java prefix 519 added to it, for use when looking names up in the hash table. */ 520 const char *lookup_name; 521 /* The length of lookup_name. */ 522 int lookup_len; 523 524 if (objfile->demangled_names_hash == NULL) 525 create_demangled_names_hash (objfile); 526 527 /* The stabs reader generally provides names that are not 528 NUL-terminated; most of the other readers don't do this, so we 529 can just use the given copy, unless we're in the Java case. */ 530 if (gsymbol->language == language_java) 531 { 532 char *alloc_name; 533 lookup_len = len + JAVA_PREFIX_LEN; 534 535 alloc_name = alloca (lookup_len + 1); 536 memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN); 537 memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len); 538 alloc_name[lookup_len] = '\0'; 539 540 lookup_name = alloc_name; 541 linkage_name_copy = alloc_name + JAVA_PREFIX_LEN; 542 } 543 else if (linkage_name[len] != '\0') 544 { 545 char *alloc_name; 546 lookup_len = len; 547 548 alloc_name = alloca (lookup_len + 1); 549 memcpy (alloc_name, linkage_name, len); 550 alloc_name[lookup_len] = '\0'; 551 552 lookup_name = alloc_name; 553 linkage_name_copy = alloc_name; 554 } 555 else 556 { 557 lookup_len = len; 558 lookup_name = linkage_name; 559 linkage_name_copy = linkage_name; 560 } 561 562 slot = (char **) htab_find_slot (objfile->demangled_names_hash, 563 lookup_name, INSERT); 564 565 /* If this name is not in the hash table, add it. */ 566 if (*slot == NULL) 567 { 568 char *demangled_name = symbol_find_demangled_name (gsymbol, 569 linkage_name_copy); 570 int demangled_len = demangled_name ? strlen (demangled_name) : 0; 571 572 /* If there is a demangled name, place it right after the mangled name. 573 Otherwise, just place a second zero byte after the end of the mangled 574 name. */ 575 *slot = obstack_alloc (&objfile->objfile_obstack, 576 lookup_len + demangled_len + 2); 577 memcpy (*slot, lookup_name, lookup_len + 1); 578 if (demangled_name != NULL) 579 { 580 memcpy (*slot + lookup_len + 1, demangled_name, demangled_len + 1); 581 xfree (demangled_name); 582 } 583 else 584 (*slot)[lookup_len + 1] = '\0'; 585 } 586 587 gsymbol->name = *slot + lookup_len - len; 588 if ((*slot)[lookup_len + 1] != '\0') 589 gsymbol->language_specific.cplus_specific.demangled_name 590 = &(*slot)[lookup_len + 1]; 591 else 592 gsymbol->language_specific.cplus_specific.demangled_name = NULL; 593} 594 595/* Initialize the demangled name of GSYMBOL if possible. Any required space 596 to store the name is obtained from the specified obstack. The function 597 symbol_set_names, above, should be used instead where possible for more 598 efficient memory usage. */ 599 600void 601symbol_init_demangled_name (struct general_symbol_info *gsymbol, 602 struct obstack *obstack) 603{ 604 char *mangled = gsymbol->name; 605 char *demangled = NULL; 606 607 demangled = symbol_find_demangled_name (gsymbol, mangled); 608 if (gsymbol->language == language_cplus 609 || gsymbol->language == language_java 610 || gsymbol->language == language_objc) 611 { 612 if (demangled) 613 { 614 gsymbol->language_specific.cplus_specific.demangled_name 615 = obsavestring (demangled, strlen (demangled), obstack); 616 xfree (demangled); 617 } 618 else 619 gsymbol->language_specific.cplus_specific.demangled_name = NULL; 620 } 621 else 622 { 623 /* Unknown language; just clean up quietly. */ 624 if (demangled) 625 xfree (demangled); 626 } 627} 628 629/* Return the source code name of a symbol. In languages where 630 demangling is necessary, this is the demangled name. */ 631 632char * 633symbol_natural_name (const struct general_symbol_info *gsymbol) 634{ 635 if ((gsymbol->language == language_cplus 636 || gsymbol->language == language_java 637 || gsymbol->language == language_objc) 638 && (gsymbol->language_specific.cplus_specific.demangled_name != NULL)) 639 { 640 return gsymbol->language_specific.cplus_specific.demangled_name; 641 } 642 else 643 { 644 return gsymbol->name; 645 } 646} 647 648/* Return the demangled name for a symbol based on the language for 649 that symbol. If no demangled name exists, return NULL. */ 650char * 651symbol_demangled_name (struct general_symbol_info *gsymbol) 652{ 653 if (gsymbol->language == language_cplus 654 || gsymbol->language == language_java 655 || gsymbol->language == language_objc) 656 return gsymbol->language_specific.cplus_specific.demangled_name; 657 658 else 659 return NULL; 660} 661 662/* Initialize the structure fields to zero values. */ 663void 664init_sal (struct symtab_and_line *sal) 665{ 666 sal->symtab = 0; 667 sal->section = 0; 668 sal->line = 0; 669 sal->pc = 0; 670 sal->end = 0; 671} 672 673 674 675/* Find which partial symtab contains PC and SECTION. Return 0 if 676 none. We return the psymtab that contains a symbol whose address 677 exactly matches PC, or, if we cannot find an exact match, the 678 psymtab that contains a symbol whose address is closest to PC. */ 679struct partial_symtab * 680find_pc_sect_psymtab (CORE_ADDR pc, asection *section) 681{ 682 struct partial_symtab *pst; 683 struct objfile *objfile; 684 struct minimal_symbol *msymbol; 685 686 /* If we know that this is not a text address, return failure. This is 687 necessary because we loop based on texthigh and textlow, which do 688 not include the data ranges. */ 689 msymbol = lookup_minimal_symbol_by_pc_section (pc, section); 690 if (msymbol 691 && (msymbol->type == mst_data 692 || msymbol->type == mst_bss 693 || msymbol->type == mst_abs 694 || msymbol->type == mst_file_data 695 || msymbol->type == mst_file_bss)) 696 return NULL; 697 698 ALL_PSYMTABS (objfile, pst) 699 { 700 if (pc >= pst->textlow && pc < pst->texthigh) 701 { 702 struct partial_symtab *tpst; 703 struct partial_symtab *best_pst = pst; 704 struct partial_symbol *best_psym = NULL; 705 706 /* An objfile that has its functions reordered might have 707 many partial symbol tables containing the PC, but 708 we want the partial symbol table that contains the 709 function containing the PC. */ 710 if (!(objfile->flags & OBJF_REORDERED) && 711 section == 0) /* can't validate section this way */ 712 return (pst); 713 714 if (msymbol == NULL) 715 return (pst); 716 717 /* The code range of partial symtabs sometimes overlap, so, in 718 the loop below, we need to check all partial symtabs and 719 find the one that fits better for the given PC address. We 720 select the partial symtab that contains a symbol whose 721 address is closest to the PC address. By closest we mean 722 that find_pc_sect_symbol returns the symbol with address 723 that is closest and still less than the given PC. */ 724 for (tpst = pst; tpst != NULL; tpst = tpst->next) 725 { 726 if (pc >= tpst->textlow && pc < tpst->texthigh) 727 { 728 struct partial_symbol *p; 729 730 p = find_pc_sect_psymbol (tpst, pc, section); 731 if (p != NULL 732 && SYMBOL_VALUE_ADDRESS (p) 733 == SYMBOL_VALUE_ADDRESS (msymbol)) 734 return (tpst); 735 if (p != NULL) 736 { 737 /* We found a symbol in this partial symtab which 738 matches (or is closest to) PC, check whether it 739 is closer than our current BEST_PSYM. Since 740 this symbol address is necessarily lower or 741 equal to PC, the symbol closer to PC is the 742 symbol which address is the highest. */ 743 /* This way we return the psymtab which contains 744 such best match symbol. This can help in cases 745 where the symbol information/debuginfo is not 746 complete, like for instance on IRIX6 with gcc, 747 where no debug info is emitted for 748 statics. (See also the nodebug.exp 749 testcase.) */ 750 if (best_psym == NULL 751 || SYMBOL_VALUE_ADDRESS (p) 752 > SYMBOL_VALUE_ADDRESS (best_psym)) 753 { 754 best_psym = p; 755 best_pst = tpst; 756 } 757 } 758 759 } 760 } 761 return (best_pst); 762 } 763 } 764 return (NULL); 765} 766 767/* Find which partial symtab contains PC. Return 0 if none. 768 Backward compatibility, no section */ 769 770struct partial_symtab * 771find_pc_psymtab (CORE_ADDR pc) 772{ 773 return find_pc_sect_psymtab (pc, find_pc_mapped_section (pc)); 774} 775 776/* Find which partial symbol within a psymtab matches PC and SECTION. 777 Return 0 if none. Check all psymtabs if PSYMTAB is 0. */ 778 779struct partial_symbol * 780find_pc_sect_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc, 781 asection *section) 782{ 783 struct partial_symbol *best = NULL, *p, **pp; 784 CORE_ADDR best_pc; 785 786 if (!psymtab) 787 psymtab = find_pc_sect_psymtab (pc, section); 788 if (!psymtab) 789 return 0; 790 791 /* Cope with programs that start at address 0 */ 792 best_pc = (psymtab->textlow != 0) ? psymtab->textlow - 1 : 0; 793 794 /* Search the global symbols as well as the static symbols, so that 795 find_pc_partial_function doesn't use a minimal symbol and thus 796 cache a bad endaddr. */ 797 for (pp = psymtab->objfile->global_psymbols.list + psymtab->globals_offset; 798 (pp - (psymtab->objfile->global_psymbols.list + psymtab->globals_offset) 799 < psymtab->n_global_syms); 800 pp++) 801 { 802 p = *pp; 803 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN 804 && SYMBOL_CLASS (p) == LOC_BLOCK 805 && pc >= SYMBOL_VALUE_ADDRESS (p) 806 && (SYMBOL_VALUE_ADDRESS (p) > best_pc 807 || (psymtab->textlow == 0 808 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0))) 809 { 810 if (section) /* match on a specific section */ 811 { 812 fixup_psymbol_section (p, psymtab->objfile); 813 if (SYMBOL_BFD_SECTION (p) != section) 814 continue; 815 } 816 best_pc = SYMBOL_VALUE_ADDRESS (p); 817 best = p; 818 } 819 } 820 821 for (pp = psymtab->objfile->static_psymbols.list + psymtab->statics_offset; 822 (pp - (psymtab->objfile->static_psymbols.list + psymtab->statics_offset) 823 < psymtab->n_static_syms); 824 pp++) 825 { 826 p = *pp; 827 if (SYMBOL_DOMAIN (p) == VAR_DOMAIN 828 && SYMBOL_CLASS (p) == LOC_BLOCK 829 && pc >= SYMBOL_VALUE_ADDRESS (p) 830 && (SYMBOL_VALUE_ADDRESS (p) > best_pc 831 || (psymtab->textlow == 0 832 && best_pc == 0 && SYMBOL_VALUE_ADDRESS (p) == 0))) 833 { 834 if (section) /* match on a specific section */ 835 { 836 fixup_psymbol_section (p, psymtab->objfile); 837 if (SYMBOL_BFD_SECTION (p) != section) 838 continue; 839 } 840 best_pc = SYMBOL_VALUE_ADDRESS (p); 841 best = p; 842 } 843 } 844 845 return best; 846} 847 848/* Find which partial symbol within a psymtab matches PC. Return 0 if none. 849 Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */ 850 851struct partial_symbol * 852find_pc_psymbol (struct partial_symtab *psymtab, CORE_ADDR pc) 853{ 854 return find_pc_sect_psymbol (psymtab, pc, find_pc_mapped_section (pc)); 855} 856 857/* Debug symbols usually don't have section information. We need to dig that 858 out of the minimal symbols and stash that in the debug symbol. */ 859 860static void 861fixup_section (struct general_symbol_info *ginfo, struct objfile *objfile) 862{ 863 struct minimal_symbol *msym; 864 msym = lookup_minimal_symbol (ginfo->name, NULL, objfile); 865 866 if (msym) 867 { 868 ginfo->bfd_section = SYMBOL_BFD_SECTION (msym); 869 ginfo->section = SYMBOL_SECTION (msym); 870 } 871} 872 873struct symbol * 874fixup_symbol_section (struct symbol *sym, struct objfile *objfile) 875{ 876 if (!sym) 877 return NULL; 878 879 if (SYMBOL_BFD_SECTION (sym)) 880 return sym; 881 882 fixup_section (&sym->ginfo, objfile); 883 884 return sym; 885} 886 887struct partial_symbol * 888fixup_psymbol_section (struct partial_symbol *psym, struct objfile *objfile) 889{ 890 if (!psym) 891 return NULL; 892 893 if (SYMBOL_BFD_SECTION (psym)) 894 return psym; 895 896 fixup_section (&psym->ginfo, objfile); 897 898 return psym; 899} 900 901/* Find the definition for a specified symbol name NAME 902 in domain DOMAIN, visible from lexical block BLOCK. 903 Returns the struct symbol pointer, or zero if no symbol is found. 904 If SYMTAB is non-NULL, store the symbol table in which the 905 symbol was found there, or NULL if not found. 906 C++: if IS_A_FIELD_OF_THIS is nonzero on entry, check to see if 907 NAME is a field of the current implied argument `this'. If so set 908 *IS_A_FIELD_OF_THIS to 1, otherwise set it to zero. 909 BLOCK_FOUND is set to the block in which NAME is found (in the case of 910 a field of `this', value_of_this sets BLOCK_FOUND to the proper value.) */ 911 912/* This function has a bunch of loops in it and it would seem to be 913 attractive to put in some QUIT's (though I'm not really sure 914 whether it can run long enough to be really important). But there 915 are a few calls for which it would appear to be bad news to quit 916 out of here: find_proc_desc in alpha-tdep.c and mips-tdep.c. (Note 917 that there is C++ code below which can error(), but that probably 918 doesn't affect these calls since they are looking for a known 919 variable and thus can probably assume it will never hit the C++ 920 code). */ 921 922struct symbol * 923lookup_symbol (const char *name, const struct block *block, 924 const domain_enum domain, int *is_a_field_of_this, 925 struct symtab **symtab) 926{ 927 char *demangled_name = NULL; 928 const char *modified_name = NULL; 929 const char *mangled_name = NULL; 930 int needtofreename = 0; 931 struct symbol *returnval; 932 933 modified_name = name; 934 935 /* If we are using C++ language, demangle the name before doing a lookup, so 936 we can always binary search. */ 937 if (current_language->la_language == language_cplus) 938 { 939 demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS); 940 if (demangled_name) 941 { 942 mangled_name = name; 943 modified_name = demangled_name; 944 needtofreename = 1; 945 } 946 } 947 948 if (case_sensitivity == case_sensitive_off) 949 { 950 char *copy; 951 int len, i; 952 953 len = strlen (name); 954 copy = (char *) alloca (len + 1); 955 for (i= 0; i < len; i++) 956 copy[i] = tolower (name[i]); 957 copy[len] = 0; 958 modified_name = copy; 959 } 960 961 returnval = lookup_symbol_aux (modified_name, mangled_name, block, 962 domain, is_a_field_of_this, symtab); 963 if (needtofreename) 964 xfree (demangled_name); 965 966 return returnval; 967} 968 969/* Behave like lookup_symbol_aux except that NAME is the natural name 970 of the symbol that we're looking for and, if LINKAGE_NAME is 971 non-NULL, ensure that the symbol's linkage name matches as 972 well. */ 973 974static struct symbol * 975lookup_symbol_aux (const char *name, const char *linkage_name, 976 const struct block *block, const domain_enum domain, 977 int *is_a_field_of_this, struct symtab **symtab) 978{ 979 struct symbol *sym; 980 981 /* Make sure we do something sensible with is_a_field_of_this, since 982 the callers that set this parameter to some non-null value will 983 certainly use it later and expect it to be either 0 or 1. 984 If we don't set it, the contents of is_a_field_of_this are 985 undefined. */ 986 if (is_a_field_of_this != NULL) 987 *is_a_field_of_this = 0; 988 989 /* Search specified block and its superiors. Don't search 990 STATIC_BLOCK or GLOBAL_BLOCK. */ 991 992 sym = lookup_symbol_aux_local (name, linkage_name, block, domain, 993 symtab); 994 if (sym != NULL) 995 return sym; 996 997 /* If requested to do so by the caller and if appropriate for the 998 current language, check to see if NAME is a field of `this'. */ 999 1000 if (current_language->la_value_of_this != NULL 1001 && is_a_field_of_this != NULL) 1002 { 1003 struct value *v = current_language->la_value_of_this (0); 1004 1005 if (v && check_field (v, name)) 1006 { 1007 *is_a_field_of_this = 1; 1008 if (symtab != NULL) 1009 *symtab = NULL; 1010 return NULL; 1011 } 1012 } 1013 1014 /* Now do whatever is appropriate for the current language to look 1015 up static and global variables. */ 1016 1017 sym = current_language->la_lookup_symbol_nonlocal (name, linkage_name, 1018 block, domain, 1019 symtab); 1020 if (sym != NULL) 1021 return sym; 1022 1023 /* Now search all static file-level symbols. Not strictly correct, 1024 but more useful than an error. Do the symtabs first, then check 1025 the psymtabs. If a psymtab indicates the existence of the 1026 desired name as a file-level static, then do psymtab-to-symtab 1027 conversion on the fly and return the found symbol. */ 1028 1029 sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, linkage_name, 1030 domain, symtab); 1031 if (sym != NULL) 1032 return sym; 1033 1034 sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, linkage_name, 1035 domain, symtab); 1036 if (sym != NULL) 1037 return sym; 1038 1039 if (symtab != NULL) 1040 *symtab = NULL; 1041 return NULL; 1042} 1043 1044/* Check to see if the symbol is defined in BLOCK or its superiors. 1045 Don't search STATIC_BLOCK or GLOBAL_BLOCK. */ 1046 1047static struct symbol * 1048lookup_symbol_aux_local (const char *name, const char *linkage_name, 1049 const struct block *block, 1050 const domain_enum domain, 1051 struct symtab **symtab) 1052{ 1053 struct symbol *sym; 1054 const struct block *static_block = block_static_block (block); 1055 1056 /* Check if either no block is specified or it's a global block. */ 1057 1058 if (static_block == NULL) 1059 return NULL; 1060 1061 while (block != static_block) 1062 { 1063 sym = lookup_symbol_aux_block (name, linkage_name, block, domain, 1064 symtab); 1065 if (sym != NULL) 1066 return sym; 1067 block = BLOCK_SUPERBLOCK (block); 1068 } 1069 1070 /* We've reached the static block without finding a result. */ 1071 1072 return NULL; 1073} 1074 1075/* Look up a symbol in a block; if found, locate its symtab, fixup the 1076 symbol, and set block_found appropriately. */ 1077 1078struct symbol * 1079lookup_symbol_aux_block (const char *name, const char *linkage_name, 1080 const struct block *block, 1081 const domain_enum domain, 1082 struct symtab **symtab) 1083{ 1084 struct symbol *sym; 1085 struct objfile *objfile = NULL; 1086 struct blockvector *bv; 1087 struct block *b; 1088 struct symtab *s = NULL; 1089 1090 sym = lookup_block_symbol (block, name, linkage_name, domain); 1091 if (sym) 1092 { 1093 block_found = block; 1094 if (symtab != NULL) 1095 { 1096 /* Search the list of symtabs for one which contains the 1097 address of the start of this block. */ 1098 ALL_SYMTABS (objfile, s) 1099 { 1100 bv = BLOCKVECTOR (s); 1101 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1102 if (BLOCK_START (b) <= BLOCK_START (block) 1103 && BLOCK_END (b) > BLOCK_START (block)) 1104 goto found; 1105 } 1106 found: 1107 *symtab = s; 1108 } 1109 1110 return fixup_symbol_section (sym, objfile); 1111 } 1112 1113 return NULL; 1114} 1115 1116/* Check to see if the symbol is defined in one of the symtabs. 1117 BLOCK_INDEX should be either GLOBAL_BLOCK or STATIC_BLOCK, 1118 depending on whether or not we want to search global symbols or 1119 static symbols. */ 1120 1121static struct symbol * 1122lookup_symbol_aux_symtabs (int block_index, 1123 const char *name, const char *linkage_name, 1124 const domain_enum domain, 1125 struct symtab **symtab) 1126{ 1127 struct symbol *sym; 1128 struct objfile *objfile; 1129 struct blockvector *bv; 1130 const struct block *block; 1131 struct symtab *s; 1132 1133 ALL_SYMTABS (objfile, s) 1134 { 1135 bv = BLOCKVECTOR (s); 1136 block = BLOCKVECTOR_BLOCK (bv, block_index); 1137 sym = lookup_block_symbol (block, name, linkage_name, domain); 1138 if (sym) 1139 { 1140 block_found = block; 1141 if (symtab != NULL) 1142 *symtab = s; 1143 return fixup_symbol_section (sym, objfile); 1144 } 1145 } 1146 1147 return NULL; 1148} 1149 1150/* Check to see if the symbol is defined in one of the partial 1151 symtabs. BLOCK_INDEX should be either GLOBAL_BLOCK or 1152 STATIC_BLOCK, depending on whether or not we want to search global 1153 symbols or static symbols. */ 1154 1155static struct symbol * 1156lookup_symbol_aux_psymtabs (int block_index, const char *name, 1157 const char *linkage_name, 1158 const domain_enum domain, 1159 struct symtab **symtab) 1160{ 1161 struct symbol *sym; 1162 struct objfile *objfile; 1163 struct blockvector *bv; 1164 const struct block *block; 1165 struct partial_symtab *ps; 1166 struct symtab *s; 1167 const int psymtab_index = (block_index == GLOBAL_BLOCK ? 1 : 0); 1168 1169 ALL_PSYMTABS (objfile, ps) 1170 { 1171 if (!ps->readin 1172 && lookup_partial_symbol (ps, name, linkage_name, 1173 psymtab_index, domain)) 1174 { 1175 s = PSYMTAB_TO_SYMTAB (ps); 1176 bv = BLOCKVECTOR (s); 1177 block = BLOCKVECTOR_BLOCK (bv, block_index); 1178 sym = lookup_block_symbol (block, name, linkage_name, domain); 1179 if (!sym) 1180 { 1181 /* This shouldn't be necessary, but as a last resort try 1182 looking in the statics even though the psymtab claimed 1183 the symbol was global, or vice-versa. It's possible 1184 that the psymtab gets it wrong in some cases. */ 1185 1186 /* FIXME: carlton/2002-09-30: Should we really do that? 1187 If that happens, isn't it likely to be a GDB error, in 1188 which case we should fix the GDB error rather than 1189 silently dealing with it here? So I'd vote for 1190 removing the check for the symbol in the other 1191 block. */ 1192 block = BLOCKVECTOR_BLOCK (bv, 1193 block_index == GLOBAL_BLOCK ? 1194 STATIC_BLOCK : GLOBAL_BLOCK); 1195 sym = lookup_block_symbol (block, name, linkage_name, domain); 1196 if (!sym) 1197 error ("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>).", 1198 block_index == GLOBAL_BLOCK ? "global" : "static", 1199 name, ps->filename, name, name); 1200 } 1201 if (symtab != NULL) 1202 *symtab = s; 1203 return fixup_symbol_section (sym, objfile); 1204 } 1205 } 1206 1207 return NULL; 1208} 1209 1210#if 0 1211/* Check for the possibility of the symbol being a function or a 1212 mangled variable that is stored in one of the minimal symbol 1213 tables. Eventually, all global symbols might be resolved in this 1214 way. */ 1215 1216/* NOTE: carlton/2002-12-05: At one point, this function was part of 1217 lookup_symbol_aux, and what are now 'return' statements within 1218 lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if 1219 sym was NULL. As far as I can tell, this was basically accidental; 1220 it didn't happen every time that msymbol was non-NULL, but only if 1221 some additional conditions held as well, and it caused problems 1222 with HP-generated symbol tables. */ 1223 1224/* NOTE: carlton/2003-05-14: This function was once used as part of 1225 lookup_symbol. It is currently unnecessary for correctness 1226 reasons, however, and using it doesn't seem to be any faster than 1227 using lookup_symbol_aux_psymtabs, so I'm commenting it out. */ 1228 1229static struct symbol * 1230lookup_symbol_aux_minsyms (const char *name, 1231 const char *linkage_name, 1232 const domain_enum domain, 1233 int *is_a_field_of_this, 1234 struct symtab **symtab) 1235{ 1236 struct symbol *sym; 1237 struct blockvector *bv; 1238 const struct block *block; 1239 struct minimal_symbol *msymbol; 1240 struct symtab *s; 1241 1242 if (domain == VAR_DOMAIN) 1243 { 1244 msymbol = lookup_minimal_symbol (name, NULL, NULL); 1245 1246 if (msymbol != NULL) 1247 { 1248 /* OK, we found a minimal symbol in spite of not finding any 1249 symbol. There are various possible explanations for 1250 this. One possibility is the symbol exists in code not 1251 compiled -g. Another possibility is that the 'psymtab' 1252 isn't doing its job. A third possibility, related to #2, 1253 is that we were confused by name-mangling. For instance, 1254 maybe the psymtab isn't doing its job because it only 1255 know about demangled names, but we were given a mangled 1256 name... */ 1257 1258 /* We first use the address in the msymbol to try to locate 1259 the appropriate symtab. Note that find_pc_sect_symtab() 1260 has a side-effect of doing psymtab-to-symtab expansion, 1261 for the found symtab. */ 1262 s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol), 1263 SYMBOL_BFD_SECTION (msymbol)); 1264 if (s != NULL) 1265 { 1266 /* This is a function which has a symtab for its address. */ 1267 bv = BLOCKVECTOR (s); 1268 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1269 1270 /* This call used to pass `SYMBOL_LINKAGE_NAME (msymbol)' as the 1271 `name' argument to lookup_block_symbol. But the name 1272 of a minimal symbol is always mangled, so that seems 1273 to be clearly the wrong thing to pass as the 1274 unmangled name. */ 1275 sym = 1276 lookup_block_symbol (block, name, linkage_name, domain); 1277 /* We kept static functions in minimal symbol table as well as 1278 in static scope. We want to find them in the symbol table. */ 1279 if (!sym) 1280 { 1281 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); 1282 sym = lookup_block_symbol (block, name, 1283 linkage_name, domain); 1284 } 1285 1286 /* NOTE: carlton/2002-12-04: The following comment was 1287 taken from a time when two versions of this function 1288 were part of the body of lookup_symbol_aux: this 1289 comment was taken from the version of the function 1290 that was #ifdef HPUXHPPA, and the comment was right 1291 before the 'return NULL' part of lookup_symbol_aux. 1292 (Hence the "Fall through and return 0" comment.) 1293 Elena did some digging into the situation for 1294 Fortran, and she reports: 1295 1296 "I asked around (thanks to Jeff Knaggs), and I think 1297 the story for Fortran goes like this: 1298 1299 "Apparently, in older Fortrans, '_' was not part of 1300 the user namespace. g77 attached a final '_' to 1301 procedure names as the exported symbols for linkage 1302 (foo_) , but the symbols went in the debug info just 1303 like 'foo'. The rationale behind this is not 1304 completely clear, and maybe it was done to other 1305 symbols as well, not just procedures." */ 1306 1307 /* If we get here with sym == 0, the symbol was 1308 found in the minimal symbol table 1309 but not in the symtab. 1310 Fall through and return 0 to use the msymbol 1311 definition of "foo_". 1312 (Note that outer code generally follows up a call 1313 to this routine with a call to lookup_minimal_symbol(), 1314 so a 0 return means we'll just flow into that other routine). 1315 1316 This happens for Fortran "foo_" symbols, 1317 which are "foo" in the symtab. 1318 1319 This can also happen if "asm" is used to make a 1320 regular symbol but not a debugging symbol, e.g. 1321 asm(".globl _main"); 1322 asm("_main:"); 1323 */ 1324 1325 if (symtab != NULL && sym != NULL) 1326 *symtab = s; 1327 return fixup_symbol_section (sym, s->objfile); 1328 } 1329 } 1330 } 1331 1332 return NULL; 1333} 1334#endif /* 0 */ 1335 1336/* A default version of lookup_symbol_nonlocal for use by languages 1337 that can't think of anything better to do. This implements the C 1338 lookup rules. */ 1339 1340struct symbol * 1341basic_lookup_symbol_nonlocal (const char *name, 1342 const char *linkage_name, 1343 const struct block *block, 1344 const domain_enum domain, 1345 struct symtab **symtab) 1346{ 1347 struct symbol *sym; 1348 1349 /* NOTE: carlton/2003-05-19: The comments below were written when 1350 this (or what turned into this) was part of lookup_symbol_aux; 1351 I'm much less worried about these questions now, since these 1352 decisions have turned out well, but I leave these comments here 1353 for posterity. */ 1354 1355 /* NOTE: carlton/2002-12-05: There is a question as to whether or 1356 not it would be appropriate to search the current global block 1357 here as well. (That's what this code used to do before the 1358 is_a_field_of_this check was moved up.) On the one hand, it's 1359 redundant with the lookup_symbol_aux_symtabs search that happens 1360 next. On the other hand, if decode_line_1 is passed an argument 1361 like filename:var, then the user presumably wants 'var' to be 1362 searched for in filename. On the third hand, there shouldn't be 1363 multiple global variables all of which are named 'var', and it's 1364 not like decode_line_1 has ever restricted its search to only 1365 global variables in a single filename. All in all, only 1366 searching the static block here seems best: it's correct and it's 1367 cleanest. */ 1368 1369 /* NOTE: carlton/2002-12-05: There's also a possible performance 1370 issue here: if you usually search for global symbols in the 1371 current file, then it would be slightly better to search the 1372 current global block before searching all the symtabs. But there 1373 are other factors that have a much greater effect on performance 1374 than that one, so I don't think we should worry about that for 1375 now. */ 1376 1377 sym = lookup_symbol_static (name, linkage_name, block, domain, symtab); 1378 if (sym != NULL) 1379 return sym; 1380 1381 return lookup_symbol_global (name, linkage_name, domain, symtab); 1382} 1383 1384/* Lookup a symbol in the static block associated to BLOCK, if there 1385 is one; do nothing if BLOCK is NULL or a global block. */ 1386 1387struct symbol * 1388lookup_symbol_static (const char *name, 1389 const char *linkage_name, 1390 const struct block *block, 1391 const domain_enum domain, 1392 struct symtab **symtab) 1393{ 1394 const struct block *static_block = block_static_block (block); 1395 1396 if (static_block != NULL) 1397 return lookup_symbol_aux_block (name, linkage_name, static_block, 1398 domain, symtab); 1399 else 1400 return NULL; 1401} 1402 1403/* Lookup a symbol in all files' global blocks (searching psymtabs if 1404 necessary). */ 1405 1406struct symbol * 1407lookup_symbol_global (const char *name, 1408 const char *linkage_name, 1409 const domain_enum domain, 1410 struct symtab **symtab) 1411{ 1412 struct symbol *sym; 1413 1414 sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, linkage_name, 1415 domain, symtab); 1416 if (sym != NULL) 1417 return sym; 1418 1419 return lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, linkage_name, 1420 domain, symtab); 1421} 1422 1423/* Look, in partial_symtab PST, for symbol whose natural name is NAME. 1424 If LINKAGE_NAME is non-NULL, check in addition that the symbol's 1425 linkage name matches it. Check the global symbols if GLOBAL, the 1426 static symbols if not */ 1427 1428struct partial_symbol * 1429lookup_partial_symbol (struct partial_symtab *pst, const char *name, 1430 const char *linkage_name, int global, 1431 domain_enum domain) 1432{ 1433 struct partial_symbol *temp; 1434 struct partial_symbol **start, **psym; 1435 struct partial_symbol **top, **real_top, **bottom, **center; 1436 int length = (global ? pst->n_global_syms : pst->n_static_syms); 1437 int do_linear_search = 1; 1438 1439 if (length == 0) 1440 { 1441 return (NULL); 1442 } 1443 start = (global ? 1444 pst->objfile->global_psymbols.list + pst->globals_offset : 1445 pst->objfile->static_psymbols.list + pst->statics_offset); 1446 1447 if (global) /* This means we can use a binary search. */ 1448 { 1449 do_linear_search = 0; 1450 1451 /* Binary search. This search is guaranteed to end with center 1452 pointing at the earliest partial symbol whose name might be 1453 correct. At that point *all* partial symbols with an 1454 appropriate name will be checked against the correct 1455 domain. */ 1456 1457 bottom = start; 1458 top = start + length - 1; 1459 real_top = top; 1460 while (top > bottom) 1461 { 1462 center = bottom + (top - bottom) / 2; 1463 if (!(center < top)) 1464 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 1465 if (!do_linear_search 1466 && (SYMBOL_LANGUAGE (*center) == language_java)) 1467 { 1468 do_linear_search = 1; 1469 } 1470 if (strcmp_iw_ordered (SYMBOL_NATURAL_NAME (*center), name) >= 0) 1471 { 1472 top = center; 1473 } 1474 else 1475 { 1476 bottom = center + 1; 1477 } 1478 } 1479 if (!(top == bottom)) 1480 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 1481 1482 while (top <= real_top 1483 && (linkage_name != NULL 1484 ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0 1485 : SYMBOL_MATCHES_NATURAL_NAME (*top,name))) 1486 { 1487 if (SYMBOL_DOMAIN (*top) == domain) 1488 { 1489 return (*top); 1490 } 1491 top++; 1492 } 1493 } 1494 1495 /* Can't use a binary search or else we found during the binary search that 1496 we should also do a linear search. */ 1497 1498 if (do_linear_search) 1499 { 1500 for (psym = start; psym < start + length; psym++) 1501 { 1502 if (domain == SYMBOL_DOMAIN (*psym)) 1503 { 1504 if (linkage_name != NULL 1505 ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0 1506 : SYMBOL_MATCHES_NATURAL_NAME (*psym, name)) 1507 { 1508 return (*psym); 1509 } 1510 } 1511 } 1512 } 1513 1514 return (NULL); 1515} 1516 1517/* Look up a type named NAME in the struct_domain. The type returned 1518 must not be opaque -- i.e., must have at least one field 1519 defined. */ 1520 1521struct type * 1522lookup_transparent_type (const char *name) 1523{ 1524 return current_language->la_lookup_transparent_type (name); 1525} 1526 1527/* The standard implementation of lookup_transparent_type. This code 1528 was modeled on lookup_symbol -- the parts not relevant to looking 1529 up types were just left out. In particular it's assumed here that 1530 types are available in struct_domain and only at file-static or 1531 global blocks. */ 1532 1533struct type * 1534basic_lookup_transparent_type (const char *name) 1535{ 1536 struct symbol *sym; 1537 struct symtab *s = NULL; 1538 struct partial_symtab *ps; 1539 struct blockvector *bv; 1540 struct objfile *objfile; 1541 struct block *block; 1542 1543 /* Now search all the global symbols. Do the symtab's first, then 1544 check the psymtab's. If a psymtab indicates the existence 1545 of the desired name as a global, then do psymtab-to-symtab 1546 conversion on the fly and return the found symbol. */ 1547 1548 ALL_SYMTABS (objfile, s) 1549 { 1550 bv = BLOCKVECTOR (s); 1551 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1552 sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); 1553 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) 1554 { 1555 return SYMBOL_TYPE (sym); 1556 } 1557 } 1558 1559 ALL_PSYMTABS (objfile, ps) 1560 { 1561 if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 1562 1, STRUCT_DOMAIN)) 1563 { 1564 s = PSYMTAB_TO_SYMTAB (ps); 1565 bv = BLOCKVECTOR (s); 1566 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1567 sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); 1568 if (!sym) 1569 { 1570 /* This shouldn't be necessary, but as a last resort 1571 * try looking in the statics even though the psymtab 1572 * claimed the symbol was global. It's possible that 1573 * the psymtab gets it wrong in some cases. 1574 */ 1575 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); 1576 sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); 1577 if (!sym) 1578 error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\ 1579%s may be an inlined function, or may be a template function\n\ 1580(if a template, try specifying an instantiation: %s<type>).", 1581 name, ps->filename, name, name); 1582 } 1583 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) 1584 return SYMBOL_TYPE (sym); 1585 } 1586 } 1587 1588 /* Now search the static file-level symbols. 1589 Not strictly correct, but more useful than an error. 1590 Do the symtab's first, then 1591 check the psymtab's. If a psymtab indicates the existence 1592 of the desired name as a file-level static, then do psymtab-to-symtab 1593 conversion on the fly and return the found symbol. 1594 */ 1595 1596 ALL_SYMTABS (objfile, s) 1597 { 1598 bv = BLOCKVECTOR (s); 1599 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); 1600 sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); 1601 if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) 1602 { 1603 return SYMBOL_TYPE (sym); 1604 } 1605 } 1606 1607 ALL_PSYMTABS (objfile, ps) 1608 { 1609 if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_DOMAIN)) 1610 { 1611 s = PSYMTAB_TO_SYMTAB (ps); 1612 bv = BLOCKVECTOR (s); 1613 block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); 1614 sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); 1615 if (!sym) 1616 { 1617 /* This shouldn't be necessary, but as a last resort 1618 * try looking in the globals even though the psymtab 1619 * claimed the symbol was static. It's possible that 1620 * the psymtab gets it wrong in some cases. 1621 */ 1622 block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1623 sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN); 1624 if (!sym) 1625 error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\ 1626%s may be an inlined function, or may be a template function\n\ 1627(if a template, try specifying an instantiation: %s<type>).", 1628 name, ps->filename, name, name); 1629 } 1630 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym))) 1631 return SYMBOL_TYPE (sym); 1632 } 1633 } 1634 return (struct type *) 0; 1635} 1636 1637 1638/* Find the psymtab containing main(). */ 1639/* FIXME: What about languages without main() or specially linked 1640 executables that have no main() ? */ 1641 1642struct partial_symtab * 1643find_main_psymtab (void) 1644{ 1645 struct partial_symtab *pst; 1646 struct objfile *objfile; 1647 1648 ALL_PSYMTABS (objfile, pst) 1649 { 1650 if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_DOMAIN)) 1651 { 1652 return (pst); 1653 } 1654 } 1655 return (NULL); 1656} 1657 1658/* Search BLOCK for symbol NAME in DOMAIN. 1659 1660 Note that if NAME is the demangled form of a C++ symbol, we will fail 1661 to find a match during the binary search of the non-encoded names, but 1662 for now we don't worry about the slight inefficiency of looking for 1663 a match we'll never find, since it will go pretty quick. Once the 1664 binary search terminates, we drop through and do a straight linear 1665 search on the symbols. Each symbol which is marked as being a ObjC/C++ 1666 symbol (language_cplus or language_objc set) has both the encoded and 1667 non-encoded names tested for a match. 1668 1669 If LINKAGE_NAME is non-NULL, verify that any symbol we find has this 1670 particular mangled name. 1671*/ 1672 1673struct symbol * 1674lookup_block_symbol (const struct block *block, const char *name, 1675 const char *linkage_name, 1676 const domain_enum domain) 1677{ 1678 struct dict_iterator iter; 1679 struct symbol *sym; 1680 1681 if (!BLOCK_FUNCTION (block)) 1682 { 1683 for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); 1684 sym != NULL; 1685 sym = dict_iter_name_next (name, &iter)) 1686 { 1687 if (SYMBOL_DOMAIN (sym) == domain 1688 && (linkage_name != NULL 1689 ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1)) 1690 return sym; 1691 } 1692 return NULL; 1693 } 1694 else 1695 { 1696 /* Note that parameter symbols do not always show up last in the 1697 list; this loop makes sure to take anything else other than 1698 parameter symbols first; it only uses parameter symbols as a 1699 last resort. Note that this only takes up extra computation 1700 time on a match. */ 1701 1702 struct symbol *sym_found = NULL; 1703 1704 for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); 1705 sym != NULL; 1706 sym = dict_iter_name_next (name, &iter)) 1707 { 1708 if (SYMBOL_DOMAIN (sym) == domain 1709 && (linkage_name != NULL 1710 ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1)) 1711 { 1712 sym_found = sym; 1713 if (SYMBOL_CLASS (sym) != LOC_ARG && 1714 SYMBOL_CLASS (sym) != LOC_LOCAL_ARG && 1715 SYMBOL_CLASS (sym) != LOC_REF_ARG && 1716 SYMBOL_CLASS (sym) != LOC_REGPARM && 1717 SYMBOL_CLASS (sym) != LOC_REGPARM_ADDR && 1718 SYMBOL_CLASS (sym) != LOC_BASEREG_ARG && 1719 SYMBOL_CLASS (sym) != LOC_COMPUTED_ARG) 1720 { 1721 break; 1722 } 1723 } 1724 } 1725 return (sym_found); /* Will be NULL if not found. */ 1726 } 1727} 1728 1729/* Find the symtab associated with PC and SECTION. Look through the 1730 psymtabs and read in another symtab if necessary. */ 1731 1732struct symtab * 1733find_pc_sect_symtab (CORE_ADDR pc, asection *section) 1734{ 1735 struct block *b; 1736 struct blockvector *bv; 1737 struct symtab *s = NULL; 1738 struct symtab *best_s = NULL; 1739 struct partial_symtab *ps; 1740 struct objfile *objfile; 1741 CORE_ADDR distance = 0; 1742 struct minimal_symbol *msymbol; 1743 1744 /* If we know that this is not a text address, return failure. This is 1745 necessary because we loop based on the block's high and low code 1746 addresses, which do not include the data ranges, and because 1747 we call find_pc_sect_psymtab which has a similar restriction based 1748 on the partial_symtab's texthigh and textlow. */ 1749 msymbol = lookup_minimal_symbol_by_pc_section (pc, section); 1750 if (msymbol 1751 && (msymbol->type == mst_data 1752 || msymbol->type == mst_bss 1753 || msymbol->type == mst_abs 1754 || msymbol->type == mst_file_data 1755 || msymbol->type == mst_file_bss)) 1756 return NULL; 1757 1758 /* Search all symtabs for the one whose file contains our address, and which 1759 is the smallest of all the ones containing the address. This is designed 1760 to deal with a case like symtab a is at 0x1000-0x2000 and 0x3000-0x4000 1761 and symtab b is at 0x2000-0x3000. So the GLOBAL_BLOCK for a is from 1762 0x1000-0x4000, but for address 0x2345 we want to return symtab b. 1763 1764 This happens for native ecoff format, where code from included files 1765 gets its own symtab. The symtab for the included file should have 1766 been read in already via the dependency mechanism. 1767 It might be swifter to create several symtabs with the same name 1768 like xcoff does (I'm not sure). 1769 1770 It also happens for objfiles that have their functions reordered. 1771 For these, the symtab we are looking for is not necessarily read in. */ 1772 1773 ALL_SYMTABS (objfile, s) 1774 { 1775 bv = BLOCKVECTOR (s); 1776 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 1777 1778 if (BLOCK_START (b) <= pc 1779 && BLOCK_END (b) > pc 1780 && (distance == 0 1781 || BLOCK_END (b) - BLOCK_START (b) < distance)) 1782 { 1783 /* For an objfile that has its functions reordered, 1784 find_pc_psymtab will find the proper partial symbol table 1785 and we simply return its corresponding symtab. */ 1786 /* In order to better support objfiles that contain both 1787 stabs and coff debugging info, we continue on if a psymtab 1788 can't be found. */ 1789 if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs) 1790 { 1791 ps = find_pc_sect_psymtab (pc, section); 1792 if (ps) 1793 return PSYMTAB_TO_SYMTAB (ps); 1794 } 1795 if (section != 0) 1796 { 1797 struct dict_iterator iter; 1798 struct symbol *sym = NULL; 1799 1800 ALL_BLOCK_SYMBOLS (b, iter, sym) 1801 { 1802 fixup_symbol_section (sym, objfile); 1803 if (section == SYMBOL_BFD_SECTION (sym)) 1804 break; 1805 } 1806 if (sym == NULL) 1807 continue; /* no symbol in this symtab matches section */ 1808 } 1809 distance = BLOCK_END (b) - BLOCK_START (b); 1810 best_s = s; 1811 } 1812 } 1813 1814 if (best_s != NULL) 1815 return (best_s); 1816 1817 s = NULL; 1818 ps = find_pc_sect_psymtab (pc, section); 1819 if (ps) 1820 { 1821 if (ps->readin) 1822 /* Might want to error() here (in case symtab is corrupt and 1823 will cause a core dump), but maybe we can successfully 1824 continue, so let's not. */ 1825 warning ("\ 1826(Internal error: pc 0x%s in read in psymtab, but not in symtab.)\n", 1827 paddr_nz (pc)); 1828 s = PSYMTAB_TO_SYMTAB (ps); 1829 } 1830 return (s); 1831} 1832 1833/* Find the symtab associated with PC. Look through the psymtabs and 1834 read in another symtab if necessary. Backward compatibility, no section */ 1835 1836struct symtab * 1837find_pc_symtab (CORE_ADDR pc) 1838{ 1839 return find_pc_sect_symtab (pc, find_pc_mapped_section (pc)); 1840} 1841 1842 1843/* Find the source file and line number for a given PC value and SECTION. 1844 Return a structure containing a symtab pointer, a line number, 1845 and a pc range for the entire source line. 1846 The value's .pc field is NOT the specified pc. 1847 NOTCURRENT nonzero means, if specified pc is on a line boundary, 1848 use the line that ends there. Otherwise, in that case, the line 1849 that begins there is used. */ 1850 1851/* The big complication here is that a line may start in one file, and end just 1852 before the start of another file. This usually occurs when you #include 1853 code in the middle of a subroutine. To properly find the end of a line's PC 1854 range, we must search all symtabs associated with this compilation unit, and 1855 find the one whose first PC is closer than that of the next line in this 1856 symtab. */ 1857 1858/* If it's worth the effort, we could be using a binary search. */ 1859 1860struct symtab_and_line 1861find_pc_sect_line (CORE_ADDR pc, struct bfd_section *section, int notcurrent) 1862{ 1863 struct symtab *s; 1864 struct linetable *l; 1865 int len; 1866 int i; 1867 struct linetable_entry *item; 1868 struct symtab_and_line val; 1869 struct blockvector *bv; 1870 struct minimal_symbol *msymbol; 1871 struct minimal_symbol *mfunsym; 1872 1873 /* Info on best line seen so far, and where it starts, and its file. */ 1874 1875 struct linetable_entry *best = NULL; 1876 CORE_ADDR best_end = 0; 1877 struct symtab *best_symtab = 0; 1878 1879 /* Store here the first line number 1880 of a file which contains the line at the smallest pc after PC. 1881 If we don't find a line whose range contains PC, 1882 we will use a line one less than this, 1883 with a range from the start of that file to the first line's pc. */ 1884 struct linetable_entry *alt = NULL; 1885 struct symtab *alt_symtab = 0; 1886 1887 /* Info on best line seen in this file. */ 1888 1889 struct linetable_entry *prev; 1890 1891 /* If this pc is not from the current frame, 1892 it is the address of the end of a call instruction. 1893 Quite likely that is the start of the following statement. 1894 But what we want is the statement containing the instruction. 1895 Fudge the pc to make sure we get that. */ 1896 1897 init_sal (&val); /* initialize to zeroes */ 1898 1899 /* It's tempting to assume that, if we can't find debugging info for 1900 any function enclosing PC, that we shouldn't search for line 1901 number info, either. However, GAS can emit line number info for 1902 assembly files --- very helpful when debugging hand-written 1903 assembly code. In such a case, we'd have no debug info for the 1904 function, but we would have line info. */ 1905 1906 if (notcurrent) 1907 pc -= 1; 1908 1909 /* elz: added this because this function returned the wrong 1910 information if the pc belongs to a stub (import/export) 1911 to call a shlib function. This stub would be anywhere between 1912 two functions in the target, and the line info was erroneously 1913 taken to be the one of the line before the pc. 1914 */ 1915 /* RT: Further explanation: 1916 1917 * We have stubs (trampolines) inserted between procedures. 1918 * 1919 * Example: "shr1" exists in a shared library, and a "shr1" stub also 1920 * exists in the main image. 1921 * 1922 * In the minimal symbol table, we have a bunch of symbols 1923 * sorted by start address. The stubs are marked as "trampoline", 1924 * the others appear as text. E.g.: 1925 * 1926 * Minimal symbol table for main image 1927 * main: code for main (text symbol) 1928 * shr1: stub (trampoline symbol) 1929 * foo: code for foo (text symbol) 1930 * ... 1931 * Minimal symbol table for "shr1" image: 1932 * ... 1933 * shr1: code for shr1 (text symbol) 1934 * ... 1935 * 1936 * So the code below is trying to detect if we are in the stub 1937 * ("shr1" stub), and if so, find the real code ("shr1" trampoline), 1938 * and if found, do the symbolization from the real-code address 1939 * rather than the stub address. 1940 * 1941 * Assumptions being made about the minimal symbol table: 1942 * 1. lookup_minimal_symbol_by_pc() will return a trampoline only 1943 * if we're really in the trampoline. If we're beyond it (say 1944 * we're in "foo" in the above example), it'll have a closer 1945 * symbol (the "foo" text symbol for example) and will not 1946 * return the trampoline. 1947 * 2. lookup_minimal_symbol_text() will find a real text symbol 1948 * corresponding to the trampoline, and whose address will 1949 * be different than the trampoline address. I put in a sanity 1950 * check for the address being the same, to avoid an 1951 * infinite recursion. 1952 */ 1953 msymbol = lookup_minimal_symbol_by_pc (pc); 1954 if (msymbol != NULL) 1955 if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline) 1956 { 1957 mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol), 1958 NULL); 1959 if (mfunsym == NULL) 1960 /* I eliminated this warning since it is coming out 1961 * in the following situation: 1962 * gdb shmain // test program with shared libraries 1963 * (gdb) break shr1 // function in shared lib 1964 * Warning: In stub for ... 1965 * In the above situation, the shared lib is not loaded yet, 1966 * so of course we can't find the real func/line info, 1967 * but the "break" still works, and the warning is annoying. 1968 * So I commented out the warning. RT */ 1969 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ; 1970 /* fall through */ 1971 else if (SYMBOL_VALUE (mfunsym) == SYMBOL_VALUE (msymbol)) 1972 /* Avoid infinite recursion */ 1973 /* See above comment about why warning is commented out */ 1974 /* warning ("In stub for %s; unable to find real function/line info", SYMBOL_LINKAGE_NAME (msymbol)) */ ; 1975 /* fall through */ 1976 else 1977 return find_pc_line (SYMBOL_VALUE (mfunsym), 0); 1978 } 1979 1980 1981 s = find_pc_sect_symtab (pc, section); 1982 if (!s) 1983 { 1984 /* if no symbol information, return previous pc */ 1985 if (notcurrent) 1986 pc++; 1987 val.pc = pc; 1988 return val; 1989 } 1990 1991 bv = BLOCKVECTOR (s); 1992 1993 /* Look at all the symtabs that share this blockvector. 1994 They all have the same apriori range, that we found was right; 1995 but they have different line tables. */ 1996 1997 for (; s && BLOCKVECTOR (s) == bv; s = s->next) 1998 { 1999 /* Find the best line in this symtab. */ 2000 l = LINETABLE (s); 2001 if (!l) 2002 continue; 2003 len = l->nitems; 2004 if (len <= 0) 2005 { 2006 /* I think len can be zero if the symtab lacks line numbers 2007 (e.g. gcc -g1). (Either that or the LINETABLE is NULL; 2008 I'm not sure which, and maybe it depends on the symbol 2009 reader). */ 2010 continue; 2011 } 2012 2013 prev = NULL; 2014 item = l->item; /* Get first line info */ 2015 2016 /* Is this file's first line closer than the first lines of other files? 2017 If so, record this file, and its first line, as best alternate. */ 2018 if (item->pc > pc && (!alt || item->pc < alt->pc)) 2019 { 2020 alt = item; 2021 alt_symtab = s; 2022 } 2023 2024 for (i = 0; i < len; i++, item++) 2025 { 2026 /* Leave prev pointing to the linetable entry for the last line 2027 that started at or before PC. */ 2028 if (item->pc > pc) 2029 break; 2030 2031 prev = item; 2032 } 2033 2034 /* At this point, prev points at the line whose start addr is <= pc, and 2035 item points at the next line. If we ran off the end of the linetable 2036 (pc >= start of the last line), then prev == item. If pc < start of 2037 the first line, prev will not be set. */ 2038 2039 /* Is this file's best line closer than the best in the other files? 2040 If so, record this file, and its best line, as best so far. Don't 2041 save prev if it represents the end of a function (i.e. line number 2042 0) instead of a real line. */ 2043 2044 if (prev && prev->line && (!best || prev->pc > best->pc)) 2045 { 2046 best = prev; 2047 best_symtab = s; 2048 2049 /* Discard BEST_END if it's before the PC of the current BEST. */ 2050 if (best_end <= best->pc) 2051 best_end = 0; 2052 } 2053 2054 /* If another line (denoted by ITEM) is in the linetable and its 2055 PC is after BEST's PC, but before the current BEST_END, then 2056 use ITEM's PC as the new best_end. */ 2057 if (best && i < len && item->pc > best->pc 2058 && (best_end == 0 || best_end > item->pc)) 2059 best_end = item->pc; 2060 } 2061 2062 if (!best_symtab) 2063 { 2064 if (!alt_symtab) 2065 { /* If we didn't find any line # info, just 2066 return zeros. */ 2067 val.pc = pc; 2068 } 2069 else 2070 { 2071 val.symtab = alt_symtab; 2072 val.line = alt->line - 1; 2073 2074 /* Don't return line 0, that means that we didn't find the line. */ 2075 if (val.line == 0) 2076 ++val.line; 2077 2078 val.pc = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); 2079 val.end = alt->pc; 2080 } 2081 } 2082 else if (best->line == 0) 2083 { 2084 /* If our best fit is in a range of PC's for which no line 2085 number info is available (line number is zero) then we didn't 2086 find any valid line information. */ 2087 val.pc = pc; 2088 } 2089 else 2090 { 2091 val.symtab = best_symtab; 2092 val.line = best->line; 2093 val.pc = best->pc; 2094 if (best_end && (!alt || best_end < alt->pc)) 2095 val.end = best_end; 2096 else if (alt) 2097 val.end = alt->pc; 2098 else 2099 val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); 2100 } 2101 val.section = section; 2102 return val; 2103} 2104 2105/* Backward compatibility (no section) */ 2106 2107struct symtab_and_line 2108find_pc_line (CORE_ADDR pc, int notcurrent) 2109{ 2110 asection *section; 2111 2112 section = find_pc_overlay (pc); 2113 if (pc_in_unmapped_range (pc, section)) 2114 pc = overlay_mapped_address (pc, section); 2115 return find_pc_sect_line (pc, section, notcurrent); 2116} 2117 2118/* Find line number LINE in any symtab whose name is the same as 2119 SYMTAB. 2120 2121 If found, return the symtab that contains the linetable in which it was 2122 found, set *INDEX to the index in the linetable of the best entry 2123 found, and set *EXACT_MATCH nonzero if the value returned is an 2124 exact match. 2125 2126 If not found, return NULL. */ 2127 2128struct symtab * 2129find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match) 2130{ 2131 int exact; 2132 2133 /* BEST_INDEX and BEST_LINETABLE identify the smallest linenumber > LINE 2134 so far seen. */ 2135 2136 int best_index; 2137 struct linetable *best_linetable; 2138 struct symtab *best_symtab; 2139 2140 /* First try looking it up in the given symtab. */ 2141 best_linetable = LINETABLE (symtab); 2142 best_symtab = symtab; 2143 best_index = find_line_common (best_linetable, line, &exact); 2144 if (best_index < 0 || !exact) 2145 { 2146 /* Didn't find an exact match. So we better keep looking for 2147 another symtab with the same name. In the case of xcoff, 2148 multiple csects for one source file (produced by IBM's FORTRAN 2149 compiler) produce multiple symtabs (this is unavoidable 2150 assuming csects can be at arbitrary places in memory and that 2151 the GLOBAL_BLOCK of a symtab has a begin and end address). */ 2152 2153 /* BEST is the smallest linenumber > LINE so far seen, 2154 or 0 if none has been seen so far. 2155 BEST_INDEX and BEST_LINETABLE identify the item for it. */ 2156 int best; 2157 2158 struct objfile *objfile; 2159 struct symtab *s; 2160 2161 if (best_index >= 0) 2162 best = best_linetable->item[best_index].line; 2163 else 2164 best = 0; 2165 2166 ALL_SYMTABS (objfile, s) 2167 { 2168 struct linetable *l; 2169 int ind; 2170 2171 if (strcmp (symtab->filename, s->filename) != 0) 2172 continue; 2173 l = LINETABLE (s); 2174 ind = find_line_common (l, line, &exact); 2175 if (ind >= 0) 2176 { 2177 if (exact) 2178 { 2179 best_index = ind; 2180 best_linetable = l; 2181 best_symtab = s; 2182 goto done; 2183 } 2184 if (best == 0 || l->item[ind].line < best) 2185 { 2186 best = l->item[ind].line; 2187 best_index = ind; 2188 best_linetable = l; 2189 best_symtab = s; 2190 } 2191 } 2192 } 2193 } 2194done: 2195 if (best_index < 0) 2196 return NULL; 2197 2198 if (index) 2199 *index = best_index; 2200 if (exact_match) 2201 *exact_match = exact; 2202 2203 return best_symtab; 2204} 2205 2206/* Set the PC value for a given source file and line number and return true. 2207 Returns zero for invalid line number (and sets the PC to 0). 2208 The source file is specified with a struct symtab. */ 2209 2210int 2211find_line_pc (struct symtab *symtab, int line, CORE_ADDR *pc) 2212{ 2213 struct linetable *l; 2214 int ind; 2215 2216 *pc = 0; 2217 if (symtab == 0) 2218 return 0; 2219 2220 symtab = find_line_symtab (symtab, line, &ind, NULL); 2221 if (symtab != NULL) 2222 { 2223 l = LINETABLE (symtab); 2224 *pc = l->item[ind].pc; 2225 return 1; 2226 } 2227 else 2228 return 0; 2229} 2230 2231/* Find the range of pc values in a line. 2232 Store the starting pc of the line into *STARTPTR 2233 and the ending pc (start of next line) into *ENDPTR. 2234 Returns 1 to indicate success. 2235 Returns 0 if could not find the specified line. */ 2236 2237int 2238find_line_pc_range (struct symtab_and_line sal, CORE_ADDR *startptr, 2239 CORE_ADDR *endptr) 2240{ 2241 CORE_ADDR startaddr; 2242 struct symtab_and_line found_sal; 2243 2244 startaddr = sal.pc; 2245 if (startaddr == 0 && !find_line_pc (sal.symtab, sal.line, &startaddr)) 2246 return 0; 2247 2248 /* This whole function is based on address. For example, if line 10 has 2249 two parts, one from 0x100 to 0x200 and one from 0x300 to 0x400, then 2250 "info line *0x123" should say the line goes from 0x100 to 0x200 2251 and "info line *0x355" should say the line goes from 0x300 to 0x400. 2252 This also insures that we never give a range like "starts at 0x134 2253 and ends at 0x12c". */ 2254 2255 found_sal = find_pc_sect_line (startaddr, sal.section, 0); 2256 if (found_sal.line != sal.line) 2257 { 2258 /* The specified line (sal) has zero bytes. */ 2259 *startptr = found_sal.pc; 2260 *endptr = found_sal.pc; 2261 } 2262 else 2263 { 2264 *startptr = found_sal.pc; 2265 *endptr = found_sal.end; 2266 } 2267 return 1; 2268} 2269 2270/* Given a line table and a line number, return the index into the line 2271 table for the pc of the nearest line whose number is >= the specified one. 2272 Return -1 if none is found. The value is >= 0 if it is an index. 2273 2274 Set *EXACT_MATCH nonzero if the value returned is an exact match. */ 2275 2276static int 2277find_line_common (struct linetable *l, int lineno, 2278 int *exact_match) 2279{ 2280 int i; 2281 int len; 2282 2283 /* BEST is the smallest linenumber > LINENO so far seen, 2284 or 0 if none has been seen so far. 2285 BEST_INDEX identifies the item for it. */ 2286 2287 int best_index = -1; 2288 int best = 0; 2289 2290 if (lineno <= 0) 2291 return -1; 2292 if (l == 0) 2293 return -1; 2294 2295 len = l->nitems; 2296 for (i = 0; i < len; i++) 2297 { 2298 struct linetable_entry *item = &(l->item[i]); 2299 2300 if (item->line == lineno) 2301 { 2302 /* Return the first (lowest address) entry which matches. */ 2303 *exact_match = 1; 2304 return i; 2305 } 2306 2307 if (item->line > lineno && (best == 0 || item->line < best)) 2308 { 2309 best = item->line; 2310 best_index = i; 2311 } 2312 } 2313 2314 /* If we got here, we didn't get an exact match. */ 2315 2316 *exact_match = 0; 2317 return best_index; 2318} 2319 2320int 2321find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr) 2322{ 2323 struct symtab_and_line sal; 2324 sal = find_pc_line (pc, 0); 2325 *startptr = sal.pc; 2326 *endptr = sal.end; 2327 return sal.symtab != 0; 2328} 2329 2330/* Given a function symbol SYM, find the symtab and line for the start 2331 of the function. 2332 If the argument FUNFIRSTLINE is nonzero, we want the first line 2333 of real code inside the function. */ 2334 2335struct symtab_and_line 2336find_function_start_sal (struct symbol *sym, int funfirstline) 2337{ 2338 CORE_ADDR pc; 2339 struct symtab_and_line sal; 2340 2341 pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); 2342 fixup_symbol_section (sym, NULL); 2343 if (funfirstline) 2344 { /* skip "first line" of function (which is actually its prologue) */ 2345 asection *section = SYMBOL_BFD_SECTION (sym); 2346 /* If function is in an unmapped overlay, use its unmapped LMA 2347 address, so that SKIP_PROLOGUE has something unique to work on */ 2348 if (section_is_overlay (section) && 2349 !section_is_mapped (section)) 2350 pc = overlay_unmapped_address (pc, section); 2351 2352 pc += FUNCTION_START_OFFSET; 2353 pc = SKIP_PROLOGUE (pc); 2354 2355 /* For overlays, map pc back into its mapped VMA range */ 2356 pc = overlay_mapped_address (pc, section); 2357 } 2358 sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0); 2359 2360 /* Check if SKIP_PROLOGUE left us in mid-line, and the next 2361 line is still part of the same function. */ 2362 if (sal.pc != pc 2363 && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= sal.end 2364 && sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym))) 2365 { 2366 /* First pc of next line */ 2367 pc = sal.end; 2368 /* Recalculate the line number (might not be N+1). */ 2369 sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0); 2370 } 2371 sal.pc = pc; 2372 2373 return sal; 2374} 2375 2376/* If P is of the form "operator[ \t]+..." where `...' is 2377 some legitimate operator text, return a pointer to the 2378 beginning of the substring of the operator text. 2379 Otherwise, return "". */ 2380char * 2381operator_chars (char *p, char **end) 2382{ 2383 *end = ""; 2384 if (strncmp (p, "operator", 8)) 2385 return *end; 2386 p += 8; 2387 2388 /* Don't get faked out by `operator' being part of a longer 2389 identifier. */ 2390 if (isalpha (*p) || *p == '_' || *p == '$' || *p == '\0') 2391 return *end; 2392 2393 /* Allow some whitespace between `operator' and the operator symbol. */ 2394 while (*p == ' ' || *p == '\t') 2395 p++; 2396 2397 /* Recognize 'operator TYPENAME'. */ 2398 2399 if (isalpha (*p) || *p == '_' || *p == '$') 2400 { 2401 char *q = p + 1; 2402 while (isalnum (*q) || *q == '_' || *q == '$') 2403 q++; 2404 *end = q; 2405 return p; 2406 } 2407 2408 while (*p) 2409 switch (*p) 2410 { 2411 case '\\': /* regexp quoting */ 2412 if (p[1] == '*') 2413 { 2414 if (p[2] == '=') /* 'operator\*=' */ 2415 *end = p + 3; 2416 else /* 'operator\*' */ 2417 *end = p + 2; 2418 return p; 2419 } 2420 else if (p[1] == '[') 2421 { 2422 if (p[2] == ']') 2423 error ("mismatched quoting on brackets, try 'operator\\[\\]'"); 2424 else if (p[2] == '\\' && p[3] == ']') 2425 { 2426 *end = p + 4; /* 'operator\[\]' */ 2427 return p; 2428 } 2429 else 2430 error ("nothing is allowed between '[' and ']'"); 2431 } 2432 else 2433 { 2434 /* Gratuitous qoute: skip it and move on. */ 2435 p++; 2436 continue; 2437 } 2438 break; 2439 case '!': 2440 case '=': 2441 case '*': 2442 case '/': 2443 case '%': 2444 case '^': 2445 if (p[1] == '=') 2446 *end = p + 2; 2447 else 2448 *end = p + 1; 2449 return p; 2450 case '<': 2451 case '>': 2452 case '+': 2453 case '-': 2454 case '&': 2455 case '|': 2456 if (p[0] == '-' && p[1] == '>') 2457 { 2458 /* Struct pointer member operator 'operator->'. */ 2459 if (p[2] == '*') 2460 { 2461 *end = p + 3; /* 'operator->*' */ 2462 return p; 2463 } 2464 else if (p[2] == '\\') 2465 { 2466 *end = p + 4; /* Hopefully 'operator->\*' */ 2467 return p; 2468 } 2469 else 2470 { 2471 *end = p + 2; /* 'operator->' */ 2472 return p; 2473 } 2474 } 2475 if (p[1] == '=' || p[1] == p[0]) 2476 *end = p + 2; 2477 else 2478 *end = p + 1; 2479 return p; 2480 case '~': 2481 case ',': 2482 *end = p + 1; 2483 return p; 2484 case '(': 2485 if (p[1] != ')') 2486 error ("`operator ()' must be specified without whitespace in `()'"); 2487 *end = p + 2; 2488 return p; 2489 case '?': 2490 if (p[1] != ':') 2491 error ("`operator ?:' must be specified without whitespace in `?:'"); 2492 *end = p + 2; 2493 return p; 2494 case '[': 2495 if (p[1] != ']') 2496 error ("`operator []' must be specified without whitespace in `[]'"); 2497 *end = p + 2; 2498 return p; 2499 default: 2500 error ("`operator %s' not supported", p); 2501 break; 2502 } 2503 2504 *end = ""; 2505 return *end; 2506} 2507 2508 2509/* If FILE is not already in the table of files, return zero; 2510 otherwise return non-zero. Optionally add FILE to the table if ADD 2511 is non-zero. If *FIRST is non-zero, forget the old table 2512 contents. */ 2513static int 2514filename_seen (const char *file, int add, int *first) 2515{ 2516 /* Table of files seen so far. */ 2517 static const char **tab = NULL; 2518 /* Allocated size of tab in elements. 2519 Start with one 256-byte block (when using GNU malloc.c). 2520 24 is the malloc overhead when range checking is in effect. */ 2521 static int tab_alloc_size = (256 - 24) / sizeof (char *); 2522 /* Current size of tab in elements. */ 2523 static int tab_cur_size; 2524 const char **p; 2525 2526 if (*first) 2527 { 2528 if (tab == NULL) 2529 tab = (const char **) xmalloc (tab_alloc_size * sizeof (*tab)); 2530 tab_cur_size = 0; 2531 } 2532 2533 /* Is FILE in tab? */ 2534 for (p = tab; p < tab + tab_cur_size; p++) 2535 if (strcmp (*p, file) == 0) 2536 return 1; 2537 2538 /* No; maybe add it to tab. */ 2539 if (add) 2540 { 2541 if (tab_cur_size == tab_alloc_size) 2542 { 2543 tab_alloc_size *= 2; 2544 tab = (const char **) xrealloc ((char *) tab, 2545 tab_alloc_size * sizeof (*tab)); 2546 } 2547 tab[tab_cur_size++] = file; 2548 } 2549 2550 return 0; 2551} 2552 2553/* Slave routine for sources_info. Force line breaks at ,'s. 2554 NAME is the name to print and *FIRST is nonzero if this is the first 2555 name printed. Set *FIRST to zero. */ 2556static void 2557output_source_filename (char *name, int *first) 2558{ 2559 /* Since a single source file can result in several partial symbol 2560 tables, we need to avoid printing it more than once. Note: if 2561 some of the psymtabs are read in and some are not, it gets 2562 printed both under "Source files for which symbols have been 2563 read" and "Source files for which symbols will be read in on 2564 demand". I consider this a reasonable way to deal with the 2565 situation. I'm not sure whether this can also happen for 2566 symtabs; it doesn't hurt to check. */ 2567 2568 /* Was NAME already seen? */ 2569 if (filename_seen (name, 1, first)) 2570 { 2571 /* Yes; don't print it again. */ 2572 return; 2573 } 2574 /* No; print it and reset *FIRST. */ 2575 if (*first) 2576 { 2577 *first = 0; 2578 } 2579 else 2580 { 2581 printf_filtered (", "); 2582 } 2583 2584 wrap_here (""); 2585 fputs_filtered (name, gdb_stdout); 2586} 2587 2588static void 2589sources_info (char *ignore, int from_tty) 2590{ 2591 struct symtab *s; 2592 struct partial_symtab *ps; 2593 struct objfile *objfile; 2594 int first; 2595 2596 if (!have_full_symbols () && !have_partial_symbols ()) 2597 { 2598 error ("No symbol table is loaded. Use the \"file\" command."); 2599 } 2600 2601 printf_filtered ("Source files for which symbols have been read in:\n\n"); 2602 2603 first = 1; 2604 ALL_SYMTABS (objfile, s) 2605 { 2606 output_source_filename (s->filename, &first); 2607 } 2608 printf_filtered ("\n\n"); 2609 2610 printf_filtered ("Source files for which symbols will be read in on demand:\n\n"); 2611 2612 first = 1; 2613 ALL_PSYMTABS (objfile, ps) 2614 { 2615 if (!ps->readin) 2616 { 2617 output_source_filename (ps->filename, &first); 2618 } 2619 } 2620 printf_filtered ("\n"); 2621} 2622 2623static int 2624file_matches (char *file, char *files[], int nfiles) 2625{ 2626 int i; 2627 2628 if (file != NULL && nfiles != 0) 2629 { 2630 for (i = 0; i < nfiles; i++) 2631 { 2632 if (strcmp (files[i], lbasename (file)) == 0) 2633 return 1; 2634 } 2635 } 2636 else if (nfiles == 0) 2637 return 1; 2638 return 0; 2639} 2640 2641/* Free any memory associated with a search. */ 2642void 2643free_search_symbols (struct symbol_search *symbols) 2644{ 2645 struct symbol_search *p; 2646 struct symbol_search *next; 2647 2648 for (p = symbols; p != NULL; p = next) 2649 { 2650 next = p->next; 2651 xfree (p); 2652 } 2653} 2654 2655static void 2656do_free_search_symbols_cleanup (void *symbols) 2657{ 2658 free_search_symbols (symbols); 2659} 2660 2661struct cleanup * 2662make_cleanup_free_search_symbols (struct symbol_search *symbols) 2663{ 2664 return make_cleanup (do_free_search_symbols_cleanup, symbols); 2665} 2666 2667/* Helper function for sort_search_symbols and qsort. Can only 2668 sort symbols, not minimal symbols. */ 2669static int 2670compare_search_syms (const void *sa, const void *sb) 2671{ 2672 struct symbol_search **sym_a = (struct symbol_search **) sa; 2673 struct symbol_search **sym_b = (struct symbol_search **) sb; 2674 2675 return strcmp (SYMBOL_PRINT_NAME ((*sym_a)->symbol), 2676 SYMBOL_PRINT_NAME ((*sym_b)->symbol)); 2677} 2678 2679/* Sort the ``nfound'' symbols in the list after prevtail. Leave 2680 prevtail where it is, but update its next pointer to point to 2681 the first of the sorted symbols. */ 2682static struct symbol_search * 2683sort_search_symbols (struct symbol_search *prevtail, int nfound) 2684{ 2685 struct symbol_search **symbols, *symp, *old_next; 2686 int i; 2687 2688 symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *) 2689 * nfound); 2690 symp = prevtail->next; 2691 for (i = 0; i < nfound; i++) 2692 { 2693 symbols[i] = symp; 2694 symp = symp->next; 2695 } 2696 /* Generally NULL. */ 2697 old_next = symp; 2698 2699 qsort (symbols, nfound, sizeof (struct symbol_search *), 2700 compare_search_syms); 2701 2702 symp = prevtail; 2703 for (i = 0; i < nfound; i++) 2704 { 2705 symp->next = symbols[i]; 2706 symp = symp->next; 2707 } 2708 symp->next = old_next; 2709 2710 xfree (symbols); 2711 return symp; 2712} 2713 2714/* Search the symbol table for matches to the regular expression REGEXP, 2715 returning the results in *MATCHES. 2716 2717 Only symbols of KIND are searched: 2718 FUNCTIONS_DOMAIN - search all functions 2719 TYPES_DOMAIN - search all type names 2720 METHODS_DOMAIN - search all methods NOT IMPLEMENTED 2721 VARIABLES_DOMAIN - search all symbols, excluding functions, type names, 2722 and constants (enums) 2723 2724 free_search_symbols should be called when *MATCHES is no longer needed. 2725 2726 The results are sorted locally; each symtab's global and static blocks are 2727 separately alphabetized. 2728 */ 2729void 2730search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[], 2731 struct symbol_search **matches) 2732{ 2733 struct symtab *s; 2734 struct partial_symtab *ps; 2735 struct blockvector *bv; 2736 struct blockvector *prev_bv = 0; 2737 struct block *b; 2738 int i = 0; 2739 struct dict_iterator iter; 2740 struct symbol *sym; 2741 struct partial_symbol **psym; 2742 struct objfile *objfile; 2743 struct minimal_symbol *msymbol; 2744 char *val; 2745 int found_misc = 0; 2746 static enum minimal_symbol_type types[] 2747 = 2748 {mst_data, mst_text, mst_abs, mst_unknown}; 2749 static enum minimal_symbol_type types2[] 2750 = 2751 {mst_bss, mst_file_text, mst_abs, mst_unknown}; 2752 static enum minimal_symbol_type types3[] 2753 = 2754 {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown}; 2755 static enum minimal_symbol_type types4[] 2756 = 2757 {mst_file_bss, mst_text, mst_abs, mst_unknown}; 2758 enum minimal_symbol_type ourtype; 2759 enum minimal_symbol_type ourtype2; 2760 enum minimal_symbol_type ourtype3; 2761 enum minimal_symbol_type ourtype4; 2762 struct symbol_search *sr; 2763 struct symbol_search *psr; 2764 struct symbol_search *tail; 2765 struct cleanup *old_chain = NULL; 2766 2767 if (kind < VARIABLES_DOMAIN) 2768 error ("must search on specific domain"); 2769 2770 ourtype = types[(int) (kind - VARIABLES_DOMAIN)]; 2771 ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)]; 2772 ourtype3 = types3[(int) (kind - VARIABLES_DOMAIN)]; 2773 ourtype4 = types4[(int) (kind - VARIABLES_DOMAIN)]; 2774 2775 sr = *matches = NULL; 2776 tail = NULL; 2777 2778 if (regexp != NULL) 2779 { 2780 /* Make sure spacing is right for C++ operators. 2781 This is just a courtesy to make the matching less sensitive 2782 to how many spaces the user leaves between 'operator' 2783 and <TYPENAME> or <OPERATOR>. */ 2784 char *opend; 2785 char *opname = operator_chars (regexp, &opend); 2786 if (*opname) 2787 { 2788 int fix = -1; /* -1 means ok; otherwise number of spaces needed. */ 2789 if (isalpha (*opname) || *opname == '_' || *opname == '$') 2790 { 2791 /* There should 1 space between 'operator' and 'TYPENAME'. */ 2792 if (opname[-1] != ' ' || opname[-2] == ' ') 2793 fix = 1; 2794 } 2795 else 2796 { 2797 /* There should 0 spaces between 'operator' and 'OPERATOR'. */ 2798 if (opname[-1] == ' ') 2799 fix = 0; 2800 } 2801 /* If wrong number of spaces, fix it. */ 2802 if (fix >= 0) 2803 { 2804 char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1); 2805 sprintf (tmp, "operator%.*s%s", fix, " ", opname); 2806 regexp = tmp; 2807 } 2808 } 2809 2810 if (0 != (val = re_comp (regexp))) 2811 error ("Invalid regexp (%s): %s", val, regexp); 2812 } 2813 2814 /* Search through the partial symtabs *first* for all symbols 2815 matching the regexp. That way we don't have to reproduce all of 2816 the machinery below. */ 2817 2818 ALL_PSYMTABS (objfile, ps) 2819 { 2820 struct partial_symbol **bound, **gbound, **sbound; 2821 int keep_going = 1; 2822 2823 if (ps->readin) 2824 continue; 2825 2826 gbound = objfile->global_psymbols.list + ps->globals_offset + ps->n_global_syms; 2827 sbound = objfile->static_psymbols.list + ps->statics_offset + ps->n_static_syms; 2828 bound = gbound; 2829 2830 /* Go through all of the symbols stored in a partial 2831 symtab in one loop. */ 2832 psym = objfile->global_psymbols.list + ps->globals_offset; 2833 while (keep_going) 2834 { 2835 if (psym >= bound) 2836 { 2837 if (bound == gbound && ps->n_static_syms != 0) 2838 { 2839 psym = objfile->static_psymbols.list + ps->statics_offset; 2840 bound = sbound; 2841 } 2842 else 2843 keep_going = 0; 2844 continue; 2845 } 2846 else 2847 { 2848 QUIT; 2849 2850 /* If it would match (logic taken from loop below) 2851 load the file and go on to the next one */ 2852 if (file_matches (ps->filename, files, nfiles) 2853 && ((regexp == NULL 2854 || re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0) 2855 && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (*psym) != LOC_TYPEDEF 2856 && SYMBOL_CLASS (*psym) != LOC_BLOCK) 2857 || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK) 2858 || (kind == TYPES_DOMAIN && SYMBOL_CLASS (*psym) == LOC_TYPEDEF) 2859 || (kind == METHODS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK)))) 2860 { 2861 PSYMTAB_TO_SYMTAB (ps); 2862 keep_going = 0; 2863 } 2864 } 2865 psym++; 2866 } 2867 } 2868 2869 /* Here, we search through the minimal symbol tables for functions 2870 and variables that match, and force their symbols to be read. 2871 This is in particular necessary for demangled variable names, 2872 which are no longer put into the partial symbol tables. 2873 The symbol will then be found during the scan of symtabs below. 2874 2875 For functions, find_pc_symtab should succeed if we have debug info 2876 for the function, for variables we have to call lookup_symbol 2877 to determine if the variable has debug info. 2878 If the lookup fails, set found_misc so that we will rescan to print 2879 any matching symbols without debug info. 2880 */ 2881 2882 if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN)) 2883 { 2884 ALL_MSYMBOLS (objfile, msymbol) 2885 { 2886 if (MSYMBOL_TYPE (msymbol) == ourtype || 2887 MSYMBOL_TYPE (msymbol) == ourtype2 || 2888 MSYMBOL_TYPE (msymbol) == ourtype3 || 2889 MSYMBOL_TYPE (msymbol) == ourtype4) 2890 { 2891 if (regexp == NULL 2892 || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0) 2893 { 2894 if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))) 2895 { 2896 /* FIXME: carlton/2003-02-04: Given that the 2897 semantics of lookup_symbol keeps on changing 2898 slightly, it would be a nice idea if we had a 2899 function lookup_symbol_minsym that found the 2900 symbol associated to a given minimal symbol (if 2901 any). */ 2902 if (kind == FUNCTIONS_DOMAIN 2903 || lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), 2904 (struct block *) NULL, 2905 VAR_DOMAIN, 2906 0, (struct symtab **) NULL) == NULL) 2907 found_misc = 1; 2908 } 2909 } 2910 } 2911 } 2912 } 2913 2914 ALL_SYMTABS (objfile, s) 2915 { 2916 bv = BLOCKVECTOR (s); 2917 /* Often many files share a blockvector. 2918 Scan each blockvector only once so that 2919 we don't get every symbol many times. 2920 It happens that the first symtab in the list 2921 for any given blockvector is the main file. */ 2922 if (bv != prev_bv) 2923 for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) 2924 { 2925 struct symbol_search *prevtail = tail; 2926 int nfound = 0; 2927 b = BLOCKVECTOR_BLOCK (bv, i); 2928 ALL_BLOCK_SYMBOLS (b, iter, sym) 2929 { 2930 QUIT; 2931 if (file_matches (s->filename, files, nfiles) 2932 && ((regexp == NULL 2933 || re_exec (SYMBOL_NATURAL_NAME (sym)) != 0) 2934 && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF 2935 && SYMBOL_CLASS (sym) != LOC_BLOCK 2936 && SYMBOL_CLASS (sym) != LOC_CONST) 2937 || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK) 2938 || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 2939 || (kind == METHODS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK)))) 2940 { 2941 /* match */ 2942 psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search)); 2943 psr->block = i; 2944 psr->symtab = s; 2945 psr->symbol = sym; 2946 psr->msymbol = NULL; 2947 psr->next = NULL; 2948 if (tail == NULL) 2949 sr = psr; 2950 else 2951 tail->next = psr; 2952 tail = psr; 2953 nfound ++; 2954 } 2955 } 2956 if (nfound > 0) 2957 { 2958 if (prevtail == NULL) 2959 { 2960 struct symbol_search dummy; 2961 2962 dummy.next = sr; 2963 tail = sort_search_symbols (&dummy, nfound); 2964 sr = dummy.next; 2965 2966 old_chain = make_cleanup_free_search_symbols (sr); 2967 } 2968 else 2969 tail = sort_search_symbols (prevtail, nfound); 2970 } 2971 } 2972 prev_bv = bv; 2973 } 2974 2975 /* If there are no eyes, avoid all contact. I mean, if there are 2976 no debug symbols, then print directly from the msymbol_vector. */ 2977 2978 if (found_misc || kind != FUNCTIONS_DOMAIN) 2979 { 2980 ALL_MSYMBOLS (objfile, msymbol) 2981 { 2982 if (MSYMBOL_TYPE (msymbol) == ourtype || 2983 MSYMBOL_TYPE (msymbol) == ourtype2 || 2984 MSYMBOL_TYPE (msymbol) == ourtype3 || 2985 MSYMBOL_TYPE (msymbol) == ourtype4) 2986 { 2987 if (regexp == NULL 2988 || re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0) 2989 { 2990 /* Functions: Look up by address. */ 2991 if (kind != FUNCTIONS_DOMAIN || 2992 (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))) 2993 { 2994 /* Variables/Absolutes: Look up by name */ 2995 if (lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), 2996 (struct block *) NULL, VAR_DOMAIN, 2997 0, (struct symtab **) NULL) == NULL) 2998 { 2999 /* match */ 3000 psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search)); 3001 psr->block = i; 3002 psr->msymbol = msymbol; 3003 psr->symtab = NULL; 3004 psr->symbol = NULL; 3005 psr->next = NULL; 3006 if (tail == NULL) 3007 { 3008 sr = psr; 3009 old_chain = make_cleanup_free_search_symbols (sr); 3010 } 3011 else 3012 tail->next = psr; 3013 tail = psr; 3014 } 3015 } 3016 } 3017 } 3018 } 3019 } 3020 3021 *matches = sr; 3022 if (sr != NULL) 3023 discard_cleanups (old_chain); 3024} 3025 3026/* Helper function for symtab_symbol_info, this function uses 3027 the data returned from search_symbols() to print information 3028 regarding the match to gdb_stdout. 3029 */ 3030static void 3031print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym, 3032 int block, char *last) 3033{ 3034 if (last == NULL || strcmp (last, s->filename) != 0) 3035 { 3036 fputs_filtered ("\nFile ", gdb_stdout); 3037 fputs_filtered (s->filename, gdb_stdout); 3038 fputs_filtered (":\n", gdb_stdout); 3039 } 3040 3041 if (kind != TYPES_DOMAIN && block == STATIC_BLOCK) 3042 printf_filtered ("static "); 3043 3044 /* Typedef that is not a C++ class */ 3045 if (kind == TYPES_DOMAIN 3046 && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN) 3047 typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout); 3048 /* variable, func, or typedef-that-is-c++-class */ 3049 else if (kind < TYPES_DOMAIN || 3050 (kind == TYPES_DOMAIN && 3051 SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN)) 3052 { 3053 type_print (SYMBOL_TYPE (sym), 3054 (SYMBOL_CLASS (sym) == LOC_TYPEDEF 3055 ? "" : SYMBOL_PRINT_NAME (sym)), 3056 gdb_stdout, 0); 3057 3058 printf_filtered (";\n"); 3059 } 3060} 3061 3062/* This help function for symtab_symbol_info() prints information 3063 for non-debugging symbols to gdb_stdout. 3064 */ 3065static void 3066print_msymbol_info (struct minimal_symbol *msymbol) 3067{ 3068 char *tmp; 3069 3070 if (TARGET_ADDR_BIT <= 32) 3071 tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol) 3072 & (CORE_ADDR) 0xffffffff, 3073 "08l"); 3074 else 3075 tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol), 3076 "016l"); 3077 printf_filtered ("%s %s\n", 3078 tmp, SYMBOL_PRINT_NAME (msymbol)); 3079} 3080 3081/* This is the guts of the commands "info functions", "info types", and 3082 "info variables". It calls search_symbols to find all matches and then 3083 print_[m]symbol_info to print out some useful information about the 3084 matches. 3085 */ 3086static void 3087symtab_symbol_info (char *regexp, domain_enum kind, int from_tty) 3088{ 3089 static char *classnames[] 3090 = 3091 {"variable", "function", "type", "method"}; 3092 struct symbol_search *symbols; 3093 struct symbol_search *p; 3094 struct cleanup *old_chain; 3095 char *last_filename = NULL; 3096 int first = 1; 3097 3098 /* must make sure that if we're interrupted, symbols gets freed */ 3099 search_symbols (regexp, kind, 0, (char **) NULL, &symbols); 3100 old_chain = make_cleanup_free_search_symbols (symbols); 3101 3102 printf_filtered (regexp 3103 ? "All %ss matching regular expression \"%s\":\n" 3104 : "All defined %ss:\n", 3105 classnames[(int) (kind - VARIABLES_DOMAIN)], regexp); 3106 3107 for (p = symbols; p != NULL; p = p->next) 3108 { 3109 QUIT; 3110 3111 if (p->msymbol != NULL) 3112 { 3113 if (first) 3114 { 3115 printf_filtered ("\nNon-debugging symbols:\n"); 3116 first = 0; 3117 } 3118 print_msymbol_info (p->msymbol); 3119 } 3120 else 3121 { 3122 print_symbol_info (kind, 3123 p->symtab, 3124 p->symbol, 3125 p->block, 3126 last_filename); 3127 last_filename = p->symtab->filename; 3128 } 3129 } 3130 3131 do_cleanups (old_chain); 3132} 3133 3134static void 3135variables_info (char *regexp, int from_tty) 3136{ 3137 symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty); 3138} 3139 3140static void 3141functions_info (char *regexp, int from_tty) 3142{ 3143 symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty); 3144} 3145 3146 3147static void 3148types_info (char *regexp, int from_tty) 3149{ 3150 symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty); 3151} 3152 3153/* Breakpoint all functions matching regular expression. */ 3154 3155void 3156rbreak_command_wrapper (char *regexp, int from_tty) 3157{ 3158 rbreak_command (regexp, from_tty); 3159} 3160 3161static void 3162rbreak_command (char *regexp, int from_tty) 3163{ 3164 struct symbol_search *ss; 3165 struct symbol_search *p; 3166 struct cleanup *old_chain; 3167 3168 search_symbols (regexp, FUNCTIONS_DOMAIN, 0, (char **) NULL, &ss); 3169 old_chain = make_cleanup_free_search_symbols (ss); 3170 3171 for (p = ss; p != NULL; p = p->next) 3172 { 3173 if (p->msymbol == NULL) 3174 { 3175 char *string = alloca (strlen (p->symtab->filename) 3176 + strlen (SYMBOL_LINKAGE_NAME (p->symbol)) 3177 + 4); 3178 strcpy (string, p->symtab->filename); 3179 strcat (string, ":'"); 3180 strcat (string, SYMBOL_LINKAGE_NAME (p->symbol)); 3181 strcat (string, "'"); 3182 break_command (string, from_tty); 3183 print_symbol_info (FUNCTIONS_DOMAIN, 3184 p->symtab, 3185 p->symbol, 3186 p->block, 3187 p->symtab->filename); 3188 } 3189 else 3190 { 3191 break_command (SYMBOL_LINKAGE_NAME (p->msymbol), from_tty); 3192 printf_filtered ("<function, no debug info> %s;\n", 3193 SYMBOL_PRINT_NAME (p->msymbol)); 3194 } 3195 } 3196 3197 do_cleanups (old_chain); 3198} 3199 3200 3201/* Helper routine for make_symbol_completion_list. */ 3202 3203static int return_val_size; 3204static int return_val_index; 3205static char **return_val; 3206 3207#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \ 3208 completion_list_add_name \ 3209 (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word)) 3210 3211/* Test to see if the symbol specified by SYMNAME (which is already 3212 demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN 3213 characters. If so, add it to the current completion list. */ 3214 3215static void 3216completion_list_add_name (char *symname, char *sym_text, int sym_text_len, 3217 char *text, char *word) 3218{ 3219 int newsize; 3220 int i; 3221 3222 /* clip symbols that cannot match */ 3223 3224 if (strncmp (symname, sym_text, sym_text_len) != 0) 3225 { 3226 return; 3227 } 3228 3229 /* We have a match for a completion, so add SYMNAME to the current list 3230 of matches. Note that the name is moved to freshly malloc'd space. */ 3231 3232 { 3233 char *new; 3234 if (word == sym_text) 3235 { 3236 new = xmalloc (strlen (symname) + 5); 3237 strcpy (new, symname); 3238 } 3239 else if (word > sym_text) 3240 { 3241 /* Return some portion of symname. */ 3242 new = xmalloc (strlen (symname) + 5); 3243 strcpy (new, symname + (word - sym_text)); 3244 } 3245 else 3246 { 3247 /* Return some of SYM_TEXT plus symname. */ 3248 new = xmalloc (strlen (symname) + (sym_text - word) + 5); 3249 strncpy (new, word, sym_text - word); 3250 new[sym_text - word] = '\0'; 3251 strcat (new, symname); 3252 } 3253 3254 if (return_val_index + 3 > return_val_size) 3255 { 3256 newsize = (return_val_size *= 2) * sizeof (char *); 3257 return_val = (char **) xrealloc ((char *) return_val, newsize); 3258 } 3259 return_val[return_val_index++] = new; 3260 return_val[return_val_index] = NULL; 3261 } 3262} 3263 3264/* ObjC: In case we are completing on a selector, look as the msymbol 3265 again and feed all the selectors into the mill. */ 3266 3267static void 3268completion_list_objc_symbol (struct minimal_symbol *msymbol, char *sym_text, 3269 int sym_text_len, char *text, char *word) 3270{ 3271 static char *tmp = NULL; 3272 static unsigned int tmplen = 0; 3273 3274 char *method, *category, *selector; 3275 char *tmp2 = NULL; 3276 3277 method = SYMBOL_NATURAL_NAME (msymbol); 3278 3279 /* Is it a method? */ 3280 if ((method[0] != '-') && (method[0] != '+')) 3281 return; 3282 3283 if (sym_text[0] == '[') 3284 /* Complete on shortened method method. */ 3285 completion_list_add_name (method + 1, sym_text, sym_text_len, text, word); 3286 3287 while ((strlen (method) + 1) >= tmplen) 3288 { 3289 if (tmplen == 0) 3290 tmplen = 1024; 3291 else 3292 tmplen *= 2; 3293 tmp = xrealloc (tmp, tmplen); 3294 } 3295 selector = strchr (method, ' '); 3296 if (selector != NULL) 3297 selector++; 3298 3299 category = strchr (method, '('); 3300 3301 if ((category != NULL) && (selector != NULL)) 3302 { 3303 memcpy (tmp, method, (category - method)); 3304 tmp[category - method] = ' '; 3305 memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1); 3306 completion_list_add_name (tmp, sym_text, sym_text_len, text, word); 3307 if (sym_text[0] == '[') 3308 completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word); 3309 } 3310 3311 if (selector != NULL) 3312 { 3313 /* Complete on selector only. */ 3314 strcpy (tmp, selector); 3315 tmp2 = strchr (tmp, ']'); 3316 if (tmp2 != NULL) 3317 *tmp2 = '\0'; 3318 3319 completion_list_add_name (tmp, sym_text, sym_text_len, text, word); 3320 } 3321} 3322 3323/* Break the non-quoted text based on the characters which are in 3324 symbols. FIXME: This should probably be language-specific. */ 3325 3326static char * 3327language_search_unquoted_string (char *text, char *p) 3328{ 3329 for (; p > text; --p) 3330 { 3331 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0') 3332 continue; 3333 else 3334 { 3335 if ((current_language->la_language == language_objc)) 3336 { 3337 if (p[-1] == ':') /* might be part of a method name */ 3338 continue; 3339 else if (p[-1] == '[' && (p[-2] == '-' || p[-2] == '+')) 3340 p -= 2; /* beginning of a method name */ 3341 else if (p[-1] == ' ' || p[-1] == '(' || p[-1] == ')') 3342 { /* might be part of a method name */ 3343 char *t = p; 3344 3345 /* Seeing a ' ' or a '(' is not conclusive evidence 3346 that we are in the middle of a method name. However, 3347 finding "-[" or "+[" should be pretty un-ambiguous. 3348 Unfortunately we have to find it now to decide. */ 3349 3350 while (t > text) 3351 if (isalnum (t[-1]) || t[-1] == '_' || 3352 t[-1] == ' ' || t[-1] == ':' || 3353 t[-1] == '(' || t[-1] == ')') 3354 --t; 3355 else 3356 break; 3357 3358 if (t[-1] == '[' && (t[-2] == '-' || t[-2] == '+')) 3359 p = t - 2; /* method name detected */ 3360 /* else we leave with p unchanged */ 3361 } 3362 } 3363 break; 3364 } 3365 } 3366 return p; 3367} 3368 3369 3370/* Return a NULL terminated array of all symbols (regardless of class) 3371 which begin by matching TEXT. If the answer is no symbols, then 3372 the return value is an array which contains only a NULL pointer. 3373 3374 Problem: All of the symbols have to be copied because readline frees them. 3375 I'm not going to worry about this; hopefully there won't be that many. */ 3376 3377char ** 3378make_symbol_completion_list (char *text, char *word) 3379{ 3380 struct symbol *sym; 3381 struct symtab *s; 3382 struct partial_symtab *ps; 3383 struct minimal_symbol *msymbol; 3384 struct objfile *objfile; 3385 struct block *b, *surrounding_static_block = 0; 3386 struct dict_iterator iter; 3387 int j; 3388 struct partial_symbol **psym; 3389 /* The symbol we are completing on. Points in same buffer as text. */ 3390 char *sym_text; 3391 /* Length of sym_text. */ 3392 int sym_text_len; 3393 3394 /* Now look for the symbol we are supposed to complete on. 3395 FIXME: This should be language-specific. */ 3396 { 3397 char *p; 3398 char quote_found; 3399 char *quote_pos = NULL; 3400 3401 /* First see if this is a quoted string. */ 3402 quote_found = '\0'; 3403 for (p = text; *p != '\0'; ++p) 3404 { 3405 if (quote_found != '\0') 3406 { 3407 if (*p == quote_found) 3408 /* Found close quote. */ 3409 quote_found = '\0'; 3410 else if (*p == '\\' && p[1] == quote_found) 3411 /* A backslash followed by the quote character 3412 doesn't end the string. */ 3413 ++p; 3414 } 3415 else if (*p == '\'' || *p == '"') 3416 { 3417 quote_found = *p; 3418 quote_pos = p; 3419 } 3420 } 3421 if (quote_found == '\'') 3422 /* A string within single quotes can be a symbol, so complete on it. */ 3423 sym_text = quote_pos + 1; 3424 else if (quote_found == '"') 3425 /* A double-quoted string is never a symbol, nor does it make sense 3426 to complete it any other way. */ 3427 { 3428 return_val = (char **) xmalloc (sizeof (char *)); 3429 return_val[0] = NULL; 3430 return return_val; 3431 } 3432 else 3433 { 3434 /* It is not a quoted string. Break it based on the characters 3435 which are in symbols. */ 3436 while (p > text) 3437 { 3438 if (isalnum (p[-1]) || p[-1] == '_' || p[-1] == '\0') 3439 --p; 3440 else 3441 break; 3442 } 3443 sym_text = p; 3444 } 3445 } 3446 3447 sym_text_len = strlen (sym_text); 3448 3449 return_val_size = 100; 3450 return_val_index = 0; 3451 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *)); 3452 return_val[0] = NULL; 3453 3454 /* Look through the partial symtabs for all symbols which begin 3455 by matching SYM_TEXT. Add each one that you find to the list. */ 3456 3457 ALL_PSYMTABS (objfile, ps) 3458 { 3459 /* If the psymtab's been read in we'll get it when we search 3460 through the blockvector. */ 3461 if (ps->readin) 3462 continue; 3463 3464 for (psym = objfile->global_psymbols.list + ps->globals_offset; 3465 psym < (objfile->global_psymbols.list + ps->globals_offset 3466 + ps->n_global_syms); 3467 psym++) 3468 { 3469 /* If interrupted, then quit. */ 3470 QUIT; 3471 COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word); 3472 } 3473 3474 for (psym = objfile->static_psymbols.list + ps->statics_offset; 3475 psym < (objfile->static_psymbols.list + ps->statics_offset 3476 + ps->n_static_syms); 3477 psym++) 3478 { 3479 QUIT; 3480 COMPLETION_LIST_ADD_SYMBOL (*psym, sym_text, sym_text_len, text, word); 3481 } 3482 } 3483 3484 /* At this point scan through the misc symbol vectors and add each 3485 symbol you find to the list. Eventually we want to ignore 3486 anything that isn't a text symbol (everything else will be 3487 handled by the psymtab code above). */ 3488 3489 ALL_MSYMBOLS (objfile, msymbol) 3490 { 3491 QUIT; 3492 COMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text, word); 3493 3494 completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text, word); 3495 } 3496 3497 /* Search upwards from currently selected frame (so that we can 3498 complete on local vars. */ 3499 3500 for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b)) 3501 { 3502 if (!BLOCK_SUPERBLOCK (b)) 3503 { 3504 surrounding_static_block = b; /* For elmin of dups */ 3505 } 3506 3507 /* Also catch fields of types defined in this places which match our 3508 text string. Only complete on types visible from current context. */ 3509 3510 ALL_BLOCK_SYMBOLS (b, iter, sym) 3511 { 3512 QUIT; 3513 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); 3514 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF) 3515 { 3516 struct type *t = SYMBOL_TYPE (sym); 3517 enum type_code c = TYPE_CODE (t); 3518 3519 if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT) 3520 { 3521 for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++) 3522 { 3523 if (TYPE_FIELD_NAME (t, j)) 3524 { 3525 completion_list_add_name (TYPE_FIELD_NAME (t, j), 3526 sym_text, sym_text_len, text, word); 3527 } 3528 } 3529 } 3530 } 3531 } 3532 } 3533 3534 /* Go through the symtabs and check the externs and statics for 3535 symbols which match. */ 3536 3537 ALL_SYMTABS (objfile, s) 3538 { 3539 QUIT; 3540 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); 3541 ALL_BLOCK_SYMBOLS (b, iter, sym) 3542 { 3543 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); 3544 } 3545 } 3546 3547 ALL_SYMTABS (objfile, s) 3548 { 3549 QUIT; 3550 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); 3551 /* Don't do this block twice. */ 3552 if (b == surrounding_static_block) 3553 continue; 3554 ALL_BLOCK_SYMBOLS (b, iter, sym) 3555 { 3556 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); 3557 } 3558 } 3559 3560 return (return_val); 3561} 3562 3563/* Like make_symbol_completion_list, but returns a list of symbols 3564 defined in a source file FILE. */ 3565 3566char ** 3567make_file_symbol_completion_list (char *text, char *word, char *srcfile) 3568{ 3569 struct symbol *sym; 3570 struct symtab *s; 3571 struct block *b; 3572 struct dict_iterator iter; 3573 /* The symbol we are completing on. Points in same buffer as text. */ 3574 char *sym_text; 3575 /* Length of sym_text. */ 3576 int sym_text_len; 3577 3578 /* Now look for the symbol we are supposed to complete on. 3579 FIXME: This should be language-specific. */ 3580 { 3581 char *p; 3582 char quote_found; 3583 char *quote_pos = NULL; 3584 3585 /* First see if this is a quoted string. */ 3586 quote_found = '\0'; 3587 for (p = text; *p != '\0'; ++p) 3588 { 3589 if (quote_found != '\0') 3590 { 3591 if (*p == quote_found) 3592 /* Found close quote. */ 3593 quote_found = '\0'; 3594 else if (*p == '\\' && p[1] == quote_found) 3595 /* A backslash followed by the quote character 3596 doesn't end the string. */ 3597 ++p; 3598 } 3599 else if (*p == '\'' || *p == '"') 3600 { 3601 quote_found = *p; 3602 quote_pos = p; 3603 } 3604 } 3605 if (quote_found == '\'') 3606 /* A string within single quotes can be a symbol, so complete on it. */ 3607 sym_text = quote_pos + 1; 3608 else if (quote_found == '"') 3609 /* A double-quoted string is never a symbol, nor does it make sense 3610 to complete it any other way. */ 3611 { 3612 return_val = (char **) xmalloc (sizeof (char *)); 3613 return_val[0] = NULL; 3614 return return_val; 3615 } 3616 else 3617 { 3618 /* Not a quoted string. */ 3619 sym_text = language_search_unquoted_string (text, p); 3620 } 3621 } 3622 3623 sym_text_len = strlen (sym_text); 3624 3625 return_val_size = 10; 3626 return_val_index = 0; 3627 return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *)); 3628 return_val[0] = NULL; 3629 3630 /* Find the symtab for SRCFILE (this loads it if it was not yet read 3631 in). */ 3632 s = lookup_symtab (srcfile); 3633 if (s == NULL) 3634 { 3635 /* Maybe they typed the file with leading directories, while the 3636 symbol tables record only its basename. */ 3637 const char *tail = lbasename (srcfile); 3638 3639 if (tail > srcfile) 3640 s = lookup_symtab (tail); 3641 } 3642 3643 /* If we have no symtab for that file, return an empty list. */ 3644 if (s == NULL) 3645 return (return_val); 3646 3647 /* Go through this symtab and check the externs and statics for 3648 symbols which match. */ 3649 3650 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); 3651 ALL_BLOCK_SYMBOLS (b, iter, sym) 3652 { 3653 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); 3654 } 3655 3656 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); 3657 ALL_BLOCK_SYMBOLS (b, iter, sym) 3658 { 3659 COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); 3660 } 3661 3662 return (return_val); 3663} 3664 3665/* A helper function for make_source_files_completion_list. It adds 3666 another file name to a list of possible completions, growing the 3667 list as necessary. */ 3668 3669static void 3670add_filename_to_list (const char *fname, char *text, char *word, 3671 char ***list, int *list_used, int *list_alloced) 3672{ 3673 char *new; 3674 size_t fnlen = strlen (fname); 3675 3676 if (*list_used + 1 >= *list_alloced) 3677 { 3678 *list_alloced *= 2; 3679 *list = (char **) xrealloc ((char *) *list, 3680 *list_alloced * sizeof (char *)); 3681 } 3682 3683 if (word == text) 3684 { 3685 /* Return exactly fname. */ 3686 new = xmalloc (fnlen + 5); 3687 strcpy (new, fname); 3688 } 3689 else if (word > text) 3690 { 3691 /* Return some portion of fname. */ 3692 new = xmalloc (fnlen + 5); 3693 strcpy (new, fname + (word - text)); 3694 } 3695 else 3696 { 3697 /* Return some of TEXT plus fname. */ 3698 new = xmalloc (fnlen + (text - word) + 5); 3699 strncpy (new, word, text - word); 3700 new[text - word] = '\0'; 3701 strcat (new, fname); 3702 } 3703 (*list)[*list_used] = new; 3704 (*list)[++*list_used] = NULL; 3705} 3706 3707static int 3708not_interesting_fname (const char *fname) 3709{ 3710 static const char *illegal_aliens[] = { 3711 "_globals_", /* inserted by coff_symtab_read */ 3712 NULL 3713 }; 3714 int i; 3715 3716 for (i = 0; illegal_aliens[i]; i++) 3717 { 3718 if (strcmp (fname, illegal_aliens[i]) == 0) 3719 return 1; 3720 } 3721 return 0; 3722} 3723 3724/* Return a NULL terminated array of all source files whose names 3725 begin with matching TEXT. The file names are looked up in the 3726 symbol tables of this program. If the answer is no matchess, then 3727 the return value is an array which contains only a NULL pointer. */ 3728 3729char ** 3730make_source_files_completion_list (char *text, char *word) 3731{ 3732 struct symtab *s; 3733 struct partial_symtab *ps; 3734 struct objfile *objfile; 3735 int first = 1; 3736 int list_alloced = 1; 3737 int list_used = 0; 3738 size_t text_len = strlen (text); 3739 char **list = (char **) xmalloc (list_alloced * sizeof (char *)); 3740 const char *base_name; 3741 3742 list[0] = NULL; 3743 3744 if (!have_full_symbols () && !have_partial_symbols ()) 3745 return list; 3746 3747 ALL_SYMTABS (objfile, s) 3748 { 3749 if (not_interesting_fname (s->filename)) 3750 continue; 3751 if (!filename_seen (s->filename, 1, &first) 3752#if HAVE_DOS_BASED_FILE_SYSTEM 3753 && strncasecmp (s->filename, text, text_len) == 0 3754#else 3755 && strncmp (s->filename, text, text_len) == 0 3756#endif 3757 ) 3758 { 3759 /* This file matches for a completion; add it to the current 3760 list of matches. */ 3761 add_filename_to_list (s->filename, text, word, 3762 &list, &list_used, &list_alloced); 3763 } 3764 else 3765 { 3766 /* NOTE: We allow the user to type a base name when the 3767 debug info records leading directories, but not the other 3768 way around. This is what subroutines of breakpoint 3769 command do when they parse file names. */ 3770 base_name = lbasename (s->filename); 3771 if (base_name != s->filename 3772 && !filename_seen (base_name, 1, &first) 3773#if HAVE_DOS_BASED_FILE_SYSTEM 3774 && strncasecmp (base_name, text, text_len) == 0 3775#else 3776 && strncmp (base_name, text, text_len) == 0 3777#endif 3778 ) 3779 add_filename_to_list (base_name, text, word, 3780 &list, &list_used, &list_alloced); 3781 } 3782 } 3783 3784 ALL_PSYMTABS (objfile, ps) 3785 { 3786 if (not_interesting_fname (ps->filename)) 3787 continue; 3788 if (!ps->readin) 3789 { 3790 if (!filename_seen (ps->filename, 1, &first) 3791#if HAVE_DOS_BASED_FILE_SYSTEM 3792 && strncasecmp (ps->filename, text, text_len) == 0 3793#else 3794 && strncmp (ps->filename, text, text_len) == 0 3795#endif 3796 ) 3797 { 3798 /* This file matches for a completion; add it to the 3799 current list of matches. */ 3800 add_filename_to_list (ps->filename, text, word, 3801 &list, &list_used, &list_alloced); 3802 3803 } 3804 else 3805 { 3806 base_name = lbasename (ps->filename); 3807 if (base_name != ps->filename 3808 && !filename_seen (base_name, 1, &first) 3809#if HAVE_DOS_BASED_FILE_SYSTEM 3810 && strncasecmp (base_name, text, text_len) == 0 3811#else 3812 && strncmp (base_name, text, text_len) == 0 3813#endif 3814 ) 3815 add_filename_to_list (base_name, text, word, 3816 &list, &list_used, &list_alloced); 3817 } 3818 } 3819 } 3820 3821 return list; 3822} 3823 3824/* Determine if PC is in the prologue of a function. The prologue is the area 3825 between the first instruction of a function, and the first executable line. 3826 Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue. 3827 3828 If non-zero, func_start is where we think the prologue starts, possibly 3829 by previous examination of symbol table information. 3830 */ 3831 3832int 3833in_prologue (CORE_ADDR pc, CORE_ADDR func_start) 3834{ 3835 struct symtab_and_line sal; 3836 CORE_ADDR func_addr, func_end; 3837 3838 /* We have several sources of information we can consult to figure 3839 this out. 3840 - Compilers usually emit line number info that marks the prologue 3841 as its own "source line". So the ending address of that "line" 3842 is the end of the prologue. If available, this is the most 3843 reliable method. 3844 - The minimal symbols and partial symbols, which can usually tell 3845 us the starting and ending addresses of a function. 3846 - If we know the function's start address, we can call the 3847 architecture-defined SKIP_PROLOGUE function to analyze the 3848 instruction stream and guess where the prologue ends. 3849 - Our `func_start' argument; if non-zero, this is the caller's 3850 best guess as to the function's entry point. At the time of 3851 this writing, handle_inferior_event doesn't get this right, so 3852 it should be our last resort. */ 3853 3854 /* Consult the partial symbol table, to find which function 3855 the PC is in. */ 3856 if (! find_pc_partial_function (pc, NULL, &func_addr, &func_end)) 3857 { 3858 CORE_ADDR prologue_end; 3859 3860 /* We don't even have minsym information, so fall back to using 3861 func_start, if given. */ 3862 if (! func_start) 3863 return 1; /* We *might* be in a prologue. */ 3864 3865 prologue_end = SKIP_PROLOGUE (func_start); 3866 3867 return func_start <= pc && pc < prologue_end; 3868 } 3869 3870 /* If we have line number information for the function, that's 3871 usually pretty reliable. */ 3872 sal = find_pc_line (func_addr, 0); 3873 3874 /* Now sal describes the source line at the function's entry point, 3875 which (by convention) is the prologue. The end of that "line", 3876 sal.end, is the end of the prologue. 3877 3878 Note that, for functions whose source code is all on a single 3879 line, the line number information doesn't always end up this way. 3880 So we must verify that our purported end-of-prologue address is 3881 *within* the function, not at its start or end. */ 3882 if (sal.line == 0 3883 || sal.end <= func_addr 3884 || func_end <= sal.end) 3885 { 3886 /* We don't have any good line number info, so use the minsym 3887 information, together with the architecture-specific prologue 3888 scanning code. */ 3889 CORE_ADDR prologue_end = SKIP_PROLOGUE (func_addr); 3890 3891 return func_addr <= pc && pc < prologue_end; 3892 } 3893 3894 /* We have line number info, and it looks good. */ 3895 return func_addr <= pc && pc < sal.end; 3896} 3897 3898/* Given PC at the function's start address, attempt to find the 3899 prologue end using SAL information. Return zero if the skip fails. 3900 3901 A non-optimized prologue traditionally has one SAL for the function 3902 and a second for the function body. A single line function has 3903 them both pointing at the same line. 3904 3905 An optimized prologue is similar but the prologue may contain 3906 instructions (SALs) from the instruction body. Need to skip those 3907 while not getting into the function body. 3908 3909 The functions end point and an increasing SAL line are used as 3910 indicators of the prologue's endpoint. 3911 3912 This code is based on the function refine_prologue_limit (versions 3913 found in both ia64 and ppc). */ 3914 3915CORE_ADDR 3916skip_prologue_using_sal (CORE_ADDR func_addr) 3917{ 3918 struct symtab_and_line prologue_sal; 3919 CORE_ADDR start_pc; 3920 CORE_ADDR end_pc; 3921 3922 /* Get an initial range for the function. */ 3923 find_pc_partial_function (func_addr, NULL, &start_pc, &end_pc); 3924 start_pc += FUNCTION_START_OFFSET; 3925 3926 prologue_sal = find_pc_line (start_pc, 0); 3927 if (prologue_sal.line != 0) 3928 { 3929 while (prologue_sal.end < end_pc) 3930 { 3931 struct symtab_and_line sal; 3932 3933 sal = find_pc_line (prologue_sal.end, 0); 3934 if (sal.line == 0) 3935 break; 3936 /* Assume that a consecutive SAL for the same (or larger) 3937 line mark the prologue -> body transition. */ 3938 if (sal.line >= prologue_sal.line) 3939 break; 3940 /* The case in which compiler's optimizer/scheduler has 3941 moved instructions into the prologue. We look ahead in 3942 the function looking for address ranges whose 3943 corresponding line number is less the first one that we 3944 found for the function. This is more conservative then 3945 refine_prologue_limit which scans a large number of SALs 3946 looking for any in the prologue */ 3947 prologue_sal = sal; 3948 } 3949 } 3950 return prologue_sal.end; 3951} 3952 3953struct symtabs_and_lines 3954decode_line_spec (char *string, int funfirstline) 3955{ 3956 struct symtabs_and_lines sals; 3957 struct symtab_and_line cursal; 3958 3959 if (string == 0) 3960 error ("Empty line specification."); 3961 3962 /* We use whatever is set as the current source line. We do not try 3963 and get a default or it will recursively call us! */ 3964 cursal = get_current_source_symtab_and_line (); 3965 3966 sals = decode_line_1 (&string, funfirstline, 3967 cursal.symtab, cursal.line, 3968 (char ***) NULL, NULL); 3969 3970 if (*string) 3971 error ("Junk at end of line specification: %s", string); 3972 return sals; 3973} 3974 3975/* Track MAIN */ 3976static char *name_of_main; 3977 3978void 3979set_main_name (const char *name) 3980{ 3981 if (name_of_main != NULL) 3982 { 3983 xfree (name_of_main); 3984 name_of_main = NULL; 3985 } 3986 if (name != NULL) 3987 { 3988 name_of_main = xstrdup (name); 3989 } 3990} 3991 3992char * 3993main_name (void) 3994{ 3995 if (name_of_main != NULL) 3996 return name_of_main; 3997 else 3998 return "main"; 3999} 4000 4001 4002void 4003_initialize_symtab (void) 4004{ 4005 add_info ("variables", variables_info, 4006 "All global and static variable names, or those matching REGEXP."); 4007 if (dbx_commands) 4008 add_com ("whereis", class_info, variables_info, 4009 "All global and static variable names, or those matching REGEXP."); 4010 4011 add_info ("functions", functions_info, 4012 "All function names, or those matching REGEXP."); 4013 4014 4015 /* FIXME: This command has at least the following problems: 4016 1. It prints builtin types (in a very strange and confusing fashion). 4017 2. It doesn't print right, e.g. with 4018 typedef struct foo *FOO 4019 type_print prints "FOO" when we want to make it (in this situation) 4020 print "struct foo *". 4021 I also think "ptype" or "whatis" is more likely to be useful (but if 4022 there is much disagreement "info types" can be fixed). */ 4023 add_info ("types", types_info, 4024 "All type names, or those matching REGEXP."); 4025 4026 add_info ("sources", sources_info, 4027 "Source files in the program."); 4028 4029 add_com ("rbreak", class_breakpoint, rbreak_command, 4030 "Set a breakpoint for all functions matching REGEXP."); 4031 4032 if (xdb_commands) 4033 { 4034 add_com ("lf", class_info, sources_info, "Source files in the program"); 4035 add_com ("lg", class_info, variables_info, 4036 "All global and static variable names, or those matching REGEXP."); 4037 } 4038 4039 /* Initialize the one built-in type that isn't language dependent... */ 4040 builtin_type_error = init_type (TYPE_CODE_ERROR, 0, 0, 4041 "<unknown type>", (struct objfile *) NULL); 4042} 4043