+2003-07-06 Andreas Jaeger <aj@suse.de>
+
+ * gcc.c: Convert prototypes to ISO C90.
+ * gcc.h: Likewise.
+ * gcov-dump.c: Likewise.
+ * gcov-iov.c: Likewise.
+ * gcse.c: Likewise.
+ * genattrtab.h: Likewise.
+ * ggc.h: Likewise.
+ * global.c: Likewise.
+ * graph.c: Likewise.
+ * graph.h: Likewise.
+ * hosthooks.h: Likewise.
+ * hooks.h: Likewise.
+ * hooks.c: Likewise.
+ * hashtable.h: Likewise.
+ * hashtable.c: Likewise.
+ * haifa-sched.c: Likewise.
+ * integrate.h: Likewise.
+ * integrate.c: Likewise.
+ * input.h: Likewise.
+ * ifcvt.c: Likewise.
+
2003-07-05 Kazu Hirata <kazu@cs.umass.edu>
* combine.c (nonzero_bits1): Fix a warning.
#include <sys/resource.h>
#endif
#if defined (HAVE_DECL_GETRUSAGE) && !HAVE_DECL_GETRUSAGE
-extern int getrusage PARAMS ((int, struct rusage *));
+extern int getrusage (int, struct rusage *);
#endif
/* By default there is no special suffix for target executables. */
/* Forward declaration for prototypes. */
struct path_prefix;
-static void init_spec PARAMS ((void));
-static void store_arg PARAMS ((const char *, int, int));
-static char *load_specs PARAMS ((const char *));
-static void read_specs PARAMS ((const char *, int));
-static void set_spec PARAMS ((const char *, const char *));
-static struct compiler *lookup_compiler PARAMS ((const char *, size_t, const char *));
-static char *build_search_list PARAMS ((struct path_prefix *, const char *, int));
-static void putenv_from_prefixes PARAMS ((struct path_prefix *, const char *));
-static int access_check PARAMS ((const char *, int));
-static char *find_a_file PARAMS ((struct path_prefix *, const char *,
- int, int));
-static void add_prefix PARAMS ((struct path_prefix *, const char *,
- const char *, int, int, int *, int));
-static void add_sysrooted_prefix PARAMS ((struct path_prefix *, const char *,
- const char *, int, int, int *, int));
-static void translate_options PARAMS ((int *, const char *const **));
-static char *skip_whitespace PARAMS ((char *));
-static void delete_if_ordinary PARAMS ((const char *));
-static void delete_temp_files PARAMS ((void));
-static void delete_failure_queue PARAMS ((void));
-static void clear_failure_queue PARAMS ((void));
-static int check_live_switch PARAMS ((int, int));
-static const char *handle_braces PARAMS ((const char *));
-static inline bool input_suffix_matches PARAMS ((const char *,
- const char *));
-static inline bool switch_matches PARAMS ((const char *,
- const char *, int));
-static inline void mark_matching_switches PARAMS ((const char *,
- const char *, int));
-static inline void process_marked_switches PARAMS ((void));
-static const char *process_brace_body PARAMS ((const char *, const char *,
- const char *, int, int));
-static const struct spec_function *lookup_spec_function PARAMS ((const char *));
-static const char *eval_spec_function PARAMS ((const char *, const char *));
-static const char *handle_spec_function PARAMS ((const char *));
-static char *save_string PARAMS ((const char *, int));
-static void set_collect_gcc_options PARAMS ((void));
-static int do_spec_1 PARAMS ((const char *, int, const char *));
-static int do_spec_2 PARAMS ((const char *));
-static void do_option_spec PARAMS ((const char *, const char *));
-static void do_self_spec PARAMS ((const char *));
-static const char *find_file PARAMS ((const char *));
-static int is_directory PARAMS ((const char *, const char *, int));
-static const char *validate_switches PARAMS ((const char *));
-static void validate_all_switches PARAMS ((void));
-static inline void validate_switches_from_spec PARAMS ((const char *));
-static void give_switch PARAMS ((int, int));
-static int used_arg PARAMS ((const char *, int));
-static int default_arg PARAMS ((const char *, int));
-static void set_multilib_dir PARAMS ((void));
-static void print_multilib_info PARAMS ((void));
-static void perror_with_name PARAMS ((const char *));
-static void pfatal_pexecute PARAMS ((const char *, const char *))
- ATTRIBUTE_NORETURN;
-static void notice PARAMS ((const char *, ...))
- ATTRIBUTE_PRINTF_1;
-static void display_help PARAMS ((void));
-static void add_preprocessor_option PARAMS ((const char *, int));
-static void add_assembler_option PARAMS ((const char *, int));
-static void add_linker_option PARAMS ((const char *, int));
-static void process_command PARAMS ((int, const char *const *));
-static int execute PARAMS ((void));
-static void alloc_args PARAMS ((void));
-static void clear_args PARAMS ((void));
-static void fatal_error PARAMS ((int));
+static void init_spec (void);
+static void store_arg (const char *, int, int);
+static char *load_specs (const char *);
+static void read_specs (const char *, int);
+static void set_spec (const char *, const char *);
+static struct compiler *lookup_compiler (const char *, size_t, const char *);
+static char *build_search_list (struct path_prefix *, const char *, int);
+static void putenv_from_prefixes (struct path_prefix *, const char *);
+static int access_check (const char *, int);
+static char *find_a_file (struct path_prefix *, const char *, int, int);
+static void add_prefix (struct path_prefix *, const char *, const char *,
+ int, int, int *, int);
+static void add_sysrooted_prefix (struct path_prefix *, const char *,
+ const char *, int, int, int *, int);
+static void translate_options (int *, const char *const **);
+static char *skip_whitespace (char *);
+static void delete_if_ordinary (const char *);
+static void delete_temp_files (void);
+static void delete_failure_queue (void);
+static void clear_failure_queue (void);
+static int check_live_switch (int, int);
+static const char *handle_braces (const char *);
+static inline bool input_suffix_matches (const char *, const char *);
+static inline bool switch_matches (const char *, const char *, int);
+static inline void mark_matching_switches (const char *, const char *, int);
+static inline void process_marked_switches (void);
+static const char *process_brace_body (const char *, const char *, const char *, int, int);
+static const struct spec_function *lookup_spec_function (const char *);
+static const char *eval_spec_function (const char *, const char *);
+static const char *handle_spec_function (const char *);
+static char *save_string (const char *, int);
+static void set_collect_gcc_options (void);
+static int do_spec_1 (const char *, int, const char *);
+static int do_spec_2 (const char *);
+static void do_option_spec (const char *, const char *);
+static void do_self_spec (const char *);
+static const char *find_file (const char *);
+static int is_directory (const char *, const char *, int);
+static const char *validate_switches (const char *);
+static void validate_all_switches (void);
+static inline void validate_switches_from_spec (const char *);
+static void give_switch (int, int);
+static int used_arg (const char *, int);
+static int default_arg (const char *, int);
+static void set_multilib_dir (void);
+static void print_multilib_info (void);
+static void perror_with_name (const char *);
+static void pfatal_pexecute (const char *, const char *) ATTRIBUTE_NORETURN;
+static void notice (const char *, ...) ATTRIBUTE_PRINTF_1;
+static void display_help (void);
+static void add_preprocessor_option (const char *, int);
+static void add_assembler_option (const char *, int);
+static void add_linker_option (const char *, int);
+static void process_command (int, const char *const *);
+static int execute (void);
+static void alloc_args (void);
+static void clear_args (void);
+static void fatal_error (int);
#ifdef ENABLE_SHARED_LIBGCC
-static void init_gcc_specs PARAMS ((struct obstack *,
- const char *, const char *,
- const char *));
+static void init_gcc_specs (struct obstack *, const char *, const char *,
+ const char *);
#endif
#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
-static const char *convert_filename PARAMS ((const char *, int, int));
+static const char *convert_filename (const char *, int, int);
#endif
-static const char *if_exists_spec_function PARAMS ((int, const char **));
-static const char *if_exists_else_spec_function PARAMS ((int, const char **));
+static const char *if_exists_spec_function (int, const char **);
+static const char *if_exists_else_spec_function (int, const char **);
\f
/* The Specs Language
name starts with `o'. %{o*} would substitute this text,
including the space; thus, two arguments would be generated.
%{S*&T*} likewise, but preserve order of S and T options (the order
- of S and T in the spec is not significant). Can be any number
- of ampersand-separated variables; for each the wild card is
- optional. Useful for CPP as %{D*&U*&A*}.
+ of S and T in the spec is not significant). Can be any number
+ of ampersand-separated variables; for each the wild card is
+ optional. Useful for CPP as %{D*&U*&A*}.
%{S:X} substitutes X, if the -S switch was given to CC.
%{!S:X} substitutes X, if the -S switch was NOT given to CC.
as %(asm_debug) %(asm_options) %m.s %A }}}}"
#endif
, 0},
-
+
#include "specs.h"
/* Mark end of table. */
{0, 0, 0}
and store its length in *ARGVC. */
static void
-translate_options (argcp, argvp)
- int *argcp;
- const char *const **argvp;
+translate_options (int *argcp, const char *const **argvp)
{
int i;
int argc = *argcp;
}
\f
static char *
-skip_whitespace (p)
- char *p;
+skip_whitespace (char *p)
{
while (1)
{
#ifdef ENABLE_SHARED_LIBGCC
static void
-init_gcc_specs (obstack, shared_name, static_name, eh_name)
- struct obstack *obstack;
- const char *shared_name;
- const char *static_name;
- const char *eh_name;
+init_gcc_specs (struct obstack *obstack, const char *shared_name,
+ const char *static_name, const char *eh_name)
{
char *buf;
current spec. */
static void
-set_spec (name, spec)
- const char *name;
- const char *spec;
+set_spec (const char *name, const char *spec)
{
struct spec_list *sl;
const char *old_spec;
/* Clear out the vector of arguments (after a command is executed). */
static void
-clear_args ()
+clear_args (void)
{
argbuf_index = 0;
}
and the file should be deleted if this compilation fails. */
static void
-store_arg (arg, delete_always, delete_failure)
- const char *arg;
- int delete_always, delete_failure;
+store_arg (const char *arg, int delete_always, int delete_failure)
{
if (argbuf_index + 1 == argbuf_length)
argbuf
a single \n. */
static char *
-load_specs (filename)
- const char *filename;
+load_specs (const char *filename)
{
int desc;
int readlen;
Anything invalid in the file is a fatal error. */
static void
-read_specs (filename, main_p)
- const char *filename;
- int main_p;
+read_specs (const char *filename, int main_p)
{
char *buffer;
char *p;
otherwise delete it in any case. */
void
-record_temp_file (filename, always_delete, fail_delete)
- const char *filename;
- int always_delete;
- int fail_delete;
+record_temp_file (const char *filename, int always_delete, int fail_delete)
{
char *const name = xstrdup (filename);
/* Delete all the temporary files whose names we previously recorded. */
static void
-delete_if_ordinary (name)
- const char *name;
+delete_if_ordinary (const char *name)
{
struct stat st;
#ifdef DEBUG
}
static void
-delete_temp_files ()
+delete_temp_files (void)
{
struct temp_file *temp;
/* Delete all the files to be deleted on error. */
static void
-delete_failure_queue ()
+delete_failure_queue (void)
{
struct temp_file *temp;
}
static void
-clear_failure_queue ()
+clear_failure_queue (void)
{
failure_delete_queue = 0;
}
It is also used by the --print-search-dirs flag. */
static char *
-build_search_list (paths, prefix, check_dir_p)
- struct path_prefix *paths;
- const char *prefix;
- int check_dir_p;
+build_search_list (struct path_prefix *paths, const char *prefix,
+ int check_dir_p)
{
int suffix_len = (machine_suffix) ? strlen (machine_suffix) : 0;
int just_suffix_len
for collect. */
static void
-putenv_from_prefixes (paths, env_var)
- struct path_prefix *paths;
- const char *env_var;
+putenv_from_prefixes (struct path_prefix *paths, const char *env_var)
{
putenv (build_search_list (paths, env_var, 1));
}
except that it never considers directories to be executable. */
static int
-access_check (name, mode)
- const char *name;
- int mode;
+access_check (const char *name, int mode)
{
if (mode == X_OK)
{
Return 0 if not found, otherwise return its name, allocated with malloc. */
static char *
-find_a_file (pprefix, name, mode, multilib)
- struct path_prefix *pprefix;
- const char *name;
- int mode, multilib;
+find_a_file (struct path_prefix *pprefix, const char *name, int mode,
+ int multilib)
{
char *temp;
const char *const file_suffix =
2 means try both machine_suffix and just_machine_suffix. */
static void
-add_prefix (pprefix, prefix, component, priority, require_machine_suffix,
- warn, os_multilib)
- struct path_prefix *pprefix;
- const char *prefix;
- const char *component;
- /* enum prefix_priority */ int priority;
- int require_machine_suffix;
- int *warn;
- int os_multilib;
+add_prefix (struct path_prefix *pprefix, const char *prefix,
+ const char *component, /* enum prefix_priority */ int priority,
+ int require_machine_suffix, int *warn, int os_multilib)
{
struct prefix_list *pl, **prev;
int len;
/* Same as add_prefix, but prepending target_system_root to prefix. */
static void
-add_sysrooted_prefix (pprefix, prefix, component, priority,
- require_machine_suffix, warn, os_multilib)
- struct path_prefix *pprefix;
- const char *prefix;
- const char *component;
- /* enum prefix_priority */ int priority;
- int require_machine_suffix;
- int *warn;
- int os_multilib;
+add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
+ const char *component,
+ /* enum prefix_priority */ int priority,
+ int require_machine_suffix, int *warn, int os_multilib)
{
if (!IS_ABSOLUTE_PATH (prefix))
abort ();
Return 0 if successful, -1 if failed. */
static int
-execute ()
+execute (void)
{
int i;
int n_commands; /* # of command. */
is true if we should look for an object suffix. */
static const char *
-convert_filename (name, do_exe, do_obj)
- const char *name;
- int do_exe ATTRIBUTE_UNUSED;
- int do_obj ATTRIBUTE_UNUSED;
+convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
+ int do_obj ATTRIBUTE_UNUSED)
{
#if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
int i;
\f
/* Display the command line switches accepted by gcc. */
static void
-display_help ()
+display_help (void)
{
printf (_("Usage: %s [options] file...\n"), programname);
fputs (_("Options:\n"), stdout);
}
static void
-add_preprocessor_option (option, len)
- const char *option;
- int len;
+add_preprocessor_option (const char *option, int len)
{
n_preprocessor_options++;
}
static void
-add_assembler_option (option, len)
- const char *option;
- int len;
+add_assembler_option (const char *option, int len)
{
n_assembler_options++;
}
static void
-add_linker_option (option, len)
- const char *option;
- int len;
+add_linker_option (const char *option, int len)
{
n_linker_options++;
Store its length in `n_switches'. */
static void
-process_command (argc, argv)
- int argc;
- const char *const *argv;
+process_command (int argc, const char *const *argv)
{
int i;
const char *temp;
char **new_argv;
char *new_argv0;
int baselen;
-
+
while (argc > 1 && argv[1][0] == '-'
&& (argv[1][1] == 'V' || argv[1][1] == 'b'))
{
for (baselen = strlen (progname); baselen > 0; baselen--)
if (IS_DIR_SEPARATOR (progname[baselen-1]))
break;
- new_argv0 = xmemdup (progname, baselen,
+ new_argv0 = xmemdup (progname, baselen,
baselen + concat_length (new_version, new_machine,
"-gcc-", NULL) + 1);
strcpy (new_argv0 + baselen, new_machine);
use_pipes = 0;
}
-
+
/* Set up the search paths before we go looking for config files. */
/* These come before the md prefixes so that we will find gcc's subcommands
and place that in the environment. */
static void
-set_collect_gcc_options ()
+set_collect_gcc_options (void)
{
int i;
int first_time;
Returns 0 if the spec is successfully processed; -1 if failed. */
int
-do_spec (spec)
- const char *spec;
+do_spec (const char *spec)
{
int value;
}
static int
-do_spec_2 (spec)
- const char *spec;
+do_spec_2 (const char *spec)
{
const char *string;
int result;
of the switches/n_switches array. */
static void
-do_option_spec (name, spec)
- const char *name;
- const char *spec;
+do_option_spec (const char *name, const char *spec)
{
unsigned int i, value_count, value_len;
const char *p, *q, *value;
of the switches/n_switches array. */
static void
-do_self_spec (spec)
- const char *spec;
+do_self_spec (const char *spec)
{
do_spec_2 (spec);
do_spec_1 (" ", 0, NULL);
and the command on that line reported an error. */
static int
-do_spec_1 (spec, inswitch, soft_matched_part)
- const char *spec;
- int inswitch;
- const char *soft_matched_part;
+do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
{
const char *p = spec;
int c;
p++;
if (p[0] == '%' && p[1] == 'O')
p += 2;
-
+
break;
}
goto create_temp_file;
p++;
if (p[0] == '%' && p[1] == 'O')
p += 2;
-
+
break;
}
goto create_temp_file;
temp_filename = alloca (temp_filename_length + 1);
strncpy ((char *) temp_filename, input_basename, basename_length);
strncpy ((char *) temp_filename + basename_length, suffix,
- suffix_length);
+ suffix_length);
*((char *) temp_filename + temp_filename_length) = '\0';
if (strcmp (temp_filename, input_filename) != 0)
{
- struct stat st_temp;
+ struct stat st_temp;
- /* Note, set_input() resets input_stat_set to 0. */
- if (input_stat_set == 0)
- {
- input_stat_set = stat (input_filename, &input_stat);
- if (input_stat_set >= 0)
- input_stat_set = 1;
- }
+ /* Note, set_input() resets input_stat_set to 0. */
+ if (input_stat_set == 0)
+ {
+ input_stat_set = stat (input_filename, &input_stat);
+ if (input_stat_set >= 0)
+ input_stat_set = 1;
+ }
- /* If we have the stat for the input_filename
- and we can do the stat for the temp_filename
- then the they could still refer to the same
- file if st_dev/st_ino's are the same. */
+ /* If we have the stat for the input_filename
+ and we can do the stat for the temp_filename
+ then the they could still refer to the same
+ file if st_dev/st_ino's are the same. */
if (input_stat_set != 1
|| stat (temp_filename, &st_temp) < 0
temp_filename = save_string (temp_filename,
temp_filename_length + 1);
obstack_grow (&obstack, temp_filename,
- temp_filename_length);
+ temp_filename_length);
arg_going = 1;
delete_this_arg = 0;
break;
/* We assume there is a directory
separator at the end of this string. */
if (target_system_root)
- {
- obstack_grow (&obstack, target_system_root,
+ {
+ obstack_grow (&obstack, target_system_root,
strlen (target_system_root));
if (target_sysroot_suffix)
- obstack_grow (&obstack, target_sysroot_suffix,
+ obstack_grow (&obstack, target_sysroot_suffix,
strlen (target_sysroot_suffix));
}
break;
/* Look up a spec function. */
static const struct spec_function *
-lookup_spec_function (name)
- const char *name;
+lookup_spec_function (const char *name)
{
static const struct spec_function * const spec_function_tables[] =
{
/* Evaluate a spec function. */
static const char *
-eval_spec_function (func, args)
- const char *func, *args;
+eval_spec_function (const char *func, const char *args)
{
const struct spec_function *sf;
const char *funcval;
NULL if no processing is required. */
static const char *
-handle_spec_function (p)
- const char *p;
+handle_spec_function (const char *p)
{
char *func, *args;
const char *endp, *funcval;
/* Inline subroutine of handle_braces. Returns true if the current
input suffix matches the atom bracketed by ATOM and END_ATOM. */
static inline bool
-input_suffix_matches (atom, end_atom)
- const char *atom;
- const char *end_atom;
+input_suffix_matches (const char *atom, const char *end_atom)
{
return (input_suffix
&& !strncmp (input_suffix, atom, end_atom - atom)
matching the atom bracketed by ATOM and END_ATOM appeared on the
command line. */
static inline bool
-switch_matches (atom, end_atom, starred)
- const char *atom;
- const char *end_atom;
- int starred;
+switch_matches (const char *atom, const char *end_atom, int starred)
{
int i;
int len = end_atom - atom;
match ATOM (extends to END_ATOM; STARRED indicates whether there
was a star after the atom) for later processing. */
static inline void
-mark_matching_switches (atom, end_atom, starred)
- const char *atom;
- const char *end_atom;
- int starred;
+mark_matching_switches (const char *atom, const char *end_atom, int starred)
{
int i;
int len = end_atom - atom;
/* Inline subroutine of handle_braces. Process all the currently
marked switches through give_switch, and clear the marks. */
static inline void
-process_marked_switches ()
+process_marked_switches (void)
{
int i;
if we call do_spec_1 and that returns -1. */
static const char *
-handle_braces (p)
- const char *p;
+handle_braces (const char *p)
{
const char *atom, *end_atom;
const char *d_atom = NULL, *d_end_atom = NULL;
returns -1. */
static const char *
-process_brace_body (p, atom, end_atom, starred, matched)
- const char *p;
- const char *atom;
- const char *end_atom;
- int starred;
- int matched;
+process_brace_body (const char *p, const char *atom, const char *end_atom,
+ int starred, int matched)
{
const char *body, *end_body;
unsigned int nesting_level;
abort ();
p++;
}
-
+
end_body = p;
while (end_body[-1] == ' ' || end_body[-1] == '\t')
end_body--;
with the "no-", similarly for a switch with the "no-" prefix. */
static int
-check_live_switch (switchnum, prefix_length)
- int switchnum;
- int prefix_length;
+check_live_switch (int switchnum, int prefix_length)
{
const char *name = switches[switchnum].part1;
int i;
If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument. */
static void
-give_switch (switchnum, omit_first_word)
- int switchnum;
- int omit_first_word;
+give_switch (int switchnum, int omit_first_word)
{
if (switches[switchnum].live_cond == SWITCH_IGNORE)
return;
Return the absolute file name found. If nothing is found, return NAME. */
static const char *
-find_file (name)
- const char *name;
+find_file (const char *name)
{
char *newname;
limit. */
static int
-is_directory (path1, path2, linker)
- const char *path1;
- const char *path2;
- int linker;
+is_directory (const char *path1, const char *path2, int linker)
{
int len1 = strlen (path1);
int len2 = strlen (path2);
the input file named FILENAME. */
void
-set_input (filename)
- const char *filename;
+set_input (const char *filename)
{
const char *p;
/* On fatal signals, delete all the temporary files. */
static void
-fatal_error (signum)
- int signum;
+fatal_error (int signum)
{
signal (signum, SIG_DFL);
delete_failure_queue ();
kill (getpid (), signum);
}
-extern int main PARAMS ((int, const char *const *));
+extern int main (int, const char *const *);
int
-main (argc, argv)
- int argc;
- const char *const *argv;
+main (int argc, const char *const *argv)
{
size_t i;
int value;
or 0 if this file is to be passed to the linker. */
static struct compiler *
-lookup_compiler (name, length, language)
- const char *name;
- size_t length;
- const char *language;
+lookup_compiler (const char *name, size_t length, const char *language)
{
struct compiler *cp;
}
\f
static char *
-save_string (s, len)
- const char *s;
- int len;
+save_string (const char *s, int len)
{
char *result = xmalloc (len + 1);
}
void
-pfatal_with_name (name)
- const char *name;
+pfatal_with_name (const char *name)
{
perror_with_name (name);
delete_temp_files ();
}
static void
-perror_with_name (name)
- const char *name;
+perror_with_name (const char *name)
{
error ("%s: %s", name, xstrerror (errno));
}
static void
-pfatal_pexecute (errmsg_fmt, errmsg_arg)
- const char *errmsg_fmt;
- const char *errmsg_arg;
+pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg)
{
if (errmsg_arg)
{
/* Output an error message and exit. */
void
-fancy_abort ()
+fancy_abort (void)
{
fatal ("internal gcc abort");
}
fatal (const char *msgid, ...)
{
va_list ap;
-
+
va_start (ap, msgid);
fprintf (stderr, "%s: ", programname);
error (const char *msgid, ...)
{
va_list ap;
-
+
va_start (ap, msgid);
fprintf (stderr, "%s: ", programname);
vfprintf (stderr, _(msgid), ap);
notice (const char *msgid, ...)
{
va_list ap;
-
+
va_start (ap, msgid);
vfprintf (stderr, _(msgid), ap);
va_end (ap);
}
\f
static inline void
-validate_switches_from_spec (spec)
- const char *spec;
+validate_switches_from_spec (const char *spec)
{
const char *p = spec;
char c;
}
static void
-validate_all_switches ()
+validate_all_switches (void)
{
struct compiler *comp;
struct spec_list *spec;
and mark as valid all supplied switches that match it. */
static const char *
-validate_switches (start)
- const char *start;
+validate_switches (const char *start)
{
const char *p = start;
const char *atom;
int i;
bool suffix = false;
bool starred = false;
-
+
#define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
-
+
next_member:
SKIP_WHITE ();
canonicalize the switches to keep only the ones we care about. */
static int
-used_arg (p, len)
- const char *p;
- int len;
+used_arg (const char *p, int len)
{
struct mswitchstr
{
}
static int
-default_arg (p, len)
- const char *p;
- int len;
+default_arg (const char *p, int len)
{
int i;
will be used. */
static void
-set_multilib_dir ()
+set_multilib_dir (void)
{
const char *p;
unsigned int this_path_len;
if (*start == '\0')
break;
-
+
for (end = start + 1;
*end != ' ' && *end != '\t' && *end != '\0'; end++)
;
the exclusions. */
static void
-print_multilib_info ()
+print_multilib_info (void)
{
const char *p = multilib_select;
const char *last_path = 0, *this_path;
(whose name has been expanded with %s). */
static const char *
-if_exists_spec_function (argc, argv)
- int argc;
- const char **argv;
+if_exists_spec_function (int argc, const char **argv)
{
/* Must have only one argument. */
if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
is returned if the first argument does not exist. */
static const char *
-if_exists_else_spec_function (argc, argv)
- int argc;
- const char **argv;
+if_exists_else_spec_function (int argc, const char **argv)
{
/* Must have exactly two arguments. */
if (argc != 2)
/* The mapping of a spec function name to the C function that
implements it. */
struct spec_function
-{
+{
const char *name;
- const char *(*func) PARAMS ((int, const char **));
+ const char *(*func) (int, const char **);
};
/* This defines which switch letters take arguments. */
/* These are exported by gcc.c. */
-extern int do_spec PARAMS ((const char *));
-extern void record_temp_file PARAMS ((const char *, int, int));
-extern void fancy_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
-extern void fatal PARAMS ((const char *, ...))
- ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
-extern void error PARAMS ((const char *, ...)) ATTRIBUTE_PRINTF_1;
-extern void pfatal_with_name PARAMS ((const char *)) ATTRIBUTE_NORETURN;
-extern void set_input PARAMS ((const char *));
+extern int do_spec (const char *);
+extern void record_temp_file (const char *, int, int);
+extern void fancy_abort (void) ATTRIBUTE_NORETURN;
+extern void fatal (const char *, ...) ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN;
+extern void error (const char *, ...) ATTRIBUTE_PRINTF_1;
+extern void pfatal_with_name (const char *) ATTRIBUTE_NORETURN;
+extern void set_input (const char *);
/* Spec files linked with gcc.c must provide definitions for these. */
/* Called before processing to change/add/remove arguments. */
-extern void lang_specific_driver PARAMS ((int *, const char *const **, int *));
+extern void lang_specific_driver (int *, const char *const **, int *);
/* Called before linking. Returns 0 on success and -1 on failure. */
-extern int lang_specific_pre_link PARAMS ((void));
+extern int lang_specific_pre_link (void);
extern int n_infiles;
/* Dump a gcov file, for debugging use.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003 Free Software Foundation, Inc.
Contributed by Nathan Sidwell <nathan@codesourcery.com>
Gcov is free software; you can redistribute it and/or modify
#include "gcov-io.h"
#include "gcov-io.c"
-static void dump_file PARAMS ((const char *));
-static void print_prefix PARAMS ((const char *, unsigned, gcov_position_t));
-static void print_usage PARAMS ((void));
-static void print_version PARAMS ((void));
-static void tag_function PARAMS ((const char *, unsigned, unsigned));
-static void tag_blocks PARAMS ((const char *, unsigned, unsigned));
-static void tag_arcs PARAMS ((const char *, unsigned, unsigned));
-static void tag_lines PARAMS ((const char *, unsigned, unsigned));
-static void tag_counters PARAMS ((const char *, unsigned, unsigned));
-static void tag_summary PARAMS ((const char *, unsigned, unsigned));
-extern int main PARAMS ((int, char **));
+static void dump_file (const char *);
+static void print_prefix (const char *, unsigned, gcov_position_t);
+static void print_usage (void);
+static void print_version (void);
+static void tag_function (const char *, unsigned, unsigned);
+static void tag_blocks (const char *, unsigned, unsigned);
+static void tag_arcs (const char *, unsigned, unsigned);
+static void tag_lines (const char *, unsigned, unsigned);
+static void tag_counters (const char *, unsigned, unsigned);
+static void tag_summary (const char *, unsigned, unsigned);
+extern int main (int, char **);
typedef struct tag_format
{
{0, NULL, NULL}
};
-int main (argc, argv)
- int argc ATTRIBUTE_UNUSED;
- char **argv;
+int
+main (int argc ATTRIBUTE_UNUSED, char **argv)
{
int opt;
fprintf (stderr, "unknown flag `%c'\n", opt);
}
}
-
+
while (argv[optind])
dump_file (argv[optind++]);
return 0;
}
static void
-print_usage ()
+print_usage (void)
{
printf ("Usage: gcov-dump [OPTION] ... gcovfiles\n");
printf ("Print coverage file contents\n");
}
static void
-print_version ()
+print_version (void)
{
char v[4];
unsigned version = GCOV_VERSION;
}
static void
-print_prefix (filename, depth, position)
- const char *filename;
- unsigned depth;
- gcov_position_t position;
+print_prefix (const char *filename, unsigned depth, gcov_position_t position)
{
static const char prefix[] = " ";
-
+
printf ("%s:", filename);
if (flag_dump_positions)
printf ("%lu:", (unsigned long) position);
}
static void
-dump_file (filename)
- const char *filename;
+dump_file (const char *filename)
{
unsigned tags[4];
unsigned depth = 0;
-
+
if (!gcov_open (filename, 1))
{
fprintf (stderr, "%s:cannot open\n", filename);
return;
}
-
+
/* magic */
{
unsigned magic = gcov_read_unsigned ();
unsigned expected = GCOV_VERSION;
unsigned ix;
int different = version != GCOV_VERSION;
-
+
if (magic == GCOV_DATA_MAGIC)
type = "data";
else if (magic == GCOV_GRAPH_MAGIC)
v[ix] = version;
m[ix] = magic;
}
-
+
printf ("%s:%s:magic `%.4s':version `%.4s'\n", filename, type, m, v);
if (different)
printf ("%s:warning:current version is `%.4s'\n", filename, e);
depth = tag_depth;
tags[depth - 1] = tag;
}
-
+
print_prefix (filename, tag_depth, position);
printf ("%08x:%4u:%s", tag, length, format->name);
if (format->proc)
(*format->proc) (filename, tag, length);
-
+
printf ("\n");
if (flag_dump_contents && format->proc)
{
unsigned long actual_length = gcov_position () - base;
-
+
if (actual_length > length)
printf ("%s:record size mismatch %lu bytes overread\n",
filename, actual_length - length);
}
static void
-tag_function (filename, tag, length)
- const char *filename ATTRIBUTE_UNUSED;
- unsigned tag ATTRIBUTE_UNUSED;
- unsigned length ATTRIBUTE_UNUSED;
+tag_function (const char *filename ATTRIBUTE_UNUSED,
+ unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
unsigned long pos = gcov_position ();
-
+
printf (" ident=%u", gcov_read_unsigned ());
printf (", checksum=0x%08x", gcov_read_unsigned ());
if (gcov_position () - pos < length)
{
const char *name;
-
+
name = gcov_read_string ();
printf (", `%s'", name ? name : "NULL");
name = gcov_read_string ();
}
static void
-tag_blocks (filename, tag, length)
- const char *filename ATTRIBUTE_UNUSED;
- unsigned tag ATTRIBUTE_UNUSED;
- unsigned length ATTRIBUTE_UNUSED;
+tag_blocks (const char *filename ATTRIBUTE_UNUSED,
+ unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
unsigned n_blocks = length / 4;
-
+
printf (" %u blocks", n_blocks);
if (flag_dump_contents)
}
static void
-tag_arcs (filename, tag, length)
- const char *filename ATTRIBUTE_UNUSED;
- unsigned tag ATTRIBUTE_UNUSED;
- unsigned length ATTRIBUTE_UNUSED;
+tag_arcs (const char *filename ATTRIBUTE_UNUSED,
+ unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
unsigned n_arcs = (length - 4) / 8;
for (ix = 0; ix != n_arcs; ix++)
{
unsigned dst, flags;
-
+
if (!(ix & 3))
{
printf ("\n");
}
static void
-tag_lines (filename, tag, length)
- const char *filename ATTRIBUTE_UNUSED;
- unsigned tag ATTRIBUTE_UNUSED;
- unsigned length ATTRIBUTE_UNUSED;
+tag_lines (const char *filename ATTRIBUTE_UNUSED,
+ unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
if (flag_dump_contents)
{
gcov_position_t position = gcov_position ();
const char *source = NULL;
unsigned lineno = gcov_read_unsigned ();
-
+
if (!lineno)
{
source = gcov_read_string ();
break;
sep = NULL;
}
-
+
if (!sep)
{
printf ("\n");
}
static void
-tag_counters (filename, tag, length)
- const char *filename ATTRIBUTE_UNUSED;
- unsigned tag ATTRIBUTE_UNUSED;
- unsigned length ATTRIBUTE_UNUSED;
+tag_counters (const char *filename ATTRIBUTE_UNUSED,
+ unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
static const char *const counter_names[] = GCOV_COUNTER_NAMES;
unsigned n_counts = length / 8;
-
+
printf (" %s %u counts",
counter_names[GCOV_COUNTER_FOR_TAG (tag)], n_counts);
if (flag_dump_contents)
for (ix = 0; ix != n_counts; ix++)
{
gcov_type count;
-
+
if (!(ix & 7))
{
printf ("\n");
print_prefix (filename, 0, gcov_position ());
printf ("\t\t%u", ix);
}
-
+
count = gcov_read_counter ();
printf (" ");
printf (HOST_WIDEST_INT_PRINT_DEC, count);
}
static void
-tag_summary (filename, tag, length)
- const char *filename ATTRIBUTE_UNUSED;
- unsigned tag ATTRIBUTE_UNUSED;
- unsigned length ATTRIBUTE_UNUSED;
+tag_summary (const char *filename ATTRIBUTE_UNUSED,
+ unsigned tag ATTRIBUTE_UNUSED, unsigned length ATTRIBUTE_UNUSED)
{
struct gcov_summary summary;
unsigned ix;
-
+
gcov_read_summary (&summary);
printf (" checksum=0x%08x", summary.checksum);
-
+
for (ix = 0; ix != GCOV_COUNTERS; ix++)
{
printf ("\n");
print_prefix (filename, 0, 0);
printf ("\t\tcounts=%u, runs=%u",
summary.ctrs[ix].num, summary.ctrs[ix].runs);
-
+
printf (", sum_all=" HOST_WIDEST_INT_PRINT_DEC,
(HOST_WIDEST_INT)summary.ctrs[ix].sum_all);
printf (", run_max=" HOST_WIDEST_INT_PRINT_DEC,
/* Generate gcov version string from version.c. See gcov-io.h for
description of how the version string is generated.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003 Free Software Foundation, Inc.
Contributed by Nathan Sidwell <nathan@codesourcery.com>
-
+
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
#include "tm.h"
#include "version.c" /* We want the actual string. */
-int main PARAMS ((int, char **));
+int main (int, char **);
int
-main (argc, argv)
- int argc ATTRIBUTE_UNUSED;
- char **argv;
+main (int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
{
unsigned version = 0;
unsigned char v[4];
v[1] = (minor / 10) + '0';
v[2] = (minor % 10) + '0';
v[3] = s ? s : '*';
-
+
for (ix = 0; ix != 4; ix++)
version = (version << 8) | v[ix];
printf ("\n");
printf ("#define GCOV_VERSION ((unsigned)%#08x) /* %.4s */\n",
version, v);
-
+
return 0;
}
sbitmap *nonnull_killed;
};
\f
-static void compute_can_copy PARAMS ((void));
-static char *gmalloc PARAMS ((unsigned int));
-static char *grealloc PARAMS ((char *, unsigned int));
-static char *gcse_alloc PARAMS ((unsigned long));
-static void alloc_gcse_mem PARAMS ((rtx));
-static void free_gcse_mem PARAMS ((void));
-static void alloc_reg_set_mem PARAMS ((int));
-static void free_reg_set_mem PARAMS ((void));
-static int get_bitmap_width PARAMS ((int, int, int));
-static void record_one_set PARAMS ((int, rtx));
-static void record_set_info PARAMS ((rtx, rtx, void *));
-static void compute_sets PARAMS ((rtx));
-static void hash_scan_insn PARAMS ((rtx, struct hash_table *, int));
-static void hash_scan_set PARAMS ((rtx, rtx, struct hash_table *));
-static void hash_scan_clobber PARAMS ((rtx, rtx, struct hash_table *));
-static void hash_scan_call PARAMS ((rtx, rtx, struct hash_table *));
-static int want_to_gcse_p PARAMS ((rtx));
-static bool gcse_constant_p PARAMS ((rtx));
-static int oprs_unchanged_p PARAMS ((rtx, rtx, int));
-static int oprs_anticipatable_p PARAMS ((rtx, rtx));
-static int oprs_available_p PARAMS ((rtx, rtx));
-static void insert_expr_in_table PARAMS ((rtx, enum machine_mode, rtx,
- int, int, struct hash_table *));
-static void insert_set_in_table PARAMS ((rtx, rtx, struct hash_table *));
-static unsigned int hash_expr PARAMS ((rtx, enum machine_mode, int *, int));
-static unsigned int hash_expr_1 PARAMS ((rtx, enum machine_mode, int *));
-static unsigned int hash_string_1 PARAMS ((const char *));
-static unsigned int hash_set PARAMS ((int, int));
-static int expr_equiv_p PARAMS ((rtx, rtx));
-static void record_last_reg_set_info PARAMS ((rtx, int));
-static void record_last_mem_set_info PARAMS ((rtx));
-static void record_last_set_info PARAMS ((rtx, rtx, void *));
-static void compute_hash_table PARAMS ((struct hash_table *));
-static void alloc_hash_table PARAMS ((int, struct hash_table *, int));
-static void free_hash_table PARAMS ((struct hash_table *));
-static void compute_hash_table_work PARAMS ((struct hash_table *));
-static void dump_hash_table PARAMS ((FILE *, const char *,
- struct hash_table *));
-static struct expr *lookup_expr PARAMS ((rtx, struct hash_table *));
-static struct expr *lookup_set PARAMS ((unsigned int, struct hash_table *));
-static struct expr *next_set PARAMS ((unsigned int, struct expr *));
-static void reset_opr_set_tables PARAMS ((void));
-static int oprs_not_set_p PARAMS ((rtx, rtx));
-static void mark_call PARAMS ((rtx));
-static void mark_set PARAMS ((rtx, rtx));
-static void mark_clobber PARAMS ((rtx, rtx));
-static void mark_oprs_set PARAMS ((rtx));
-static void alloc_cprop_mem PARAMS ((int, int));
-static void free_cprop_mem PARAMS ((void));
-static void compute_transp PARAMS ((rtx, int, sbitmap *, int));
-static void compute_transpout PARAMS ((void));
-static void compute_local_properties PARAMS ((sbitmap *, sbitmap *, sbitmap *,
- struct hash_table *));
-static void compute_cprop_data PARAMS ((void));
-static void find_used_regs PARAMS ((rtx *, void *));
-static int try_replace_reg PARAMS ((rtx, rtx, rtx));
-static struct expr *find_avail_set PARAMS ((int, rtx));
-static int cprop_jump PARAMS ((basic_block, rtx, rtx, rtx, rtx));
-static void mems_conflict_for_gcse_p PARAMS ((rtx, rtx, void *));
-static int load_killed_in_block_p PARAMS ((basic_block, int, rtx, int));
-static void canon_list_insert PARAMS ((rtx, rtx, void *));
-static int cprop_insn PARAMS ((rtx, int));
-static int cprop PARAMS ((int));
-static void find_implicit_sets PARAMS ((void));
-static int one_cprop_pass PARAMS ((int, int, int));
-static bool constprop_register PARAMS ((rtx, rtx, rtx, int));
-static struct expr *find_bypass_set PARAMS ((int, int));
-static bool reg_killed_on_edge PARAMS ((rtx, edge));
-static int bypass_block PARAMS ((basic_block, rtx, rtx));
-static int bypass_conditional_jumps PARAMS ((void));
-static void alloc_pre_mem PARAMS ((int, int));
-static void free_pre_mem PARAMS ((void));
-static void compute_pre_data PARAMS ((void));
-static int pre_expr_reaches_here_p PARAMS ((basic_block, struct expr *,
- basic_block));
-static void insert_insn_end_bb PARAMS ((struct expr *, basic_block, int));
-static void pre_insert_copy_insn PARAMS ((struct expr *, rtx));
-static void pre_insert_copies PARAMS ((void));
-static int pre_delete PARAMS ((void));
-static int pre_gcse PARAMS ((void));
-static int one_pre_gcse_pass PARAMS ((int));
-static void add_label_notes PARAMS ((rtx, rtx));
-static void alloc_code_hoist_mem PARAMS ((int, int));
-static void free_code_hoist_mem PARAMS ((void));
-static void compute_code_hoist_vbeinout PARAMS ((void));
-static void compute_code_hoist_data PARAMS ((void));
-static int hoist_expr_reaches_here_p PARAMS ((basic_block, int, basic_block,
- char *));
-static void hoist_code PARAMS ((void));
-static int one_code_hoisting_pass PARAMS ((void));
-static void alloc_rd_mem PARAMS ((int, int));
-static void free_rd_mem PARAMS ((void));
-static void handle_rd_kill_set PARAMS ((rtx, int, basic_block));
-static void compute_kill_rd PARAMS ((void));
-static void compute_rd PARAMS ((void));
-static void alloc_avail_expr_mem PARAMS ((int, int));
-static void free_avail_expr_mem PARAMS ((void));
-static void compute_ae_gen PARAMS ((struct hash_table *));
-static int expr_killed_p PARAMS ((rtx, basic_block));
-static void compute_ae_kill PARAMS ((sbitmap *, sbitmap *, struct hash_table *));
-static int expr_reaches_here_p PARAMS ((struct occr *, struct expr *,
- basic_block, int));
-static rtx computing_insn PARAMS ((struct expr *, rtx));
-static int def_reaches_here_p PARAMS ((rtx, rtx));
-static int can_disregard_other_sets PARAMS ((struct reg_set **, rtx, int));
-static int handle_avail_expr PARAMS ((rtx, struct expr *));
-static int classic_gcse PARAMS ((void));
-static int one_classic_gcse_pass PARAMS ((int));
-static void invalidate_nonnull_info PARAMS ((rtx, rtx, void *));
-static int delete_null_pointer_checks_1 PARAMS ((unsigned int *,
- sbitmap *, sbitmap *,
- struct null_pointer_info *));
-static rtx process_insert_insn PARAMS ((struct expr *));
-static int pre_edge_insert PARAMS ((struct edge_list *, struct expr **));
-static int expr_reaches_here_p_work PARAMS ((struct occr *, struct expr *,
- basic_block, int, char *));
-static int pre_expr_reaches_here_p_work PARAMS ((basic_block, struct expr *,
- basic_block, char *));
-static struct ls_expr * ldst_entry PARAMS ((rtx));
-static void free_ldst_entry PARAMS ((struct ls_expr *));
-static void free_ldst_mems PARAMS ((void));
-static void print_ldst_list PARAMS ((FILE *));
-static struct ls_expr * find_rtx_in_ldst PARAMS ((rtx));
-static int enumerate_ldsts PARAMS ((void));
-static inline struct ls_expr * first_ls_expr PARAMS ((void));
-static inline struct ls_expr * next_ls_expr PARAMS ((struct ls_expr *));
-static int simple_mem PARAMS ((rtx));
-static void invalidate_any_buried_refs PARAMS ((rtx));
-static void compute_ld_motion_mems PARAMS ((void));
-static void trim_ld_motion_mems PARAMS ((void));
-static void update_ld_motion_stores PARAMS ((struct expr *));
-static void reg_set_info PARAMS ((rtx, rtx, void *));
-static bool store_ops_ok PARAMS ((rtx, int *));
-static rtx extract_mentioned_regs PARAMS ((rtx));
-static rtx extract_mentioned_regs_helper PARAMS ((rtx, rtx));
-static void find_moveable_store PARAMS ((rtx, int *, int *));
-static int compute_store_table PARAMS ((void));
-static bool load_kills_store PARAMS ((rtx, rtx));
-static bool find_loads PARAMS ((rtx, rtx));
-static bool store_killed_in_insn PARAMS ((rtx, rtx, rtx));
-static bool store_killed_after PARAMS ((rtx, rtx, rtx, basic_block,
- int *, rtx *));
-static bool store_killed_before PARAMS ((rtx, rtx, rtx, basic_block,
- int *));
-static void build_store_vectors PARAMS ((void));
-static void insert_insn_start_bb PARAMS ((rtx, basic_block));
-static int insert_store PARAMS ((struct ls_expr *, edge));
-static void replace_store_insn PARAMS ((rtx, rtx, basic_block));
-static void delete_store PARAMS ((struct ls_expr *,
- basic_block));
-static void free_store_memory PARAMS ((void));
-static void store_motion PARAMS ((void));
-static void free_insn_expr_list_list PARAMS ((rtx *));
-static void clear_modify_mem_tables PARAMS ((void));
-static void free_modify_mem_tables PARAMS ((void));
-static rtx gcse_emit_move_after PARAMS ((rtx, rtx, rtx));
-static void local_cprop_find_used_regs PARAMS ((rtx *, void *));
-static bool do_local_cprop PARAMS ((rtx, rtx, int, rtx*));
-static bool adjust_libcall_notes PARAMS ((rtx, rtx, rtx, rtx*));
-static void local_cprop_pass PARAMS ((int));
+static void compute_can_copy (void);
+static char *gmalloc (unsigned int);
+static char *grealloc (char *, unsigned int);
+static char *gcse_alloc (unsigned long);
+static void alloc_gcse_mem (rtx);
+static void free_gcse_mem (void);
+static void alloc_reg_set_mem (int);
+static void free_reg_set_mem (void);
+static int get_bitmap_width (int, int, int);
+static void record_one_set (int, rtx);
+static void record_set_info (rtx, rtx, void *);
+static void compute_sets (rtx);
+static void hash_scan_insn (rtx, struct hash_table *, int);
+static void hash_scan_set (rtx, rtx, struct hash_table *);
+static void hash_scan_clobber (rtx, rtx, struct hash_table *);
+static void hash_scan_call (rtx, rtx, struct hash_table *);
+static int want_to_gcse_p (rtx);
+static bool gcse_constant_p (rtx);
+static int oprs_unchanged_p (rtx, rtx, int);
+static int oprs_anticipatable_p (rtx, rtx);
+static int oprs_available_p (rtx, rtx);
+static void insert_expr_in_table (rtx, enum machine_mode, rtx, int, int,
+ struct hash_table *);
+static void insert_set_in_table (rtx, rtx, struct hash_table *);
+static unsigned int hash_expr (rtx, enum machine_mode, int *, int);
+static unsigned int hash_expr_1 (rtx, enum machine_mode, int *);
+static unsigned int hash_string_1 (const char *);
+static unsigned int hash_set (int, int);
+static int expr_equiv_p (rtx, rtx);
+static void record_last_reg_set_info (rtx, int);
+static void record_last_mem_set_info (rtx);
+static void record_last_set_info (rtx, rtx, void *);
+static void compute_hash_table (struct hash_table *);
+static void alloc_hash_table (int, struct hash_table *, int);
+static void free_hash_table (struct hash_table *);
+static void compute_hash_table_work (struct hash_table *);
+static void dump_hash_table (FILE *, const char *, struct hash_table *);
+static struct expr *lookup_expr (rtx, struct hash_table *);
+static struct expr *lookup_set (unsigned int, struct hash_table *);
+static struct expr *next_set (unsigned int, struct expr *);
+static void reset_opr_set_tables (void);
+static int oprs_not_set_p (rtx, rtx);
+static void mark_call (rtx);
+static void mark_set (rtx, rtx);
+static void mark_clobber (rtx, rtx);
+static void mark_oprs_set (rtx);
+static void alloc_cprop_mem (int, int);
+static void free_cprop_mem (void);
+static void compute_transp (rtx, int, sbitmap *, int);
+static void compute_transpout (void);
+static void compute_local_properties (sbitmap *, sbitmap *, sbitmap *,
+ struct hash_table *);
+static void compute_cprop_data (void);
+static void find_used_regs (rtx *, void *);
+static int try_replace_reg (rtx, rtx, rtx);
+static struct expr *find_avail_set (int, rtx);
+static int cprop_jump (basic_block, rtx, rtx, rtx, rtx);
+static void mems_conflict_for_gcse_p (rtx, rtx, void *);
+static int load_killed_in_block_p (basic_block, int, rtx, int);
+static void canon_list_insert (rtx, rtx, void *);
+static int cprop_insn (rtx, int);
+static int cprop (int);
+static void find_implicit_sets (void);
+static int one_cprop_pass (int, int, int);
+static bool constprop_register (rtx, rtx, rtx, int);
+static struct expr *find_bypass_set (int, int);
+static bool reg_killed_on_edge (rtx, edge);
+static int bypass_block (basic_block, rtx, rtx);
+static int bypass_conditional_jumps (void);
+static void alloc_pre_mem (int, int);
+static void free_pre_mem (void);
+static void compute_pre_data (void);
+static int pre_expr_reaches_here_p (basic_block, struct expr *,
+ basic_block);
+static void insert_insn_end_bb (struct expr *, basic_block, int);
+static void pre_insert_copy_insn (struct expr *, rtx);
+static void pre_insert_copies (void);
+static int pre_delete (void);
+static int pre_gcse (void);
+static int one_pre_gcse_pass (int);
+static void add_label_notes (rtx, rtx);
+static void alloc_code_hoist_mem (int, int);
+static void free_code_hoist_mem (void);
+static void compute_code_hoist_vbeinout (void);
+static void compute_code_hoist_data (void);
+static int hoist_expr_reaches_here_p (basic_block, int, basic_block, char *);
+static void hoist_code (void);
+static int one_code_hoisting_pass (void);
+static void alloc_rd_mem (int, int);
+static void free_rd_mem (void);
+static void handle_rd_kill_set (rtx, int, basic_block);
+static void compute_kill_rd (void);
+static void compute_rd (void);
+static void alloc_avail_expr_mem (int, int);
+static void free_avail_expr_mem (void);
+static void compute_ae_gen (struct hash_table *);
+static int expr_killed_p (rtx, basic_block);
+static void compute_ae_kill (sbitmap *, sbitmap *, struct hash_table *);
+static int expr_reaches_here_p (struct occr *, struct expr *, basic_block,
+ int);
+static rtx computing_insn (struct expr *, rtx);
+static int def_reaches_here_p (rtx, rtx);
+static int can_disregard_other_sets (struct reg_set **, rtx, int);
+static int handle_avail_expr (rtx, struct expr *);
+static int classic_gcse (void);
+static int one_classic_gcse_pass (int);
+static void invalidate_nonnull_info (rtx, rtx, void *);
+static int delete_null_pointer_checks_1 (unsigned int *, sbitmap *, sbitmap *,
+ struct null_pointer_info *);
+static rtx process_insert_insn (struct expr *);
+static int pre_edge_insert (struct edge_list *, struct expr **);
+static int expr_reaches_here_p_work (struct occr *, struct expr *,
+ basic_block, int, char *);
+static int pre_expr_reaches_here_p_work (basic_block, struct expr *,
+ basic_block, char *);
+static struct ls_expr * ldst_entry (rtx);
+static void free_ldst_entry (struct ls_expr *);
+static void free_ldst_mems (void);
+static void print_ldst_list (FILE *);
+static struct ls_expr * find_rtx_in_ldst (rtx);
+static int enumerate_ldsts (void);
+static inline struct ls_expr * first_ls_expr (void);
+static inline struct ls_expr * next_ls_expr (struct ls_expr *);
+static int simple_mem (rtx);
+static void invalidate_any_buried_refs (rtx);
+static void compute_ld_motion_mems (void);
+static void trim_ld_motion_mems (void);
+static void update_ld_motion_stores (struct expr *);
+static void reg_set_info (rtx, rtx, void *);
+static bool store_ops_ok (rtx, int *);
+static rtx extract_mentioned_regs (rtx);
+static rtx extract_mentioned_regs_helper (rtx, rtx);
+static void find_moveable_store (rtx, int *, int *);
+static int compute_store_table (void);
+static bool load_kills_store (rtx, rtx);
+static bool find_loads (rtx, rtx);
+static bool store_killed_in_insn (rtx, rtx, rtx);
+static bool store_killed_after (rtx, rtx, rtx, basic_block, int *, rtx *);
+static bool store_killed_before (rtx, rtx, rtx, basic_block, int *);
+static void build_store_vectors (void);
+static void insert_insn_start_bb (rtx, basic_block);
+static int insert_store (struct ls_expr *, edge);
+static void replace_store_insn (rtx, rtx, basic_block);
+static void delete_store (struct ls_expr *, basic_block);
+static void free_store_memory (void);
+static void store_motion (void);
+static void free_insn_expr_list_list (rtx *);
+static void clear_modify_mem_tables (void);
+static void free_modify_mem_tables (void);
+static rtx gcse_emit_move_after (rtx, rtx, rtx);
+static void local_cprop_find_used_regs (rtx *, void *);
+static bool do_local_cprop (rtx, rtx, int, rtx*);
+static bool adjust_libcall_notes (rtx, rtx, rtx, rtx*);
+static void local_cprop_pass (int);
\f
/* Entry point for global common subexpression elimination.
F is the first instruction in the function. */
int
-gcse_main (f, file)
- rtx f;
- FILE *file;
+gcse_main (rtx f, FILE *file)
{
int changed, pass;
/* Bytes used at start of pass. */
/* Compute which modes support reg/reg copy operations. */
static void
-compute_can_copy ()
+compute_can_copy (void)
{
int i;
#ifndef AVOID_CCMODE_COPIES
/* Returns whether the mode supports reg/reg copy operations. */
bool
-can_copy_p (mode)
- enum machine_mode mode;
+can_copy_p (enum machine_mode mode)
{
static bool can_copy_init_p = false;
/* Cover function to xmalloc to record bytes allocated. */
static char *
-gmalloc (size)
- unsigned int size;
+gmalloc (unsigned int size)
{
bytes_used += size;
return xmalloc (size);
It won't affect memory usage stats much anyway. */
static char *
-grealloc (ptr, size)
- char *ptr;
- unsigned int size;
+grealloc (char *ptr, unsigned int size)
{
return xrealloc (ptr, size);
}
/* Cover function to obstack_alloc. */
static char *
-gcse_alloc (size)
- unsigned long size;
+gcse_alloc (unsigned long size)
{
bytes_used += size;
return (char *) obstack_alloc (&gcse_obstack, size);
This is called at the start of each pass. */
static void
-alloc_gcse_mem (f)
- rtx f;
+alloc_gcse_mem (rtx f)
{
int i, n;
rtx insn;
/* Free memory allocated by alloc_gcse_mem. */
static void
-free_gcse_mem ()
+free_gcse_mem (void)
{
free (uid_cuid);
free (cuid_insn);
less space. */
static int
-get_bitmap_width (n, x, y)
- int n;
- int x;
- int y;
+get_bitmap_width (int n, int x, int y)
{
/* It's not really worth figuring out *exactly* how much memory will
be used by a particular choice. The important thing is to get
ABSALTERED. */
static void
-compute_local_properties (transp, comp, antloc, table)
- sbitmap *transp;
- sbitmap *comp;
- sbitmap *antloc;
- struct hash_table *table;
+compute_local_properties (sbitmap *transp, sbitmap *comp, sbitmap *antloc, struct hash_table *table)
{
unsigned int i;
static struct obstack reg_set_obstack;
static void
-alloc_reg_set_mem (n_regs)
- int n_regs;
+alloc_reg_set_mem (int n_regs)
{
unsigned int n;
}
static void
-free_reg_set_mem ()
+free_reg_set_mem (void)
{
free (reg_set_table);
obstack_free (®_set_obstack, NULL);
/* Record REGNO in the reg_set table. */
static void
-record_one_set (regno, insn)
- int regno;
- rtx insn;
+record_one_set (int regno, rtx insn)
{
/* Allocate a new reg_set element and link it onto the list. */
struct reg_set *new_reg_info;
occurring. */
static void
-record_set_info (dest, setter, data)
- rtx dest, setter ATTRIBUTE_UNUSED;
- void *data;
+record_set_info (rtx dest, rtx setter ATTRIBUTE_UNUSED, void *data)
{
rtx record_set_insn = (rtx) data;
`reg_set_table' for further documentation. */
static void
-compute_sets (f)
- rtx f;
+compute_sets (rtx f)
{
rtx insn;
static GTY(()) rtx test_insn;
static int
-want_to_gcse_p (x)
- rtx x;
+want_to_gcse_p (rtx x)
{
int num_clobbers = 0;
int icode;
or from INSN to the end of INSN's basic block (if AVAIL_P != 0). */
static int
-oprs_unchanged_p (x, insn, avail_p)
- rtx x, insn;
- int avail_p;
+oprs_unchanged_p (rtx x, rtx insn, int avail_p)
{
int i, j;
enum rtx_code code;
gcse_mems_conflict_p to a nonzero value. */
static void
-mems_conflict_for_gcse_p (dest, setter, data)
- rtx dest, setter ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+mems_conflict_for_gcse_p (rtx dest, rtx setter ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
while (GET_CODE (dest) == SUBREG
|| GET_CODE (dest) == ZERO_EXTRACT
AVAIL_P to 0. */
static int
-load_killed_in_block_p (bb, uid_limit, x, avail_p)
- basic_block bb;
- int uid_limit;
- rtx x;
- int avail_p;
+load_killed_in_block_p (basic_block bb, int uid_limit, rtx x, int avail_p)
{
rtx list_entry = modify_mem_list[bb->index];
while (list_entry)
the start of INSN's basic block up to but not including INSN. */
static int
-oprs_anticipatable_p (x, insn)
- rtx x, insn;
+oprs_anticipatable_p (rtx x, rtx insn)
{
return oprs_unchanged_p (x, insn, 0);
}
INSN to the end of INSN's basic block. */
static int
-oprs_available_p (x, insn)
- rtx x, insn;
+oprs_available_p (rtx x, rtx insn)
{
return oprs_unchanged_p (x, insn, 1);
}
??? One might want to merge this with canon_hash. Later. */
static unsigned int
-hash_expr (x, mode, do_not_record_p, hash_table_size)
- rtx x;
- enum machine_mode mode;
- int *do_not_record_p;
- int hash_table_size;
+hash_expr (rtx x, enum machine_mode mode, int *do_not_record_p, int hash_table_size)
{
unsigned int hash;
/* Hash a string. Just add its bytes up. */
static inline unsigned
-hash_string_1 (ps)
- const char *ps;
+hash_string_1 (const char *ps)
{
unsigned hash = 0;
const unsigned char *p = (const unsigned char *) ps;
/* Subroutine of hash_expr to do the actual work. */
static unsigned int
-hash_expr_1 (x, mode, do_not_record_p)
- rtx x;
- enum machine_mode mode;
- int *do_not_record_p;
+hash_expr_1 (rtx x, enum machine_mode mode, int *do_not_record_p)
{
int i, j;
unsigned hash = 0;
??? May need to make things more elaborate. Later, as necessary. */
static unsigned int
-hash_set (regno, hash_table_size)
- int regno;
- int hash_table_size;
+hash_set (int regno, int hash_table_size)
{
unsigned int hash;
??? Borrowed from cse.c. Might want to remerge with cse.c. Later. */
static int
-expr_equiv_p (x, y)
- rtx x, y;
+expr_equiv_p (rtx x, rtx y)
{
int i, j;
enum rtx_code code;
AVAIL_P is nonzero if X is an available expression. */
static void
-insert_expr_in_table (x, mode, insn, antic_p, avail_p, table)
- rtx x;
- enum machine_mode mode;
- rtx insn;
- int antic_p, avail_p;
- struct hash_table *table;
+insert_expr_in_table (rtx x, enum machine_mode mode, rtx insn, int antic_p,
+ int avail_p, struct hash_table *table)
{
int found, do_not_record_p;
unsigned int hash;
basic block. */
static void
-insert_set_in_table (x, insn, table)
- rtx x;
- rtx insn;
- struct hash_table *table;
+insert_set_in_table (rtx x, rtx insn, struct hash_table *table)
{
int found;
unsigned int hash;
the purposes of GCSE's constant propagation. */
static bool
-gcse_constant_p (x)
- rtx x;
+gcse_constant_p (rtx x)
{
/* Consider a COMPARE of two integers constant. */
if (GET_CODE (x) == COMPARE
expression one). */
static void
-hash_scan_set (pat, insn, table)
- rtx pat, insn;
- struct hash_table *table;
+hash_scan_set (rtx pat, rtx insn, struct hash_table *table)
{
rtx src = SET_SRC (pat);
rtx dest = SET_DEST (pat);
}
static void
-hash_scan_clobber (x, insn, table)
- rtx x ATTRIBUTE_UNUSED, insn ATTRIBUTE_UNUSED;
- struct hash_table *table ATTRIBUTE_UNUSED;
+hash_scan_clobber (rtx x ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED,
+ struct hash_table *table ATTRIBUTE_UNUSED)
{
/* Currently nothing to do. */
}
static void
-hash_scan_call (x, insn, table)
- rtx x ATTRIBUTE_UNUSED, insn ATTRIBUTE_UNUSED;
- struct hash_table *table ATTRIBUTE_UNUSED;
+hash_scan_call (rtx x ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED,
+ struct hash_table *table ATTRIBUTE_UNUSED)
{
/* Currently nothing to do. */
}
not record any expressions. */
static void
-hash_scan_insn (insn, table, in_libcall_block)
- rtx insn;
- struct hash_table *table;
- int in_libcall_block;
+hash_scan_insn (rtx insn, struct hash_table *table, int in_libcall_block)
{
rtx pat = PATTERN (insn);
int i;
}
static void
-dump_hash_table (file, name, table)
- FILE *file;
- const char *name;
- struct hash_table *table;
+dump_hash_table (FILE *file, const char *name, struct hash_table *table)
{
int i;
/* Flattened out table, so it's printed in proper order. */
and is used to compute "transparency". */
static void
-record_last_reg_set_info (insn, regno)
- rtx insn;
- int regno;
+record_last_reg_set_info (rtx insn, int regno)
{
struct reg_avail_info *info = ®_avail_info[regno];
int cuid = INSN_CUID (insn);
taken off pairwise. */
static void
-canon_list_insert (dest, unused1, v_insn)
- rtx dest ATTRIBUTE_UNUSED;
- rtx unused1 ATTRIBUTE_UNUSED;
- void * v_insn;
+canon_list_insert (rtx dest ATTRIBUTE_UNUSED, rtx unused1 ATTRIBUTE_UNUSED,
+ void * v_insn)
{
rtx dest_addr, insn;
int bb;
a CALL_INSN). We merely need to record which insns modify memory. */
static void
-record_last_mem_set_info (insn)
- rtx insn;
+record_last_mem_set_info (rtx insn)
{
int bb = BLOCK_NUM (insn);
the SET is taking place. */
static void
-record_last_set_info (dest, setter, data)
- rtx dest, setter ATTRIBUTE_UNUSED;
- void *data;
+record_last_set_info (rtx dest, rtx setter ATTRIBUTE_UNUSED, void *data)
{
rtx last_set_insn = (rtx) data;
TABLE is the table computed. */
static void
-compute_hash_table_work (table)
- struct hash_table *table;
+compute_hash_table_work (struct hash_table *table)
{
unsigned int i;
be created. */
static void
-alloc_hash_table (n_insns, table, set_p)
- int n_insns;
- struct hash_table *table;
- int set_p;
+alloc_hash_table (int n_insns, struct hash_table *table, int set_p)
{
int n;
/* Free things allocated by alloc_hash_table. */
static void
-free_hash_table (table)
- struct hash_table *table;
+free_hash_table (struct hash_table *table)
{
free (table->table);
}
expression hash table. */
static void
-compute_hash_table (table)
- struct hash_table *table;
+compute_hash_table (struct hash_table *table)
{
/* Initialize count of number of entries in hash table. */
table->n_elems = 0;
The result is a pointer to the table entry, or NULL if not found. */
static struct expr *
-lookup_expr (pat, table)
- rtx pat;
- struct hash_table *table;
+lookup_expr (rtx pat, struct hash_table *table)
{
int do_not_record_p;
unsigned int hash = hash_expr (pat, GET_MODE (pat), &do_not_record_p,
table entry, or NULL if not found. */
static struct expr *
-lookup_set (regno, table)
- unsigned int regno;
- struct hash_table *table;
+lookup_set (unsigned int regno, struct hash_table *table)
{
unsigned int hash = hash_set (regno, table->size);
struct expr *expr;
/* Return the next entry for REGNO in list EXPR. */
static struct expr *
-next_set (regno, expr)
- unsigned int regno;
- struct expr *expr;
+next_set (unsigned int regno, struct expr *expr)
{
do
expr = expr->next_same_hash;
types may be mixed. */
static void
-free_insn_expr_list_list (listp)
- rtx *listp;
+free_insn_expr_list_list (rtx *listp)
{
rtx list, next;
/* Clear canon_modify_mem_list and modify_mem_list tables. */
static void
-clear_modify_mem_tables ()
+clear_modify_mem_tables (void)
{
int i;
/* Release memory used by modify_mem_list_set and canon_modify_mem_list_set. */
static void
-free_modify_mem_tables ()
+free_modify_mem_tables (void)
{
clear_modify_mem_tables ();
free (modify_mem_list);
start of the block]. */
static void
-reset_opr_set_tables ()
+reset_opr_set_tables (void)
{
/* Maintain a bitmap of which regs have been set since beginning of
the block. */
INSN's basic block. */
static int
-oprs_not_set_p (x, insn)
- rtx x, insn;
+oprs_not_set_p (rtx x, rtx insn)
{
int i, j;
enum rtx_code code;
/* Mark things set by a CALL. */
static void
-mark_call (insn)
- rtx insn;
+mark_call (rtx insn)
{
if (! CONST_OR_PURE_CALL_P (insn))
record_last_mem_set_info (insn);
/* Mark things set by a SET. */
static void
-mark_set (pat, insn)
- rtx pat, insn;
+mark_set (rtx pat, rtx insn)
{
rtx dest = SET_DEST (pat);
/* Record things set by a CLOBBER. */
static void
-mark_clobber (pat, insn)
- rtx pat, insn;
+mark_clobber (rtx pat, rtx insn)
{
rtx clob = XEXP (pat, 0);
This data is used by oprs_not_set_p. */
static void
-mark_oprs_set (insn)
- rtx insn;
+mark_oprs_set (rtx insn)
{
rtx pat = PATTERN (insn);
int i;
/* Allocate reaching def variables. */
static void
-alloc_rd_mem (n_blocks, n_insns)
- int n_blocks, n_insns;
+alloc_rd_mem (int n_blocks, int n_insns)
{
rd_kill = (sbitmap *) sbitmap_vector_alloc (n_blocks, n_insns);
sbitmap_vector_zero (rd_kill, n_blocks);
/* Free reaching def variables. */
static void
-free_rd_mem ()
+free_rd_mem (void)
{
sbitmap_vector_free (rd_kill);
sbitmap_vector_free (rd_gen);
/* Add INSN to the kills of BB. REGNO, set in BB, is killed by INSN. */
static void
-handle_rd_kill_set (insn, regno, bb)
- rtx insn;
- int regno;
- basic_block bb;
+handle_rd_kill_set (rtx insn, int regno, basic_block bb)
{
struct reg_set *this_reg;
/* Compute the set of kill's for reaching definitions. */
static void
-compute_kill_rd ()
+compute_kill_rd (void)
{
int cuid;
unsigned int regno;
expressions but applied to the gens and kills of reaching definitions. */
static void
-compute_rd ()
+compute_rd (void)
{
int changed, passes;
basic_block bb;
/* Allocate memory for available expression computation. */
static void
-alloc_avail_expr_mem (n_blocks, n_exprs)
- int n_blocks, n_exprs;
+alloc_avail_expr_mem (int n_blocks, int n_exprs)
{
ae_kill = (sbitmap *) sbitmap_vector_alloc (n_blocks, n_exprs);
sbitmap_vector_zero (ae_kill, n_blocks);
}
static void
-free_avail_expr_mem ()
+free_avail_expr_mem (void)
{
sbitmap_vector_free (ae_kill);
sbitmap_vector_free (ae_gen);
/* Compute the set of available expressions generated in each basic block. */
static void
-compute_ae_gen (expr_hash_table)
- struct hash_table *expr_hash_table;
+compute_ae_gen (struct hash_table *expr_hash_table)
{
unsigned int i;
struct expr *expr;
/* Return nonzero if expression X is killed in BB. */
static int
-expr_killed_p (x, bb)
- rtx x;
- basic_block bb;
+expr_killed_p (rtx x, basic_block bb)
{
int i, j;
enum rtx_code code;
/* Compute the set of available expressions killed in each basic block. */
static void
-compute_ae_kill (ae_gen, ae_kill, expr_hash_table)
- sbitmap *ae_gen, *ae_kill;
- struct hash_table *expr_hash_table;
+compute_ae_kill (sbitmap *ae_gen, sbitmap *ae_kill,
+ struct hash_table *expr_hash_table)
{
basic_block bb;
unsigned int i;
the closest such expression. */
static int
-expr_reaches_here_p_work (occr, expr, bb, check_self_loop, visited)
- struct occr *occr;
- struct expr *expr;
- basic_block bb;
- int check_self_loop;
- char *visited;
+expr_reaches_here_p_work (struct occr *occr, struct expr *expr,
+ basic_block bb, int check_self_loop, char *visited)
{
edge pred;
memory allocated for that function is returned. */
static int
-expr_reaches_here_p (occr, expr, bb, check_self_loop)
- struct occr *occr;
- struct expr *expr;
- basic_block bb;
- int check_self_loop;
+expr_reaches_here_p (struct occr *occr, struct expr *expr, basic_block bb,
+ int check_self_loop)
{
int rval;
char *visited = (char *) xcalloc (last_basic_block, 1);
Called only by handle_avail_expr. */
static rtx
-computing_insn (expr, insn)
- struct expr *expr;
- rtx insn;
+computing_insn (struct expr *expr, rtx insn)
{
basic_block bb = BLOCK_FOR_INSN (insn);
Only called by can_disregard_other_sets. */
static int
-def_reaches_here_p (insn, def_insn)
- rtx insn, def_insn;
+def_reaches_here_p (rtx insn, rtx def_insn)
{
rtx reg;
always safe to return zero. */
static int
-can_disregard_other_sets (addr_this_reg, insn, for_combine)
- struct reg_set **addr_this_reg;
- rtx insn;
- int for_combine;
+can_disregard_other_sets (struct reg_set **addr_this_reg, rtx insn, int for_combine)
{
int number_of_reaching_defs = 0;
struct reg_set *this_reg;
The result is nonzero if any changes were made. */
static int
-handle_avail_expr (insn, expr)
- rtx insn;
- struct expr *expr;
+handle_avail_expr (rtx insn, struct expr *expr)
{
rtx pat, insn_computes_expr, expr_set;
rtx to;
The result is nonzero if a change was made. */
static int
-classic_gcse ()
+classic_gcse (void)
{
int changed;
rtx insn;
Return nonzero if a change was made. */
static int
-one_classic_gcse_pass (pass)
- int pass;
+one_classic_gcse_pass (int pass)
{
int changed = 0;
basic blocks. N_SETS is the number of sets. */
static void
-alloc_cprop_mem (n_blocks, n_sets)
- int n_blocks, n_sets;
+alloc_cprop_mem (int n_blocks, int n_sets)
{
cprop_pavloc = sbitmap_vector_alloc (n_blocks, n_sets);
cprop_absaltered = sbitmap_vector_alloc (n_blocks, n_sets);
/* Free vars used by copy/const propagation. */
static void
-free_cprop_mem ()
+free_cprop_mem (void)
{
sbitmap_vector_free (cprop_pavloc);
sbitmap_vector_free (cprop_absaltered);
bit in BMAP. */
static void
-compute_transp (x, indx, bmap, set_p)
- rtx x;
- int indx;
- sbitmap *bmap;
- int set_p;
+compute_transp (rtx x, int indx, sbitmap *bmap, int set_p)
{
int i, j;
basic_block bb;
propagation. */
static void
-compute_cprop_data ()
+compute_cprop_data (void)
{
compute_local_properties (cprop_absaltered, cprop_pavloc, NULL, &set_hash_table);
compute_available (cprop_pavloc, cprop_absaltered,
This doesn't hurt anything but it will slow things down. */
static void
-find_used_regs (xptr, data)
- rtx *xptr;
- void *data ATTRIBUTE_UNUSED;
+find_used_regs (rtx *xptr, void *data ATTRIBUTE_UNUSED)
{
int i, j;
enum rtx_code code;
Returns nonzero is successful. */
static int
-try_replace_reg (from, to, insn)
- rtx from, to, insn;
+try_replace_reg (rtx from, rtx to, rtx insn)
{
rtx note = find_reg_equal_equiv_note (insn);
rtx src = 0;
NULL no such set is found. */
static struct expr *
-find_avail_set (regno, insn)
- int regno;
- rtx insn;
+find_avail_set (int regno, rtx insn)
{
/* SET1 contains the last set found that can be returned to the caller for
use in a substitution. */
if a change was made. */
static int
-cprop_jump (bb, setcc, jump, from, src)
- basic_block bb;
- rtx setcc;
- rtx jump;
- rtx from;
- rtx src;
+cprop_jump (basic_block bb, rtx setcc, rtx jump, rtx from, rtx src)
{
rtx new, set_src, note_src;
rtx set = pc_set (jump);
}
static bool
-constprop_register (insn, from, to, alter_jumps)
- rtx insn;
- rtx from;
- rtx to;
- int alter_jumps;
+constprop_register (rtx insn, rtx from, rtx to, int alter_jumps)
{
rtx sset;
The result is nonzero if a change was made. */
static int
-cprop_insn (insn, alter_jumps)
- rtx insn;
- int alter_jumps;
+cprop_insn (rtx insn, int alter_jumps)
{
struct reg_use *reg_used;
int changed = 0;
can legitimately make replacements. */
static void
-local_cprop_find_used_regs (xptr, data)
- rtx *xptr;
- void *data;
+local_cprop_find_used_regs (rtx *xptr, void *data)
{
rtx x = *xptr;
find_used_regs (xptr, data);
}
-
+
/* LIBCALL_SP is a zero-terminated array of insns at the end of a libcall;
their REG_EQUAL notes need updating. */
static bool
-do_local_cprop (x, insn, alter_jumps, libcall_sp)
- rtx x;
- rtx insn;
- int alter_jumps;
- rtx *libcall_sp;
+do_local_cprop (rtx x, rtx insn, int alter_jumps, rtx *libcall_sp)
{
rtx newreg = NULL, newcnst = NULL;
replaced with NEWVAL in INSN. Return true if all substitutions could
be made. */
static bool
-adjust_libcall_notes (oldreg, newval, insn, libcall_sp)
- rtx oldreg, newval, insn, *libcall_sp;
+adjust_libcall_notes (rtx oldreg, rtx newval, rtx insn, rtx *libcall_sp)
{
rtx end;
#define MAX_NESTED_LIBCALLS 9
static void
-local_cprop_pass (alter_jumps)
- int alter_jumps;
+local_cprop_pass (int alter_jumps)
{
rtx insn;
struct reg_use *reg_used;
nonzero if a change was made. */
static int
-cprop (alter_jumps)
- int alter_jumps;
+cprop (int alter_jumps)
{
int changed;
basic_block bb;
but this would require some code reorganization. */
rtx
-fis_get_condition (jump)
- rtx jump;
+fis_get_condition (rtx jump)
{
rtx cond, set, tmp, insn, earliest;
bool reverse;
basic block. */
static void
-find_implicit_sets ()
+find_implicit_sets (void)
{
basic_block bb, dest;
unsigned int count;
perform conditional jump bypassing optimizations. */
static int
-one_cprop_pass (pass, cprop_jumps, bypass_jumps)
- int pass;
- int cprop_jumps;
- int bypass_jumps;
+one_cprop_pass (int pass, int cprop_jumps, int bypass_jumps)
{
int changed = 0;
find_avail_set. */
static struct expr *
-find_bypass_set (regno, bb)
- int regno;
- int bb;
+find_bypass_set (int regno, int bb)
{
struct expr *result = 0;
valid prior to commit_edge_insertions. */
static bool
-reg_killed_on_edge (reg, e)
- rtx reg;
- edge e;
+reg_killed_on_edge (rtx reg, edge e)
{
rtx insn;
these inserted insns when performing its transformations. */
static int
-bypass_block (bb, setcc, jump)
- basic_block bb;
- rtx setcc, jump;
+bypass_block (basic_block bb, rtx setcc, rtx jump)
{
rtx insn, note;
edge e, enext, edest;
new = simplify_replace_rtx (src, reg_used->reg_rtx,
SET_SRC (set->expr));
- /* Jump bypassing may have already placed instructions on
+ /* Jump bypassing may have already placed instructions on
edges of the CFG. We can't bypass an outgoing edge that
has instructions associated with it, as these insns won't
get executed if the incoming edge is redirected. */
This function is now mis-named, because we also handle indirect jumps. */
static int
-bypass_conditional_jumps ()
+bypass_conditional_jumps (void)
{
basic_block bb;
int changed;
/* Allocate vars used for PRE analysis. */
static void
-alloc_pre_mem (n_blocks, n_exprs)
- int n_blocks, n_exprs;
+alloc_pre_mem (int n_blocks, int n_exprs)
{
transp = sbitmap_vector_alloc (n_blocks, n_exprs);
comp = sbitmap_vector_alloc (n_blocks, n_exprs);
/* Free vars used for PRE analysis. */
static void
-free_pre_mem ()
+free_pre_mem (void)
{
sbitmap_vector_free (transp);
sbitmap_vector_free (comp);
/* Top level routine to do the dataflow analysis needed by PRE. */
static void
-compute_pre_data ()
+compute_pre_data (void)
{
sbitmap trapping_expr;
basic_block bb;
the closest such expression. */
static int
-pre_expr_reaches_here_p_work (occr_bb, expr, bb, visited)
- basic_block occr_bb;
- struct expr *expr;
- basic_block bb;
- char *visited;
+pre_expr_reaches_here_p_work (basic_block occr_bb, struct expr *expr, basic_block bb, char *visited)
{
edge pred;
memory allocated for that function is returned. */
static int
-pre_expr_reaches_here_p (occr_bb, expr, bb)
- basic_block occr_bb;
- struct expr *expr;
- basic_block bb;
+pre_expr_reaches_here_p (basic_block occr_bb, struct expr *expr, basic_block bb)
{
int rval;
char *visited = (char *) xcalloc (last_basic_block, 1);
the value of BB. */
static rtx
-process_insert_insn (expr)
- struct expr *expr;
+process_insert_insn (struct expr *expr)
{
rtx reg = expr->reaching_reg;
rtx exp = copy_rtx (expr->expr);
no sense for code hoisting. */
static void
-insert_insn_end_bb (expr, bb, pre)
- struct expr *expr;
- basic_block bb;
- int pre;
+insert_insn_end_bb (struct expr *expr, basic_block bb, int pre)
{
rtx insn = bb->end;
rtx new_insn;
the expressions fully redundant. */
static int
-pre_edge_insert (edge_list, index_map)
- struct edge_list *edge_list;
- struct expr **index_map;
+pre_edge_insert (struct edge_list *edge_list, struct expr **index_map)
{
int e, i, j, num_edges, set_size, did_insert = 0;
sbitmap *inserted;
/* Copy the result of INSN to REG. INDX is the expression number. */
static void
-pre_insert_copy_insn (expr, insn)
- struct expr *expr;
- rtx insn;
+pre_insert_copy_insn (struct expr *expr, rtx insn)
{
rtx reg = expr->reaching_reg;
int regno = REGNO (reg);
to `reaching_reg'. */
static void
-pre_insert_copies ()
+pre_insert_copies (void)
{
unsigned int i;
struct expr *expr;
/* Emit move from SRC to DEST noting the equivalence with expression computed
in INSN. */
static rtx
-gcse_emit_move_after (src, dest, insn)
- rtx src, dest, insn;
+gcse_emit_move_after (rtx src, rtx dest, rtx insn)
{
rtx new;
rtx set = single_set (insn), set2;
Returns nonzero if a change is made. */
static int
-pre_delete ()
+pre_delete (void)
{
unsigned int i;
int changed;
redundancies. */
static int
-pre_gcse ()
+pre_gcse (void)
{
unsigned int i;
int did_insert, changed;
Return nonzero if a change was made. */
static int
-one_pre_gcse_pass (pass)
- int pass;
+one_pre_gcse_pass (int pass)
{
int changed = 0;
necessary REG_LABEL notes. */
static void
-add_label_notes (x, insn)
- rtx x;
- rtx insn;
+add_label_notes (rtx x, rtx insn)
{
enum rtx_code code = GET_CODE (x);
int i, j;
EH table sizes, this may not be worthwhile. */
static void
-compute_transpout ()
+compute_transpout (void)
{
basic_block bb;
unsigned int i;
We ignore hard registers. */
static void
-invalidate_nonnull_info (x, setter, data)
- rtx x;
- rtx setter ATTRIBUTE_UNUSED;
- void *data;
+invalidate_nonnull_info (rtx x, rtx setter ATTRIBUTE_UNUSED, void *data)
{
unsigned int regno;
struct null_pointer_info *npi = (struct null_pointer_info *) data;
they are not our responsibility to free. */
static int
-delete_null_pointer_checks_1 (block_reg, nonnull_avin,
- nonnull_avout, npi)
- unsigned int *block_reg;
- sbitmap *nonnull_avin;
- sbitmap *nonnull_avout;
- struct null_pointer_info *npi;
+delete_null_pointer_checks_1 (unsigned int *block_reg, sbitmap *nonnull_avin,
+ sbitmap *nonnull_avout,
+ struct null_pointer_info *npi)
{
basic_block bb, current_block;
sbitmap *nonnull_local = npi->nonnull_local;
This could probably be integrated with global cprop with a little work. */
int
-delete_null_pointer_checks (f)
- rtx f ATTRIBUTE_UNUSED;
+delete_null_pointer_checks (rtx f ATTRIBUTE_UNUSED)
{
sbitmap *nonnull_avin, *nonnull_avout;
unsigned int *block_reg;
/* Allocate vars used for code hoisting analysis. */
static void
-alloc_code_hoist_mem (n_blocks, n_exprs)
- int n_blocks, n_exprs;
+alloc_code_hoist_mem (int n_blocks, int n_exprs)
{
antloc = sbitmap_vector_alloc (n_blocks, n_exprs);
transp = sbitmap_vector_alloc (n_blocks, n_exprs);
/* Free vars used for code hoisting analysis. */
static void
-free_code_hoist_mem ()
+free_code_hoist_mem (void)
{
sbitmap_vector_free (antloc);
sbitmap_vector_free (transp);
compute the expression. */
static void
-compute_code_hoist_vbeinout ()
+compute_code_hoist_vbeinout (void)
{
int changed, passes;
basic_block bb;
/* Top level routine to do the dataflow analysis needed by code hoisting. */
static void
-compute_code_hoist_data ()
+compute_code_hoist_data (void)
{
compute_local_properties (transp, comp, antloc, &expr_hash_table);
compute_transpout ();
paths. */
static int
-hoist_expr_reaches_here_p (expr_bb, expr_index, bb, visited)
- basic_block expr_bb;
- int expr_index;
- basic_block bb;
- char *visited;
+hoist_expr_reaches_here_p (basic_block expr_bb, int expr_index, basic_block bb, char *visited)
{
edge pred;
int visited_allocated_locally = 0;
/* Actually perform code hoisting. */
static void
-hoist_code ()
+hoist_code (void)
{
basic_block bb, dominated;
basic_block *domby;
/* If we found nothing to hoist, then quit now. */
if (! found)
{
- free (domby);
+ free (domby);
continue;
}
Return nonzero if a change was made. */
static int
-one_code_hoisting_pass ()
+one_code_hoisting_pass (void)
{
int changed = 0;
doesn't find one, we create one and initialize it. */
static struct ls_expr *
-ldst_entry (x)
- rtx x;
+ldst_entry (rtx x)
{
struct ls_expr * ptr;
/* Free up an individual ldst entry. */
static void
-free_ldst_entry (ptr)
- struct ls_expr * ptr;
+free_ldst_entry (struct ls_expr * ptr)
{
free_INSN_LIST_list (& ptr->loads);
free_INSN_LIST_list (& ptr->stores);
/* Free up all memory associated with the ldst list. */
static void
-free_ldst_mems ()
+free_ldst_mems (void)
{
while (pre_ldst_mems)
{
/* Dump debugging info about the ldst list. */
static void
-print_ldst_list (file)
- FILE * file;
+print_ldst_list (FILE * file)
{
struct ls_expr * ptr;
/* Returns 1 if X is in the list of ldst only expressions. */
static struct ls_expr *
-find_rtx_in_ldst (x)
- rtx x;
+find_rtx_in_ldst (rtx x)
{
struct ls_expr * ptr;
/* Assign each element of the list of mems a monotonically increasing value. */
static int
-enumerate_ldsts ()
+enumerate_ldsts (void)
{
struct ls_expr * ptr;
int n = 0;
/* Return first item in the list. */
static inline struct ls_expr *
-first_ls_expr ()
+first_ls_expr (void)
{
return pre_ldst_mems;
}
/* Return the next item in the list after the specified one. */
static inline struct ls_expr *
-next_ls_expr (ptr)
- struct ls_expr * ptr;
+next_ls_expr (struct ls_expr * ptr)
{
return ptr->next;
}
ld_motion list, otherwise we let the usual aliasing take care of it. */
static int
-simple_mem (x)
- rtx x;
+simple_mem (rtx x)
{
if (GET_CODE (x) != MEM)
return 0;
fix it up. */
static void
-invalidate_any_buried_refs (x)
- rtx x;
+invalidate_any_buried_refs (rtx x)
{
const char * fmt;
int i, j;
later. */
static void
-compute_ld_motion_mems ()
+compute_ld_motion_mems (void)
{
struct ls_expr * ptr;
basic_block bb;
expression list for pre gcse. */
static void
-trim_ld_motion_mems ()
+trim_ld_motion_mems (void)
{
struct ls_expr * last = NULL;
struct ls_expr * ptr = first_ls_expr ();
correct value in the reaching register for the loads. */
static void
-update_ld_motion_stores (expr)
- struct expr * expr;
+update_ld_motion_stores (struct expr * expr)
{
struct ls_expr * mem_ptr;
/* Checks to set if we need to mark a register set. Called from note_stores. */
static void
-reg_set_info (dest, setter, data)
- rtx dest, setter ATTRIBUTE_UNUSED;
- void * data ATTRIBUTE_UNUSED;
+reg_set_info (rtx dest, rtx setter ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
if (GET_CODE (dest) == SUBREG)
dest = SUBREG_REG (dest);
/* Return zero if some of the registers in list X are killed
due to set of registers in bitmap REGS_SET. */
-
+
static bool
-store_ops_ok (x, regs_set)
- rtx x;
- int *regs_set;
+store_ops_ok (rtx x, int *regs_set)
{
rtx reg;
{
reg = XEXP (x, 0);
if (regs_set[REGNO(reg)])
- return false;
+ return false;
}
return true;
/* Returns a list of registers mentioned in X. */
static rtx
-extract_mentioned_regs (x)
- rtx x;
+extract_mentioned_regs (rtx x)
{
return extract_mentioned_regs_helper (x, NULL_RTX);
}
/* Helper for extract_mentioned_regs; ACCUM is used to accumulate used
registers. */
static rtx
-extract_mentioned_regs_helper (x, accum)
- rtx x;
- rtx accum;
+extract_mentioned_regs_helper (rtx x, rtx accum)
{
int i;
enum rtx_code code;
current insn, REGS_SET_AFTER is bitmap of registers set after (and
including) the insn in this basic block. We must be passing through BB from
head to end, as we are using this fact to speed things up.
-
+
The results are stored this way:
-- the first anticipatable expression is added into ANTIC_STORE_LIST
*/
static void
-find_moveable_store (insn, regs_set_before, regs_set_after)
- rtx insn;
- int *regs_set_before;
- int *regs_set_after;
+find_moveable_store (rtx insn, int *regs_set_before, int *regs_set_after)
{
struct ls_expr * ptr;
rtx dest, set, tmp;
continue. */
if (flag_non_call_exceptions && may_trap_p (dest))
return;
-
+
ptr = ldst_entry (dest);
if (!ptr->pattern_regs)
ptr->pattern_regs = extract_mentioned_regs (dest);
if (!check_available)
AVAIL_STORE_LIST (ptr) = alloc_INSN_LIST (insn, AVAIL_STORE_LIST (ptr));
}
-
+
/* Find available and anticipatable stores. */
static int
-compute_store_table ()
+compute_store_table (void)
{
int ret;
basic_block bb;
/* Check to see if the load X is aliased with STORE_PATTERN. */
static bool
-load_kills_store (x, store_pattern)
- rtx x, store_pattern;
+load_kills_store (rtx x, rtx store_pattern)
{
if (true_dependence (x, GET_MODE (x), store_pattern, rtx_addr_varies_p))
return true;
STORE_PATTERN. Return true if found. */
static bool
-find_loads (x, store_pattern)
- rtx x, store_pattern;
+find_loads (rtx x, rtx store_pattern)
{
const char * fmt;
int i, j;
Return true if it it does. */
static bool
-store_killed_in_insn (x, x_regs, insn)
- rtx x, x_regs, insn;
+store_killed_in_insn (rtx x, rtx x_regs, rtx insn)
{
rtx reg, base;
is killed, return the last insn in that it occurs in FAIL_INSN. */
static bool
-store_killed_after (x, x_regs, insn, bb, regs_set_after, fail_insn)
- rtx x, x_regs, insn;
- basic_block bb;
- int *regs_set_after;
- rtx *fail_insn;
+store_killed_after (rtx x, rtx x_regs, rtx insn, basic_block bb,
+ int *regs_set_after, rtx *fail_insn)
{
rtx last = bb->end, act;
if (!store_ops_ok (x_regs, regs_set_after))
- {
+ {
/* We do not know where it will happen. */
if (fail_insn)
*fail_insn = NULL_RTX;
return false;
}
-
+
/* Returns true if the expression X is loaded or clobbered on or before INSN
within basic block BB. X_REGS is list of registers mentioned in X.
REGS_SET_BEFORE is bitmap of registers set before or in this insn. */
static bool
-store_killed_before (x, x_regs, insn, bb, regs_set_before)
- rtx x, x_regs, insn;
- basic_block bb;
- int *regs_set_before;
+store_killed_before (rtx x, rtx x_regs, rtx insn, basic_block bb,
+ int *regs_set_before)
{
rtx first = bb->head;
return false;
}
-
+
/* Fill in available, anticipatable, transparent and kill vectors in
STORE_DATA, based on lists of available and anticipatable stores. */
static void
-build_store_vectors ()
+build_store_vectors (void)
{
basic_block bb;
int *regs_set_in_block;
if (!TEST_BIT (st_antloc[bb->index], ptr->index)
|| !TEST_BIT (ae_gen[bb->index], ptr->index))
SET_BIT (ae_kill[bb->index], ptr->index);
- }
- else
- SET_BIT (transp[bb->index], ptr->index);
- }
+ }
+ else
+ SET_BIT (transp[bb->index], ptr->index);
+ }
}
free (regs_set_in_block);
the BLOCK_HEAD if needed. */
static void
-insert_insn_start_bb (insn, bb)
- rtx insn;
- basic_block bb;
+insert_insn_start_bb (rtx insn, basic_block bb)
{
/* Insert at start of successor block. */
rtx prev = PREV_INSN (bb->head);
if an edge insertion was performed. */
static int
-insert_store (expr, e)
- struct ls_expr * expr;
- edge e;
+insert_store (struct ls_expr * expr, edge e)
{
rtx reg, insn;
basic_block bb;
/* This routine will replace a store with a SET to a specified register. */
static void
-replace_store_insn (reg, del, bb)
- rtx reg, del;
- basic_block bb;
+replace_store_insn (rtx reg, rtx del, basic_block bb)
{
rtx insn;
the reaching_reg for later storing. */
static void
-delete_store (expr, bb)
- struct ls_expr * expr;
- basic_block bb;
+delete_store (struct ls_expr * expr, basic_block bb)
{
rtx reg, i, del;
/* Free memory used by store motion. */
static void
-free_store_memory ()
+free_store_memory (void)
{
free_ldst_mems ();
other way by looking at the flowgraph in reverse. */
static void
-store_motion ()
+store_motion (void)
{
basic_block bb;
int x;
/* Entry point for jump bypassing optimization pass. */
int
-bypass_jumps (file)
- FILE *file;
+bypass_jumps (FILE *file)
{
int changed;
/* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS.
If LENGTH is -1, then CONTENTS is assumed to be a
null-terminated string and the memory sized accordingly. */
-extern const char *ggc_alloc_string PARAMS ((const char *contents,
- int length));
+extern const char *ggc_alloc_string (const char *contents, int length);
/* Make a copy of S, in GC-able memory. */
#define ggc_strdup(S) ggc_alloc_string((S), -1)
/* Allocate registers for pseudo-registers that span basic blocks.
Copyright (C) 1987, 1988, 1991, 1994, 1996, 1997, 1998,
- 1999, 2000, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
static HARD_REG_SET eliminable_regset;
-static int allocno_compare PARAMS ((const void *, const void *));
-static void global_conflicts PARAMS ((void));
-static void mirror_conflicts PARAMS ((void));
-static void expand_preferences PARAMS ((void));
-static void prune_preferences PARAMS ((void));
-static void find_reg PARAMS ((int, HARD_REG_SET, int, int, int));
-static void record_one_conflict PARAMS ((int));
-static void record_conflicts PARAMS ((int *, int));
-static void mark_reg_store PARAMS ((rtx, rtx, void *));
-static void mark_reg_clobber PARAMS ((rtx, rtx, void *));
-static void mark_reg_conflicts PARAMS ((rtx));
-static void mark_reg_death PARAMS ((rtx));
-static void mark_reg_live_nc PARAMS ((int, enum machine_mode));
-static void set_preference PARAMS ((rtx, rtx));
-static void dump_conflicts PARAMS ((FILE *));
-static void reg_becomes_live PARAMS ((rtx, rtx, void *));
-static void reg_dies PARAMS ((int, enum machine_mode,
- struct insn_chain *));
+static int allocno_compare (const void *, const void *);
+static void global_conflicts (void);
+static void mirror_conflicts (void);
+static void expand_preferences (void);
+static void prune_preferences (void);
+static void find_reg (int, HARD_REG_SET, int, int, int);
+static void record_one_conflict (int);
+static void record_conflicts (int *, int);
+static void mark_reg_store (rtx, rtx, void *);
+static void mark_reg_clobber (rtx, rtx, void *);
+static void mark_reg_conflicts (rtx);
+static void mark_reg_death (rtx);
+static void mark_reg_live_nc (int, enum machine_mode);
+static void set_preference (rtx, rtx);
+static void dump_conflicts (FILE *);
+static void reg_becomes_live (rtx, rtx, void *);
+static void reg_dies (int, enum machine_mode, struct insn_chain *);
\f
/* Perform allocation of pseudo-registers not allocated by local_alloc.
FILE is a file to output debugging information on,
and we must not do any more for this function. */
int
-global_alloc (file)
- FILE *file;
+global_alloc (FILE *file)
{
int retval;
#ifdef ELIMINABLE_REGS
Returns -1 (1) if *v1 should be allocated before (after) *v2. */
static int
-allocno_compare (v1p, v2p)
- const void *v1p;
- const void *v2p;
+allocno_compare (const void *v1p, const void *v2p)
{
int v1 = *(const int *)v1p, v2 = *(const int *)v2p;
/* Note that the quotient will never be bigger than
conflict matrices and preference tables. */
static void
-global_conflicts ()
+global_conflicts (void)
{
int i;
basic_block b;
scan the instruction that makes either X or Y become live. */
record_conflicts (block_start_allocnos, ax);
- /* Pseudos can't go in stack regs at the start of a basic block that
- is reached by an abnormal edge. Likewise for call clobbered regs,
- because because caller-save, fixup_abnormal_edges, and possibly
- the table driven EH machinery are not quite ready to handle such
- regs live across such edges. */
+ /* Pseudos can't go in stack regs at the start of a basic block that
+ is reached by an abnormal edge. Likewise for call clobbered regs,
+ because because caller-save, fixup_abnormal_edges, and possibly
+ the table driven EH machinery are not quite ready to handle such
+ regs live across such edges. */
{
edge e;
merge any preferences between those allocnos. */
static void
-expand_preferences ()
+expand_preferences (void)
{
rtx insn;
rtx link;
we will avoid using these registers. */
static void
-prune_preferences ()
+prune_preferences (void)
{
int i;
int num;
If not, do nothing. */
static void
-find_reg (num, losers, alt_regs_p, accept_call_clobbered, retrying)
- int num;
- HARD_REG_SET losers;
- int alt_regs_p;
- int accept_call_clobbered;
- int retrying;
+find_reg (int num, HARD_REG_SET losers, int alt_regs_p, int accept_call_clobbered, int retrying)
{
int i, best_reg, pass;
HARD_REG_SET used, used1, used2;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j)
&& (REGNO_REG_CLASS (j)
- == REGNO_REG_CLASS (best_reg + (j - i))
+ == REGNO_REG_CLASS (best_reg + (j - i))
|| reg_class_subset_p (REGNO_REG_CLASS (j),
REGNO_REG_CLASS (best_reg + (j - i)))
|| reg_class_subset_p (REGNO_REG_CLASS (best_reg + (j - i)),
(j < lim
&& ! TEST_HARD_REG_BIT (used, j)
&& (REGNO_REG_CLASS (j)
- == REGNO_REG_CLASS (best_reg + (j - i))
+ == REGNO_REG_CLASS (best_reg + (j - i))
|| reg_class_subset_p (REGNO_REG_CLASS (j),
REGNO_REG_CLASS (best_reg + (j - i)))
|| reg_class_subset_p (REGNO_REG_CLASS (best_reg + (j - i)),
If FORBIDDEN_REGS is zero, no regs are forbidden. */
void
-retry_global_alloc (regno, forbidden_regs)
- int regno;
- HARD_REG_SET forbidden_regs;
+retry_global_alloc (int regno, HARD_REG_SET forbidden_regs)
{
int alloc_no = reg_allocno[regno];
if (alloc_no >= 0)
reg_renumber before calling here. */
static void
-record_one_conflict (regno)
- int regno;
+record_one_conflict (int regno)
{
int j;
are currently live. Their bits are also flagged in allocnos_live. */
static void
-record_conflicts (allocno_vec, len)
- int *allocno_vec;
- int len;
+record_conflicts (int *allocno_vec, int len)
{
while (--len >= 0)
IOR_HARD_REG_SET (allocno[allocno_vec[len]].hard_reg_conflicts,
/* If CONFLICTP (i, j) is true, make sure CONFLICTP (j, i) is also true. */
static void
-mirror_conflicts ()
+mirror_conflicts (void)
{
int i, j;
int rw = allocno_row_words;
a REG_INC note was found for it). */
static void
-mark_reg_store (reg, setter, data)
- rtx reg, setter;
- void *data ATTRIBUTE_UNUSED;
+mark_reg_store (rtx reg, rtx setter, void *data ATTRIBUTE_UNUSED)
{
int regno;
/* Like mark_reg_set except notice just CLOBBERs; ignore SETs. */
static void
-mark_reg_clobber (reg, setter, data)
- rtx reg, setter;
- void *data ATTRIBUTE_UNUSED;
+mark_reg_clobber (rtx reg, rtx setter, void *data ATTRIBUTE_UNUSED)
{
if (GET_CODE (setter) == CLOBBER)
mark_reg_store (reg, setter, data);
Do not mark REG itself as live. */
static void
-mark_reg_conflicts (reg)
- rtx reg;
+mark_reg_conflicts (rtx reg)
{
int regno;
Store a 0 in regs_live or allocnos_live for this register. */
static void
-mark_reg_death (reg)
- rtx reg;
+mark_reg_death (rtx reg)
{
int regno = REGNO (reg);
it is assumed that the caller will do that. */
static void
-mark_reg_live_nc (regno, mode)
- int regno;
- enum machine_mode mode;
+mark_reg_live_nc (int regno, enum machine_mode mode)
{
int last = regno + HARD_REGNO_NREGS (regno, mode);
while (regno < last)
pseudo-register to a hard register. */
static void
-set_preference (dest, src)
- rtx dest, src;
+set_preference (rtx dest, rtx src)
{
unsigned int src_regno, dest_regno;
/* Amount to add to the hard regno for SRC, or subtract from that for DEST,
a use of TO. */
void
-mark_elimination (from, to)
- int from, to;
+mark_elimination (int from, int to)
{
basic_block bb;
/* Record in live_relevant_regs and REGS_SET that register REG became live.
This is called via note_stores. */
static void
-reg_becomes_live (reg, setter, regs_set)
- rtx reg;
- rtx setter ATTRIBUTE_UNUSED;
- void *regs_set;
+reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *regs_set)
{
int regno;
/* Record in live_relevant_regs that register REGNO died. */
static void
-reg_dies (regno, mode, chain)
- int regno;
- enum machine_mode mode;
- struct insn_chain *chain;
+reg_dies (int regno, enum machine_mode mode, struct insn_chain *chain)
{
if (regno < FIRST_PSEUDO_REGISTER)
{
/* Walk the insns of the current function and build reload_insn_chain,
and record register life information. */
void
-build_insn_chain (first)
- rtx first;
+build_insn_chain (rtx first)
{
struct insn_chain **p = &reload_insn_chain;
struct insn_chain *prev = 0;
showing the information on which the allocation decisions are based. */
static void
-dump_conflicts (file)
- FILE *file;
+dump_conflicts (FILE *file)
{
int i;
int has_preferences;
}
void
-dump_global_regs (file)
- FILE *file;
+dump_global_regs (FILE *file)
{
int i, j;
/* Output routines for graphical representation.
- Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
This file is part of GCC.
/* vcg */ ".vcg",
};
-static void start_fct PARAMS ((FILE *));
-static void start_bb PARAMS ((FILE *, int));
-static void node_data PARAMS ((FILE *, rtx));
-static void draw_edge PARAMS ((FILE *, int, int, int, int));
-static void end_fct PARAMS ((FILE *));
-static void end_bb PARAMS ((FILE *));
+static void start_fct (FILE *);
+static void start_bb (FILE *, int);
+static void node_data (FILE *, rtx);
+static void draw_edge (FILE *, int, int, int, int);
+static void end_fct (FILE *);
+static void end_bb (FILE *);
/* Output text for new basic block. */
static void
-start_fct (fp)
- FILE *fp;
+start_fct (FILE *fp)
{
switch (graph_dump_format)
{
}
static void
-start_bb (fp, bb)
- FILE *fp;
- int bb;
+start_bb (FILE *fp, int bb)
{
switch (graph_dump_format)
{
}
static void
-node_data (fp, tmp_rtx)
- FILE *fp;
- rtx tmp_rtx;
+node_data (FILE *fp, rtx tmp_rtx)
{
if (PREV_INSN (tmp_rtx) == 0)
{
}
static void
-draw_edge (fp, from, to, bb_edge, class)
- FILE *fp;
- int from;
- int to;
- int bb_edge;
- int class;
+draw_edge (FILE *fp, int from, int to, int bb_edge, int class)
{
const char * color;
switch (graph_dump_format)
}
static void
-end_bb (fp)
- FILE *fp;
+end_bb (FILE *fp)
{
switch (graph_dump_format)
{
}
static void
-end_fct (fp)
- FILE *fp;
+end_fct (FILE *fp)
{
switch (graph_dump_format)
{
/* Like print_rtl, but also print out live information for the start of each
basic block. */
void
-print_rtl_graph_with_bb (base, suffix, rtx_first)
- const char *base;
- const char *suffix;
- rtx rtx_first;
+print_rtl_graph_with_bb (const char *base, const char *suffix, rtx rtx_first)
{
rtx tmp_rtx;
size_t namelen = strlen (base);
/* Similar as clean_dump_file, but this time for graph output files. */
void
-clean_graph_dump_file (base, suffix)
- const char *base;
- const char *suffix;
+clean_graph_dump_file (const char *base, const char *suffix)
{
size_t namelen = strlen (base);
size_t suffixlen = strlen (suffix);
/* Do final work on the graph output file. */
void
-finish_graph_dump_file (base, suffix)
- const char *base;
- const char *suffix;
+finish_graph_dump_file (const char *base, const char *suffix)
{
size_t namelen = strlen (base);
size_t suffixlen = strlen (suffix);
/* Header file for graph routines.
- Copyright (C) 1999 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2003 Free Software Foundation, Inc.
This file is part of GCC.
#ifndef GCC_GRAPH_H
#define GCC_GRAPH_H
-extern void print_rtl_graph_with_bb PARAMS ((const char *, const char *, rtx));
-extern void clean_graph_dump_file PARAMS ((const char *, const char *));
-extern void finish_graph_dump_file PARAMS ((const char *, const char *));
+extern void print_rtl_graph_with_bb (const char *, const char *, rtx);
+extern void clean_graph_dump_file (const char *, const char *);
+extern void finish_graph_dump_file (const char *, const char *);
#endif /* ! GCC_GRAPH_H */
/* Instruction scheduling pass.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
of the -fsched-verbose=N option. */
void
-fix_sched_param (param, val)
- const char *param, *val;
+fix_sched_param (const char *param, const char *val)
{
if (!strcmp (param, "verbose"))
sched_verbose_param = atoi (val);
int n_ready;
};
-static int may_trap_exp PARAMS ((rtx, int));
+static int may_trap_exp (rtx, int);
/* Nonzero iff the address is comprised from at most 1 register. */
#define CONST_BASED_ADDRESS_P(x) \
as found by analyzing insn's expression. */
static int
-may_trap_exp (x, is_store)
- rtx x;
- int is_store;
+may_trap_exp (rtx x, int is_store)
{
enum rtx_code code;
being either PFREE or PRISKY. */
int
-haifa_classify_insn (insn)
- rtx insn;
+haifa_classify_insn (rtx insn)
{
rtx pat = PATTERN (insn);
int tmp_class = TRAP_FREE;
/* The scheduler using only DFA description should never use the
following five functions: */
-static unsigned int blockage_range PARAMS ((int, rtx));
-static void clear_units PARAMS ((void));
-static void schedule_unit PARAMS ((int, rtx, int));
-static int actual_hazard PARAMS ((int, rtx, int, int));
-static int potential_hazard PARAMS ((int, rtx, int));
-
-static int priority PARAMS ((rtx));
-static int rank_for_schedule PARAMS ((const void *, const void *));
-static void swap_sort PARAMS ((rtx *, int));
-static void queue_insn PARAMS ((rtx, int));
-static int schedule_insn PARAMS ((rtx, struct ready_list *, int));
-static int find_set_reg_weight PARAMS ((rtx));
-static void find_insn_reg_weight PARAMS ((int));
-static void adjust_priority PARAMS ((rtx));
-static void advance_one_cycle PARAMS ((void));
+static unsigned int blockage_range (int, rtx);
+static void clear_units (void);
+static void schedule_unit (int, rtx, int);
+static int actual_hazard (int, rtx, int, int);
+static int potential_hazard (int, rtx, int);
+
+static int priority (rtx);
+static int rank_for_schedule (const void *, const void *);
+static void swap_sort (rtx *, int);
+static void queue_insn (rtx, int);
+static int schedule_insn (rtx, struct ready_list *, int);
+static int find_set_reg_weight (rtx);
+static void find_insn_reg_weight (int);
+static void adjust_priority (rtx);
+static void advance_one_cycle (void);
/* Notes handling mechanism:
=========================
unlink_other_notes ()). After scheduling the block, these notes are
inserted at the beginning of the block (in schedule_block()). */
-static rtx unlink_other_notes PARAMS ((rtx, rtx));
-static rtx unlink_line_notes PARAMS ((rtx, rtx));
-static rtx reemit_notes PARAMS ((rtx, rtx));
+static rtx unlink_other_notes (rtx, rtx);
+static rtx unlink_line_notes (rtx, rtx);
+static rtx reemit_notes (rtx, rtx);
-static rtx *ready_lastpos PARAMS ((struct ready_list *));
-static void ready_sort PARAMS ((struct ready_list *));
-static rtx ready_remove_first PARAMS ((struct ready_list *));
+static rtx *ready_lastpos (struct ready_list *);
+static void ready_sort (struct ready_list *);
+static rtx ready_remove_first (struct ready_list *);
-static void queue_to_ready PARAMS ((struct ready_list *));
+static void queue_to_ready (struct ready_list *);
-static void debug_ready_list PARAMS ((struct ready_list *));
+static void debug_ready_list (struct ready_list *);
-static rtx move_insn1 PARAMS ((rtx, rtx));
-static rtx move_insn PARAMS ((rtx, rtx));
+static rtx move_insn1 (rtx, rtx);
+static rtx move_insn (rtx, rtx);
/* The following functions are used to implement multi-pass scheduling
on the first cycle. It is used only for DFA based scheduler. */
-static rtx ready_element PARAMS ((struct ready_list *, int));
-static rtx ready_remove PARAMS ((struct ready_list *, int));
-static int max_issue PARAMS ((struct ready_list *, int *));
+static rtx ready_element (struct ready_list *, int);
+static rtx ready_remove (struct ready_list *, int);
+static int max_issue (struct ready_list *, int *);
-static rtx choose_ready PARAMS ((struct ready_list *));
+static rtx choose_ready (struct ready_list *);
#endif /* INSN_SCHEDULING */
\f
\f
#ifndef INSN_SCHEDULING
void
-schedule_insns (dump_file)
- FILE *dump_file ATTRIBUTE_UNUSED;
+schedule_insns (FILE *dump_file ATTRIBUTE_UNUSED)
{
}
#else
should never use the following function. */
HAIFA_INLINE int
-insn_unit (insn)
- rtx insn;
+insn_unit (rtx insn)
{
int unit = INSN_UNIT (insn);
function. */
HAIFA_INLINE static unsigned int
-blockage_range (unit, insn)
- int unit;
- rtx insn;
+blockage_range (int unit, rtx insn)
{
unsigned int blockage = INSN_BLOCKAGE (insn);
unsigned int range;
following function. */
rtx
-get_unit_last_insn (instance)
- int instance;
+get_unit_last_insn (int instance)
{
return unit_last_insn[instance];
}
/* Reset the function unit state to the null state. */
static void
-clear_units ()
+clear_units (void)
{
memset ((char *) unit_last_insn, 0, sizeof (unit_last_insn));
memset ((char *) unit_tick, 0, sizeof (unit_tick));
description should never use the following function. */
HAIFA_INLINE int
-insn_issue_delay (insn)
- rtx insn;
+insn_issue_delay (rtx insn)
{
int i, delay = 0;
int unit = insn_unit (insn);
use the following function. */
HAIFA_INLINE int
-actual_hazard_this_instance (unit, instance, insn, clock, cost)
- int unit, instance, clock, cost;
- rtx insn;
+actual_hazard_this_instance (int unit, int instance, rtx insn, int clock, int cost)
{
int tick = unit_tick[instance]; /* Issue time of the last issued insn. */
never use the following function. */
HAIFA_INLINE static void
-schedule_unit (unit, insn, clock)
- int unit, clock;
- rtx insn;
+schedule_unit (int unit, rtx insn, int clock)
{
int i;
use the following function. */
HAIFA_INLINE static int
-actual_hazard (unit, insn, clock, cost)
- int unit, clock, cost;
- rtx insn;
+actual_hazard (int unit, rtx insn, int clock, int cost)
{
int i;
the following function. */
HAIFA_INLINE static int
-potential_hazard (unit, insn, cost)
- int unit, cost;
- rtx insn;
+potential_hazard (int unit, rtx insn, int cost)
{
int i, ncost;
unsigned int minb, maxb;
instruction results. */
HAIFA_INLINE int
-insn_cost (insn, link, used)
- rtx insn, link, used;
+insn_cost (rtx insn, rtx link, rtx used)
{
int cost = INSN_COST (insn);
cost = insn_default_latency (insn);
else
cost = result_ready_cost (insn);
-
+
if (cost < 0)
cost = 0;
-
+
INSN_COST (insn) = cost;
}
}
if (cost < 0)
cost = 0;
}
-
+
return cost;
}
/* Compute the priority number for INSN. */
static int
-priority (insn)
- rtx insn;
+priority (rtx insn)
{
rtx link;
unstable. */
static int
-rank_for_schedule (x, y)
- const void *x;
- const void *y;
+rank_for_schedule (const void *x, const void *y)
{
rtx tmp = *(const rtx *) y;
rtx tmp2 = *(const rtx *) x;
/* Resort the array A in which only element at index N may be out of order. */
HAIFA_INLINE static void
-swap_sort (a, n)
- rtx *a;
- int n;
+swap_sort (rtx *a, int n)
{
rtx insn = a[n - 1];
int i = n - 2;
chain for debugging purposes. */
HAIFA_INLINE static void
-queue_insn (insn, n_cycles)
- rtx insn;
- int n_cycles;
+queue_insn (rtx insn, int n_cycles)
{
int next_q = NEXT_Q_AFTER (q_ptr, n_cycles);
rtx link = alloc_INSN_LIST (insn, insn_queue[next_q]);
with the lowest priority. */
HAIFA_INLINE static rtx *
-ready_lastpos (ready)
- struct ready_list *ready;
+ready_lastpos (struct ready_list *ready)
{
if (ready->n_ready == 0)
abort ();
priority. */
HAIFA_INLINE void
-ready_add (ready, insn)
- struct ready_list *ready;
- rtx insn;
+ready_add (struct ready_list *ready, rtx insn)
{
if (ready->first == ready->n_ready)
{
return it. */
HAIFA_INLINE static rtx
-ready_remove_first (ready)
- struct ready_list *ready;
+ready_remove_first (struct ready_list *ready)
{
rtx t;
if (ready->n_ready == 0)
N_READY - 1. */
HAIFA_INLINE static rtx
-ready_element (ready, index)
- struct ready_list *ready;
- int index;
+ready_element (struct ready_list *ready, int index)
{
#ifdef ENABLE_CHECKING
if (ready->n_ready == 0 || index >= ready->n_ready)
has N_READY - 1. */
HAIFA_INLINE static rtx
-ready_remove (ready, index)
- struct ready_list *ready;
- int index;
+ready_remove (struct ready_list *ready, int index)
{
rtx t;
int i;
macro. */
HAIFA_INLINE static void
-ready_sort (ready)
- struct ready_list *ready;
+ready_sort (struct ready_list *ready)
{
rtx *first = ready_lastpos (ready);
SCHED_SORT (first, ready->n_ready);
provide a hook for the target to tweek itself. */
HAIFA_INLINE static void
-adjust_priority (prev)
- rtx prev;
+adjust_priority (rtx prev)
{
/* ??? There used to be code here to try and estimate how an insn
affected register lifetimes, but it did it by looking at REG_DEAD
/* Advance time on one cycle. */
HAIFA_INLINE static void
-advance_one_cycle ()
+advance_one_cycle (void)
{
if (targetm.sched.use_dfa_pipeline_interface
&& (*targetm.sched.use_dfa_pipeline_interface) ())
zero for insns in a schedule group). */
static int
-schedule_insn (insn, ready, clock)
- rtx insn;
- struct ready_list *ready;
- int clock;
+schedule_insn (rtx insn, struct ready_list *ready, int clock)
{
rtx link;
int advance = 0;
if (MAX_BLOCKAGE > 1 || issue_rate > 1 || sched_verbose)
schedule_unit (unit, insn, clock);
-
+
if (INSN_DEPEND (insn) == 0)
return 0;
}
Returns the insn following the notes. */
static rtx
-unlink_other_notes (insn, tail)
- rtx insn, tail;
+unlink_other_notes (rtx insn, rtx tail)
{
rtx prev = PREV_INSN (insn);
they can be reused. Returns the insn following the notes. */
static rtx
-unlink_line_notes (insn, tail)
- rtx insn, tail;
+unlink_line_notes (rtx insn, rtx tail)
{
rtx prev = PREV_INSN (insn);
/* Return the head and tail pointers of BB. */
void
-get_block_head_tail (b, headp, tailp)
- int b;
- rtx *headp;
- rtx *tailp;
+get_block_head_tail (int b, rtx *headp, rtx *tailp)
{
/* HEAD and TAIL delimit the basic block being scheduled. */
rtx head = BLOCK_HEAD (b);
/* Return nonzero if there are no real insns in the range [ HEAD, TAIL ]. */
int
-no_real_insns_p (head, tail)
- rtx head, tail;
+no_real_insns_p (rtx head, rtx tail)
{
while (head != NEXT_INSN (tail))
{
block in which notes should be processed. */
void
-rm_line_notes (head, tail)
- rtx head, tail;
+rm_line_notes (rtx head, rtx tail)
{
rtx next_tail;
rtx insn;
the boundaries of the block in which notes should be processed. */
void
-save_line_notes (b, head, tail)
- int b;
- rtx head, tail;
+save_line_notes (int b, rtx head, rtx tail)
{
rtx next_tail;
be processed. */
void
-restore_line_notes (head, tail)
- rtx head, tail;
+restore_line_notes (rtx head, rtx tail)
{
rtx line, note, prev, new;
int added_notes = 0;
insns list. */
void
-rm_redundant_line_notes ()
+rm_redundant_line_notes (void)
{
rtx line = 0;
rtx insn = get_insns ();
of notes ended by NOTE_LIST. */
void
-rm_other_notes (head, tail)
- rtx head;
- rtx tail;
+rm_other_notes (rtx head, rtx tail)
{
rtx next_tail;
rtx insn;
a new register is not needed. */
static int
-find_set_reg_weight (x)
- rtx x;
+find_set_reg_weight (rtx x)
{
if (GET_CODE (x) == CLOBBER
&& register_operand (SET_DEST (x), VOIDmode))
/* Calculate INSN_REG_WEIGHT for all insns of a block. */
static void
-find_insn_reg_weight (b)
- int b;
+find_insn_reg_weight (int b)
{
rtx insn, next_tail, head, tail;
x = PATTERN (insn);
reg_weight += find_set_reg_weight (x);
if (GET_CODE (x) == PARALLEL)
- {
- int j;
- for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
- {
- x = XVECEXP (PATTERN (insn), 0, j);
+ {
+ int j;
+ for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
+ {
+ x = XVECEXP (PATTERN (insn), 0, j);
reg_weight += find_set_reg_weight (x);
- }
- }
+ }
+ }
/* Decrement weight for each register that dies here. */
for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
{
/* Move insns that became ready to fire from queue to ready list. */
static void
-queue_to_ready (ready)
- struct ready_list *ready;
+queue_to_ready (struct ready_list *ready)
{
rtx insn;
rtx link;
/* Print the ready list for debugging purposes. Callable from debugger. */
static void
-debug_ready_list (ready)
- struct ready_list *ready;
+debug_ready_list (struct ready_list *ready)
{
rtx *p;
int i;
/* move_insn1: Remove INSN from insn chain, and link it after LAST insn. */
static rtx
-move_insn1 (insn, last)
- rtx insn, last;
+move_insn1 (rtx insn, rtx last)
{
NEXT_INSN (PREV_INSN (insn)) = NEXT_INSN (insn);
PREV_INSN (NEXT_INSN (insn)) = PREV_INSN (insn);
output by the instruction scheduler. Return the new value of LAST. */
static rtx
-reemit_notes (insn, last)
- rtx insn;
- rtx last;
+reemit_notes (rtx insn, rtx last)
{
rtx note, retval;
return value from the first call to reemit_notes. */
static rtx
-move_insn (insn, last)
- rtx insn, last;
+move_insn (rtx insn, rtx last)
{
rtx retval = NULL;
of the best insn in READY. The following function is used only for
first cycle multipass scheduling. */
static int
-max_issue (ready, index)
- struct ready_list *ready;
- int *index;
+max_issue (struct ready_list *ready, int *index)
{
int n, i, all, n_ready, best, delay, tries_num;
struct choice_entry *top;
cycle multipass scheduling. */
static rtx
-choose_ready (ready)
- struct ready_list *ready;
+choose_ready (struct ready_list *ready)
{
int lookahead = 0;
the instruction stream. */
rtx
-sched_emit_insn (pat)
- rtx pat;
+sched_emit_insn (rtx pat)
{
rtx insn = emit_insn_after (pat, last_scheduled_insn);
last_scheduled_insn = insn;
possibly bringing insns from subsequent blocks in the same region. */
void
-schedule_block (b, rgn_n_insns)
- int b;
- int rgn_n_insns;
+schedule_block (int b, int rgn_n_insns)
{
struct ready_list ready;
int i, first_cycle_insn_p;
start_clock_var = clock_var;
clock_var++;
-
+
advance_one_cycle ();
-
+
/* Add to the ready list all pending insns that can be issued now.
If there are no ready insns, increment clock until one
is ready and add all pending insns at that point to the ready
list. */
queue_to_ready (&ready);
-
+
if (ready.n_ready == 0)
abort ();
-
+
if (sched_verbose >= 2)
{
fprintf (sched_dump, ";;\t\tReady list after queue_to_ready: ");
{
/* Sort the ready list based on priority. */
ready_sort (&ready);
-
+
if (sched_verbose >= 2)
{
fprintf (sched_dump, ";;\t\tReady list after ready_sort: ");
|| state_dead_lock_p (curr_state)
|| !(*current_sched_info->schedule_more_p) ())
break;
-
+
/* Select and remove the insn from the ready list. */
if (sort_p)
insn = choose_ready (&ready);
else
insn = ready_remove_first (&ready);
-
+
if (targetm.sched.dfa_new_cycle
&& (*targetm.sched.dfa_new_cycle) (sched_dump, sched_verbose,
insn, last_clock_var,
ready_add (&ready, insn);
break;
}
-
+
sort_p = TRUE;
memcpy (temp_state, curr_state, dfa_state_size);
if (recog_memoized (insn) < 0)
{
int j;
rtx bubble;
-
+
for (j = 0;
(bubble = (*targetm.sched.dfa_bubble) (j))
!= NULL_RTX;
j++)
{
memcpy (temp_state, curr_state, dfa_state_size);
-
+
if (state_transition (temp_state, bubble) < 0
&& state_transition (temp_state, insn) < 0)
break;
}
-
+
if (bubble != NULL_RTX)
{
if (insert_schedule_bubbles_p)
{
rtx copy;
-
+
copy = copy_rtx (PATTERN (bubble));
emit_insn_after (copy, last_scheduled_insn);
last_scheduled_insn
= NEXT_INSN (last_scheduled_insn);
INSN_CODE (last_scheduled_insn)
= INSN_CODE (bubble);
-
+
/* Annotate the same for the first insns
scheduling by using mode. */
PUT_MODE (last_scheduled_insn,
? clock_var - last_clock_var
: VOIDmode));
last_clock_var = clock_var;
-
+
if (sched_verbose >= 2)
{
fprintf (sched_dump,
";;\t\t--> scheduling bubble insn <<<%d>>>:reservation ",
INSN_UID (last_scheduled_insn));
-
+
if (recog_memoized (last_scheduled_insn)
< 0)
fprintf (sched_dump, "nothing");
else
print_reservation
(sched_dump, last_scheduled_insn);
-
+
fprintf (sched_dump, "\n");
}
}
cycle_issued_insns++;
memcpy (curr_state, temp_state, dfa_state_size);
}
-
+
if (targetm.sched.variable_issue)
can_issue_more =
(*targetm.sched.variable_issue) (sched_dump, sched_verbose,
if (!reload_completed)
{
rtx insn, link, next;
-
+
/* INSN_TICK (minimum clock tick at which the insn becomes
ready) may be not correct for the insn in the subsequent
blocks of the region. We should use a correct value of
/* Set_priorities: compute priority of each insn in the block. */
int
-set_priorities (head, tail)
- rtx head, tail;
+set_priorities (rtx head, rtx tail)
{
rtx insn;
int n_insn;
for debugging output. */
void
-sched_init (dump_file)
- FILE *dump_file;
+sched_init (FILE *dump_file)
{
int luid;
basic_block b;
{
if (targetm.sched.init_dfa_pre_cycle_insn)
(*targetm.sched.init_dfa_pre_cycle_insn) ();
-
+
if (targetm.sched.init_dfa_post_cycle_insn)
(*targetm.sched.init_dfa_post_cycle_insn) ();
-
+
if (targetm.sched.first_cycle_multipass_dfa_lookahead
&& targetm.sched.init_dfa_bubbles)
(*targetm.sched.init_dfa_bubbles) ();
-
+
dfa_start ();
dfa_state_size = state_size ();
curr_state = xmalloc (dfa_state_size);
/* Free global data used during insn scheduling. */
void
-sched_finish ()
+sched_finish (void)
{
free (h_i_d);
/* Hash tables.
- Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
existing entry with a potential new one. Also, the ability to
delete members from the table has been removed. */
-static unsigned int calc_hash PARAMS ((const unsigned char *, unsigned int));
-static void ht_expand PARAMS ((hash_table *));
+static unsigned int calc_hash (const unsigned char *, unsigned int);
+static void ht_expand (hash_table *);
/* Calculate the hash of the string STR of length LEN. */
static unsigned int
-calc_hash (str, len)
- const unsigned char *str;
- unsigned int len;
+calc_hash (const unsigned char *str, unsigned int len)
{
unsigned int n = len;
unsigned int r = 0;
/* Initialize an identifier hashtable. */
hash_table *
-ht_create (order)
- unsigned int order;
+ht_create (unsigned int order)
{
unsigned int nslots = 1 << order;
hash_table *table;
/* Frees all memory associated with a hash table. */
void
-ht_destroy (table)
- hash_table *table;
+ht_destroy (hash_table *table)
{
obstack_free (&table->stack, NULL);
free (table->entries);
CPP_ALLOCED and the item is assumed to be at the top of the
obstack. */
hashnode
-ht_lookup (table, str, len, insert)
- hash_table *table;
- const unsigned char *str;
- unsigned int len;
- enum ht_lookup_option insert;
+ht_lookup (hash_table *table, const unsigned char *str, unsigned int len,
+ enum ht_lookup_option insert)
{
unsigned int hash = calc_hash (str, len);
unsigned int hash2;
/* Double the size of a hash table, re-hashing existing entries. */
static void
-ht_expand (table)
- hash_table *table;
+ht_expand (hash_table *table)
{
hashnode *nentries, *p, *limit;
unsigned int size, sizemask;
/* For all nodes in TABLE, callback CB with parameters TABLE->PFILE,
the node, and V. */
void
-ht_forall (table, cb, v)
- hash_table *table;
- ht_cb cb;
- const void *v;
+ht_forall (hash_table *table, ht_cb cb, const void *v)
{
hashnode *p, *limit;
/* Dump allocation statistics to stderr. */
void
-ht_dump_statistics (table)
- hash_table *table;
+ht_dump_statistics (hash_table *table)
{
size_t nelts, nids, overhead, headers;
size_t total_bytes, longest, sum_of_squares;
nids++;
}
while (++p < limit);
-
+
nelts = table->nelements;
overhead = obstack_memory_used (&table->stack) - total_bytes;
headers = table->nslots * sizeof (hashnode);
/* Return the approximate positive square root of a number N. This is for
statistical reports, not code generation. */
double
-approx_sqrt (x)
- double x;
+approx_sqrt (double x)
{
double s, d;
/* Hash tables.
- Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
hashnode *entries;
/* Call back. */
- hashnode (*alloc_node) PARAMS ((hash_table *));
+ hashnode (*alloc_node) (hash_table *);
unsigned int nslots; /* Total slots in the entries array. */
unsigned int nelements; /* Number of live elements. */
};
/* Initialize the hashtable with 2 ^ order entries. */
-extern hash_table *ht_create PARAMS ((unsigned int order));
+extern hash_table *ht_create (unsigned int order);
/* Frees all memory associated with a hash table. */
-extern void ht_destroy PARAMS ((hash_table *));
+extern void ht_destroy (hash_table *);
-extern hashnode ht_lookup PARAMS ((hash_table *, const unsigned char *,
- unsigned int, enum ht_lookup_option));
+extern hashnode ht_lookup (hash_table *, const unsigned char *,
+ unsigned int, enum ht_lookup_option);
/* For all nodes in TABLE, make a callback. The callback takes
TABLE->PFILE, the node, and a PTR, and the callback sequence stops
if the callback returns zero. */
-typedef int (*ht_cb) PARAMS ((struct cpp_reader *, hashnode, const void *));
-extern void ht_forall PARAMS ((hash_table *, ht_cb, const void *));
+typedef int (*ht_cb) (struct cpp_reader *, hashnode, const void *);
+extern void ht_forall (hash_table *, ht_cb, const void *);
/* Dump allocation statistics to stderr. */
-extern void ht_dump_statistics PARAMS ((hash_table *));
+extern void ht_dump_statistics (hash_table *);
/* Approximate positive square root of a host double. This is for
statistical reports, not code generation. */
-extern double approx_sqrt PARAMS ((double));
+extern double approx_sqrt (double);
#endif /* GCC_HASHTABLE_H */
/* Generic hook that does absolutely zappo. */
void
-hook_void_void ()
+hook_void_void (void)
{
}
/* Generic hook that takes no arguments and returns false. */
bool
-hook_bool_void_false ()
+hook_bool_void_false (void)
{
return false;
}
/* Generic hook that takes (tree, int) and does nothing. */
void
-hook_void_tree_int (a, b)
- tree a ATTRIBUTE_UNUSED;
- int b ATTRIBUTE_UNUSED;
+hook_void_tree_int (tree a ATTRIBUTE_UNUSED, int b ATTRIBUTE_UNUSED)
{
}
/* Generic hook that takes (FILE *, const char *) and does nothing. */
void
-hook_void_FILEptr_constcharptr (a, b)
- FILE *a ATTRIBUTE_UNUSED;
- const char *b ATTRIBUTE_UNUSED;
+hook_void_FILEptr_constcharptr (FILE *a ATTRIBUTE_UNUSED, const char *b ATTRIBUTE_UNUSED)
{
}
/* Used for the TARGET_ASM_CAN_OUTPUT_MI_THUNK hook. */
bool
-hook_bool_tree_hwi_hwi_tree_false (a, b, c, d)
- tree a ATTRIBUTE_UNUSED;
- HOST_WIDE_INT b ATTRIBUTE_UNUSED;
- HOST_WIDE_INT c ATTRIBUTE_UNUSED;
- tree d ATTRIBUTE_UNUSED;
+hook_bool_tree_hwi_hwi_tree_false (tree a ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT b ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT c ATTRIBUTE_UNUSED,
+ tree d ATTRIBUTE_UNUSED)
{
return false;
}
bool
-hook_bool_tree_hwi_hwi_tree_true (a, b, c, d)
- tree a ATTRIBUTE_UNUSED;
- HOST_WIDE_INT b ATTRIBUTE_UNUSED;
- HOST_WIDE_INT c ATTRIBUTE_UNUSED;
- tree d ATTRIBUTE_UNUSED;
+hook_bool_tree_hwi_hwi_tree_true (tree a ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT b ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT c ATTRIBUTE_UNUSED,
+ tree d ATTRIBUTE_UNUSED)
{
return true;
}
bool
-default_can_output_mi_thunk_no_vcall (a, b, c, d)
- tree a ATTRIBUTE_UNUSED;
- HOST_WIDE_INT b ATTRIBUTE_UNUSED;
- HOST_WIDE_INT c;
- tree d ATTRIBUTE_UNUSED;
+default_can_output_mi_thunk_no_vcall (tree a ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT b ATTRIBUTE_UNUSED,
+ HOST_WIDE_INT c,
+ tree d ATTRIBUTE_UNUSED)
{
return c == 0;
}
/* ??? Used for comp_type_attributes, which ought to return bool. */
int
-hook_int_tree_tree_1 (a, b)
- tree a ATTRIBUTE_UNUSED;
- tree b ATTRIBUTE_UNUSED;
+hook_int_tree_tree_1 (tree a ATTRIBUTE_UNUSED, tree b ATTRIBUTE_UNUSED)
{
return 1;
}
int
-hook_int_rtx_0 (a)
- rtx a ATTRIBUTE_UNUSED;
+hook_int_rtx_0 (rtx a ATTRIBUTE_UNUSED)
{
return 0;
}
}
void
-hook_void_tree (a)
- tree a ATTRIBUTE_UNUSED;
+hook_void_tree (tree a ATTRIBUTE_UNUSED)
{
}
void
-hook_void_tree_treeptr (a, b)
- tree a ATTRIBUTE_UNUSED;
- tree *b ATTRIBUTE_UNUSED;
+hook_void_tree_treeptr (tree a ATTRIBUTE_UNUSED, tree *b ATTRIBUTE_UNUSED)
{
}
bool
-hook_bool_tree_false (a)
- tree a ATTRIBUTE_UNUSED;
+hook_bool_tree_false (tree a ATTRIBUTE_UNUSED)
{
return false;
}
bool
-hook_bool_tree_tree_false (a, b)
- tree a ATTRIBUTE_UNUSED;
- tree b ATTRIBUTE_UNUSED;
+hook_bool_tree_tree_false (tree a ATTRIBUTE_UNUSED, tree b ATTRIBUTE_UNUSED)
{
return false;
}
bool
-hook_bool_rtx_false (a)
- rtx a ATTRIBUTE_UNUSED;
+hook_bool_rtx_false (rtx a ATTRIBUTE_UNUSED)
{
return false;
}
bool
-hook_bool_rtx_int_int_intp_false (a, b, c, d)
- rtx a ATTRIBUTE_UNUSED;
- int b ATTRIBUTE_UNUSED;
- int c ATTRIBUTE_UNUSED;
- int *d ATTRIBUTE_UNUSED;
+hook_bool_rtx_int_int_intp_false (rtx a ATTRIBUTE_UNUSED,
+ int b ATTRIBUTE_UNUSED,
+ int c ATTRIBUTE_UNUSED,
+ int *d ATTRIBUTE_UNUSED)
{
return false;
}
/* Generic hook that takes an rtx and returns it. */
rtx
-hook_rtx_rtx_identity (x)
- rtx x;
+hook_rtx_rtx_identity (rtx x)
{
return x;
}
/* Generic hook that takes an rtx and returns NULL_RTX. */
rtx
-hook_rtx_rtx_null (x)
- rtx x ATTRIBUTE_UNUSED;
+hook_rtx_rtx_null (rtx x ATTRIBUTE_UNUSED)
{
return 0;
}
#ifndef GCC_HOOKS_H
#define GCC_HOOKS_H
-bool hook_bool_void_false PARAMS ((void));
+bool hook_bool_void_false (void);
bool hook_bool_bool_false (bool);
-bool hook_bool_tree_false PARAMS ((tree));
-bool hook_bool_tree_hwi_hwi_tree_false
- PARAMS ((tree, HOST_WIDE_INT, HOST_WIDE_INT, tree));
-bool hook_bool_tree_hwi_hwi_tree_true
- PARAMS ((tree, HOST_WIDE_INT, HOST_WIDE_INT, tree));
-bool hook_bool_rtx_false PARAMS ((rtx));
-bool hook_bool_rtx_int_int_intp_false PARAMS ((rtx, int, int, int *));
-
-void hook_void_tree_int PARAMS ((tree, int));
-void hook_void_void PARAMS ((void));
-void hook_void_FILEptr_constcharptr PARAMS ((FILE *, const char *));
-void hook_void_tree PARAMS ((tree));
-void hook_void_tree_treeptr PARAMS ((tree, tree *));
-
-int hook_int_tree_tree_1 PARAMS ((tree, tree));
-int hook_int_rtx_0 PARAMS ((rtx));
+bool hook_bool_tree_false (tree);
+bool hook_bool_tree_hwi_hwi_tree_false (tree, HOST_WIDE_INT, HOST_WIDE_INT,
+ tree);
+bool hook_bool_tree_hwi_hwi_tree_true (tree, HOST_WIDE_INT, HOST_WIDE_INT,
+ tree);
+bool hook_bool_rtx_false (rtx);
+bool hook_bool_rtx_int_int_intp_false (rtx, int, int, int *);
+
+void hook_void_tree_int (tree, int);
+void hook_void_void (void);
+void hook_void_FILEptr_constcharptr (FILE *, const char *);
+void hook_void_tree (tree);
+void hook_void_tree_treeptr (tree, tree *);
+
+int hook_int_tree_tree_1 (tree, tree);
+int hook_int_rtx_0 (rtx);
int hook_int_void_0 (void);
int hook_int_size_t_constcharptr_int_0 (size_t, const char *, int);
int hook_int_void_no_regs (void);
unsigned hook_uint_uint_constcharptrptr_0 (unsigned, const char **);
-bool default_can_output_mi_thunk_no_vcall
- PARAMS ((tree, HOST_WIDE_INT, HOST_WIDE_INT, tree));
+bool default_can_output_mi_thunk_no_vcall (tree, HOST_WIDE_INT,
+ HOST_WIDE_INT, tree);
-bool hook_bool_tree_tree_false PARAMS ((tree, tree));
+bool hook_bool_tree_tree_false (tree, tree);
-rtx hook_rtx_rtx_identity PARAMS ((rtx));
-rtx hook_rtx_rtx_null PARAMS ((rtx));
+rtx hook_rtx_rtx_identity (rtx);
+rtx hook_rtx_rtx_null (rtx);
#endif
#ifndef GCC_HOST_HOOKS_H
#define GCC_HOST_HOOKS_H
-struct host_hooks
+struct host_hooks
{
- void (*extra_signals) PARAMS((void));
+ void (*extra_signals) (void);
/* Whenever you add entries here, make sure you adjust hosthooks-def.h. */
};
/* If-conversion support.
- Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
static dominance_info post_dominators;
/* Forward references. */
-static int count_bb_insns PARAMS ((basic_block));
-static rtx first_active_insn PARAMS ((basic_block));
-static rtx last_active_insn PARAMS ((basic_block, int));
-static int seq_contains_jump PARAMS ((rtx));
-static basic_block block_fallthru PARAMS ((basic_block));
-static int cond_exec_process_insns PARAMS ((ce_if_block_t *,
- rtx, rtx, rtx, rtx, int));
-static rtx cond_exec_get_condition PARAMS ((rtx));
-static int cond_exec_process_if_block PARAMS ((ce_if_block_t *, int));
-static rtx noce_get_condition PARAMS ((rtx, rtx *));
-static int noce_operand_ok PARAMS ((rtx));
-static int noce_process_if_block PARAMS ((ce_if_block_t *));
-static int process_if_block PARAMS ((ce_if_block_t *));
-static void merge_if_block PARAMS ((ce_if_block_t *));
-static int find_cond_trap PARAMS ((basic_block, edge, edge));
-static basic_block find_if_header PARAMS ((basic_block, int));
-static int block_jumps_and_fallthru_p PARAMS ((basic_block, basic_block));
-static int find_if_block PARAMS ((ce_if_block_t *));
-static int find_if_case_1 PARAMS ((basic_block, edge, edge));
-static int find_if_case_2 PARAMS ((basic_block, edge, edge));
-static int find_memory PARAMS ((rtx *, void *));
-static int dead_or_predicable PARAMS ((basic_block, basic_block,
- basic_block, basic_block, int));
-static void noce_emit_move_insn PARAMS ((rtx, rtx));
-static rtx block_has_only_trap PARAMS ((basic_block));
+static int count_bb_insns (basic_block);
+static rtx first_active_insn (basic_block);
+static rtx last_active_insn (basic_block, int);
+static int seq_contains_jump (rtx);
+static basic_block block_fallthru (basic_block);
+static int cond_exec_process_insns (ce_if_block_t *, rtx, rtx, rtx, rtx, int);
+static rtx cond_exec_get_condition (rtx);
+static int cond_exec_process_if_block (ce_if_block_t *, int);
+static rtx noce_get_condition (rtx, rtx *);
+static int noce_operand_ok (rtx);
+static int noce_process_if_block (ce_if_block_t *);
+static int process_if_block (ce_if_block_t *);
+static void merge_if_block (ce_if_block_t *);
+static int find_cond_trap (basic_block, edge, edge);
+static basic_block find_if_header (basic_block, int);
+static int block_jumps_and_fallthru_p (basic_block, basic_block);
+static int find_if_block (ce_if_block_t *);
+static int find_if_case_1 (basic_block, edge, edge);
+static int find_if_case_2 (basic_block, edge, edge);
+static int find_memory (rtx *, void *);
+static int dead_or_predicable (basic_block, basic_block, basic_block,
+ basic_block, int);
+static void noce_emit_move_insn (rtx, rtx);
+static rtx block_has_only_trap (basic_block);
\f
/* Count the number of non-jump active insns in BB. */
static int
-count_bb_insns (bb)
- basic_block bb;
+count_bb_insns (basic_block bb)
{
int count = 0;
rtx insn = bb->head;
/* Return the first non-jump active insn in the basic block. */
static rtx
-first_active_insn (bb)
- basic_block bb;
+first_active_insn (basic_block bb)
{
rtx insn = bb->head;
/* Return the last non-jump active (non-jump) insn in the basic block. */
static rtx
-last_active_insn (bb, skip_use_p)
- basic_block bb;
- int skip_use_p;
+last_active_insn (basic_block bb, int skip_use_p)
{
rtx insn = bb->end;
rtx head = bb->head;
return insn;
}
-/* It is possible, especially when having dealt with multi-word
+/* It is possible, especially when having dealt with multi-word
arithmetic, for the expanders to have emitted jumps. Search
through the sequence and return TRUE if a jump exists so that
we can abort the conversion. */
static int
-seq_contains_jump (insn)
- rtx insn;
+seq_contains_jump (rtx insn)
{
while (insn)
{
}
static basic_block
-block_fallthru (bb)
- basic_block bb;
+block_fallthru (basic_block bb)
{
edge e;
insns were processed. */
static int
-cond_exec_process_insns (ce_info, start, end, test, prob_val, mod_ok)
- ce_if_block_t *ce_info ATTRIBUTE_UNUSED; /* if block information */
- rtx start; /* first insn to look at */
- rtx end; /* last insn to look at */
- rtx test; /* conditional execution test */
- rtx prob_val; /* probability of branch taken. */
- int mod_ok; /* true if modifications ok last insn. */
+cond_exec_process_insns (ce_if_block_t *ce_info ATTRIBUTE_UNUSED,
+ /* if block information */rtx start,
+ /* first insn to look at */rtx end,
+ /* last insn to look at */rtx test,
+ /* conditional execution test */rtx prob_val,
+ /* probability of branch taken. */int mod_ok)
{
int must_be_last = FALSE;
rtx insn;
/* Remove USE insns that get in the way. */
if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
{
- /* ??? Ug. Actually unlinking the thing is problematic,
+ /* ??? Ug. Actually unlinking the thing is problematic,
given what we'd have to coordinate with our callers. */
PUT_CODE (insn, NOTE);
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
/* Return the condition for a jump. Do not do any special processing. */
static rtx
-cond_exec_get_condition (jump)
- rtx jump;
+cond_exec_get_condition (rtx jump)
{
rtx test_if, cond;
converting the block. */
static int
-cond_exec_process_if_block (ce_info, do_multiple_p)
- ce_if_block_t * ce_info; /* if block information */
- int do_multiple_p; /* != 0 if we should handle && and || blocks */
+cond_exec_process_if_block (ce_if_block_t * ce_info,
+ /* if block information */int do_multiple_p)
{
basic_block test_bb = ce_info->test_bb; /* last test block */
basic_block then_bb = ce_info->then_bb; /* THEN */
/* Map test_expr/test_jump into the appropriate MD tests to use on
the conditionally executed code. */
-
+
true_expr = test_expr;
false_code = reversed_comparison_code (true_expr, test_bb->end);
return FALSE;
}
\f
-/* Used by noce_process_if_block to communicate with its subroutines.
+/* Used by noce_process_if_block to communicate with its subroutines.
The subroutines know that A and B may be evaluated freely. They
- know that X is a register. They should insert new instructions
+ know that X is a register. They should insert new instructions
before cond_earliest. */
struct noce_if_info
rtx jump, cond, cond_earliest;
};
-static rtx noce_emit_store_flag PARAMS ((struct noce_if_info *,
- rtx, int, int));
-static int noce_try_store_flag PARAMS ((struct noce_if_info *));
-static int noce_try_addcc PARAMS ((struct noce_if_info *));
-static int noce_try_store_flag_constants PARAMS ((struct noce_if_info *));
-static int noce_try_store_flag_mask PARAMS ((struct noce_if_info *));
-static rtx noce_emit_cmove PARAMS ((struct noce_if_info *,
- rtx, enum rtx_code, rtx,
- rtx, rtx, rtx));
-static int noce_try_cmove PARAMS ((struct noce_if_info *));
-static int noce_try_cmove_arith PARAMS ((struct noce_if_info *));
-static rtx noce_get_alt_condition PARAMS ((struct noce_if_info *,
- rtx, rtx *));
-static int noce_try_minmax PARAMS ((struct noce_if_info *));
-static int noce_try_abs PARAMS ((struct noce_if_info *));
+static rtx noce_emit_store_flag (struct noce_if_info *, rtx, int, int);
+static int noce_try_store_flag (struct noce_if_info *);
+static int noce_try_addcc (struct noce_if_info *);
+static int noce_try_store_flag_constants (struct noce_if_info *);
+static int noce_try_store_flag_mask (struct noce_if_info *);
+static rtx noce_emit_cmove (struct noce_if_info *, rtx, enum rtx_code, rtx,
+ rtx, rtx, rtx);
+static int noce_try_cmove (struct noce_if_info *);
+static int noce_try_cmove_arith (struct noce_if_info *);
+static rtx noce_get_alt_condition (struct noce_if_info *, rtx, rtx *);
+static int noce_try_minmax (struct noce_if_info *);
+static int noce_try_abs (struct noce_if_info *);
/* Helper function for noce_try_store_flag*. */
static rtx
-noce_emit_store_flag (if_info, x, reversep, normalize)
- struct noce_if_info *if_info;
- rtx x;
- int reversep, normalize;
+noce_emit_store_flag (struct noce_if_info *if_info, rtx x, int reversep,
+ int normalize)
{
rtx cond = if_info->cond;
int cond_complex;
/* Emit instruction to move an rtx into STRICT_LOW_PART. */
static void
-noce_emit_move_insn (x, y)
- rtx x, y;
+noce_emit_move_insn (rtx x, rtx y)
{
enum machine_mode outmode, inmode;
rtx outer, inner;
a go at the conversion. */
static int
-noce_try_store_flag (if_info)
- struct noce_if_info *if_info;
+noce_try_store_flag (struct noce_if_info *if_info)
{
int reversep;
rtx target, seq;
/* Convert "if (test) x = a; else x = b", for A and B constant. */
static int
-noce_try_store_flag_constants (if_info)
- struct noce_if_info *if_info;
+noce_try_store_flag_constants (struct noce_if_info *if_info)
{
rtx target, seq;
int reversep;
return FALSE;
if (reversep)
- {
+ {
tmp = itrue; itrue = ifalse; ifalse = tmp;
diff = trunc_int_for_mode (-diff, mode);
}
return FALSE;
}
-/* Convert "if (test) foo++" into "foo += (test != 0)", and
+/* Convert "if (test) foo++" into "foo += (test != 0)", and
similarly for "foo--". */
static int
-noce_try_addcc (if_info)
- struct noce_if_info *if_info;
+noce_try_addcc (struct noce_if_info *if_info)
{
rtx target, seq;
int subtract, normalize;
}
end_sequence ();
}
-
+
/* If that fails, construct conditional increment or decrement using
setcc. */
if (BRANCH_COST >= 2
/* Convert "if (test) x = 0;" to "x &= -(test == 0);" */
static int
-noce_try_store_flag_mask (if_info)
- struct noce_if_info *if_info;
+noce_try_store_flag_mask (struct noce_if_info *if_info)
{
rtx target, seq;
int reversep;
/* Helper function for noce_try_cmove and noce_try_cmove_arith. */
static rtx
-noce_emit_cmove (if_info, x, code, cmp_a, cmp_b, vfalse, vtrue)
- struct noce_if_info *if_info;
- rtx x, cmp_a, cmp_b, vfalse, vtrue;
- enum rtx_code code;
+noce_emit_cmove (struct noce_if_info *if_info, rtx x, enum rtx_code code,
+ rtx cmp_a, rtx cmp_b, rtx vfalse, rtx vtrue)
{
/* If earliest == jump, try to build the cmove insn directly.
This is helpful when combine has created some complex condition
#else
/* We'll never get here, as noce_process_if_block doesn't call the
functions involved. Ifdef code, however, should be discouraged
- because it leads to typos in the code not selected. However,
+ because it leads to typos in the code not selected. However,
emit_conditional_move won't exist either. */
return NULL_RTX;
#endif
has had a go at it. */
static int
-noce_try_cmove (if_info)
- struct noce_if_info *if_info;
+noce_try_cmove (struct noce_if_info *if_info)
{
enum rtx_code code;
rtx target, seq;
/* Try more complex cases involving conditional_move. */
static int
-noce_try_cmove_arith (if_info)
- struct noce_if_info *if_info;
+noce_try_cmove_arith (struct noce_if_info *if_info)
{
rtx a = if_info->a;
rtx b = if_info->b;
if (test)
x = y;
*/
-
+
code = GET_CODE (if_info->cond);
insn_a = if_info->insn_a;
insn_b = if_info->insn_b;
/* If either operand is complex, load it into a register first.
The best way to do this is to copy the original insn. In this
- way we preserve any clobbers etc that the insn may have had.
+ way we preserve any clobbers etc that the insn may have had.
This is of course not possible in the IS_MEM case. */
if (! general_operand (a, GET_MODE (a)))
{
For these we wish to know that it is A or B in the condition. */
static rtx
-noce_get_alt_condition (if_info, target, earliest)
- struct noce_if_info *if_info;
- rtx target;
- rtx *earliest;
+noce_get_alt_condition (struct noce_if_info *if_info, rtx target,
+ rtx *earliest)
{
rtx cond, set, insn;
int reverse;
/* Convert "if (a < b) x = a; else x = b;" to "x = min(a, b);", etc. */
static int
-noce_try_minmax (if_info)
- struct noce_if_info *if_info;
-{
+noce_try_minmax (struct noce_if_info *if_info)
+{
rtx cond, earliest, target, seq;
enum rtx_code code, op;
int unsignedp;
noce_emit_move_insn (if_info->x, target);
seq = get_insns ();
- end_sequence ();
+ end_sequence ();
if (seq_contains_jump (seq))
return FALSE;
/* Convert "if (a < 0) x = -a; else x = a;" to "x = abs(a);", etc. */
static int
-noce_try_abs (if_info)
- struct noce_if_info *if_info;
-{
+noce_try_abs (struct noce_if_info *if_info)
+{
rtx cond, earliest, target, seq, a, b, c;
int negate;
}
else
return FALSE;
-
+
cond = noce_get_alt_condition (if_info, b, &earliest);
if (!cond)
return FALSE;
for (insn = earliest;
insn != if_info->test_bb->head;
insn = PREV_INSN (insn))
- if (INSN_P (insn)
+ if (INSN_P (insn)
&& ((note = find_reg_note (insn, REG_EQUAL, c))
|| (note = find_reg_note (insn, REG_EQUIV, c))))
break;
c = get_pool_constant (XEXP (c, 0));
/* Work around funny ideas get_condition has wrt canonicalization.
- Note that these rtx constants are known to be CONST_INT, and
+ Note that these rtx constants are known to be CONST_INT, and
therefore imply integer comparisons. */
if (c == constm1_rtx && GET_CODE (cond) == GT)
;
noce_emit_move_insn (if_info->x, target);
seq = get_insns ();
- end_sequence ();
+ end_sequence ();
if (seq_contains_jump (seq))
return FALSE;
valid at JUMP, instead of at EARLIEST. */
static rtx
-noce_get_condition (jump, earliest)
- rtx jump;
- rtx *earliest;
+noce_get_condition (rtx jump, rtx *earliest)
{
rtx cond, set, tmp, insn;
bool reverse;
/* Return true if OP is ok for if-then-else processing. */
static int
-noce_operand_ok (op)
- rtx op;
+noce_operand_ok (rtx op)
{
/* We special-case memories, so handle any of them with
no address side effects. */
successful at converting the block. */
static int
-noce_process_if_block (ce_info)
- struct ce_if_block * ce_info;
+noce_process_if_block (struct ce_if_block * ce_info)
{
basic_block test_bb = ce_info->test_bb; /* test block */
basic_block then_bb = ce_info->then_bb; /* THEN */
/* If x has side effects then only the if-then-else form is safe to
convert. But even in that case we would need to restore any notes
- (such as REG_INC) at then end. That can be tricky if
+ (such as REG_INC) at then end. That can be tricky if
noce_emit_move_insn expands to more than one insn, so disable the
optimization entirely for now if there are side effects. */
if (side_effects_p (x))
x must be executed twice. */
else if (insn_b && side_effects_p (orig_x))
return FALSE;
-
+
x = orig_x;
goto success;
}
straight line code. Return true if successful. */
static int
-process_if_block (ce_info)
- struct ce_if_block * ce_info;
+process_if_block (struct ce_if_block * ce_info)
{
if (! reload_completed
&& noce_process_if_block (ce_info))
/* Merge the blocks and mark for local life update. */
static void
-merge_if_block (ce_info)
- struct ce_if_block * ce_info;
+merge_if_block (struct ce_if_block * ce_info)
{
basic_block test_bb = ce_info->test_bb; /* last test block */
basic_block then_bb = ce_info->then_bb; /* THEN */
basic_block bb = test_bb;
basic_block last_test_bb = ce_info->last_test_bb;
basic_block fallthru = block_fallthru (bb);
-
+
do
{
bb = fallthru;
Since we've already merged the TEST, THEN and ELSE blocks, we should
have only one remaining edge from our if-then-else diamond. If there
is more than one remaining edge, it must come from elsewhere. There
- may be zero incoming edges if the THEN block didn't actually join
+ may be zero incoming edges if the THEN block didn't actually join
back up (as with a call to abort). */
else if ((join_bb->pred == NULL
|| join_bb->pred->pred_next == NULL)
first block if some transformation was done. Return NULL otherwise. */
static basic_block
-find_if_header (test_bb, pass)
- basic_block test_bb;
- int pass;
+find_if_header (basic_block test_bb, int pass)
{
ce_if_block_t ce_info;
edge then_edge;
of non-note, non-jump, non-USE/CLOBBER insns in the block. */
static int
-block_jumps_and_fallthru_p (cur_bb, target_bb)
- basic_block cur_bb;
- basic_block target_bb;
+block_jumps_and_fallthru_p (basic_block cur_bb, basic_block target_bb)
{
edge cur_edge;
int fallthru_p = FALSE;
Return TRUE if we were successful at converting the block. */
static int
-find_if_block (ce_info)
- struct ce_if_block * ce_info;
+find_if_block (struct ce_if_block * ce_info)
{
basic_block test_bb = ce_info->test_bb;
basic_block then_bb = ce_info->then_bb;
}
else if ((n_insns = block_jumps_and_fallthru_p (bb, then_bb)) >= 0)
{
- ce_info->and_and_p = FALSE;
+ ce_info->and_and_p = FALSE;
target_bb = then_bb;
}
else
/* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination. */
else
- return FALSE;
+ return FALSE;
num_possible_if_blocks++;
to a trap, into a conditional trap. */
static int
-find_cond_trap (test_bb, then_edge, else_edge)
- basic_block test_bb;
- edge then_edge, else_edge;
+find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge)
{
basic_block then_bb = then_edge->dest;
basic_block else_bb = else_edge->dest;
return TRUE;
}
-/* Subroutine of find_cond_trap: if BB contains only a trap insn,
+/* Subroutine of find_cond_trap: if BB contains only a trap insn,
return it. */
static rtx
-block_has_only_trap (bb)
- basic_block bb;
+block_has_only_trap (basic_block bb)
{
rtx trap;
/* Tests for case 1 above. */
static int
-find_if_case_1 (test_bb, then_edge, else_edge)
- basic_block test_bb;
- edge then_edge, else_edge;
+find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
{
basic_block then_bb = then_edge->dest;
basic_block else_bb = else_edge->dest, new_bb;
return FALSE;
/* Registers set are dead, or are predicable. */
- if (! dead_or_predicable (test_bb, then_bb, else_bb,
+ if (! dead_or_predicable (test_bb, then_bb, else_bb,
then_bb->succ->dest, 1))
return FALSE;
bitmap_operation (test_bb->global_live_at_end,
else_bb->global_live_at_start,
then_bb->global_live_at_end, BITMAP_IOR);
-
+
new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb), else_bb);
then_bb_index = then_bb->index;
if (post_dominators)
/* Test for case 2 above. */
static int
-find_if_case_2 (test_bb, then_edge, else_edge)
- basic_block test_bb;
- edge then_edge, else_edge;
+find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
{
basic_block then_bb = then_edge->dest;
basic_block else_bb = else_edge->dest;
if (note && INTVAL (XEXP (note, 0)) >= REG_BR_PROB_BASE / 2)
;
else if (else_succ->dest->index < 0
- || dominated_by_p (post_dominators, then_bb,
+ || dominated_by_p (post_dominators, then_bb,
else_succ->dest))
;
else
bitmap_operation (test_bb->global_live_at_end,
then_bb->global_live_at_start,
else_bb->global_live_at_end, BITMAP_IOR);
-
+
if (post_dominators)
delete_from_dominance_info (post_dominators, else_bb);
delete_block (else_bb);
Return 1 if a memory is found. */
static int
-find_memory (px, data)
- rtx *px;
- void *data ATTRIBUTE_UNUSED;
+find_memory (rtx *px, void *data ATTRIBUTE_UNUSED)
{
return GET_CODE (*px) == MEM;
}
REVERSEP is true if the sense of the branch should be reversed. */
static int
-dead_or_predicable (test_bb, merge_bb, other_bb, new_dest, reversep)
- basic_block test_bb, merge_bb, other_bb;
- basic_block new_dest;
- int reversep;
+dead_or_predicable (basic_block test_bb, basic_block merge_bb,
+ basic_block other_bb, basic_block new_dest, int reversep)
{
rtx head, end, jump, earliest, old_dest, new_label = NULL_RTX;
test_set = INITIALIZE_REG_SET (test_set_head);
/* ??? bb->local_set is only valid during calculate_global_regs_live,
- so we must recompute usage for MERGE_BB. Not so bad, I suppose,
+ so we must recompute usage for MERGE_BB. Not so bad, I suppose,
since we've already asserted that MERGE_BB is small. */
propagate_block (merge_bb, tmp, merge_set, merge_set, 0);
/* Main entry point for all if-conversion. */
void
-if_convert (x_life_data_ok)
- int x_life_data_ok;
+if_convert (int x_life_data_ok)
{
basic_block bb;
int pass;
/* The data structure used to record a location in a translation unit. */
struct location_s GTY (())
{
- /* The name of the source file involved. */
+ /* The name of the source file involved. */
const char *file;
/* The line-location in the source file. */
/* Incremented on each change to input_file_stack. */
extern int input_file_stack_tick;
-extern void push_srcloc PARAMS ((const char *name, int line));
-extern void pop_srcloc PARAMS ((void));
+extern void push_srcloc (const char *name, int line);
+extern void pop_srcloc (void);
#endif
initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
} initial_value_struct;
-static void setup_initial_hard_reg_value_integration PARAMS ((struct function *, struct inline_remap *));
-
-static rtvec initialize_for_inline PARAMS ((tree));
-static void note_modified_parmregs PARAMS ((rtx, rtx, void *));
-static void integrate_parm_decls PARAMS ((tree, struct inline_remap *,
- rtvec));
-static tree integrate_decl_tree PARAMS ((tree,
- struct inline_remap *));
-static void subst_constants PARAMS ((rtx *, rtx,
- struct inline_remap *, int));
-static void set_block_origin_self PARAMS ((tree));
-static void set_block_abstract_flags PARAMS ((tree, int));
-static void process_reg_param PARAMS ((struct inline_remap *, rtx,
- rtx));
-static void mark_stores PARAMS ((rtx, rtx, void *));
-static void save_parm_insns PARAMS ((rtx, rtx));
-static void copy_insn_list PARAMS ((rtx, struct inline_remap *,
- rtx));
-static void copy_insn_notes PARAMS ((rtx, struct inline_remap *,
- int));
-static int compare_blocks PARAMS ((const void *, const void *));
-static int find_block PARAMS ((const void *, const void *));
+static void setup_initial_hard_reg_value_integration (struct function *,
+ struct inline_remap *);
+
+static rtvec initialize_for_inline (tree);
+static void note_modified_parmregs (rtx, rtx, void *);
+static void integrate_parm_decls (tree, struct inline_remap *, rtvec);
+static tree integrate_decl_tree (tree, struct inline_remap *);
+static void subst_constants (rtx *, rtx, struct inline_remap *, int);
+static void set_block_origin_self (tree);
+static void set_block_abstract_flags (tree, int);
+static void process_reg_param (struct inline_remap *, rtx, rtx);
+static void mark_stores (rtx, rtx, void *);
+static void save_parm_insns (rtx, rtx);
+static void copy_insn_list (rtx, struct inline_remap *, rtx);
+static void copy_insn_notes (rtx, struct inline_remap *, int);
+static int compare_blocks (const void *, const void *);
+static int find_block (const void *, const void *);
/* Used by copy_rtx_and_substitute; this indicates whether the function is
called for the purpose of inlining or some other purpose (i.e. loop
explosions when the label_map gets very large. */
rtx
-get_label_from_map (map, i)
- struct inline_remap *map;
- int i;
+get_label_from_map (struct inline_remap *map, int i)
{
rtx x = map->label_map[i];
/* Return false if the function FNDECL cannot be inlined on account of its
attributes, true otherwise. */
bool
-function_attribute_inlinable_p (fndecl)
- tree fndecl;
+function_attribute_inlinable_p (tree fndecl)
{
if (targetm.attribute_table)
{
for the function's name. */
const char *
-function_cannot_inline_p (fndecl)
- tree fndecl;
+function_cannot_inline_p (tree fndecl)
{
rtx insn;
tree last = tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
needed to save FNDECL's insns and info for future inline expansion. */
static rtvec
-initialize_for_inline (fndecl)
- tree fndecl;
+initialize_for_inline (tree fndecl)
{
int i;
rtvec arg_vector;
TO_FN. */
tree
-copy_decl_for_inlining (decl, from_fn, to_fn)
- tree decl;
- tree from_fn;
- tree to_fn;
+copy_decl_for_inlining (tree decl, tree from_fn, tree to_fn)
{
tree copy;
functions at the end of compilation. */
void
-save_for_inline (fndecl)
- tree fndecl;
+save_for_inline (tree fndecl)
{
rtx insn;
rtvec argvec;
register and track the new register's life. */
static void
-save_parm_insns (insn, first_nonparm_insn)
- rtx insn;
- rtx first_nonparm_insn;
+save_parm_insns (rtx insn, rtx first_nonparm_insn)
{
if (insn == NULL_RTX)
return;
/* Note whether a parameter is modified or not. */
static void
-note_modified_parmregs (reg, x, data)
- rtx reg;
- rtx x ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+note_modified_parmregs (rtx reg, rtx x ATTRIBUTE_UNUSED, void *data ATTRIBUTE_UNUSED)
{
if (GET_CODE (reg) == REG && in_nonparm_insns
&& REGNO (reg) < max_parm_reg
Also, don't allow hard registers here; they might not be valid when
substituted into insns. */
static void
-process_reg_param (map, loc, copy)
- struct inline_remap *map;
- rtx loc, copy;
+process_reg_param (struct inline_remap *map, rtx loc, rtx copy)
{
if ((GET_CODE (copy) != REG && GET_CODE (copy) != SUBREG)
|| (GET_CODE (copy) == REG && REG_USERVAR_P (loc)
two pointers, because it may overflow sizeof(int). */
static int
-compare_blocks (v1, v2)
- const void *v1;
- const void *v2;
+compare_blocks (const void *v1, const void *v2)
{
tree b1 = *((const tree *) v1);
tree b2 = *((const tree *) v2);
an original block; the second to a remapped equivalent. */
static int
-find_block (v1, v2)
- const void *v1;
- const void *v2;
+find_block (const void *v1, const void *v2)
{
const union tree_node *b1 = (const union tree_node *) v1;
tree b2 = *((const tree *) v2);
else an rtx for where the value is stored. */
rtx
-expand_inline_function (fndecl, parms, target, ignore, type,
- structure_value_addr)
- tree fndecl, parms;
- rtx target;
- int ignore;
- tree type;
- rtx structure_value_addr;
+expand_inline_function (tree fndecl, tree parms, rtx target, int ignore,
+ tree type, rtx structure_value_addr)
{
struct function *inlining_previous;
struct function *inl_f = DECL_SAVED_INSNS (fndecl);
/* If the formal type was const but the actual was not, we might
end up here with an rtx wrongly tagged unchanging in the caller's
context. Fix that. */
- if (arg_vals[i] != 0
+ if (arg_vals[i] != 0
&& (GET_CODE (arg_vals[i]) == REG || GET_CODE (arg_vals[i]) == MEM)
&& ! TREE_READONLY (TREE_VALUE (actual)))
- RTX_UNCHANGING_P (arg_vals[i]) = 0;
+ RTX_UNCHANGING_P (arg_vals[i]) = 0;
if (arg_vals[i] != 0
&& (! TREE_READONLY (formal)
REG_FUNCTION_RETURN_VALUE_P. */
map->inline_target = 0;
- loc = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
+ loc = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
if (TYPE_MODE (type) == VOIDmode)
register for the function. */
static void
-copy_insn_list (insns, map, static_chain_value)
- rtx insns;
- struct inline_remap *map;
- rtx static_chain_value;
+copy_insn_list (rtx insns, struct inline_remap *map, rtx static_chain_value)
{
int i;
rtx insn;
that are valid across the entire function. */
static void
-copy_insn_notes (insns, map, eh_region_offset)
- rtx insns;
- struct inline_remap *map;
- int eh_region_offset;
+copy_insn_notes (rtx insns, struct inline_remap *map, int eh_region_offset)
{
rtx insn, new_insn;
push all of those decls and give each one the corresponding home. */
static void
-integrate_parm_decls (args, map, arg_vector)
- tree args;
- struct inline_remap *map;
- rtvec arg_vector;
+integrate_parm_decls (tree args, struct inline_remap *map, rtvec arg_vector)
{
tree tail;
int i;
no mapping is necessary. */
static tree
-integrate_decl_tree (let, map)
- tree let;
- struct inline_remap *map;
+integrate_decl_tree (tree let, struct inline_remap *map)
{
tree t;
tree new_block;
calling `force_const_mem'. */
rtx
-copy_rtx_and_substitute (orig, map, for_lhs)
- rtx orig;
- struct inline_remap *map;
- int for_lhs;
+copy_rtx_and_substitute (rtx orig, struct inline_remap *map, int for_lhs)
{
rtx copy, temp;
int i, j;
{
if (!map->leaf_reg_map[regno][mode])
map->leaf_reg_map[regno][mode] = gen_rtx_REG (mode, regno);
- return map->leaf_reg_map[regno][mode];
+ return map->leaf_reg_map[regno][mode];
}
#endif
else
MEM_COPY_ATTRIBUTES (copy, XEXP (orig, 0));
return
- gen_rtx_CALL (GET_MODE (orig), copy,
+ gen_rtx_CALL (GET_MODE (orig), copy,
copy_rtx_and_substitute (XEXP (orig, 1), map, 0));
}
break;
/* Substitute known constant values into INSN, if that is valid. */
void
-try_constants (insn, map)
- rtx insn;
- struct inline_remap *map;
+try_constants (rtx insn, struct inline_remap *map)
{
int i;
apply_change_group ();
subst_constants (&PATTERN (insn), insn, map, 0);
apply_change_group ();
-
+
/* Enforce consistency between the addresses in the regular insn flow
and the ones in CALL_INSN_FUNCTION_USAGE lists, if any. */
if (GET_CODE (insn) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (insn))
If MEMONLY is nonzero, only make changes inside a MEM. */
static void
-subst_constants (loc, insn, map, memonly)
- rtx *loc;
- rtx insn;
- struct inline_remap *map;
- int memonly;
+subst_constants (rtx *loc, rtx insn, struct inline_remap *map, int memonly)
{
rtx x = *loc;
int i, j;
integral mode and extracting the low part. */
subst_constants (&inner, NULL_RTX, map, 0);
new = simplify_gen_subreg (GET_MODE (x), inner,
- GET_MODE (SUBREG_REG (x)),
+ GET_MODE (SUBREG_REG (x)),
SUBREG_BYTE (x));
if (new)
called from note_stores with parts of the new insn. */
static void
-mark_stores (dest, x, data)
- rtx dest;
- rtx x ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+mark_stores (rtx dest, rtx x ATTRIBUTE_UNUSED, void *data ATTRIBUTE_UNUSED)
{
int regno = -1;
enum machine_mode mode = VOIDmode;
values to point to themselves. */
static void
-set_block_origin_self (stmt)
- tree stmt;
+set_block_origin_self (tree stmt)
{
if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
{
point to themselves. */
void
-set_decl_origin_self (decl)
- tree decl;
+set_decl_origin_self (tree decl)
{
if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
{
(recursively) which are contained therein. */
static void
-set_block_abstract_flags (stmt, setting)
- tree stmt;
- int setting;
+set_block_abstract_flags (tree stmt, int setting)
{
tree local_decl;
tree subblock;
blocks and sub-blocks (recursively) to the same setting. */
void
-set_decl_abstract_flags (decl, setting)
- tree decl;
- int setting;
+set_decl_abstract_flags (tree decl, int setting)
{
DECL_ABSTRACT (decl) = setting;
if (TREE_CODE (decl) == FUNCTION_DECL)
static GTY(()) struct function *old_cfun;
void
-output_inline_function (fndecl)
- tree fndecl;
+output_inline_function (tree fndecl)
{
enum debug_info_type old_write_symbols = write_symbols;
const struct gcc_debug_hooks *const old_debug_hooks = debug_hooks;
the function. */
rtx
-get_hard_reg_initial_reg (fun, reg)
- struct function *fun;
- rtx reg;
+get_hard_reg_initial_reg (struct function *fun, rtx reg)
{
struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
int i;
}
rtx
-has_func_hard_reg_initial_val (fun, reg)
- struct function *fun;
- rtx reg;
+has_func_hard_reg_initial_val (struct function *fun, rtx reg)
{
struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
int i;
}
rtx
-get_func_hard_reg_initial_val (fun, reg)
- struct function *fun;
- rtx reg;
+get_func_hard_reg_initial_val (struct function *fun, rtx reg)
{
struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
rtx rv = has_func_hard_reg_initial_val (fun, reg);
if (ivs->num_entries >= ivs->max_entries)
{
ivs->max_entries += 5;
- ivs->entries =
+ ivs->entries =
(initial_value_pair *) ggc_realloc (ivs->entries,
ivs->max_entries
* sizeof (initial_value_pair));
}
rtx
-get_hard_reg_initial_val (mode, regno)
- enum machine_mode mode;
- int regno;
+get_hard_reg_initial_val (enum machine_mode mode, int regno)
{
return get_func_hard_reg_initial_val (cfun, gen_rtx_REG (mode, regno));
}
rtx
-has_hard_reg_initial_val (mode, regno)
- enum machine_mode mode;
- int regno;
+has_hard_reg_initial_val (enum machine_mode mode, int regno)
{
return has_func_hard_reg_initial_val (cfun, gen_rtx_REG (mode, regno));
}
static void
-setup_initial_hard_reg_value_integration (inl_f, remap)
- struct function *inl_f;
- struct inline_remap *remap;
+setup_initial_hard_reg_value_integration (struct function *inl_f, struct inline_remap *remap)
{
struct initial_value_struct *ivs = inl_f->hard_reg_initial_vals;
int i;
void
-emit_initial_value_sets ()
+emit_initial_value_sets (void)
{
struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
int i;
/* If the backend knows where to allocate pseudos for hard
register initial values, register these allocations now. */
void
-allocate_initial_values (reg_equiv_memory_loc)
- rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED;
+allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
{
#ifdef ALLOCATE_INITIAL_VALUE
struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
/* Function integration definitions for GCC
- Copyright (C) 1990, 1995, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1995, 1998, 1999, 2000, 2001, 2003
+ Free Software Foundation, Inc.
This file is part of GCC.
rtx dest;
rtx equiv;
} equiv_sets[MAX_RECOG_OPERANDS];
- /* Record the last thing assigned to pc. This is used for folded
+ /* Record the last thing assigned to pc. This is used for folded
conditional branch insns. */
rtx last_pc_value;
#ifdef HAVE_cc0
/* Return a copy of an rtx (as needed), substituting pseudo-register,
labels, and frame-pointer offsets as necessary. */
-extern rtx copy_rtx_and_substitute PARAMS ((rtx, struct inline_remap *, int));
+extern rtx copy_rtx_and_substitute (rtx, struct inline_remap *, int);
/* Return a pseudo that corresponds to the value in the specified hard
reg as of the start of the function (for inlined functions, the
value at the start of the parent function). */
-extern rtx get_hard_reg_initial_val PARAMS ((enum machine_mode, int));
+extern rtx get_hard_reg_initial_val (enum machine_mode, int);
/* Likewise, but for a different than the current function, or
arbitrary expression. */
-extern rtx get_func_hard_reg_initial_val PARAMS ((struct function *, rtx));
+extern rtx get_func_hard_reg_initial_val (struct function *, rtx);
/* Likewise, but iff someone else has caused it to become allocated. */
-extern rtx has_func_hard_reg_initial_val PARAMS ((struct function *, rtx));
+extern rtx has_func_hard_reg_initial_val (struct function *, rtx);
/* Likewise, but for common cases. */
-extern rtx has_hard_reg_initial_val PARAMS ((enum machine_mode, int));
+extern rtx has_hard_reg_initial_val (enum machine_mode, int);
/* If a pseudo represents an initial hard reg (or expression), return
it, else return NULL_RTX. */
-extern rtx get_hard_reg_initial_reg PARAMS ((struct function *, rtx));
+extern rtx get_hard_reg_initial_reg (struct function *, rtx);
/* Called from rest_of_compilation. */
-extern void emit_initial_value_sets PARAMS ((void));
-extern void allocate_initial_values PARAMS ((rtx *));
+extern void emit_initial_value_sets (void);
+extern void allocate_initial_values (rtx *);
/* Copy a declaration when one function is substituted inline into
another. */
-extern union tree_node *copy_decl_for_inlining PARAMS ((union tree_node *,
- union tree_node *,
- union tree_node *));
+extern union tree_node *copy_decl_for_inlining (union tree_node *,
+ union tree_node *,
+ union tree_node *);
/* Check whether there's any attribute in a function declaration that
makes the function uninlinable. Returns false if it finds any,
true otherwise. */
-extern bool function_attribute_inlinable_p PARAMS ((union tree_node *));
+extern bool function_attribute_inlinable_p (union tree_node *);
-extern void try_constants PARAMS ((rtx, struct inline_remap *));
+extern void try_constants (rtx, struct inline_remap *);
/* Return the label indicated. */
-extern rtx get_label_from_map PARAMS ((struct inline_remap *, int));
+extern rtx get_label_from_map (struct inline_remap *, int);
/* Set the label indicated. */
#define set_label_in_map(MAP, I, X) ((MAP)->label_map[I] = (X))
OSDN Git Service
