* sbitmap.c: Convert prototypes to ISO C90.
* sbitmap.h: Likewise.
* scan-decls.c: Likewise.
* scan.c: Likewise.
* sched-deps.c: Likewise.
* sched-ebb.c: Likewise.
* sched-int.h: Likewise.
* sched-rgn.c: Likewise.
* sched-vis.c: Likewise.
* sibcall.c: Likewise.
* simplify-rtx.c: Likewise.
* sreal.c: Likewise.
* sreal.h: Likewise.
* ssa-ccp.c: Likewise.
* ssa-dce.c: Likewise.
* ssa.c: Likewise.
* ssa.h: Likewise.
* stack.h: Likewise.
* stmt.c: Likewise.
* stor-layout.c: Likewise.
* stringpool.c: Likewise.
* target.h: Likewise.
* timevar.c: Likewise.
* timevar.h: Likewise.
* tlink.c: Likewise.
* tracer.c: Likewise.
* tree-inline.c: Likewise.
* tree-inline.h: Likewise.
* tree.c: Likewise.
* tree.h: Likewise.
From-SVN: r69002
* rtl.c: Likewise.
* rtl.h: Likewise.
* rtlanal.c: Likewise.
+ * sbitmap.c: Likewise.
+ * sbitmap.h: Likewise.
+ * scan-decls.c: Likewise.
+ * scan.c: Likewise.
+ * sched-deps.c: Likewise.
+ * sched-ebb.c: Likewise.
+ * sched-int.h: Likewise.
+ * sched-rgn.c: Likewise.
+ * sched-vis.c: Likewise.
+ * sibcall.c: Likewise.
+ * simplify-rtx.c: Likewise.
+ * sreal.c: Likewise.
+ * sreal.h: Likewise.
+ * ssa-ccp.c: Likewise.
+ * ssa-dce.c: Likewise.
+ * ssa.c: Likewise.
+ * ssa.h: Likewise.
+ * stack.h: Likewise.
+ * stmt.c: Likewise.
+ * stor-layout.c: Likewise.
+ * stringpool.c: Likewise.
+ * target.h: Likewise.
+ * timevar.c: Likewise.
+ * timevar.h: Likewise.
+ * tlink.c: Likewise.
+ * tracer.c: Likewise.
+ * tree-inline.c: Likewise.
+ * tree-inline.h: Likewise.
+ * tree.c: Likewise.
+ * tree.h: Likewise.
2003-07-05 Kazu Hirata <kazu@cs.umass.edu>
/* Allocate a simple bitmap of N_ELMS bits. */
sbitmap
-sbitmap_alloc (n_elms)
- unsigned int n_elms;
+sbitmap_alloc (unsigned int n_elms)
{
unsigned int bytes, size, amt;
sbitmap bmap;
is zero, and set them to one otherwise. */
sbitmap
-sbitmap_resize (bmap, n_elms, def)
- sbitmap bmap;
- unsigned int n_elms;
- int def;
+sbitmap_resize (sbitmap bmap, unsigned int n_elms, int def)
{
unsigned int bytes, size, amt;
unsigned int last_bit;
/* Allocate a vector of N_VECS bitmaps of N_ELMS bits. */
sbitmap *
-sbitmap_vector_alloc (n_vecs, n_elms)
- unsigned int n_vecs, n_elms;
+sbitmap_vector_alloc (unsigned int n_vecs, unsigned int n_elms)
{
unsigned int i, bytes, offset, elm_bytes, size, amt, vector_bytes;
sbitmap *bitmap_vector;
/* Copy sbitmap SRC to DST. */
void
-sbitmap_copy (dst, src)
- sbitmap dst, src;
+sbitmap_copy (sbitmap dst, sbitmap src)
{
memcpy (dst->elms, src->elms, sizeof (SBITMAP_ELT_TYPE) * dst->size);
}
/* Determine if a == b. */
int
-sbitmap_equal (a, b)
- sbitmap a, b;
+sbitmap_equal (sbitmap a, sbitmap b)
{
return !memcmp (a->elms, b->elms, sizeof (SBITMAP_ELT_TYPE) * a->size);
}
/* Zero all elements in a bitmap. */
void
-sbitmap_zero (bmap)
- sbitmap bmap;
+sbitmap_zero (sbitmap bmap)
{
memset (bmap->elms, 0, bmap->bytes);
}
/* Set all elements in a bitmap to ones. */
void
-sbitmap_ones (bmap)
- sbitmap bmap;
+sbitmap_ones (sbitmap bmap)
{
unsigned int last_bit;
/* Zero a vector of N_VECS bitmaps. */
void
-sbitmap_vector_zero (bmap, n_vecs)
- sbitmap *bmap;
- unsigned int n_vecs;
+sbitmap_vector_zero (sbitmap *bmap, unsigned int n_vecs)
{
unsigned int i;
/* Set a vector of N_VECS bitmaps to ones. */
void
-sbitmap_vector_ones (bmap, n_vecs)
- sbitmap *bmap;
- unsigned int n_vecs;
+sbitmap_vector_ones (sbitmap *bmap, unsigned int n_vecs)
{
unsigned int i;
Returns true if any change is made. */
bool
-sbitmap_union_of_diff_cg (dst, a, b, c)
- sbitmap dst, a, b, c;
+sbitmap_union_of_diff_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
}
void
-sbitmap_union_of_diff (dst, a, b, c)
- sbitmap dst, a, b, c;
+sbitmap_union_of_diff (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
/* Set bitmap DST to the bitwise negation of the bitmap SRC. */
void
-sbitmap_not (dst, src)
- sbitmap dst, src;
+sbitmap_not (sbitmap dst, sbitmap src)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
in A and the bits in B. i.e. dst = a & (~b). */
void
-sbitmap_difference (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_difference (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, dst_size = dst->size;
unsigned int min_size = dst->size;
sbitmap_ptr dstp = dst->elms;
sbitmap_ptr ap = a->elms;
sbitmap_ptr bp = b->elms;
-
+
/* A should be at least as large as DEST, to have a defined source. */
if (a->size < dst_size)
abort ();
Return nonzero if any change is made. */
bool
-sbitmap_a_and_b_cg (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_a_and_b_cg (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
}
void
-sbitmap_a_and_b (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_a_and_b (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
Return nonzero if any change is made. */
bool
-sbitmap_a_xor_b_cg (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_a_xor_b_cg (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
}
void
-sbitmap_a_xor_b (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_a_xor_b (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
Return nonzero if any change is made. */
bool
-sbitmap_a_or_b_cg (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_a_or_b_cg (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
}
void
-sbitmap_a_or_b (dst, a, b)
- sbitmap dst, a, b;
+sbitmap_a_or_b (sbitmap dst, sbitmap a, sbitmap b)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
/* Return nonzero if A is a subset of B. */
bool
-sbitmap_a_subset_b_p (a, b)
- sbitmap a, b;
+sbitmap_a_subset_b_p (sbitmap a, sbitmap b)
{
unsigned int i, n = a->size;
sbitmap_ptr ap, bp;
Return nonzero if any change is made. */
bool
-sbitmap_a_or_b_and_c_cg (dst, a, b, c)
- sbitmap dst, a, b, c;
+sbitmap_a_or_b_and_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
}
void
-sbitmap_a_or_b_and_c (dst, a, b, c)
- sbitmap dst, a, b, c;
+sbitmap_a_or_b_and_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
Return nonzero if any change is made. */
bool
-sbitmap_a_and_b_or_c_cg (dst, a, b, c)
- sbitmap dst, a, b, c;
+sbitmap_a_and_b_or_c_cg (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
}
void
-sbitmap_a_and_b_or_c (dst, a, b, c)
- sbitmap dst, a, b, c;
+sbitmap_a_and_b_or_c (sbitmap dst, sbitmap a, sbitmap b, sbitmap c)
{
unsigned int i, n = dst->size;
sbitmap_ptr dstp = dst->elms;
block number BB, using the new flow graph structures. */
void
-sbitmap_intersection_of_succs (dst, src, bb)
- sbitmap dst;
- sbitmap *src;
- int bb;
+sbitmap_intersection_of_succs (sbitmap dst, sbitmap *src, int bb)
{
basic_block b = BASIC_BLOCK (bb);
unsigned int set_size = dst->size;
block number BB, using the new flow graph structures. */
void
-sbitmap_intersection_of_preds (dst, src, bb)
- sbitmap dst;
- sbitmap *src;
- int bb;
+sbitmap_intersection_of_preds (sbitmap dst, sbitmap *src, int bb)
{
basic_block b = BASIC_BLOCK (bb);
unsigned int set_size = dst->size;
block number BB, using the new flow graph structures. */
void
-sbitmap_union_of_succs (dst, src, bb)
- sbitmap dst;
- sbitmap *src;
- int bb;
+sbitmap_union_of_succs (sbitmap dst, sbitmap *src, int bb)
{
basic_block b = BASIC_BLOCK (bb);
unsigned int set_size = dst->size;
block number BB, using the new flow graph structures. */
void
-sbitmap_union_of_preds (dst, src, bb)
- sbitmap dst;
- sbitmap *src;
- int bb;
+sbitmap_union_of_preds (sbitmap dst, sbitmap *src, int bb)
{
basic_block b = BASIC_BLOCK (bb);
unsigned int set_size = dst->size;
/* Return number of first bit set in the bitmap, -1 if none. */
int
-sbitmap_first_set_bit (bmap)
- sbitmap bmap;
+sbitmap_first_set_bit (sbitmap bmap)
{
unsigned int n;
/* Return number of last bit set in the bitmap, -1 if none. */
int
-sbitmap_last_set_bit (bmap)
- sbitmap bmap;
+sbitmap_last_set_bit (sbitmap bmap)
{
int i;
SBITMAP_ELT_TYPE *ptr = bmap->elms;
}
void
-dump_sbitmap (file, bmap)
- FILE *file;
- sbitmap bmap;
+dump_sbitmap (FILE *file, sbitmap bmap)
{
unsigned int i, n, j;
unsigned int set_size = bmap->size;
}
void
-dump_sbitmap_file (file, bmap)
- FILE *file;
- sbitmap bmap;
+dump_sbitmap_file (FILE *file, sbitmap bmap)
{
unsigned int i, pos;
}
void
-debug_sbitmap (bmap)
- sbitmap bmap;
+debug_sbitmap (sbitmap bmap)
{
dump_sbitmap_file (stderr, bmap);
}
void
-dump_sbitmap_vector (file, title, subtitle, bmaps, n_maps)
- FILE *file;
- const char *title, *subtitle;
- sbitmap *bmaps;
- int n_maps;
+dump_sbitmap_vector (FILE *file, const char *title, const char *subtitle,
+ sbitmap *bmaps, int n_maps)
{
int bb;
02111-1307, USA. */
#ifndef GCC_SBITMAP_H
-#define GCC_SBITMAP_H
+#define GCC_SBITMAP_H
/* It's not clear yet whether using bitmap.[ch] will be a win.
It should be straightforward to convert so for now we keep things simple
struct int_list;
-extern void dump_sbitmap PARAMS ((FILE *, sbitmap));
-extern void dump_sbitmap_file PARAMS ((FILE *, sbitmap));
-extern void dump_sbitmap_vector PARAMS ((FILE *, const char *,
- const char *, sbitmap *,
- int));
-extern sbitmap sbitmap_alloc PARAMS ((unsigned int));
-extern sbitmap *sbitmap_vector_alloc PARAMS ((unsigned int, unsigned int));
-extern sbitmap sbitmap_resize PARAMS ((sbitmap, unsigned int, int));
-extern void sbitmap_copy PARAMS ((sbitmap, sbitmap));
-extern int sbitmap_equal PARAMS ((sbitmap, sbitmap));
-extern void sbitmap_zero PARAMS ((sbitmap));
-extern void sbitmap_ones PARAMS ((sbitmap));
-extern void sbitmap_vector_zero PARAMS ((sbitmap *, unsigned int));
-extern void sbitmap_vector_ones PARAMS ((sbitmap *, unsigned int));
-
-extern void sbitmap_union_of_diff PARAMS ((sbitmap, sbitmap, sbitmap,
- sbitmap));
-extern bool sbitmap_union_of_diff_cg PARAMS ((sbitmap, sbitmap, sbitmap,
- sbitmap));
-extern void sbitmap_difference PARAMS ((sbitmap, sbitmap, sbitmap));
-extern void sbitmap_not PARAMS ((sbitmap, sbitmap));
-extern void sbitmap_a_or_b_and_c PARAMS ((sbitmap, sbitmap, sbitmap,
- sbitmap));
-extern bool sbitmap_a_or_b_and_c_cg PARAMS ((sbitmap, sbitmap, sbitmap,
- sbitmap));
-extern void sbitmap_a_and_b_or_c PARAMS ((sbitmap, sbitmap, sbitmap,
- sbitmap));
-extern bool sbitmap_a_and_b_or_c_cg PARAMS ((sbitmap, sbitmap, sbitmap,
- sbitmap));
-extern void sbitmap_a_and_b PARAMS ((sbitmap, sbitmap, sbitmap));
-extern bool sbitmap_a_and_b_cg PARAMS ((sbitmap, sbitmap, sbitmap));
-extern void sbitmap_a_or_b PARAMS ((sbitmap, sbitmap, sbitmap));
-extern bool sbitmap_a_or_b_cg PARAMS ((sbitmap, sbitmap, sbitmap));
-extern void sbitmap_a_xor_b PARAMS ((sbitmap, sbitmap, sbitmap));
-extern bool sbitmap_a_xor_b_cg PARAMS ((sbitmap, sbitmap, sbitmap));
-extern bool sbitmap_a_subset_b_p PARAMS ((sbitmap, sbitmap));
-
-extern int sbitmap_first_set_bit PARAMS ((sbitmap));
-extern int sbitmap_last_set_bit PARAMS ((sbitmap));
-
-extern void sbitmap_intersect_of_predsucc PARAMS ((sbitmap, sbitmap *,
- int, struct int_list **));
+extern void dump_sbitmap (FILE *, sbitmap);
+extern void dump_sbitmap_file (FILE *, sbitmap);
+extern void dump_sbitmap_vector (FILE *, const char *, const char *, sbitmap *,
+ int);
+extern sbitmap sbitmap_alloc (unsigned int);
+extern sbitmap *sbitmap_vector_alloc (unsigned int, unsigned int);
+extern sbitmap sbitmap_resize (sbitmap, unsigned int, int);
+extern void sbitmap_copy (sbitmap, sbitmap);
+extern int sbitmap_equal (sbitmap, sbitmap);
+extern void sbitmap_zero (sbitmap);
+extern void sbitmap_ones (sbitmap);
+extern void sbitmap_vector_zero (sbitmap *, unsigned int);
+extern void sbitmap_vector_ones (sbitmap *, unsigned int);
+
+extern void sbitmap_union_of_diff (sbitmap, sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_union_of_diff_cg (sbitmap, sbitmap, sbitmap, sbitmap);
+extern void sbitmap_difference (sbitmap, sbitmap, sbitmap);
+extern void sbitmap_not (sbitmap, sbitmap);
+extern void sbitmap_a_or_b_and_c (sbitmap, sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_a_or_b_and_c_cg (sbitmap, sbitmap, sbitmap, sbitmap);
+extern void sbitmap_a_and_b_or_c (sbitmap, sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_a_and_b_or_c_cg (sbitmap, sbitmap, sbitmap, sbitmap);
+extern void sbitmap_a_and_b (sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_a_and_b_cg (sbitmap, sbitmap, sbitmap);
+extern void sbitmap_a_or_b (sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_a_or_b_cg (sbitmap, sbitmap, sbitmap);
+extern void sbitmap_a_xor_b (sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_a_xor_b_cg (sbitmap, sbitmap, sbitmap);
+extern bool sbitmap_a_subset_b_p (sbitmap, sbitmap);
+
+extern int sbitmap_first_set_bit (sbitmap);
+extern int sbitmap_last_set_bit (sbitmap);
+
+extern void sbitmap_intersect_of_predsucc (sbitmap, sbitmap *, int,
+ struct int_list **);
#define sbitmap_intersect_of_predecessors sbitmap_intersect_of_predsucc
#define sbitmap_intersect_of_successors sbitmap_intersect_of_predsucc
-extern void sbitmap_union_of_predsucc PARAMS ((sbitmap, sbitmap *, int,
- struct int_list **));
+extern void sbitmap_union_of_predsucc (sbitmap, sbitmap *, int,
+ struct int_list **);
#define sbitmap_union_of_predecessors sbitmap_union_of_predsucc
#define sbitmap_union_of_successors sbitmap_union_of_predsucc
-/* Intersection and Union of preds/succs using the new flow graph
+/* Intersection and Union of preds/succs using the new flow graph
structure instead of the pred/succ arrays. */
-extern void sbitmap_intersection_of_succs PARAMS ((sbitmap, sbitmap *, int));
-extern void sbitmap_intersection_of_preds PARAMS ((sbitmap, sbitmap *, int));
-extern void sbitmap_union_of_succs PARAMS ((sbitmap, sbitmap *, int));
-extern void sbitmap_union_of_preds PARAMS ((sbitmap, sbitmap *, int));
+extern void sbitmap_intersection_of_succs (sbitmap, sbitmap *, int);
+extern void sbitmap_intersection_of_preds (sbitmap, sbitmap *, int);
+extern void sbitmap_union_of_succs (sbitmap, sbitmap *, int);
+extern void sbitmap_union_of_preds (sbitmap, sbitmap *, int);
-extern void debug_sbitmap PARAMS ((sbitmap));
+extern void debug_sbitmap (sbitmap);
#endif /* ! GCC_SBITMAP_H */
/* scan-decls.c - Extracts declarations from cpp output.
Copyright (C) 1993, 1995, 1997, 1998,
- 1999, 2000 Free Software Foundation, Inc.
+ 1999, 2000, 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
#include "cpplib.h"
#include "scan.h"
-static void skip_to_closing_brace PARAMS ((cpp_reader *));
-static const cpp_token *get_a_token PARAMS ((cpp_reader *));
+static void skip_to_closing_brace (cpp_reader *);
+static const cpp_token *get_a_token (cpp_reader *);
int brace_nesting = 0;
/* Get a token but skip padding. */
static const cpp_token *
-get_a_token (pfile)
- cpp_reader *pfile;
+get_a_token (cpp_reader *pfile)
{
for (;;)
{
}
static void
-skip_to_closing_brace (pfile)
- cpp_reader *pfile;
+skip_to_closing_brace (cpp_reader *pfile)
{
int nesting = 1;
for (;;)
*/
int
-scan_decls (pfile, argc, argv)
- cpp_reader *pfile;
- int argc ATTRIBUTE_UNUSED;
- char **argv ATTRIBUTE_UNUSED;
+scan_decls (cpp_reader *pfile, int argc ATTRIBUTE_UNUSED,
+ char **argv ATTRIBUTE_UNUSED)
{
int saw_extern, saw_inline;
cpp_token prev_id;
/* Utility functions for scan-decls and fix-header programs.
- Copyright (C) 1993, 1994, 1998, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1998, 2002, 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
sstring source_filename;
void
-make_sstring_space (str, count)
- sstring *str;
- int count;
+make_sstring_space (sstring *str, int count)
{
int cur_pos = str->ptr - str->base;
int cur_size = str->limit - str->base;
}
void
-sstring_append (dst, src)
- sstring *dst;
- sstring *src;
+sstring_append (sstring *dst, sstring *src)
{
char *d, *s;
int count = SSTRING_LENGTH (src);
}
int
-scan_ident (fp, s, c)
- FILE *fp;
- sstring *s;
- int c;
+scan_ident (FILE *fp, sstring *s, int c)
{
s->ptr = s->base;
if (ISIDST (c))
}
int
-scan_string (fp, s, init)
- FILE *fp;
- sstring *s;
- int init;
+scan_string (FILE *fp, sstring *s, int init)
{
int c;
/* Skip horizontal white spaces (spaces, tabs, and C-style comments). */
int
-skip_spaces (fp, c)
- FILE *fp;
- int c;
+skip_spaces (FILE *fp, int c)
{
for (;;)
{
}
int
-read_upto (fp, str, delim)
- FILE *fp;
- sstring *str;
- int delim;
+read_upto (FILE *fp, sstring *str, int delim)
{
int ch;
}
int
-get_token (fp, s)
- FILE *fp;
- sstring *s;
+get_token (FILE *fp, sstring *s)
{
int c;
}
unsigned int
-hashstr (str, len)
- const char *str;
- unsigned int len;
+hashstr (const char *str, unsigned int len)
{
unsigned int n = len;
unsigned int r = 0;
/* Instruction scheduling pass. This file computes dependencies between
instructions.
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)
static sbitmap *forward_dependency_cache;
#endif
-static int deps_may_trap_p PARAMS ((rtx));
-static void add_dependence_list PARAMS ((rtx, rtx, enum reg_note));
-static void add_dependence_list_and_free PARAMS ((rtx, rtx *, enum reg_note));
-static void set_sched_group_p PARAMS ((rtx));
+static int deps_may_trap_p (rtx);
+static void add_dependence_list (rtx, rtx, enum reg_note);
+static void add_dependence_list_and_free (rtx, rtx *, enum reg_note);
+static void set_sched_group_p (rtx);
-static void flush_pending_lists PARAMS ((struct deps *, rtx, int, int));
-static void sched_analyze_1 PARAMS ((struct deps *, rtx, rtx));
-static void sched_analyze_2 PARAMS ((struct deps *, rtx, rtx));
-static void sched_analyze_insn PARAMS ((struct deps *, rtx, rtx, rtx));
+static void flush_pending_lists (struct deps *, rtx, int, int);
+static void sched_analyze_1 (struct deps *, rtx, rtx);
+static void sched_analyze_2 (struct deps *, rtx, rtx);
+static void sched_analyze_insn (struct deps *, rtx, rtx, rtx);
-static rtx get_condition PARAMS ((rtx));
-static int conditions_mutex_p PARAMS ((rtx, rtx));
+static rtx get_condition (rtx);
+static int conditions_mutex_p (rtx, rtx);
\f
/* Return nonzero if a load of the memory reference MEM can cause a trap. */
static int
-deps_may_trap_p (mem)
- rtx mem;
+deps_may_trap_p (rtx mem)
{
rtx addr = XEXP (mem, 0);
if LIST does not contain INSN. */
rtx
-find_insn_list (insn, list)
- rtx insn;
- rtx list;
+find_insn_list (rtx insn, rtx list)
{
while (list)
{
/* Find the condition under which INSN is executed. */
static rtx
-get_condition (insn)
- rtx insn;
+get_condition (rtx insn)
{
rtx pat = PATTERN (insn);
rtx cond;
/* Return nonzero if conditions COND1 and COND2 can never be both true. */
static int
-conditions_mutex_p (cond1, cond2)
- rtx cond1, cond2;
+conditions_mutex_p (rtx cond1, rtx cond2)
{
if (GET_RTX_CLASS (GET_CODE (cond1)) == '<'
&& GET_RTX_CLASS (GET_CODE (cond2)) == '<'
nonzero if a new entry has been added to insn's LOG_LINK. */
int
-add_dependence (insn, elem, dep_type)
- rtx insn;
- rtx elem;
- enum reg_note dep_type;
+add_dependence (rtx insn, rtx elem, enum reg_note dep_type)
{
rtx link;
int present_p;
abort ();
}
#endif
-
+
/* If this is a more restrictive type of dependence than the existing
one, then change the existing dependence to this type. */
if ((int) dep_type < (int) REG_NOTE_KIND (link))
/* A convenience wrapper to operate on an entire list. */
static void
-add_dependence_list (insn, list, dep_type)
- rtx insn, list;
- enum reg_note dep_type;
+add_dependence_list (rtx insn, rtx list, enum reg_note dep_type)
{
for (; list; list = XEXP (list, 1))
add_dependence (insn, XEXP (list, 0), dep_type);
/* Similar, but free *LISTP at the same time. */
static void
-add_dependence_list_and_free (insn, listp, dep_type)
- rtx insn;
- rtx *listp;
- enum reg_note dep_type;
+add_dependence_list_and_free (rtx insn, rtx *listp, enum reg_note dep_type)
{
rtx list, next;
for (list = *listp, *listp = NULL; list ; list = next)
goes along with that. */
static void
-set_sched_group_p (insn)
- rtx insn;
+set_sched_group_p (rtx insn)
{
rtx prev;
so that we can do memory aliasing on it. */
void
-add_insn_mem_dependence (deps, insn_list, mem_list, insn, mem)
- struct deps *deps;
- rtx *insn_list, *mem_list, insn, mem;
+add_insn_mem_dependence (struct deps *deps, rtx *insn_list, rtx *mem_list,
+ rtx insn, rtx mem)
{
rtx link;
dependencies for a read operation, similarly with FOR_WRITE. */
static void
-flush_pending_lists (deps, insn, for_read, for_write)
- struct deps *deps;
- rtx insn;
- int for_read, for_write;
+flush_pending_lists (struct deps *deps, rtx insn, int for_read,
+ int for_write)
{
if (for_write)
{
destination of X, and reads of everything mentioned. */
static void
-sched_analyze_1 (deps, x, insn)
- struct deps *deps;
- rtx x;
- rtx insn;
+sched_analyze_1 (struct deps *deps, rtx x, rtx insn)
{
int regno;
rtx dest = XEXP (x, 0);
|| GET_CODE (dest) == SIGN_EXTRACT
|| read_modify_subreg_p (dest))
{
- /* These both read and modify the result. We must handle
+ /* These both read and modify the result. We must handle
them as writes to get proper dependencies for following
instructions. We must handle them as reads to get proper
dependencies from this to previous instructions.
Thus we need to call sched_analyze_2. */
- sched_analyze_2 (deps, XEXP (dest, 0), insn);
+ sched_analyze_2 (deps, XEXP (dest, 0), insn);
}
if (GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SIGN_EXTRACT)
{
/* Analyze the uses of memory and registers in rtx X in INSN. */
static void
-sched_analyze_2 (deps, x, insn)
- struct deps *deps;
- rtx x;
- rtx insn;
+sched_analyze_2 (struct deps *deps, rtx x, rtx insn)
{
int i;
int j;
/* Analyze an INSN with pattern X to find all dependencies. */
static void
-sched_analyze_insn (deps, x, insn, loop_notes)
- struct deps *deps;
- rtx x, insn;
- rtx loop_notes;
+sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
{
RTX_CODE code = GET_CODE (x);
rtx link;
for every dependency. */
void
-sched_analyze (deps, head, tail)
- struct deps *deps;
- rtx head, tail;
+sched_analyze (struct deps *deps, rtx head, rtx tail)
{
rtx insn;
rtx loop_notes = 0;
/* Now that we have completed handling INSN, check and see if it is
a CLOBBER beginning a libcall block. If it is, record the
- end of the libcall sequence.
+ end of the libcall sequence.
We want to schedule libcall blocks as a unit before reload. While
this restricts scheduling, it preserves the meaning of a libcall
a libcall block. */
if (!reload_completed
/* Note we may have nested libcall sequences. We only care about
- the outermost libcall sequence. */
+ the outermost libcall sequence. */
&& deps->libcall_block_tail_insn == 0
/* The sequence must start with a clobber of a register. */
&& GET_CODE (insn) == INSN
given DEP_TYPE. The forward dependence should be not exist before. */
void
-add_forward_dependence (from, to, dep_type)
- rtx from;
- rtx to;
- enum reg_note dep_type;
+add_forward_dependence (rtx from, rtx to, enum reg_note dep_type)
{
rtx new_link;
/* If add_dependence is working properly there should never
be notes, deleted insns or duplicates in the backward
links. Thus we need not check for them here.
-
+
However, if we have enabled checking we might as well go
ahead and verify that add_dependence worked properly. */
if (GET_CODE (from) == NOTE
SET_BIT (forward_dependency_cache[INSN_LUID (from)],
INSN_LUID (to));
#endif
-
+
new_link = alloc_INSN_LIST (to, INSN_DEPEND (from));
-
+
PUT_REG_NOTE_KIND (new_link, dep_type);
-
+
INSN_DEPEND (from) = new_link;
INSN_DEP_COUNT (to) += 1;
}
INSN_DEPEND. */
void
-compute_forward_dependences (head, tail)
- rtx head, tail;
+compute_forward_dependences (rtx head, rtx tail)
{
rtx insn, link;
rtx next_tail;
n_bbs is the number of region blocks. */
void
-init_deps (deps)
- struct deps *deps;
+init_deps (struct deps *deps)
{
int max_reg = (reload_completed ? FIRST_PSEUDO_REGISTER : max_reg_num ());
/* Free insn lists found in DEPS. */
void
-free_deps (deps)
- struct deps *deps;
+free_deps (struct deps *deps)
{
int i;
it is used in the estimate of profitability. */
void
-init_dependency_caches (luid)
- int luid;
+init_dependency_caches (int luid)
{
/* ?!? We could save some memory by computing a per-region luid mapping
which could reduce both the number of vectors in the cache and the size
/* Free the caches allocated in init_dependency_caches. */
void
-free_dependency_caches ()
+free_dependency_caches (void)
{
if (true_dependency_cache)
{
code. */
void
-init_deps_global ()
+init_deps_global (void)
{
reg_pending_sets = INITIALIZE_REG_SET (reg_pending_sets_head);
reg_pending_clobbers = INITIALIZE_REG_SET (reg_pending_clobbers_head);
/* Free everything used by the dependency analysis code. */
void
-finish_deps_global ()
+finish_deps_global (void)
{
FREE_REG_SET (reg_pending_sets);
FREE_REG_SET (reg_pending_clobbers);
/* 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)
static int sched_n_insns;
/* Implementations of the sched_info functions for region scheduling. */
-static void init_ready_list PARAMS ((struct ready_list *));
-static int can_schedule_ready_p PARAMS ((rtx));
-static int new_ready PARAMS ((rtx));
-static int schedule_more_p PARAMS ((void));
-static const char *ebb_print_insn PARAMS ((rtx, int));
-static int rank PARAMS ((rtx, rtx));
-static int contributes_to_priority PARAMS ((rtx, rtx));
-static void compute_jump_reg_dependencies PARAMS ((rtx, regset));
-static basic_block earliest_block_with_similiar_load PARAMS ((basic_block,
- rtx));
-static void add_deps_for_risky_insns PARAMS ((rtx, rtx));
-static basic_block schedule_ebb PARAMS ((rtx, rtx));
-static basic_block fix_basic_block_boundaries PARAMS ((basic_block, basic_block, rtx, rtx));
-static void add_missing_bbs PARAMS ((rtx, basic_block, basic_block));
+static void init_ready_list (struct ready_list *);
+static int can_schedule_ready_p (rtx);
+static int new_ready (rtx);
+static int schedule_more_p (void);
+static const char *ebb_print_insn (rtx, int);
+static int rank (rtx, rtx);
+static int contributes_to_priority (rtx, rtx);
+static void compute_jump_reg_dependencies (rtx, regset);
+static basic_block earliest_block_with_similiar_load (basic_block, rtx);
+static void add_deps_for_risky_insns (rtx, rtx);
+static basic_block schedule_ebb (rtx, rtx);
+static basic_block fix_basic_block_boundaries (basic_block, basic_block, rtx,
+ rtx);
+static void add_missing_bbs (rtx, basic_block, basic_block);
/* Return nonzero if there are more insns that should be scheduled. */
static int
-schedule_more_p ()
+schedule_more_p (void)
{
return sched_n_insns < target_n_insns;
}
once before scheduling a set of insns. */
static void
-init_ready_list (ready)
- struct ready_list *ready;
+init_ready_list (struct ready_list *ready)
{
rtx prev_head = current_sched_info->prev_head;
rtx next_tail = current_sched_info->next_tail;
insn can be scheduled, nonzero if we should silently discard it. */
static int
-can_schedule_ready_p (insn)
- rtx insn ATTRIBUTE_UNUSED;
+can_schedule_ready_p (rtx insn ATTRIBUTE_UNUSED)
{
sched_n_insns++;
return 1;
if it should be moved to the ready list or the queue, or zero if we
should silently discard it. */
static int
-new_ready (next)
- rtx next ATTRIBUTE_UNUSED;
+new_ready (rtx next ATTRIBUTE_UNUSED)
{
return 1;
}
to be formatted so that multiple output lines will line up nicely. */
static const char *
-ebb_print_insn (insn, aligned)
- rtx insn;
- int aligned ATTRIBUTE_UNUSED;
+ebb_print_insn (rtx insn, int aligned ATTRIBUTE_UNUSED)
{
static char tmp[80];
is to be preferred. Zero if they are equally good. */
static int
-rank (insn1, insn2)
- rtx insn1, insn2;
+rank (rtx insn1, rtx insn2)
{
basic_block bb1 = BLOCK_FOR_INSN (insn1);
basic_block bb2 = BLOCK_FOR_INSN (insn2);
calculations. */
static int
-contributes_to_priority (next, insn)
- rtx next ATTRIBUTE_UNUSED, insn ATTRIBUTE_UNUSED;
+contributes_to_priority (rtx next ATTRIBUTE_UNUSED,
+ rtx insn ATTRIBUTE_UNUSED)
{
return 1;
}
to be set by this jump in SET. */
static void
-compute_jump_reg_dependencies (insn, set)
- rtx insn;
- regset set;
+compute_jump_reg_dependencies (rtx insn, regset set)
{
basic_block b = BLOCK_FOR_INSN (insn);
edge e;
Place blocks from FIRST to LAST before BEFORE. */
static void
-add_missing_bbs (before, first, last)
- rtx before;
- basic_block first, last;
+add_missing_bbs (rtx before, basic_block first, basic_block last)
{
for (; last != first->prev_bb; last = last->prev_bb)
{
structures between BB and LAST. */
static basic_block
-fix_basic_block_boundaries (bb, last, head, tail)
- basic_block bb, last;
- rtx head, tail;
+fix_basic_block_boundaries (basic_block bb, basic_block last, rtx head,
+ rtx tail)
{
rtx insn = head;
rtx last_inside = bb->head;
In this case we can create new basic block. It is
always exactly one basic block last in the sequence. Handle
it by splitting the edge and repositioning the block.
- This is somewhat hackish, but at least avoid cut&paste
+ This is somewhat hackish, but at least avoid cut&paste
A safer solution can be to bring the code into sequence,
do the split and re-emit it back in case this will ever
blocks in EBB. The list is formed in `add_deps_for_risky_insns'. */
static basic_block
-earliest_block_with_similiar_load (last_block, load_insn)
- basic_block last_block;
- rtx load_insn;
+earliest_block_with_similiar_load (basic_block last_block, rtx load_insn)
{
rtx back_link;
basic_block bb, earliest_block = NULL;
if (haifa_classify_insn (insn2) != PFREE_CANDIDATE)
/* insn2 not guaranteed to be a 1 base reg load. */
continue;
-
+
for (bb = last_block; bb; bb = bb->aux)
if (insn2_block == bb)
break;
insns in given ebb. */
static void
-add_deps_for_risky_insns (head, tail)
- rtx head, tail;
+add_deps_for_risky_insns (rtx head, rtx tail)
{
rtx insn, prev;
int class;
rtx last_jump = NULL_RTX;
rtx next_tail = NEXT_INSN (tail);
basic_block last_block = NULL, bb;
-
+
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
if (GET_CODE (insn) == JUMP_INSN)
{
if (add_dependence (insn, prev, REG_DEP_ANTI))
add_forward_dependence (prev, insn, REG_DEP_ANTI);
break;
-
+
default:
break;
}
and TAIL. */
static basic_block
-schedule_ebb (head, tail)
- rtx head, tail;
+schedule_ebb (rtx head, rtx tail)
{
int n_insns;
basic_block b;
this pass. */
void
-schedule_ebbs (dump_file)
- FILE *dump_file;
+schedule_ebbs (FILE *dump_file)
{
basic_block bb;
/* Instruction scheduling pass. This file contains definitions used
internally in the scheduler.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
This file is part of GCC.
{
/* Add all insns that are initially ready to the ready list. Called once
before scheduling a set of insns. */
- void (*init_ready_list) PARAMS ((struct ready_list *));
+ void (*init_ready_list) (struct ready_list *);
/* Called after taking an insn from the ready list. Returns nonzero if
this insn can be scheduled, nonzero if we should silently discard it. */
int (*can_schedule_ready_p) PARAMS ((rtx));
#endif
/* Functions in sched-vis.c. */
-extern void init_target_units PARAMS ((void));
-extern void insn_print_units PARAMS ((rtx));
-extern void init_block_visualization PARAMS ((void));
-extern void print_block_visualization PARAMS ((const char *));
-extern void visualize_scheduled_insns PARAMS ((int));
-extern void visualize_no_unit PARAMS ((rtx));
-extern void visualize_stall_cycles PARAMS ((int));
-extern void visualize_alloc PARAMS ((void));
-extern void visualize_free PARAMS ((void));
+extern void init_target_units (void);
+extern void insn_print_units (rtx);
+extern void init_block_visualization (void);
+extern void print_block_visualization (const char *);
+extern void visualize_scheduled_insns (int);
+extern void visualize_no_unit (rtx);
+extern void visualize_stall_cycles (int);
+extern void visualize_alloc (void);
+extern void visualize_free (void);
/* Functions in sched-deps.c. */
-extern int add_dependence PARAMS ((rtx, rtx, enum reg_note));
-extern void add_insn_mem_dependence PARAMS ((struct deps *, rtx *, rtx *, rtx,
- rtx));
-extern void sched_analyze PARAMS ((struct deps *, rtx, rtx));
-extern void init_deps PARAMS ((struct deps *));
-extern void free_deps PARAMS ((struct deps *));
-extern void init_deps_global PARAMS ((void));
-extern void finish_deps_global PARAMS ((void));
-extern void add_forward_dependence PARAMS ((rtx, rtx, enum reg_note));
-extern void compute_forward_dependences PARAMS ((rtx, rtx));
-extern rtx find_insn_list PARAMS ((rtx, rtx));
-extern void init_dependency_caches PARAMS ((int));
-extern void free_dependency_caches PARAMS ((void));
+extern int add_dependence (rtx, rtx, enum reg_note);
+extern void add_insn_mem_dependence (struct deps *, rtx *, rtx *, rtx, rtx);
+extern void sched_analyze (struct deps *, rtx, rtx);
+extern void init_deps (struct deps *);
+extern void free_deps (struct deps *);
+extern void init_deps_global (void);
+extern void finish_deps_global (void);
+extern void add_forward_dependence (rtx, rtx, enum reg_note);
+extern void compute_forward_dependences (rtx, rtx);
+extern rtx find_insn_list (rtx, rtx);
+extern void init_dependency_caches (int);
+extern void free_dependency_caches (void);
/* Functions in haifa-sched.c. */
-extern int haifa_classify_insn PARAMS ((rtx));
-extern void get_block_head_tail PARAMS ((int, rtx *, rtx *));
-extern int no_real_insns_p PARAMS ((rtx, rtx));
+extern int haifa_classify_insn (rtx);
+extern void get_block_head_tail (int, rtx *, rtx *);
+extern int no_real_insns_p (rtx, rtx);
-extern void rm_line_notes PARAMS ((rtx, rtx));
-extern void save_line_notes PARAMS ((int, rtx, rtx));
-extern void restore_line_notes PARAMS ((rtx, rtx));
-extern void rm_redundant_line_notes PARAMS ((void));
-extern void rm_other_notes PARAMS ((rtx, rtx));
+extern void rm_line_notes (rtx, rtx);
+extern void save_line_notes (int, rtx, rtx);
+extern void restore_line_notes (rtx, rtx);
+extern void rm_redundant_line_notes (void);
+extern void rm_other_notes (rtx, rtx);
-extern int insn_issue_delay PARAMS ((rtx));
-extern int set_priorities PARAMS ((rtx, rtx));
+extern int insn_issue_delay (rtx);
+extern int set_priorities (rtx, rtx);
-extern rtx sched_emit_insn PARAMS ((rtx));
-extern void schedule_block PARAMS ((int, int));
-extern void sched_init PARAMS ((FILE *));
-extern void sched_finish PARAMS ((void));
+extern rtx sched_emit_insn (rtx);
+extern void schedule_block (int, int);
+extern void sched_init (FILE *);
+extern void sched_finish (void);
-extern void ready_add PARAMS ((struct ready_list *, rtx));
+extern void ready_add (struct ready_list *, rtx);
/* The following are exported for the benefit of debugging functions. It
would be nicer to keep them private to haifa-sched.c. */
-extern int insn_unit PARAMS ((rtx));
-extern int insn_cost PARAMS ((rtx, rtx, rtx));
-extern rtx get_unit_last_insn PARAMS ((int));
-extern int actual_hazard_this_instance PARAMS ((int, int, rtx, int, int));
-extern void print_insn PARAMS ((char *, rtx, int));
+extern int insn_unit (rtx);
+extern int insn_cost (rtx, rtx, rtx);
+extern rtx get_unit_last_insn (int);
+extern int actual_hazard_this_instance (int, int, rtx, int, int);
+extern void print_insn (char *, rtx, int);
/* 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)
#define IN_EDGES(block) (in_edges[block])
#define OUT_EDGES(block) (out_edges[block])
-static int is_cfg_nonregular PARAMS ((void));
-static int build_control_flow PARAMS ((struct edge_list *));
-static void new_edge PARAMS ((int, int));
+static int is_cfg_nonregular (void);
+static int build_control_flow (struct edge_list *);
+static void new_edge (int, int);
/* A region is the main entity for interblock scheduling: insns
are allowed to move between blocks in the same region, along
#define BLOCK_TO_BB(block) (block_to_bb[block])
#define CONTAINING_RGN(block) (containing_rgn[block])
-void debug_regions PARAMS ((void));
-static void find_single_block_region PARAMS ((void));
-static void find_rgns PARAMS ((struct edge_list *, dominance_info));
-static int too_large PARAMS ((int, int *, int *));
+void debug_regions (void);
+static void find_single_block_region (void);
+static void find_rgns (struct edge_list *, dominance_info);
+static int too_large (int, int *, int *);
-extern void debug_live PARAMS ((int, int));
+extern void debug_live (int, int);
/* Blocks of the current region being scheduled. */
static int current_nr_blocks;
static int bitlst_table_last;
static int *bitlst_table;
-static void extract_bitlst PARAMS ((sbitmap, bitlst *));
+static void extract_bitlst (sbitmap, bitlst *);
/* Target info declarations.
typedef bitlst edgelst;
/* Target info functions. */
-static void split_edges PARAMS ((int, int, edgelst *));
-static void compute_trg_info PARAMS ((int));
-void debug_candidate PARAMS ((int));
-void debug_candidates PARAMS ((int));
+static void split_edges (int, int, edgelst *);
+static void compute_trg_info (int);
+void debug_candidate (int);
+void debug_candidates (int);
/* Dominators array: dom[i] contains the sbitmap of dominators of
bb i in the region. */
/* For every bb, a set of its ancestor edges. */
static edgeset *ancestor_edges;
-static void compute_dom_prob_ps PARAMS ((int));
+static void compute_dom_prob_ps (int);
#define INSN_PROBABILITY(INSN) (SRC_PROB (BLOCK_TO_BB (BLOCK_NUM (INSN))))
#define IS_SPECULATIVE_INSN(INSN) (IS_SPECULATIVE (BLOCK_TO_BB (BLOCK_NUM (INSN))))
#define MIN_PROBABILITY 40
/* Speculative scheduling functions. */
-static int check_live_1 PARAMS ((int, rtx));
-static void update_live_1 PARAMS ((int, rtx));
-static int check_live PARAMS ((rtx, int));
-static void update_live PARAMS ((rtx, int));
-static void set_spec_fed PARAMS ((rtx));
-static int is_pfree PARAMS ((rtx, int, int));
-static int find_conditional_protection PARAMS ((rtx, int));
-static int is_conditionally_protected PARAMS ((rtx, int, int));
-static int is_prisky PARAMS ((rtx, int, int));
-static int is_exception_free PARAMS ((rtx, int, int));
-
-static bool sets_likely_spilled PARAMS ((rtx));
-static void sets_likely_spilled_1 PARAMS ((rtx, rtx, void *));
-static void add_branch_dependences PARAMS ((rtx, rtx));
-static void compute_block_backward_dependences PARAMS ((int));
-void debug_dependencies PARAMS ((void));
-
-static void init_regions PARAMS ((void));
-static void schedule_region PARAMS ((int));
-static rtx concat_INSN_LIST PARAMS ((rtx, rtx));
-static void concat_insn_mem_list PARAMS ((rtx, rtx, rtx *, rtx *));
-static void propagate_deps PARAMS ((int, struct deps *));
-static void free_pending_lists PARAMS ((void));
+static int check_live_1 (int, rtx);
+static void update_live_1 (int, rtx);
+static int check_live (rtx, int);
+static void update_live (rtx, int);
+static void set_spec_fed (rtx);
+static int is_pfree (rtx, int, int);
+static int find_conditional_protection (rtx, int);
+static int is_conditionally_protected (rtx, int, int);
+static int is_prisky (rtx, int, int);
+static int is_exception_free (rtx, int, int);
+
+static bool sets_likely_spilled (rtx);
+static void sets_likely_spilled_1 (rtx, rtx, void *);
+static void add_branch_dependences (rtx, rtx);
+static void compute_block_backward_dependences (int);
+void debug_dependencies (void);
+
+static void init_regions (void);
+static void schedule_region (int);
+static rtx concat_INSN_LIST (rtx, rtx);
+static void concat_insn_mem_list (rtx, rtx, rtx *, rtx *);
+static void propagate_deps (int, struct deps *);
+static void free_pending_lists (void);
/* Functions for construction of the control flow graph. */
have nonlocal gotos. */
static int
-is_cfg_nonregular ()
+is_cfg_nonregular (void)
{
basic_block b;
rtx insn;
prevent cross block scheduling. */
static int
-build_control_flow (edge_list)
- struct edge_list *edge_list;
+build_control_flow (struct edge_list *edge_list)
{
int i, unreachable, num_edges;
basic_block b;
integer lists. */
static void
-new_edge (source, target)
- int source, target;
+new_edge (int source, int target)
{
int e, next_edge;
int curr_edge, fst_edge;
/* Translate a bit-set SET to a list BL of the bit-set members. */
static void
-extract_bitlst (set, bl)
- sbitmap set;
- bitlst *bl;
+extract_bitlst (sbitmap set, bitlst *bl)
{
int i;
/* Print the regions, for debugging purposes. Callable from debugger. */
void
-debug_regions ()
+debug_regions (void)
{
int rgn, bb;
scheduling. */
static void
-find_single_block_region ()
+find_single_block_region (void)
{
basic_block bb;
scheduling (compile time considerations), otherwise return 0. */
static int
-too_large (block, num_bbs, num_insns)
- int block, *num_bbs, *num_insns;
+too_large (int block, int *num_bbs, int *num_insns)
{
(*num_bbs)++;
(*num_insns) += (INSN_LUID (BLOCK_END (block)) -
of edge tables. That would simplify it somewhat. */
static void
-find_rgns (edge_list, dom)
- struct edge_list *edge_list;
- dominance_info dom;
+find_rgns (struct edge_list *edge_list, dominance_info dom)
{
int *max_hdr, *dfs_nr, *stack, *degree;
char no_loops = 1;
Assume that these values were already computed for bb's predecessors. */
static void
-compute_dom_prob_ps (bb)
- int bb;
+compute_dom_prob_ps (int bb)
{
int nxt_in_edge, fst_in_edge, pred;
int fst_out_edge, nxt_out_edge, nr_out_edges, nr_rgn_out_edges;
Note that bb_trg dominates bb_src. */
static void
-split_edges (bb_src, bb_trg, bl)
- int bb_src;
- int bb_trg;
- edgelst *bl;
+split_edges (int bb_src, int bb_trg, edgelst *bl)
{
sbitmap src = (edgeset) sbitmap_alloc (pot_split[bb_src]->n_bits);
sbitmap_copy (src, pot_split[bb_src]);
For speculative sources, compute their update-blocks and split-blocks. */
static void
-compute_trg_info (trg)
- int trg;
+compute_trg_info (int trg)
{
candidate *sp;
edgelst el;
/* Print candidates info, for debugging purposes. Callable from debugger. */
void
-debug_candidate (i)
- int i;
+debug_candidate (int i)
{
if (!candidate_table[i].is_valid)
return;
/* Print candidates info, for debugging purposes. Callable from debugger. */
void
-debug_candidates (trg)
- int trg;
+debug_candidates (int trg)
{
int i;
of the split-blocks of src, otherwise return 1. */
static int
-check_live_1 (src, x)
- int src;
- rtx x;
+check_live_1 (int src, rtx x)
{
int i;
int regno;
of every update-block of src. */
static void
-update_live_1 (src, x)
- int src;
- rtx x;
+update_live_1 (int src, rtx x)
{
int i;
int regno;
ready-list or before the scheduling. */
static int
-check_live (insn, src)
- rtx insn;
- int src;
+check_live (rtx insn, int src)
{
/* Find the registers set by instruction. */
if (GET_CODE (PATTERN (insn)) == SET
block src to trg. */
static void
-update_live (insn, src)
- rtx insn;
- int src;
+update_live (rtx insn, int src)
{
/* Find the registers set by instruction. */
if (GET_CODE (PATTERN (insn)) == SET
/* Turns on the fed_by_spec_load flag for insns fed by load_insn. */
static void
-set_spec_fed (load_insn)
- rtx load_insn;
+set_spec_fed (rtx load_insn)
{
rtx link;
branch depending on insn, that guards the speculative load. */
static int
-find_conditional_protection (insn, load_insn_bb)
- rtx insn;
- int load_insn_bb;
+find_conditional_protection (rtx insn, int load_insn_bb)
{
rtx link;
Locate the branch by following INSN_DEPEND from insn1. */
static int
-is_conditionally_protected (load_insn, bb_src, bb_trg)
- rtx load_insn;
- int bb_src, bb_trg;
+is_conditionally_protected (rtx load_insn, int bb_src, int bb_trg)
{
rtx link;
load2 anyhow. */
static int
-is_pfree (load_insn, bb_src, bb_trg)
- rtx load_insn;
- int bb_src, bb_trg;
+is_pfree (rtx load_insn, int bb_src, int bb_trg)
{
rtx back_link;
candidate *candp = candidate_table + bb_src;
a compare on load_insn's address). */
static int
-is_prisky (load_insn, bb_src, bb_trg)
- rtx load_insn;
- int bb_src, bb_trg;
+is_prisky (rtx load_insn, int bb_src, int bb_trg)
{
if (FED_BY_SPEC_LOAD (load_insn))
return 1;
and 0 otherwise. */
static int
-is_exception_free (insn, bb_src, bb_trg)
- rtx insn;
- int bb_src, bb_trg;
+is_exception_free (rtx insn, int bb_src, int bb_trg)
{
int insn_class = haifa_classify_insn (insn);
static int last_was_jump;
/* Implementations of the sched_info functions for region scheduling. */
-static void init_ready_list PARAMS ((struct ready_list *));
-static int can_schedule_ready_p PARAMS ((rtx));
-static int new_ready PARAMS ((rtx));
-static int schedule_more_p PARAMS ((void));
-static const char *rgn_print_insn PARAMS ((rtx, int));
-static int rgn_rank PARAMS ((rtx, rtx));
-static int contributes_to_priority PARAMS ((rtx, rtx));
-static void compute_jump_reg_dependencies PARAMS ((rtx, regset));
+static void init_ready_list (struct ready_list *);
+static int can_schedule_ready_p (rtx);
+static int new_ready (rtx);
+static int schedule_more_p (void);
+static const char *rgn_print_insn (rtx, int);
+static int rgn_rank (rtx, rtx);
+static int contributes_to_priority (rtx, rtx);
+static void compute_jump_reg_dependencies (rtx, regset);
/* Return nonzero if there are more insns that should be scheduled. */
static int
-schedule_more_p ()
+schedule_more_p (void)
{
return ! last_was_jump && sched_target_n_insns < target_n_insns;
}
once before scheduling a set of insns. */
static void
-init_ready_list (ready)
- struct ready_list *ready;
+init_ready_list (struct ready_list *ready)
{
rtx prev_head = current_sched_info->prev_head;
rtx next_tail = current_sched_info->next_tail;
insn can be scheduled, nonzero if we should silently discard it. */
static int
-can_schedule_ready_p (insn)
- rtx insn;
+can_schedule_ready_p (rtx insn)
{
if (GET_CODE (insn) == JUMP_INSN)
last_was_jump = 1;
if it should be moved to the ready list or the queue, or zero if we
should silently discard it. */
static int
-new_ready (next)
- rtx next;
+new_ready (rtx next)
{
/* For speculative insns, before inserting to ready/queue,
check live, exception-free, and issue-delay. */
to be formatted so that multiple output lines will line up nicely. */
static const char *
-rgn_print_insn (insn, aligned)
- rtx insn;
- int aligned;
+rgn_print_insn (rtx insn, int aligned)
{
static char tmp[80];
is to be preferred. Zero if they are equally good. */
static int
-rgn_rank (insn1, insn2)
- rtx insn1, insn2;
+rgn_rank (rtx insn1, rtx insn2)
{
/* Some comparison make sense in interblock scheduling only. */
if (INSN_BB (insn1) != INSN_BB (insn2))
calculations. */
static int
-contributes_to_priority (next, insn)
- rtx next, insn;
+contributes_to_priority (rtx next, rtx insn)
{
return BLOCK_NUM (next) == BLOCK_NUM (insn);
}
to be set by this jump in SET. */
static void
-compute_jump_reg_dependencies (insn, set)
- rtx insn ATTRIBUTE_UNUSED;
- regset set ATTRIBUTE_UNUSED;
+compute_jump_reg_dependencies (rtx insn ATTRIBUTE_UNUSED,
+ regset set ATTRIBUTE_UNUSED)
{
/* Nothing to do here, since we postprocess jumps in
add_branch_dependences. */
/* Determine if PAT sets a CLASS_LIKELY_SPILLED_P register. */
static bool
-sets_likely_spilled (pat)
- rtx pat;
+sets_likely_spilled (rtx pat)
{
bool ret = false;
note_stores (pat, sets_likely_spilled_1, &ret);
}
static void
-sets_likely_spilled_1 (x, pat, data)
- rtx x, pat;
- void *data;
+sets_likely_spilled_1 (rtx x, rtx pat, void *data)
{
bool *ret = (bool *) data;
block. */
static void
-add_branch_dependences (head, tail)
- rtx head, tail;
+add_branch_dependences (rtx head, rtx tail)
{
rtx insn, last;
/* Duplicate the INSN_LIST elements of COPY and prepend them to OLD. */
static rtx
-concat_INSN_LIST (copy, old)
- rtx copy, old;
+concat_INSN_LIST (rtx copy, rtx old)
{
rtx new = old;
for (; copy ; copy = XEXP (copy, 1))
}
static void
-concat_insn_mem_list (copy_insns, copy_mems, old_insns_p, old_mems_p)
- rtx copy_insns, copy_mems;
- rtx *old_insns_p, *old_mems_p;
+concat_insn_mem_list (rtx copy_insns, rtx copy_mems, rtx *old_insns_p,
+ rtx *old_mems_p)
{
rtx new_insns = *old_insns_p;
rtx new_mems = *old_mems_p;
/* After computing the dependencies for block BB, propagate the dependencies
found in TMP_DEPS to the successors of the block. */
static void
-propagate_deps (bb, pred_deps)
- int bb;
- struct deps *pred_deps;
+propagate_deps (int bb, struct deps *pred_deps)
{
int b = BB_TO_BLOCK (bb);
int e, first_edge;
similar, and the result is interblock dependences in the region. */
static void
-compute_block_backward_dependences (bb)
- int bb;
+compute_block_backward_dependences (int bb)
{
rtx head, tail;
struct deps tmp_deps;
them to the unused_*_list variables, so that they can be reused. */
static void
-free_pending_lists ()
+free_pending_lists (void)
{
int bb;
/* Print dependences for debugging, callable from debugger. */
void
-debug_dependencies ()
+debug_dependencies (void)
{
int bb;
scheduled after its flow predecessors. */
static void
-schedule_region (rgn)
- int rgn;
+schedule_region (int rgn)
{
int bb;
int rgn_n_insns = 0;
/* rm_other_notes only removes notes which are _inside_ the
block---that is, it won't remove notes before the first real insn
- or after the last real insn of the block. So if the first insn
+ or after the last real insn of the block. So if the first insn
has a REG_SAVE_NOTE which would otherwise be emitted before the
insn, it is redundant with the note before the start of the
block, and so we have to take it out. */
/* Initialize data structures for region scheduling. */
static void
-init_regions ()
+init_regions (void)
{
sbitmap blocks;
int rgn;
this pass. */
void
-schedule_insns (dump_file)
- FILE *dump_file;
+schedule_insns (FILE *dump_file)
{
sbitmap large_region_blocks, blocks;
int rgn;
/* Instruction scheduling pass.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2002 Free Software Foundation, Inc.
+ 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
static int target_units = 0;
-static char *safe_concat PARAMS ((char *, char *, const char *));
-static int get_visual_tbl_length PARAMS ((void));
-static void print_exp PARAMS ((char *, rtx, int));
-static void print_value PARAMS ((char *, rtx, int));
-static void print_pattern PARAMS ((char *, rtx, int));
+static char *safe_concat (char *, char *, const char *);
+static int get_visual_tbl_length (void);
+static void print_exp (char *, rtx, int);
+static void print_value (char *, rtx, int);
+static void print_pattern (char *, rtx, int);
/* Print names of units on which insn can/should execute, for debugging. */
void
-insn_print_units (insn)
- rtx insn;
+insn_print_units (rtx insn)
{
int i;
int unit = insn_unit (insn);
for visualization. */
void
-init_target_units ()
+init_target_units (void)
{
rtx insn;
int unit;
/* Return the length of the visualization table. */
static int
-get_visual_tbl_length ()
+get_visual_tbl_length (void)
{
int unit, i;
int n, n1;
/* Init block visualization debugging info. */
void
-init_block_visualization ()
+init_block_visualization (void)
{
strcpy (visual_tbl, "");
n_visual_lines = 0;
#define BUF_LEN 2048
static char *
-safe_concat (buf, cur, str)
- char *buf;
- char *cur;
- const char *str;
+safe_concat (char *buf, char *cur, const char *str)
{
char *end = buf + BUF_LEN - 2; /* Leave room for null. */
int c;
may be stored in objects representing values. */
static void
-print_exp (buf, x, verbose)
- char *buf;
- rtx x;
- int verbose;
+print_exp (char *buf, rtx x, int verbose)
{
char tmp[BUF_LEN];
const char *st[4];
registers, labels, symbols and memory accesses. */
static void
-print_value (buf, x, verbose)
- char *buf;
- rtx x;
- int verbose;
+print_value (char *buf, rtx x, int verbose)
{
char t[BUF_LEN];
char *cur = buf;
/* The next step in insn detalization, its pattern recognition. */
static void
-print_pattern (buf, x, verbose)
- char *buf;
- rtx x;
- int verbose;
+print_pattern (char *buf, rtx x, int verbose)
{
char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
depends now on sched.c inner variables ...) */
void
-print_insn (buf, x, verbose)
- char *buf;
- rtx x;
- int verbose;
+print_insn (char *buf, rtx x, int verbose)
{
char t[BUF_LEN];
rtx insn = x;
description should never use the following function. */
void
-print_block_visualization (s)
- const char *s;
+print_block_visualization (const char *s)
{
int unit, i;
/* Print insns in the 'no_unit' column of visualization. */
void
-visualize_no_unit (insn)
- rtx insn;
+visualize_no_unit (rtx insn)
{
if (n_vis_no_unit < MAX_VISUAL_NO_UNIT)
{
/* Print insns scheduled in clock, for visualization. */
void
-visualize_scheduled_insns (clock)
- int clock;
+visualize_scheduled_insns (int clock)
{
int i, unit;
/* Print stalled cycles. */
void
-visualize_stall_cycles (stalls)
- int stalls;
+visualize_stall_cycles (int stalls)
{
static const char *const prefix = ";; ";
const char *suffix = "\n";
/* Allocate data used for visualization during scheduling. */
void
-visualize_alloc ()
+visualize_alloc (void)
{
visual_tbl = xmalloc (get_visual_tbl_length ());
}
/* Free data used for visualization. */
void
-visualize_free ()
+visualize_free (void)
{
free (visual_tbl);
}
/* Generic sibling call optimization support
- Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2001, 2002, 2003
+ Free Software Foundation, Inc.
This file is part of GCC.
return in the sibcall sequence. */
static rtx return_value_pseudo;
-static int identify_call_return_value PARAMS ((rtx, rtx *, rtx *));
-static rtx skip_copy_to_return_value PARAMS ((rtx));
-static rtx skip_use_of_return_value PARAMS ((rtx, enum rtx_code));
-static rtx skip_stack_adjustment PARAMS ((rtx));
-static rtx skip_pic_restore PARAMS ((rtx));
-static rtx skip_jump_insn PARAMS ((rtx));
-static int call_ends_block_p PARAMS ((rtx, rtx));
-static int uses_addressof PARAMS ((rtx));
-static int sequence_uses_addressof PARAMS ((rtx));
-static void purge_reg_equiv_notes PARAMS ((void));
-static void purge_mem_unchanging_flag PARAMS ((rtx));
-static rtx skip_unreturned_value PARAMS ((rtx));
+static int identify_call_return_value (rtx, rtx *, rtx *);
+static rtx skip_copy_to_return_value (rtx);
+static rtx skip_use_of_return_value (rtx, enum rtx_code);
+static rtx skip_stack_adjustment (rtx);
+static rtx skip_pic_restore (rtx);
+static rtx skip_jump_insn (rtx);
+static int call_ends_block_p (rtx, rtx);
+static int uses_addressof (rtx);
+static int sequence_uses_addressof (rtx);
+static void purge_reg_equiv_notes (void);
+static void purge_mem_unchanging_flag (rtx);
+static rtx skip_unreturned_value (rtx);
/* Examine a CALL_PLACEHOLDER pattern and determine where the call's
return value is located. P_HARD_RETURN receives the hard register
that the sequence used. Return nonzero if the values were located. */
static int
-identify_call_return_value (cp, p_hard_return, p_soft_return)
- rtx cp;
- rtx *p_hard_return, *p_soft_return;
+identify_call_return_value (rtx cp, rtx *p_hard_return, rtx *p_soft_return)
{
rtx insn, set, hard, soft;
copy. Otherwise return ORIG_INSN. */
static rtx
-skip_copy_to_return_value (orig_insn)
- rtx orig_insn;
+skip_copy_to_return_value (rtx orig_insn)
{
rtx insn, set = NULL_RTX;
rtx hardret, softret;
value, return insn. Otherwise return ORIG_INSN. */
static rtx
-skip_use_of_return_value (orig_insn, code)
- rtx orig_insn;
- enum rtx_code code;
+skip_use_of_return_value (rtx orig_insn, enum rtx_code code)
{
rtx insn;
/* In case function does not return value, we get clobber of pseudo followed
by set to hard return value. */
static rtx
-skip_unreturned_value (orig_insn)
- rtx orig_insn;
+skip_unreturned_value (rtx orig_insn)
{
rtx insn = next_nonnote_insn (orig_insn);
Otherwise return ORIG_INSN. */
static rtx
-skip_stack_adjustment (orig_insn)
- rtx orig_insn;
+skip_stack_adjustment (rtx orig_insn)
{
rtx insn, set = NULL_RTX;
return it. Otherwise return ORIG_INSN. */
static rtx
-skip_pic_restore (orig_insn)
- rtx orig_insn;
+skip_pic_restore (rtx orig_insn)
{
rtx insn, set = NULL_RTX;
Otherwise return ORIG_INSN. */
static rtx
-skip_jump_insn (orig_insn)
- rtx orig_insn;
+skip_jump_insn (rtx orig_insn)
{
rtx insn;
goes all the way to END, the end of a basic block. Return 1 if so. */
static int
-call_ends_block_p (insn, end)
- rtx insn;
- rtx end;
+call_ends_block_p (rtx insn, rtx end)
{
rtx new_insn;
/* END might be a note, so get the last nonnote insn of the block. */
is found outside of some MEM expression, else return zero. */
static int
-uses_addressof (x)
- rtx x;
+uses_addressof (rtx x)
{
RTX_CODE code;
int i, j;
of insns. */
static int
-sequence_uses_addressof (seq)
- rtx seq;
+sequence_uses_addressof (rtx seq)
{
rtx insn;
/* Remove all REG_EQUIV notes found in the insn chain. */
static void
-purge_reg_equiv_notes ()
+purge_reg_equiv_notes (void)
{
rtx insn;
/* Clear RTX_UNCHANGING_P flag of incoming argument MEMs. */
static void
-purge_mem_unchanging_flag (x)
- rtx x;
+purge_mem_unchanging_flag (rtx x)
{
RTX_CODE code;
int i, j;
the CALL_PLACEHOLDER insn; USE tells which child to use. */
void
-replace_call_placeholder (insn, use)
- rtx insn;
- sibcall_use_t use;
+replace_call_placeholder (rtx insn, sibcall_use_t use)
{
if (use == sibcall_use_tail_recursion)
emit_insn_before (XEXP (PATTERN (insn), 2), insn);
Replace the CALL_PLACEHOLDER with an appropriate insn chain. */
void
-optimize_sibling_and_tail_recursive_calls ()
+optimize_sibling_and_tail_recursive_calls (void)
{
rtx insn, insns;
basic_block alternate_exit = EXIT_BLOCK_PTR;
#define HWI_SIGN_EXTEND(low) \
((((HOST_WIDE_INT) low) < 0) ? ((HOST_WIDE_INT) -1) : ((HOST_WIDE_INT) 0))
-static rtx neg_const_int PARAMS ((enum machine_mode, rtx));
-static int simplify_plus_minus_op_data_cmp PARAMS ((const void *,
- const void *));
-static rtx simplify_plus_minus PARAMS ((enum rtx_code,
- enum machine_mode, rtx,
- rtx, int));
+static rtx neg_const_int (enum machine_mode, rtx);
+static int simplify_plus_minus_op_data_cmp (const void *, const void *);
+static rtx simplify_plus_minus (enum rtx_code, enum machine_mode, rtx,
+ rtx, int);
\f
/* Negate a CONST_INT rtx, truncating (because a conversion from a
maximally negative number can overflow). */
static rtx
-neg_const_int (mode, i)
- enum machine_mode mode;
- rtx i;
+neg_const_int (enum machine_mode mode, rtx i)
{
return gen_int_mode (- INTVAL (i), mode);
}
seeing if the expression folds. */
rtx
-simplify_gen_binary (code, mode, op0, op1)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op0, op1;
+simplify_gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0,
+ rtx op1)
{
rtx tem;
/* If X is a MEM referencing the constant pool, return the real value.
Otherwise return X. */
rtx
-avoid_constant_pool_reference (x)
- rtx x;
+avoid_constant_pool_reference (rtx x)
{
rtx c, tmp, addr;
enum machine_mode cmode;
the specified operation. */
rtx
-simplify_gen_unary (code, mode, op, op_mode)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op;
- enum machine_mode op_mode;
+simplify_gen_unary (enum rtx_code code, enum machine_mode mode, rtx op,
+ enum machine_mode op_mode)
{
rtx tem;
/* Likewise for ternary operations. */
rtx
-simplify_gen_ternary (code, mode, op0_mode, op0, op1, op2)
- enum rtx_code code;
- enum machine_mode mode, op0_mode;
- rtx op0, op1, op2;
+simplify_gen_ternary (enum rtx_code code, enum machine_mode mode,
+ enum machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
{
rtx tem;
*/
rtx
-simplify_gen_relational (code, mode, cmp_mode, op0, op1)
- enum rtx_code code;
- enum machine_mode mode;
- enum machine_mode cmp_mode;
- rtx op0, op1;
+simplify_gen_relational (enum rtx_code code, enum machine_mode mode,
+ enum machine_mode cmp_mode, rtx op0, rtx op1)
{
rtx tem;
resulting RTX. Return a new RTX which is as simplified as possible. */
rtx
-simplify_replace_rtx (x, old, new)
- rtx x;
- rtx old;
- rtx new;
+simplify_replace_rtx (rtx x, rtx old, rtx new)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
rtx exp;
exp = simplify_gen_subreg (GET_MODE (x),
simplify_replace_rtx (SUBREG_REG (x),
- old, new),
+ old, new),
GET_MODE (SUBREG_REG (x)),
SUBREG_BYTE (x));
if (exp)
MODE with input operand OP whose mode was originally OP_MODE.
Return zero if no simplification can be made. */
rtx
-simplify_unary_operation (code, mode, op, op_mode)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op;
- enum machine_mode op_mode;
+simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
+ rtx op, enum machine_mode op_mode)
{
unsigned int width = GET_MODE_BITSIZE (mode);
rtx trueop = avoid_constant_pool_reference (op);
Don't use this for relational operations such as EQ or LT.
Use simplify_relational_operation instead. */
rtx
-simplify_binary_operation (code, mode, op0, op1)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op0, op1;
+simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
+ rtx op0, rtx op1)
{
HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
HOST_WIDE_INT val;
};
static int
-simplify_plus_minus_op_data_cmp (p1, p2)
- const void *p1;
- const void *p2;
+simplify_plus_minus_op_data_cmp (const void *p1, const void *p2)
{
const struct simplify_plus_minus_op_data *d1 = p1;
const struct simplify_plus_minus_op_data *d2 = p2;
}
static rtx
-simplify_plus_minus (code, mode, op0, op1, force)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op0, op1;
- int force;
+simplify_plus_minus (enum rtx_code code, enum machine_mode mode, rtx op0,
+ rtx op1, int force)
{
struct simplify_plus_minus_op_data ops[8];
rtx result, tem;
it returns either const_true_rtx or const0_rtx. */
rtx
-simplify_relational_operation (code, mode, op0, op1)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op0, op1;
+simplify_relational_operation (enum rtx_code code, enum machine_mode mode,
+ rtx op0, rtx op1)
{
int equal, op0lt, op0ltu, op1lt, op1ltu;
rtx tem;
return const_true_rtx;
}
break;
-
+
default:
break;
}
a constant. Return 0 if no simplifications is possible. */
rtx
-simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2)
- enum rtx_code code;
- enum machine_mode mode, op0_mode;
- rtx op0, op1, op2;
+simplify_ternary_operation (enum rtx_code code, enum machine_mode mode,
+ enum machine_mode op0_mode, rtx op0, rtx op1,
+ rtx op2)
{
unsigned int width = GET_MODE_BITSIZE (mode);
/* Simplify SUBREG:OUTERMODE(OP:INNERMODE, BYTE)
Return 0 if no simplifications is possible. */
rtx
-simplify_subreg (outermode, op, innermode, byte)
- rtx op;
- unsigned int byte;
- enum machine_mode outermode, innermode;
+simplify_subreg (enum machine_mode outermode, rtx op,
+ enum machine_mode innermode, unsigned int byte)
{
/* Little bit of sanity checking. */
if (innermode == VOIDmode || outermode == VOIDmode
/* Make a SUBREG operation or equivalent if it folds. */
rtx
-simplify_gen_subreg (outermode, op, innermode, byte)
- rtx op;
- unsigned int byte;
- enum machine_mode outermode, innermode;
+simplify_gen_subreg (enum machine_mode outermode, rtx op,
+ enum machine_mode innermode, unsigned int byte)
{
rtx new;
/* Little bit of sanity checking. */
simplification and 1 for tree simplification. */
rtx
-simplify_rtx (x)
- rtx x;
+simplify_rtx (rtx x)
{
enum rtx_code code = GET_CODE (x);
enum machine_mode mode = GET_MODE (x);
Value of sreal is
x = sig * 2 ^ exp
- where
+ where
sig = significant
(for < 64-bit machines sig = sig_lo + sig_hi * 2 ^ SREAL_PART_BITS)
exp = exponent
Only a half of significant bits is used (in normalized sreals) so that we do
not have problems with overflow, for example when c->sig = a->sig * b->sig.
So the precision for 64-bit and 32-bit machines is 32-bit.
-
+
Invariant: The numbers are normalized before and after each call of sreal_*.
Normalized sreals:
All numbers (except zero) meet following conditions:
SREAL_MIN_SIG <= sig && sig <= SREAL_MAX_SIG
- -SREAL_MAX_EXP <= exp && exp <= SREAL_MAX_EXP
+ -SREAL_MAX_EXP <= exp && exp <= SREAL_MAX_EXP
If the number would be too large, it is set to upper bounds of these
conditions.
#include "tm.h"
#include "sreal.h"
-static inline void copy PARAMS ((sreal *, sreal *));
-static inline void shift_right PARAMS ((sreal *, int));
-static void normalize PARAMS ((sreal *));
+static inline void copy (sreal *, sreal *);
+static inline void shift_right (sreal *, int);
+static void normalize (sreal *);
/* Print the content of struct sreal. */
void
-dump_sreal (file, x)
- FILE *file;
- sreal *x;
+dump_sreal (FILE *file, sreal *x)
{
#if SREAL_PART_BITS < 32
fprintf (file, "((" HOST_WIDE_INT_PRINT_UNSIGNED " * 2^16 + "
/* Copy the sreal number. */
static inline void
-copy (r, a)
- sreal *r;
- sreal *a;
+copy (sreal *r, sreal *a)
{
#if SREAL_PART_BITS < 32
r->sig_lo = a->sig_lo;
When the most significant bit shifted out is 1, add 1 to X (rounding). */
static inline void
-shift_right (x, s)
- sreal *x;
- int s;
+shift_right (sreal *x, int s)
{
#ifdef ENABLE_CHECKING
if (s <= 0 || s > SREAL_BITS)
/* Normalize *X. */
static void
-normalize (x)
- sreal *x;
+normalize (sreal *x)
{
#if SREAL_PART_BITS < 32
int shift;
HOST_WIDE_INT mask;
-
+
if (x->sig_lo == 0 && x->sig_hi == 0)
{
x->exp = -SREAL_MAX_EXP;
/* Set *R to SIG * 2 ^ EXP. Return R. */
sreal *
-sreal_init (r, sig, exp)
- sreal *r;
- unsigned HOST_WIDE_INT sig;
- signed int exp;
+sreal_init (sreal *r, unsigned HOST_WIDE_INT sig, signed int exp)
{
#if SREAL_PART_BITS < 32
r->sig_lo = 0;
/* Return integer value of *R. */
HOST_WIDE_INT
-sreal_to_int (r)
- sreal *r;
+sreal_to_int (sreal *r)
{
#if SREAL_PART_BITS < 32
if (r->exp <= -SREAL_BITS)
/* Compare *A and *B. Return -1 if *A < *B, 1 if *A > *B and 0 if *A == *B. */
int
-sreal_compare (a, b)
- sreal *a;
- sreal *b;
+sreal_compare (sreal *a, sreal *b)
{
if (a->exp > b->exp)
return 1;
/* *R = *A + *B. Return R. */
sreal *
-sreal_add (r, a, b)
- sreal *r;
- sreal *a;
- sreal *b;
+sreal_add (sreal *r, sreal *a, sreal *b)
{
int dexp;
sreal tmp;
/* *R = *A - *B. Return R. */
sreal *
-sreal_sub (r, a, b)
- sreal *r;
- sreal *a;
- sreal *b;
+sreal_sub (sreal *r, sreal *a, sreal *b)
{
int dexp;
sreal tmp;
/* *R = *A * *B. Return R. */
sreal *
-sreal_mul (r, a, b)
- sreal *r;
- sreal *a;
- sreal *b;
+sreal_mul (sreal *r, sreal *a, sreal *b)
{
#if SREAL_PART_BITS < 32
if (a->sig_hi < SREAL_MIN_SIG || b->sig_hi < SREAL_MIN_SIG)
/* *R = *A / *B. Return R. */
sreal *
-sreal_div (r, a, b)
- sreal *r;
- sreal *a;
- sreal *b;
+sreal_div (sreal *r, sreal *a, sreal *b)
{
#if SREAL_PART_BITS < 32
unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
/* Definitions for simple data type for positive real numbers.
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
signed int exp; /* Exponent. */
} sreal;
-extern void dump_sreal PARAMS ((FILE *, sreal *));
-extern sreal *sreal_init PARAMS ((sreal *,
- unsigned HOST_WIDE_INT,
- signed int));
-extern HOST_WIDE_INT sreal_to_int PARAMS ((sreal *));
-extern int sreal_compare PARAMS ((sreal *, sreal *));
-extern sreal *sreal_add PARAMS ((sreal *, sreal *, sreal *));
-extern sreal *sreal_sub PARAMS ((sreal *, sreal *, sreal *));
-extern sreal *sreal_mul PARAMS ((sreal *, sreal *, sreal *));
-extern sreal *sreal_div PARAMS ((sreal *, sreal *, sreal *));
+extern void dump_sreal (FILE *, sreal *);
+extern sreal *sreal_init (sreal *, unsigned HOST_WIDE_INT, signed int);
+extern HOST_WIDE_INT sreal_to_int (sreal *);
+extern int sreal_compare (sreal *, sreal *);
+extern sreal *sreal_add (sreal *, sreal *, sreal *);
+extern sreal *sreal_sub (sreal *, sreal *, sreal *);
+extern sreal *sreal_mul (sreal *, sreal *, sreal *);
+extern sreal *sreal_div (sreal *, sreal *, sreal *);
#endif
/* Conditional constant propagation pass for the GNU compiler.
- Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Original framework by Daniel Berlin <dan@cgsoftware.com>
Fleshed out and major cleanups by Jeff Law <law@redhat.com>
#define SSA_NAME(x) REGNO (SET_DEST (x))
#define EIE(x,y) EDGE_INDEX (edges, x, y)
-static void visit_phi_node PARAMS ((rtx, basic_block));
-static void visit_expression PARAMS ((rtx, basic_block));
-static void defs_to_undefined PARAMS ((rtx));
-static void defs_to_varying PARAMS ((rtx));
-static void examine_flow_edges PARAMS ((void));
-static int mark_references PARAMS ((rtx *, void *));
-static void follow_def_use_chains PARAMS ((void));
-static void optimize_unexecutable_edges PARAMS ((struct edge_list *, sbitmap));
-static void ssa_ccp_substitute_constants PARAMS ((void));
-static void ssa_ccp_df_delete_unreachable_insns PARAMS ((void));
-static void ssa_fast_dce PARAMS ((struct df *));
+static void visit_phi_node (rtx, basic_block);
+static void visit_expression (rtx, basic_block);
+static void defs_to_undefined (rtx);
+static void defs_to_varying (rtx);
+static void examine_flow_edges (void);
+static int mark_references (rtx *, void *);
+static void follow_def_use_chains (void);
+static void optimize_unexecutable_edges (struct edge_list *, sbitmap);
+static void ssa_ccp_substitute_constants (void);
+static void ssa_ccp_df_delete_unreachable_insns (void);
+static void ssa_fast_dce (struct df *);
/* Loop through the PHI_NODE's parameters for BLOCK and compare their
lattice values to determine PHI_NODE's lattice value. */
static void
-visit_phi_node (phi_node, block)
- rtx phi_node;
- basic_block block;
+visit_phi_node (rtx phi_node, basic_block block)
{
unsigned int i;
rtx phi_node_expr = NULL;
/* Sets all defs in an insn to UNDEFINED. */
static void
-defs_to_undefined (insn)
- rtx insn;
+defs_to_undefined (rtx insn)
{
struct df_link *currdef;
for (currdef = DF_INSN_DEFS (df_analyzer, insn); currdef;
/* Sets all defs in an insn to VARYING. */
static void
-defs_to_varying (insn)
- rtx insn;
+defs_to_varying (rtx insn)
{
struct df_link *currdef;
for (currdef = DF_INSN_DEFS (df_analyzer, insn); currdef;
/* Go through the expression, call the appropriate evaluation routines
to attempt cprop */
static void
-visit_expression (insn, block)
- rtx insn;
- basic_block block;
+visit_expression (rtx insn, basic_block block)
{
rtx src, dest, set;
/* Iterate over the FLOW_EDGES work list. Simulate the target block
for each edge. */
static void
-examine_flow_edges ()
+examine_flow_edges (void)
{
while (flow_edges != NULL)
{
simulate the uses of the definition. */
static void
-follow_def_use_chains ()
+follow_def_use_chains (void)
{
/* Iterate over all the entries on the SSA_EDGES worklist. */
while (sbitmap_first_set_bit (ssa_edges) >= 0)
the edge from the CFG. Note we do not delete unreachable blocks
yet as the DF analyzer can not deal with that yet. */
static void
-optimize_unexecutable_edges (edges, executable_edges)
- struct edge_list *edges;
- sbitmap executable_edges;
+optimize_unexecutable_edges (struct edge_list *edges,
+ sbitmap executable_edges)
{
int i;
basic_block bb;
replace uses with the known constant value. */
static void
-ssa_ccp_substitute_constants ()
+ssa_ccp_substitute_constants (void)
{
unsigned int i;
updates for the DF analyzer. */
static void
-ssa_ccp_df_delete_unreachable_insns ()
+ssa_ccp_df_delete_unreachable_insns (void)
{
basic_block b;
operate on so that it can be called for sub-graphs. */
void
-ssa_const_prop ()
+ssa_const_prop (void)
{
unsigned int i;
edge curredge;
}
static int
-mark_references (current_rtx, data)
- rtx *current_rtx;
- void *data;
+mark_references (rtx *current_rtx, void *data)
{
rtx x = *current_rtx;
sbitmap worklist = (sbitmap) data;
}
static void
-ssa_fast_dce (df)
- struct df *df;
+ssa_fast_dce (struct df *df)
{
sbitmap worklist = sbitmap_alloc (VARRAY_SIZE (ssa_definition));
sbitmap_ones (worklist);
/* Dead-code elimination pass for the GNU compiler.
- Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Written by Jeffrey D. Oldham <oldham@codesourcery.com>.
This file is part of GCC.
/* Local function prototypes. */
static control_dependent_block_to_edge_map control_dependent_block_to_edge_map_create
- PARAMS((size_t num_basic_blocks));
+ (size_t num_basic_blocks);
static void set_control_dependent_block_to_edge_map_bit
- PARAMS ((control_dependent_block_to_edge_map c, basic_block bb,
- int edge_index));
+ (control_dependent_block_to_edge_map c, basic_block bb, int edge_index);
static void control_dependent_block_to_edge_map_free
- PARAMS ((control_dependent_block_to_edge_map c));
+ (control_dependent_block_to_edge_map c);
static void find_all_control_dependences
- PARAMS ((struct edge_list *el, dominance_info pdom,
- control_dependent_block_to_edge_map cdbte));
+ (struct edge_list *el, dominance_info pdom,
+ control_dependent_block_to_edge_map cdbte);
static void find_control_dependence
- PARAMS ((struct edge_list *el, int edge_index, dominance_info pdom,
- control_dependent_block_to_edge_map cdbte));
-static basic_block find_pdom
- PARAMS ((dominance_info pdom, basic_block block));
-static int inherently_necessary_register_1
- PARAMS ((rtx *current_rtx, void *data));
-static int inherently_necessary_register
- PARAMS ((rtx current_rtx));
-static int find_inherently_necessary
- PARAMS ((rtx current_rtx));
-static int propagate_necessity_through_operand
- PARAMS ((rtx *current_rtx, void *data));
-static void note_inherently_necessary_set
- PARAMS ((rtx, rtx, void *));
+ (struct edge_list *el, int edge_index, dominance_info pdom,
+ control_dependent_block_to_edge_map cdbte);
+static basic_block find_pdom (dominance_info pdom, basic_block block);
+static int inherently_necessary_register_1 (rtx *current_rtx, void *data);
+static int inherently_necessary_register (rtx current_rtx);
+static int find_inherently_necessary (rtx current_rtx);
+static int propagate_necessity_through_operand (rtx *current_rtx, void *data);
+static void note_inherently_necessary_set (rtx, rtx, void *);
\f
/* Unnecessary insns are indicated using insns' in_struct bit. */
#define RESURRECT_INSN(INSN) INSN_DEAD_CODE_P(INSN) = 0
/* Return nonzero if INSN is unnecessary. */
#define UNNECESSARY_P(INSN) INSN_DEAD_CODE_P(INSN)
-static void mark_all_insn_unnecessary
- PARAMS ((void));
+static void mark_all_insn_unnecessary (void);
/* Execute CODE with free variable INSN for all unnecessary insns in
an unspecified order, producing no output. */
#define EXECUTE_IF_UNNECESSARY(INSN, CODE) \
}
/* Find the label beginning block BB. */
-static rtx find_block_label
- PARAMS ((basic_block bb));
+static rtx find_block_label (basic_block bb);
/* Remove INSN, updating its basic block structure. */
-static void delete_insn_bb
- PARAMS ((rtx insn));
+static void delete_insn_bb (rtx insn);
\f
/* Recording which blocks are control dependent on which edges. We
expect each block to be control dependent on very few edges so we
control_dependent_block_to_edge_map_free (). */
static control_dependent_block_to_edge_map
-control_dependent_block_to_edge_map_create (num_basic_blocks)
- size_t num_basic_blocks;
+control_dependent_block_to_edge_map_create (size_t num_basic_blocks)
{
int i;
control_dependent_block_to_edge_map c
control-dependent. */
static void
-set_control_dependent_block_to_edge_map_bit (c, bb, edge_index)
- control_dependent_block_to_edge_map c;
- basic_block bb;
- int edge_index;
+set_control_dependent_block_to_edge_map_bit (control_dependent_block_to_edge_map c,
+ basic_block bb, int edge_index)
{
if (bb->index - (INVALID_BLOCK+1) >= c->length)
abort ();
/* Destroy a control_dependent_block_to_edge_map C. */
static void
-control_dependent_block_to_edge_map_free (c)
- control_dependent_block_to_edge_map c;
+control_dependent_block_to_edge_map_free (control_dependent_block_to_edge_map c)
{
int i;
for (i = 0; i < c->length; ++i)
which should be empty. */
static void
-find_all_control_dependences (el, pdom, cdbte)
- struct edge_list *el;
- dominance_info pdom;
- control_dependent_block_to_edge_map cdbte;
+find_all_control_dependences (struct edge_list *el, dominance_info pdom,
+ control_dependent_block_to_edge_map cdbte)
{
int i;
with zeros in each (block b', edge) position. */
static void
-find_control_dependence (el, edge_index, pdom, cdbte)
- struct edge_list *el;
- int edge_index;
- dominance_info pdom;
- control_dependent_block_to_edge_map cdbte;
+find_control_dependence (struct edge_list *el, int edge_index,
+ dominance_info pdom,
+ control_dependent_block_to_edge_map cdbte)
{
basic_block current_block;
basic_block ending_block;
negative numbers. */
static basic_block
-find_pdom (pdom, block)
- dominance_info pdom;
- basic_block block;
+find_pdom (dominance_info pdom, basic_block block)
{
if (!block)
abort ();
particular PC values. */
static int
-inherently_necessary_register_1 (current_rtx, data)
- rtx *current_rtx;
- void *data ATTRIBUTE_UNUSED;
+inherently_necessary_register_1 (rtx *current_rtx,
+ void *data ATTRIBUTE_UNUSED)
{
rtx x = *current_rtx;
/* Return nonzero if the insn CURRENT_RTX is inherently necessary. */
static int
-inherently_necessary_register (current_rtx)
- rtx current_rtx;
+inherently_necessary_register (rtx current_rtx)
{
return for_each_rtx (¤t_rtx,
&inherently_necessary_register_1, NULL);
nonzero value in inherently_necessary_p if such a store is found. */
static void
-note_inherently_necessary_set (dest, set, data)
- rtx set ATTRIBUTE_UNUSED;
- rtx dest;
- void *data;
+note_inherently_necessary_set (rtx dest, rtx set ATTRIBUTE_UNUSED, void *data)
{
int *inherently_necessary_set_p = (int *) data;
Return nonzero iff inherently necessary. */
static int
-find_inherently_necessary (x)
- rtx x;
+find_inherently_necessary (rtx x)
{
if (x == NULL_RTX)
return 0;
instructions. */
static int
-propagate_necessity_through_operand (current_rtx, data)
- rtx *current_rtx;
- void *data;
+propagate_necessity_through_operand (rtx *current_rtx, void *data)
{
rtx x = *current_rtx;
varray_type *unprocessed_instructions = (varray_type *) data;
/* Indicate all insns initially assumed to be unnecessary. */
static void
-mark_all_insn_unnecessary ()
+mark_all_insn_unnecessary (void)
{
rtx insn;
for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn)) {
if (INSN_P (insn))
KILL_INSN (insn);
}
-
+
}
/* Find the label beginning block BB, adding one if necessary. */
static rtx
-find_block_label (bb)
- basic_block bb;
+find_block_label (basic_block bb)
{
rtx insn = bb->head;
if (LABEL_P (insn))
/* Remove INSN, updating its basic block structure. */
static void
-delete_insn_bb (insn)
- rtx insn;
+delete_insn_bb (rtx insn)
{
if (!insn)
abort ();
/* Perform the dead-code elimination. */
void
-ssa_eliminate_dead_code ()
+ssa_eliminate_dead_code (void)
{
rtx insn;
basic_block bb;
if (INSN_P (insn))
RESURRECT_INSN (insn);
}
-
+
if (VARRAY_ACTIVE_SIZE (unprocessed_instructions) != 0)
abort ();
control_dependent_block_to_edge_map_free (cdbte);
partition reg_partition;
};
-static rtx gen_sequence
- PARAMS ((void));
-static void ssa_rename_from_initialize
- PARAMS ((void));
-static rtx ssa_rename_from_lookup
- PARAMS ((int reg));
-static unsigned int original_register
- PARAMS ((unsigned int regno));
-static void ssa_rename_from_insert
- PARAMS ((unsigned int reg, rtx r));
-static void ssa_rename_from_free
- PARAMS ((void));
-typedef int (*srf_trav) PARAMS ((int regno, rtx r, sbitmap canonical_elements, partition reg_partition));
-static void ssa_rename_from_traverse
- PARAMS ((htab_trav callback_function, sbitmap canonical_elements, partition reg_partition));
-/*static Avoid warning message. */ void ssa_rename_from_print
- PARAMS ((void));
-static int ssa_rename_from_print_1
- PARAMS ((void **slot, void *data));
-static hashval_t ssa_rename_from_hash_function
- PARAMS ((const void * srfp));
-static int ssa_rename_from_equal
- PARAMS ((const void *srfp1, const void *srfp2));
-static void ssa_rename_from_delete
- PARAMS ((void *srfp));
-
-static rtx ssa_rename_to_lookup
- PARAMS ((rtx reg));
-static void ssa_rename_to_insert
- PARAMS ((rtx reg, rtx r));
+static rtx gen_sequence (void);
+static void ssa_rename_from_initialize (void);
+static rtx ssa_rename_from_lookup (int reg);
+static unsigned int original_register (unsigned int regno);
+static void ssa_rename_from_insert (unsigned int reg, rtx r);
+static void ssa_rename_from_free (void);
+typedef int (*srf_trav) (int regno, rtx r, sbitmap canonical_elements,
+ partition reg_partition);
+static void ssa_rename_from_traverse (htab_trav callback_function,
+ sbitmap canonical_elements, partition reg_partition);
+/*static Avoid warning message. */ void ssa_rename_from_print (void);
+static int ssa_rename_from_print_1 (void **slot, void *data);
+static hashval_t ssa_rename_from_hash_function (const void * srfp);
+static int ssa_rename_from_equal (const void *srfp1, const void *srfp2);
+static void ssa_rename_from_delete (void *srfp);
+
+static rtx ssa_rename_to_lookup (rtx reg);
+static void ssa_rename_to_insert (rtx reg, rtx r);
/* The number of registers that were live on entry to the SSA routines. */
static unsigned int ssa_max_reg_num;
struct rename_context;
-static inline rtx * phi_alternative
- PARAMS ((rtx, int));
-static void compute_dominance_frontiers_1
- PARAMS ((sbitmap *frontiers, dominance_info idom, int bb, sbitmap done));
-static void find_evaluations_1
- PARAMS ((rtx dest, rtx set, void *data));
-static void find_evaluations
- PARAMS ((sbitmap *evals, int nregs));
-static void compute_iterated_dominance_frontiers
- PARAMS ((sbitmap *idfs, sbitmap *frontiers, sbitmap *evals, int nregs));
-static void insert_phi_node
- PARAMS ((int regno, int b));
-static void insert_phi_nodes
- PARAMS ((sbitmap *idfs, sbitmap *evals, int nregs));
-static void create_delayed_rename
- PARAMS ((struct rename_context *, rtx *));
-static void apply_delayed_renames
- PARAMS ((struct rename_context *));
-static int rename_insn_1
- PARAMS ((rtx *ptr, void *data));
-static void rename_block
- PARAMS ((int b, dominance_info dom));
-static void rename_registers
- PARAMS ((int nregs, dominance_info idom));
-
-static inline int ephi_add_node
- PARAMS ((rtx reg, rtx *nodes, int *n_nodes));
-static int * ephi_forward
- PARAMS ((int t, sbitmap visited, sbitmap *succ, int *tstack));
-static void ephi_backward
- PARAMS ((int t, sbitmap visited, sbitmap *pred, rtx *nodes));
-static void ephi_create
- PARAMS ((int t, sbitmap visited, sbitmap *pred, sbitmap *succ, rtx *nodes));
-static void eliminate_phi
- PARAMS ((edge e, partition reg_partition));
-static int make_regs_equivalent_over_bad_edges
- PARAMS ((int bb, partition reg_partition));
+static inline rtx * phi_alternative (rtx, int);
+static void compute_dominance_frontiers_1 (sbitmap *frontiers,
+ dominance_info idom, int bb,
+ sbitmap done);
+static void find_evaluations_1 (rtx dest, rtx set, void *data);
+static void find_evaluations (sbitmap *evals, int nregs);
+static void compute_iterated_dominance_frontiers (sbitmap *idfs,
+ sbitmap *frontiers,
+ sbitmap *evals, int nregs);
+static void insert_phi_node (int regno, int b);
+static void insert_phi_nodes (sbitmap *idfs, sbitmap *evals, int nregs);
+static void create_delayed_rename (struct rename_context *, rtx *);
+static void apply_delayed_renames (struct rename_context *);
+static int rename_insn_1 (rtx *ptr, void *data);
+static void rename_block (int b, dominance_info dom);
+static void rename_registers (int nregs, dominance_info idom);
+
+static inline int ephi_add_node (rtx reg, rtx *nodes, int *n_nodes);
+static int * ephi_forward (int t, sbitmap visited, sbitmap *succ, int *tstack);
+static void ephi_backward (int t, sbitmap visited, sbitmap *pred, rtx *nodes);
+static void ephi_create (int t, sbitmap visited, sbitmap *pred,
+ sbitmap *succ, rtx *nodes);
+static void eliminate_phi (edge e, partition reg_partition);
+static int make_regs_equivalent_over_bad_edges (int bb,
+ partition reg_partition);
/* These are used only in the conservative register partitioning
algorithms. */
static int make_equivalent_phi_alternatives_equivalent
- PARAMS ((int bb, partition reg_partition));
-static partition compute_conservative_reg_partition
- PARAMS ((void));
-static int record_canonical_element_1
- PARAMS ((void **srfp, void *data));
-static int check_hard_regs_in_partition
- PARAMS ((partition reg_partition));
+ (int bb, partition reg_partition);
+static partition compute_conservative_reg_partition (void);
+static int record_canonical_element_1 (void **srfp, void *data);
+static int check_hard_regs_in_partition (partition reg_partition);
/* These are used in the register coalescing algorithm. */
-static int coalesce_if_unconflicting
- PARAMS ((partition p, conflict_graph conflicts, int reg1, int reg2));
-static int coalesce_regs_in_copies
- PARAMS ((basic_block bb, partition p, conflict_graph conflicts));
-static int coalesce_reg_in_phi
- PARAMS ((rtx, int dest_regno, int src_regno, void *data));
-static int coalesce_regs_in_successor_phi_nodes
- PARAMS ((basic_block bb, partition p, conflict_graph conflicts));
-static partition compute_coalesced_reg_partition
- PARAMS ((void));
-static int mark_reg_in_phi
- PARAMS ((rtx *ptr, void *data));
-static void mark_phi_and_copy_regs
- PARAMS ((regset phi_set));
-
-static int rename_equivalent_regs_in_insn
- PARAMS ((rtx *ptr, void *data));
-static void rename_equivalent_regs
- PARAMS ((partition reg_partition));
+static int coalesce_if_unconflicting (partition p, conflict_graph conflicts,
+ int reg1, int reg2);
+static int coalesce_regs_in_copies (basic_block bb, partition p,
+ conflict_graph conflicts);
+static int coalesce_reg_in_phi (rtx, int dest_regno, int src_regno,
+ void *data);
+static int coalesce_regs_in_successor_phi_nodes (basic_block bb,
+ partition p,
+ conflict_graph conflicts);
+static partition compute_coalesced_reg_partition (void);
+static int mark_reg_in_phi (rtx *ptr, void *data);
+static void mark_phi_and_copy_regs (regset phi_set);
+
+static int rename_equivalent_regs_in_insn (rtx *ptr, void *data);
+static void rename_equivalent_regs (partition reg_partition);
/* Deal with hard registers. */
-static int conflicting_hard_regs_p
- PARAMS ((int reg1, int reg2));
+static int conflicting_hard_regs_p (int reg1, int reg2);
/* ssa_rename_to maps registers and machine modes to SSA pseudo registers. */
/* Find the register associated with REG in the indicated mode. */
static rtx
-ssa_rename_to_lookup (reg)
- rtx reg;
+ssa_rename_to_lookup (rtx reg)
{
if (!HARD_REGISTER_P (reg))
return ssa_rename_to_pseudo[REGNO (reg) - FIRST_PSEUDO_REGISTER];
/* Store a new value mapping REG to R in ssa_rename_to. */
static void
-ssa_rename_to_insert(reg, r)
- rtx reg;
- rtx r;
+ssa_rename_to_insert (rtx reg, rtx r)
{
if (!HARD_REGISTER_P (reg))
ssa_rename_to_pseudo[REGNO (reg) - FIRST_PSEUDO_REGISTER] = r;
/* Prepare ssa_rename_from for use. */
static void
-ssa_rename_from_initialize ()
+ssa_rename_from_initialize (void)
{
/* We use an arbitrary initial hash table size of 64. */
ssa_rename_from_ht = htab_create (64,
found. */
static rtx
-ssa_rename_from_lookup (reg)
- int reg;
+ssa_rename_from_lookup (int reg)
{
ssa_rename_from_pair srfp;
ssa_rename_from_pair *answer;
Otherwise, return this register number REGNO. */
static unsigned int
-original_register (regno)
- unsigned int regno;
+original_register (unsigned int regno)
{
rtx original_rtx = ssa_rename_from_lookup (regno);
return original_rtx != NULL_RTX ? REGNO (original_rtx) : regno;
/* Add mapping from R to REG to ssa_rename_from even if already present. */
static void
-ssa_rename_from_insert (reg, r)
- unsigned int reg;
- rtx r;
+ssa_rename_from_insert (unsigned int reg, rtx r)
{
void **slot;
ssa_rename_from_pair *srfp = xmalloc (sizeof (ssa_rename_from_pair));
current use of this function. */
static void
-ssa_rename_from_traverse (callback_function,
- canonical_elements, reg_partition)
- htab_trav callback_function;
- sbitmap canonical_elements;
- partition reg_partition;
+ssa_rename_from_traverse (htab_trav callback_function,
+ sbitmap canonical_elements, partition reg_partition)
{
struct ssa_rename_from_hash_table_data srfhd;
srfhd.canonical_elements = canonical_elements;
/* Destroy ssa_rename_from. */
static void
-ssa_rename_from_free ()
+ssa_rename_from_free (void)
{
htab_delete (ssa_rename_from_ht);
}
/* static Avoid erroneous error message. */
void
-ssa_rename_from_print ()
+ssa_rename_from_print (void)
{
printf ("ssa_rename_from's hash table contents:\n");
htab_traverse (ssa_rename_from_ht, &ssa_rename_from_print_1, NULL);
attribute DATA. Used as a callback function with htab_traverse (). */
static int
-ssa_rename_from_print_1 (slot, data)
- void **slot;
- void *data ATTRIBUTE_UNUSED;
+ssa_rename_from_print_1 (void **slot, void *data ATTRIBUTE_UNUSED)
{
ssa_rename_from_pair * p = *slot;
printf ("ssa_rename_from maps pseudo %i to original %i.\n",
/* Given a hash entry SRFP, yield a hash value. */
static hashval_t
-ssa_rename_from_hash_function (srfp)
- const void *srfp;
+ssa_rename_from_hash_function (const void *srfp)
{
return ((const ssa_rename_from_pair *) srfp)->reg;
}
/* Test whether two hash table entries SRFP1 and SRFP2 are equal. */
static int
-ssa_rename_from_equal (srfp1, srfp2)
- const void *srfp1;
- const void *srfp2;
+ssa_rename_from_equal (const void *srfp1, const void *srfp2)
{
return ssa_rename_from_hash_function (srfp1) ==
ssa_rename_from_hash_function (srfp2);
/* Delete the hash table entry SRFP. */
static void
-ssa_rename_from_delete (srfp)
- void *srfp;
+ssa_rename_from_delete (void *srfp)
{
free (srfp);
}
for predecessor block C. */
static inline rtx *
-phi_alternative (set, c)
- rtx set;
- int c;
+phi_alternative (rtx set, int c)
{
rtvec phi_vec = XVEC (SET_SRC (set), 0);
int v;
found for C. */
int
-remove_phi_alternative (set, block)
- rtx set;
- basic_block block;
+remove_phi_alternative (rtx set, basic_block block)
{
rtvec phi_vec = XVEC (SET_SRC (set), 0);
int num_elem = GET_NUM_ELEM (phi_vec);
static int fe_current_bb;
static void
-find_evaluations_1 (dest, set, data)
- rtx dest;
- rtx set ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+find_evaluations_1 (rtx dest, rtx set ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
if (GET_CODE (dest) == REG
&& CONVERT_REGISTER_TO_SSA_P (REGNO (dest)))
}
static void
-find_evaluations (evals, nregs)
- sbitmap *evals;
- int nregs;
+find_evaluations (sbitmap *evals, int nregs)
{
basic_block bb;
*/
static void
-compute_dominance_frontiers_1 (frontiers, idom, bb, done)
- sbitmap *frontiers;
- dominance_info idom;
- int bb;
- sbitmap done;
+compute_dominance_frontiers_1 (sbitmap *frontiers, dominance_info idom,
+ int bb, sbitmap done)
{
basic_block b = BASIC_BLOCK (bb);
edge e;
}
void
-compute_dominance_frontiers (frontiers, idom)
- sbitmap *frontiers;
- dominance_info idom;
+compute_dominance_frontiers (sbitmap *frontiers, dominance_info idom)
{
sbitmap done = sbitmap_alloc (last_basic_block);
sbitmap_zero (done);
*/
static void
-compute_iterated_dominance_frontiers (idfs, frontiers, evals, nregs)
- sbitmap *idfs;
- sbitmap *frontiers;
- sbitmap *evals;
- int nregs;
+compute_iterated_dominance_frontiers (sbitmap *idfs, sbitmap *frontiers,
+ sbitmap *evals, int nregs)
{
sbitmap worklist;
int reg, passes = 0;
/* Insert the phi nodes. */
static void
-insert_phi_node (regno, bb)
- int regno, bb;
+insert_phi_node (int regno, int bb)
{
basic_block b = BASIC_BLOCK (bb);
edge e;
}
static void
-insert_phi_nodes (idfs, evals, nregs)
- sbitmap *idfs;
- sbitmap *evals ATTRIBUTE_UNUSED;
- int nregs;
+insert_phi_nodes (sbitmap *idfs, sbitmap *evals ATTRIBUTE_UNUSED, int nregs)
{
int reg;
/* Queue the rename of *REG_LOC. */
static void
-create_delayed_rename (c, reg_loc)
- struct rename_context *c;
- rtx *reg_loc;
+create_delayed_rename (struct rename_context *c, rtx *reg_loc)
{
struct rename_set_data *r;
r = (struct rename_set_data *) xmalloc (sizeof(*r));
applying all the renames on NEW_RENAMES. */
static void
-apply_delayed_renames (c)
- struct rename_context *c;
+apply_delayed_renames (struct rename_context *c)
{
struct rename_set_data *r;
struct rename_set_data *last_r = NULL;
Mark pseudos that are set for later update. Transform uses of pseudos. */
static int
-rename_insn_1 (ptr, data)
- rtx *ptr;
- void *data;
+rename_insn_1 (rtx *ptr, void *data)
{
rtx x = *ptr;
struct rename_context *context = data;
}
static rtx
-gen_sequence ()
+gen_sequence (void)
{
rtx first_insn = get_insns ();
rtx result;
}
static void
-rename_block (bb, idom)
- int bb;
- dominance_info idom;
+rename_block (int bb, dominance_info idom)
{
basic_block b = BASIC_BLOCK (bb);
edge e;
}
static void
-rename_registers (nregs, idom)
- int nregs;
- dominance_info idom;
+rename_registers (int nregs, dominance_info idom)
{
VARRAY_RTX_INIT (ssa_definition, nregs * 3, "ssa_definition");
ssa_rename_from_initialize ();
/* The main entry point for moving to SSA. */
void
-convert_to_ssa ()
+convert_to_ssa (void)
{
/* Element I is the set of blocks that set register I. */
sbitmap *evals;
index of this register in the node set. */
static inline int
-ephi_add_node (reg, nodes, n_nodes)
- rtx reg, *nodes;
- int *n_nodes;
+ephi_add_node (rtx reg, rtx *nodes, int *n_nodes)
{
int i;
for (i = *n_nodes - 1; i >= 0; --i)
no other dependencies. */
static int *
-ephi_forward (t, visited, succ, tstack)
- int t;
- sbitmap visited;
- sbitmap *succ;
- int *tstack;
+ephi_forward (int t, sbitmap visited, sbitmap *succ, int *tstack)
{
int s;
a cycle in the graph, copying the data forward as we go. */
static void
-ephi_backward (t, visited, pred, nodes)
- int t;
- sbitmap visited, *pred;
- rtx *nodes;
+ephi_backward (int t, sbitmap visited, sbitmap *pred, rtx *nodes)
{
int p;
and any cycle of which it is a member. */
static void
-ephi_create (t, visited, pred, succ, nodes)
- int t;
- sbitmap visited, *pred, *succ;
- rtx *nodes;
+ephi_create (int t, sbitmap visited, sbitmap *pred, sbitmap *succ, rtx *nodes)
{
rtx reg_u = NULL_RTX;
int unvisited_predecessors = 0;
/* Convert the edge to normal form. */
static void
-eliminate_phi (e, reg_partition)
- edge e;
- partition reg_partition;
+eliminate_phi (edge e, partition reg_partition)
{
int n_nodes;
sbitmap *pred, *succ;
regs were not already in the same class. */
static int
-make_regs_equivalent_over_bad_edges (bb, reg_partition)
- int bb;
- partition reg_partition;
+make_regs_equivalent_over_bad_edges (int bb, partition reg_partition)
{
int changed = 0;
basic_block b = BASIC_BLOCK (bb);
Return nonzero if any new register classes were unioned. */
static int
-make_equivalent_phi_alternatives_equivalent (bb, reg_partition)
- int bb;
- partition reg_partition;
+make_equivalent_phi_alternatives_equivalent (int bb, partition reg_partition)
{
int changed = 0;
basic_block b = BASIC_BLOCK (bb);
See Morgan 7.3.1. */
static partition
-compute_conservative_reg_partition ()
+compute_conservative_reg_partition (void)
{
basic_block bb;
int changed = 0;
See Morgan figure 11.15. */
static int
-coalesce_if_unconflicting (p, conflicts, reg1, reg2)
- partition p;
- conflict_graph conflicts;
- int reg1;
- int reg2;
+coalesce_if_unconflicting (partition p, conflict_graph conflicts,
+ int reg1, int reg2)
{
int reg;
See Morgan figure 11.14. */
static int
-coalesce_regs_in_copies (bb, p, conflicts)
- basic_block bb;
- partition p;
- conflict_graph conflicts;
+coalesce_regs_in_copies (basic_block bb, partition p, conflict_graph conflicts)
{
int changed = 0;
rtx insn;
phi_coalesce_context struct. */
static int
-coalesce_reg_in_phi (insn, dest_regno, src_regno, data)
- rtx insn ATTRIBUTE_UNUSED;
- int dest_regno;
- int src_regno;
- void *data;
+coalesce_reg_in_phi (rtx insn ATTRIBUTE_UNUSED, int dest_regno,
+ int src_regno, void *data)
{
struct phi_coalesce_context *context =
(struct phi_coalesce_context *) data;
See Morgan figure 11.14. */
static int
-coalesce_regs_in_successor_phi_nodes (bb, p, conflicts)
- basic_block bb;
- partition p;
- conflict_graph conflicts;
+coalesce_regs_in_successor_phi_nodes (basic_block bb, partition p,
+ conflict_graph conflicts)
{
struct phi_coalesce_context context;
context.p = p;
The caller is responsible for deallocating the returned partition. */
static partition
-compute_coalesced_reg_partition ()
+compute_coalesced_reg_partition (void)
{
basic_block bb;
int changed = 0;
set all regs. Called from for_each_rtx. */
static int
-mark_reg_in_phi (ptr, data)
- rtx *ptr;
- void *data;
+mark_reg_in_phi (rtx *ptr, void *data)
{
rtx expr = *ptr;
regset set = (regset) data;
ssa_definition. */
static void
-mark_phi_and_copy_regs (phi_set)
- regset phi_set;
+mark_phi_and_copy_regs (regset phi_set)
{
unsigned int reg;
partition which specifies equivalences. */
static int
-rename_equivalent_regs_in_insn (ptr, data)
- rtx *ptr;
- void* data;
+rename_equivalent_regs_in_insn (rtx *ptr, void* data)
{
rtx x = *ptr;
partition reg_partition = (partition) data;
as a callback function for traversing ssa_rename_from. */
static int
-record_canonical_element_1 (srfp, data)
- void **srfp;
- void *data;
+record_canonical_element_1 (void **srfp, void *data)
{
unsigned int reg = ((ssa_rename_from_pair *) *srfp)->reg;
sbitmap canonical_elements =
nonzero if this is the case, i.e., the partition is acceptable. */
static int
-check_hard_regs_in_partition (reg_partition)
- partition reg_partition;
+check_hard_regs_in_partition (partition reg_partition)
{
/* CANONICAL_ELEMENTS has a nonzero bit if a class with the given register
number and machine mode has already been seen. This is a
any SEQUENCE insns. */
static void
-rename_equivalent_regs (reg_partition)
- partition reg_partition;
+rename_equivalent_regs (partition reg_partition)
{
basic_block b;
/* The main entry point for moving from SSA. */
void
-convert_from_ssa ()
+convert_from_ssa (void)
{
basic_block b, bb;
partition reg_partition;
value. Otherwise, returns zero. */
int
-for_each_successor_phi (bb, fn, data)
- basic_block bb;
- successor_phi_fn fn;
- void *data;
+for_each_successor_phi (basic_block bb, successor_phi_fn fn, void *data)
{
edge e;
different hard registers. */
static int
-conflicting_hard_regs_p (reg1, reg2)
- int reg1;
- int reg2;
+conflicting_hard_regs_p (int reg1, int reg2)
{
int orig_reg1 = original_register (reg1);
int orig_reg2 = original_register (reg2);
/* Static Single Assignment (SSA) definitions for GCC
- Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2003 Free Software Foundation, Inc.
Written by Jeffrey D. Oldham <oldham@codesourcery.com>.
This file is part of GCC.
/* Main SSA routines. */
-extern void convert_to_ssa PARAMS ((void));
-extern void convert_from_ssa PARAMS ((void));
-typedef int (*successor_phi_fn) PARAMS ((rtx, int, int, void *));
-extern int for_each_successor_phi PARAMS ((basic_block bb,
- successor_phi_fn,
- void *));
-void compute_dominance_frontiers PARAMS ((sbitmap *frontiers,
- dominance_info idom));
-extern int remove_phi_alternative PARAMS ((rtx, basic_block));
+extern void convert_to_ssa (void);
+extern void convert_from_ssa (void);
+typedef int (*successor_phi_fn) (rtx, int, int, void *);
+extern int for_each_successor_phi (basic_block bb, successor_phi_fn,
+ void *);
+void compute_dominance_frontiers (sbitmap *frontiers, dominance_info idom);
+extern int remove_phi_alternative (rtx, basic_block);
/* Optimizations. */
/* In ssa-dce.c */
-extern void ssa_eliminate_dead_code PARAMS ((void));
+extern void ssa_eliminate_dead_code (void);
/* In ssa-ccp.c */
-extern void ssa_const_prop PARAMS ((void));
+extern void ssa_const_prop (void);
/* SSA definitions and uses. */
/* stack.h - structed access to object stacks
- Copyright (C) 1988, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1988, 2000, 2003 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com).
This program is free software; you can redistribute it and/or modify it
on top of obstacks for GNU C++. */
/* Stack of data placed on obstacks. */
-
+
struct stack_level
{
/* Pointer back to previous such level. */
int limit;
};
-struct stack_level *push_stack_level PARAMS ((struct obstack *, char *, int));
-struct stack_level *pop_stack_level PARAMS ((struct stack_level *));
+struct stack_level *push_stack_level (struct obstack *, char *, int);
+struct stack_level *pop_stack_level (struct stack_level *);
/* Nonzero if we are using EH to handle cleanups. */
static int using_eh_for_cleanups_p = 0;
-static int n_occurrences PARAMS ((int, const char *));
-static bool parse_input_constraint PARAMS ((const char **, int, int, int,
- int, const char * const *,
- bool *, bool *));
-static bool decl_conflicts_with_clobbers_p PARAMS ((tree, const HARD_REG_SET));
-static void expand_goto_internal PARAMS ((tree, rtx, rtx));
-static int expand_fixup PARAMS ((tree, rtx, rtx));
-static rtx expand_nl_handler_label PARAMS ((rtx, rtx));
-static void expand_nl_goto_receiver PARAMS ((void));
-static void expand_nl_goto_receivers PARAMS ((struct nesting *));
-static void fixup_gotos PARAMS ((struct nesting *, rtx, tree,
- rtx, int));
-static bool check_operand_nalternatives PARAMS ((tree, tree));
-static bool check_unique_operand_names PARAMS ((tree, tree));
-static char *resolve_operand_name_1 PARAMS ((char *, tree, tree));
-static void expand_null_return_1 PARAMS ((rtx));
-static enum br_predictor return_prediction PARAMS ((rtx));
-static void expand_value_return PARAMS ((rtx));
-static int tail_recursion_args PARAMS ((tree, tree));
-static void expand_cleanups PARAMS ((tree, int, int));
-static void check_seenlabel PARAMS ((void));
-static void do_jump_if_equal PARAMS ((rtx, rtx, rtx, int));
-static int estimate_case_costs PARAMS ((case_node_ptr));
-static bool same_case_target_p PARAMS ((rtx, rtx));
-static void strip_default_case_nodes PARAMS ((case_node_ptr *, rtx));
-static bool lshift_cheap_p PARAMS ((void));
-static int case_bit_test_cmp PARAMS ((const void *, const void *));
-static void emit_case_bit_tests PARAMS ((tree, tree, tree, tree,
- case_node_ptr, rtx));
-static void group_case_nodes PARAMS ((case_node_ptr));
-static void balance_case_nodes PARAMS ((case_node_ptr *,
- case_node_ptr));
-static int node_has_low_bound PARAMS ((case_node_ptr, tree));
-static int node_has_high_bound PARAMS ((case_node_ptr, tree));
-static int node_is_bounded PARAMS ((case_node_ptr, tree));
-static void emit_jump_if_reachable PARAMS ((rtx));
-static void emit_case_nodes PARAMS ((rtx, case_node_ptr, rtx, tree));
-static struct case_node *case_tree2list PARAMS ((case_node *, case_node *));
+static int n_occurrences (int, const char *);
+static bool parse_input_constraint (const char **, int, int, int, int,
+ const char * const *, bool *, bool *);
+static bool decl_conflicts_with_clobbers_p (tree, const HARD_REG_SET);
+static void expand_goto_internal (tree, rtx, rtx);
+static int expand_fixup (tree, rtx, rtx);
+static rtx expand_nl_handler_label (rtx, rtx);
+static void expand_nl_goto_receiver (void);
+static void expand_nl_goto_receivers (struct nesting *);
+static void fixup_gotos (struct nesting *, rtx, tree, rtx, int);
+static bool check_operand_nalternatives (tree, tree);
+static bool check_unique_operand_names (tree, tree);
+static char *resolve_operand_name_1 (char *, tree, tree);
+static void expand_null_return_1 (rtx);
+static enum br_predictor return_prediction (rtx);
+static void expand_value_return (rtx);
+static int tail_recursion_args (tree, tree);
+static void expand_cleanups (tree, int, int);
+static void check_seenlabel (void);
+static void do_jump_if_equal (rtx, rtx, rtx, int);
+static int estimate_case_costs (case_node_ptr);
+static bool same_case_target_p (rtx, rtx);
+static void strip_default_case_nodes (case_node_ptr *, rtx);
+static bool lshift_cheap_p (void);
+static int case_bit_test_cmp (const void *, const void *);
+static void emit_case_bit_tests (tree, tree, tree, tree, case_node_ptr, rtx);
+static void group_case_nodes (case_node_ptr);
+static void balance_case_nodes (case_node_ptr *, case_node_ptr);
+static int node_has_low_bound (case_node_ptr, tree);
+static int node_has_high_bound (case_node_ptr, tree);
+static int node_is_bounded (case_node_ptr, tree);
+static void emit_jump_if_reachable (rtx);
+static void emit_case_nodes (rtx, case_node_ptr, rtx, tree);
+static struct case_node *case_tree2list (case_node *, case_node *);
\f
void
-using_eh_for_cleanups ()
+using_eh_for_cleanups (void)
{
using_eh_for_cleanups_p = 1;
}
void
-init_stmt_for_function ()
+init_stmt_for_function (void)
{
cfun->stmt = ((struct stmt_status *)ggc_alloc (sizeof (struct stmt_status)));
\f
/* Record the current file and line. Called from emit_line_note. */
void
-set_file_and_line_for_stmt (file, line)
- const char *file;
- int line;
+set_file_and_line_for_stmt (const char *file, int line)
{
/* If we're outputting an inline function, and we add a line note,
there may be no CFUN->STMT information. So, there's no need to
/* Emit a no-op instruction. */
void
-emit_nop ()
+emit_nop (void)
{
rtx last_insn;
creating it if necessary. */
rtx
-label_rtx (label)
- tree label;
+label_rtx (tree label)
{
if (TREE_CODE (label) != LABEL_DECL)
abort ();
/* As above, but also put it on the forced-reference list of the
function that contains it. */
rtx
-force_label_rtx (label)
- tree label;
+force_label_rtx (tree label)
{
rtx ref = label_rtx (label);
tree function = decl_function_context (label);
/* Add an unconditional jump to LABEL as the next sequential instruction. */
void
-emit_jump (label)
- rtx label;
+emit_jump (rtx label)
{
do_pending_stack_adjust ();
emit_jump_insn (gen_jump (label));
specified by the pointer expression EXP. */
void
-expand_computed_goto (exp)
- tree exp;
+expand_computed_goto (tree exp)
{
rtx x = expand_expr (exp, NULL_RTX, VOIDmode, 0);
cfun->computed_goto_common_reg = copy_to_mode_reg (Pmode, x);
cfun->computed_goto_common_label = gen_label_rtx ();
emit_label (cfun->computed_goto_common_label);
-
+
do_pending_stack_adjust ();
emit_indirect_jump (cfun->computed_goto_common_reg);
Languages vary in how they do that and what that even means. */
void
-expand_label (label)
- tree label;
+expand_label (tree label)
{
struct label_chain *p;
from nested functions. */
void
-declare_nonlocal_label (label)
- tree label;
+declare_nonlocal_label (tree label)
{
rtx slot = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
defined with `expand_label'. */
void
-expand_goto (label)
- tree label;
+expand_goto (tree label)
{
tree context;
insn emitted (for the purposes of cleaning up a return). */
static void
-expand_goto_internal (body, label, last_insn)
- tree body;
- rtx label;
- rtx last_insn;
+expand_goto_internal (tree body, rtx label, rtx last_insn)
{
struct nesting *block;
rtx stack_level = 0;
Value is nonzero if a fixup is made. */
static int
-expand_fixup (tree_label, rtl_label, last_insn)
- tree tree_label;
- rtx rtl_label;
- rtx last_insn;
+expand_fixup (tree tree_label, rtx rtl_label, rtx last_insn)
{
struct nesting *block, *end_block;
function. FIRST_INSN is the first insn in the function. */
void
-expand_fixups (first_insn)
- rtx first_insn;
+expand_fixups (rtx first_insn)
{
fixup_gotos (NULL, NULL_RTX, NULL_TREE, first_insn, 0);
}
STACK_LEVEL is nonzero unless DONT_JUMP_IN is negative. */
static void
-fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
- struct nesting *thisblock;
- rtx stack_level;
- tree cleanup_list;
- rtx first_insn;
- int dont_jump_in;
+fixup_gotos (struct nesting *thisblock, rtx stack_level,
+ tree cleanup_list, rtx first_insn, int dont_jump_in)
{
struct goto_fixup *f, *prev;
\f
/* Return the number of times character C occurs in string S. */
static int
-n_occurrences (c, s)
- int c;
- const char *s;
+n_occurrences (int c, const char *s)
{
int n = 0;
while (*s)
insn is volatile; don't optimize it. */
void
-expand_asm (string, vol)
- tree string;
- int vol;
+expand_asm (tree string, int vol)
{
rtx body;
MEM_VOLATILE_P (body) = vol;
emit_insn (body);
-
+
clear_last_expr ();
}
Returns TRUE if all went well; FALSE if an error occurred. */
bool
-parse_output_constraint (constraint_p, operand_num, ninputs, noutputs,
- allows_mem, allows_reg, is_inout)
- const char **constraint_p;
- int operand_num;
- int ninputs;
- int noutputs;
- bool *allows_mem;
- bool *allows_reg;
- bool *is_inout;
+parse_output_constraint (const char **constraint_p, int operand_num,
+ int ninputs, int noutputs, bool *allows_mem,
+ bool *allows_reg, bool *is_inout)
{
const char *constraint = *constraint_p;
const char *p;
/* Similar, but for input constraints. */
static bool
-parse_input_constraint (constraint_p, input_num, ninputs, noutputs, ninout,
- constraints, allows_mem, allows_reg)
- const char **constraint_p;
- int input_num;
- int ninputs;
- int noutputs;
- int ninout;
- const char * const * constraints;
- bool *allows_mem;
- bool *allows_reg;
+parse_input_constraint (const char **constraint_p, int input_num,
+ int ninputs, int noutputs, int ninout,
+ const char * const * constraints,
+ bool *allows_mem, bool *allows_reg)
{
const char *constraint = *constraint_p;
const char *orig_constraint = constraint;
FALSE for ok. */
static bool
-decl_conflicts_with_clobbers_p (decl, clobbered_regs)
- tree decl;
- const HARD_REG_SET clobbered_regs;
+decl_conflicts_with_clobbers_p (tree decl, const HARD_REG_SET clobbered_regs)
{
/* Conflicts between asm-declared register variables and the clobber
list are not allowed. */
VOL nonzero means the insn is volatile; don't optimize it. */
void
-expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
- tree string, outputs, inputs, clobbers;
- int vol;
- const char *filename;
- int line;
+expand_asm_operands (tree string, tree outputs, tree inputs,
+ tree clobbers, int vol, const char *filename, int line)
{
rtvec argvec, constraintvec;
rtx body;
the same number of alternatives. Return true if so. */
static bool
-check_operand_nalternatives (outputs, inputs)
- tree outputs, inputs;
+check_operand_nalternatives (tree outputs, tree inputs)
{
if (outputs || inputs)
{
so all we need are pointer comparisons. */
static bool
-check_unique_operand_names (outputs, inputs)
- tree outputs, inputs;
+check_unique_operand_names (tree outputs, tree inputs)
{
tree i, j;
balance of the string after substitution. */
static char *
-resolve_operand_name_1 (p, outputs, inputs)
- char *p;
- tree outputs, inputs;
+resolve_operand_name_1 (char *p, tree outputs, tree inputs)
{
char *q;
int op;
should be used for new code. */
void
-expand_expr_stmt (exp)
- tree exp;
+expand_expr_stmt (tree exp)
{
expand_expr_stmt_value (exp, -1, 1);
}
deprecated, and retained only for backward compatibility. */
void
-expand_expr_stmt_value (exp, want_value, maybe_last)
- tree exp;
- int want_value, maybe_last;
+expand_expr_stmt_value (tree exp, int want_value, int maybe_last)
{
rtx value;
tree type;
Return 1 if a warning is printed; 0 otherwise. */
int
-warn_if_unused_value (exp)
- tree exp;
+warn_if_unused_value (tree exp)
{
if (TREE_USED (exp))
return 0;
/* Clear out the memory of the last expression evaluated. */
void
-clear_last_expr ()
+clear_last_expr (void)
{
last_expr_type = NULL_TREE;
last_expr_value = NULL_RTX;
expression. */
tree
-expand_start_stmt_expr (has_scope)
- int has_scope;
+expand_start_stmt_expr (int has_scope)
{
tree t;
return something with type `void'. */
tree
-expand_end_stmt_expr (t)
- tree t;
+expand_end_stmt_expr (tree t)
{
OK_DEFER_POP;
`exit_something'. */
void
-expand_start_cond (cond, exitflag)
- tree cond;
- int exitflag;
+expand_start_cond (tree cond, int exitflag)
{
struct nesting *thiscond = ALLOC_NESTING ();
of an if-then-elseif-.... */
void
-expand_start_elseif (cond)
- tree cond;
+expand_start_elseif (tree cond)
{
if (cond_stack->data.cond.endif_label == 0)
cond_stack->data.cond.endif_label = gen_label_rtx ();
of an if-then-else. */
void
-expand_start_else ()
+expand_start_else (void)
{
if (cond_stack->data.cond.endif_label == 0)
cond_stack->data.cond.endif_label = gen_label_rtx ();
by providing another condition. */
void
-expand_elseif (cond)
- tree cond;
+expand_elseif (tree cond)
{
cond_stack->data.cond.next_label = gen_label_rtx ();
do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX);
Pop the record for it off of cond_stack. */
void
-expand_end_cond ()
+expand_end_cond (void)
{
struct nesting *thiscond = cond_stack;
this loop. */
struct nesting *
-expand_start_loop (exit_flag)
- int exit_flag;
+expand_start_loop (int exit_flag)
{
struct nesting *thisloop = ALLOC_NESTING ();
(for expand_continue_loop) will be specified explicitly. */
struct nesting *
-expand_start_loop_continue_elsewhere (exit_flag)
- int exit_flag;
+expand_start_loop_continue_elsewhere (int exit_flag)
{
struct nesting *thisloop = expand_start_loop (exit_flag);
loop_stack->data.loop.continue_label = gen_label_rtx ();
of said loop can still contain a break, we must frob the loop nest. */
struct nesting *
-expand_start_null_loop ()
+expand_start_null_loop (void)
{
struct nesting *thisloop = ALLOC_NESTING ();
should jump. */
void
-expand_loop_continue_here ()
+expand_loop_continue_here (void)
{
do_pending_stack_adjust ();
emit_note (NOTE_INSN_LOOP_CONT);
Pop the block off of loop_stack. */
void
-expand_end_loop ()
+expand_end_loop (void)
{
rtx start_label = loop_stack->data.loop.start_label;
rtx etc_note;
/* Finish a null loop, aka do { } while (0). */
void
-expand_end_null_loop ()
+expand_end_null_loop (void)
{
do_pending_stack_adjust ();
emit_label (loop_stack->data.loop.end_label);
return 0 and do nothing; caller will print an error message. */
int
-expand_continue_loop (whichloop)
- struct nesting *whichloop;
+expand_continue_loop (struct nesting *whichloop)
{
/* Emit information for branch prediction. */
rtx note;
return 0 and do nothing; caller will print an error message. */
int
-expand_exit_loop (whichloop)
- struct nesting *whichloop;
+expand_exit_loop (struct nesting *whichloop)
{
clear_last_expr ();
if (whichloop == 0)
return 0 and do nothing; caller will print an error message. */
int
-expand_exit_loop_if_false (whichloop, cond)
- struct nesting *whichloop;
- tree cond;
+expand_exit_loop_if_false (struct nesting *whichloop, tree cond)
{
rtx label;
clear_last_expr ();
after expand_loop_start. */
int
-expand_exit_loop_top_cond (whichloop, cond)
- struct nesting *whichloop;
- tree cond;
+expand_exit_loop_top_cond (struct nesting *whichloop, tree cond)
{
if (! expand_exit_loop_if_false (whichloop, cond))
return 0;
the loop may still be a small one. */
int
-preserve_subexpressions_p ()
+preserve_subexpressions_p (void)
{
rtx insn;
return 0 and do nothing; caller will print an error message. */
int
-expand_exit_something ()
+expand_exit_something (void)
{
struct nesting *n;
clear_last_expr ();
(That is, we do not do anything about returning any value.) */
void
-expand_null_return ()
+expand_null_return (void)
{
rtx last_insn;
/* Try to guess whether the value of return means error code. */
static enum br_predictor
-return_prediction (val)
- rtx val;
+return_prediction (rtx val)
{
/* Different heuristics for pointers and scalars. */
if (POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl))))
/* Generate RTL to return from the current function, with value VAL. */
static void
-expand_value_return (val)
- rtx val;
+expand_value_return (rtx val)
{
rtx last_insn;
rtx return_reg;
pretend that the return takes place after LAST_INSN. */
static void
-expand_null_return_1 (last_insn)
- rtx last_insn;
+expand_null_return_1 (rtx last_insn)
{
rtx end_label = cleanup_label ? cleanup_label : return_label;
from the current function. */
void
-expand_return (retval)
- tree retval;
+expand_return (tree retval)
{
/* If there are any cleanups to be performed, then they will
be inserted following LAST_INSN. It is desirable
Return TRUE if the call was optimized into a goto. */
int
-optimize_tail_recursion (arguments, last_insn)
- tree arguments;
- rtx last_insn;
+optimize_tail_recursion (tree arguments, rtx last_insn)
{
/* Finish checking validity, and if valid emit code to set the
argument variables for the new call. */
otherwise return 0 and do not emit any code. */
static int
-tail_recursion_args (actuals, formals)
- tree actuals, formals;
+tail_recursion_args (tree actuals, tree formals)
{
tree a = actuals, f = formals;
int i;
note. */
void
-expand_start_bindings_and_block (flags, block)
- int flags;
- tree block;
+expand_start_bindings_and_block (int flags, tree block)
{
struct nesting *thisblock = ALLOC_NESTING ();
rtx note;
destroyed and their space freed for reuse. */
void
-expand_start_target_temps ()
+expand_start_target_temps (void)
{
/* This is so that even if the result is preserved, the space
allocated will be freed, as we know that it is no longer in use. */
}
void
-expand_end_target_temps ()
+expand_end_target_temps (void)
{
expand_end_bindings (NULL_TREE, 0, 0);
*that* node in turn will point to the relevant FUNCTION_DECL node. */
int
-is_body_block (stmt)
- tree stmt;
+is_body_block (tree stmt)
{
if (lang_hooks.no_body_blocks)
return 0;
the cleanup handling code to generate conditional cleanup actions. */
int
-conditional_context ()
+conditional_context (void)
{
return block_stack && block_stack->data.block.conditional_code;
}
can check its own sanity. */
struct nesting *
-current_nesting_level ()
+current_nesting_level (void)
{
return cfun ? block_stack : 0;
}
Also emit code to store the handler label in SLOT before BEFORE_INSN. */
static rtx
-expand_nl_handler_label (slot, before_insn)
- rtx slot, before_insn;
+expand_nl_handler_label (rtx slot, rtx before_insn)
{
rtx insns;
rtx handler_label = gen_label_rtx ();
/* Emit code to restore vital registers at the beginning of a nonlocal goto
handler. */
static void
-expand_nl_goto_receiver ()
+expand_nl_goto_receiver (void)
{
#ifdef HAVE_nonlocal_goto
if (! HAVE_nonlocal_goto)
block THISBLOCK. */
static void
-expand_nl_goto_receivers (thisblock)
- struct nesting *thisblock;
+expand_nl_goto_receivers (struct nesting *thisblock)
{
tree link;
rtx afterward = gen_label_rtx ();
via the TREE_CHAIN field. */
void
-warn_about_unused_variables (vars)
- tree vars;
+warn_about_unused_variables (tree vars)
{
tree decl;
labels (because the front end does that). */
void
-expand_end_bindings (vars, mark_ends, dont_jump_in)
- tree vars;
- int mark_ends;
- int dont_jump_in;
+expand_end_bindings (tree vars, int mark_ends, int dont_jump_in)
{
struct nesting *thisblock = block_stack;
and set up to restore it on exit. */
void
-save_stack_pointer ()
+save_stack_pointer (void)
{
struct nesting *thisblock = block_stack;
(Other kinds of declarations are simply ignored if seen here.) */
void
-expand_decl (decl)
- tree decl;
+expand_decl (tree decl)
{
tree type;
/* Emit code to perform the initialization of a declaration DECL. */
void
-expand_decl_init (decl)
- tree decl;
+expand_decl_init (tree decl)
{
int was_used = TREE_USED (decl);
that is not associated with any particular variable. */
int
-expand_decl_cleanup (decl, cleanup)
- tree decl, cleanup;
+expand_decl_cleanup (tree decl, tree cleanup)
{
struct nesting *thisblock;
is thrown. */
int
-expand_decl_cleanup_eh (decl, cleanup, eh_only)
- tree decl, cleanup;
- int eh_only;
+expand_decl_cleanup_eh (tree decl, tree cleanup, int eh_only)
{
int ret = expand_decl_cleanup (decl, cleanup);
if (cleanup && ret)
In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup. */
void
-expand_anon_union_decl (decl, cleanup, decl_elts)
- tree decl, cleanup, decl_elts;
+expand_anon_union_decl (tree decl, tree cleanup, tree decl_elts)
{
struct nesting *thisblock = cfun == 0 ? 0 : block_stack;
rtx x;
code about this finalization. */
static void
-expand_cleanups (list, in_fixup, reachable)
- tree list;
- int in_fixup;
- int reachable;
+expand_cleanups (tree list, int in_fixup, int reachable)
{
tree tail;
for (tail = list; tail; tail = TREE_CHAIN (tail))
expression (tree) is expanded that is within a conditional context. */
void
-start_cleanup_deferral ()
+start_cleanup_deferral (void)
{
/* block_stack can be NULL if we are inside the parameter list. It is
OK to do nothing, because cleanups aren't possible here. */
deferred cleanups, are we back in unconditional code. */
void
-end_cleanup_deferral ()
+end_cleanup_deferral (void)
{
/* block_stack can be NULL if we are inside the parameter list. It is
OK to do nothing, because cleanups aren't possible here. */
}
tree
-last_cleanup_this_contour ()
+last_cleanup_this_contour (void)
{
if (block_stack == 0)
return 0;
the current contour. */
int
-any_pending_cleanups ()
+any_pending_cleanups (void)
{
struct nesting *block;
but instead we take short cuts. */
void
-expand_start_case (exit_flag, expr, type, printname)
- int exit_flag;
- tree expr;
- tree type;
- const char *printname;
+expand_start_case (int exit_flag, tree expr, tree type,
+ const char *printname)
{
struct nesting *thiscase = ALLOC_NESTING ();
into the middle of certain kinds of constructs. */
void
-expand_start_case_dummy ()
+expand_start_case_dummy (void)
{
struct nesting *thiscase = ALLOC_NESTING ();
}
\f
static void
-check_seenlabel ()
+check_seenlabel (void)
{
/* If this is the first label, warn if any insns have been emitted. */
if (case_stack->data.case_stmt.line_number_status >= 0)
Extended to handle range statements. */
int
-pushcase (value, converter, label, duplicate)
- tree value;
- tree (*converter) PARAMS ((tree, tree));
- tree label;
- tree *duplicate;
+pushcase (tree value, tree (*converter) (tree, tree), tree label,
+ tree *duplicate)
{
tree index_type;
tree nominal_type;
additional error code: 4 means the specified range was empty. */
int
-pushcase_range (value1, value2, converter, label, duplicate)
- tree value1, value2;
- tree (*converter) PARAMS ((tree, tree));
- tree label;
- tree *duplicate;
+pushcase_range (tree value1, tree value2, tree (*converter) (tree, tree),
+ tree label, tree *duplicate)
{
tree index_type;
tree nominal_type;
slowdown for large switch statements. */
int
-add_case_node (low, high, label, duplicate)
- tree low, high;
- tree label;
- tree *duplicate;
+add_case_node (tree low, tree high, tree label, tree *duplicate)
{
struct case_node *p, **q, *r;
otherwise sets it to 0. */
HOST_WIDE_INT
-all_cases_count (type, sparseness)
- tree type;
- int *sparseness;
+all_cases_count (tree type, int *sparseness)
{
tree t;
HOST_WIDE_INT count, minval, lastval;
SPARSENESS is 2, in which case quadratic time is needed. */
void
-mark_seen_cases (type, cases_seen, count, sparseness)
- tree type;
- unsigned char *cases_seen;
- HOST_WIDE_INT count;
- int sparseness;
+mark_seen_cases (tree type, unsigned char *cases_seen, HOST_WIDE_INT count,
+ int sparseness)
{
tree next_node_to_try = NULL_TREE;
HOST_WIDE_INT next_node_offset = 0;
is the same as one of the enumeration literals.'' */
void
-check_for_full_enumeration_handling (type)
- tree type;
+check_for_full_enumeration_handling (tree type)
{
struct case_node *n;
tree chain;
node targets. */
static void
-emit_case_bit_tests (index_type, index_expr, minval, range,
- nodes, default_label)
- tree index_type, index_expr, minval, range;
- case_node_ptr nodes;
- rtx default_label;
+emit_case_bit_tests (tree index_type, tree index_expr, tree minval,
+ tree range, case_node_ptr nodes, rtx default_label)
{
struct case_bit_test test[MAX_CASE_BIT_TESTS];
enum machine_mode mode;
Generate the code to test it and jump to the right place. */
void
-expand_end_case_type (orig_index, orig_type)
- tree orig_index, orig_type;
+expand_end_case_type (tree orig_index, tree orig_type)
{
tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE;
rtx default_label = 0;
rightmost in the resulting list. */
static struct case_node *
-case_tree2list (node, right)
- struct case_node *node, *right;
+case_tree2list (struct case_node *node, struct case_node *right)
{
struct case_node *left;
/* Generate code to jump to LABEL if OP1 and OP2 are equal. */
static void
-do_jump_if_equal (op1, op2, label, unsignedp)
- rtx op1, op2, label;
- int unsignedp;
+do_jump_if_equal (rtx op1, rtx op2, rtx label, int unsignedp)
{
if (GET_CODE (op1) == CONST_INT && GET_CODE (op2) == CONST_INT)
{
return 0. */
static int
-estimate_case_costs (node)
- case_node_ptr node;
+estimate_case_costs (case_node_ptr node)
{
tree min_ascii = integer_minus_one_node;
tree max_ascii = convert (TREE_TYPE (node->high), build_int_2 (127, 0));
/* Determine whether two case labels branch to the same target. */
static bool
-same_case_target_p (l1, l2)
- rtx l1, l2;
+same_case_target_p (rtx l1, rtx l2)
{
rtx i1, i2;
case nodes. Eg. case 5: default: becomes just default: */
static void
-strip_default_case_nodes (prev, deflab)
- case_node_ptr *prev;
- rtx deflab;
+strip_default_case_nodes (case_node_ptr *prev, rtx deflab)
{
case_node_ptr ptr;
Eg. three separate entries 1: 2: 3: become one entry 1..3: */
static void
-group_case_nodes (head)
- case_node_ptr head;
+group_case_nodes (case_node_ptr head)
{
case_node_ptr node = head;
branch is then transformed recursively. */
static void
-balance_case_nodes (head, parent)
- case_node_ptr *head;
- case_node_ptr parent;
+balance_case_nodes (case_node_ptr *head, case_node_ptr parent)
{
case_node_ptr np;
span. Thus the test would be redundant. */
static int
-node_has_low_bound (node, index_type)
- case_node_ptr node;
- tree index_type;
+node_has_low_bound (case_node_ptr node, tree index_type)
{
tree low_minus_one;
case_node_ptr pnode;
span. Thus the test would be redundant. */
static int
-node_has_high_bound (node, index_type)
- case_node_ptr node;
- tree index_type;
+node_has_high_bound (case_node_ptr node, tree index_type)
{
tree high_plus_one;
case_node_ptr pnode;
bounds of NODE would be redundant. */
static int
-node_is_bounded (node, index_type)
- case_node_ptr node;
- tree index_type;
+node_is_bounded (case_node_ptr node, tree index_type)
{
return (node_has_low_bound (node, index_type)
&& node_has_high_bound (node, index_type));
/* Emit an unconditional jump to LABEL unless it would be dead code. */
static void
-emit_jump_if_reachable (label)
- rtx label;
+emit_jump_if_reachable (rtx label)
{
if (GET_CODE (get_last_insn ()) != BARRIER)
emit_jump (label);
tests for the value 50, then this node need not test anything. */
static void
-emit_case_nodes (index, node, default_label, index_type)
- rtx index;
- case_node_ptr node;
- rtx default_label;
- tree index_type;
+emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
+ tree index_type)
{
/* If INDEX has an unsigned type, we must make unsigned branches. */
int unsignedp = TREE_UNSIGNED (index_type);
called only by a front end. */
static int reference_types_internal = 0;
-static void finalize_record_size PARAMS ((record_layout_info));
-static void finalize_type_size PARAMS ((tree));
-static void place_union_field PARAMS ((record_layout_info, tree));
+static void finalize_record_size (record_layout_info);
+static void finalize_type_size (tree);
+static void place_union_field (record_layout_info, tree);
#if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
-static int excess_unit_span PARAMS ((HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, HOST_WIDE_INT,
- tree));
+static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, tree);
#endif
-static unsigned int update_alignment_for_field
- PARAMS ((record_layout_info, tree,
- unsigned int));
-extern void debug_rli PARAMS ((record_layout_info));
+static unsigned int update_alignment_for_field (record_layout_info, tree,
+ unsigned int);
+extern void debug_rli (record_layout_info);
\f
/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */
by front end. */
void
-internal_reference_types ()
+internal_reference_types (void)
{
reference_types_internal = 1;
}
/* Get a list of all the objects put on the pending sizes list. */
tree
-get_pending_sizes ()
+get_pending_sizes (void)
{
tree chain = pending_sizes;
tree t;
/* Return nonzero if EXPR is present on the pending sizes list. */
int
-is_pending_size (expr)
- tree expr;
+is_pending_size (tree expr)
{
tree t;
/* Add EXPR to the pending sizes list. */
void
-put_pending_size (expr)
- tree expr;
+put_pending_size (tree expr)
{
/* Strip any simple arithmetic from EXPR to see if it has an underlying
SAVE_EXPR. */
empty. */
void
-put_pending_sizes (chain)
- tree chain;
+put_pending_sizes (tree chain)
{
if (pending_sizes)
abort ();
to serve as the actual size-expression for a type or decl. */
tree
-variable_size (size)
- tree size;
+variable_size (tree size)
{
tree save;
be used. */
enum machine_mode
-mode_for_size (size, class, limit)
- unsigned int size;
- enum mode_class class;
- int limit;
+mode_for_size (unsigned int size, enum mode_class class, int limit)
{
enum machine_mode mode;
/* Similar, except passed a tree node. */
enum machine_mode
-mode_for_size_tree (size, class, limit)
- tree size;
- enum mode_class class;
- int limit;
+mode_for_size_tree (tree size, enum mode_class class, int limit)
{
if (TREE_CODE (size) != INTEGER_CST
|| TREE_OVERFLOW (size)
contains at least the requested number of bits. */
enum machine_mode
-smallest_mode_for_size (size, class)
- unsigned int size;
- enum mode_class class;
+smallest_mode_for_size (unsigned int size, enum mode_class class)
{
enum machine_mode mode;
/* Find an integer mode of the exact same size, or BLKmode on failure. */
enum machine_mode
-int_mode_for_mode (mode)
- enum machine_mode mode;
+int_mode_for_mode (enum machine_mode mode)
{
switch (GET_MODE_CLASS (mode))
{
BIGGEST_ALIGNMENT. */
unsigned int
-get_mode_alignment (mode)
- enum machine_mode mode;
+get_mode_alignment (enum machine_mode mode)
{
unsigned int alignment;
This can only be applied to objects of a sizetype. */
tree
-round_up (value, divisor)
- tree value;
- int divisor;
+round_up (tree value, int divisor)
{
tree arg = size_int_type (divisor, TREE_TYPE (value));
/* Likewise, but round down. */
tree
-round_down (value, divisor)
- tree value;
- int divisor;
+round_down (tree value, int divisor)
{
tree arg = size_int_type (divisor, TREE_TYPE (value));
the record will be aligned to suit. */
void
-layout_decl (decl, known_align)
- tree decl;
- unsigned int known_align;
+layout_decl (tree decl, unsigned int known_align)
{
tree type = TREE_TYPE (decl);
enum tree_code code = TREE_CODE (decl);
/* Hook for a front-end function that can modify the record layout as needed
immediately before it is finalized. */
-void (*lang_adjust_rli) PARAMS ((record_layout_info)) = 0;
+void (*lang_adjust_rli) (record_layout_info) = 0;
void
-set_lang_adjust_rli (f)
- void (*f) PARAMS ((record_layout_info));
+set_lang_adjust_rli (void (*f) (record_layout_info))
{
lang_adjust_rli = f;
}
out the record. */
record_layout_info
-start_record_layout (t)
- tree t;
+start_record_layout (tree t)
{
record_layout_info rli
= (record_layout_info) xmalloc (sizeof (struct record_layout_info_s));
the offset/bitpos forms and byte and bit offsets. */
tree
-bit_from_pos (offset, bitpos)
- tree offset, bitpos;
+bit_from_pos (tree offset, tree bitpos)
{
return size_binop (PLUS_EXPR, bitpos,
size_binop (MULT_EXPR, convert (bitsizetype, offset),
}
tree
-byte_from_pos (offset, bitpos)
- tree offset, bitpos;
+byte_from_pos (tree offset, tree bitpos)
{
return size_binop (PLUS_EXPR, offset,
convert (sizetype,
}
void
-pos_from_bit (poffset, pbitpos, off_align, pos)
- tree *poffset, *pbitpos;
- unsigned int off_align;
- tree pos;
+pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align,
+ tree pos)
{
*poffset = size_binop (MULT_EXPR,
convert (sizetype,
normalize the offsets so they are within the alignment. */
void
-normalize_offset (poffset, pbitpos, off_align)
- tree *poffset, *pbitpos;
- unsigned int off_align;
+normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align)
{
/* If the bit position is now larger than it should be, adjust it
downwards. */
/* Print debugging information about the information in RLI. */
void
-debug_rli (rli)
- record_layout_info rli;
+debug_rli (record_layout_info rli)
{
print_node_brief (stderr, "type", rli->t, 0);
print_node_brief (stderr, "\noffset", rli->offset, 0);
BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */
void
-normalize_rli (rli)
- record_layout_info rli;
+normalize_rli (record_layout_info rli)
{
normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align);
}
/* Returns the size in bytes allocated so far. */
tree
-rli_size_unit_so_far (rli)
- record_layout_info rli;
+rli_size_unit_so_far (record_layout_info rli)
{
return byte_from_pos (rli->offset, rli->bitpos);
}
/* Returns the size in bits allocated so far. */
tree
-rli_size_so_far (rli)
- record_layout_info rli;
+rli_size_so_far (record_layout_info rli)
{
return bit_from_pos (rli->offset, rli->bitpos);
}
the FIELD. */
static unsigned int
-update_alignment_for_field (rli, field, known_align)
- record_layout_info rli;
- tree field;
- unsigned int known_align;
+update_alignment_for_field (record_layout_info rli, tree field,
+ unsigned int known_align)
{
/* The alignment required for FIELD. */
unsigned int desired_align;
applies if there was an immediately prior, nonzero-size
bitfield. (That's the way it is, experimentally.) */
if (! integer_zerop (DECL_SIZE (field))
- ? ! DECL_PACKED (field)
- : (rli->prev_field
- && DECL_BIT_FIELD_TYPE (rli->prev_field)
- && ! integer_zerop (DECL_SIZE (rli->prev_field))))
+ ? ! DECL_PACKED (field)
+ : (rli->prev_field
+ && DECL_BIT_FIELD_TYPE (rli->prev_field)
+ && ! integer_zerop (DECL_SIZE (rli->prev_field))))
{
unsigned int type_align = TYPE_ALIGN (type);
type_align = MAX (type_align, desired_align);
/* Called from place_field to handle unions. */
static void
-place_union_field (rli, field)
- record_layout_info rli;
- tree field;
+place_union_field (record_layout_info rli, tree field)
{
update_alignment_for_field (rli, field, /*known_align=*/0);
at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more
units of alignment than the underlying TYPE. */
static int
-excess_unit_span (byte_offset, bit_offset, size, align, type)
- HOST_WIDE_INT byte_offset, bit_offset, size, align;
- tree type;
+excess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset,
+ HOST_WIDE_INT size, HOST_WIDE_INT align, tree type)
{
/* Note that the calculation of OFFSET might overflow; we calculate it so
that we still get the right result as long as ALIGN is a power of two. */
callers that desire that behavior must manually perform that step.) */
void
-place_field (rli, field)
- record_layout_info rli;
- tree field;
+place_field (record_layout_info rli, tree field)
{
/* The alignment required for FIELD. */
unsigned int desired_align;
& - tree_low_cst (rli->offset, 1)));
else
known_align = rli->offset_align;
-
+
desired_align = update_alignment_for_field (rli, field, known_align);
if (warn_packed && DECL_PACKED (field))
if ((* targetm.ms_bitfield_layout_p) (rli->t)
&& ((DECL_BIT_FIELD_TYPE (field) && ! DECL_PACKED (field))
- || (rli->prev_field && ! DECL_PACKED (rli->prev_field))))
+ || (rli->prev_field && ! DECL_PACKED (rli->prev_field))))
{
/* At this point, either the prior or current are bitfields,
(possibly both), and we're dealing with MS packing. */
indicated by RLI. */
static void
-finalize_record_size (rli)
- record_layout_info rli;
+finalize_record_size (record_layout_info rli)
{
tree unpadded_size, unpadded_size_unit;
/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */
void
-compute_record_mode (type)
- tree type;
+compute_record_mode (tree type)
{
tree field;
enum machine_mode mode = VOIDmode;
out. */
static void
-finalize_type_size (type)
- tree type;
+finalize_type_size (tree type)
{
/* Normally, use the alignment corresponding to the mode chosen.
However, where strict alignment is not required, avoid
G++ 3.2 ABI. */
void
-finish_record_layout (rli, free_p)
- record_layout_info rli;
- int free_p;
+finish_record_layout (record_layout_info rli, int free_p)
{
/* Compute the final size. */
finalize_record_size (rli);
ALIGN_TYPE. */
void
-finish_builtin_struct (type, name, fields, align_type)
- tree type;
- const char *name;
- tree fields;
- tree align_type;
+finish_builtin_struct (tree type, const char *name, tree fields,
+ tree align_type)
{
tree tail, next;
If the type is incomplete, its TYPE_SIZE remains zero. */
void
-layout_type (type)
- tree type;
+layout_type (tree type)
{
if (type == 0)
abort ();
/* Create and return a type for signed integers of PRECISION bits. */
tree
-make_signed_type (precision)
- int precision;
+make_signed_type (int precision)
{
tree type = make_node (INTEGER_TYPE);
/* Create and return a type for unsigned integers of PRECISION bits. */
tree
-make_unsigned_type (precision)
- int precision;
+make_unsigned_type (int precision)
{
tree type = make_node (INTEGER_TYPE);
value to enable integer types to be created. */
void
-initialize_sizetypes ()
+initialize_sizetypes (void)
{
tree t = make_node (INTEGER_TYPE);
Also update the type of any standard type's sizes made so far. */
void
-set_sizetype (type)
- tree type;
+set_sizetype (tree type)
{
int oprecision = TYPE_PRECISION (type);
/* The *bitsizetype types use a precision that avoids overflows when
E.g. for Pascal, when the -fsigned-char option is given. */
void
-fixup_signed_type (type)
- tree type;
+fixup_signed_type (tree type)
{
int precision = TYPE_PRECISION (type);
and for enumeral types. */
void
-fixup_unsigned_type (type)
- tree type;
+fixup_unsigned_type (tree type)
{
int precision = TYPE_PRECISION (type);
all the conditions. */
enum machine_mode
-get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
- int bitsize, bitpos;
- unsigned int align;
- enum machine_mode largest_mode;
- int volatilep;
+get_best_mode (int bitsize, int bitpos, unsigned int align,
+ enum machine_mode largest_mode, int volatilep)
{
enum machine_mode mode;
unsigned int unit = 0;
/* String pool for GCC.
- 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.
struct ht *ident_hash;
static struct obstack string_stack;
-static hashnode alloc_node PARAMS ((hash_table *));
-static int mark_ident PARAMS ((struct cpp_reader *, hashnode, const void *));
-static int ht_copy_and_clear PARAMS ((struct cpp_reader *, hashnode, const void *));
+static hashnode alloc_node (hash_table *);
+static int mark_ident (struct cpp_reader *, hashnode, const void *);
+static int ht_copy_and_clear (struct cpp_reader *, hashnode, const void *);
/* Initialize the string pool. */
void
-init_stringpool ()
+init_stringpool (void)
{
/* Create with 16K (2^14) entries. */
ident_hash = ht_create (14);
/* Allocate a hash node. */
static hashnode
-alloc_node (table)
- hash_table *table ATTRIBUTE_UNUSED;
+alloc_node (hash_table *table ATTRIBUTE_UNUSED)
{
return GCC_IDENT_TO_HT_IDENT (make_node (IDENTIFIER_NODE));
}
returned this time too. */
const char *
-ggc_alloc_string (contents, length)
- const char *contents;
- int length;
+ggc_alloc_string (const char *contents, int length)
{
if (length == -1)
length = strlen (contents);
the same node is returned this time. */
tree
-get_identifier (text)
- const char *text;
+get_identifier (const char *text)
{
hashnode ht_node = ht_lookup (ident_hash,
(const unsigned char *) text,
known. */
tree
-get_identifier_with_length (text, length)
- const char *text;
- unsigned int length;
+get_identifier_with_length (const char *text, unsigned int length)
{
hashnode ht_node = ht_lookup (ident_hash,
(const unsigned char *) text,
NULL_TREE. */
tree
-maybe_get_identifier (text)
- const char *text;
+maybe_get_identifier (const char *text)
{
hashnode ht_node;
/* Report some basic statistics about the string pool. */
void
-stringpool_statistics ()
+stringpool_statistics (void)
{
ht_dump_statistics (ident_hash);
}
/* Mark an identifier for GC. */
static int
-mark_ident (pfile, h, v)
- struct cpp_reader *pfile ATTRIBUTE_UNUSED;
- hashnode h;
- const void *v ATTRIBUTE_UNUSED;
+mark_ident (struct cpp_reader *pfile ATTRIBUTE_UNUSED, hashnode h,
+ const void *v ATTRIBUTE_UNUSED)
{
gt_ggc_m_9tree_node (HT_IDENT_TO_GCC_IDENT (h));
return 1;
treatment for strings. */
void
-ggc_mark_stringpool ()
+ggc_mark_stringpool (void)
{
ht_forall (ident_hash, mark_ident, NULL);
}
to strings. */
void
-gt_ggc_m_S (x)
- void *x ATTRIBUTE_UNUSED;
+gt_ggc_m_S (void *x ATTRIBUTE_UNUSED)
{
}
strings don't contain pointers). */
void
-gt_pch_p_S (obj, x, op, cookie)
- void *obj ATTRIBUTE_UNUSED;
- void *x ATTRIBUTE_UNUSED;
- gt_pointer_operator op ATTRIBUTE_UNUSED;
- void *cookie ATTRIBUTE_UNUSED;
+gt_pch_p_S (void *obj ATTRIBUTE_UNUSED, void *x ATTRIBUTE_UNUSED,
+ gt_pointer_operator op ATTRIBUTE_UNUSED,
+ void *cookie ATTRIBUTE_UNUSED)
{
}
/* PCH pointer-walking routine for strings. */
void
-gt_pch_n_S (x)
- const void *x;
+gt_pch_n_S (const void *x)
{
gt_pch_note_object ((void *)x, (void *)x, >_pch_p_S);
}
static GTY(()) struct string_pool_data * spd;
-static int
-ht_copy_and_clear (r, hp, ht2_p)
- cpp_reader *r ATTRIBUTE_UNUSED;
- hashnode hp;
- const void *ht2_p;
+static int
+ht_copy_and_clear (cpp_reader *r ATTRIBUTE_UNUSED, hashnode hp, const void *ht2_p)
{
cpp_hashnode *h = CPP_HASHNODE (hp);
struct ht *ht2 = (struct ht *) ht2_p;
static struct ht *saved_ident_hash;
void
-gt_pch_save_stringpool ()
+gt_pch_save_stringpool (void)
{
unsigned int i;
-
+
spd = ggc_alloc (sizeof (*spd));
spd->nslots = ident_hash->nslots;
spd->nelements = ident_hash->nelements;
}
void
-gt_pch_fixup_stringpool ()
+gt_pch_fixup_stringpool (void)
{
ht_forall (saved_ident_hash, ht_copy_and_clear, ident_hash);
ht_destroy (saved_ident_hash);
}
void
-gt_pch_restore_stringpool ()
+gt_pch_restore_stringpool (void)
{
unsigned int i;
-
+
ident_hash->nslots = spd->nslots;
ident_hash->nelements = spd->nelements;
ident_hash->entries = xrealloc (ident_hash->entries,
ALIGNED_P indicates whether it is aligned. Return true if
successful. Only handles cases for which BYTE_OP, ALIGNED_OP
and UNALIGNED_OP are NULL. */
- bool (* integer) PARAMS ((rtx x, unsigned int size, int aligned_p));
+ bool (* integer) (rtx x, unsigned int size, int aligned_p);
/* Output code that will globalize a label. */
- void (* globalize_label) PARAMS ((FILE *, const char *));
+ void (* globalize_label) (FILE *, const char *);
/* Output an internal label. */
- void (* internal_label) PARAMS ((FILE *, const char *, unsigned long));
+ void (* internal_label) (FILE *, const char *, unsigned long);
/* Emit an assembler directive to set visibility for the symbol
associated with the tree decl. */
- void (* visibility) PARAMS ((tree, int));
+ void (* visibility) (tree, int);
/* Output the assembler code for entry to a function. */
- void (* function_prologue) PARAMS ((FILE *, HOST_WIDE_INT));
+ void (* function_prologue) (FILE *, HOST_WIDE_INT);
/* Output the assembler code for end of prologue. */
- void (* function_end_prologue) PARAMS ((FILE *));
+ void (* function_end_prologue) (FILE *);
/* Output the assembler code for start of epilogue. */
- void (* function_begin_epilogue) PARAMS ((FILE *));
+ void (* function_begin_epilogue) (FILE *);
/* Output the assembler code for function exit. */
- void (* function_epilogue) PARAMS ((FILE *, HOST_WIDE_INT));
+ void (* function_epilogue) (FILE *, HOST_WIDE_INT);
/* Switch to an arbitrary section NAME with attributes as
specified by FLAGS. */
- void (* named_section) PARAMS ((const char *, unsigned int));
+ void (* named_section) (const char *, unsigned int);
/* Switch to the section that holds the exception table. */
- void (* exception_section) PARAMS ((void));
+ void (* exception_section) (void);
/* Switch to the section that holds the exception frames. */
- void (* eh_frame_section) PARAMS ((void));
+ void (* eh_frame_section) (void);
/* Select and switch to a section for EXP. It may be a DECL or a
constant. RELOC is nonzero if runtime relocations must be applied;
bit 1 will be set if the runtime relocations require non-local
name resolution. ALIGN is the required alignment of the data. */
- void (* select_section) PARAMS ((tree, int, unsigned HOST_WIDE_INT));
+ void (* select_section) (tree, int, unsigned HOST_WIDE_INT);
/* Select and switch to a section for X with MODE. ALIGN is
the desired alignment of the data. */
- void (* select_rtx_section) PARAMS ((enum machine_mode, rtx,
- unsigned HOST_WIDE_INT));
+ void (* select_rtx_section) (enum machine_mode, rtx,
+ unsigned HOST_WIDE_INT);
/* Select a unique section name for DECL. RELOC is the same as
for SELECT_SECTION. */
- void (* unique_section) PARAMS ((tree, int));
+ void (* unique_section) (tree, int);
/* Output a constructor for a symbol with a given priority. */
- void (* constructor) PARAMS ((rtx, int));
+ void (* constructor) (rtx, int);
/* Output a destructor for a symbol with a given priority. */
- void (* destructor) PARAMS ((rtx, int));
+ void (* destructor) (rtx, int);
/* Output the assembler code for a thunk function. THUNK_DECL is the
declaration for the thunk function itself, FUNCTION is the decl for
the target function. DELTA is an immediate constant offset to be
added to THIS. If VCALL_OFFSET is nonzero, the word at
*(*this + vcall_offset) should be added to THIS. */
- void (* output_mi_thunk) PARAMS ((FILE *file, tree thunk_decl,
- HOST_WIDE_INT delta,
- HOST_WIDE_INT vcall_offset,
- tree function_decl));
+ void (* output_mi_thunk) (FILE *file, tree thunk_decl,
+ HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
+ tree function_decl);
/* Determine whether output_mi_thunk would succeed. */
/* ??? Ideally, this hook would not exist, and success or failure
too much undo-able setup involved in invoking output_mi_thunk.
Could be fixed by making output_mi_thunk emit rtl instead of
text to the output file. */
- bool (* can_output_mi_thunk) PARAMS ((tree thunk_decl,
- HOST_WIDE_INT delta,
- HOST_WIDE_INT vcall_offset,
- tree function_decl));
+ bool (* can_output_mi_thunk) (tree thunk_decl, HOST_WIDE_INT delta,
+ HOST_WIDE_INT vcall_offset,
+ tree function_decl);
/* Output any boilerplate text needed at the beginning of a
translation unit. */
- void (*file_start) PARAMS ((void));
+ void (*file_start) (void);
/* Output any boilerplate text needed at the end of a
translation unit. */
- void (*file_end) PARAMS ((void));
+ void (*file_end) (void);
} asm_out;
/* Functions relating to instruction scheduling. */
/* Given the current cost, COST, of an insn, INSN, calculate and
return a new cost based on its relationship to DEP_INSN through
the dependence LINK. The default is to make no adjustment. */
- int (* adjust_cost) PARAMS ((rtx insn, rtx link, rtx def_insn, int cost));
+ int (* adjust_cost) (rtx insn, rtx link, rtx def_insn, int cost);
/* Adjust the priority of an insn as you see fit. Returns the new
priority. */
- int (* adjust_priority) PARAMS ((rtx, int));
+ int (* adjust_priority) (rtx, int);
/* Function which returns the maximum number of insns that can be
scheduled in the same machine cycle. This must be constant
over an entire compilation. The default is 1. */
- int (* issue_rate) PARAMS ((void));
+ int (* issue_rate) (void);
/* Calculate how much this insn affects how many more insns we
can emit this cycle. Default is they all cost the same. */
- int (* variable_issue) PARAMS ((FILE *, int, rtx, int));
+ int (* variable_issue) (FILE *, int, rtx, int);
/* Initialize machine-dependent scheduling code. */
- void (* md_init) PARAMS ((FILE *, int, int));
+ void (* md_init) (FILE *, int, int);
/* Finalize machine-dependent scheduling code. */
- void (* md_finish) PARAMS ((FILE *, int));
+ void (* md_finish) (FILE *, int);
/* Reorder insns in a machine-dependent fashion, in two different
places. Default does nothing. */
- int (* reorder) PARAMS ((FILE *, int, rtx *, int *, int));
- int (* reorder2) PARAMS ((FILE *, int, rtx *, int *, int));
+ int (* reorder) (FILE *, int, rtx *, int *, int);
+ int (* reorder2) (FILE *, int, rtx *, int *, int);
/* The following member value is a pointer to a function called
after evaluation forward dependencies of insns in chain given
by two parameter values (head and tail correspondingly). */
- void (* dependencies_evaluation_hook) PARAMS ((rtx, rtx));
+ void (* dependencies_evaluation_hook) (rtx, rtx);
/* The following member value is a pointer to a function returning
nonzero if we should use DFA based scheduling. The default is
to use the old pipeline scheduler. */
- int (* use_dfa_pipeline_interface) PARAMS ((void));
+ int (* use_dfa_pipeline_interface) (void);
/* The values of all the following members are used only for the
DFA based scheduler: */
/* The values of the following four members are pointers to
the memebers result in not changing the automaton state when
the new simulated processor cycle correspondingly starts and
finishes. */
- void (* init_dfa_pre_cycle_insn) PARAMS ((void));
- rtx (* dfa_pre_cycle_insn) PARAMS ((void));
- void (* init_dfa_post_cycle_insn) PARAMS ((void));
- rtx (* dfa_post_cycle_insn) PARAMS ((void));
+ void (* init_dfa_pre_cycle_insn) (void);
+ rtx (* dfa_pre_cycle_insn) (void);
+ void (* init_dfa_post_cycle_insn) (void);
+ rtx (* dfa_post_cycle_insn) (void);
/* The following member value is a pointer to a function returning value
which defines how many insns in queue `ready' will we try for
multi-pass scheduling. if the member value is nonzero and the
multi-pass scheduling for the first cycle. In other words, we will
try to choose ready insn which permits to start maximum number of
insns on the same cycle. */
- int (* first_cycle_multipass_dfa_lookahead) PARAMS ((void));
+ int (* first_cycle_multipass_dfa_lookahead) (void);
/* The following member value is pointer to a function controlling
what insns from the ready insn queue will be considered for the
multipass insn scheduling. If the hook returns zero for insn
passed as the parameter, the insn will be not chosen to be
issued. */
- int (* first_cycle_multipass_dfa_lookahead_guard) PARAMS ((rtx));
+ int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
/* The following member value is pointer to a function called by
the insn scheduler before issuing insn passed as the third
parameter on given cycle. If the hook returns nonzero, the
parameter values are correspondingly processor cycle on which
the previous insn has been issued and the current processor
cycle. */
- int (* dfa_new_cycle) PARAMS ((FILE *, int, rtx, int, int, int *));
+ int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
/* The values of the following members are pointers to functions
used to improve the first cycle multipass scheduling by
inserting nop insns. dfa_scheduler_bubble gives a function
init_dfa_scheduler_bubbles is used. The default values of the
members result in not inserting nop insns during the multipass
scheduling. */
- void (* init_dfa_bubbles) PARAMS ((void));
- rtx (* dfa_bubble) PARAMS ((int));
+ void (* init_dfa_bubbles) (void);
+ rtx (* dfa_bubble) (int);
} sched;
/* Given two decls, merge their attributes and return the result. */
- tree (* merge_decl_attributes) PARAMS ((tree, tree));
+ tree (* merge_decl_attributes) (tree, tree);
/* Given two types, merge their attributes and return the result. */
- tree (* merge_type_attributes) PARAMS ((tree, tree));
+ tree (* merge_type_attributes) (tree, tree);
/* Table of machine attributes and functions to handle them.
Ignored if NULL. */
/* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
one if they are compatible and two if they are nearly compatible
(which causes a warning to be generated). */
- int (* comp_type_attributes) PARAMS ((tree type1, tree type2));
+ int (* comp_type_attributes) (tree type1, tree type2);
/* Assign default attributes to the newly defined TYPE. */
- void (* set_default_type_attributes) PARAMS ((tree type));
+ void (* set_default_type_attributes) (tree type);
/* Insert attributes on the newly created DECL. */
- void (* insert_attributes) PARAMS ((tree decl, tree *attributes));
+ void (* insert_attributes) (tree decl, tree *attributes);
/* Return true if FNDECL (which has at least one machine attribute)
can be inlined despite its machine attributes, false otherwise. */
- bool (* function_attribute_inlinable_p) PARAMS ((tree fndecl));
+ bool (* function_attribute_inlinable_p) (tree fndecl);
/* Return true if bitfields in RECORD_TYPE should follow the
Microsoft Visual C++ bitfield layout rules. */
- bool (* ms_bitfield_layout_p) PARAMS ((tree record_type));
+ bool (* ms_bitfield_layout_p) (tree record_type);
/* Set up target-specific built-in functions. */
- void (* init_builtins) PARAMS ((void));
+ void (* init_builtins) (void);
/* Expand a target-specific builtin. */
- rtx (* expand_builtin) PARAMS ((tree exp, rtx target, rtx subtarget,
- enum machine_mode mode, int ignore));
+ rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
+ enum machine_mode mode, int ignore);
/* Given a decl, a section name, and whether the decl initializer
has relocs, choose attributes for the section. */
/* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */
- unsigned int (* section_type_flags) PARAMS ((tree, const char *, int));
+ unsigned int (* section_type_flags) (tree, const char *, int);
/* True if new jumps cannot be created, to replace existing ones or
not, at the current point in the compilation. */
- bool (* cannot_modify_jumps_p) PARAMS ((void));
+ bool (* cannot_modify_jumps_p) (void);
/* Return a register class for which branch target register
optimizations should be applied. */
- int (* branch_target_register_class) PARAMS ((void));
+ int (* branch_target_register_class) (void);
/* Return true if branch target register optimizations should include
callee-saved registers that are not already live during the current
function. AFTER_PE_GEN is true if prologues and epilogues have
already been generated. */
- bool (* branch_target_register_callee_saved) PARAMS ((bool after_pe_gen));
+ bool (* branch_target_register_callee_saved) (bool after_pe_gen);
/* True if the constant X cannot be placed in the constant pool. */
- bool (* cannot_force_const_mem) PARAMS ((rtx));
+ bool (* cannot_force_const_mem) (rtx);
/* True if the insn X cannot be duplicated. */
- bool (* cannot_copy_insn_p) PARAMS ((rtx));
+ bool (* cannot_copy_insn_p) (rtx);
/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */
- rtx (* delegitimize_address) PARAMS ((rtx));
+ rtx (* delegitimize_address) (rtx);
/* True if it is OK to do sibling call optimization for the specified
call expression EXP. DECL will be the called function, or NULL if
this is an indirect call. */
- bool (*function_ok_for_sibcall) PARAMS ((tree decl, tree exp));
-
+ bool (*function_ok_for_sibcall) (tree decl, tree exp);
+
/* True if EXP should be placed in a "small data" section. */
- bool (* in_small_data_p) PARAMS ((tree));
+ bool (* in_small_data_p) (tree);
/* True if EXP names an object for which name resolution must resolve
to the current module. */
- bool (* binds_local_p) PARAMS ((tree));
+ bool (* binds_local_p) (tree);
/* Do something target-specific to record properties of the DECL into
the associated SYMBOL_REF. */
- void (* encode_section_info) PARAMS ((tree, rtx, int));
+ void (* encode_section_info) (tree, rtx, int);
/* Undo the effects of encode_section_info on the symbol string. */
- const char * (* strip_name_encoding) PARAMS ((const char *));
+ const char * (* strip_name_encoding) (const char *);
/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
- bool (* valid_pointer_mode) PARAMS ((enum machine_mode mode));
+ bool (* valid_pointer_mode) (enum machine_mode mode);
/* True if a vector is opaque. */
- bool (* vector_opaque_p) PARAMS ((tree));
+ bool (* vector_opaque_p) (tree);
/* Compute a (partial) cost for rtx X. Return true if the complete
cost has been computed, and false if subexpressions should be
scanned. In either case, *TOTAL contains the cost result. */
/* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
not necessarily defined at this point. */
- bool (* rtx_costs) PARAMS ((rtx x, int code, int outer_code, int *total));
+ bool (* rtx_costs) (rtx x, int code, int outer_code, int *total);
/* Compute the cost of X, used as an address. Never called with
invalid addresses. */
- int (* address_cost) PARAMS ((rtx x));
+ int (* address_cost) (rtx x);
/* Given a register, this hook should return a parallel of registers
to represent where to find the register pieces. Define this hook
non-contiguous locations, or if the register should be
represented in more than one register in Dwarf. Otherwise, this
hook should return NULL_RTX. */
- rtx (* dwarf_register_span) PARAMS ((rtx));
+ rtx (* dwarf_register_span) (rtx);
/* Do machine-dependent code transformations. Called just before
delayed-branch scheduling. */
- void (* machine_dependent_reorg) PARAMS ((void));
+ void (* machine_dependent_reorg) (void);
/* Leave the boolean fields at the end. */
information). */
#ifdef HAVE_TIMES
# if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
- extern clock_t times PARAMS ((struct tms *));
+ extern clock_t times (struct tms *);
# endif
# define USE_TIMES
# define HAVE_USER_TIME
element. */
static struct timevar_time_def start_time;
-static void get_time
- PARAMS ((struct timevar_time_def *));
-static void timevar_accumulate
- PARAMS ((struct timevar_time_def *, struct timevar_time_def *,
- struct timevar_time_def *));
+static void get_time (struct timevar_time_def *);
+static void timevar_accumulate (struct timevar_time_def *,
+ struct timevar_time_def *,
+ struct timevar_time_def *);
/* Fill the current times into TIME. The definition of this function
also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
HAVE_WALL_TIME macros. */
static void
-get_time (now)
- struct timevar_time_def *now;
+get_time (struct timevar_time_def *now)
{
now->user = 0;
now->sys = 0;
/* Add the difference between STOP_TIME and START_TIME to TIMER. */
static void
-timevar_accumulate (timer, start_time, stop_time)
- struct timevar_time_def *timer;
- struct timevar_time_def *start_time;
- struct timevar_time_def *stop_time;
+timevar_accumulate (struct timevar_time_def *timer,
+ struct timevar_time_def *start_time,
+ struct timevar_time_def *stop_time)
{
timer->user += stop_time->user - start_time->user;
timer->sys += stop_time->sys - start_time->sys;
/* Initialize timing variables. */
void
-timevar_init ()
+timevar_init (void)
{
timevar_enable = true;
TIMEVAR cannot be running as a standalone timer. */
void
-timevar_push (timevar)
- timevar_id_t timevar;
+timevar_push (timevar_id_t timevar)
{
struct timevar_def *tv = &timevars[timevar];
struct timevar_stack_def *context;
timing variable. */
void
-timevar_pop (timevar)
- timevar_id_t timevar;
+timevar_pop (timevar_id_t timevar)
{
struct timevar_time_def now;
struct timevar_stack_def *popped = stack;
attributed to TIMEVAR. */
void
-timevar_start (timevar)
- timevar_id_t timevar;
+timevar_start (timevar_id_t timevar)
{
struct timevar_def *tv = &timevars[timevar];
is attributed to it. */
void
-timevar_stop (timevar)
- timevar_id_t timevar;
+timevar_stop (timevar_id_t timevar)
{
struct timevar_def *tv = &timevars[timevar];
struct timevar_time_def now;
update-to-date information even if TIMEVAR is currently running. */
void
-timevar_get (timevar, elapsed)
- timevar_id_t timevar;
- struct timevar_time_def *elapsed;
+timevar_get (timevar_id_t timevar, struct timevar_time_def *elapsed)
{
struct timevar_def *tv = &timevars[timevar];
struct timevar_time_def now;
for normalizing the others, and is displayed last. */
void
-timevar_print (fp)
- FILE *fp;
+timevar_print (FILE *fp)
{
/* Only print stuff if we have some sort of time information. */
#if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME)
TOTAL (given in microseconds). */
void
-print_time (str, total)
- const char *str;
- long total;
+print_time (const char *str, long total)
{
long all_time = get_run_time ();
fprintf (stderr,
/* Execute the sequence: timevar_pop (TV), return (E); */
#define POP_TIMEVAR_AND_RETURN(TV, E) return (timevar_pop (TV), (E))
-extern void timevar_init PARAMS ((void));
-extern void timevar_push PARAMS ((timevar_id_t));
-extern void timevar_pop PARAMS ((timevar_id_t));
-extern void timevar_start PARAMS ((timevar_id_t));
-extern void timevar_stop PARAMS ((timevar_id_t));
-extern void timevar_get PARAMS ((timevar_id_t, struct timevar_time_def *));
-extern void timevar_print PARAMS ((FILE *));
+extern void timevar_init (void);
+extern void timevar_push (timevar_id_t);
+extern void timevar_pop (timevar_id_t);
+extern void timevar_start (timevar_id_t);
+extern void timevar_stop (timevar_id_t);
+extern void timevar_get (timevar_id_t, struct timevar_time_def *);
+extern void timevar_print (FILE *);
/* Provided for backward compatibility. */
-extern void print_time PARAMS ((const char *, long));
+extern void print_time (const char *, long);
#endif /* ! GCC_TIMEVAR_H */
/* Scan linker error messages for missing template instantiations and provide
them.
- Copyright (C) 1995, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1998, 1999, 2000, 2001, 2003
+ Free Software Foundation, Inc.
Contributed by Jason Merrill (jason@cygnus.com).
This file is part of GCC.
/* Hash and comparison functions for these hash tables. */
-static int hash_string_eq PARAMS ((const void *, const void *));
-static hashval_t hash_string_hash PARAMS ((const void *));
+static int hash_string_eq (const void *, const void *);
+static hashval_t hash_string_hash (const void *);
static int
-hash_string_eq (s1_p, s2_p)
- const void *s1_p;
- const void *s2_p;
+hash_string_eq (const void *s1_p, const void *s2_p)
{
const char *const *s1 = (const char *const *) s1_p;
const char *s2 = (const char *) s2_p;
}
static hashval_t
-hash_string_hash (s_p)
- const void *s_p;
+hash_string_hash (const void *s_p)
{
const char *const *s = (const char *const *) s_p;
return (*htab_hash_string) (*s);
static htab_t symbol_table;
-static struct symbol_hash_entry * symbol_hash_lookup PARAMS ((const char *,
- int));
-static struct file_hash_entry * file_hash_lookup PARAMS ((const char *));
-static struct demangled_hash_entry *
- demangled_hash_lookup PARAMS ((const char *, int));
-static void symbol_push PARAMS ((symbol *));
-static symbol * symbol_pop PARAMS ((void));
-static void file_push PARAMS ((file *));
-static file * file_pop PARAMS ((void));
-static void tlink_init PARAMS ((void));
-static int tlink_execute PARAMS ((const char *, char **, const char *));
-static char * frob_extension PARAMS ((const char *, const char *));
-static char * obstack_fgets PARAMS ((FILE *, struct obstack *));
-static char * tfgets PARAMS ((FILE *));
-static char * pfgets PARAMS ((FILE *));
-static void freadsym PARAMS ((FILE *, file *, int));
-static void read_repo_file PARAMS ((file *));
-static void maybe_tweak PARAMS ((char *, file *));
-static int recompile_files PARAMS ((void));
-static int read_repo_files PARAMS ((char **));
-static void demangle_new_symbols PARAMS ((void));
-static int scan_linker_output PARAMS ((const char *));
+static struct symbol_hash_entry * symbol_hash_lookup (const char *, int);
+static struct file_hash_entry * file_hash_lookup (const char *);
+static struct demangled_hash_entry *demangled_hash_lookup (const char *, int);
+static void symbol_push (symbol *);
+static symbol * symbol_pop (void);
+static void file_push (file *);
+static file * file_pop (void);
+static void tlink_init (void);
+static int tlink_execute (const char *, char **, const char *);
+static char * frob_extension (const char *, const char *);
+static char * obstack_fgets (FILE *, struct obstack *);
+static char * tfgets (FILE *);
+static char * pfgets (FILE *);
+static void freadsym (FILE *, file *, int);
+static void read_repo_file (file *);
+static void maybe_tweak (char *, file *);
+static int recompile_files (void);
+static int read_repo_files (char **);
+static void demangle_new_symbols (void);
+static int scan_linker_output (const char *);
/* Look up an entry in the symbol hash table. */
static struct symbol_hash_entry *
-symbol_hash_lookup (string, create)
- const char *string;
- int create;
+symbol_hash_lookup (const char *string, int create)
{
void **e;
e = htab_find_slot_with_hash (symbol_table, string,
/* Look up an entry in the file hash table. */
static struct file_hash_entry *
-file_hash_lookup (string)
- const char *string;
+file_hash_lookup (const char *string)
{
void **e;
e = htab_find_slot_with_hash (file_table, string,
/* Look up an entry in the demangled name hash table. */
static struct demangled_hash_entry *
-demangled_hash_lookup (string, create)
- const char *string;
- int create;
+demangled_hash_lookup (const char *string, int create)
{
void **e;
e = htab_find_slot_with_hash (demangled_table, string,
struct file_stack_entry *file_stack;
static void
-symbol_push (p)
- symbol *p;
+symbol_push (symbol *p)
{
struct symbol_stack_entry *ep = (struct symbol_stack_entry *) obstack_alloc
(&symbol_stack_obstack, sizeof (struct symbol_stack_entry));
}
static symbol *
-symbol_pop ()
+symbol_pop (void)
{
struct symbol_stack_entry *ep = symbol_stack;
symbol *p;
}
static void
-file_push (p)
- file *p;
+file_push (file *p)
{
struct file_stack_entry *ep;
}
static file *
-file_pop ()
+file_pop (void)
{
struct file_stack_entry *ep = file_stack;
file *p;
/* Initialize the tlink machinery. Called from do_tlink. */
static void
-tlink_init ()
+tlink_init (void)
{
const char *p;
NULL);
demangled_table = htab_create (500, hash_string_hash, hash_string_eq,
NULL);
-
+
obstack_begin (&symbol_stack_obstack, 0);
obstack_begin (&file_stack_obstack, 0);
}
static int
-tlink_execute (prog, argv, redir)
- const char *prog;
- char **argv;
- const char *redir;
+tlink_execute (const char *prog, char **argv, const char *redir)
{
collect_execute (prog, argv, redir);
return collect_wait (prog);
}
static char *
-frob_extension (s, ext)
- const char *s;
- const char *ext;
+frob_extension (const char *s, const char *ext)
{
const char *p = strrchr (s, '/');
if (! p)
}
static char *
-obstack_fgets (stream, ob)
- FILE *stream;
- struct obstack *ob;
+obstack_fgets (FILE *stream, struct obstack *ob)
{
int c;
while ((c = getc (stream)) != EOF && c != '\n')
}
static char *
-tfgets (stream)
- FILE *stream;
+tfgets (FILE *stream)
{
return obstack_fgets (stream, &temporary_obstack);
}
static char *
-pfgets (stream)
- FILE *stream;
+pfgets (FILE *stream)
{
return xstrdup (tfgets (stream));
}
XXX "provided" is unimplemented, both here and in the compiler. */
static void
-freadsym (stream, f, chosen)
- FILE *stream;
- file *f;
- int chosen;
+freadsym (FILE *stream, file *f, int chosen)
{
symbol *sym;
/* Read in the repo file denoted by F, and record all its information. */
static void
-read_repo_file (f)
- file *f;
+read_repo_file (file *f)
{
char c;
FILE *stream = fopen (f->key, "r");
this one wants to emit it as well. */
static void
-maybe_tweak (line, f)
- char *line;
- file *f;
+maybe_tweak (char *line, file *f)
{
symbol *sym = symbol_hash_lookup (line + 2, false);
XXX Should this use collect_execute instead of system? */
static int
-recompile_files ()
+recompile_files (void)
{
file *f;
.rpo files associated with them, and read in the information. */
static int
-read_repo_files (object_lst)
- char **object_lst;
+read_repo_files (char **object_lst)
{
char **object = object_lst;
/* Add the demangled forms of any new symbols to the hash table. */
static void
-demangle_new_symbols ()
+demangle_new_symbols (void)
{
symbol *sym;
adjust the settings for each symbol encountered. */
static int
-scan_linker_output (fname)
- const char *fname;
+scan_linker_output (const char *fname)
{
FILE *stream = fopen (fname, "r");
char *line;
to provide missing definitions. Currently ignored. */
void
-do_tlink (ld_argv, object_lst)
- char **ld_argv, **object_lst ATTRIBUTE_UNUSED;
+do_tlink (char **ld_argv, char **object_lst ATTRIBUTE_UNUSED)
{
int exit = tlink_execute ("ld", ld_argv, ldout);
#include "params.h"
#include "coverage.h"
-static int count_insns PARAMS ((basic_block));
-static bool ignore_bb_p PARAMS ((basic_block));
-static bool better_p PARAMS ((edge, edge));
-static edge find_best_successor PARAMS ((basic_block));
-static edge find_best_predecessor PARAMS ((basic_block));
-static int find_trace PARAMS ((basic_block, basic_block *));
-static void tail_duplicate PARAMS ((void));
-static void layout_superblocks PARAMS ((void));
+static int count_insns (basic_block);
+static bool ignore_bb_p (basic_block);
+static bool better_p (edge, edge);
+static edge find_best_successor (basic_block);
+static edge find_best_predecessor (basic_block);
+static int find_trace (basic_block, basic_block *);
+static void tail_duplicate (void);
+static void layout_superblocks (void);
/* Minimal outgoing edge probability considered for superblock formation. */
static int probability_cutoff;
/* Return true if we should ignore the basic block for purposes of tracing. */
static bool
-ignore_bb_p (bb)
- basic_block bb;
+ignore_bb_p (basic_block bb)
{
if (bb->index < 0)
return true;
/* Return number of instructions in the block. */
static int
-count_insns (bb)
- basic_block bb;
+count_insns (basic_block bb)
{
rtx insn;
int n = 0;
/* Return true if E1 is more frequent than E2. */
static bool
-better_p (e1, e2)
- edge e1, e2;
+better_p (edge e1, edge e2)
{
if (e1->count != e2->count)
return e1->count > e2->count;
/* Return most frequent successor of basic block BB. */
static edge
-find_best_successor (bb)
- basic_block bb;
+find_best_successor (basic_block bb)
{
edge e;
edge best = NULL;
/* Return most frequent predecessor of basic block BB. */
static edge
-find_best_predecessor (bb)
- basic_block bb;
+find_best_predecessor (basic_block bb)
{
edge e;
edge best = NULL;
Return number of basic blocks recorded. */
static int
-find_trace (bb, trace)
- basic_block bb;
- basic_block *trace;
+find_trace (basic_block bb, basic_block *trace)
{
int i = 0;
edge e;
if profitable. */
static void
-tail_duplicate ()
+tail_duplicate (void)
{
fibnode_t *blocks = xcalloc (last_basic_block, sizeof (fibnode_t));
basic_block *trace = xmalloc (sizeof (basic_block) * n_basic_blocks);
change though. */
static void
-layout_superblocks ()
+layout_superblocks (void)
{
basic_block end = ENTRY_BLOCK_PTR->succ->dest;
basic_block bb = ENTRY_BLOCK_PTR->succ->dest->next_bb;
/* Main entry point to this file. */
void
-tracer ()
+tracer (void)
{
if (n_basic_blocks <= 1)
return;
/* Prototypes. */
-static tree declare_return_variable PARAMS ((inline_data *, tree, tree *));
-static tree copy_body_r PARAMS ((tree *, int *, void *));
-static tree copy_body PARAMS ((inline_data *));
-static tree expand_call_inline PARAMS ((tree *, int *, void *));
-static void expand_calls_inline PARAMS ((tree *, inline_data *));
-static int inlinable_function_p PARAMS ((tree, inline_data *, int));
-static tree remap_decl PARAMS ((tree, inline_data *));
+static tree declare_return_variable (inline_data *, tree, tree *);
+static tree copy_body_r (tree *, int *, void *);
+static tree copy_body (inline_data *);
+static tree expand_call_inline (tree *, int *, void *);
+static void expand_calls_inline (tree *, inline_data *);
+static int inlinable_function_p (tree, inline_data *, int);
+static tree remap_decl (tree, inline_data *);
#ifndef INLINER_FOR_JAVA
-static tree initialize_inlined_parameters PARAMS ((inline_data *, tree, tree));
-static void remap_block PARAMS ((tree, tree, inline_data *));
-static void copy_scope_stmt PARAMS ((tree *, int *, inline_data *));
+static tree initialize_inlined_parameters (inline_data *, tree, tree);
+static void remap_block (tree, tree, inline_data *);
+static void copy_scope_stmt (tree *, int *, inline_data *);
#else /* INLINER_FOR_JAVA */
-static tree initialize_inlined_parameters PARAMS ((inline_data *, tree, tree, tree));
-static void remap_block PARAMS ((tree *, tree, inline_data *));
-static tree add_stmt_to_compound PARAMS ((tree, tree, tree));
+static tree initialize_inlined_parameters (inline_data *, tree, tree, tree);
+static void remap_block (tree *, tree, inline_data *);
+static tree add_stmt_to_compound (tree, tree, tree);
#endif /* INLINER_FOR_JAVA */
-static tree find_alloca_call_1 PARAMS ((tree *, int *, void *));
-static tree find_alloca_call PARAMS ((tree));
-static tree find_builtin_longjmp_call_1 PARAMS ((tree *, int *, void *));
-static tree find_builtin_longjmp_call PARAMS ((tree));
+static tree find_alloca_call_1 (tree *, int *, void *);
+static tree find_alloca_call (tree);
+static tree find_builtin_longjmp_call_1 (tree *, int *, void *);
+static tree find_builtin_longjmp_call (tree);
/* The approximate number of instructions per statement. This number
need not be particularly accurate; it is used only to make
/* Remap DECL during the copying of the BLOCK tree for the function. */
static tree
-remap_decl (decl, id)
- tree decl;
- inline_data *id;
+remap_decl (tree decl, inline_data *id)
{
splay_tree_node n;
tree fn;
static void
#ifndef INLINER_FOR_JAVA
-remap_block (scope_stmt, decls, id)
- tree scope_stmt;
+remap_block (tree scope_stmt, tree decls, inline_data *id)
#else /* INLINER_FOR_JAVA */
-remap_block (block, decls, id)
- tree *block;
+remap_block (tree *block, tree decls, inline_data *id)
#endif /* INLINER_FOR_JAVA */
- tree decls;
- inline_data *id;
{
#ifndef INLINER_FOR_JAVA
/* We cannot do this in the cleanup for a TARGET_EXPR since we do
/* Copy the SCOPE_STMT pointed to by TP. */
static void
-copy_scope_stmt (tp, walk_subtrees, id)
- tree *tp;
- int *walk_subtrees;
- inline_data *id;
+copy_scope_stmt (tree *tp, int *walk_subtrees, inline_data *id)
{
tree block;
/* Called from copy_body via walk_tree. DATA is really an
`inline_data *'. */
static tree
-copy_body_r (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data;
+copy_body_r (tree *tp, int *walk_subtrees, void *data)
{
inline_data* id;
tree fn;
another function. */
static tree
-copy_body (id)
- inline_data *id;
+copy_body (inline_data *id)
{
tree body;
static tree
#ifndef INLINER_FOR_JAVA
-initialize_inlined_parameters (id, args, fn)
+initialize_inlined_parameters (inline_data *id, tree args, tree fn)
#else /* INLINER_FOR_JAVA */
-initialize_inlined_parameters (id, args, fn, block)
-#endif /* INLINER_FOR_JAVA */
- inline_data *id;
- tree args;
- tree fn;
-#ifdef INLINER_FOR_JAVA
- tree block;
+initialize_inlined_parameters (inline_data *id, tree args, tree fn, tree block)
#endif /* INLINER_FOR_JAVA */
{
tree init_stmts;
#ifndef INLINER_FOR_JAVA
static tree
-declare_return_variable (id, return_slot_addr, use_stmt)
- struct inline_data *id;
- tree return_slot_addr;
- tree *use_stmt;
+declare_return_variable (struct inline_data *id, tree return_slot_addr,
+ tree *use_stmt)
#else /* INLINER_FOR_JAVA */
static tree
-declare_return_variable (id, return_slot_addr, var)
- struct inline_data *id;
- tree return_slot_addr;
- tree *var;
+declare_return_variable (struct inline_data *id, tree return_slot_addr,
+ tree *var)
#endif /* INLINER_FOR_JAVA */
{
tree fn = VARRAY_TOP_TREE (id->fns);
/* Returns nonzero if a function can be inlined as a tree. */
int
-tree_inlinable_function_p (fn, nolimit)
- tree fn;
- int nolimit;
+tree_inlinable_function_p (tree fn, int nolimit)
{
return inlinable_function_p (fn, NULL, nolimit);
}
/* If *TP is possibly call to alloca, return nonzero. */
static tree
-find_alloca_call_1 (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+find_alloca_call_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
if (alloca_call_p (*tp))
return *tp;
/* Return subexpression representing possible alloca call, if any. */
static tree
-find_alloca_call (exp)
- tree exp;
+find_alloca_call (tree exp)
{
location_t saved_loc = input_location;
tree ret = walk_tree (&exp, find_alloca_call_1, NULL, NULL);
}
static tree
-find_builtin_longjmp_call_1 (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+find_builtin_longjmp_call_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
tree exp = *tp, decl;
}
static tree
-find_builtin_longjmp_call (exp)
- tree exp;
+find_builtin_longjmp_call (tree exp)
{
location_t saved_loc = input_location;
tree ret = walk_tree (&exp, find_builtin_longjmp_call_1, NULL, NULL);
can be inlined at all. */
static int
-inlinable_function_p (fn, id, nolimit)
- tree fn;
- inline_data *id;
- int nolimit;
+inlinable_function_p (tree fn, inline_data *id, int nolimit)
{
int inlinable;
int currfn_insns;
inlined. (It is important that this hook be called early because
in C++ it may result in template instantiation.) */
inlinable = !(*lang_hooks.tree_inlining.cannot_inline_tree_fn) (&fn);
-
+
/* We may be here either because fn is declared inline or because
we use -finline-functions. For the second case, we are more
restrictive. */
if (DID_INLINE_FUNC (fn))
max_inline_insns_single = MAX_INLINE_INSNS_AUTO;
-
+
/* The number of instructions (estimated) of current function. */
currfn_insns = DECL_NUM_STMTS (fn) * INSNS_PER_STMT;
/* If *TP is a CALL_EXPR, replace it with its inline expansion. */
static tree
-expand_call_inline (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data;
+expand_call_inline (tree *tp, int *walk_subtrees, void *data)
{
inline_data *id;
tree t;
*walk_subtrees = 0;
/* Update the source position. */
push_srcloc (EXPR_WFL_FILENAME (t), EXPR_WFL_LINENO (t));
- walk_tree (&EXPR_WFL_NODE (t), expand_call_inline, data,
+ walk_tree (&EXPR_WFL_NODE (t), expand_call_inline, data,
id->tree_pruner);
/* Restore the original source position. */
pop_srcloc ();
expansions as appropriate. */
static void
-expand_calls_inline (tp, id)
- tree *tp;
- inline_data *id;
+expand_calls_inline (tree *tp, inline_data *id)
{
/* Search through *TP, replacing all calls to inline functions by
appropriate equivalents. Use walk_tree in no-duplicates mode
/* Expand calls to inline functions in the body of FN. */
void
-optimize_inline_calls (fn)
- tree fn;
+optimize_inline_calls (tree fn)
{
inline_data id;
tree prev_fn;
declarations according to the ARG_MAP splay_tree. */
void
-clone_body (clone, fn, arg_map)
- tree clone, fn;
- void *arg_map;
+clone_body (tree clone, tree fn, void *arg_map)
{
inline_data id;
once. */
tree
-walk_tree (tp, func, data, htab_)
- tree *tp;
- walk_tree_fn func;
- void *data;
- void *htab_;
+walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
{
htab_t htab = (htab_t) htab_;
enum tree_code code;
once. */
tree
-walk_tree_without_duplicates (tp, func, data)
- tree *tp;
- walk_tree_fn func;
- void *data;
+walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
{
tree result;
htab_t htab;
/* Passed to walk_tree. Copies the node pointed to, if appropriate. */
tree
-copy_tree_r (tp, walk_subtrees, data)
- tree *tp;
- int *walk_subtrees;
- void *data ATTRIBUTE_UNUSED;
+copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{
enum tree_code code = TREE_CODE (*tp);
ST. FN is the function into which the copy will be placed. */
void
-remap_save_expr (tp, st_, fn, walk_subtrees)
- tree *tp;
- void *st_;
- tree fn;
- int *walk_subtrees;
+remap_save_expr (tree *tp, void *st_, tree fn, int *walk_subtrees)
{
splay_tree st = (splay_tree) st_;
splay_tree_node n;
COMPOUND_EXPR and add STMT to it. */
static tree
-add_stmt_to_compound (existing, type, stmt)
- tree existing, type, stmt;
+add_stmt_to_compound (tree existing, tree type, tree stmt)
{
if (!stmt)
return existing;
/* Tree inlining hooks and declarations.
- Copyright 2001 Free Software Foundation, Inc.
+ Copyright 2001, 2003 Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
This file is part of GCC.
/* Function prototypes. */
-void optimize_inline_calls PARAMS ((tree));
-int tree_inlinable_function_p PARAMS ((tree, int));
-tree walk_tree PARAMS ((tree*, walk_tree_fn, void*, void*));
-tree walk_tree_without_duplicates PARAMS ((tree*, walk_tree_fn, void*));
-tree copy_tree_r PARAMS ((tree*, int*, void*));
-void clone_body PARAMS ((tree, tree, void*));
-void remap_save_expr PARAMS ((tree*, void*, tree, int*));
+void optimize_inline_calls (tree);
+int tree_inlinable_function_p (tree, int);
+tree walk_tree (tree*, walk_tree_fn, void*, void*);
+tree walk_tree_without_duplicates (tree*, walk_tree_fn, void*);
+tree copy_tree_r (tree*, int*, void*);
+void clone_body (tree, tree, void*);
+void remap_save_expr (tree*, void*, tree, int*);
/* 0 if we should not perform inlining.
1 if we should expand functions calls inline at the tree level.
#include "langhooks.h"
/* obstack.[ch] explicitly declined to prototype this. */
-extern int _obstack_allocated_p PARAMS ((struct obstack *h, void *obj));
+extern int _obstack_allocated_p (struct obstack *h, void *obj);
#ifdef GATHER_STATISTICS
/* Statistics-gathering stuff. */
static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
htab_t type_hash_table;
-static void set_type_quals PARAMS ((tree, int));
-static void append_random_chars PARAMS ((char *));
-static int type_hash_eq PARAMS ((const void *, const void *));
-static hashval_t type_hash_hash PARAMS ((const void *));
-static void print_type_hash_statistics PARAMS((void));
-static void finish_vector_type PARAMS((tree));
-static tree make_vector PARAMS ((enum machine_mode, tree, int));
-static int type_hash_marked_p PARAMS ((const void *));
+static void set_type_quals (tree, int);
+static void append_random_chars (char *);
+static int type_hash_eq (const void *, const void *);
+static hashval_t type_hash_hash (const void *);
+static void print_type_hash_statistics (void);
+static void finish_vector_type (tree);
+static tree make_vector (enum machine_mode, tree, int);
+static int type_hash_marked_p (const void *);
tree global_trees[TI_MAX];
tree integer_types[itk_none];
/* Init tree.c. */
void
-init_ttree ()
+init_ttree (void)
{
/* Initialize the hash table of types. */
type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
translations made by ASM_OUTPUT_LABELREF). Often this is the same
as DECL_NAME. It is an IDENTIFIER_NODE. */
tree
-decl_assembler_name (decl)
- tree decl;
+decl_assembler_name (tree decl)
{
if (!DECL_ASSEMBLER_NAME_SET_P (decl))
(*lang_hooks.set_decl_assembler_name) (decl);
/* Compute the number of bytes occupied by 'node'. This routine only
looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
size_t
-tree_size (node)
- tree node;
+tree_size (tree node)
{
enum tree_code code = TREE_CODE (node);
Achoo! I got a code in the node. */
tree
-make_node (code)
- enum tree_code code;
+make_node (enum tree_code code)
{
tree t;
int type = TREE_CODE_CLASS (code);
TREE_CHAIN is zero and it has a fresh uid. */
tree
-copy_node (node)
- tree node;
+copy_node (tree node)
{
tree t;
enum tree_code code = TREE_CODE (node);
For example, this can copy a list made of TREE_LIST nodes. */
tree
-copy_list (list)
- tree list;
+copy_list (tree list)
{
tree head;
tree prev, next;
This function should be used via the `build_int_2' macro. */
tree
-build_int_2_wide (low, hi)
- unsigned HOST_WIDE_INT low;
- HOST_WIDE_INT hi;
+build_int_2_wide (unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
{
tree t = make_node (INTEGER_CST);
are in a list pointed by VALS. */
tree
-build_vector (type, vals)
- tree type, vals;
+build_vector (tree type, tree vals)
{
tree v = make_node (VECTOR_CST);
int over1 = 0, over2 = 0;
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
are in a list pointed to by VALS. */
tree
-build_constructor (type, vals)
- tree type, vals;
+build_constructor (tree type, tree vals)
{
tree c = make_node (CONSTRUCTOR);
TREE_TYPE (c) = type;
/* Return a new REAL_CST node whose type is TYPE and value is D. */
tree
-build_real (type, d)
- tree type;
- REAL_VALUE_TYPE d;
+build_real (tree type, REAL_VALUE_TYPE d)
{
tree v;
REAL_VALUE_TYPE *dp;
and whose value is the integer value of the INTEGER_CST node I. */
REAL_VALUE_TYPE
-real_value_from_int_cst (type, i)
- tree type ATTRIBUTE_UNUSED, i;
+real_value_from_int_cst (tree type ATTRIBUTE_UNUSED, tree i)
{
REAL_VALUE_TYPE d;
representing the same value as a floating-point constant of type TYPE. */
tree
-build_real_from_int_cst (type, i)
- tree type;
- tree i;
+build_real_from_int_cst (tree type, tree i)
{
tree v;
int overflow = TREE_OVERFLOW (i);
The TREE_TYPE is not initialized. */
tree
-build_string (len, str)
- int len;
- const char *str;
+build_string (int len, const char *str)
{
tree s = make_node (STRING_CST);
will be the type of the COMPLEX_CST; otherwise a new type will be made. */
tree
-build_complex (type, real, imag)
- tree type;
- tree real, imag;
+build_complex (tree type, tree real, tree imag)
{
tree t = make_node (COMPLEX_CST);
/* Build a newly constructed TREE_VEC node of length LEN. */
tree
-make_tree_vec (len)
- int len;
+make_tree_vec (int len)
{
tree t;
int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
of zero. */
int
-integer_zerop (expr)
- tree expr;
+integer_zerop (tree expr)
{
STRIP_NOPS (expr);
complex constant. */
int
-integer_onep (expr)
- tree expr;
+integer_onep (tree expr)
{
STRIP_NOPS (expr);
it contains. Likewise for the corresponding complex constant. */
int
-integer_all_onesp (expr)
- tree expr;
+integer_all_onesp (tree expr)
{
int prec;
int uns;
one bit on). */
int
-integer_pow2p (expr)
- tree expr;
+integer_pow2p (tree expr)
{
int prec;
HOST_WIDE_INT high, low;
complex constant other than zero. */
int
-integer_nonzerop (expr)
- tree expr;
+integer_nonzerop (tree expr)
{
STRIP_NOPS (expr);
power of two. */
int
-tree_log2 (expr)
- tree expr;
+tree_log2 (tree expr)
{
int prec;
HOST_WIDE_INT high, low;
than or equal to EXPR. */
int
-tree_floor_log2 (expr)
- tree expr;
+tree_floor_log2 (tree expr)
{
int prec;
HOST_WIDE_INT high, low;
/* Return 1 if EXPR is the real constant zero. */
int
-real_zerop (expr)
- tree expr;
+real_zerop (tree expr)
{
STRIP_NOPS (expr);
/* Return 1 if EXPR is the real constant one in real or complex form. */
int
-real_onep (expr)
- tree expr;
+real_onep (tree expr)
{
STRIP_NOPS (expr);
/* Return 1 if EXPR is the real constant two. */
int
-real_twop (expr)
- tree expr;
+real_twop (tree expr)
{
STRIP_NOPS (expr);
/* Return 1 if EXPR is the real constant minus one. */
int
-real_minus_onep (expr)
- tree expr;
+real_minus_onep (tree expr)
{
STRIP_NOPS (expr);
/* Nonzero if EXP is a constant or a cast of a constant. */
int
-really_constant_p (exp)
- tree exp;
+really_constant_p (tree exp)
{
/* This is not quite the same as STRIP_NOPS. It does more. */
while (TREE_CODE (exp) == NOP_EXPR
Return 0 if ELEM is not in LIST. */
tree
-value_member (elem, list)
- tree elem, list;
+value_member (tree elem, tree list)
{
while (list)
{
Return 0 if ELEM is not in LIST. */
tree
-purpose_member (elem, list)
- tree elem, list;
+purpose_member (tree elem, tree list)
{
while (list)
{
Return 0 if ELEM is not in LIST. */
tree
-binfo_member (elem, list)
- tree elem, list;
+binfo_member (tree elem, tree list)
{
while (list)
{
/* Return nonzero if ELEM is part of the chain CHAIN. */
int
-chain_member (elem, chain)
- tree elem, chain;
+chain_member (tree elem, tree chain)
{
while (chain)
{
This is the Lisp primitive `length'. */
int
-list_length (t)
- tree t;
+list_length (tree t)
{
tree tail;
int len = 0;
/* Returns the number of FIELD_DECLs in TYPE. */
int
-fields_length (type)
- tree type;
+fields_length (tree type)
{
tree t = TYPE_FIELDS (type);
int count = 0;
This is the Lisp primitive `nconc'. */
tree
-chainon (op1, op2)
- tree op1, op2;
+chainon (tree op1, tree op2)
{
tree t1;
/* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
tree
-tree_last (chain)
- tree chain;
+tree_last (tree chain)
{
tree next;
if (chain)
and return the new head of the chain (old last element). */
tree
-nreverse (t)
- tree t;
+nreverse (tree t)
{
tree prev = 0, decl, next;
for (decl = t; decl; decl = next)
purpose and value fields are PARM and VALUE. */
tree
-build_tree_list (parm, value)
- tree parm, value;
+build_tree_list (tree parm, tree value)
{
tree t = make_node (TREE_LIST);
TREE_PURPOSE (t) = parm;
and whose TREE_CHAIN is CHAIN. */
tree
-tree_cons (purpose, value, chain)
- tree purpose, value, chain;
+tree_cons (tree purpose, tree value, tree chain)
{
tree node;
expr_length (tree expr)
{
int len = 0;
-
+
if (expr == NULL_TREE)
return 0;
for (; TREE_CODE (expr) == COMPOUND_EXPR; expr = TREE_OPERAND (expr, 1))
make_unsigned_type). */
tree
-size_in_bytes (type)
- tree type;
+size_in_bytes (tree type)
{
tree t;
or return -1 if the size can vary or is larger than an integer. */
HOST_WIDE_INT
-int_size_in_bytes (type)
- tree type;
+int_size_in_bytes (tree type)
{
tree t;
This is a tree of type bitsizetype. */
tree
-bit_position (field)
- tree field;
+bit_position (tree field)
{
return bit_from_pos (DECL_FIELD_OFFSET (field),
DECL_FIELD_BIT_OFFSET (field));
of returning -1 like int_size_in_byte can. */
HOST_WIDE_INT
-int_bit_position (field)
- tree field;
+int_bit_position (tree field)
{
return tree_low_cst (bit_position (field), 0);
}
This is a tree of type sizetype. */
tree
-byte_position (field)
- tree field;
+byte_position (tree field)
{
return byte_from_pos (DECL_FIELD_OFFSET (field),
DECL_FIELD_BIT_OFFSET (field));
of returning -1 like int_size_in_byte can. */
HOST_WIDE_INT
-int_byte_position (field)
- tree field;
+int_byte_position (tree field)
{
return tree_low_cst (byte_position (field), 0);
}
/* Return the strictest alignment, in bits, that T is known to have. */
unsigned int
-expr_align (t)
- tree t;
+expr_align (tree t)
{
unsigned int align0, align1;
ARRAY_TYPE) minus one. This counts only elements of the top array. */
tree
-array_type_nelts (type)
- tree type;
+array_type_nelts (tree type)
{
tree index_type, min, max;
static storage. This is not the same as the C meaning of `static'. */
int
-staticp (arg)
- tree arg;
+staticp (tree arg)
{
switch (TREE_CODE (arg))
{
are used for. */
tree
-save_expr (expr)
- tree expr;
+save_expr (tree expr)
{
tree t = fold (expr);
tree inner;
the innermost non-arithmetic node. */
tree
-skip_simple_arithmetic (expr)
- tree expr;
+skip_simple_arithmetic (tree expr)
{
tree inner;
-
+
/* We don't care about whether this can be used as an lvalue in this
context. */
while (TREE_CODE (expr) == NON_LVALUE_EXPR)
SAVE_EXPR. Return FALSE otherwise. */
bool
-saved_expr_p (expr)
- tree expr;
+saved_expr_p (tree expr)
{
return TREE_CODE (skip_simple_arithmetic (expr)) == SAVE_EXPR;
}
expand them multiple times in different places. */
tree
-unsave_expr (expr)
- tree expr;
+unsave_expr (tree expr)
{
tree t;
of operands if all are trees. */
int
-first_rtl_op (code)
- enum tree_code code;
+first_rtl_op (enum tree_code code)
{
switch (code)
{
/* Return which tree structure is used by T. */
enum tree_node_structure_enum
-tree_node_structure (t)
- tree t;
+tree_node_structure (tree t)
{
enum tree_code code = TREE_CODE (t);
-
+
switch (TREE_CODE_CLASS (code))
{
case 'd': return TS_DECL;
case 't': return TS_TYPE;
case 'b': return TS_BLOCK;
- case 'r': case '<': case '1': case '2': case 'e': case 's':
+ case 'r': case '<': case '1': case '2': case 'e': case 's':
return TS_EXP;
default: /* 'c' and 'x' */
break;
not recurse into EXPR's subtrees. */
void
-unsave_expr_1 (expr)
- tree expr;
+unsave_expr_1 (tree expr)
{
switch (TREE_CODE (expr))
{
/* Default lang hook for "unsave_expr_now". */
tree
-lhd_unsave_expr_now (expr)
- tree expr;
+lhd_unsave_expr_now (tree expr)
{
enum tree_code code;
never possible to unsave them. */
int
-unsafe_for_reeval (expr)
- tree expr;
+unsafe_for_reeval (tree expr)
{
int unsafeness = 0;
enum tree_code code;
or offset that depends on a field within a record. */
bool
-contains_placeholder_p (exp)
- tree exp;
+contains_placeholder_p (tree exp)
{
enum tree_code code;
int result;
positions. */
bool
-type_contains_placeholder_p (type)
- tree type;
+type_contains_placeholder_p (tree type)
{
/* If the size contains a placeholder or the parent type (component type in
the case of arrays) type involves a placeholder, this type does. */
outer scope to deal with. Used by fold. */
int
-has_cleanups (exp)
- tree exp;
+has_cleanups (tree exp)
{
int i, nops, cmp;
PLACEHOLDER_EXPR occurring only in its arglist. */
tree
-substitute_in_expr (exp, f, r)
- tree exp;
- tree f;
- tree r;
+substitute_in_expr (tree exp, tree f, tree r)
{
enum tree_code code = TREE_CODE (exp);
tree op0, op1, op2;
Any other kind of expression is returned unchanged. */
tree
-stabilize_reference (ref)
- tree ref;
+stabilize_reference (tree ref)
{
tree result;
enum tree_code code = TREE_CODE (ref);
multiple utterances of the same expression should that prove fruitful. */
tree
-stabilize_reference_1 (e)
- tree e;
+stabilize_reference_1 (tree e)
{
tree result;
enum tree_code code = TREE_CODE (e);
of varargs, which is expensive for RISC machines. */
tree
-build1 (code, type, node)
- enum tree_code code;
- tree type;
- tree node;
+build1 (enum tree_code code, tree type, tree node)
{
int length = sizeof (struct tree_exp);
#ifdef GATHER_STATISTICS
Other slots are initialized to 0 or null pointers. */
tree
-build_decl (code, name, type)
- enum tree_code code;
- tree name, type;
+build_decl (enum tree_code code, tree name, tree type)
{
tree t;
compiled. This information is used for outputting debugging info. */
tree
-build_block (vars, tags, subblocks, supercontext, chain)
- tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
+build_block (tree vars, tree tags ATTRIBUTE_UNUSED, tree subblocks,
+ tree supercontext, tree chain)
{
tree block = make_node (BLOCK);
recursively more than one file (Java is one of them). */
tree
-build_expr_wfl (node, file, line, col)
- tree node;
- const char *file;
- int line, col;
+build_expr_wfl (tree node, const char *file, int line, int col)
{
static const char *last_file = 0;
static tree last_filenode = NULL_TREE;
is ATTRIBUTE. */
tree
-build_decl_attribute_variant (ddecl, attribute)
- tree ddecl, attribute;
+build_decl_attribute_variant (tree ddecl, tree attribute)
{
DECL_ATTRIBUTES (ddecl) = attribute;
return ddecl;
Record such modified types already made so we don't make duplicates. */
tree
-build_type_attribute_variant (ttype, attribute)
- tree ttype, attribute;
+build_type_attribute_variant (tree ttype, tree attribute)
{
if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
{
their canonicalized form. */
int
-is_attribute_p (attr, ident)
- const char *attr;
- tree ident;
+is_attribute_p (const char *attr, tree ident)
{
int ident_len, attr_len;
const char *p;
be passed back in if further occurrences are wanted. */
tree
-lookup_attribute (attr_name, list)
- const char *attr_name;
- tree list;
+lookup_attribute (const char *attr_name, tree list)
{
tree l;
/* Return an attribute list that is the union of a1 and a2. */
tree
-merge_attributes (a1, a2)
- tree a1, a2;
+merge_attributes (tree a1, tree a2)
{
tree attributes;
the result. */
tree
-merge_type_attributes (t1, t2)
- tree t1, t2;
+merge_type_attributes (tree t1, tree t2)
{
return merge_attributes (TYPE_ATTRIBUTES (t1),
TYPE_ATTRIBUTES (t2));
the result. */
tree
-merge_decl_attributes (olddecl, newdecl)
- tree olddecl, newdecl;
+merge_decl_attributes (tree olddecl, tree newdecl)
{
return merge_attributes (DECL_ATTRIBUTES (olddecl),
DECL_ATTRIBUTES (newdecl));
The second instance of `foo' nullifies the dllimport. */
tree
-merge_dllimport_decl_attributes (old, new)
- tree old;
- tree new;
+merge_dllimport_decl_attributes (tree old, tree new)
{
tree a;
int delete_dllimport_p;
of the various TYPE_QUAL values. */
static void
-set_type_quals (type, type_quals)
- tree type;
- int type_quals;
+set_type_quals (tree type, int type_quals)
{
TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
return NULL_TREE. */
tree
-get_qualified_type (type, type_quals)
- tree type;
- int type_quals;
+get_qualified_type (tree type, int type_quals)
{
tree t;
exist. This function never returns NULL_TREE. */
tree
-build_qualified_type (type, type_quals)
- tree type;
- int type_quals;
+build_qualified_type (tree type, int type_quals)
{
tree t;
This is so the caller can modify it. */
tree
-build_type_copy (type)
- tree type;
+build_type_copy (tree type)
{
tree t, m = TYPE_MAIN_VARIANT (type);
of the individual types. */
unsigned int
-type_hash_list (list)
- tree list;
+type_hash_list (tree list)
{
unsigned int hashcode;
tree tail;
/* Returns true if the types are equal. */
static int
-type_hash_eq (va, vb)
- const void *va;
- const void *vb;
+type_hash_eq (const void *va, const void *vb)
{
const struct type_hash *a = va, *b = vb;
if (a->hash == b->hash
/* Return the cached hash value. */
static hashval_t
-type_hash_hash (item)
- const void *item;
+type_hash_hash (const void *item)
{
return ((const struct type_hash *) item)->hash;
}
If one is found, return it. Otherwise return 0. */
tree
-type_hash_lookup (hashcode, type)
- unsigned int hashcode;
- tree type;
+type_hash_lookup (unsigned int hashcode, tree type)
{
struct type_hash *h, in;
for a type TYPE whose hash code is HASHCODE. */
void
-type_hash_add (hashcode, type)
- unsigned int hashcode;
- tree type;
+type_hash_add (unsigned int hashcode, tree type)
{
struct type_hash *h;
void **loc;
int debug_no_type_hash = 0;
tree
-type_hash_canon (hashcode, type)
- unsigned int hashcode;
- tree type;
+type_hash_canon (unsigned int hashcode, tree type)
{
tree t1;
the number of garbage collections. */
static int
-type_hash_marked_p (p)
- const void *p;
+type_hash_marked_p (const void *p)
{
tree type = ((struct type_hash *) p)->type;
}
static void
-print_type_hash_statistics ()
+print_type_hash_statistics (void)
{
fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
(long) htab_size (type_hash_table),
by adding the hash codes of the individual attributes. */
unsigned int
-attribute_hash_list (list)
- tree list;
+attribute_hash_list (tree list)
{
unsigned int hashcode;
tree tail;
equivalent to l1. */
int
-attribute_list_equal (l1, l2)
- tree l1, l2;
+attribute_list_equal (tree l1, tree l2)
{
return attribute_list_contained (l1, l2)
&& attribute_list_contained (l2, l1);
correctly. */
int
-attribute_list_contained (l1, l2)
- tree l1, l2;
+attribute_list_contained (tree l1, tree l2)
{
tree t1, t2;
Also, the TREE_PURPOSEs must match. */
int
-type_list_equal (l1, l2)
- tree l1, l2;
+type_list_equal (tree l1, tree l2)
{
tree t1, t2;
then this function counts only the ordinary arguments. */
int
-type_num_arguments (type)
- tree type;
+type_num_arguments (tree type)
{
int i = 0;
tree t;
represent the same constant value. */
int
-tree_int_cst_equal (t1, t2)
- tree t1, t2;
+tree_int_cst_equal (tree t1, tree t2)
{
if (t1 == t2)
return 1;
The precise way of comparison depends on their data type. */
int
-tree_int_cst_lt (t1, t2)
- tree t1, t2;
+tree_int_cst_lt (tree t1, tree t2)
{
if (t1 == t2)
return 0;
/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
int
-tree_int_cst_compare (t1, t2)
- tree t1;
- tree t2;
+tree_int_cst_compare (tree t1, tree t2)
{
if (tree_int_cst_lt (t1, t2))
return -1;
be represented in a single unsigned HOST_WIDE_INT. */
int
-host_integerp (t, pos)
- tree t;
- int pos;
+host_integerp (tree t, int pos)
{
return (TREE_CODE (t) == INTEGER_CST
&& ! TREE_OVERFLOW (t)
be positive. Abort if we cannot satisfy the above conditions. */
HOST_WIDE_INT
-tree_low_cst (t, pos)
- tree t;
- int pos;
+tree_low_cst (tree t, int pos)
{
if (host_integerp (t, pos))
return TREE_INT_CST_LOW (t);
/* Return the most significant bit of the integer constant T. */
int
-tree_int_cst_msb (t)
- tree t;
+tree_int_cst_msb (tree t)
{
int prec;
HOST_WIDE_INT h;
Note that -1 will never be returned it T's type is unsigned. */
int
-tree_int_cst_sgn (t)
- tree t;
+tree_int_cst_sgn (tree t)
{
if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
return 0;
are known to be equal; otherwise return 0. */
int
-simple_cst_list_equal (l1, l2)
- tree l1, l2;
+simple_cst_list_equal (tree l1, tree l2)
{
while (l1 != NULL_TREE && l2 != NULL_TREE)
{
this function. */
int
-simple_cst_equal (t1, t2)
- tree t1, t2;
+simple_cst_equal (tree t1, tree t2)
{
enum tree_code code1, code2;
int cmp;
than U, respectively. */
int
-compare_tree_int (t, u)
- tree t;
- unsigned HOST_WIDE_INT u;
+compare_tree_int (tree t, unsigned HOST_WIDE_INT u)
{
if (tree_int_cst_sgn (t) < 0)
return -1;
reuse it. */
tree
-build_pointer_type_for_mode (to_type, mode)
- tree to_type;
- enum machine_mode mode;
+build_pointer_type_for_mode (tree to_type, enum machine_mode mode)
{
tree t = TYPE_POINTER_TO (to_type);
/* By default build pointers in ptr_mode. */
tree
-build_pointer_type (to_type)
- tree to_type;
+build_pointer_type (tree to_type)
{
return build_pointer_type_for_mode (to_type, ptr_mode);
}
reuse it. */
tree
-build_reference_type_for_mode (to_type, mode)
- tree to_type;
- enum machine_mode mode;
+build_reference_type_for_mode (tree to_type, enum machine_mode mode)
{
tree t = TYPE_REFERENCE_TO (to_type);
in ptr_mode. */
tree
-build_reference_type (to_type)
- tree to_type;
+build_reference_type (tree to_type)
{
return build_reference_type_for_mode (to_type, ptr_mode);
}
const char *const *const * -> char ***. */
tree
-build_type_no_quals (t)
- tree t;
+build_type_no_quals (tree t)
{
switch (TREE_CODE (t))
{
sizes that use more than one HOST_WIDE_INT. */
tree
-build_index_type (maxval)
- tree maxval;
+build_index_type (tree maxval)
{
tree itype = make_node (INTEGER_TYPE);
if TYPE==NULL_TREE, sizetype is used. */
tree
-build_range_type (type, lowval, highval)
- tree type, lowval, highval;
+build_range_type (tree type, tree lowval, tree highval)
{
tree itype = make_node (INTEGER_TYPE);
of just highval (maxval). */
tree
-build_index_2_type (lowval, highval)
- tree lowval, highval;
+build_index_2_type (tree lowval, tree highval)
{
return build_range_type (sizetype, lowval, highval);
}
If such a type has already been constructed, reuse it. */
tree
-build_array_type (elt_type, index_type)
- tree elt_type, index_type;
+build_array_type (tree elt_type, tree index_type)
{
tree t;
unsigned int hashcode;
the innermost dimension of ARRAY. */
tree
-get_inner_array_type (array)
- tree array;
+get_inner_array_type (tree array)
{
tree type = TREE_TYPE (array);
If such a type has already been constructed, reuse it. */
tree
-build_function_type (value_type, arg_types)
- tree value_type, arg_types;
+build_function_type (tree value_type, tree arg_types)
{
tree t;
unsigned int hashcode;
TYPE must be a FUNCTION_TYPE node. */
tree
-build_method_type (basetype, type)
- tree basetype, type;
+build_method_type (tree basetype, tree type)
{
tree t;
unsigned int hashcode;
If a suitable offset type exists already, reuse it. */
tree
-build_offset_type (basetype, type)
- tree basetype, type;
+build_offset_type (tree basetype, tree type)
{
tree t;
unsigned int hashcode;
/* Create a complex type whose components are COMPONENT_TYPE. */
tree
-build_complex_type (component_type)
- tree component_type;
+build_complex_type (tree component_type)
{
tree t;
unsigned int hashcode;
is different from (int) OP. */
tree
-get_unwidened (op, for_type)
- tree op;
- tree for_type;
+get_unwidened (tree op, tree for_type)
{
/* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
tree type = TREE_TYPE (op);
or 0 if the value should be sign-extended. */
tree
-get_narrower (op, unsignedp_ptr)
- tree op;
- int *unsignedp_ptr;
+get_narrower (tree op, int *unsignedp_ptr)
{
int uns = 0;
int first = 1;
for type TYPE (an INTEGER_TYPE). */
int
-int_fits_type_p (c, type)
- tree c, type;
+int_fits_type_p (tree c, tree type)
{
tree type_low_bound = TYPE_MIN_VALUE (type);
tree type_high_bound = TYPE_MAX_VALUE (type);
int ok_for_low_bound, ok_for_high_bound;
-
+
/* Perform some generic filtering first, which may allow making a decision
even if the bounds are not constant. First, negative integers never fit
in unsigned types, */
if ((TREE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0)
/* Also, unsigned integers with top bit set never fit signed types. */
- || (! TREE_UNSIGNED (type)
+ || (! TREE_UNSIGNED (type)
&& TREE_UNSIGNED (TREE_TYPE (c)) && tree_int_cst_msb (c)))
return 0;
ok_for_low_bound = -1;
ok_for_high_bound = -1;
-
+
/* Check if C >= type_low_bound. */
if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
{
can check ourselves here. Look at the base type if we have one. */
else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0)
return int_fits_type_p (c, TREE_TYPE (type));
-
+
/* Or to force_fit_type, if nothing else. */
else
{
modified types': in C99, a struct type is never variably modified
because a VLA may not appear as a structure member. However, in
GNU C code like:
-
+
struct S { int i[f()]; };
is valid, and other languages may define similar constructs. */
bool
-variably_modified_type_p (type)
- tree type;
+variably_modified_type_p (tree type)
{
if (type == error_mark_node)
return false;
- /* If TYPE itself has variable size, it is variably modified.
+ /* If TYPE itself has variable size, it is variably modified.
We do not yet have a representation of the C99 '[*]' syntax.
When a representation is chosen, this function should be modified
to test for that case as well. */
- if (TYPE_SIZE (type)
+ if (TYPE_SIZE (type)
&& TYPE_SIZE (type) != error_mark_node
&& TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
return true;
- /* If TYPE is a pointer or reference, it is variably modified if
+ /* If TYPE is a pointer or reference, it is variably modified if
the type pointed to is variably modified. */
if ((TREE_CODE (type) == POINTER_TYPE
|| TREE_CODE (type) == REFERENCE_TYPE)
&& variably_modified_type_p (TREE_TYPE (type)))
return true;
-
+
/* If TYPE is an array, it is variably modified if the array
elements are. (Note that the VLA case has already been checked
above.) */
if (variably_modified_type_p (TREE_TYPE (type)))
return true;
- for (parm = TYPE_ARG_TYPES (type);
- parm && parm != void_list_node;
+ for (parm = TYPE_ARG_TYPES (type);
+ parm && parm != void_list_node;
parm = TREE_CHAIN (parm))
if (variably_modified_type_p (TREE_VALUE (parm)))
return true;
NULL_TREE if there is no containing scope. */
tree
-get_containing_scope (t)
- tree t;
+get_containing_scope (tree t)
{
return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
}
a FUNCTION_DECL, or zero if none. */
tree
-decl_function_context (decl)
- tree decl;
+decl_function_context (tree decl)
{
tree context;
TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
tree
-decl_type_context (decl)
- tree decl;
+decl_type_context (tree decl)
{
tree context = DECL_CONTEXT (decl);
determined. */
tree
-get_callee_fndecl (call)
- tree call;
+get_callee_fndecl (tree call)
{
tree addr;
and any language-specific information. */
void
-dump_tree_statistics ()
+dump_tree_statistics (void)
{
#ifdef GATHER_STATISTICS
int i;
{
unsigned HOST_WIDE_INT value;
char *new_random_seed;
-
+
if (flag_random_seed != NULL)
return;
#ifdef HAVE_GETTIMEOFDAY
{
struct timeval tv;
-
+
gettimeofday (&tv, NULL);
- value = (((unsigned HOST_WIDE_INT) tv.tv_usec << 16)
+ value = (((unsigned HOST_WIDE_INT) tv.tv_usec << 16)
^ tv.tv_sec ^ getpid ());
}
#else
Derived from mkstemp.c in libiberty. */
static void
-append_random_chars (template)
- char *template;
+append_random_chars (char *template)
{
static const char letters[]
= "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
default_flag_random_seed ();
- /* This isn't a very good hash, but it does guarantee no collisions
+ /* This isn't a very good hash, but it does guarantee no collisions
when the random string is generated by the code above and the time
delta is small. */
v = 0;
that are not valid in that context. */
void
-clean_symbol_name (p)
- char *p;
+clean_symbol_name (char *p)
{
for (; *p; p++)
if (! (ISALNUM (*p)
linker or collect2. */
tree
-get_file_function_name_long (type)
- const char *type;
+get_file_function_name_long (const char *type)
{
char *buf;
const char *p;
If KIND=='D', return a suitable global clean-up (destructor) name. */
tree
-get_file_function_name (kind)
- int kind;
+get_file_function_name (int kind)
{
char p[2];
Otherwise, a TREE_LIST of the non-constant elements is emitted. */
tree
-get_set_constructor_bits (init, buffer, bit_size)
- tree init;
- char *buffer;
- int bit_size;
+get_set_constructor_bits (tree init, char *buffer, int bit_size)
{
int i;
tree vals;
Otherwise, a TREE_LIST of the non-constant elements is emitted. */
tree
-get_set_constructor_bytes (init, buffer, wd_size)
- tree init;
- unsigned char *buffer;
- int wd_size;
+get_set_constructor_bytes (tree init, unsigned char *buffer, int wd_size)
{
int i;
int set_word_size = BITS_PER_UNIT;
FILE, LINE, and FUNCTION are of the caller. */
void
-tree_check_failed (node, code, file, line, function)
- const tree node;
- enum tree_code code;
- const char *file;
- int line;
- const char *function;
+tree_check_failed (const tree node, enum tree_code code, const char *file,
+ int line, const char *function)
{
internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
tree_code_name[code], tree_code_name[TREE_CODE (node)],
code, given in CL. */
void
-tree_class_check_failed (node, cl, file, line, function)
- const tree node;
- int cl;
- const char *file;
- int line;
- const char *function;
+tree_class_check_failed (const tree node, int cl, const char *file,
+ int line, const char *function)
{
internal_error
("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
(dynamically sized) vector. */
void
-tree_vec_elt_check_failed (idx, len, file, line, function)
- int idx;
- int len;
- const char *file;
- int line;
- const char *function;
+tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
+ const char *function)
{
internal_error
("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
vector of an expression node. */
void
-tree_operand_check_failed (idx, code, file, line, function)
- int idx;
- enum tree_code code;
- const char *file;
- int line;
- const char *function;
+tree_operand_check_failed (int idx, enum tree_code code, const char *file,
+ int line, const char *function)
{
internal_error
("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
debugging output. */
static void
-finish_vector_type (t)
- tree t;
+finish_vector_type (tree t)
{
layout_type (t);
this function to select one of the types as sizetype. */
void
-build_common_tree_nodes (signed_char)
- int signed_char;
+build_common_tree_nodes (int signed_char)
{
error_mark_node = make_node (ERROR_MARK);
TREE_TYPE (error_mark_node) = error_mark_node;
It will create several other common tree nodes. */
void
-build_common_tree_nodes_2 (short_double)
- int short_double;
+build_common_tree_nodes_2 (int short_double)
{
/* Define these next since types below may used them. */
integer_zero_node = build_int_2 (0, 0);
the signness. */
static tree
-make_vector (mode, innertype, unsignedp)
- enum machine_mode mode;
- tree innertype;
- int unsignedp;
+make_vector (enum machine_mode mode, tree innertype, int unsignedp)
{
tree t;
aggregate of zeros. Otherwise return FALSE. */
bool
-initializer_zerop (init)
- tree init;
+initializer_zerop (tree init)
{
STRIP_NOPS (init);
addressable_flag:
TREE_ADDRESSABLE in
- VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
+ VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
..._TYPE, IDENTIFIER_NODE.
In a STMT_EXPR, it means we want the result of the enclosed
expression.
__FILE__, __LINE__, __FUNCTION__); \
&__t->exp.operands[__i]; }))
-extern void tree_check_failed PARAMS ((const tree, enum tree_code,
- const char *, int, const char *))
+extern void tree_check_failed (const tree, enum tree_code,
+ const char *, int, const char *)
ATTRIBUTE_NORETURN;
-extern void tree_class_check_failed PARAMS ((const tree, int,
- const char *, int, const char *))
+extern void tree_class_check_failed (const tree, int,
+ const char *, int, const char *)
ATTRIBUTE_NORETURN;
-extern void tree_vec_elt_check_failed PARAMS ((int, int, const char *,
- int, const char *))
+extern void tree_vec_elt_check_failed (int, int, const char *,
+ int, const char *)
ATTRIBUTE_NORETURN;
-extern void tree_operand_check_failed PARAMS ((int, enum tree_code,
- const char *, int, const char *))
+extern void tree_operand_check_failed (int, enum tree_code,
+ const char *, int, const char *)
ATTRIBUTE_NORETURN;
-
+
#else /* not ENABLE_TREE_CHECKING, or not gcc */
#define TREE_CHECK(T, CODE) (T)
|| (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A) \
== (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B)) \
&& TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
-
+
struct tree_int_cst GTY(())
{
struct tree_common common;
{
struct tree_common common;
int complexity;
- tree GTY ((special ("tree_exp"),
- desc ("TREE_CODE ((tree) &%0)")))
+ tree GTY ((special ("tree_exp"),
+ desc ("TREE_CODE ((tree) &%0)")))
operands[1];
};
\f
tree pointer_to;
tree reference_to;
union tree_type_symtab {
- int GTY ((tag ("0"))) address;
- char * GTY ((tag ("1"))) pointer;
+ int GTY ((tag ("0"))) address;
+ char * GTY ((tag ("1"))) pointer;
struct die_struct * GTY ((tag ("2"))) die;
- } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
+ } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
descbits ("2"))) symtab;
tree name;
tree minval;
/* DECL_ALIGN and DECL_OFFSET_ALIGN. (These are not used for
FUNCTION_DECLs). */
struct tree_decl_u1_a {
- unsigned int align : 24;
+ unsigned int align : 24;
unsigned int off_align : 8;
} a;
} GTY ((skip (""))) u1;
\f
#define NULL_TREE (tree) NULL
-extern tree decl_assembler_name PARAMS ((tree));
+extern tree decl_assembler_name (tree);
/* Compute the number of bytes occupied by 'node'. This routine only
looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
-extern size_t tree_size PARAMS ((tree));
+extern size_t tree_size (tree);
/* Lowest level primitive for allocating a node.
The TREE_CODE is the only argument. Contents are initialized
to zero except for a few of the common fields. */
-extern tree make_node PARAMS ((enum tree_code));
+extern tree make_node (enum tree_code);
/* Make a copy of a node, with all the same contents. */
-extern tree copy_node PARAMS ((tree));
+extern tree copy_node (tree);
/* Make a copy of a chain of TREE_LIST nodes. */
-extern tree copy_list PARAMS ((tree));
+extern tree copy_list (tree);
/* Make a TREE_VEC. */
-extern tree make_tree_vec PARAMS ((int));
+extern tree make_tree_vec (int);
/* Return the (unique) IDENTIFIER_NODE node for a given name.
The name is supplied as a char *. */
-extern tree get_identifier PARAMS ((const char *));
+extern tree get_identifier (const char *);
/* Identical to get_identifier, except that the length is assumed
known. */
-extern tree get_identifier_with_length PARAMS ((const char *, unsigned int));
+extern tree get_identifier_with_length (const char *, unsigned int);
/* If an identifier with the name TEXT (a null-terminated string) has
previously been referred to, return that node; otherwise return
NULL_TREE. */
-extern tree maybe_get_identifier PARAMS ((const char *));
+extern tree maybe_get_identifier (const char *);
/* Construct various types of nodes. */
#define build_int_2(LO, HI) \
build_int_2_wide ((unsigned HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
-extern tree build PARAMS ((enum tree_code, tree, ...));
-extern tree build_nt PARAMS ((enum tree_code, ...));
-
-extern tree build_int_2_wide PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT));
-extern tree build_vector PARAMS ((tree, tree));
-extern tree build_constructor PARAMS ((tree, tree));
-extern tree build_real_from_int_cst PARAMS ((tree, tree));
-extern tree build_complex PARAMS ((tree, tree, tree));
-extern tree build_string PARAMS ((int, const char *));
-extern tree build1 PARAMS ((enum tree_code, tree, tree));
-extern tree build_tree_list PARAMS ((tree, tree));
-extern tree build_decl PARAMS ((enum tree_code, tree, tree));
-extern tree build_block PARAMS ((tree, tree, tree, tree, tree));
-extern tree build_expr_wfl PARAMS ((tree, const char *, int, int));
+extern tree build (enum tree_code, tree, ...);
+extern tree build_nt (enum tree_code, ...);
+
+extern tree build_int_2_wide (unsigned HOST_WIDE_INT, HOST_WIDE_INT);
+extern tree build_vector (tree, tree);
+extern tree build_constructor (tree, tree);
+extern tree build_real_from_int_cst (tree, tree);
+extern tree build_complex (tree, tree, tree);
+extern tree build_string (int, const char *);
+extern tree build1 (enum tree_code, tree, tree);
+extern tree build_tree_list (tree, tree);
+extern tree build_decl (enum tree_code, tree, tree);
+extern tree build_block (tree, tree, tree, tree, tree);
+extern tree build_expr_wfl (tree, const char *, int, int);
/* Construct various nodes representing data types. */
-extern tree make_signed_type PARAMS ((int));
-extern tree make_unsigned_type PARAMS ((int));
-extern void initialize_sizetypes PARAMS ((void));
-extern void set_sizetype PARAMS ((tree));
-extern void fixup_unsigned_type PARAMS ((tree));
-extern tree build_pointer_type_for_mode PARAMS ((tree, enum machine_mode));
-extern tree build_pointer_type PARAMS ((tree));
-extern tree build_reference_type_for_mode PARAMS ((tree, enum machine_mode));
-extern tree build_reference_type PARAMS ((tree));
-extern tree build_type_no_quals PARAMS ((tree));
-extern tree build_index_type PARAMS ((tree));
-extern tree build_index_2_type PARAMS ((tree, tree));
-extern tree build_array_type PARAMS ((tree, tree));
-extern tree build_function_type PARAMS ((tree, tree));
-extern tree build_function_type_list PARAMS ((tree, ...));
-extern tree build_method_type PARAMS ((tree, tree));
-extern tree build_offset_type PARAMS ((tree, tree));
-extern tree build_complex_type PARAMS ((tree));
-extern tree array_type_nelts PARAMS ((tree));
-
-extern tree value_member PARAMS ((tree, tree));
-extern tree purpose_member PARAMS ((tree, tree));
-extern tree binfo_member PARAMS ((tree, tree));
-extern unsigned int attribute_hash_list PARAMS ((tree));
-extern int attribute_list_equal PARAMS ((tree, tree));
-extern int attribute_list_contained PARAMS ((tree, tree));
-extern int tree_int_cst_equal PARAMS ((tree, tree));
-extern int tree_int_cst_lt PARAMS ((tree, tree));
-extern int tree_int_cst_compare PARAMS ((tree, tree));
-extern int host_integerp PARAMS ((tree, int));
-extern HOST_WIDE_INT tree_low_cst PARAMS ((tree, int));
-extern int tree_int_cst_msb PARAMS ((tree));
-extern int tree_int_cst_sgn PARAMS ((tree));
-extern int tree_expr_nonnegative_p PARAMS ((tree));
-extern int rtl_expr_nonnegative_p PARAMS ((rtx));
-extern tree get_inner_array_type PARAMS ((tree));
+extern tree make_signed_type (int);
+extern tree make_unsigned_type (int);
+extern void initialize_sizetypes (void);
+extern void set_sizetype (tree);
+extern void fixup_unsigned_type (tree);
+extern tree build_pointer_type_for_mode (tree, enum machine_mode);
+extern tree build_pointer_type (tree);
+extern tree build_reference_type_for_mode (tree, enum machine_mode);
+extern tree build_reference_type (tree);
+extern tree build_type_no_quals (tree);
+extern tree build_index_type (tree);
+extern tree build_index_2_type (tree, tree);
+extern tree build_array_type (tree, tree);
+extern tree build_function_type (tree, tree);
+extern tree build_function_type_list (tree, ...);
+extern tree build_method_type (tree, tree);
+extern tree build_offset_type (tree, tree);
+extern tree build_complex_type (tree);
+extern tree array_type_nelts (tree);
+
+extern tree value_member (tree, tree);
+extern tree purpose_member (tree, tree);
+extern tree binfo_member (tree, tree);
+extern unsigned int attribute_hash_list (tree);
+extern int attribute_list_equal (tree, tree);
+extern int attribute_list_contained (tree, tree);
+extern int tree_int_cst_equal (tree, tree);
+extern int tree_int_cst_lt (tree, tree);
+extern int tree_int_cst_compare (tree, tree);
+extern int host_integerp (tree, int);
+extern HOST_WIDE_INT tree_low_cst (tree, int);
+extern int tree_int_cst_msb (tree);
+extern int tree_int_cst_sgn (tree);
+extern int tree_expr_nonnegative_p (tree);
+extern int rtl_expr_nonnegative_p (rtx);
+extern tree get_inner_array_type (tree);
/* From expmed.c. Since rtl.h is included after tree.h, we can't
put the prototype here. Rtl.h does declare the prototype if
tree.h had been included. */
-extern tree make_tree PARAMS ((tree, rtx));
+extern tree make_tree (tree, rtx);
\f
/* Return a type like TTYPE except that its TYPE_ATTRIBUTES
is ATTRIBUTE.
Such modified types already made are recorded so that duplicates
are not made. */
-extern tree build_type_attribute_variant PARAMS ((tree, tree));
-extern tree build_decl_attribute_variant PARAMS ((tree, tree));
+extern tree build_type_attribute_variant (tree, tree);
+extern tree build_decl_attribute_variant (tree, tree);
/* Structure describing an attribute and a function to handle it. */
struct attribute_spec
otherwise the return value should be NULL_TREE. This pointer may be
NULL if no special handling is required beyond the checks implied
by the rest of this structure. */
- tree (*const handler) PARAMS ((tree *node, tree name, tree args,
- int flags, bool *no_add_attrs));
+ tree (*const handler) (tree *node, tree name, tree args,
+ int flags, bool *no_add_attrs);
};
/* Flags that may be passed in the third argument of decl_attributes, and
/* Default versions of target-overridable functions. */
-extern tree merge_decl_attributes PARAMS ((tree, tree));
-extern tree merge_type_attributes PARAMS ((tree, tree));
-extern void default_register_cpp_builtins PARAMS ((struct cpp_reader *));
+extern tree merge_decl_attributes (tree, tree);
+extern tree merge_type_attributes (tree, tree);
+extern void default_register_cpp_builtins (struct cpp_reader *);
/* Split a list of declspecs and attributes into two. */
/* Return 1 if an attribute and its arguments are valid for a decl or type. */
-extern int valid_machine_attribute PARAMS ((tree, tree, tree, tree));
+extern int valid_machine_attribute (tree, tree, tree, tree);
/* Given a tree node and a string, return nonzero if the tree node is
a valid attribute name for the string. */
-extern int is_attribute_p PARAMS ((const char *, tree));
+extern int is_attribute_p (const char *, tree);
/* Given an attribute name and a list of attributes, return the list element
of the attribute or NULL_TREE if not found. */
-extern tree lookup_attribute PARAMS ((const char *, tree));
+extern tree lookup_attribute (const char *, tree);
/* Given two attributes lists, return a list of their union. */
-extern tree merge_attributes PARAMS ((tree, tree));
+extern tree merge_attributes (tree, tree);
#ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
/* Given two Windows decl attributes lists, possibly including
dllimport, return a list of their union . */
-extern tree merge_dllimport_decl_attributes PARAMS ((tree, tree));
+extern tree merge_dllimport_decl_attributes (tree, tree);
#endif
/* Return a version of the TYPE, qualified as indicated by the
TYPE_QUALS, if one exists. If no qualified version exists yet,
return NULL_TREE. */
-extern tree get_qualified_type PARAMS ((tree, int));
+extern tree get_qualified_type (tree, int);
/* Like get_qualified_type, but creates the type if it does not
exist. This function never returns NULL_TREE. */
-extern tree build_qualified_type PARAMS ((tree, int));
+extern tree build_qualified_type (tree, int);
/* Like build_qualified_type, but only deals with the `const' and
`volatile' qualifiers. This interface is retained for backwards
/* Make a copy of a type node. */
-extern tree build_type_copy PARAMS ((tree));
+extern tree build_type_copy (tree);
/* Finish up a builtin RECORD_TYPE. Give it a name and provide its
fields. Optionally specify an alignment, and then lsy it out. */
-extern void finish_builtin_struct PARAMS ((tree, const char *,
- tree, tree));
+extern void finish_builtin_struct (tree, const char *,
+ tree, tree);
/* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
TYPE_ALIGN and TYPE_MODE fields. If called more than once on one
node, does nothing except for the first time. */
-extern void layout_type PARAMS ((tree));
+extern void layout_type (tree);
/* These functions allow a front-end to perform a manual layout of a
RECORD_TYPE. (For instance, if the placement of subsequent fields
int packed_maybe_necessary;
} *record_layout_info;
-extern void set_lang_adjust_rli PARAMS ((void (*) PARAMS
- ((record_layout_info))));
-extern record_layout_info start_record_layout PARAMS ((tree));
-extern tree bit_from_pos PARAMS ((tree, tree));
-extern tree byte_from_pos PARAMS ((tree, tree));
-extern void pos_from_bit PARAMS ((tree *, tree *, unsigned int,
- tree));
-extern void normalize_offset PARAMS ((tree *, tree *,
- unsigned int));
-extern tree rli_size_unit_so_far PARAMS ((record_layout_info));
-extern tree rli_size_so_far PARAMS ((record_layout_info));
-extern void normalize_rli PARAMS ((record_layout_info));
-extern void place_field PARAMS ((record_layout_info, tree));
-extern void compute_record_mode PARAMS ((tree));
-extern void finish_record_layout PARAMS ((record_layout_info, int));
+extern void set_lang_adjust_rli (void (*) (record_layout_info));
+extern record_layout_info start_record_layout (tree);
+extern tree bit_from_pos (tree, tree);
+extern tree byte_from_pos (tree, tree);
+extern void pos_from_bit (tree *, tree *, unsigned int, tree);
+extern void normalize_offset (tree *, tree *, unsigned int);
+extern tree rli_size_unit_so_far (record_layout_info);
+extern tree rli_size_so_far (record_layout_info);
+extern void normalize_rli (record_layout_info);
+extern void place_field (record_layout_info, tree);
+extern void compute_record_mode (tree);
+extern void finish_record_layout (record_layout_info, int);
/* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
return a canonicalized ..._TYPE node, so that duplicates are not made.
How the hash code is computed is up to the caller, as long as any two
callers that could hash identical-looking type nodes agree. */
-extern tree type_hash_canon PARAMS ((unsigned int, tree));
+extern tree type_hash_canon (unsigned int, tree);
/* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
be starting at (in bits). Zero means it can be assumed aligned
on any boundary that may be needed. */
-extern void layout_decl PARAMS ((tree, unsigned));
+extern void layout_decl (tree, unsigned);
/* Return the mode for data of a given size SIZE and mode class CLASS.
If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
The value is BLKmode if no other mode is found. This is like
mode_for_size, but is passed a tree. */
-extern enum machine_mode mode_for_size_tree PARAMS ((tree, enum mode_class,
- int));
+extern enum machine_mode mode_for_size_tree (tree, enum mode_class, int);
/* Return an expr equal to X but certainly not valid as an lvalue. */
-extern tree non_lvalue PARAMS ((tree));
-extern tree pedantic_non_lvalue PARAMS ((tree));
-
-extern tree convert PARAMS ((tree, tree));
-extern unsigned int expr_align PARAMS ((tree));
-extern tree expr_first PARAMS ((tree));
-extern tree expr_last PARAMS ((tree));
-extern int expr_length PARAMS ((tree));
-extern tree size_in_bytes PARAMS ((tree));
-extern HOST_WIDE_INT int_size_in_bytes PARAMS ((tree));
-extern tree bit_position PARAMS ((tree));
-extern HOST_WIDE_INT int_bit_position PARAMS ((tree));
-extern tree byte_position PARAMS ((tree));
-extern HOST_WIDE_INT int_byte_position PARAMS ((tree));
+extern tree non_lvalue (tree);
+extern tree pedantic_non_lvalue (tree);
+
+extern tree convert (tree, tree);
+extern unsigned int expr_align (tree);
+extern tree expr_first (tree);
+extern tree expr_last (tree);
+extern int expr_length (tree);
+extern tree size_in_bytes (tree);
+extern HOST_WIDE_INT int_size_in_bytes (tree);
+extern tree bit_position (tree);
+extern HOST_WIDE_INT int_bit_position (tree);
+extern tree byte_position (tree);
+extern HOST_WIDE_INT int_byte_position (tree);
/* Define data structures, macros, and functions for handling sizes
and the various types used to represent sizes. */
#define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
#define ubitsizetype sizetype_tab[(int) UBITSIZETYPE]
-extern tree size_binop PARAMS ((enum tree_code, tree, tree));
-extern tree size_diffop PARAMS ((tree, tree));
-extern tree size_int_wide PARAMS ((HOST_WIDE_INT,
- enum size_type_kind));
-extern tree size_int_type_wide PARAMS ((HOST_WIDE_INT, tree));
+extern tree size_binop (enum tree_code, tree, tree);
+extern tree size_diffop (tree, tree);
+extern tree size_int_wide (HOST_WIDE_INT, enum size_type_kind);
+extern tree size_int_type_wide (HOST_WIDE_INT, tree);
#define size_int_type(L, T) size_int_type_wide ((HOST_WIDE_INT) (L), T)
#define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), SIZETYPE)
#define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), BITSIZETYPE)
#define sbitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SBITSIZETYPE)
-extern tree round_up PARAMS ((tree, int));
-extern tree round_down PARAMS ((tree, int));
-extern tree get_pending_sizes PARAMS ((void));
-extern int is_pending_size PARAMS ((tree));
-extern void put_pending_size PARAMS ((tree));
-extern void put_pending_sizes PARAMS ((tree));
+extern tree round_up (tree, int);
+extern tree round_down (tree, int);
+extern tree get_pending_sizes (void);
+extern int is_pending_size (tree);
+extern void put_pending_size (tree);
+extern void put_pending_sizes (tree);
/* Type for sizes of data-type. */
by making the last node in X point to Y.
Returns X, except if X is 0 returns Y. */
-extern tree chainon PARAMS ((tree, tree));
+extern tree chainon (tree, tree);
/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
-extern tree tree_cons PARAMS ((tree, tree, tree));
+extern tree tree_cons (tree, tree, tree);
/* Return the last tree node in a chain. */
-extern tree tree_last PARAMS ((tree));
+extern tree tree_last (tree);
/* Reverse the order of elements in a chain, and return the new head. */
-extern tree nreverse PARAMS ((tree));
+extern tree nreverse (tree);
/* Returns the length of a chain of nodes
(number of chain pointers to follow before reaching a null pointer). */
-extern int list_length PARAMS ((tree));
+extern int list_length (tree);
/* Returns the number of FIELD_DECLs in a type. */
-extern int fields_length PARAMS ((tree));
+extern int fields_length (tree);
/* Given an initializer INIT, return TRUE if INIT is zero or some
aggregate of zeros. Otherwise return FALSE. */
-extern bool initializer_zerop PARAMS ((tree));
+extern bool initializer_zerop (tree);
/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
-extern int integer_zerop PARAMS ((tree));
+extern int integer_zerop (tree);
/* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */
-extern int integer_onep PARAMS ((tree));
+extern int integer_onep (tree);
/* integer_all_onesp (tree x) is nonzero if X is an integer constant
all of whose significant bits are 1. */
-extern int integer_all_onesp PARAMS ((tree));
+extern int integer_all_onesp (tree);
/* integer_pow2p (tree x) is nonzero is X is an integer constant with
exactly one bit 1. */
-extern int integer_pow2p PARAMS ((tree));
+extern int integer_pow2p (tree);
/* integer_nonzerop (tree x) is nonzero if X is an integer constant
with a nonzero value. */
-extern int integer_nonzerop PARAMS ((tree));
+extern int integer_nonzerop (tree);
/* staticp (tree x) is nonzero if X is a reference to data allocated
at a fixed address in memory. */
-extern int staticp PARAMS ((tree));
+extern int staticp (tree);
/* Gets an error if argument X is not an lvalue.
Also returns 1 if X is an lvalue, 0 if not. */
-extern int lvalue_or_else PARAMS ((tree, const char *));
+extern int lvalue_or_else (tree, const char *);
/* save_expr (EXP) returns an expression equivalent to EXP
but it can be used multiple times within context CTX
and only evaluate EXP once. */
-extern tree save_expr PARAMS ((tree));
+extern tree save_expr (tree);
/* Look inside EXPR and into any simple arithmetic operations. Return
the innermost non-arithmetic node. */
-extern tree skip_simple_arithmetic PARAMS ((tree));
+extern tree skip_simple_arithmetic (tree);
/* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a
SAVE_EXPR. Return FALSE otherwise. */
-extern bool saved_expr_p PARAMS ((tree));
+extern bool saved_expr_p (tree);
/* Returns the index of the first non-tree operand for CODE, or the number
of operands if all are trees. */
-extern int first_rtl_op PARAMS ((enum tree_code));
+extern int first_rtl_op (enum tree_code);
/* Return which tree structure is used by T. */
-enum tree_node_structure_enum tree_node_structure PARAMS ((tree));
+enum tree_node_structure_enum tree_node_structure (tree);
/* unsave_expr (EXP) returns an expression equivalent to EXP but it
can be used multiple times and will evaluate EXP in its entirety
each time. */
-extern tree unsave_expr PARAMS ((tree));
+extern tree unsave_expr (tree);
/* Reset EXP in place so that it can be expanded again. Does not
recurse into subtrees. */
-extern void unsave_expr_1 PARAMS ((tree));
+extern void unsave_expr_1 (tree);
/* Return 0 if it is safe to evaluate EXPR multiple times,
return 1 if it is safe if EXPR is unsaved afterward, or
return 2 if it is completely unsafe. */
-extern int unsafe_for_reeval PARAMS ((tree));
+extern int unsafe_for_reeval (tree);
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
or offset that depends on a field within a record.
Note that we only allow such expressions within simple arithmetic
or a COND_EXPR. */
-extern bool contains_placeholder_p PARAMS ((tree));
+extern bool contains_placeholder_p (tree);
/* This macro calls the above function but short-circuits the common
case of a constant to save time. Also check for null. */
This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
positions. */
-extern bool type_contains_placeholder_p PARAMS ((tree));
+extern bool type_contains_placeholder_p (tree);
/* Return 1 if EXP contains any expressions that produce cleanups for an
outer scope to deal with. Used by fold. */
-extern int has_cleanups PARAMS ((tree));
+extern int has_cleanups (tree);
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
return a tree with all occurrences of references to F in a
PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
contains only arithmetic expressions. */
-extern tree substitute_in_expr PARAMS ((tree, tree, tree));
+extern tree substitute_in_expr (tree, tree, tree);
/* variable_size (EXP) is like save_expr (EXP) except that it
is for the special case of something that is part of a
to compute the value at the right time when the data type
belongs to a function parameter. */
-extern tree variable_size PARAMS ((tree));
+extern tree variable_size (tree);
/* stabilize_reference (EXP) returns an reference equivalent to EXP
but it can be used multiple times
and only evaluate the subexpressions once. */
-extern tree stabilize_reference PARAMS ((tree));
+extern tree stabilize_reference (tree);
/* Subroutine of stabilize_reference; this is called for subtrees of
references. Any expression with side-effects must be put in a SAVE_EXPR
to ensure that it is only evaluated once. */
-extern tree stabilize_reference_1 PARAMS ((tree));
+extern tree stabilize_reference_1 (tree);
/* Return EXP, stripped of any conversions to wider types
in such a way that the result of converting to type FOR_TYPE
is the same as if EXP were converted to FOR_TYPE.
If FOR_TYPE is 0, it signifies EXP's type. */
-extern tree get_unwidened PARAMS ((tree, tree));
+extern tree get_unwidened (tree, tree);
/* Return OP or a simpler expression for a narrower value
which can be sign-extended or zero-extended to give back OP.
Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
or 0 if the value should be sign-extended. */
-extern tree get_narrower PARAMS ((tree, int *));
+extern tree get_narrower (tree, int *);
/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
look for nested component-refs or array-refs at constant positions
and find the ultimate containing object, which is returned. */
-extern tree get_inner_reference PARAMS ((tree, HOST_WIDE_INT *,
- HOST_WIDE_INT *, tree *,
- enum machine_mode *, int *,
- int *));
+extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
+ tree *, enum machine_mode *, int *, int *);
/* Return 1 if T is an expression that get_inner_reference handles. */
-extern int handled_component_p PARAMS ((tree));
+extern int handled_component_p (tree);
/* Given a DECL or TYPE, return the scope in which it was declared, or
NUL_TREE if there is no containing scope. */
-extern tree get_containing_scope PARAMS ((tree));
+extern tree get_containing_scope (tree);
/* Return the FUNCTION_DECL which provides this _DECL with its context,
or zero if none. */
-extern tree decl_function_context PARAMS ((tree));
+extern tree decl_function_context (tree);
/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
this _DECL with its context, or zero if none. */
-extern tree decl_type_context PARAMS ((tree));
+extern tree decl_type_context (tree);
/* Given the FUNCTION_DECL for the current function,
return zero if it is ok for this function to be inline.
Otherwise return a warning message with a single %s
for the function's name. */
-extern const char *function_cannot_inline_p PARAMS ((tree));
+extern const char *function_cannot_inline_p (tree);
/* Return 1 if EXPR is the real constant zero. */
-extern int real_zerop PARAMS ((tree));
+extern int real_zerop (tree);
\f
/* Declare commonly used variables for tree structure. */
/* Declare a predefined function. Return the declaration. This function is
provided by each language frontend. */
-extern tree builtin_function PARAMS ((const char *, tree, int,
- enum built_in_class,
- const char *, tree));
+extern tree builtin_function (const char *, tree, int, enum built_in_class,
+ const char *, tree);
\f
/* In tree.c */
-extern void clean_symbol_name PARAMS ((char *));
-extern tree get_file_function_name_long PARAMS ((const char *));
-extern tree get_set_constructor_bits PARAMS ((tree, char *, int));
-extern tree get_set_constructor_bytes PARAMS ((tree,
- unsigned char *, int));
-extern tree get_callee_fndecl PARAMS ((tree));
-extern void set_decl_assembler_name PARAMS ((tree));
-extern int type_num_arguments PARAMS ((tree));
-extern tree lhd_unsave_expr_now PARAMS ((tree));
+extern void clean_symbol_name (char *);
+extern tree get_file_function_name_long (const char *);
+extern tree get_set_constructor_bits (tree, char *, int);
+extern tree get_set_constructor_bytes (tree, unsigned char *, int);
+extern tree get_callee_fndecl (tree);
+extern void set_decl_assembler_name (tree);
+extern int type_num_arguments (tree);
+extern tree lhd_unsave_expr_now (tree);
\f
/* In stmt.c */
-extern void expand_fixups PARAMS ((rtx));
-extern tree expand_start_stmt_expr PARAMS ((int));
-extern tree expand_end_stmt_expr PARAMS ((tree));
-extern void expand_expr_stmt PARAMS ((tree));
-extern void expand_expr_stmt_value PARAMS ((tree, int, int));
-extern int warn_if_unused_value PARAMS ((tree));
-extern void expand_decl_init PARAMS ((tree));
-extern void clear_last_expr PARAMS ((void));
-extern void expand_label PARAMS ((tree));
-extern void expand_goto PARAMS ((tree));
-extern void expand_asm PARAMS ((tree, int));
-extern void expand_start_cond PARAMS ((tree, int));
-extern void expand_end_cond PARAMS ((void));
-extern void expand_start_else PARAMS ((void));
-extern void expand_start_elseif PARAMS ((tree));
-extern struct nesting *expand_start_loop PARAMS ((int));
-extern struct nesting *expand_start_loop_continue_elsewhere PARAMS ((int));
-extern struct nesting *expand_start_null_loop PARAMS ((void));
-extern void expand_loop_continue_here PARAMS ((void));
-extern void expand_end_loop PARAMS ((void));
-extern void expand_end_null_loop PARAMS ((void));
-extern int expand_continue_loop PARAMS ((struct nesting *));
-extern int expand_exit_loop PARAMS ((struct nesting *));
-extern int expand_exit_loop_if_false PARAMS ((struct nesting *,
- tree));
-extern int expand_exit_loop_top_cond PARAMS ((struct nesting *,
- tree));
-extern int expand_exit_something PARAMS ((void));
-
-extern void expand_return PARAMS ((tree));
-extern int optimize_tail_recursion PARAMS ((tree, rtx));
-extern void expand_start_bindings_and_block PARAMS ((int, tree));
+extern void expand_fixups (rtx);
+extern tree expand_start_stmt_expr (int);
+extern tree expand_end_stmt_expr (tree);
+extern void expand_expr_stmt (tree);
+extern void expand_expr_stmt_value (tree, int, int);
+extern int warn_if_unused_value (tree);
+extern void expand_decl_init (tree);
+extern void clear_last_expr (void);
+extern void expand_label (tree);
+extern void expand_goto (tree);
+extern void expand_asm (tree, int);
+extern void expand_start_cond (tree, int);
+extern void expand_end_cond (void);
+extern void expand_start_else (void);
+extern void expand_start_elseif (tree);
+extern struct nesting *expand_start_loop (int);
+extern struct nesting *expand_start_loop_continue_elsewhere (int);
+extern struct nesting *expand_start_null_loop (void);
+extern void expand_loop_continue_here (void);
+extern void expand_end_loop (void);
+extern void expand_end_null_loop (void);
+extern int expand_continue_loop (struct nesting *);
+extern int expand_exit_loop (struct nesting *);
+extern int expand_exit_loop_if_false (struct nesting *,tree);
+extern int expand_exit_loop_top_cond (struct nesting *, tree);
+extern int expand_exit_something (void);
+
+extern void expand_return (tree);
+extern int optimize_tail_recursion (tree, rtx);
+extern void expand_start_bindings_and_block (int, tree);
#define expand_start_bindings(flags) \
expand_start_bindings_and_block(flags, NULL_TREE)
-extern void expand_end_bindings PARAMS ((tree, int, int));
-extern void warn_about_unused_variables PARAMS ((tree));
-extern void start_cleanup_deferral PARAMS ((void));
-extern void end_cleanup_deferral PARAMS ((void));
-extern int is_body_block PARAMS ((tree));
-
-extern int conditional_context PARAMS ((void));
-extern struct nesting * current_nesting_level PARAMS ((void));
-extern tree last_cleanup_this_contour PARAMS ((void));
-extern void expand_start_case PARAMS ((int, tree, tree,
- const char *));
-extern void expand_end_case_type PARAMS ((tree, tree));
+extern void expand_end_bindings (tree, int, int);
+extern void warn_about_unused_variables (tree);
+extern void start_cleanup_deferral (void);
+extern void end_cleanup_deferral (void);
+extern int is_body_block (tree);
+
+extern int conditional_context (void);
+extern struct nesting * current_nesting_level (void);
+extern tree last_cleanup_this_contour (void);
+extern void expand_start_case (int, tree, tree, const char *);
+extern void expand_end_case_type (tree, tree);
#define expand_end_case(cond) expand_end_case_type (cond, NULL)
-extern int add_case_node PARAMS ((tree, tree,
- tree, tree *));
-extern int pushcase PARAMS ((tree,
- tree (*) (tree, tree),
- tree, tree *));
-extern int pushcase_range PARAMS ((tree, tree,
- tree (*) (tree, tree),
- tree, tree *));
-extern void using_eh_for_cleanups PARAMS ((void));
+extern int add_case_node (tree, tree, tree, tree *);
+extern int pushcase (tree, tree (*) (tree, tree), tree, tree *);
+extern int pushcase_range (tree, tree, tree (*) (tree, tree), tree, tree *);
+extern void using_eh_for_cleanups (void);
/* In fold-const.c */
if the argument itself cannot be simplified, its
subexpressions are not changed. */
-extern tree fold PARAMS ((tree));
-extern tree fold_single_bit_test
- PARAMS ((enum tree_code, tree, tree, tree));
-
-extern int force_fit_type PARAMS ((tree, int));
-extern int add_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern int neg_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern int mul_double PARAMS ((unsigned HOST_WIDE_INT,
- HOST_WIDE_INT,
- unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern void lshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *, int));
-extern void rshift_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *, int));
-extern void lrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-extern void rrotate_double PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
- HOST_WIDE_INT, unsigned int,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-
-extern int div_and_round_double PARAMS ((enum tree_code, int,
- unsigned HOST_WIDE_INT,
- HOST_WIDE_INT,
- unsigned HOST_WIDE_INT,
- HOST_WIDE_INT,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *,
- unsigned HOST_WIDE_INT *,
- HOST_WIDE_INT *));
-
-extern int operand_equal_p PARAMS ((tree, tree, int));
-extern tree omit_one_operand PARAMS ((tree, tree, tree));
-extern tree invert_truthvalue PARAMS ((tree));
+extern tree fold (tree);
+extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
+
+extern int force_fit_type (tree, int);
+extern int add_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern int mul_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
+extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
+extern void lrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+extern void rrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned int,
+ unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
+
+extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned HOST_WIDE_INT,
+ HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
+ HOST_WIDE_INT *);
+
+extern int operand_equal_p (tree, tree, int);
+extern tree omit_one_operand (tree, tree, tree);
+extern tree invert_truthvalue (tree);
/* In builtins.c */
-extern tree fold_builtin PARAMS ((tree));
-extern enum built_in_function builtin_mathfn_code PARAMS ((tree));
-extern tree build_function_call_expr PARAMS ((tree, tree));
-extern tree mathfn_built_in PARAMS ((tree, enum built_in_function fn));
+extern tree fold_builtin (tree);
+extern enum built_in_function builtin_mathfn_code (tree);
+extern tree build_function_call_expr (tree, tree);
+extern tree mathfn_built_in (tree, enum built_in_function fn);
/* In convert.c */
-extern tree strip_float_extensions PARAMS ((tree));
+extern tree strip_float_extensions (tree);
/* In alias.c */
-extern void record_component_aliases PARAMS ((tree));
-extern HOST_WIDE_INT get_alias_set PARAMS ((tree));
-extern int alias_sets_conflict_p PARAMS ((HOST_WIDE_INT,
- HOST_WIDE_INT));
-extern int readonly_fields_p PARAMS ((tree));
-extern int objects_must_conflict_p PARAMS ((tree, tree));
+extern void record_component_aliases (tree);
+extern HOST_WIDE_INT get_alias_set (tree);
+extern int alias_sets_conflict_p (HOST_WIDE_INT, HOST_WIDE_INT);
+extern int readonly_fields_p (tree);
+extern int objects_must_conflict_p (tree, tree);
/* In tree.c */
-extern int really_constant_p PARAMS ((tree));
-extern int int_fits_type_p PARAMS ((tree, tree));
-extern bool variably_modified_type_p PARAMS ((tree));
-extern int tree_log2 PARAMS ((tree));
-extern int tree_floor_log2 PARAMS ((tree));
-extern int simple_cst_equal PARAMS ((tree, tree));
-extern unsigned int iterative_hash_expr PARAMS ((tree, unsigned int));
-extern int compare_tree_int PARAMS ((tree,
- unsigned HOST_WIDE_INT));
-extern int type_list_equal PARAMS ((tree, tree));
-extern int chain_member PARAMS ((tree, tree));
-extern tree type_hash_lookup PARAMS ((unsigned int, tree));
-extern void type_hash_add PARAMS ((unsigned int, tree));
-extern unsigned int type_hash_list PARAMS ((tree));
-extern int simple_cst_list_equal PARAMS ((tree, tree));
-extern void dump_tree_statistics PARAMS ((void));
-extern void expand_function_end PARAMS ((void));
-extern void expand_function_start PARAMS ((tree, int));
-extern void expand_pending_sizes PARAMS ((tree));
-
-extern int real_onep PARAMS ((tree));
-extern int real_twop PARAMS ((tree));
-extern int real_minus_onep PARAMS ((tree));
-extern void init_ttree PARAMS ((void));
-extern void build_common_tree_nodes PARAMS ((int));
-extern void build_common_tree_nodes_2 PARAMS ((int));
-extern tree build_range_type PARAMS ((tree, tree, tree));
+extern int really_constant_p (tree);
+extern int int_fits_type_p (tree, tree);
+extern bool variably_modified_type_p (tree);
+extern int tree_log2 (tree);
+extern int tree_floor_log2 (tree);
+extern int simple_cst_equal (tree, tree);
+extern unsigned int iterative_hash_expr (tree, unsigned int);
+extern int compare_tree_int (tree, unsigned HOST_WIDE_INT);
+extern int type_list_equal (tree, tree);
+extern int chain_member (tree, tree);
+extern tree type_hash_lookup (unsigned int, tree);
+extern void type_hash_add (unsigned int, tree);
+extern unsigned int type_hash_list (tree);
+extern int simple_cst_list_equal (tree, tree);
+extern void dump_tree_statistics (void);
+extern void expand_function_end (void);
+extern void expand_function_start (tree, int);
+extern void expand_pending_sizes (tree);
+
+extern int real_onep (tree);
+extern int real_twop (tree);
+extern int real_minus_onep (tree);
+extern void init_ttree (void);
+extern void build_common_tree_nodes (int);
+extern void build_common_tree_nodes_2 (int);
+extern tree build_range_type (tree, tree, tree);
/* In function.c */
-extern void setjmp_protect_args PARAMS ((void));
-extern void setjmp_protect PARAMS ((tree));
-extern void expand_main_function PARAMS ((void));
-extern void init_dummy_function_start PARAMS ((void));
-extern void expand_dummy_function_end PARAMS ((void));
-extern void init_function_for_compilation PARAMS ((void));
-extern void init_function_start PARAMS ((tree));
-extern void assign_parms PARAMS ((tree));
-extern void put_var_into_stack PARAMS ((tree, int));
-extern void flush_addressof PARAMS ((tree));
-extern void uninitialized_vars_warning PARAMS ((tree));
-extern void setjmp_args_warning PARAMS ((void));
-extern void mark_all_temps_used PARAMS ((void));
-extern void init_temp_slots PARAMS ((void));
-extern void combine_temp_slots PARAMS ((void));
-extern void free_temp_slots PARAMS ((void));
-extern void pop_temp_slots PARAMS ((void));
-extern void push_temp_slots PARAMS ((void));
-extern void preserve_temp_slots PARAMS ((rtx));
-extern void preserve_rtl_expr_temps PARAMS ((tree));
-extern int aggregate_value_p PARAMS ((tree));
-extern void free_temps_for_rtl_expr PARAMS ((tree));
-extern void instantiate_virtual_regs PARAMS ((tree, rtx));
-extern void unshare_all_rtl PARAMS ((tree, rtx));
-extern void push_function_context PARAMS ((void));
-extern void pop_function_context PARAMS ((void));
-extern void push_function_context_to PARAMS ((tree));
-extern void pop_function_context_from PARAMS ((tree));
+extern void setjmp_protect_args (void);
+extern void setjmp_protect (tree);
+extern void expand_main_function (void);
+extern void init_dummy_function_start (void);
+extern void expand_dummy_function_end (void);
+extern void init_function_for_compilation (void);
+extern void init_function_start (tree);
+extern void assign_parms (tree);
+extern void put_var_into_stack (tree, int);
+extern void flush_addressof (tree);
+extern void uninitialized_vars_warning (tree);
+extern void setjmp_args_warning (void);
+extern void mark_all_temps_used (void);
+extern void init_temp_slots (void);
+extern void combine_temp_slots (void);
+extern void free_temp_slots (void);
+extern void pop_temp_slots (void);
+extern void push_temp_slots (void);
+extern void preserve_temp_slots (rtx);
+extern void preserve_rtl_expr_temps (tree);
+extern int aggregate_value_p (tree);
+extern void free_temps_for_rtl_expr (tree);
+extern void instantiate_virtual_regs (tree, rtx);
+extern void unshare_all_rtl (tree, rtx);
+extern void push_function_context (void);
+extern void pop_function_context (void);
+extern void push_function_context_to (tree);
+extern void pop_function_context_from (tree);
/* In print-rtl.c */
#ifdef BUFSIZ
-extern void print_rtl PARAMS ((FILE *, rtx));
+extern void print_rtl (FILE *, rtx);
#endif
/* In print-tree.c */
-extern void debug_tree PARAMS ((tree));
+extern void debug_tree (tree);
#ifdef BUFSIZ
-extern void print_node PARAMS ((FILE *, const char *, tree,
- int));
-extern void print_node_brief PARAMS ((FILE *, const char *, tree,
- int));
-extern void indent_to PARAMS ((FILE *, int));
+extern void print_node (FILE *, const char *, tree, int);
+extern void print_node_brief (FILE *, const char *, tree, int);
+extern void indent_to (FILE *, int);
#endif
/* In expr.c */
-extern int apply_args_register_offset PARAMS ((int));
-extern rtx expand_builtin_return_addr
- PARAMS ((enum built_in_function, int, rtx));
-extern void check_max_integer_computation_mode PARAMS ((tree));
+extern int apply_args_register_offset (int);
+extern rtx expand_builtin_return_addr (enum built_in_function, int, rtx);
+extern void check_max_integer_computation_mode (tree);
/* In emit-rtl.c */
-extern void start_sequence_for_rtl_expr PARAMS ((tree));
-extern rtx emit_line_note PARAMS ((const char *, int));
+extern void start_sequence_for_rtl_expr (tree);
+extern rtx emit_line_note (const char *, int);
/* In calls.c */
/* Create libcall block around the call. */
#define ECF_LIBCALL_BLOCK 4096
-extern int flags_from_decl_or_type PARAMS ((tree));
+extern int flags_from_decl_or_type (tree);
-extern int setjmp_call_p PARAMS ((tree));
-extern bool alloca_call_p PARAMS ((tree));
+extern int setjmp_call_p (tree);
+extern bool alloca_call_p (tree);
/* In attribs.c. */
extern tree decl_attributes (tree *, tree, int);
/* In integrate.c */
-extern void save_for_inline PARAMS ((tree));
-extern void set_decl_abstract_flags PARAMS ((tree, int));
-extern void output_inline_function PARAMS ((tree));
-extern void set_decl_origin_self PARAMS ((tree));
+extern void save_for_inline (tree);
+extern void set_decl_abstract_flags (tree, int);
+extern void output_inline_function (tree);
+extern void set_decl_origin_self (tree);
/* In stor-layout.c */
-extern void fixup_signed_type PARAMS ((tree));
-extern void internal_reference_types PARAMS ((void));
+extern void fixup_signed_type (tree);
+extern void internal_reference_types (void);
/* varasm.c */
-extern void make_decl_rtl PARAMS ((tree, const char *));
-extern void make_decl_one_only PARAMS ((tree));
-extern int supports_one_only PARAMS ((void));
-extern void variable_section PARAMS ((tree, int));
-enum tls_model decl_tls_model PARAMS ((tree));
-enum symbol_visibility decl_visibility PARAMS ((tree));
-extern void resolve_unique_section PARAMS ((tree, int, int));
-extern void mark_referenced PARAMS ((tree));
+extern void make_decl_rtl (tree, const char *);
+extern void make_decl_one_only (tree);
+extern int supports_one_only (void);
+extern void variable_section (tree, int);
+enum tls_model decl_tls_model (tree);
+enum symbol_visibility decl_visibility (tree);
+extern void resolve_unique_section (tree, int, int);
+extern void mark_referenced (tree);
/* In stmt.c */
-extern void emit_nop PARAMS ((void));
-extern void expand_computed_goto PARAMS ((tree));
-extern bool parse_output_constraint PARAMS ((const char **,
- int, int, int,
- bool *, bool *, bool *));
-extern void expand_asm_operands PARAMS ((tree, tree, tree, tree, int,
- const char *, int));
+extern void emit_nop (void);
+extern void expand_computed_goto (tree);
+extern bool parse_output_constraint (const char **, int, int, int,
+ bool *, bool *, bool *);
+extern void expand_asm_operands (tree, tree, tree, tree, int,
+ const char *, int);
extern tree resolve_asm_operand_names (tree, tree, tree);
-extern int any_pending_cleanups PARAMS ((void));
-extern void init_stmt_for_function PARAMS ((void));
-extern void expand_start_target_temps PARAMS ((void));
-extern void expand_end_target_temps PARAMS ((void));
-extern void expand_elseif PARAMS ((tree));
-extern void save_stack_pointer PARAMS ((void));
-extern void expand_decl PARAMS ((tree));
-extern int expand_decl_cleanup PARAMS ((tree, tree));
-extern int expand_decl_cleanup_eh PARAMS ((tree, tree, int));
-extern void expand_anon_union_decl PARAMS ((tree, tree, tree));
-extern void expand_start_case_dummy PARAMS ((void));
-extern HOST_WIDE_INT all_cases_count PARAMS ((tree, int *));
-extern void check_for_full_enumeration_handling PARAMS ((tree));
-extern void declare_nonlocal_label PARAMS ((tree));
-extern void default_flag_random_seed PARAMS ((void));
+extern int any_pending_cleanups (void);
+extern void init_stmt_for_function (void);
+extern void expand_start_target_temps (void);
+extern void expand_end_target_temps (void);
+extern void expand_elseif (tree);
+extern void save_stack_pointer (void);
+extern void expand_decl (tree);
+extern int expand_decl_cleanup (tree, tree);
+extern int expand_decl_cleanup_eh (tree, tree, int);
+extern void expand_anon_union_decl (tree, tree, tree);
+extern void expand_start_case_dummy (void);
+extern HOST_WIDE_INT all_cases_count (tree, int *);
+extern void check_for_full_enumeration_handling (tree);
+extern void declare_nonlocal_label (tree);
+extern void default_flag_random_seed (void);
/* If KIND=='I', return a suitable global initializer (constructor) name.
If KIND=='D', return a suitable global clean-up (destructor) name. */
-extern tree get_file_function_name PARAMS ((int));
+extern tree get_file_function_name (int);
\f
/* Interface of the DWARF2 unwind info support. */
/* Generate a new label for the CFI info to refer to. */
-extern char *dwarf2out_cfi_label PARAMS ((void));
+extern char *dwarf2out_cfi_label (void);
/* Entry point to update the canonical frame address (CFA). */
-extern void dwarf2out_def_cfa PARAMS ((const char *, unsigned, long));
+extern void dwarf2out_def_cfa (const char *, unsigned, long);
/* Add the CFI for saving a register window. */
-extern void dwarf2out_window_save PARAMS ((const char *));
+extern void dwarf2out_window_save (const char *);
/* Add a CFI to update the running total of the size of arguments pushed
onto the stack. */
-extern void dwarf2out_args_size PARAMS ((const char *, long));
+extern void dwarf2out_args_size (const char *, long);
/* Entry point for saving a register to the stack. */
-extern void dwarf2out_reg_save PARAMS ((const char *, unsigned, long));
+extern void dwarf2out_reg_save (const char *, unsigned, long);
/* Entry point for saving the return address in the stack. */
-extern void dwarf2out_return_save PARAMS ((const char *, long));
+extern void dwarf2out_return_save (const char *, long);
/* Entry point for saving the return address in a register. */
-extern void dwarf2out_return_reg PARAMS ((const char *, unsigned));
+extern void dwarf2out_return_reg (const char *, unsigned);
/* The type of a function that walks over tree structure. */
-typedef tree (*walk_tree_fn) PARAMS ((tree *, int *, void *));
+typedef tree (*walk_tree_fn) (tree *, int *, void *);
/* In tree-dump.c */
typedef struct dump_info *dump_info_p;
-extern int dump_flag PARAMS ((dump_info_p, int, tree));
-extern int dump_enabled_p PARAMS ((enum tree_dump_index));
-extern FILE *dump_begin PARAMS ((enum tree_dump_index, int *));
-extern void dump_end PARAMS ((enum tree_dump_index, FILE *));
-extern void dump_node PARAMS ((tree, int, FILE *));
-extern int dump_switch_p PARAMS ((const char *));
-extern const char *dump_flag_name PARAMS ((enum tree_dump_index));
+extern int dump_flag (dump_info_p, int, tree);
+extern int dump_enabled_p (enum tree_dump_index);
+extern FILE *dump_begin (enum tree_dump_index, int *);
+extern void dump_end (enum tree_dump_index, FILE *);
+extern void dump_node (tree, int, FILE *);
+extern int dump_switch_p (const char *);
+extern const char *dump_flag_name (enum tree_dump_index);
/* Assign the RTX to declaration. */
-extern void set_decl_rtl PARAMS ((tree, rtx));
+extern void set_decl_rtl (tree, rtx);
\f
/* Redefine abort to report an internal error w/o coredump, and
reporting the location of the error in the source file. This logic
special abort includes one or both. toplev.h gets too few files,
system.h gets too many. */
-extern void fancy_abort PARAMS ((const char *, int, const char *))
+extern void fancy_abort (const char *, int, const char *)
ATTRIBUTE_NORETURN;
#define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__)
projects / thirdparty / gcc.git / commitdiff
