#include "filenames.h" /* for FILENAME_CMP */
#include "objc-lang.h"
#include "ada-lang.h"
+#include "p-lang.h"
#include "hashtab.h"
const domain_enum domain,
struct symtab **symtab);
-#if 0
-static
-struct symbol *lookup_symbol_aux_minsyms (const char *name,
- const char *linkage_name,
- const domain_enum domain,
- int *is_a_field_of_this,
- struct symtab **symtab);
-#endif
-
static void fixup_section (struct general_symbol_info *, struct objfile *);
static int file_matches (char *, char **, int);
sal->line = 0;
sal->pc = 0;
sal->end = 0;
+ sal->explicit_pc = 0;
+ sal->explicit_line = 0;
}
\f
return NULL;
}
-#if 0
-/* Check for the possibility of the symbol being a function or a
- mangled variable that is stored in one of the minimal symbol
- tables. Eventually, all global symbols might be resolved in this
- way. */
-
-/* NOTE: carlton/2002-12-05: At one point, this function was part of
- lookup_symbol_aux, and what are now 'return' statements within
- lookup_symbol_aux_minsyms returned from lookup_symbol_aux, even if
- sym was NULL. As far as I can tell, this was basically accidental;
- it didn't happen every time that msymbol was non-NULL, but only if
- some additional conditions held as well, and it caused problems
- with HP-generated symbol tables. */
-
-/* NOTE: carlton/2003-05-14: This function was once used as part of
- lookup_symbol. It is currently unnecessary for correctness
- reasons, however, and using it doesn't seem to be any faster than
- using lookup_symbol_aux_psymtabs, so I'm commenting it out. */
-
-static struct symbol *
-lookup_symbol_aux_minsyms (const char *name,
- const char *linkage_name,
- const domain_enum domain,
- int *is_a_field_of_this,
- struct symtab **symtab)
-{
- struct symbol *sym;
- struct blockvector *bv;
- const struct block *block;
- struct minimal_symbol *msymbol;
- struct symtab *s;
-
- if (domain == VAR_DOMAIN)
- {
- msymbol = lookup_minimal_symbol (name, NULL, NULL);
-
- if (msymbol != NULL)
- {
- /* OK, we found a minimal symbol in spite of not finding any
- symbol. There are various possible explanations for
- this. One possibility is the symbol exists in code not
- compiled -g. Another possibility is that the 'psymtab'
- isn't doing its job. A third possibility, related to #2,
- is that we were confused by name-mangling. For instance,
- maybe the psymtab isn't doing its job because it only
- know about demangled names, but we were given a mangled
- name... */
-
- /* We first use the address in the msymbol to try to locate
- the appropriate symtab. Note that find_pc_sect_symtab()
- has a side-effect of doing psymtab-to-symtab expansion,
- for the found symtab. */
- s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
- SYMBOL_BFD_SECTION (msymbol));
- if (s != NULL)
- {
- /* This is a function which has a symtab for its address. */
- bv = BLOCKVECTOR (s);
- block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-
- /* This call used to pass `SYMBOL_LINKAGE_NAME (msymbol)' as the
- `name' argument to lookup_block_symbol. But the name
- of a minimal symbol is always mangled, so that seems
- to be clearly the wrong thing to pass as the
- unmangled name. */
- sym =
- lookup_block_symbol (block, name, linkage_name, domain);
- /* We kept static functions in minimal symbol table as well as
- in static scope. We want to find them in the symbol table. */
- if (!sym)
- {
- block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name,
- linkage_name, domain);
- }
-
- /* NOTE: carlton/2002-12-04: The following comment was
- taken from a time when two versions of this function
- were part of the body of lookup_symbol_aux: this
- comment was taken from the version of the function
- that was #ifdef HPUXHPPA, and the comment was right
- before the 'return NULL' part of lookup_symbol_aux.
- (Hence the "Fall through and return 0" comment.)
- Elena did some digging into the situation for
- Fortran, and she reports:
-
- "I asked around (thanks to Jeff Knaggs), and I think
- the story for Fortran goes like this:
-
- "Apparently, in older Fortrans, '_' was not part of
- the user namespace. g77 attached a final '_' to
- procedure names as the exported symbols for linkage
- (foo_) , but the symbols went in the debug info just
- like 'foo'. The rationale behind this is not
- completely clear, and maybe it was done to other
- symbols as well, not just procedures." */
-
- /* If we get here with sym == 0, the symbol was
- found in the minimal symbol table
- but not in the symtab.
- Fall through and return 0 to use the msymbol
- definition of "foo_".
- (Note that outer code generally follows up a call
- to this routine with a call to lookup_minimal_symbol(),
- so a 0 return means we'll just flow into that other routine).
-
- This happens for Fortran "foo_" symbols,
- which are "foo" in the symtab.
-
- This can also happen if "asm" is used to make a
- regular symbol but not a debugging symbol, e.g.
- asm(".globl _main");
- asm("_main:");
- */
-
- if (symtab != NULL && sym != NULL)
- *symtab = s;
- return fixup_symbol_section (sym, s->objfile);
- }
- }
- }
-
- return NULL;
-}
-#endif /* 0 */
-
/* A default version of lookup_symbol_nonlocal for use by languages
that can't think of anything better to do. This implements the C
lookup rules. */
struct objfile *objfile;
struct symtab *s;
+ struct partial_symtab *p;
if (best_index >= 0)
best = best_linetable->item[best_index].line;
else
best = 0;
+ ALL_PSYMTABS (objfile, p)
+ {
+ if (strcmp (symtab->filename, p->filename) != 0)
+ continue;
+ PSYMTAB_TO_SYMTAB (p);
+ }
+
ALL_SYMTABS (objfile, s)
{
struct linetable *l;
static void
find_main_name (void)
{
- char *new_main_name;
+ const char *new_main_name;
/* Try to see if the main procedure is in Ada. */
/* FIXME: brobecker/2005-03-07: Another way of doing this would
return;
}
+ new_main_name = pascal_main_name ();
+ if (new_main_name != NULL)
+ {
+ set_main_name (new_main_name);
+ return;
+ }
+
/* The languages above didn't identify the name of the main procedure.
Fallback to "main". */
set_main_name ("main");
set_main_name (NULL);
}
+/* Helper to expand_line_sal below. Appends new sal to SAL,
+ initializing it from SYMTAB, LINENO and PC. */
+static void
+append_expanded_sal (struct symtabs_and_lines *sal,
+ struct symtab *symtab,
+ int lineno, CORE_ADDR pc)
+{
+ CORE_ADDR func_addr, func_end;
+
+ sal->sals = xrealloc (sal->sals,
+ sizeof (sal->sals[0])
+ * (sal->nelts + 1));
+ init_sal (sal->sals + sal->nelts);
+ sal->sals[sal->nelts].symtab = symtab;
+ sal->sals[sal->nelts].section = NULL;
+ sal->sals[sal->nelts].end = 0;
+ sal->sals[sal->nelts].line = lineno;
+ sal->sals[sal->nelts].pc = pc;
+ ++sal->nelts;
+}
+
+/* Compute a set of all sals in
+ the entire program that correspond to same file
+ and line as SAL and return those. If there
+ are several sals that belong to the same block,
+ only one sal for the block is included in results. */
+
+struct symtabs_and_lines
+expand_line_sal (struct symtab_and_line sal)
+{
+ struct symtabs_and_lines ret, this_line;
+ int i, j;
+ struct objfile *objfile;
+ struct partial_symtab *psymtab;
+ struct symtab *symtab;
+ int lineno;
+ int deleted = 0;
+ struct block **blocks = NULL;
+ int *filter;
+
+ ret.nelts = 0;
+ ret.sals = NULL;
+
+ if (sal.symtab == NULL || sal.line == 0 || sal.pc != 0)
+ {
+ ret.sals = xmalloc (sizeof (struct symtab_and_line));
+ ret.sals[0] = sal;
+ ret.nelts = 1;
+ return ret;
+ }
+ else
+ {
+ struct linetable_entry *best_item = 0;
+ struct symtab *best_symtab = 0;
+ int exact = 0;
+
+ lineno = sal.line;
+
+ /* We meed to find all symtabs for a file which name
+ is described by sal. We cannot just directly
+ iterate over symtabs, since a symtab might not be
+ yet created. We also cannot iterate over psymtabs,
+ calling PSYMTAB_TO_SYMTAB and working on that symtab,
+ since PSYMTAB_TO_SYMTAB will return NULL for psymtab
+ corresponding to an included file. Therefore, we do
+ first pass over psymtabs, reading in those with
+ the right name. Then, we iterate over symtabs, knowing
+ that all symtabs we're interested in are loaded. */
+
+ ALL_PSYMTABS (objfile, psymtab)
+ {
+ if (strcmp (sal.symtab->filename,
+ psymtab->filename) == 0)
+ PSYMTAB_TO_SYMTAB (psymtab);
+ }
+
+
+ /* For each symtab, we add all pcs to ret.sals. I'm actually
+ not sure what to do if we have exact match in one symtab,
+ and non-exact match on another symtab.
+ */
+ ALL_SYMTABS (objfile, symtab)
+ {
+ if (strcmp (sal.symtab->filename,
+ symtab->filename) == 0)
+ {
+ struct linetable *l;
+ int len;
+ l = LINETABLE (symtab);
+ if (!l)
+ continue;
+ len = l->nitems;
+
+ for (j = 0; j < len; j++)
+ {
+ struct linetable_entry *item = &(l->item[j]);
+
+ if (item->line == lineno)
+ {
+ exact = 1;
+ append_expanded_sal (&ret, symtab, lineno, item->pc);
+ }
+ else if (!exact && item->line > lineno
+ && (best_item == NULL || item->line < best_item->line))
+
+ {
+ best_item = item;
+ best_symtab = symtab;
+ }
+ }
+ }
+ }
+ if (!exact && best_item)
+ append_expanded_sal (&ret, best_symtab, lineno, best_item->pc);
+ }
+
+ /* For optimized code, compiler can scatter one source line accross
+ disjoint ranges of PC values, even when no duplicate functions
+ or inline functions are involved. For example, 'for (;;)' inside
+ non-template non-inline non-ctor-or-dtor function can result
+ in two PC ranges. In this case, we don't want to set breakpoint
+ on first PC of each range. To filter such cases, we use containing
+ blocks -- for each PC found above we see if there are other PCs
+ that are in the same block. If yes, the other PCs are filtered out. */
+
+ filter = xmalloc (ret.nelts * sizeof (int));
+ blocks = xmalloc (ret.nelts * sizeof (struct block *));
+ for (i = 0; i < ret.nelts; ++i)
+ {
+ filter[i] = 1;
+ blocks[i] = block_for_pc (ret.sals[i].pc);
+ }
+
+ for (i = 0; i < ret.nelts; ++i)
+ if (blocks[i] != NULL)
+ for (j = i+1; j < ret.nelts; ++j)
+ if (blocks[j] == blocks[i])
+ {
+ filter[j] = 0;
+ ++deleted;
+ break;
+ }
+
+ {
+ struct symtab_and_line *final =
+ xmalloc (sizeof (struct symtab_and_line) * (ret.nelts-deleted));
+
+ for (i = 0, j = 0; i < ret.nelts; ++i)
+ if (filter[i])
+ final[j++] = ret.sals[i];
+
+ ret.nelts -= deleted;
+ xfree (ret.sals);
+ ret.sals = final;
+ }
+
+ return ret;
+}
+
+
void
_initialize_symtab (void)
{