2012-09-26 Jan Kratochvil <jan.kratochvil@redhat.com>
Tom Tromey <tromey@redhat.com> * f-lang.c (allocate_saved_bf_node, allocate_saved_function_node, allocate_saved_f77_common_node, allocate_common_entry_node, tail_common_list, current_common, saved_bf_list, saved_bf_list_end, current_head_bf_list, tmp_bf_ptr, add_common_block, add_common_entry, find_first_common_named, patch_common_entries, patch_all_commons_by_name, ADD_BF_SYMNUM, clear_bf_list, global_remote_debug, get_bf_for_fcn, saved_function_list, saved_function_list_end, clear_function_list, struct saved_fcn, struct saved_bf_symnum, SAVED_FUNCTION, SAVED_FUNCTION_PTR, SAVED_BF, SAVED_BF_PTR): Remove. * f-lang.h (tail_common_list, current_common, UNINITIALIZED_SECNUM, COMMON_NEEDS_PATCHING, BLANK_COMMON_NAME_ORIGINAL, BLANK_COMMON_NAME_MF77, DEFAULT_UPPER_BOUND, DEFAULT_LOWER_BOUND, real_main_name, real_main_c_value): Remove. * f-valprint.c (there_is_a_visible_common_named): Remove.
This commit is contained in:
parent
6f380991ba
commit
965f07a88d
|
@ -1,3 +1,24 @@
|
|||
2012-09-26 Jan Kratochvil <jan.kratochvil@redhat.com>
|
||||
Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* f-lang.c (allocate_saved_bf_node,
|
||||
allocate_saved_function_node, allocate_saved_f77_common_node,
|
||||
allocate_common_entry_node, tail_common_list, current_common,
|
||||
saved_bf_list, saved_bf_list_end, current_head_bf_list,
|
||||
tmp_bf_ptr, add_common_block, add_common_entry,
|
||||
find_first_common_named, patch_common_entries,
|
||||
patch_all_commons_by_name, ADD_BF_SYMNUM, clear_bf_list,
|
||||
global_remote_debug, get_bf_for_fcn, saved_function_list,
|
||||
saved_function_list_end, clear_function_list, struct saved_fcn,
|
||||
struct saved_bf_symnum, SAVED_FUNCTION, SAVED_FUNCTION_PTR,
|
||||
SAVED_BF, SAVED_BF_PTR): Remove.
|
||||
* f-lang.h (tail_common_list, current_common,
|
||||
UNINITIALIZED_SECNUM, COMMON_NEEDS_PATCHING,
|
||||
BLANK_COMMON_NAME_ORIGINAL, BLANK_COMMON_NAME_MF77,
|
||||
DEFAULT_UPPER_BOUND, DEFAULT_LOWER_BOUND, real_main_name,
|
||||
real_main_c_value): Remove.
|
||||
* f-valprint.c (there_is_a_visible_common_named): Remove.
|
||||
|
||||
2012-09-26 Andrew Burgess <aburgess@broadcom.com>
|
||||
|
||||
* breakpoint.c (update_global_location_list): Ignore previous
|
||||
|
|
402
gdb/f-lang.c
402
gdb/f-lang.c
|
@ -36,43 +36,9 @@
|
|||
#include "c-lang.h"
|
||||
|
||||
|
||||
/* Following is dubious stuff that had been in the xcoff reader. */
|
||||
|
||||
struct saved_fcn
|
||||
{
|
||||
long line_offset; /* Line offset for function. */
|
||||
struct saved_fcn *next;
|
||||
};
|
||||
|
||||
|
||||
struct saved_bf_symnum
|
||||
{
|
||||
long symnum_fcn; /* Symnum of function (i.e. .function
|
||||
directive). */
|
||||
long symnum_bf; /* Symnum of .bf for this function. */
|
||||
struct saved_bf_symnum *next;
|
||||
};
|
||||
|
||||
typedef struct saved_fcn SAVED_FUNCTION, *SAVED_FUNCTION_PTR;
|
||||
typedef struct saved_bf_symnum SAVED_BF, *SAVED_BF_PTR;
|
||||
|
||||
/* Local functions */
|
||||
|
||||
extern void _initialize_f_language (void);
|
||||
#if 0
|
||||
static void clear_function_list (void);
|
||||
static long get_bf_for_fcn (long);
|
||||
static void clear_bf_list (void);
|
||||
static void patch_all_commons_by_name (char *, CORE_ADDR, int);
|
||||
static SAVED_F77_COMMON_PTR find_first_common_named (char *);
|
||||
static void add_common_entry (struct symbol *);
|
||||
static void add_common_block (char *, CORE_ADDR, int, char *);
|
||||
static SAVED_FUNCTION *allocate_saved_function_node (void);
|
||||
static SAVED_BF_PTR allocate_saved_bf_node (void);
|
||||
static COMMON_ENTRY_PTR allocate_common_entry_node (void);
|
||||
static SAVED_F77_COMMON_PTR allocate_saved_f77_common_node (void);
|
||||
static void patch_common_entries (SAVED_F77_COMMON_PTR, CORE_ADDR, int);
|
||||
#endif
|
||||
|
||||
static void f_printchar (int c, struct type *type, struct ui_file * stream);
|
||||
static void f_emit_char (int c, struct type *type,
|
||||
|
@ -384,185 +350,7 @@ _initialize_f_language (void)
|
|||
add_language (&f_language_defn);
|
||||
}
|
||||
|
||||
#if 0
|
||||
static SAVED_BF_PTR
|
||||
allocate_saved_bf_node (void)
|
||||
{
|
||||
SAVED_BF_PTR new;
|
||||
|
||||
new = (SAVED_BF_PTR) xmalloc (sizeof (SAVED_BF));
|
||||
return (new);
|
||||
}
|
||||
|
||||
static SAVED_FUNCTION *
|
||||
allocate_saved_function_node (void)
|
||||
{
|
||||
SAVED_FUNCTION *new;
|
||||
|
||||
new = (SAVED_FUNCTION *) xmalloc (sizeof (SAVED_FUNCTION));
|
||||
return (new);
|
||||
}
|
||||
|
||||
static SAVED_F77_COMMON_PTR
|
||||
allocate_saved_f77_common_node (void)
|
||||
{
|
||||
SAVED_F77_COMMON_PTR new;
|
||||
|
||||
new = (SAVED_F77_COMMON_PTR) xmalloc (sizeof (SAVED_F77_COMMON));
|
||||
return (new);
|
||||
}
|
||||
|
||||
static COMMON_ENTRY_PTR
|
||||
allocate_common_entry_node (void)
|
||||
{
|
||||
COMMON_ENTRY_PTR new;
|
||||
|
||||
new = (COMMON_ENTRY_PTR) xmalloc (sizeof (COMMON_ENTRY));
|
||||
return (new);
|
||||
}
|
||||
#endif
|
||||
|
||||
SAVED_F77_COMMON_PTR head_common_list = NULL; /* Ptr to 1st saved COMMON */
|
||||
SAVED_F77_COMMON_PTR tail_common_list = NULL; /* Ptr to last saved COMMON */
|
||||
SAVED_F77_COMMON_PTR current_common = NULL; /* Ptr to current COMMON */
|
||||
|
||||
#if 0
|
||||
static SAVED_BF_PTR saved_bf_list = NULL; /* Ptr to (.bf,function)
|
||||
list */
|
||||
static SAVED_BF_PTR saved_bf_list_end = NULL; /* Ptr to above list's end */
|
||||
static SAVED_BF_PTR current_head_bf_list = NULL; /* Current head of
|
||||
above list. */
|
||||
|
||||
static SAVED_BF_PTR tmp_bf_ptr; /* Generic temporary for use
|
||||
in macros. */
|
||||
|
||||
/* The following function simply enters a given common block onto
|
||||
the global common block chain. */
|
||||
|
||||
static void
|
||||
add_common_block (char *name, CORE_ADDR offset, int secnum, char *func_stab)
|
||||
{
|
||||
SAVED_F77_COMMON_PTR tmp;
|
||||
char *c, *local_copy_func_stab;
|
||||
|
||||
/* If the COMMON block we are trying to add has a blank
|
||||
name (i.e. "#BLNK_COM") then we set it to __BLANK
|
||||
because the darn "#" character makes GDB's input
|
||||
parser have fits. */
|
||||
|
||||
|
||||
if (strcmp (name, BLANK_COMMON_NAME_ORIGINAL) == 0
|
||||
|| strcmp (name, BLANK_COMMON_NAME_MF77) == 0)
|
||||
{
|
||||
|
||||
xfree (name);
|
||||
name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1);
|
||||
strcpy (name, BLANK_COMMON_NAME_LOCAL);
|
||||
}
|
||||
|
||||
tmp = allocate_saved_f77_common_node ();
|
||||
|
||||
local_copy_func_stab = xmalloc (strlen (func_stab) + 1);
|
||||
strcpy (local_copy_func_stab, func_stab);
|
||||
|
||||
tmp->name = xmalloc (strlen (name) + 1);
|
||||
|
||||
/* local_copy_func_stab is a stabstring, let us first extract the
|
||||
function name from the stab by NULLing out the ':' character. */
|
||||
|
||||
|
||||
c = NULL;
|
||||
c = strchr (local_copy_func_stab, ':');
|
||||
|
||||
if (c)
|
||||
*c = '\0';
|
||||
else
|
||||
error (_("Malformed function STAB found in add_common_block()"));
|
||||
|
||||
|
||||
tmp->owning_function = xmalloc (strlen (local_copy_func_stab) + 1);
|
||||
|
||||
strcpy (tmp->owning_function, local_copy_func_stab);
|
||||
|
||||
strcpy (tmp->name, name);
|
||||
tmp->offset = offset;
|
||||
tmp->next = NULL;
|
||||
tmp->entries = NULL;
|
||||
tmp->secnum = secnum;
|
||||
|
||||
current_common = tmp;
|
||||
|
||||
if (head_common_list == NULL)
|
||||
{
|
||||
head_common_list = tail_common_list = tmp;
|
||||
}
|
||||
else
|
||||
{
|
||||
tail_common_list->next = tmp;
|
||||
tail_common_list = tmp;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* The following function simply enters a given common entry onto
|
||||
the "current_common" block that has been saved away. */
|
||||
|
||||
#if 0
|
||||
static void
|
||||
add_common_entry (struct symbol *entry_sym_ptr)
|
||||
{
|
||||
COMMON_ENTRY_PTR tmp;
|
||||
|
||||
|
||||
|
||||
/* The order of this list is important, since
|
||||
we expect the entries to appear in decl.
|
||||
order when we later issue "info common" calls. */
|
||||
|
||||
tmp = allocate_common_entry_node ();
|
||||
|
||||
tmp->next = NULL;
|
||||
tmp->symbol = entry_sym_ptr;
|
||||
|
||||
if (current_common == NULL)
|
||||
error (_("Attempt to add COMMON entry with no block open!"));
|
||||
else
|
||||
{
|
||||
if (current_common->entries == NULL)
|
||||
{
|
||||
current_common->entries = tmp;
|
||||
current_common->end_of_entries = tmp;
|
||||
}
|
||||
else
|
||||
{
|
||||
current_common->end_of_entries->next = tmp;
|
||||
current_common->end_of_entries = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This routine finds the first encountred COMMON block named "name". */
|
||||
|
||||
#if 0
|
||||
static SAVED_F77_COMMON_PTR
|
||||
find_first_common_named (char *name)
|
||||
{
|
||||
|
||||
SAVED_F77_COMMON_PTR tmp;
|
||||
|
||||
tmp = head_common_list;
|
||||
|
||||
while (tmp != NULL)
|
||||
{
|
||||
if (strcmp (tmp->name, name) == 0)
|
||||
return (tmp);
|
||||
else
|
||||
tmp = tmp->next;
|
||||
}
|
||||
return (NULL);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This routine finds the first encountred COMMON block named "name"
|
||||
that belongs to function funcname. */
|
||||
|
@ -585,193 +373,3 @@ find_common_for_function (const char *name, const char *funcname)
|
|||
}
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
/* The following function is called to patch up the offsets
|
||||
for the statics contained in the COMMON block named
|
||||
"name." */
|
||||
|
||||
static void
|
||||
patch_common_entries (SAVED_F77_COMMON_PTR blk, CORE_ADDR offset, int secnum)
|
||||
{
|
||||
COMMON_ENTRY_PTR entry;
|
||||
|
||||
blk->offset = offset; /* Keep this around for future use. */
|
||||
|
||||
entry = blk->entries;
|
||||
|
||||
while (entry != NULL)
|
||||
{
|
||||
SYMBOL_VALUE (entry->symbol) += offset;
|
||||
SYMBOL_SECTION (entry->symbol) = secnum;
|
||||
|
||||
entry = entry->next;
|
||||
}
|
||||
blk->secnum = secnum;
|
||||
}
|
||||
|
||||
/* Patch all commons named "name" that need patching.Since COMMON
|
||||
blocks occur with relative infrequency, we simply do a linear scan on
|
||||
the name. Eventually, the best way to do this will be a
|
||||
hashed-lookup. Secnum is the section number for the .bss section
|
||||
(which is where common data lives). */
|
||||
|
||||
static void
|
||||
patch_all_commons_by_name (char *name, CORE_ADDR offset, int secnum)
|
||||
{
|
||||
|
||||
SAVED_F77_COMMON_PTR tmp;
|
||||
|
||||
/* For blank common blocks, change the canonical reprsentation
|
||||
of a blank name */
|
||||
|
||||
if (strcmp (name, BLANK_COMMON_NAME_ORIGINAL) == 0
|
||||
|| strcmp (name, BLANK_COMMON_NAME_MF77) == 0)
|
||||
{
|
||||
xfree (name);
|
||||
name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1);
|
||||
strcpy (name, BLANK_COMMON_NAME_LOCAL);
|
||||
}
|
||||
|
||||
tmp = head_common_list;
|
||||
|
||||
while (tmp != NULL)
|
||||
{
|
||||
if (COMMON_NEEDS_PATCHING (tmp))
|
||||
if (strcmp (tmp->name, name) == 0)
|
||||
patch_common_entries (tmp, offset, secnum);
|
||||
|
||||
tmp = tmp->next;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This macro adds the symbol-number for the start of the function
|
||||
(the symbol number of the .bf) referenced by symnum_fcn to a
|
||||
list. This list, in reality should be a FIFO queue but since
|
||||
#line pragmas sometimes cause line ranges to get messed up
|
||||
we simply create a linear list. This list can then be searched
|
||||
first by a queueing algorithm and upon failure fall back to
|
||||
a linear scan. */
|
||||
|
||||
#if 0
|
||||
#define ADD_BF_SYMNUM(bf_sym,fcn_sym) \
|
||||
\
|
||||
if (saved_bf_list == NULL) \
|
||||
{ \
|
||||
tmp_bf_ptr = allocate_saved_bf_node(); \
|
||||
\
|
||||
tmp_bf_ptr->symnum_bf = (bf_sym); \
|
||||
tmp_bf_ptr->symnum_fcn = (fcn_sym); \
|
||||
tmp_bf_ptr->next = NULL; \
|
||||
\
|
||||
current_head_bf_list = saved_bf_list = tmp_bf_ptr; \
|
||||
saved_bf_list_end = tmp_bf_ptr; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
tmp_bf_ptr = allocate_saved_bf_node(); \
|
||||
\
|
||||
tmp_bf_ptr->symnum_bf = (bf_sym); \
|
||||
tmp_bf_ptr->symnum_fcn = (fcn_sym); \
|
||||
tmp_bf_ptr->next = NULL; \
|
||||
\
|
||||
saved_bf_list_end->next = tmp_bf_ptr; \
|
||||
saved_bf_list_end = tmp_bf_ptr; \
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This function frees the entire (.bf,function) list. */
|
||||
|
||||
#if 0
|
||||
static void
|
||||
clear_bf_list (void)
|
||||
{
|
||||
|
||||
SAVED_BF_PTR tmp = saved_bf_list;
|
||||
SAVED_BF_PTR next = NULL;
|
||||
|
||||
while (tmp != NULL)
|
||||
{
|
||||
next = tmp->next;
|
||||
xfree (tmp);
|
||||
tmp = next;
|
||||
}
|
||||
saved_bf_list = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
int global_remote_debug;
|
||||
|
||||
#if 0
|
||||
|
||||
static long
|
||||
get_bf_for_fcn (long the_function)
|
||||
{
|
||||
SAVED_BF_PTR tmp;
|
||||
int nprobes = 0;
|
||||
|
||||
/* First use a simple queuing algorithm (i.e. look and see if the
|
||||
item at the head of the queue is the one you want). */
|
||||
|
||||
if (saved_bf_list == NULL)
|
||||
internal_error (__FILE__, __LINE__,
|
||||
_("cannot get .bf node off empty list"));
|
||||
|
||||
if (current_head_bf_list != NULL)
|
||||
if (current_head_bf_list->symnum_fcn == the_function)
|
||||
{
|
||||
if (global_remote_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "*");
|
||||
|
||||
tmp = current_head_bf_list;
|
||||
current_head_bf_list = current_head_bf_list->next;
|
||||
return (tmp->symnum_bf);
|
||||
}
|
||||
|
||||
/* If the above did not work (probably because #line directives were
|
||||
used in the sourcefile and they messed up our internal tables) we now do
|
||||
the ugly linear scan. */
|
||||
|
||||
if (global_remote_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "\ndefaulting to linear scan\n");
|
||||
|
||||
nprobes = 0;
|
||||
tmp = saved_bf_list;
|
||||
while (tmp != NULL)
|
||||
{
|
||||
nprobes++;
|
||||
if (tmp->symnum_fcn == the_function)
|
||||
{
|
||||
if (global_remote_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Found in %d probes\n", nprobes);
|
||||
current_head_bf_list = tmp->next;
|
||||
return (tmp->symnum_bf);
|
||||
}
|
||||
tmp = tmp->next;
|
||||
}
|
||||
|
||||
return (-1);
|
||||
}
|
||||
|
||||
static SAVED_FUNCTION_PTR saved_function_list = NULL;
|
||||
static SAVED_FUNCTION_PTR saved_function_list_end = NULL;
|
||||
|
||||
static void
|
||||
clear_function_list (void)
|
||||
{
|
||||
SAVED_FUNCTION_PTR tmp = saved_function_list;
|
||||
SAVED_FUNCTION_PTR next = NULL;
|
||||
|
||||
while (tmp != NULL)
|
||||
{
|
||||
next = tmp->next;
|
||||
xfree (tmp);
|
||||
tmp = next;
|
||||
}
|
||||
|
||||
saved_function_list = NULL;
|
||||
}
|
||||
#endif
|
||||
|
|
18
gdb/f-lang.h
18
gdb/f-lang.h
|
@ -72,30 +72,12 @@ typedef struct saved_f77_common SAVED_F77_COMMON, *SAVED_F77_COMMON_PTR;
|
|||
typedef struct common_entry COMMON_ENTRY, *COMMON_ENTRY_PTR;
|
||||
|
||||
extern SAVED_F77_COMMON_PTR head_common_list; /* Ptr to 1st saved COMMON */
|
||||
extern SAVED_F77_COMMON_PTR tail_common_list; /* Ptr to last saved COMMON */
|
||||
extern SAVED_F77_COMMON_PTR current_common; /* Ptr to current COMMON */
|
||||
|
||||
extern SAVED_F77_COMMON_PTR find_common_for_function (const char *,
|
||||
const char *);
|
||||
|
||||
#define UNINITIALIZED_SECNUM -1
|
||||
#define COMMON_NEEDS_PATCHING(blk) ((blk)->secnum == UNINITIALIZED_SECNUM)
|
||||
|
||||
#define BLANK_COMMON_NAME_ORIGINAL "#BLNK_COM" /* XLF assigned */
|
||||
#define BLANK_COMMON_NAME_MF77 "__BLNK__" /* MF77 assigned */
|
||||
#define BLANK_COMMON_NAME_LOCAL "__BLANK" /* Local GDB */
|
||||
|
||||
/* When reasonable array bounds cannot be fetched, such as when
|
||||
you ask to 'mt print symbols' and there is no stack frame and
|
||||
therefore no way of knowing the bounds of stack-based arrays,
|
||||
we have to assign default bounds, these are as good as any... */
|
||||
|
||||
#define DEFAULT_UPPER_BOUND 999999
|
||||
#define DEFAULT_LOWER_BOUND -999999
|
||||
|
||||
extern char *real_main_name; /* Name of main function. */
|
||||
extern int real_main_c_value; /* C_value field of main function. */
|
||||
|
||||
extern int f77_get_upperbound (struct type *);
|
||||
|
||||
extern int f77_get_lowerbound (struct type *);
|
||||
|
|
|
@ -35,10 +35,6 @@
|
|||
#include "command.h"
|
||||
#include "block.h"
|
||||
|
||||
#if 0
|
||||
static int there_is_a_visible_common_named (char *);
|
||||
#endif
|
||||
|
||||
extern void _initialize_f_valprint (void);
|
||||
static void info_common_command (char *, int);
|
||||
static void list_all_visible_commons (const char *);
|
||||
|
@ -537,67 +533,6 @@ info_common_command (char *comname, int from_tty)
|
|||
comname, funname);
|
||||
}
|
||||
|
||||
/* This function is used to determine whether there is a
|
||||
F77 common block visible at the current scope called 'comname'. */
|
||||
|
||||
#if 0
|
||||
static int
|
||||
there_is_a_visible_common_named (char *comname)
|
||||
{
|
||||
SAVED_F77_COMMON_PTR the_common;
|
||||
struct frame_info *fi;
|
||||
char *funname = 0;
|
||||
struct symbol *func;
|
||||
|
||||
if (comname == NULL)
|
||||
error (_("Cannot deal with NULL common name!"));
|
||||
|
||||
fi = get_selected_frame (_("No frame selected"));
|
||||
|
||||
/* The following is generally ripped off from stack.c's routine
|
||||
print_frame_info(). */
|
||||
|
||||
func = find_pc_function (fi->pc);
|
||||
if (func)
|
||||
{
|
||||
/* In certain pathological cases, the symtabs give the wrong
|
||||
function (when we are in the first function in a file which
|
||||
is compiled without debugging symbols, the previous function
|
||||
is compiled with debugging symbols, and the "foo.o" symbol
|
||||
that is supposed to tell us where the file with debugging symbols
|
||||
ends has been truncated by ar because it is longer than 15
|
||||
characters).
|
||||
|
||||
So look in the minimal symbol tables as well, and if it comes
|
||||
up with a larger address for the function use that instead.
|
||||
I don't think this can ever cause any problems; there shouldn't
|
||||
be any minimal symbols in the middle of a function.
|
||||
FIXME: (Not necessarily true. What about text labels?) */
|
||||
|
||||
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
|
||||
|
||||
if (msymbol != NULL
|
||||
&& (SYMBOL_VALUE_ADDRESS (msymbol)
|
||||
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
|
||||
funname = SYMBOL_LINKAGE_NAME (msymbol);
|
||||
else
|
||||
funname = SYMBOL_LINKAGE_NAME (func);
|
||||
}
|
||||
else
|
||||
{
|
||||
struct minimal_symbol *msymbol =
|
||||
lookup_minimal_symbol_by_pc (fi->pc);
|
||||
|
||||
if (msymbol != NULL)
|
||||
funname = SYMBOL_LINKAGE_NAME (msymbol);
|
||||
}
|
||||
|
||||
the_common = find_common_for_function (comname, funname);
|
||||
|
||||
return (the_common ? 1 : 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
_initialize_f_valprint (void)
|
||||
{
|
||||
|
|
Loading…
Reference in New Issue