+2003-06-29 Andreas Jaeger <aj@suse.de>
+
+ * cse.c: Convert prototypes to ISO C90.
+ * cselib.c: Likewise.
+ * cselib.h: Likewise.
+ * dbxout.c: Likewise.
+ * debug.c: Likewise.
+ * df.c: Likewise.
+ * df.h: Likewise.
+ * dojump.c: Likewise.
+ * doloop.c: Likewise.
+ * dominance.c: Likewise.
+ * dwarf2asm.c: Likewise.
+ * dwarf2out.c: Likewise.
+ * dwarf2out.h: Likewise.
+ * dwarfout.c: Likewise.
+
2003-06-29 Kazu Hirata <kazu@cs.umass.edu>
* alloc-pool.c: Fix comment formatting.
a cost of 2. Aside from these special cases, call `rtx_cost'. */
#define CHEAP_REGNO(N) \
- ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
- || (N) == STACK_POINTER_REGNUM || (N) == ARG_POINTER_REGNUM \
- || ((N) >= FIRST_VIRTUAL_REGISTER && (N) <= LAST_VIRTUAL_REGISTER) \
+ ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
+ || (N) == STACK_POINTER_REGNUM || (N) == ARG_POINTER_REGNUM \
+ || ((N) >= FIRST_VIRTUAL_REGISTER && (N) <= LAST_VIRTUAL_REGISTER) \
|| ((N) < FIRST_PSEUDO_REGISTER \
&& FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS))
/* Get the info associated with register N. */
-#define GET_CSE_REG_INFO(N) \
+#define GET_CSE_REG_INFO(N) \
(((N) == cached_regno && cached_cse_reg_info) \
? cached_cse_reg_info : get_cse_reg_info ((N)))
} *path;
};
-static bool fixed_base_plus_p PARAMS ((rtx x));
-static int notreg_cost PARAMS ((rtx, enum rtx_code));
-static int approx_reg_cost_1 PARAMS ((rtx *, void *));
-static int approx_reg_cost PARAMS ((rtx));
-static int preferrable PARAMS ((int, int, int, int));
-static void new_basic_block PARAMS ((void));
-static void make_new_qty PARAMS ((unsigned int, enum machine_mode));
-static void make_regs_eqv PARAMS ((unsigned int, unsigned int));
-static void delete_reg_equiv PARAMS ((unsigned int));
-static int mention_regs PARAMS ((rtx));
-static int insert_regs PARAMS ((rtx, struct table_elt *, int));
-static void remove_from_table PARAMS ((struct table_elt *, unsigned));
-static struct table_elt *lookup PARAMS ((rtx, unsigned, enum machine_mode)),
- *lookup_for_remove PARAMS ((rtx, unsigned, enum machine_mode));
-static rtx lookup_as_function PARAMS ((rtx, enum rtx_code));
-static struct table_elt *insert PARAMS ((rtx, struct table_elt *, unsigned,
- enum machine_mode));
-static void merge_equiv_classes PARAMS ((struct table_elt *,
- struct table_elt *));
-static void invalidate PARAMS ((rtx, enum machine_mode));
-static int cse_rtx_varies_p PARAMS ((rtx, int));
-static void remove_invalid_refs PARAMS ((unsigned int));
-static void remove_invalid_subreg_refs PARAMS ((unsigned int, unsigned int,
- enum machine_mode));
-static void rehash_using_reg PARAMS ((rtx));
-static void invalidate_memory PARAMS ((void));
-static void invalidate_for_call PARAMS ((void));
-static rtx use_related_value PARAMS ((rtx, struct table_elt *));
-static unsigned canon_hash PARAMS ((rtx, enum machine_mode));
-static unsigned canon_hash_string PARAMS ((const char *));
-static unsigned safe_hash PARAMS ((rtx, enum machine_mode));
-static int exp_equiv_p PARAMS ((rtx, rtx, int, int));
-static rtx canon_reg PARAMS ((rtx, rtx));
-static void find_best_addr PARAMS ((rtx, rtx *, enum machine_mode));
-static enum rtx_code find_comparison_args PARAMS ((enum rtx_code, rtx *, rtx *,
- enum machine_mode *,
- enum machine_mode *));
-static rtx fold_rtx PARAMS ((rtx, rtx));
-static rtx equiv_constant PARAMS ((rtx));
-static void record_jump_equiv PARAMS ((rtx, int));
-static void record_jump_cond PARAMS ((enum rtx_code, enum machine_mode,
- rtx, rtx, int));
-static void cse_insn PARAMS ((rtx, rtx));
-static int addr_affects_sp_p PARAMS ((rtx));
-static void invalidate_from_clobbers PARAMS ((rtx));
-static rtx cse_process_notes PARAMS ((rtx, rtx));
-static void cse_around_loop PARAMS ((rtx));
-static void invalidate_skipped_set PARAMS ((rtx, rtx, void *));
-static void invalidate_skipped_block PARAMS ((rtx));
-static void cse_check_loop_start PARAMS ((rtx, rtx, void *));
-static void cse_set_around_loop PARAMS ((rtx, rtx, rtx));
-static rtx cse_basic_block PARAMS ((rtx, rtx, struct branch_path *, int));
-static void count_reg_usage PARAMS ((rtx, int *, rtx, int));
-static int check_for_label_ref PARAMS ((rtx *, void *));
-extern void dump_class PARAMS ((struct table_elt*));
-static struct cse_reg_info * get_cse_reg_info PARAMS ((unsigned int));
-static int check_dependence PARAMS ((rtx *, void *));
-
-static void flush_hash_table PARAMS ((void));
-static bool insn_live_p PARAMS ((rtx, int *));
-static bool set_live_p PARAMS ((rtx, rtx, int *));
-static bool dead_libcall_p PARAMS ((rtx, int *));
+static bool fixed_base_plus_p (rtx x);
+static int notreg_cost (rtx, enum rtx_code);
+static int approx_reg_cost_1 (rtx *, void *);
+static int approx_reg_cost (rtx);
+static int preferrable (int, int, int, int);
+static void new_basic_block (void);
+static void make_new_qty (unsigned int, enum machine_mode);
+static void make_regs_eqv (unsigned int, unsigned int);
+static void delete_reg_equiv (unsigned int);
+static int mention_regs (rtx);
+static int insert_regs (rtx, struct table_elt *, int);
+static void remove_from_table (struct table_elt *, unsigned);
+static struct table_elt *lookup (rtx, unsigned, enum machine_mode);
+static struct table_elt *lookup_for_remove (rtx, unsigned, enum machine_mode);
+static rtx lookup_as_function (rtx, enum rtx_code);
+static struct table_elt *insert (rtx, struct table_elt *, unsigned,
+ enum machine_mode);
+static void merge_equiv_classes (struct table_elt *, struct table_elt *);
+static void invalidate (rtx, enum machine_mode);
+static int cse_rtx_varies_p (rtx, int);
+static void remove_invalid_refs (unsigned int);
+static void remove_invalid_subreg_refs (unsigned int, unsigned int,
+ enum machine_mode);
+static void rehash_using_reg (rtx);
+static void invalidate_memory (void);
+static void invalidate_for_call (void);
+static rtx use_related_value (rtx, struct table_elt *);
+static unsigned canon_hash (rtx, enum machine_mode);
+static unsigned canon_hash_string (const char *);
+static unsigned safe_hash (rtx, enum machine_mode);
+static int exp_equiv_p (rtx, rtx, int, int);
+static rtx canon_reg (rtx, rtx);
+static void find_best_addr (rtx, rtx *, enum machine_mode);
+static enum rtx_code find_comparison_args (enum rtx_code, rtx *, rtx *,
+ enum machine_mode *,
+ enum machine_mode *);
+static rtx fold_rtx (rtx, rtx);
+static rtx equiv_constant (rtx);
+static void record_jump_equiv (rtx, int);
+static void record_jump_cond (enum rtx_code, enum machine_mode, rtx, rtx,
+ int);
+static void cse_insn (rtx, rtx);
+static int addr_affects_sp_p (rtx);
+static void invalidate_from_clobbers (rtx);
+static rtx cse_process_notes (rtx, rtx);
+static void cse_around_loop (rtx);
+static void invalidate_skipped_set (rtx, rtx, void *);
+static void invalidate_skipped_block (rtx);
+static void cse_check_loop_start (rtx, rtx, void *);
+static void cse_set_around_loop (rtx, rtx, rtx);
+static rtx cse_basic_block (rtx, rtx, struct branch_path *, int);
+static void count_reg_usage (rtx, int *, rtx, int);
+static int check_for_label_ref (rtx *, void *);
+extern void dump_class (struct table_elt*);
+static struct cse_reg_info * get_cse_reg_info (unsigned int);
+static int check_dependence (rtx *, void *);
+
+static void flush_hash_table (void);
+static bool insn_live_p (rtx, int *);
+static bool set_live_p (rtx, rtx, int *);
+static bool dead_libcall_p (rtx, int *);
\f
/* Nonzero if X has the form (PLUS frame-pointer integer). We check for
virtual regs here because the simplify_*_operation routines are called
by integrate.c, which is called before virtual register instantiation. */
static bool
-fixed_base_plus_p (x)
- rtx x;
+fixed_base_plus_p (rtx x)
{
switch (GET_CODE (x))
{
/* Dump the expressions in the equivalence class indicated by CLASSP.
This function is used only for debugging. */
void
-dump_class (classp)
- struct table_elt *classp;
+dump_class (struct table_elt *classp)
{
struct table_elt *elt;
/* Subroutine of approx_reg_cost; called through for_each_rtx. */
static int
-approx_reg_cost_1 (xp, data)
- rtx *xp;
- void *data;
+approx_reg_cost_1 (rtx *xp, void *data)
{
rtx x = *xp;
int *cost_p = data;
0. If any other hard register reference occurs, return MAX_COST. */
static int
-approx_reg_cost (x)
- rtx x;
+approx_reg_cost (rtx x)
{
int cost = 0;
Return a positive value if A is less desirable, or 0 if the two are
equally good. */
static int
-preferrable (cost_a, regcost_a, cost_b, regcost_b)
- int cost_a, regcost_a, cost_b, regcost_b;
+preferrable (int cost_a, int regcost_a, int cost_b, int regcost_b)
{
/* First, get rid of cases involving expressions that are entirely
unwanted. */
from COST macro to keep it simple. */
static int
-notreg_cost (x, outer)
- rtx x;
- enum rtx_code outer;
+notreg_cost (rtx x, enum rtx_code outer)
{
return ((GET_CODE (x) == SUBREG
&& GET_CODE (SUBREG_REG (x)) == REG
Other uses like the latter are expected in the future. */
int
-rtx_cost (x, outer_code)
- rtx x;
- enum rtx_code outer_code ATTRIBUTE_UNUSED;
+rtx_cost (rtx x, enum rtx_code outer_code ATTRIBUTE_UNUSED)
{
int i, j;
enum rtx_code code;
Expect that X is properly formed address reference. */
int
-address_cost (x, mode)
- rtx x;
- enum machine_mode mode;
+address_cost (rtx x, enum machine_mode mode)
{
/* The address_cost target hook does not deal with ADDRESSOF nodes. But,
during CSE, such nodes are present. Using an ADDRESSOF node which
/* If the target doesn't override, compute the cost as with arithmetic. */
int
-default_address_cost (x)
- rtx x;
+default_address_cost (rtx x)
{
return rtx_cost (x, MEM);
}
\f
static struct cse_reg_info *
-get_cse_reg_info (regno)
- unsigned int regno;
+get_cse_reg_info (unsigned int regno)
{
struct cse_reg_info **hash_head = ®_hash[REGHASH_FN (regno)];
struct cse_reg_info *p;
for a new basic block. */
static void
-new_basic_block ()
+new_basic_block (void)
{
int i;
register before and initialize that quantity. */
static void
-make_new_qty (reg, mode)
- unsigned int reg;
- enum machine_mode mode;
+make_new_qty (unsigned int reg, enum machine_mode mode)
{
int q;
struct qty_table_elem *ent;
OLD is not changing; NEW is. */
static void
-make_regs_eqv (new, old)
- unsigned int new, old;
+make_regs_eqv (unsigned int new, unsigned int old)
{
unsigned int lastr, firstr;
int q = REG_QTY (old);
/* Remove REG from its equivalence class. */
static void
-delete_reg_equiv (reg)
- unsigned int reg;
+delete_reg_equiv (unsigned int reg)
{
struct qty_table_elem *ent;
int q = REG_QTY (reg);
of X. */
static int
-mention_regs (x)
- rtx x;
+mention_regs (rtx x)
{
enum rtx_code code;
int i, j;
so X's hash code may be different. */
static int
-insert_regs (x, classp, modified)
- rtx x;
- struct table_elt *classp;
- int modified;
+insert_regs (rtx x, struct table_elt *classp, int modified)
{
if (GET_CODE (x) == REG)
{
and we save much time not recomputing it. */
static void
-remove_from_table (elt, hash)
- struct table_elt *elt;
- unsigned hash;
+remove_from_table (struct table_elt *elt, unsigned int hash)
{
if (elt == 0)
return;
looks like X. */
static struct table_elt *
-lookup (x, hash, mode)
- rtx x;
- unsigned hash;
- enum machine_mode mode;
+lookup (rtx x, unsigned int hash, enum machine_mode mode)
{
struct table_elt *p;
Also ignore discrepancies in the machine mode of a register. */
static struct table_elt *
-lookup_for_remove (x, hash, mode)
- rtx x;
- unsigned hash;
- enum machine_mode mode;
+lookup_for_remove (rtx x, unsigned int hash, enum machine_mode mode)
{
struct table_elt *p;
If one is found, return that expression. */
static rtx
-lookup_as_function (x, code)
- rtx x;
- enum rtx_code code;
+lookup_as_function (rtx x, enum rtx_code code)
{
struct table_elt *p
= lookup (x, safe_hash (x, VOIDmode) & HASH_MASK, GET_MODE (x));
(preferrable ((X)->cost, (X)->regcost, (Y)->cost, (Y)->regcost) < 0)
static struct table_elt *
-insert (x, classp, hash, mode)
- rtx x;
- struct table_elt *classp;
- unsigned hash;
- enum machine_mode mode;
+insert (rtx x, struct table_elt *classp, unsigned int hash, enum machine_mode mode)
{
struct table_elt *elt;
Any invalid entries in CLASS2 will not be copied. */
static void
-merge_equiv_classes (class1, class2)
- struct table_elt *class1, *class2;
+merge_equiv_classes (struct table_elt *class1, struct table_elt *class2)
{
struct table_elt *elt, *next, *new;
/* Flush the entire hash table. */
static void
-flush_hash_table ()
+flush_hash_table (void)
{
int i;
struct table_elt *p;
};
static int
-check_dependence (x, data)
- rtx *x;
- void *data;
+check_dependence (rtx *x, void *data)
{
struct check_dependence_data *d = (struct check_dependence_data *) data;
if (*x && GET_CODE (*x) == MEM)
or it may be either of those plus a numeric offset. */
static void
-invalidate (x, full_mode)
- rtx x;
- enum machine_mode full_mode;
+invalidate (rtx x, enum machine_mode full_mode)
{
int i;
struct table_elt *p;
expressions to reappear as valid. */
static void
-remove_invalid_refs (regno)
- unsigned int regno;
+remove_invalid_refs (unsigned int regno)
{
unsigned int i;
struct table_elt *p, *next;
/* Likewise for a subreg with subreg_reg REGNO, subreg_byte OFFSET,
and mode MODE. */
static void
-remove_invalid_subreg_refs (regno, offset, mode)
- unsigned int regno;
- unsigned int offset;
- enum machine_mode mode;
+remove_invalid_subreg_refs (unsigned int regno, unsigned int offset,
+ enum machine_mode mode)
{
unsigned int i;
struct table_elt *p, *next;
This is called when we make a jump equivalence. */
static void
-rehash_using_reg (x)
- rtx x;
+rehash_using_reg (rtx x)
{
unsigned int i;
struct table_elt *p, *next;
register. Also update their TICK values. */
static void
-invalidate_for_call ()
+invalidate_for_call (void)
{
unsigned int regno, endregno;
unsigned int i;
If none can be found, return 0. */
static rtx
-use_related_value (x, elt)
- rtx x;
- struct table_elt *elt;
+use_related_value (rtx x, struct table_elt *elt)
{
struct table_elt *relt = 0;
struct table_elt *p, *q;
\f
/* Hash a string. Just add its bytes up. */
static inline unsigned
-canon_hash_string (ps)
- const char *ps;
+canon_hash_string (const char *ps)
{
unsigned hash = 0;
const unsigned char *p = (const unsigned char *) ps;
is just (int) MEM plus the hash code of the address. */
static unsigned
-canon_hash (x, mode)
- rtx x;
- enum machine_mode mode;
+canon_hash (rtx x, enum machine_mode mode)
{
int i, j;
unsigned hash = 0;
record = false;
else
record = true;
-
+
if (!record)
{
do_not_record = 1;
/* Like canon_hash but with no side effects. */
static unsigned
-safe_hash (x, mode)
- rtx x;
- enum machine_mode mode;
+safe_hash (rtx x, enum machine_mode mode)
{
int save_do_not_record = do_not_record;
int save_hash_arg_in_memory = hash_arg_in_memory;
is the same as that of the given value is pure luck. */
static int
-exp_equiv_p (x, y, validate, equal_values)
- rtx x, y;
- int validate;
- int equal_values;
+exp_equiv_p (rtx x, rtx y, int validate, int equal_values)
{
int i, j;
enum rtx_code code;
against certain constants or near-constants. */
static int
-cse_rtx_varies_p (x, from_alias)
- rtx x;
- int from_alias;
+cse_rtx_varies_p (rtx x, int from_alias)
{
/* We need not check for X and the equivalence class being of the same
mode because if X is equivalent to a constant in some mode, it
generally be discarded since the changes we are making are optional. */
static rtx
-canon_reg (x, insn)
- rtx x;
- rtx insn;
+canon_reg (rtx x, rtx insn)
{
int i;
enum rtx_code code;
hard registers here because we would also prefer the pseudo registers. */
static void
-find_best_addr (insn, loc, mode)
- rtx insn;
- rtx *loc;
- enum machine_mode mode;
+find_best_addr (rtx insn, rtx *loc, enum machine_mode mode)
{
struct table_elt *elt;
rtx addr = *loc;
A or the code corresponding to the inverse of the comparison. */
static enum rtx_code
-find_comparison_args (code, parg1, parg2, pmode1, pmode2)
- enum rtx_code code;
- rtx *parg1, *parg2;
- enum machine_mode *pmode1, *pmode2;
+find_comparison_args (enum rtx_code code, rtx *parg1, rtx *parg2,
+ enum machine_mode *pmode1, enum machine_mode *pmode2)
{
rtx arg1, arg2;
of X before modifying it. */
static rtx
-fold_rtx (x, insn)
- rtx x;
- rtx insn;
+fold_rtx (rtx x, rtx insn)
{
enum rtx_code code;
enum machine_mode mode;
|| code == UNORDERED)
{
if (must_swap || (const_arg0
- && (const_arg1 == 0
- || (GET_CODE (const_arg0) == CONST_INT
+ && (const_arg1 == 0
+ || (GET_CODE (const_arg0) == CONST_INT
&& GET_CODE (const_arg1) != CONST_INT))))
{
rtx tem = XEXP (x, 0);
Return 0 if we don't know one. */
static rtx
-equiv_constant (x)
- rtx x;
+equiv_constant (rtx x)
{
if (GET_CODE (x) == REG
&& REGNO_QTY_VALID_P (REGNO (x)))
This is similar to gen_lowpart in emit-rtl.c. */
rtx
-gen_lowpart_if_possible (mode, x)
- enum machine_mode mode;
- rtx x;
+gen_lowpart_if_possible (enum machine_mode mode, rtx x)
{
rtx result = gen_lowpart_common (mode, x);
In certain cases, this can cause us to add an equivalence. For example,
if we are following the taken case of
- if (i == 2)
+ if (i == 2)
we can add the fact that `i' and '2' are now equivalent.
In any case, we can record that this comparison was passed. If the same
comparison is seen later, we will know its value. */
static void
-record_jump_equiv (insn, taken)
- rtx insn;
- int taken;
+record_jump_equiv (rtx insn, int taken)
{
int cond_known_true;
rtx op0, op1;
above function and called recursively. */
static void
-record_jump_cond (code, mode, op0, op1, reversed_nonequality)
- enum rtx_code code;
- enum machine_mode mode;
- rtx op0, op1;
- int reversed_nonequality;
+record_jump_cond (enum rtx_code code, enum machine_mode mode, rtx op0,
+ rtx op1, int reversed_nonequality)
{
unsigned op0_hash, op1_hash;
int op0_in_memory, op1_in_memory;
};
static void
-cse_insn (insn, libcall_insn)
- rtx insn;
- rtx libcall_insn;
+cse_insn (rtx insn, rtx libcall_insn)
{
rtx x = PATTERN (insn);
int i;
}
while (prev && GET_CODE (prev) == NOTE
&& NOTE_LINE_NUMBER (prev) != NOTE_INSN_BASIC_BLOCK);
-
+
/* Do not swap the registers around if the previous instruction
attaches a REG_EQUIV note to REG1.
/* Remove from the hash table all expressions that reference memory. */
static void
-invalidate_memory ()
+invalidate_memory (void)
{
int i;
struct table_elt *p, *next;
1 and update the register tables to show the effect. Else, return 0. */
static int
-addr_affects_sp_p (addr)
- rtx addr;
+addr_affects_sp_p (rtx addr)
{
if (GET_RTX_CLASS (GET_CODE (addr)) == 'a'
&& GET_CODE (XEXP (addr, 0)) == REG
X is the pattern of the insn. */
static void
-invalidate_from_clobbers (x)
- rtx x;
+invalidate_from_clobbers (rtx x)
{
if (GET_CODE (x) == CLOBBER)
{
Return the replacement for X. */
static rtx
-cse_process_notes (x, object)
- rtx x;
- rtx object;
+cse_process_notes (rtx x, rtx object)
{
enum rtx_code code = GET_CODE (x);
const char *fmt = GET_RTX_FORMAT (code);
jumps to a label used only once. */
static void
-cse_around_loop (loop_start)
- rtx loop_start;
+cse_around_loop (rtx loop_start)
{
rtx insn;
int i;
since they are done elsewhere. This function is called via note_stores. */
static void
-invalidate_skipped_set (dest, set, data)
- rtx set;
- rtx dest;
- void *data ATTRIBUTE_UNUSED;
+invalidate_skipped_set (rtx dest, rtx set, void *data ATTRIBUTE_UNUSED)
{
enum rtx_code code = GET_CODE (dest);
conditionally executed. */
static void
-invalidate_skipped_block (start)
- rtx start;
+invalidate_skipped_block (rtx start)
{
rtx insn;
NULL_RTX. */
static void
-cse_check_loop_start (x, set, data)
- rtx x;
- rtx set ATTRIBUTE_UNUSED;
- void *data;
+cse_check_loop_start (rtx x, rtx set ATTRIBUTE_UNUSED, void *data)
{
rtx *cse_check_loop_start_value = (rtx *) data;
In any event, we invalidate whatever this SET or CLOBBER modifies. */
static void
-cse_set_around_loop (x, insn, loop_start)
- rtx x;
- rtx insn;
- rtx loop_start;
+cse_set_around_loop (rtx x, rtx insn, rtx loop_start)
{
struct table_elt *src_elt;
to construct the output branch path. */
void
-cse_end_of_basic_block (insn, data, follow_jumps, after_loop, skip_blocks)
- rtx insn;
- struct cse_basic_block_data *data;
- int follow_jumps;
- int after_loop;
- int skip_blocks;
+cse_end_of_basic_block (rtx insn, struct cse_basic_block_data *data,
+ int follow_jumps, int after_loop, int skip_blocks)
{
rtx p = insn, q;
int nsets = 0;
in conditional jump instructions. */
int
-cse_main (f, nregs, after_loop, file)
- rtx f;
- int nregs;
- int after_loop;
- FILE *file;
+cse_main (rtx f, int nregs, int after_loop, FILE *file)
{
struct cse_basic_block_data val;
rtx insn = f;
block and this CSE pass is before loop.c. */
static rtx
-cse_basic_block (from, to, next_branch, around_loop)
- rtx from, to;
- struct branch_path *next_branch;
- int around_loop;
+cse_basic_block (rtx from, rtx to, struct branch_path *next_branch,
+ int around_loop)
{
rtx insn;
int to_usage = 0;
there isn't a REG_LABEL note. Return one if so. DATA is the insn. */
static int
-check_for_label_ref (rtl, data)
- rtx *rtl;
- void *data;
+check_for_label_ref (rtx *rtl, void *data)
{
rtx insn = (rtx) data;
modify the liveness of DEST. */
static void
-count_reg_usage (x, counts, dest, incr)
- rtx x;
- int *counts;
- rtx dest;
- int incr;
+count_reg_usage (rtx x, int *counts, rtx dest, int incr)
{
enum rtx_code code;
rtx note;
\f
/* Return true if set is live. */
static bool
-set_live_p (set, insn, counts)
- rtx set;
- rtx insn ATTRIBUTE_UNUSED; /* Only used with HAVE_cc0. */
- int *counts;
+set_live_p (rtx set, rtx insn ATTRIBUTE_UNUSED, /* Only used with HAVE_cc0. */
+ int *counts)
{
#ifdef HAVE_cc0
rtx tem;
/* Return true if insn is live. */
static bool
-insn_live_p (insn, counts)
- rtx insn;
- int *counts;
+insn_live_p (rtx insn, int *counts)
{
int i;
if (flag_non_call_exceptions && may_trap_p (PATTERN (insn)))
/* Return true if libcall is dead as a whole. */
static bool
-dead_libcall_p (insn, counts)
- rtx insn;
- int *counts;
+dead_libcall_p (rtx insn, int *counts)
{
rtx note, set, new;
return true;
}
}
-
+
count_reg_usage (insn, counts, NULL_RTX, 1);
return false;
}
remaining passes of the compilation are also sped up. */
int
-delete_trivially_dead_insns (insns, nreg)
- rtx insns;
- int nreg;
+delete_trivially_dead_insns (rtx insns, int nreg)
{
int *counts;
rtx insn, prev;
#include "hashtab.h"
#include "cselib.h"
-static int entry_and_rtx_equal_p PARAMS ((const void *, const void *));
-static hashval_t get_value_hash PARAMS ((const void *));
-static struct elt_list *new_elt_list PARAMS ((struct elt_list *,
- cselib_val *));
-static struct elt_loc_list *new_elt_loc_list PARAMS ((struct elt_loc_list *,
- rtx));
-static void unchain_one_value PARAMS ((cselib_val *));
-static void unchain_one_elt_list PARAMS ((struct elt_list **));
-static void unchain_one_elt_loc_list PARAMS ((struct elt_loc_list **));
-static void clear_table PARAMS ((void));
-static int discard_useless_locs PARAMS ((void **, void *));
-static int discard_useless_values PARAMS ((void **, void *));
-static void remove_useless_values PARAMS ((void));
-static rtx wrap_constant PARAMS ((enum machine_mode, rtx));
-static unsigned int hash_rtx PARAMS ((rtx, enum machine_mode, int));
-static cselib_val *new_cselib_val PARAMS ((unsigned int,
- enum machine_mode));
-static void add_mem_for_addr PARAMS ((cselib_val *, cselib_val *,
- rtx));
-static cselib_val *cselib_lookup_mem PARAMS ((rtx, int));
-static void cselib_invalidate_regno PARAMS ((unsigned int,
- enum machine_mode));
-static int cselib_mem_conflict_p PARAMS ((rtx, rtx));
-static void cselib_invalidate_mem PARAMS ((rtx));
-static void cselib_invalidate_rtx PARAMS ((rtx, rtx, void *));
-static void cselib_record_set PARAMS ((rtx, cselib_val *,
- cselib_val *));
-static void cselib_record_sets PARAMS ((rtx));
+static int entry_and_rtx_equal_p (const void *, const void *);
+static hashval_t get_value_hash (const void *);
+static struct elt_list *new_elt_list (struct elt_list *, cselib_val *);
+static struct elt_loc_list *new_elt_loc_list (struct elt_loc_list *, rtx);
+static void unchain_one_value (cselib_val *);
+static void unchain_one_elt_list (struct elt_list **);
+static void unchain_one_elt_loc_list (struct elt_loc_list **);
+static void clear_table (void);
+static int discard_useless_locs (void **, void *);
+static int discard_useless_values (void **, void *);
+static void remove_useless_values (void);
+static rtx wrap_constant (enum machine_mode, rtx);
+static unsigned int hash_rtx (rtx, enum machine_mode, int);
+static cselib_val *new_cselib_val (unsigned int, enum machine_mode);
+static void add_mem_for_addr (cselib_val *, cselib_val *, rtx);
+static cselib_val *cselib_lookup_mem (rtx, int);
+static void cselib_invalidate_regno (unsigned int, enum machine_mode);
+static int cselib_mem_conflict_p (rtx, rtx);
+static void cselib_invalidate_mem (rtx);
+static void cselib_invalidate_rtx (rtx, rtx, void *);
+static void cselib_record_set (rtx, cselib_val *, cselib_val *);
+static void cselib_record_sets (rtx);
/* There are three ways in which cselib can look up an rtx:
- for a REG, the reg_values table (which is indexed by regno) is used
presence in the list by checking the next pointer. */
static cselib_val dummy_val;
-/* Used to list all values that contain memory reference.
+/* Used to list all values that contain memory reference.
May or may not contain the useless values - the list is compacted
each time memory is invalidated. */
static cselib_val *first_containing_mem = &dummy_val;
arguments. */
static struct elt_list *
-new_elt_list (next, elt)
- struct elt_list *next;
- cselib_val *elt;
+new_elt_list (struct elt_list *next, cselib_val *elt)
{
struct elt_list *el = empty_elt_lists;
arguments. */
static struct elt_loc_list *
-new_elt_loc_list (next, loc)
- struct elt_loc_list *next;
- rtx loc;
+new_elt_loc_list (struct elt_loc_list *next, rtx loc)
{
struct elt_loc_list *el = empty_elt_loc_lists;
storage. */
static void
-unchain_one_elt_list (pl)
- struct elt_list **pl;
+unchain_one_elt_list (struct elt_list **pl)
{
struct elt_list *l = *pl;
/* Likewise for elt_loc_lists. */
static void
-unchain_one_elt_loc_list (pl)
- struct elt_loc_list **pl;
+unchain_one_elt_loc_list (struct elt_loc_list **pl)
{
struct elt_loc_list *l = *pl;
V. */
static void
-unchain_one_value (v)
- cselib_val *v;
+unchain_one_value (cselib_val *v)
{
while (v->addr_list)
unchain_one_elt_list (&v->addr_list);
which are known to have been used. */
static void
-clear_table ()
+clear_table (void)
{
unsigned int i;
CONST of an appropriate mode. */
static int
-entry_and_rtx_equal_p (entry, x_arg)
- const void *entry, *x_arg;
+entry_and_rtx_equal_p (const void *entry, const void *x_arg)
{
struct elt_loc_list *l;
const cselib_val *v = (const cselib_val *) entry;
&& (GET_CODE (XEXP (x, 0)) == CONST_INT
|| GET_CODE (XEXP (x, 0)) == CONST_DOUBLE))
x = XEXP (x, 0);
-
+
/* We don't guarantee that distinct rtx's have different hash values,
so we need to do a comparison. */
for (l = v->locs; l; l = l->next)
value from a cselib_val structure. */
static hashval_t
-get_value_hash (entry)
- const void *entry;
+get_value_hash (const void *entry)
{
const cselib_val *v = (const cselib_val *) entry;
return v->value;
removed. */
int
-references_value_p (x, only_useless)
- rtx x;
- int only_useless;
+references_value_p (rtx x, int only_useless)
{
enum rtx_code code = GET_CODE (x);
const char *fmt = GET_RTX_FORMAT (code);
htab_traverse. */
static int
-discard_useless_locs (x, info)
- void **x;
- void *info ATTRIBUTE_UNUSED;
+discard_useless_locs (void **x, void *info ATTRIBUTE_UNUSED)
{
cselib_val *v = (cselib_val *)*x;
struct elt_loc_list **p = &v->locs;
/* If X is a value with no locations, remove it from the hashtable. */
static int
-discard_useless_values (x, info)
- void **x;
- void *info ATTRIBUTE_UNUSED;
+discard_useless_values (void **x, void *info ATTRIBUTE_UNUSED)
{
cselib_val *v = (cselib_val *)*x;
associated with them) from the hash table. */
static void
-remove_useless_values ()
+remove_useless_values (void)
{
cselib_val **p, *v;
/* First pass: eliminate locations that reference the value. That in
VOIDmode. */
enum machine_mode
-cselib_reg_set_mode (x)
- rtx x;
+cselib_reg_set_mode (rtx x)
{
if (GET_CODE (x) != REG)
return GET_MODE (x);
our gathered information into account. */
int
-rtx_equal_for_cselib_p (x, y)
- rtx x, y;
+rtx_equal_for_cselib_p (rtx x, rtx y)
{
enum rtx_code code;
const char *fmt;
int i;
-
+
if (GET_CODE (x) == REG || GET_CODE (x) == MEM)
{
cselib_val *e = cselib_lookup (x, GET_MODE (x), 0);
else if (rtx_equal_for_cselib_p (t, y))
return 1;
}
-
+
return 0;
}
else if (rtx_equal_for_cselib_p (x, t))
return 1;
}
-
+
return 0;
}
/* This won't be handled correctly by the code below. */
if (GET_CODE (x) == LABEL_REF)
return XEXP (x, 0) == XEXP (y, 0);
-
+
code = GET_CODE (x);
fmt = GET_RTX_FORMAT (code);
functions. For that purpose, wrap them in a CONST of the appropriate
mode. */
static rtx
-wrap_constant (mode, x)
- enum machine_mode mode;
- rtx x;
+wrap_constant (enum machine_mode mode, rtx x)
{
if (GET_CODE (x) != CONST_INT
&& (GET_CODE (x) != CONST_DOUBLE || GET_MODE (x) != VOIDmode))
otherwise the mode of X is used. */
static unsigned int
-hash_rtx (x, mode, create)
- rtx x;
- enum machine_mode mode;
- int create;
+hash_rtx (rtx x, enum machine_mode mode, int create)
{
cselib_val *e;
int i, j;
return 0;
break;
-
+
default:
break;
}
value is MODE. */
static cselib_val *
-new_cselib_val (value, mode)
- unsigned int value;
- enum machine_mode mode;
+new_cselib_val (unsigned int value, enum machine_mode mode)
{
cselib_val *e = empty_vals;
value. Update the two value structures to represent this situation. */
static void
-add_mem_for_addr (addr_elt, mem_elt, x)
- cselib_val *addr_elt, *mem_elt;
- rtx x;
+add_mem_for_addr (cselib_val *addr_elt, cselib_val *mem_elt, rtx x)
{
struct elt_loc_list *l;
If CREATE, make a new one if we haven't seen it before. */
static cselib_val *
-cselib_lookup_mem (x, create)
- rtx x;
- int create;
+cselib_lookup_mem (rtx x, int create)
{
enum machine_mode mode = GET_MODE (x);
void **slot;
allocated. However, the return value can share rtl with X. */
rtx
-cselib_subst_to_values (x)
- rtx x;
+cselib_subst_to_values (rtx x)
{
enum rtx_code code = GET_CODE (x);
const char *fmt = GET_RTX_FORMAT (code);
case PRE_MODIFY:
e = new_cselib_val (++next_unknown_value, GET_MODE (x));
return e->u.val_rtx;
-
+
default:
break;
}
(i.e. because it's a constant). */
cselib_val *
-cselib_lookup (x, mode, create)
- rtx x;
- enum machine_mode mode;
- int create;
+cselib_lookup (rtx x, enum machine_mode mode, int create)
{
void **slot;
cselib_val *e;
invalidating call clobbered registers across a call. */
static void
-cselib_invalidate_regno (regno, mode)
- unsigned int regno;
- enum machine_mode mode;
+cselib_invalidate_regno (unsigned int regno, enum machine_mode mode)
{
unsigned int endregno;
unsigned int i;
{
if (mode == VOIDmode)
abort ();
-
+
if (regno < max_value_regs)
i = 0;
else
Return whether this change will invalidate VAL. */
static int
-cselib_mem_conflict_p (mem_base, val)
- rtx mem_base;
- rtx val;
+cselib_mem_conflict_p (rtx mem_base, rtx val)
{
enum rtx_code code;
const char *fmt;
instruction, MEM_RTX is (mem:BLK const0_rtx). */
static void
-cselib_invalidate_mem (mem_rtx)
- rtx mem_rtx;
+cselib_invalidate_mem (rtx mem_rtx)
{
cselib_val **vp, *v, *next;
note_stores; they are ignored. */
static void
-cselib_invalidate_rtx (dest, ignore, data)
- rtx dest;
- rtx ignore ATTRIBUTE_UNUSED;
- void *data ATTRIBUTE_UNUSED;
+cselib_invalidate_rtx (rtx dest, rtx ignore ATTRIBUTE_UNUSED,
+ void *data ATTRIBUTE_UNUSED)
{
while (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == SIGN_EXTRACT
|| GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SUBREG)
describes its address. */
static void
-cselib_record_set (dest, src_elt, dest_addr_elt)
- rtx dest;
- cselib_val *src_elt, *dest_addr_elt;
+cselib_record_set (rtx dest, cselib_val *src_elt, cselib_val *dest_addr_elt)
{
int dreg = GET_CODE (dest) == REG ? (int) REGNO (dest) : -1;
/* Record the effects of any sets in INSN. */
static void
-cselib_record_sets (insn)
- rtx insn;
+cselib_record_sets (rtx insn)
{
int n_sets = 0;
int i;
/* Record the effects of INSN. */
void
-cselib_process_insn (insn)
- rtx insn;
+cselib_process_insn (rtx insn)
{
int i;
rtx x;
it must be called by the user if it allocated new registers. */
void
-cselib_update_varray_sizes ()
+cselib_update_varray_sizes (void)
{
unsigned int nregs = max_reg_num ();
init_alias_analysis. */
void
-cselib_init ()
+cselib_init (void)
{
/* This is only created once. */
if (! callmem)
VARRAY_ELT_LIST_INIT (reg_values, cselib_nregs, "reg_values");
VARRAY_UINT_INIT (used_regs, cselib_nregs, "used_regs");
}
- hash_table = htab_create_ggc (31, get_value_hash, entry_and_rtx_equal_p,
+ hash_table = htab_create_ggc (31, get_value_hash, entry_and_rtx_equal_p,
NULL);
cselib_current_insn_in_libcall = false;
}
/* Called when the current user is done with cselib. */
void
-cselib_finish ()
+cselib_finish (void)
{
clear_table ();
reg_values_old = reg_values;
cselib_val *elt;
};
-extern cselib_val *cselib_lookup PARAMS ((rtx, enum machine_mode, int));
-extern void cselib_update_varray_sizes PARAMS ((void));
-extern void cselib_init PARAMS ((void));
-extern void cselib_finish PARAMS ((void));
-extern void cselib_process_insn PARAMS ((rtx));
-extern enum machine_mode cselib_reg_set_mode PARAMS ((rtx));
-extern int rtx_equal_for_cselib_p PARAMS ((rtx, rtx));
-extern int references_value_p PARAMS ((rtx, int));
-extern rtx cselib_subst_to_values PARAMS ((rtx));
+extern cselib_val *cselib_lookup (rtx, enum machine_mode, int);
+extern void cselib_update_varray_sizes (void);
+extern void cselib_init (void);
+extern void cselib_finish (void);
+extern void cselib_process_insn (rtx);
+extern enum machine_mode cselib_reg_set_mode (rtx);
+extern int rtx_equal_for_cselib_p (rtx, rtx);
+extern int references_value_p (rtx, int);
+extern rtx cselib_subst_to_values (rtx);
#define CONTIN do { } while (0)
#endif
-static void dbxout_init PARAMS ((const char *));
-static void dbxout_finish PARAMS ((const char *));
-static void dbxout_start_source_file PARAMS ((unsigned, const char *));
-static void dbxout_end_source_file PARAMS ((unsigned));
-static void dbxout_typedefs PARAMS ((tree));
-static void dbxout_fptype_value PARAMS ((tree));
-static void dbxout_type_index PARAMS ((tree));
+static void dbxout_init (const char *);
+static void dbxout_finish (const char *);
+static void dbxout_start_source_file (unsigned, const char *);
+static void dbxout_end_source_file (unsigned);
+static void dbxout_typedefs (tree);
+static void dbxout_fptype_value (tree);
+static void dbxout_type_index (tree);
#if DBX_CONTIN_LENGTH > 0
-static void dbxout_continue PARAMS ((void));
+static void dbxout_continue (void);
#endif
-static void dbxout_args PARAMS ((tree));
-static void dbxout_type_fields PARAMS ((tree));
-static void dbxout_type_method_1 PARAMS ((tree, const char *));
-static void dbxout_type_methods PARAMS ((tree));
-static void dbxout_range_type PARAMS ((tree));
-static void dbxout_type PARAMS ((tree, int));
-static bool print_int_cst_bounds_in_octal_p PARAMS ((tree));
-static void print_int_cst_octal PARAMS ((tree));
-static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
-static void print_wide_int PARAMS ((HOST_WIDE_INT));
-static void dbxout_type_name PARAMS ((tree));
-static void dbxout_class_name_qualifiers PARAMS ((tree));
-static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
-static void dbxout_symbol_name PARAMS ((tree, const char *, int));
-static void dbxout_prepare_symbol PARAMS ((tree));
-static void dbxout_finish_symbol PARAMS ((tree));
-static void dbxout_block PARAMS ((tree, int, tree));
-static void dbxout_global_decl PARAMS ((tree));
-static void dbxout_handle_pch PARAMS ((unsigned));
+static void dbxout_args (tree);
+static void dbxout_type_fields (tree);
+static void dbxout_type_method_1 (tree, const char *);
+static void dbxout_type_methods (tree);
+static void dbxout_range_type (tree);
+static void dbxout_type (tree, int);
+static bool print_int_cst_bounds_in_octal_p (tree);
+static void print_int_cst_octal (tree);
+static void print_octal (unsigned HOST_WIDE_INT, int);
+static void print_wide_int (HOST_WIDE_INT);
+static void dbxout_type_name (tree);
+static void dbxout_class_name_qualifiers (tree);
+static int dbxout_symbol_location (tree, tree, const char *, rtx);
+static void dbxout_symbol_name (tree, const char *, int);
+static void dbxout_prepare_symbol (tree);
+static void dbxout_finish_symbol (tree);
+static void dbxout_block (tree, int, tree);
+static void dbxout_global_decl (tree);
+static void dbxout_handle_pch (unsigned);
\f
/* The debug hooks structure. */
#if defined (DBX_DEBUGGING_INFO)
-static void dbxout_source_line PARAMS ((unsigned int, const char *));
-static void dbxout_source_file PARAMS ((FILE *, const char *));
-static void dbxout_function_end PARAMS ((void));
-static void dbxout_begin_function PARAMS ((tree));
-static void dbxout_begin_block PARAMS ((unsigned, unsigned));
-static void dbxout_end_block PARAMS ((unsigned, unsigned));
-static void dbxout_function_decl PARAMS ((tree));
+static void dbxout_source_line (unsigned int, const char *);
+static void dbxout_source_file (FILE *, const char *);
+static void dbxout_function_end (void);
+static void dbxout_begin_function (tree);
+static void dbxout_begin_block (unsigned, unsigned);
+static void dbxout_end_block (unsigned, unsigned);
+static void dbxout_function_decl (tree);
const struct gcc_debug_hooks dbx_debug_hooks =
{
\f
#if defined (DBX_DEBUGGING_INFO)
static void
-dbxout_function_end ()
+dbxout_function_end (void)
{
char lscope_label_name[100];
/* Convert Ltext into the appropriate format for local labels in case
Initialize `typevec' and output the standard data types of C. */
static void
-dbxout_init (input_file_name)
- const char *input_file_name;
+dbxout_init (const char *input_file_name)
{
char ltext_label_name[100];
tree syms = (*lang_hooks.decls.getdecls) ();
in the reverse order from that which is found in SYMS. */
static void
-dbxout_typedefs (syms)
- tree syms;
+dbxout_typedefs (tree syms)
{
if (syms)
{
/* Change to reading from a new source file. Generate a N_BINCL stab. */
static void
-dbxout_start_source_file (line, filename)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *filename ATTRIBUTE_UNUSED;
+dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
+ const char *filename ATTRIBUTE_UNUSED)
{
#ifdef DBX_USE_BINCL
struct dbx_file *n = (struct dbx_file *) ggc_alloc (sizeof *n);
/* Revert to reading a previous source file. Generate a N_EINCL stab. */
static void
-dbxout_end_source_file (line)
- unsigned int line ATTRIBUTE_UNUSED;
+dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
{
#ifdef DBX_USE_BINCL
fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
/* Output debugging info to FILE to switch to sourcefile FILENAME. */
static void
-dbxout_source_file (file, filename)
- FILE *file;
- const char *filename;
+dbxout_source_file (FILE *file, const char *filename)
{
if (lastfile == 0 && lastfile_is_base)
{
number LINENO. */
static void
-dbxout_source_line (lineno, filename)
- unsigned int lineno;
- const char *filename;
+dbxout_source_line (unsigned int lineno, const char *filename)
{
dbxout_source_file (asmfile, filename);
/* Describe the beginning of an internal block within a function. */
static void
-dbxout_begin_block (line, n)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int n;
+dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
{
(*targetm.asm_out.internal_label) (asmfile, "LBB", n);
}
/* Describe the end line-number of an internal block within a function. */
static void
-dbxout_end_block (line, n)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int n;
+dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
{
(*targetm.asm_out.internal_label) (asmfile, "LBE", n);
}
(including all the auto variables of the function). */
static void
-dbxout_function_decl (decl)
- tree decl;
+dbxout_function_decl (tree decl)
{
#ifndef DBX_FUNCTION_FIRST
dbxout_begin_function (decl);
/* Debug information for a global DECL. Called from toplev.c after
compilation proper has finished. */
static void
-dbxout_global_decl (decl)
- tree decl;
+dbxout_global_decl (tree decl)
{
if (TREE_CODE (decl) == VAR_DECL
&& ! DECL_EXTERNAL (decl)
to do nothing. */
static void
-dbxout_finish (filename)
- const char *filename ATTRIBUTE_UNUSED;
+dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
{
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
them. */
static void
-dbxout_fptype_value (type)
- tree type;
+dbxout_fptype_value (tree type)
{
char value = '0';
enum machine_mode mode = TYPE_MODE (type);
/* Output the index of a type. */
static void
-dbxout_type_index (type)
- tree type;
+dbxout_type_index (tree type)
{
#ifndef DBX_USE_BINCL
fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
.stabs "...rest",code,0,value */
static void
-dbxout_continue ()
+dbxout_continue (void)
{
#ifdef DBX_CONTIN_CHAR
fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
recursive calls. */
static void
-dbxout_type_fields (type)
- tree type;
+dbxout_type_fields (tree type)
{
tree tem;
now. */
static void
-dbxout_type_method_1 (decl, debug_name)
- tree decl;
- const char *debug_name;
+dbxout_type_method_1 (tree decl, const char *debug_name)
{
char c1 = 'A', c2;
in TYPE. */
static void
-dbxout_type_methods (type)
- tree type;
+dbxout_type_methods (tree type)
{
/* C++: put out the method names and their parameter lists */
tree methods = TYPE_METHODS (type);
TYPE is an INTEGER_TYPE. */
static void
-dbxout_range_type (type)
- tree type;
+dbxout_range_type (tree type)
{
fprintf (asmfile, "r");
if (TREE_TYPE (type))
using the number previously allocated. */
static void
-dbxout_type (type, full)
- tree type;
- int full;
+dbxout_type (tree type, int full)
{
tree tem;
tree main_variant;
{
typevec
= (struct typeinfo *) ggc_realloc (typevec,
- (typevec_len * 2
+ (typevec_len * 2
* sizeof typevec[0]));
memset ((char *) (typevec + typevec_len), 0,
typevec_len * sizeof typevec[0]);
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
debug_queue_symbol (TYPE_NAME (type));
}
-
+
/* Output the number of this type, to refer to it. */
dbxout_type_index (type);
{
tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
- if ((TREE_CODE (orig_type) == RECORD_TYPE
+ if ((TREE_CODE (orig_type) == RECORD_TYPE
|| TREE_CODE (orig_type) == UNION_TYPE
|| TREE_CODE (orig_type) == QUAL_UNION_TYPE
|| TREE_CODE (orig_type) == ENUMERAL_TYPE)
CHARS (5);
}
- if (print_int_cst_bounds_in_octal_p (type))
+ if (print_int_cst_bounds_in_octal_p (type))
{
fprintf (asmfile, "r");
CHARS (1);
tree child = BINFO_BASETYPE (binfo, i);
tree access = (BINFO_BASEACCESSES (binfo)
? BINFO_BASEACCESS (binfo, i) : access_public_node);
-
+
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
should be printed in octal format. */
static bool
-print_int_cst_bounds_in_octal_p (type)
- tree type;
+print_int_cst_bounds_in_octal_p (tree type)
{
/* If we can use GDB extensions and the size is wider than a long
(the size used by GDB to read them) or we may have trouble writing
the *target's* size of "long", not that of the host. The host test
is just to make sure we can write it out in case the host wide int
is narrower than the target "long".
-
+
For unsigned types, we use octal if they are the same size or larger.
This is because we print the bounds as signed decimal, and hence they
can't span same size unsigned types. */
handling double precision. */
static void
-print_int_cst_octal (c)
- tree c;
+print_int_cst_octal (tree c)
{
unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
}
static void
-print_octal (value, digits)
- unsigned HOST_WIDE_INT value;
- int digits;
+print_octal (unsigned HOST_WIDE_INT value, int digits)
{
int i;
/* Output C in decimal while adjusting the number of digits written. */
static void
-print_wide_int (c)
- HOST_WIDE_INT c;
+print_wide_int (HOST_WIDE_INT c)
{
int digs = 0;
or by struct, enum and union tags. */
static void
-dbxout_type_name (type)
- tree type;
+dbxout_type_name (tree type)
{
tree t;
if (TYPE_NAME (type) == 0)
type whose scope is limited to a struct or class. */
static void
-dbxout_class_name_qualifiers (decl)
- tree decl;
+dbxout_class_name_qualifiers (tree decl)
{
tree context = decl_type_context (decl);
- if (context != NULL_TREE
+ if (context != NULL_TREE
&& TREE_CODE(context) == RECORD_TYPE
- && TYPE_NAME (context) != 0
+ && TYPE_NAME (context) != 0
&& (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (context)) != 0)))
{
Return 1 if a stabs might have been emitted. */
int
-dbxout_symbol (decl, local)
- tree decl;
- int local ATTRIBUTE_UNUSED;
+dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
{
tree type = TREE_TYPE (decl);
tree context = NULL_TREE;
/* If we are to generate only the symbols actualy used then such
symbol nodees are flagged with TREE_USED. Ignore any that
aren't flaged as TREE_USED. */
-
+
if (flag_debug_only_used_symbols)
{
tree t;
pointer to a named type we need to look for the first name
we see following the TREE_TYPE chain. */
- t = type;
+ t = type;
while (POINTER_TYPE_P (t))
t = TREE_TYPE (t);
Returns 1 if the stab was really emitted. */
static int
-dbxout_symbol_location (decl, type, suffix, home)
- tree decl, type;
- const char *suffix;
- rtx home;
+dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
{
int letter = 0;
int regno = -1;
Then output LETTER to indicate the kind of location the symbol has. */
static void
-dbxout_symbol_name (decl, suffix, letter)
- tree decl;
- const char *suffix;
- int letter;
+dbxout_symbol_name (tree decl, const char *suffix, int letter)
{
const char *name;
}
static void
-dbxout_prepare_symbol (decl)
- tree decl ATTRIBUTE_UNUSED;
+dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED)
{
#ifdef WINNING_GDB
const char *filename = DECL_SOURCE_FILE (decl);
}
static void
-dbxout_finish_symbol (sym)
- tree sym;
+dbxout_finish_symbol (tree sym)
{
#ifdef DBX_FINISH_SYMBOL
DBX_FINISH_SYMBOL (sym);
anything was output */
int
-dbxout_syms (syms)
- tree syms;
+dbxout_syms (tree syms)
{
int result = 0;
while (syms)
of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
void
-dbxout_parms (parms)
- tree parms;
+dbxout_parms (tree parms)
{
++debug_nesting;
PARMS is a chain of PARM_DECL nodes. */
void
-dbxout_reg_parms (parms)
- tree parms;
+dbxout_reg_parms (tree parms)
{
++debug_nesting;
output definitions of those names, in raw form */
static void
-dbxout_args (args)
- tree args;
+dbxout_args (tree args)
{
while (args)
{
We handle them all in sequence. */
static void
-dbxout_block (block, depth, args)
- tree block;
- int depth;
- tree args;
+dbxout_block (tree block, int depth, tree args)
{
int blocknum = -1;
#if defined (DBX_DEBUGGING_INFO)
static void
-dbxout_begin_function (decl)
- tree decl;
+dbxout_begin_function (tree decl)
{
int saved_tree_used1 = TREE_USED (decl);
TREE_USED (decl) = 1;
if (DECL_NAME (DECL_RESULT (decl)) != 0)
{
- int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
+ int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
TREE_USED (DECL_RESULT (decl)) = 1;
dbxout_symbol (decl, 0);
TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
/* Do-nothing debug hooks for GCC.
- Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2001, 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
nothing. */
void
-debug_nothing_void ()
+debug_nothing_void (void)
{
}
void
-debug_nothing_tree (decl)
- tree decl ATTRIBUTE_UNUSED;
+debug_nothing_tree (tree decl ATTRIBUTE_UNUSED)
{
}
bool
-debug_true_tree (block)
- tree block ATTRIBUTE_UNUSED;
+debug_true_tree (tree block ATTRIBUTE_UNUSED)
{
return true;
}
void
-debug_nothing_rtx (insn)
- rtx insn ATTRIBUTE_UNUSED;
+debug_nothing_rtx (rtx insn ATTRIBUTE_UNUSED)
{
}
void
-debug_nothing_charstar (main_filename)
- const char *main_filename ATTRIBUTE_UNUSED;
+debug_nothing_charstar (const char *main_filename ATTRIBUTE_UNUSED)
{
}
void
-debug_nothing_int_charstar (line, text)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *text ATTRIBUTE_UNUSED;
+debug_nothing_int_charstar (unsigned int line ATTRIBUTE_UNUSED,
+ const char *text ATTRIBUTE_UNUSED)
{
}
void
-debug_nothing_int (line)
- unsigned int line ATTRIBUTE_UNUSED;
+debug_nothing_int (unsigned int line ATTRIBUTE_UNUSED)
{
}
void
-debug_nothing_int_int (line, n)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int n ATTRIBUTE_UNUSED;
+debug_nothing_int_int (unsigned int line ATTRIBUTE_UNUSED,
+ unsigned int n ATTRIBUTE_UNUSED)
{
}
static alloc_pool df_link_pool;
static struct df *ddf;
-static void df_reg_table_realloc PARAMS((struct df *, int));
-static void df_insn_table_realloc PARAMS((struct df *, unsigned int));
-static void df_bitmaps_alloc PARAMS((struct df *, int));
-static void df_bitmaps_free PARAMS((struct df *, int));
-static void df_free PARAMS((struct df *));
-static void df_alloc PARAMS((struct df *, int));
-
-static rtx df_reg_clobber_gen PARAMS((unsigned int));
-static rtx df_reg_use_gen PARAMS((unsigned int));
-
-static inline struct df_link *df_link_create PARAMS((struct ref *,
- struct df_link *));
-static struct df_link *df_ref_unlink PARAMS((struct df_link **, struct ref *));
-static void df_def_unlink PARAMS((struct df *, struct ref *));
-static void df_use_unlink PARAMS((struct df *, struct ref *));
-static void df_insn_refs_unlink PARAMS ((struct df *, basic_block, rtx));
+static void df_reg_table_realloc (struct df *, int);
+static void df_insn_table_realloc (struct df *, unsigned int);
+static void df_bitmaps_alloc (struct df *, int);
+static void df_bitmaps_free (struct df *, int);
+static void df_free (struct df *);
+static void df_alloc (struct df *, int);
+
+static rtx df_reg_clobber_gen (unsigned int);
+static rtx df_reg_use_gen (unsigned int);
+
+static inline struct df_link *df_link_create (struct ref *, struct df_link *);
+static struct df_link *df_ref_unlink (struct df_link **, struct ref *);
+static void df_def_unlink (struct df *, struct ref *);
+static void df_use_unlink (struct df *, struct ref *);
+static void df_insn_refs_unlink (struct df *, basic_block, rtx);
#if 0
-static void df_bb_refs_unlink PARAMS ((struct df *, basic_block));
-static void df_refs_unlink PARAMS ((struct df *, bitmap));
+static void df_bb_refs_unlink (struct df *, basic_block);
+static void df_refs_unlink (struct df *, bitmap);
#endif
-static struct ref *df_ref_create PARAMS((struct df *,
- rtx, rtx *, rtx,
- enum df_ref_type, enum df_ref_flags));
-static void df_ref_record_1 PARAMS((struct df *, rtx, rtx *,
- rtx, enum df_ref_type,
- enum df_ref_flags));
-static void df_ref_record PARAMS((struct df *, rtx, rtx *,
- rtx, enum df_ref_type,
- enum df_ref_flags));
-static void df_def_record_1 PARAMS((struct df *, rtx, basic_block, rtx));
-static void df_defs_record PARAMS((struct df *, rtx, basic_block, rtx));
-static void df_uses_record PARAMS((struct df *, rtx *,
- enum df_ref_type, basic_block, rtx,
- enum df_ref_flags));
-static void df_insn_refs_record PARAMS((struct df *, basic_block, rtx));
-static void df_bb_refs_record PARAMS((struct df *, basic_block));
-static void df_refs_record PARAMS((struct df *, bitmap));
-
-static void df_bb_reg_def_chain_create PARAMS((struct df *, basic_block));
-static void df_reg_def_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_reg_use_chain_create PARAMS((struct df *, basic_block));
-static void df_reg_use_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_du_chain_create PARAMS((struct df *, basic_block, bitmap));
-static void df_du_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_ud_chain_create PARAMS((struct df *, basic_block));
-static void df_ud_chain_create PARAMS((struct df *, bitmap));
-static void df_bb_rd_local_compute PARAMS((struct df *, basic_block));
-static void df_rd_local_compute PARAMS((struct df *, bitmap));
-static void df_bb_ru_local_compute PARAMS((struct df *, basic_block));
-static void df_ru_local_compute PARAMS((struct df *, bitmap));
-static void df_bb_lr_local_compute PARAMS((struct df *, basic_block));
-static void df_lr_local_compute PARAMS((struct df *, bitmap));
-static void df_bb_reg_info_compute PARAMS((struct df *, basic_block, bitmap));
-static void df_reg_info_compute PARAMS((struct df *, bitmap));
-
-static int df_bb_luids_set PARAMS((struct df *df, basic_block));
-static int df_luids_set PARAMS((struct df *df, bitmap));
-
-static int df_modified_p PARAMS ((struct df *, bitmap));
-static int df_refs_queue PARAMS ((struct df *));
-static int df_refs_process PARAMS ((struct df *));
-static int df_bb_refs_update PARAMS ((struct df *, basic_block));
-static int df_refs_update PARAMS ((struct df *));
-static void df_analyse_1 PARAMS((struct df *, bitmap, int, int));
-
-static void df_insns_modify PARAMS((struct df *, basic_block,
- rtx, rtx));
-static int df_rtx_mem_replace PARAMS ((rtx *, void *));
-static int df_rtx_reg_replace PARAMS ((rtx *, void *));
-void df_refs_reg_replace PARAMS ((struct df *, bitmap,
- struct df_link *, rtx, rtx));
-
-static int df_def_dominates_all_uses_p PARAMS((struct df *, struct ref *def));
-static int df_def_dominates_uses_p PARAMS((struct df *,
- struct ref *def, bitmap));
-static struct ref *df_bb_regno_last_use_find PARAMS((struct df *, basic_block,
- unsigned int));
-static struct ref *df_bb_regno_first_def_find PARAMS((struct df *, basic_block,
- unsigned int));
-static struct ref *df_bb_insn_regno_last_use_find PARAMS((struct df *,
- basic_block,
- rtx, unsigned int));
-static struct ref *df_bb_insn_regno_first_def_find PARAMS((struct df *,
- basic_block,
- rtx, unsigned int));
-
-static void df_chain_dump PARAMS((struct df_link *, FILE *file));
-static void df_chain_dump_regno PARAMS((struct df_link *, FILE *file));
-static void df_regno_debug PARAMS ((struct df *, unsigned int, FILE *));
-static void df_ref_debug PARAMS ((struct df *, struct ref *, FILE *));
-static void df_rd_transfer_function PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
-static void df_ru_transfer_function PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
-static void df_lr_transfer_function PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
-static void hybrid_search_bitmap PARAMS ((basic_block, bitmap *, bitmap *,
- bitmap *, bitmap *, enum df_flow_dir,
- enum df_confluence_op,
- transfer_function_bitmap,
- sbitmap, sbitmap, void *));
-static void hybrid_search_sbitmap PARAMS ((basic_block, sbitmap *, sbitmap *,
- sbitmap *, sbitmap *, enum df_flow_dir,
- enum df_confluence_op,
- transfer_function_sbitmap,
- sbitmap, sbitmap, void *));
+static struct ref *df_ref_create (struct df *, rtx, rtx *, rtx,
+ enum df_ref_type, enum df_ref_flags);
+static void df_ref_record_1 (struct df *, rtx, rtx *, rtx, enum df_ref_type,
+ enum df_ref_flags);
+static void df_ref_record (struct df *, rtx, rtx *, rtx, enum df_ref_type,
+ enum df_ref_flags);
+static void df_def_record_1 (struct df *, rtx, basic_block, rtx);
+static void df_defs_record (struct df *, rtx, basic_block, rtx);
+static void df_uses_record (struct df *, rtx *, enum df_ref_type,
+ basic_block, rtx, enum df_ref_flags);
+static void df_insn_refs_record (struct df *, basic_block, rtx);
+static void df_bb_refs_record (struct df *, basic_block);
+static void df_refs_record (struct df *, bitmap);
+
+static void df_bb_reg_def_chain_create (struct df *, basic_block);
+static void df_reg_def_chain_create (struct df *, bitmap);
+static void df_bb_reg_use_chain_create (struct df *, basic_block);
+static void df_reg_use_chain_create (struct df *, bitmap);
+static void df_bb_du_chain_create (struct df *, basic_block, bitmap);
+static void df_du_chain_create (struct df *, bitmap);
+static void df_bb_ud_chain_create (struct df *, basic_block);
+static void df_ud_chain_create (struct df *, bitmap);
+static void df_bb_rd_local_compute (struct df *, basic_block);
+static void df_rd_local_compute (struct df *, bitmap);
+static void df_bb_ru_local_compute (struct df *, basic_block);
+static void df_ru_local_compute (struct df *, bitmap);
+static void df_bb_lr_local_compute (struct df *, basic_block);
+static void df_lr_local_compute (struct df *, bitmap);
+static void df_bb_reg_info_compute (struct df *, basic_block, bitmap);
+static void df_reg_info_compute (struct df *, bitmap);
+
+static int df_bb_luids_set (struct df *df, basic_block);
+static int df_luids_set (struct df *df, bitmap);
+
+static int df_modified_p (struct df *, bitmap);
+static int df_refs_queue (struct df *);
+static int df_refs_process (struct df *);
+static int df_bb_refs_update (struct df *, basic_block);
+static int df_refs_update (struct df *);
+static void df_analyse_1 (struct df *, bitmap, int, int);
+
+static void df_insns_modify (struct df *, basic_block, rtx, rtx);
+static int df_rtx_mem_replace (rtx *, void *);
+static int df_rtx_reg_replace (rtx *, void *);
+void df_refs_reg_replace (struct df *, bitmap, struct df_link *, rtx, rtx);
+
+static int df_def_dominates_all_uses_p (struct df *, struct ref *def);
+static int df_def_dominates_uses_p (struct df *, struct ref *def, bitmap);
+static struct ref *df_bb_regno_last_use_find (struct df *, basic_block,
+ unsigned int);
+static struct ref *df_bb_regno_first_def_find (struct df *, basic_block,
+ unsigned int);
+static struct ref *df_bb_insn_regno_last_use_find (struct df *, basic_block,
+ rtx, unsigned int);
+static struct ref *df_bb_insn_regno_first_def_find (struct df *, basic_block,
+ rtx, unsigned int);
+
+static void df_chain_dump (struct df_link *, FILE *file);
+static void df_chain_dump_regno (struct df_link *, FILE *file);
+static void df_regno_debug (struct df *, unsigned int, FILE *);
+static void df_ref_debug (struct df *, struct ref *, FILE *);
+static void df_rd_transfer_function (int, int *, bitmap, bitmap, bitmap,
+ bitmap, void *);
+static void df_ru_transfer_function (int, int *, bitmap, bitmap, bitmap,
+ bitmap, void *);
+static void df_lr_transfer_function (int, int *, bitmap, bitmap, bitmap,
+ bitmap, void *);
+static void hybrid_search_bitmap (basic_block, bitmap *, bitmap *,
+ bitmap *, bitmap *, enum df_flow_dir,
+ enum df_confluence_op,
+ transfer_function_bitmap,
+ sbitmap, sbitmap, void *);
+static void hybrid_search_sbitmap (basic_block, sbitmap *, sbitmap *,
+ sbitmap *, sbitmap *, enum df_flow_dir,
+ enum df_confluence_op,
+ transfer_function_sbitmap,
+ sbitmap, sbitmap, void *);
\f
/* Local memory allocation/deallocation routines. */
/* Increase the insn info table to have space for at least SIZE + 1
elements. */
static void
-df_insn_table_realloc (df, size)
- struct df *df;
- unsigned int size;
+df_insn_table_realloc (struct df *df, unsigned int size)
{
size++;
if (size <= df->insn_size)
/* Increase the reg info table by SIZE more elements. */
static void
-df_reg_table_realloc (df, size)
- struct df *df;
- int size;
+df_reg_table_realloc (struct df *df, int size)
{
/* Make table 25 percent larger by default. */
if (! size)
/* Allocate bitmaps for each basic block. */
static void
-df_bitmaps_alloc (df, flags)
- struct df *df;
- int flags;
+df_bitmaps_alloc (struct df *df, int flags)
{
int dflags = 0;
basic_block bb;
/* Free bitmaps for each basic block. */
static void
-df_bitmaps_free (df, flags)
- struct df *df ATTRIBUTE_UNUSED;
- int flags;
+df_bitmaps_free (struct df *df, int flags)
{
basic_block bb;
/* Allocate and initialize dataflow memory. */
static void
-df_alloc (df, n_regs)
- struct df *df;
- int n_regs;
+df_alloc (struct df *df, int n_regs)
{
int n_insns;
basic_block bb;
/* Free all the dataflow info. */
static void
-df_free (df)
- struct df *df;
+df_free (struct df *df)
{
df_bitmaps_free (df, DF_ALL);
/* Local miscellaneous routines. */
/* Return a USE for register REGNO. */
-static rtx df_reg_use_gen (regno)
- unsigned int regno;
+static rtx df_reg_use_gen (unsigned int regno)
{
rtx reg;
rtx use;
/* Return a CLOBBER for register REGNO. */
-static rtx df_reg_clobber_gen (regno)
- unsigned int regno;
+static rtx df_reg_clobber_gen (unsigned int regno)
{
rtx reg;
rtx use;
/* Create a link in a def-use or use-def chain. */
static inline struct df_link *
-df_link_create (ref, next)
- struct ref *ref;
- struct df_link *next;
+df_link_create (struct ref *ref, struct df_link *next)
{
struct df_link *link;
/* Add REF to chain head pointed to by PHEAD. */
static struct df_link *
-df_ref_unlink (phead, ref)
- struct df_link **phead;
- struct ref *ref;
+df_ref_unlink (struct df_link **phead, struct ref *ref)
{
struct df_link *link = *phead;
/* Unlink REF from all def-use/use-def chains, etc. */
int
-df_ref_remove (df, ref)
- struct df *df;
- struct ref *ref;
+df_ref_remove (struct df *df, struct ref *ref)
{
if (DF_REF_REG_DEF_P (ref))
{
/* Unlink DEF from use-def and reg-def chains. */
static void
-df_def_unlink (df, def)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *def;
+df_def_unlink (struct df *df ATTRIBUTE_UNUSED, struct ref *def)
{
struct df_link *du_link;
unsigned int dregno = DF_REF_REGNO (def);
/* Unlink use from def-use and reg-use chains. */
static void
-df_use_unlink (df, use)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *use;
+df_use_unlink (struct df *df ATTRIBUTE_UNUSED, struct ref *use)
{
struct df_link *ud_link;
unsigned int uregno = DF_REF_REGNO (use);
/* Create a new ref of type DF_REF_TYPE for register REG at address
LOC within INSN of BB. */
static struct ref *
-df_ref_create (df, reg, loc, insn, ref_type, ref_flags)
- struct df *df;
- rtx reg;
- rtx *loc;
- rtx insn;
- enum df_ref_type ref_type;
- enum df_ref_flags ref_flags;
+df_ref_create (struct df *df, rtx reg, rtx *loc, rtx insn,
+ enum df_ref_type ref_type, enum df_ref_flags ref_flags)
{
struct ref *this_ref;
/* Create a new reference of type DF_REF_TYPE for a single register REG,
used inside the LOC rtx of INSN. */
static void
-df_ref_record_1 (df, reg, loc, insn, ref_type, ref_flags)
- struct df *df;
- rtx reg;
- rtx *loc;
- rtx insn;
- enum df_ref_type ref_type;
- enum df_ref_flags ref_flags;
+df_ref_record_1 (struct df *df, rtx reg, rtx *loc, rtx insn,
+ enum df_ref_type ref_type, enum df_ref_flags ref_flags)
{
df_ref_create (df, reg, loc, insn, ref_type, ref_flags);
}
/* Create new references of type DF_REF_TYPE for each part of register REG
at address LOC within INSN of BB. */
static void
-df_ref_record (df, reg, loc, insn, ref_type, ref_flags)
- struct df *df;
- rtx reg;
- rtx *loc;
- rtx insn;
- enum df_ref_type ref_type;
- enum df_ref_flags ref_flags;
+df_ref_record (struct df *df, rtx reg, rtx *loc, rtx insn,
+ enum df_ref_type ref_type, enum df_ref_flags ref_flags)
{
unsigned int regno;
/* Return nonzero if writes to paradoxical SUBREGs, or SUBREGs which
are too narrow, are read-modify-write. */
bool
-read_modify_subreg_p (x)
- rtx x;
+read_modify_subreg_p (rtx x)
{
unsigned int isize, osize;
if (GET_CODE (x) != SUBREG)
/* Process all the registers defined in the rtx, X. */
static void
-df_def_record_1 (df, x, bb, insn)
- struct df *df;
- rtx x;
- basic_block bb;
- rtx insn;
+df_def_record_1 (struct df *df, rtx x, basic_block bb, rtx insn)
{
rtx *loc;
rtx dst;
enum df_ref_flags flags = 0;
/* We may recursivly call ourselves on EXPR_LIST when dealing with PARALLEL
- construct. */
+ construct. */
if (GET_CODE (x) == EXPR_LIST || GET_CODE (x) == CLOBBER)
loc = &XEXP (x, 0);
else
return;
}
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (GET_CODE (dst) == SUBREG
- && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- flags |= DF_REF_MODE_CHANGE;
-#endif
-
/* Maybe, we should flag the use of STRICT_LOW_PART somehow. It might
be handy for the reg allocator. */
while (GET_CODE (dst) == STRICT_LOW_PART
loc = &XEXP (dst, 0);
dst = *loc;
}
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (GET_CODE (dst) == SUBREG
- && CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- flags |= DF_REF_MODE_CHANGE;
-#endif
loc = &XEXP (dst, 0);
dst = *loc;
flags |= DF_REF_READ_WRITE;
/* Process all the registers defined in the pattern rtx, X. */
static void
-df_defs_record (df, x, bb, insn)
- struct df *df;
- rtx x;
- basic_block bb;
- rtx insn;
+df_defs_record (struct df *df, rtx x, basic_block bb, rtx insn)
{
RTX_CODE code = GET_CODE (x);
/* Process all the registers used in the rtx at address LOC. */
static void
-df_uses_record (df, loc, ref_type, bb, insn, flags)
- struct df *df;
- rtx *loc;
- enum df_ref_type ref_type;
- basic_block bb;
- rtx insn;
- enum df_ref_flags flags;
+df_uses_record (struct df *df, rtx *loc, enum df_ref_type ref_type,
+ basic_block bb, rtx insn, enum df_ref_flags flags)
{
RTX_CODE code;
rtx x;
df_uses_record (df, loc, ref_type, bb, insn, flags);
return;
}
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (x),
- GET_MODE (SUBREG_REG (x))))
- flags |= DF_REF_MODE_CHANGE;
-#endif
-
/* ... Fall through ... */
case REG:
&& read_modify_subreg_p (dst))
{
use_flags = DF_REF_READ_WRITE;
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- use_flags |= DF_REF_MODE_CHANGE;
-#endif
df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
insn, use_flags);
break;
if (GET_CODE (dst) != SUBREG)
abort ();
use_flags = DF_REF_READ_WRITE;
-#ifdef CLASS_CANNOT_CHANGE_MODE
- if (CLASS_CANNOT_CHANGE_MODE_P (GET_MODE (dst),
- GET_MODE (SUBREG_REG (dst))))
- use_flags |= DF_REF_MODE_CHANGE;
-#endif
df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
insn, use_flags);
break;
/* Record all the df within INSN of basic block BB. */
static void
-df_insn_refs_record (df, bb, insn)
- struct df *df;
- basic_block bb;
- rtx insn;
+df_insn_refs_record (struct df *df, basic_block bb, rtx insn)
{
int i;
/* Record all the refs within the basic block BB. */
static void
-df_bb_refs_record (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_refs_record (struct df *df, basic_block bb)
{
rtx insn;
/* Record all the refs in the basic blocks specified by BLOCKS. */
static void
-df_refs_record (df, blocks)
- struct df *df;
- bitmap blocks;
+df_refs_record (struct df *df, bitmap blocks)
{
basic_block bb;
/* Create reg-def chains for basic block BB. These are a list of
definitions for each register. */
static void
-df_bb_reg_def_chain_create (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_reg_def_chain_create (struct df *df, basic_block bb)
{
rtx insn;
/* Create reg-def chains for each basic block within BLOCKS. These
are a list of definitions for each register. */
static void
-df_reg_def_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_reg_def_chain_create (struct df *df, bitmap blocks)
{
basic_block bb;
/* Create reg-use chains for basic block BB. These are a list of uses
for each register. */
static void
-df_bb_reg_use_chain_create (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_reg_use_chain_create (struct df *df, basic_block bb)
{
rtx insn;
/* Create reg-use chains for each basic block within BLOCKS. These
are a list of uses for each register. */
static void
-df_reg_use_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_reg_use_chain_create (struct df *df, bitmap blocks)
{
basic_block bb;
/* Create def-use chains from reaching use bitmaps for basic block BB. */
static void
-df_bb_du_chain_create (df, bb, ru)
- struct df *df;
- basic_block bb;
- bitmap ru;
+df_bb_du_chain_create (struct df *df, basic_block bb, bitmap ru)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
rtx insn;
/* Create def-use chains from reaching use bitmaps for basic blocks
in BLOCKS. */
static void
-df_du_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_du_chain_create (struct df *df, bitmap blocks)
{
bitmap ru;
basic_block bb;
/* Create use-def chains from reaching def bitmaps for basic block BB. */
static void
-df_bb_ud_chain_create (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_ud_chain_create (struct df *df, basic_block bb)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
struct ref **reg_def_last = df->reg_def_last;
/* Create use-def chains from reaching def bitmaps for basic blocks
within BLOCKS. */
static void
-df_ud_chain_create (df, blocks)
- struct df *df;
- bitmap blocks;
+df_ud_chain_create (struct df *df, bitmap blocks)
{
basic_block bb;
static void
-df_rd_transfer_function (bb, changed, in, out, gen, kill, data)
- int bb ATTRIBUTE_UNUSED;
- int *changed;
- bitmap in, out, gen, kill;
- void *data ATTRIBUTE_UNUSED;
+df_rd_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, bitmap in,
+ bitmap out, bitmap gen, bitmap kill,
+ void *data ATTRIBUTE_UNUSED)
{
*changed = bitmap_union_of_diff (out, gen, in, kill);
}
static void
-df_ru_transfer_function (bb, changed, in, out, gen, kill, data)
- int bb ATTRIBUTE_UNUSED;
- int *changed;
- bitmap in, out, gen, kill;
- void *data ATTRIBUTE_UNUSED;
+df_ru_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, bitmap in,
+ bitmap out, bitmap gen, bitmap kill,
+ void *data ATTRIBUTE_UNUSED)
{
*changed = bitmap_union_of_diff (in, gen, out, kill);
}
static void
-df_lr_transfer_function (bb, changed, in, out, use, def, data)
- int bb ATTRIBUTE_UNUSED;
- int *changed;
- bitmap in, out, use, def;
- void *data ATTRIBUTE_UNUSED;
+df_lr_transfer_function (int bb ATTRIBUTE_UNUSED, int *changed, bitmap in,
+ bitmap out, bitmap use, bitmap def,
+ void *data ATTRIBUTE_UNUSED)
{
*changed = bitmap_union_of_diff (in, use, out, def);
}
/* Compute local reaching def info for basic block BB. */
static void
-df_bb_rd_local_compute (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_rd_local_compute (struct df *df, basic_block bb)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
rtx insn;
/* Compute local reaching def info for each basic block within BLOCKS. */
static void
-df_rd_local_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_rd_local_compute (struct df *df, bitmap blocks)
{
basic_block bb;
/* Compute local reaching use (upward exposed use) info for basic
block BB. */
static void
-df_bb_ru_local_compute (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_ru_local_compute (struct df *df, basic_block bb)
{
/* This is much more tricky than computing reaching defs. With
reaching defs, defs get killed by other defs. With upwards
/* Compute local reaching use (upward exposed use) info for each basic
block within BLOCKS. */
static void
-df_ru_local_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_ru_local_compute (struct df *df, bitmap blocks)
{
basic_block bb;
/* Compute local live variable info for basic block BB. */
static void
-df_bb_lr_local_compute (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_lr_local_compute (struct df *df, basic_block bb)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
rtx insn;
/* Compute local live variable info for each basic block within BLOCKS. */
static void
-df_lr_local_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_lr_local_compute (struct df *df, bitmap blocks)
{
basic_block bb;
/* Compute register info: lifetime, bb, and number of defs and uses
for basic block BB. */
static void
-df_bb_reg_info_compute (df, bb, live)
- struct df *df;
- basic_block bb;
- bitmap live;
+df_bb_reg_info_compute (struct df *df, basic_block bb, bitmap live)
{
struct reg_info *reg_info = df->regs;
struct bb_info *bb_info = DF_BB_INFO (df, bb);
/* Compute register info: lifetime, bb, and number of defs and uses. */
static void
-df_reg_info_compute (df, blocks)
- struct df *df;
- bitmap blocks;
+df_reg_info_compute (struct df *df, bitmap blocks)
{
basic_block bb;
bitmap live;
/* Assign LUIDs for BB. */
static int
-df_bb_luids_set (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_luids_set (struct df *df, basic_block bb)
{
rtx insn;
int luid = 0;
/* Assign LUIDs for each basic block within BLOCKS. */
static int
-df_luids_set (df, blocks)
- struct df *df;
- bitmap blocks;
+df_luids_set (struct df *df, bitmap blocks)
{
basic_block bb;
int total = 0;
/* Perform dataflow analysis using existing DF structure for blocks
within BLOCKS. If BLOCKS is zero, use all basic blocks in the CFG. */
static void
-df_analyse_1 (df, blocks, flags, update)
- struct df *df;
- bitmap blocks;
- int flags;
- int update;
+df_analyse_1 (struct df *df, bitmap blocks, int flags, int update)
{
int aflags;
int dflags;
{
df_reg_info_compute (df, df->all_blocks);
}
-
+
free (df->dfs_order);
free (df->rc_order);
free (df->rts_order);
/* Initialize dataflow analysis. */
struct df *
-df_init ()
+df_init (void)
{
struct df *df;
/* Start queuing refs. */
static int
-df_refs_queue (df)
- struct df *df;
+df_refs_queue (struct df *df)
{
df->def_id_save = df->def_id;
df->use_id_save = df->use_id;
/* Process queued refs. */
static int
-df_refs_process (df)
- struct df *df;
+df_refs_process (struct df *df)
{
unsigned int i;
/* Update refs for basic block BB. */
static int
-df_bb_refs_update (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_refs_update (struct df *df, basic_block bb)
{
rtx insn;
int count = 0;
/* Process all the modified/deleted insns that were queued. */
static int
-df_refs_update (df)
- struct df *df;
+df_refs_update (struct df *df)
{
basic_block bb;
int count = 0;
/* Return nonzero if any of the requested blocks in the bitmap
BLOCKS have been modified. */
static int
-df_modified_p (df, blocks)
- struct df *df;
- bitmap blocks;
+df_modified_p (struct df *df, bitmap blocks)
{
int update = 0;
basic_block bb;
BLOCKS, or for the whole CFG if BLOCKS is zero, or just for the
modified blocks if BLOCKS is -1. */
int
-df_analyse (df, blocks, flags)
- struct df *df;
- bitmap blocks;
- int flags;
+df_analyse (struct df *df, bitmap blocks, int flags)
{
int update;
/* Free all the dataflow info and the DF structure. */
void
-df_finish (df)
- struct df *df;
+df_finish (struct df *df)
{
df_free (df);
free (df);
/* Unlink INSN from its reference information. */
static void
-df_insn_refs_unlink (df, bb, insn)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
+df_insn_refs_unlink (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn)
{
struct df_link *link;
unsigned int uid;
#if 0
/* Unlink all the insns within BB from their reference information. */
static void
-df_bb_refs_unlink (df, bb)
- struct df *df;
- basic_block bb;
+df_bb_refs_unlink (struct df *df, basic_block bb)
{
rtx insn;
/* Unlink all the refs in the basic blocks specified by BLOCKS.
Not currently used. */
static void
-df_refs_unlink (df, blocks)
- struct df *df;
- bitmap blocks;
+df_refs_unlink (struct df *df, bitmap blocks)
{
basic_block bb;
/* Delete INSN and all its reference information. */
rtx
-df_insn_delete (df, bb, insn)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
+df_insn_delete (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn)
{
/* If the insn is a jump, we should perhaps call delete_insn to
handle the JUMP_LABEL? */
harm calling this function if the insn wasn't changed; it will just
slow down the rescanning of refs. */
void
-df_insn_modify (df, bb, insn)
- struct df *df;
- basic_block bb;
- rtx insn;
+df_insn_modify (struct df *df, basic_block bb, rtx insn)
{
unsigned int uid;
instruction currently being scanned and the MEM we are currently
replacing. */
static int
-df_rtx_mem_replace (px, data)
- rtx *px;
- void *data;
+df_rtx_mem_replace (rtx *px, void *data)
{
replace_args *args = (replace_args *) data;
rtx mem = *px;
int
-df_insn_mem_replace (df, bb, insn, mem, reg)
- struct df *df;
- basic_block bb;
- rtx insn;
- rtx mem;
- rtx reg;
+df_insn_mem_replace (struct df *df, basic_block bb, rtx insn, rtx mem, rtx reg)
{
replace_args args;
points to the rtx being scanned. DATA is actually a pointer to a
structure of arguments. */
static int
-df_rtx_reg_replace (px, data)
- rtx *px;
- void *data;
+df_rtx_reg_replace (rtx *px, void *data)
{
rtx x = *px;
replace_args *args = (replace_args *) data;
BLOCKS of basic blocks with NEWREG. Also update the regs within
REG_NOTES. */
void
-df_refs_reg_replace (df, blocks, chain, oldreg, newreg)
- struct df *df;
- bitmap blocks;
- struct df_link *chain;
- rtx oldreg;
- rtx newreg;
+df_refs_reg_replace (struct df *df, bitmap blocks, struct df_link *chain, rtx oldreg, rtx newreg)
{
struct df_link *link;
replace_args args;
OLDREG in the REG_NOTES but only for insns containing OLDREG. This
routine expects the reg-use and reg-def chains to be valid. */
int
-df_reg_replace (df, blocks, oldreg, newreg)
- struct df *df;
- bitmap blocks;
- rtx oldreg;
- rtx newreg;
+df_reg_replace (struct df *df, bitmap blocks, rtx oldreg, rtx newreg)
{
unsigned int oldregno = REGNO (oldreg);
/* Try replacing the reg within REF with NEWREG. Do not modify
def-use/use-def chains. */
int
-df_ref_reg_replace (df, ref, oldreg, newreg)
- struct df *df;
- struct ref *ref;
- rtx oldreg;
- rtx newreg;
+df_ref_reg_replace (struct df *df, struct ref *ref, rtx oldreg, rtx newreg)
{
/* Check that insn was deleted by being converted into a NOTE. If
so ignore this insn. */
struct ref*
-df_bb_def_use_swap (df, bb, def_insn, use_insn, regno)
- struct df * df;
- basic_block bb;
- rtx def_insn;
- rtx use_insn;
- unsigned int regno;
+df_bb_def_use_swap (struct df *df, basic_block bb, rtx def_insn, rtx use_insn, unsigned int regno)
{
struct ref *def;
struct ref *use;
/* Record df between FIRST_INSN and LAST_INSN inclusive. All new
insns must be processed by this routine. */
static void
-df_insns_modify (df, bb, first_insn, last_insn)
- struct df *df;
- basic_block bb;
- rtx first_insn;
- rtx last_insn;
+df_insns_modify (struct df *df, basic_block bb, rtx first_insn, rtx last_insn)
{
rtx insn;
/* Emit PATTERN before INSN within BB. */
rtx
-df_pattern_emit_before (df, pattern, bb, insn)
- struct df *df ATTRIBUTE_UNUSED;
- rtx pattern;
- basic_block bb;
- rtx insn;
+df_pattern_emit_before (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
rtx ret_insn;
rtx prev_insn = PREV_INSN (insn);
/* Emit PATTERN after INSN within BB. */
rtx
-df_pattern_emit_after (df, pattern, bb, insn)
- struct df *df;
- rtx pattern;
- basic_block bb;
- rtx insn;
+df_pattern_emit_after (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
rtx ret_insn;
/* Emit jump PATTERN after INSN within BB. */
rtx
-df_jump_pattern_emit_after (df, pattern, bb, insn)
- struct df *df;
- rtx pattern;
- basic_block bb;
- rtx insn;
+df_jump_pattern_emit_after (struct df *df, rtx pattern, basic_block bb, rtx insn)
{
rtx ret_insn;
out of a loop where it has been proven that the def-use info
will still be valid. */
rtx
-df_insn_move_before (df, bb, insn, before_bb, before_insn)
- struct df *df;
- basic_block bb;
- rtx insn;
- basic_block before_bb;
- rtx before_insn;
+df_insn_move_before (struct df *df, basic_block bb, rtx insn, basic_block before_bb, rtx before_insn)
{
struct df_link *link;
unsigned int uid;
int
-df_insn_regno_def_p (df, bb, insn, regno)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- unsigned int regno;
+df_insn_regno_def_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
+ rtx insn, unsigned int regno)
{
unsigned int uid;
struct df_link *link;
static int
-df_def_dominates_all_uses_p (df, def)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *def;
+df_def_dominates_all_uses_p (struct df *df ATTRIBUTE_UNUSED, struct ref *def)
{
struct df_link *du_link;
int
-df_insn_dominates_all_uses_p (df, bb, insn)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
+df_insn_dominates_all_uses_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
+ rtx insn)
{
unsigned int uid;
struct df_link *link;
/* Return nonzero if all DF dominates all the uses within the bitmap
BLOCKS. */
static int
-df_def_dominates_uses_p (df, def, blocks)
- struct df *df ATTRIBUTE_UNUSED;
- struct ref *def;
- bitmap blocks;
+df_def_dominates_uses_p (struct df *df ATTRIBUTE_UNUSED, struct ref *def,
+ bitmap blocks)
{
struct df_link *du_link;
/* Return nonzero if all the defs of INSN within BB dominates
all the corresponding uses. */
int
-df_insn_dominates_uses_p (df, bb, insn, blocks)
- struct df *df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- bitmap blocks;
+df_insn_dominates_uses_p (struct df *df, basic_block bb ATTRIBUTE_UNUSED,
+ rtx insn, bitmap blocks)
{
unsigned int uid;
struct df_link *link;
/* Return the basic block that REG referenced in or NULL if referenced
in multiple basic blocks. */
basic_block
-df_regno_bb (df, regno)
- struct df *df;
- unsigned int regno;
+df_regno_bb (struct df *df, unsigned int regno)
{
struct df_link *defs = df->regs[regno].defs;
struct df_link *uses = df->regs[regno].uses;
/* Return nonzero if REG used in multiple basic blocks. */
int
-df_reg_global_p (df, reg)
- struct df *df;
- rtx reg;
+df_reg_global_p (struct df *df, rtx reg)
{
return df_regno_bb (df, REGNO (reg)) != 0;
}
/* Return total lifetime (in insns) of REG. */
int
-df_reg_lifetime (df, reg)
- struct df *df;
- rtx reg;
+df_reg_lifetime (struct df *df, rtx reg)
{
return df->regs[REGNO (reg)].lifetime;
}
/* Return nonzero if REG live at start of BB. */
int
-df_bb_reg_live_start_p (df, bb, reg)
- struct df *df ATTRIBUTE_UNUSED;
- basic_block bb;
- rtx reg;
+df_bb_reg_live_start_p (struct df *df, basic_block bb, rtx reg)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
/* Return nonzero if REG live at end of BB. */
int
-df_bb_reg_live_end_p (df, bb, reg)
- struct df *df ATTRIBUTE_UNUSED;
- basic_block bb;
- rtx reg;
+df_bb_reg_live_end_p (struct df *df, basic_block bb, rtx reg)
{
struct bb_info *bb_info = DF_BB_INFO (df, bb);
/* Return -1 if life of REG1 before life of REG2, 1 if life of REG1
after life of REG2, or 0, if the lives overlap. */
int
-df_bb_regs_lives_compare (df, bb, reg1, reg2)
- struct df *df;
- basic_block bb;
- rtx reg1;
- rtx reg2;
+df_bb_regs_lives_compare (struct df *df, basic_block bb, rtx reg1, rtx reg2)
{
unsigned int regno1 = REGNO (reg1);
unsigned int regno2 = REGNO (reg2);
/* Return last use of REGNO within BB. */
static struct ref *
-df_bb_regno_last_use_find (df, bb, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- unsigned int regno;
+df_bb_regno_last_use_find (struct df *df, basic_block bb, unsigned int regno)
{
struct df_link *link;
/* Return first def of REGNO within BB. */
static struct ref *
-df_bb_regno_first_def_find (df, bb, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- unsigned int regno;
+df_bb_regno_first_def_find (struct df *df, basic_block bb, unsigned int regno)
{
struct df_link *link;
/* Return first use of REGNO inside INSN within BB. */
static struct ref *
-df_bb_insn_regno_last_use_find (df, bb, insn, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- unsigned int regno;
+df_bb_insn_regno_last_use_find (struct df *df,
+ basic_block bb ATTRIBUTE_UNUSED, rtx insn,
+ unsigned int regno)
{
unsigned int uid;
struct df_link *link;
/* Return first def of REGNO inside INSN within BB. */
static struct ref *
-df_bb_insn_regno_first_def_find (df, bb, insn, regno)
- struct df * df;
- basic_block bb ATTRIBUTE_UNUSED;
- rtx insn;
- unsigned int regno;
+df_bb_insn_regno_first_def_find (struct df *df,
+ basic_block bb ATTRIBUTE_UNUSED, rtx insn,
+ unsigned int regno)
{
unsigned int uid;
struct df_link *link;
/* Return insn using REG if the BB contains only a single
use and def of REG. */
rtx
-df_bb_single_def_use_insn_find (df, bb, insn, reg)
- struct df * df;
- basic_block bb;
- rtx insn;
- rtx reg;
+df_bb_single_def_use_insn_find (struct df *df, basic_block bb, rtx insn, rtx reg)
{
struct ref *def;
struct ref *use;
/* Dump a def-use or use-def chain for REF to FILE. */
static void
-df_chain_dump (link, file)
- struct df_link *link;
- FILE *file;
+df_chain_dump (struct df_link *link, FILE *file)
{
fprintf (file, "{ ");
for (; link; link = link->next)
/* Dump a chain of refs with the associated regno. */
static void
-df_chain_dump_regno (link, file)
- struct df_link *link;
- FILE *file;
+df_chain_dump_regno (struct df_link *link, FILE *file)
{
fprintf (file, "{ ");
for (; link; link = link->next)
/* Dump dataflow info. */
void
-df_dump (df, flags, file)
- struct df *df;
- int flags;
- FILE *file;
+df_dump (struct df *df, int flags, FILE *file)
{
unsigned int j;
basic_block bb;
void
-df_insn_debug (df, insn, file)
- struct df *df;
- rtx insn;
- FILE *file;
+df_insn_debug (struct df *df, rtx insn, FILE *file)
{
unsigned int uid;
int bbi;
void
-df_insn_debug_regno (df, insn, file)
- struct df *df;
- rtx insn;
- FILE *file;
+df_insn_debug_regno (struct df *df, rtx insn, FILE *file)
{
unsigned int uid;
int bbi;
static void
-df_regno_debug (df, regno, file)
- struct df *df;
- unsigned int regno;
- FILE *file;
+df_regno_debug (struct df *df, unsigned int regno, FILE *file)
{
if (regno >= df->reg_size)
return;
static void
-df_ref_debug (df, ref, file)
- struct df *df;
- struct ref *ref;
- FILE *file;
+df_ref_debug (struct df *df, struct ref *ref, FILE *file)
{
fprintf (file, "%c%d ",
DF_REF_REG_DEF_P (ref) ? 'd' : 'u',
/* Functions for debugging from GDB. */
void
-debug_df_insn (insn)
- rtx insn;
+debug_df_insn (rtx insn)
{
df_insn_debug (ddf, insn, stderr);
debug_rtx (insn);
void
-debug_df_reg (reg)
- rtx reg;
+debug_df_reg (rtx reg)
{
df_regno_debug (ddf, REGNO (reg), stderr);
}
void
-debug_df_regno (regno)
- unsigned int regno;
+debug_df_regno (unsigned int regno)
{
df_regno_debug (ddf, regno, stderr);
}
void
-debug_df_ref (ref)
- struct ref *ref;
+debug_df_ref (struct ref *ref)
{
df_ref_debug (ddf, ref, stderr);
}
void
-debug_df_defno (defno)
- unsigned int defno;
+debug_df_defno (unsigned int defno)
{
df_ref_debug (ddf, ddf->defs[defno], stderr);
}
void
-debug_df_useno (defno)
- unsigned int defno;
+debug_df_useno (unsigned int defno)
{
df_ref_debug (ddf, ddf->uses[defno], stderr);
}
void
-debug_df_chain (link)
- struct df_link *link;
+debug_df_chain (struct df_link *link)
{
df_chain_dump (link, stderr);
fputc ('\n', stderr);
/* Hybrid search algorithm from "Implementation Techniques for
Efficient Data-Flow Analysis of Large Programs". */
static void
-hybrid_search_bitmap (block, in, out, gen, kill, dir,
- conf_op, transfun, visited, pending,
- data)
- basic_block block;
- bitmap *in, *out, *gen, *kill;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_bitmap transfun;
- sbitmap visited;
- sbitmap pending;
- void *data;
+hybrid_search_bitmap (basic_block block, bitmap *in, bitmap *out, bitmap *gen,
+ bitmap *kill, enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_bitmap transfun, sbitmap visited,
+ sbitmap pending, void *data)
{
int changed;
int i = block->index;
/* Hybrid search for sbitmaps, rather than bitmaps. */
static void
-hybrid_search_sbitmap (block, in, out, gen, kill, dir,
- conf_op, transfun, visited, pending,
- data)
- basic_block block;
- sbitmap *in, *out, *gen, *kill;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_sbitmap transfun;
- sbitmap visited;
- sbitmap pending;
- void *data;
+hybrid_search_sbitmap (basic_block block, sbitmap *in, sbitmap *out,
+ sbitmap *gen, sbitmap *kill, enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_sbitmap transfun, sbitmap visited,
+ sbitmap pending, void *data)
{
int changed;
int i = block->index;
block number to rc_order (like df->inverse_rc_map).
*/
void
-iterative_dataflow_sbitmap (in, out, gen, kill, blocks,
- dir, conf_op, transfun, order, data)
- sbitmap *in, *out, *gen, *kill;
- bitmap blocks;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_sbitmap transfun;
- int *order;
- void *data;
+iterative_dataflow_sbitmap (sbitmap *in, sbitmap *out, sbitmap *gen,
+ sbitmap *kill, bitmap blocks,
+ enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_sbitmap transfun, int *order,
+ void *data)
{
int i;
fibheap_t worklist;
/* Exactly the same as iterative_dataflow_sbitmap, except it works on
bitmaps instead. */
void
-iterative_dataflow_bitmap (in, out, gen, kill, blocks,
- dir, conf_op, transfun, order, data)
- bitmap *in, *out, *gen, *kill;
- bitmap blocks;
- enum df_flow_dir dir;
- enum df_confluence_op conf_op;
- transfer_function_bitmap transfun;
- int *order;
- void *data;
+iterative_dataflow_bitmap (bitmap *in, bitmap *out, bitmap *gen, bitmap *kill,
+ bitmap blocks, enum df_flow_dir dir,
+ enum df_confluence_op conf_op,
+ transfer_function_bitmap transfun, int *order,
+ void *data)
{
int i;
fibheap_t worklist;
/* Form lists of pseudo register references for autoinc optimization
- for GNU compiler. This is part of flow optimization.
+ for GNU compiler. This is part of flow optimization.
Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
these are marked with this flag to show that they are not
independent. */
DF_REF_READ_WRITE = 1,
-
+
/* This flag is set on register references inside a subreg on
machines which have CANNOT_CHANGE_MODE_CLASS.
Note, that this flag can also be set on df_refs representing
bitmap insns_modified; /* Insns that (may) have changed. */
bitmap bbs_modified; /* Blocks that (may) have changed. */
bitmap all_blocks; /* All blocks in CFG. */
- /* The sbitmap vector of dominators or NULL if not computed.
+ /* The sbitmap vector of dominators or NULL if not computed.
Ideally, this should be a pointer to a CFG object. */
sbitmap *dom;
int *dfs_order; /* DFS order -> block number. */
/* Functions to build and analyse dataflow information. */
-extern struct df *df_init PARAMS ((void));
+extern struct df *df_init (void);
-extern int df_analyse PARAMS ((struct df *, bitmap, int));
+extern int df_analyse (struct df *, bitmap, int);
-extern void df_finish PARAMS ((struct df *));
+extern void df_finish (struct df *);
-extern void df_dump PARAMS ((struct df *, int, FILE *));
+extern void df_dump (struct df *, int, FILE *);
/* Functions to modify insns. */
-extern void df_insn_modify PARAMS ((struct df *, basic_block, rtx));
+extern void df_insn_modify (struct df *, basic_block, rtx);
-extern rtx df_insn_delete PARAMS ((struct df *, basic_block, rtx));
+extern rtx df_insn_delete (struct df *, basic_block, rtx);
-extern rtx df_pattern_emit_before PARAMS ((struct df *, rtx,
- basic_block, rtx));
+extern rtx df_pattern_emit_before (struct df *, rtx, basic_block, rtx);
-extern rtx df_jump_pattern_emit_after PARAMS ((struct df *, rtx,
- basic_block, rtx));
+extern rtx df_jump_pattern_emit_after (struct df *, rtx, basic_block, rtx);
-extern rtx df_pattern_emit_after PARAMS ((struct df *, rtx,
- basic_block, rtx));
+extern rtx df_pattern_emit_after (struct df *, rtx, basic_block, rtx);
-extern rtx df_insn_move_before PARAMS ((struct df *, basic_block, rtx,
- basic_block, rtx));
+extern rtx df_insn_move_before (struct df *, basic_block, rtx, basic_block,
+ rtx);
-extern int df_reg_replace PARAMS ((struct df *, bitmap, rtx, rtx));
+extern int df_reg_replace (struct df *, bitmap, rtx, rtx);
-extern int df_ref_reg_replace PARAMS ((struct df *, struct ref *, rtx, rtx));
+extern int df_ref_reg_replace (struct df *, struct ref *, rtx, rtx);
-extern int df_ref_remove PARAMS ((struct df *, struct ref *));
+extern int df_ref_remove (struct df *, struct ref *);
-extern int df_insn_reg_replace PARAMS ((struct df *, basic_block,
- rtx, rtx, rtx));
+extern int df_insn_reg_replace (struct df *, basic_block, rtx, rtx, rtx);
-extern int df_insn_mem_replace PARAMS ((struct df *, basic_block,
- rtx, rtx, rtx));
+extern int df_insn_mem_replace (struct df *, basic_block, rtx, rtx, rtx);
-extern struct ref *df_bb_def_use_swap PARAMS ((struct df *, basic_block,
- rtx, rtx, unsigned int));
+extern struct ref *df_bb_def_use_swap (struct df *, basic_block, rtx, rtx,
+ unsigned int);
/* Functions to query dataflow information. */
-extern basic_block df_regno_bb PARAMS((struct df *, unsigned int));
+extern basic_block df_regno_bb (struct df *, unsigned int);
-extern int df_reg_lifetime PARAMS ((struct df *, rtx));
+extern int df_reg_lifetime (struct df *, rtx);
-extern int df_reg_global_p PARAMS ((struct df *, rtx));
+extern int df_reg_global_p (struct df *, rtx);
-extern int df_insn_regno_def_p PARAMS ((struct df *,
- basic_block, rtx, unsigned int));
+extern int df_insn_regno_def_p (struct df *, basic_block, rtx, unsigned int);
-extern int df_insn_dominates_all_uses_p PARAMS ((struct df *,
- basic_block, rtx));
+extern int df_insn_dominates_all_uses_p (struct df *, basic_block, rtx);
-extern int df_insn_dominates_uses_p PARAMS ((struct df *, basic_block,
- rtx, bitmap));
+extern int df_insn_dominates_uses_p (struct df *, basic_block, rtx, bitmap);
-extern int df_bb_reg_live_start_p PARAMS ((struct df *, basic_block, rtx));
+extern int df_bb_reg_live_start_p (struct df *, basic_block, rtx);
-extern int df_bb_reg_live_end_p PARAMS ((struct df *, basic_block, rtx));
+extern int df_bb_reg_live_end_p (struct df *, basic_block, rtx);
-extern int df_bb_regs_lives_compare PARAMS ((struct df *, basic_block,
- rtx, rtx));
+extern int df_bb_regs_lives_compare (struct df *, basic_block, rtx, rtx);
-extern rtx df_bb_single_def_use_insn_find PARAMS((struct df *, basic_block,
- rtx, rtx));
+extern rtx df_bb_single_def_use_insn_find (struct df *, basic_block, rtx,
+ rtx);
/* Functions for debugging from GDB. */
-extern void debug_df_insn PARAMS ((rtx));
+extern void debug_df_insn (rtx);
-extern void debug_df_regno PARAMS ((unsigned int));
+extern void debug_df_regno (unsigned int);
-extern void debug_df_reg PARAMS ((rtx));
+extern void debug_df_reg (rtx);
-extern void debug_df_defno PARAMS ((unsigned int));
+extern void debug_df_defno (unsigned int);
-extern void debug_df_useno PARAMS ((unsigned int));
+extern void debug_df_useno (unsigned int);
-extern void debug_df_ref PARAMS ((struct ref *));
+extern void debug_df_ref (struct ref *);
-extern void debug_df_chain PARAMS ((struct df_link *));
+extern void debug_df_chain (struct df_link *);
-extern void df_insn_debug PARAMS ((struct df *, rtx, FILE *));
+extern void df_insn_debug (struct df *, rtx, FILE *);
-extern void df_insn_debug_regno PARAMS ((struct df *, rtx, FILE *));
+extern void df_insn_debug_regno (struct df *, rtx, FILE *);
/* Meet over any path (UNION) or meet over all paths (INTERSECTION). */
};
-typedef void (*transfer_function_sbitmap) PARAMS ((int, int *, sbitmap, sbitmap,
- sbitmap, sbitmap, void *));
+typedef void (*transfer_function_sbitmap) (int, int *, sbitmap, sbitmap,
+ sbitmap, sbitmap, void *);
-typedef void (*transfer_function_bitmap) PARAMS ((int, int *, bitmap, bitmap,
- bitmap, bitmap, void *));
+typedef void (*transfer_function_bitmap) (int, int *, bitmap, bitmap,
+ bitmap, bitmap, void *);
-extern void iterative_dataflow_sbitmap PARAMS ((sbitmap *, sbitmap *,
- sbitmap *, sbitmap *,
- bitmap, enum df_flow_dir,
- enum df_confluence_op,
- transfer_function_sbitmap,
- int *, void *));
+extern void iterative_dataflow_sbitmap (sbitmap *, sbitmap *, sbitmap *,
+ sbitmap *, bitmap, enum df_flow_dir,
+ enum df_confluence_op,
+ transfer_function_sbitmap,
+ int *, void *);
-extern void iterative_dataflow_bitmap PARAMS ((bitmap *, bitmap *, bitmap *,
- bitmap *, bitmap,
- enum df_flow_dir,
- enum df_confluence_op,
- transfer_function_bitmap,
- int *, void *));
-extern bool read_modify_subreg_p PARAMS ((rtx));
+extern void iterative_dataflow_bitmap (bitmap *, bitmap *, bitmap *,
+ bitmap *, bitmap,
+ enum df_flow_dir,
+ enum df_confluence_op,
+ transfer_function_bitmap,
+ int *, void *);
+extern bool read_modify_subreg_p (rtx);
#include "optabs.h"
#include "langhooks.h"
-static void do_jump_by_parts_greater PARAMS ((tree, int, rtx, rtx));
-static void do_jump_by_parts_equality PARAMS ((tree, rtx, rtx));
-static void do_compare_and_jump PARAMS ((tree, enum rtx_code, enum rtx_code,
- rtx, rtx));
+static void do_jump_by_parts_greater (tree, int, rtx, rtx);
+static void do_jump_by_parts_equality (tree, rtx, rtx);
+static void do_compare_and_jump (tree, enum rtx_code, enum rtx_code, rtx,
+ rtx);
/* At the start of a function, record that we have no previously-pushed
arguments waiting to be popped. */
void
-init_pending_stack_adjust ()
+init_pending_stack_adjust (void)
{
pending_stack_adjust = 0;
}
frame pointer regardless of the value of flag_omit_frame_pointer. */
void
-clear_pending_stack_adjust ()
+clear_pending_stack_adjust (void)
{
#ifdef EXIT_IGNORE_STACK
if (optimize > 0
/* Pop any previously-pushed arguments that have not been popped yet. */
void
-do_pending_stack_adjust ()
+do_pending_stack_adjust (void)
{
if (inhibit_defer_pop == 0)
{
functions here. */
void
-jumpifnot (exp, label)
- tree exp;
- rtx label;
+jumpifnot (tree exp, rtx label)
{
do_jump (exp, label, NULL_RTX);
}
/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
void
-jumpif (exp, label)
- tree exp;
- rtx label;
+jumpif (tree exp, rtx label)
{
do_jump (exp, NULL_RTX, label);
}
&&, || and comparison operators in EXP. */
void
-do_jump (exp, if_false_label, if_true_label)
- tree exp;
- rtx if_false_label, if_true_label;
+do_jump (tree exp, rtx if_false_label, rtx if_true_label)
{
enum tree_code code = TREE_CODE (exp);
/* Some cases need to create a label to jump to
and LT if SWAP is 1. */
static void
-do_jump_by_parts_greater (exp, swap, if_false_label, if_true_label)
- tree exp;
- int swap;
- rtx if_false_label, if_true_label;
+do_jump_by_parts_greater (tree exp, int swap, rtx if_false_label,
+ rtx if_true_label)
{
rtx op0 = expand_expr (TREE_OPERAND (exp, swap), NULL_RTX, VOIDmode, 0);
rtx op1 = expand_expr (TREE_OPERAND (exp, !swap), NULL_RTX, VOIDmode, 0);
Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
void
-do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label, if_true_label)
- enum machine_mode mode;
- int unsignedp;
- rtx op0, op1;
- rtx if_false_label, if_true_label;
+do_jump_by_parts_greater_rtx (enum machine_mode mode, int unsignedp, rtx op0,
+ rtx op1, rtx if_false_label, rtx if_true_label)
{
int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
rtx drop_through_label = 0;
with one insn, test the comparison and jump to the appropriate label. */
static void
-do_jump_by_parts_equality (exp, if_false_label, if_true_label)
- tree exp;
- rtx if_false_label, if_true_label;
+do_jump_by_parts_equality (tree exp, rtx if_false_label, rtx if_true_label)
{
rtx op0 = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
rtx op1 = expand_expr (TREE_OPERAND (exp, 1), NULL_RTX, VOIDmode, 0);
for the available compare insns. */
void
-do_jump_by_parts_equality_rtx (op0, if_false_label, if_true_label)
- rtx op0;
- rtx if_false_label, if_true_label;
+do_jump_by_parts_equality_rtx (rtx op0, rtx if_false_label, rtx if_true_label)
{
int nwords = GET_MODE_SIZE (GET_MODE (op0)) / UNITS_PER_WORD;
rtx part;
compared. */
rtx
-compare_from_rtx (op0, op1, code, unsignedp, mode, size)
- rtx op0, op1;
- enum rtx_code code;
- int unsignedp;
- enum machine_mode mode;
- rtx size;
+compare_from_rtx (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
+ enum machine_mode mode, rtx size)
{
enum rtx_code ucode;
rtx tem;
compared. */
void
-do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, size,
- if_false_label, if_true_label)
- rtx op0, op1;
- enum rtx_code code;
- int unsignedp;
- enum machine_mode mode;
- rtx size;
- rtx if_false_label, if_true_label;
+do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
+ enum machine_mode mode, rtx size, rtx if_false_label,
+ rtx if_true_label)
{
enum rtx_code ucode;
rtx tem;
things pushed on the stack that aren't yet used. */
static void
-do_compare_and_jump (exp, signed_code, unsigned_code, if_false_label,
- if_true_label)
- tree exp;
- enum rtx_code signed_code, unsigned_code;
- rtx if_false_label, if_true_label;
+do_compare_and_jump (tree exp, enum rtx_code signed_code,
+ enum rtx_code unsigned_code, rtx if_false_label,
+ rtx if_true_label)
{
rtx op0, op1;
tree type;
/* Perform doloop optimizations
- Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2001, 2002, 2003
+ Free Software Foundation, Inc.
Contributed by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
This file is part of GCC.
#ifdef HAVE_doloop_end
-static rtx doloop_condition_get
- PARAMS ((rtx));
-static unsigned HOST_WIDE_INT doloop_iterations_max
- PARAMS ((const struct loop_info *, enum machine_mode, int));
-static int doloop_valid_p
- PARAMS ((const struct loop *, rtx));
-static int doloop_modify
- PARAMS ((const struct loop *, rtx, rtx, rtx, rtx, rtx));
-static int doloop_modify_runtime
- PARAMS ((const struct loop *, rtx, rtx, rtx, enum machine_mode, rtx));
+static rtx doloop_condition_get (rtx);
+static unsigned HOST_WIDE_INT doloop_iterations_max (const struct loop_info *,
+ enum machine_mode, int);
+static int doloop_valid_p (const struct loop *, rtx);
+static int doloop_modify (const struct loop *, rtx, rtx, rtx, rtx, rtx);
+static int doloop_modify_runtime (const struct loop *, rtx, rtx, rtx,
+ enum machine_mode, rtx);
/* Return the loop termination condition for PATTERN or zero
if it is not a decrement and branch jump insn. */
static rtx
-doloop_condition_get (pattern)
- rtx pattern;
+doloop_condition_get (rtx pattern)
{
rtx cmp;
rtx inc;
MODE is the mode of the iteration count and NONNEG is nonzero if
the iteration count has been proved to be non-negative. */
static unsigned HOST_WIDE_INT
-doloop_iterations_max (loop_info, mode, nonneg)
- const struct loop_info *loop_info;
- enum machine_mode mode;
- int nonneg;
+doloop_iterations_max (const struct loop_info *loop_info,
+ enum machine_mode mode, int nonneg)
{
unsigned HOST_WIDE_INT n_iterations_max;
enum rtx_code code;
/* Return nonzero if the loop specified by LOOP is suitable for
the use of special low-overhead looping instructions. */
static int
-doloop_valid_p (loop, jump_insn)
- const struct loop *loop;
- rtx jump_insn;
+doloop_valid_p (const struct loop *loop, rtx jump_insn)
{
const struct loop_info *loop_info = LOOP_INFO (loop);
low-overhead looping insn to emit at the end of the loop. This
returns nonzero if it was successful. */
static int
-doloop_modify (loop, iterations, iterations_max,
- doloop_seq, start_label, condition)
- const struct loop *loop;
- rtx iterations;
- rtx iterations_max;
- rtx doloop_seq;
- rtx start_label;
- rtx condition;
+doloop_modify (const struct loop *loop, rtx iterations, rtx iterations_max,
+ rtx doloop_seq, rtx start_label, rtx condition)
{
rtx counter_reg;
rtx count;
number of loop iterations. DOLOOP_INSN is the low-overhead looping
insn to insert. Returns nonzero if loop successfully modified. */
static int
-doloop_modify_runtime (loop, iterations_max,
- doloop_seq, start_label, mode, condition)
- const struct loop *loop;
- rtx iterations_max;
- rtx doloop_seq;
- rtx start_label;
- enum machine_mode mode;
- rtx condition;
+doloop_modify_runtime (const struct loop *loop, rtx iterations_max,
+ rtx doloop_seq, rtx start_label,
+ enum machine_mode mode, rtx condition)
{
const struct loop_info *loop_info = LOOP_INFO (loop);
HOST_WIDE_INT abs_inc;
is a candidate for this optimization. Returns nonzero if loop
successfully modified. */
int
-doloop_optimize (loop)
- const struct loop *loop;
+doloop_optimize (const struct loop *loop)
{
struct loop_info *loop_info = LOOP_INFO (loop);
rtx initial_value;
/* Calculate (post)dominators in slightly super-linear time.
- Copyright (C) 2000 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2003 Free Software Foundation, Inc.
Contributed by Michael Matz (matz@ifh.de).
This file is part of GCC.
unsigned int nodes;
};
-static void init_dom_info PARAMS ((struct dom_info *));
-static void free_dom_info PARAMS ((struct dom_info *));
-static void calc_dfs_tree_nonrec PARAMS ((struct dom_info *,
- basic_block,
- enum cdi_direction));
-static void calc_dfs_tree PARAMS ((struct dom_info *,
- enum cdi_direction));
-static void compress PARAMS ((struct dom_info *, TBB));
-static TBB eval PARAMS ((struct dom_info *, TBB));
-static void link_roots PARAMS ((struct dom_info *, TBB, TBB));
-static void calc_idoms PARAMS ((struct dom_info *,
- enum cdi_direction));
-void debug_dominance_info PARAMS ((dominance_info));
+static void init_dom_info (struct dom_info *);
+static void free_dom_info (struct dom_info *);
+static void calc_dfs_tree_nonrec (struct dom_info *, basic_block,
+ enum cdi_direction);
+static void calc_dfs_tree (struct dom_info *, enum cdi_direction);
+static void compress (struct dom_info *, TBB);
+static TBB eval (struct dom_info *, TBB);
+static void link_roots (struct dom_info *, TBB, TBB);
+static void calc_idoms (struct dom_info *, enum cdi_direction);
+void debug_dominance_info (dominance_info);
/* Helper macro for allocating and initializing an array,
for aesthetic reasons. */
This initializes the contents of DI, which already must be allocated. */
static void
-init_dom_info (di)
- struct dom_info *di;
+init_dom_info (struct dom_info *di)
{
/* We need memory for n_basic_blocks nodes and the ENTRY_BLOCK or
EXIT_BLOCK. */
/* Free all allocated memory in DI, but not DI itself. */
static void
-free_dom_info (di)
- struct dom_info *di;
+free_dom_info (struct dom_info *di)
{
free (di->dfs_parent);
free (di->path_min);
assigned their dfs number and are linked together to form a tree. */
static void
-calc_dfs_tree_nonrec (di, bb, reverse)
- struct dom_info *di;
- basic_block bb;
- enum cdi_direction reverse;
+calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, enum cdi_direction reverse)
{
/* We never call this with bb==EXIT_BLOCK_PTR (ENTRY_BLOCK_PTR if REVERSE). */
/* We call this _only_ if bb is not already visited. */
because there may be nodes from which the EXIT_BLOCK is unreachable. */
static void
-calc_dfs_tree (di, reverse)
- struct dom_info *di;
- enum cdi_direction reverse;
+calc_dfs_tree (struct dom_info *di, enum cdi_direction reverse)
{
/* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE). */
basic_block begin = reverse ? EXIT_BLOCK_PTR : ENTRY_BLOCK_PTR;
from V to that root. */
static void
-compress (di, v)
- struct dom_info *di;
- TBB v;
+compress (struct dom_info *di, TBB v)
{
/* Btw. It's not worth to unrecurse compress() as the depth is usually not
greater than 5 even for huge graphs (I've not seen call depth > 4).
value on the path from V to the root. */
static inline TBB
-eval (di, v)
- struct dom_info *di;
- TBB v;
+eval (struct dom_info *di, TBB v)
{
/* The representant of the set V is in, also called root (as the set
representation is a tree). */
of W. */
static void
-link_roots (di, v, w)
- struct dom_info *di;
- TBB v, w;
+link_roots (struct dom_info *di, TBB v, TBB w)
{
TBB s = w;
On return the immediate dominator to node V is in di->dom[V]. */
static void
-calc_idoms (di, reverse)
- struct dom_info *di;
- enum cdi_direction reverse;
+calc_idoms (struct dom_info *di, enum cdi_direction reverse)
{
TBB v, w, k, par;
basic_block en_block;
immediate resp. all dominators). */
dominance_info
-calculate_dominance_info (reverse)
- enum cdi_direction reverse;
+calculate_dominance_info (enum cdi_direction reverse)
{
struct dom_info di;
dominance_info info;
/* Free dominance information. */
void
-free_dominance_info (info)
- dominance_info info;
+free_dominance_info (dominance_info info)
{
basic_block bb;
/* Return the immediate dominator of basic block BB. */
basic_block
-get_immediate_dominator (dom, bb)
- dominance_info dom;
- basic_block bb;
+get_immediate_dominator (dominance_info dom, basic_block bb)
{
return et_forest_node_value (dom->forest,
et_forest_parent (dom->forest,
/* Set the immediate dominator of the block possibly removing
existing edge. NULL can be used to remove any edge. */
inline void
-set_immediate_dominator (dom, bb, dominated_by)
- dominance_info dom;
- basic_block bb, dominated_by;
+set_immediate_dominator (dominance_info dom, basic_block bb, basic_block dominated_by)
{
void *aux_bb_node;
et_forest_node_t bb_node = BB_NODE (dom, bb);
/* Store all basic blocks dominated by BB into BBS and return their number. */
int
-get_dominated_by (dom, bb, bbs)
- dominance_info dom;
- basic_block bb;
- basic_block **bbs;
+get_dominated_by (dominance_info dom, basic_block bb, basic_block **bbs)
{
int n, i;
/* Redirect all edges pointing to BB to TO. */
void
-redirect_immediate_dominators (dom, bb, to)
- dominance_info dom;
- basic_block bb;
- basic_block to;
+redirect_immediate_dominators (dominance_info dom, basic_block bb, basic_block to)
{
et_forest_node_t *bbs = xmalloc (n_basic_blocks * sizeof (basic_block));
et_forest_node_t node = BB_NODE (dom, bb);
/* Find first basic block in the tree dominating both BB1 and BB2. */
basic_block
-nearest_common_dominator (dom, bb1, bb2)
- dominance_info dom;
- basic_block bb1;
- basic_block bb2;
+nearest_common_dominator (dominance_info dom, basic_block bb1, basic_block bb2)
{
if (!bb1)
return bb2;
/* Return TRUE in case BB1 is dominated by BB2. */
bool
-dominated_by_p (dom, bb1, bb2)
- dominance_info dom;
- basic_block bb1;
- basic_block bb2;
+dominated_by_p (dominance_info dom, basic_block bb1, basic_block bb2)
{
return nearest_common_dominator (dom, bb1, bb2) == bb2;
}
/* Verify invariants of dominator structure. */
void
-verify_dominators (dom)
- dominance_info dom;
+verify_dominators (dominance_info dom)
{
int err = 0;
basic_block bb;
/* Recount dominator of BB. */
basic_block
-recount_dominator (dom, bb)
- dominance_info dom;
- basic_block bb;
+recount_dominator (dominance_info dom, basic_block bb)
{
basic_block dom_bb = NULL;
edge e;
/* Iteratively recount dominators of BBS. The change is supposed to be local
and not to grow further. */
void
-iterate_fix_dominators (dom, bbs, n)
- dominance_info dom;
- basic_block *bbs;
- int n;
+iterate_fix_dominators (dominance_info dom, basic_block *bbs, int n)
{
int i, changed = 1;
basic_block old_dom, new_dom;
}
void
-add_to_dominance_info (dom, bb)
- dominance_info dom;
- basic_block bb;
+add_to_dominance_info (dominance_info dom, basic_block bb)
{
VARRAY_GROW (dom->varray, last_basic_block + 3);
#ifdef ENABLE_CHECKING
}
void
-delete_from_dominance_info (dom, bb)
- dominance_info dom;
- basic_block bb;
+delete_from_dominance_info (dominance_info dom, basic_block bb)
{
et_forest_remove_node (dom->forest, BB_NODE (dom, bb));
SET_BB_NODE (dom, bb, NULL);
}
void
-debug_dominance_info (dom)
- dominance_info dom;
+debug_dominance_info (dominance_info dom)
{
basic_block bb, bb2;
FOR_EACH_BB (bb)
/* Dwarf2 assembler output helper routines.
- Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
This file is part of GCC.
to print a newline, since the caller may want to add a comment. */
void
-dw2_assemble_integer (size, x)
- int size;
- rtx x;
+dw2_assemble_integer (int size, rtx x)
{
const char *op = integer_asm_op (size, FALSE);
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
if (size * 8 < HOST_BITS_PER_WIDE_INT)
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
#ifdef ASM_OUTPUT_DWARF_DELTA
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
#ifdef ASM_OUTPUT_DWARF_OFFSET
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
#ifdef ASM_OUTPUT_DWARF_PCREL
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
dw2_assemble_integer (size, gen_rtx_SYMBOL_REF (Pmode, label));
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
dw2_assemble_integer (size, addr);
/* Return the size of an unsigned LEB128 quantity. */
int
-size_of_uleb128 (value)
- unsigned HOST_WIDE_INT value;
+size_of_uleb128 (unsigned HOST_WIDE_INT value)
{
int size = 0;
/* Return the size of a signed LEB128 quantity. */
int
-size_of_sleb128 (value)
- HOST_WIDE_INT value;
+size_of_sleb128 (HOST_WIDE_INT value)
{
int size = 0, byte;
include leb128. */
int
-size_of_encoded_value (encoding)
- int encoding;
+size_of_encoded_value (int encoding)
{
if (encoding == DW_EH_PE_omit)
return 0;
/* Yield a name for a given pointer encoding. */
const char *
-eh_data_format_name (format)
- int format;
+eh_data_format_name (int format)
{
#if HAVE_DESIGNATED_INITIALIZERS
#define S(p, v) [p] = v,
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
#ifdef HAVE_AS_LEB128
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
#ifdef HAVE_AS_LEB128
const char *comment, ...)
{
va_list ap;
-
+
va_start (ap, comment);
#ifdef HAVE_AS_LEB128
va_end (ap);
}
\f
-static rtx dw2_force_const_mem PARAMS ((rtx));
-static int dw2_output_indirect_constant_1 PARAMS ((splay_tree_node, void *));
+static rtx dw2_force_const_mem (rtx);
+static int dw2_output_indirect_constant_1 (splay_tree_node, void *);
static GTY((param1_is (char *), param2_is (tree))) splay_tree indirect_pool;
"near" the function in any interesting sense. */
static rtx
-dw2_force_const_mem (x)
- rtx x;
+dw2_force_const_mem (rtx x)
{
splay_tree_node node;
const char *str;
splay_tree_foreach. Emit one queued constant to memory. */
static int
-dw2_output_indirect_constant_1 (node, data)
- splay_tree_node node;
- void* data ATTRIBUTE_UNUSED;
+dw2_output_indirect_constant_1 (splay_tree_node node,
+ void *data ATTRIBUTE_UNUSED)
{
const char *sym;
rtx sym_ref;
/* Emit the constants queued through dw2_force_const_mem. */
void
-dw2_output_indirect_constants ()
+dw2_output_indirect_constants (void)
{
if (indirect_pool)
splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL);
{
int size;
va_list ap;
-
+
va_start (ap, comment);
size = size_of_encoded_value (encoding);
#include "hashtab.h"
#ifdef DWARF2_DEBUGGING_INFO
-static void dwarf2out_source_line PARAMS ((unsigned int, const char *));
+static void dwarf2out_source_line (unsigned int, const char *);
#endif
/* DWARF2 Abbreviation Glossary:
translation unit. */
int
-dwarf2out_do_frame ()
+dwarf2out_do_frame (void)
{
return (write_symbols == DWARF2_DEBUG
|| write_symbols == VMS_AND_DWARF2_DEBUG
guards. */
void
-default_eh_frame_section ()
+default_eh_frame_section (void)
{
#ifdef EH_FRAME_SECTION_NAME
#ifdef HAVE_LD_RO_RW_SECTION_MIXING
{
dw_cfi_ref dw_cfi_next;
enum dwarf_call_frame_info dw_cfi_opc;
- dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
+ dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
dw_cfi_oprnd1;
- dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
+ dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
dw_cfi_oprnd2;
}
dw_cfi_node;
/* Forward declarations for functions defined in this file. */
-static char *stripattributes PARAMS ((const char *));
-static const char *dwarf_cfi_name PARAMS ((unsigned));
-static dw_cfi_ref new_cfi PARAMS ((void));
-static void add_cfi PARAMS ((dw_cfi_ref *, dw_cfi_ref));
-static void add_fde_cfi PARAMS ((const char *, dw_cfi_ref));
-static void lookup_cfa_1 PARAMS ((dw_cfi_ref,
- dw_cfa_location *));
-static void lookup_cfa PARAMS ((dw_cfa_location *));
-static void reg_save PARAMS ((const char *, unsigned,
- unsigned, long));
-static void initial_return_save PARAMS ((rtx));
-static long stack_adjust_offset PARAMS ((rtx));
-static void output_cfi PARAMS ((dw_cfi_ref, dw_fde_ref, int));
-static void output_call_frame_info PARAMS ((int));
-static void dwarf2out_stack_adjust PARAMS ((rtx));
-static void queue_reg_save PARAMS ((const char *, rtx, long));
-static void flush_queued_reg_saves PARAMS ((void));
-static bool clobbers_queued_reg_save PARAMS ((rtx));
-static void dwarf2out_frame_debug_expr PARAMS ((rtx, const char *));
+static char *stripattributes (const char *);
+static const char *dwarf_cfi_name (unsigned);
+static dw_cfi_ref new_cfi (void);
+static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
+static void add_fde_cfi (const char *, dw_cfi_ref);
+static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
+static void lookup_cfa (dw_cfa_location *);
+static void reg_save (const char *, unsigned, unsigned, long);
+static void initial_return_save (rtx);
+static long stack_adjust_offset (rtx);
+static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
+static void output_call_frame_info (int);
+static void dwarf2out_stack_adjust (rtx);
+static void queue_reg_save (const char *, rtx, long);
+static void flush_queued_reg_saves (void);
+static bool clobbers_queued_reg_save (rtx);
+static void dwarf2out_frame_debug_expr (rtx, const char *);
/* Support for complex CFA locations. */
-static void output_cfa_loc PARAMS ((dw_cfi_ref));
-static void get_cfa_from_loc_descr PARAMS ((dw_cfa_location *,
- struct dw_loc_descr_struct *));
+static void output_cfa_loc (dw_cfi_ref);
+static void get_cfa_from_loc_descr (dw_cfa_location *,
+ struct dw_loc_descr_struct *);
static struct dw_loc_descr_struct *build_cfa_loc
- PARAMS ((dw_cfa_location *));
-static void def_cfa_1 PARAMS ((const char *,
- dw_cfa_location *));
+ (dw_cfa_location *);
+static void def_cfa_1 (const char *, dw_cfa_location *);
/* How to start an assembler comment. */
#ifndef ASM_COMMENT_START
registers. */
#ifndef DWARF_FRAME_RETURN_COLUMN
#ifdef PC_REGNUM
-#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
+#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
#else
-#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
+#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
#endif
#endif
/* Hook used by __throw. */
rtx
-expand_builtin_dwarf_sp_column ()
+expand_builtin_dwarf_sp_column (void)
{
return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
}
attributes stripped off, and an asterisk prepended (for assemble_name). */
static inline char *
-stripattributes (s)
- const char *s;
+stripattributes (const char *s)
{
char *stripped = xmalloc (strlen (s) + 2);
char *p = stripped;
/* Generate code to initialize the register size table. */
void
-expand_builtin_init_dwarf_reg_sizes (address)
- tree address;
+expand_builtin_init_dwarf_reg_sizes (tree address)
{
int i;
enum machine_mode mode = TYPE_MODE (char_type_node);
/* Convert a DWARF call frame info. operation to its string name */
static const char *
-dwarf_cfi_name (cfi_opc)
- unsigned cfi_opc;
+dwarf_cfi_name (unsigned int cfi_opc)
{
switch (cfi_opc)
{
/* Return a pointer to a newly allocated Call Frame Instruction. */
static inline dw_cfi_ref
-new_cfi ()
+new_cfi (void)
{
dw_cfi_ref cfi = (dw_cfi_ref) ggc_alloc (sizeof (dw_cfi_node));
/* Add a Call Frame Instruction to list of instructions. */
static inline void
-add_cfi (list_head, cfi)
- dw_cfi_ref *list_head;
- dw_cfi_ref cfi;
+add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
{
dw_cfi_ref *p;
/* Generate a new label for the CFI info to refer to. */
char *
-dwarf2out_cfi_label ()
+dwarf2out_cfi_label (void)
{
static char label[20];
or to the CIE if LABEL is NULL. */
static void
-add_fde_cfi (label, cfi)
- const char *label;
- dw_cfi_ref cfi;
+add_fde_cfi (const char *label, dw_cfi_ref cfi)
{
if (label)
{
/* Subroutine of lookup_cfa. */
static inline void
-lookup_cfa_1 (cfi, loc)
- dw_cfi_ref cfi;
- dw_cfa_location *loc;
+lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
{
switch (cfi->dw_cfi_opc)
{
/* Find the previous value for the CFA. */
static void
-lookup_cfa (loc)
- dw_cfa_location *loc;
+lookup_cfa (dw_cfa_location *loc)
{
dw_cfi_ref cfi;
calculated from REG+OFFSET. */
void
-dwarf2out_def_cfa (label, reg, offset)
- const char *label;
- unsigned reg;
- long offset;
+dwarf2out_def_cfa (const char *label, unsigned int reg, long int offset)
{
dw_cfa_location loc;
loc.indirect = 0;
the dw_cfa_location structure. */
static void
-def_cfa_1 (label, loc_p)
- const char *label;
- dw_cfa_location *loc_p;
+def_cfa_1 (const char *label, dw_cfa_location *loc_p)
{
dw_cfi_ref cfi;
dw_cfa_location old_cfa, loc;
otherwise it is saved in SREG. */
static void
-reg_save (label, reg, sreg, offset)
- const char *label;
- unsigned reg;
- unsigned sreg;
- long offset;
+reg_save (const char *label, unsigned int reg, unsigned int sreg, long int offset)
{
dw_cfi_ref cfi = new_cfi ();
assuming 0(cfa)) and what registers are in the window. */
void
-dwarf2out_window_save (label)
- const char *label;
+dwarf2out_window_save (const char *label)
{
dw_cfi_ref cfi = new_cfi ();
pushed onto the stack. */
void
-dwarf2out_args_size (label, size)
- const char *label;
- long size;
+dwarf2out_args_size (const char *label, long int size)
{
dw_cfi_ref cfi;
number. LABEL and OFFSET are passed to reg_save. */
void
-dwarf2out_reg_save (label, reg, offset)
- const char *label;
- unsigned reg;
- long offset;
+dwarf2out_reg_save (const char *label, unsigned int reg, long int offset)
{
reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
}
LABEL and OFFSET are passed to reg_save. */
void
-dwarf2out_return_save (label, offset)
- const char *label;
- long offset;
+dwarf2out_return_save (const char *label, long int offset)
{
reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
}
LABEL and SREG are passed to reg_save. */
void
-dwarf2out_return_reg (label, sreg)
- const char *label;
- unsigned sreg;
+dwarf2out_return_reg (const char *label, unsigned int sreg)
{
reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
}
INCOMING_RETURN_ADDR_RTX. */
static void
-initial_return_save (rtl)
- rtx rtl;
+initial_return_save (rtx rtl)
{
unsigned int reg = (unsigned int) -1;
HOST_WIDE_INT offset = 0;
contains. */
static long
-stack_adjust_offset (pattern)
- rtx pattern;
+stack_adjust_offset (rtx pattern)
{
rtx src = SET_SRC (pattern);
rtx dest = SET_DEST (pattern);
much extra space it needs to pop off the stack. */
static void
-dwarf2out_stack_adjust (insn)
- rtx insn;
+dwarf2out_stack_adjust (rtx insn)
{
HOST_WIDE_INT offset;
const char *label;
static const char *last_reg_save_label;
static void
-queue_reg_save (label, reg, offset)
- const char *label;
- rtx reg;
- long offset;
+queue_reg_save (const char *label, rtx reg, long int offset)
{
struct queued_reg_save *q = ggc_alloc (sizeof (*q));
}
static void
-flush_queued_reg_saves ()
+flush_queued_reg_saves (void)
{
struct queued_reg_save *q, *next;
}
static bool
-clobbers_queued_reg_save (insn)
- rtx insn;
+clobbers_queued_reg_save (rtx insn)
{
struct queued_reg_save *q;
to track stores to the stack via fp or a temp reg.
Rules 1- 4: Setting a register's value to cfa.reg or an expression
- with cfa.reg as the first operand changes the cfa.reg and its
+ with cfa.reg as the first operand changes the cfa.reg and its
cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
cfa_temp.offset.
(set sp ({minus,plus,losum} {sp,fp}:cfa.reg
{<const_int>,<reg>:cfa_temp.reg}))
effects: cfa.reg = sp if fp used
- cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
+ cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
if cfa_store.reg==sp
Rule 3:
(set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
effects: cfa.reg = fp
- cfa_offset += +/- <const_int>
+ cfa_offset += +/- <const_int>
Rule 4:
(set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
constraints: <reg1> != fp
- <reg1> != sp
+ <reg1> != sp
effects: cfa.reg = <reg1>
cfa_temp.reg = <reg1>
cfa_temp.offset = cfa.offset
Rule 5:
(set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
constraints: <reg1> != fp
- <reg1> != sp
+ <reg1> != sp
effects: cfa_store.reg = <reg1>
- cfa_store.offset = cfa.offset - cfa_temp.offset
+ cfa_store.offset = cfa.offset - cfa_temp.offset
Rule 6:
(set <reg> <const_int>)
effects: cfa_temp.reg = <reg>
- cfa_temp.offset = <const_int>
+ cfa_temp.offset = <const_int>
Rule 7:
(set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
Rule 9:
(set <reg> (lo_sum <exp> <const_int>))
effects: cfa_temp.reg = <reg>
- cfa_temp.offset = <const_int>
+ cfa_temp.offset = <const_int>
Rule 10:
(set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
cfa_temp.offset -= mode_size(mem) */
static void
-dwarf2out_frame_debug_expr (expr, label)
- rtx expr;
- const char *label;
+dwarf2out_frame_debug_expr (rtx expr, const char *label)
{
rtx src, dest;
HOST_WIDE_INT offset;
register to the stack. If INSN is NULL_RTX, initialize our state. */
void
-dwarf2out_frame_debug (insn)
- rtx insn;
+dwarf2out_frame_debug (rtx insn)
{
const char *label;
rtx src;
#endif
/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
-static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
- PARAMS ((enum dwarf_call_frame_info cfi));
+static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
+ (enum dwarf_call_frame_info cfi);
static enum dw_cfi_oprnd_type
-dw_cfi_oprnd1_desc (cfi)
- enum dwarf_call_frame_info cfi;
+dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
{
switch (cfi)
{
case DW_CFA_GNU_args_size:
case DW_CFA_def_cfa_offset_sf:
return dw_cfi_oprnd_offset;
-
+
case DW_CFA_def_cfa_expression:
case DW_CFA_expression:
return dw_cfi_oprnd_loc;
}
/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
-static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
- PARAMS ((enum dwarf_call_frame_info cfi));
+static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
+ (enum dwarf_call_frame_info cfi);
static enum dw_cfi_oprnd_type
-dw_cfi_oprnd2_desc (cfi)
- enum dwarf_call_frame_info cfi;
+dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
{
switch (cfi)
{
/* Output a Call Frame Information opcode and its operand(s). */
static void
-output_cfi (cfi, fde, for_eh)
- dw_cfi_ref cfi;
- dw_fde_ref fde;
- int for_eh;
+output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
{
if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
dw2_asm_output_data (1, (cfi->dw_cfi_opc
location of saved registers. */
static void
-output_call_frame_info (for_eh)
- int for_eh;
+output_call_frame_info (int for_eh)
{
unsigned int i;
dw_fde_ref fde;
/* Augmentation:
z Indicates that a uleb128 is present to size the
- augmentation section.
+ augmentation section.
L Indicates the encoding (and thus presence) of
an LSDA pointer in the FDE augmentation.
R Indicates a non-default pointer encoding for
fde->funcdef_number);
dw2_asm_output_encoded_addr_rtx (
lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
- "Language Specific Data Area");
+ "Language Specific Data Area");
}
else
{
the prologue. */
void
-dwarf2out_begin_prologue (line, file)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *file ATTRIBUTE_UNUSED;
+dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
+ const char *file ATTRIBUTE_UNUSED)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
dw_fde_ref fde;
been generated. */
void
-dwarf2out_end_epilogue (line, file)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *file ATTRIBUTE_UNUSED;
+dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
+ const char *file ATTRIBUTE_UNUSED)
{
dw_fde_ref fde;
char label[MAX_ARTIFICIAL_LABEL_BYTES];
}
void
-dwarf2out_frame_init ()
+dwarf2out_frame_init (void)
{
/* Allocate the initial hunk of the fde_table. */
fde_table = (dw_fde_ref) ggc_alloc_cleared (FDE_TABLE_INCREMENT
}
void
-dwarf2out_frame_finish ()
+dwarf2out_frame_finish (void)
{
/* Output call frame information. */
if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
-static const char *dwarf_stack_op_name PARAMS ((unsigned));
-static dw_loc_descr_ref new_loc_descr PARAMS ((enum dwarf_location_atom,
- unsigned long,
- unsigned long));
-static void add_loc_descr PARAMS ((dw_loc_descr_ref *,
- dw_loc_descr_ref));
-static unsigned long size_of_loc_descr PARAMS ((dw_loc_descr_ref));
-static unsigned long size_of_locs PARAMS ((dw_loc_descr_ref));
-static void output_loc_operands PARAMS ((dw_loc_descr_ref));
-static void output_loc_sequence PARAMS ((dw_loc_descr_ref));
+static const char *dwarf_stack_op_name (unsigned);
+static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
+ unsigned long, unsigned long);
+static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
+static unsigned long size_of_loc_descr (dw_loc_descr_ref);
+static unsigned long size_of_locs (dw_loc_descr_ref);
+static void output_loc_operands (dw_loc_descr_ref);
+static void output_loc_sequence (dw_loc_descr_ref);
/* Convert a DWARF stack opcode into its string name. */
static const char *
-dwarf_stack_op_name (op)
- unsigned op;
+dwarf_stack_op_name (unsigned int op)
{
switch (op)
{
together to form more complicated location (address) descriptions. */
static inline dw_loc_descr_ref
-new_loc_descr (op, oprnd1, oprnd2)
- enum dwarf_location_atom op;
- unsigned long oprnd1;
- unsigned long oprnd2;
+new_loc_descr (enum dwarf_location_atom op, long unsigned int oprnd1,
+ long unsigned int oprnd2)
{
dw_loc_descr_ref descr
= (dw_loc_descr_ref) ggc_alloc_cleared (sizeof (dw_loc_descr_node));
/* Add a location description term to a location description expression. */
static inline void
-add_loc_descr (list_head, descr)
- dw_loc_descr_ref *list_head;
- dw_loc_descr_ref descr;
+add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
{
dw_loc_descr_ref *d;
/* Return the size of a location descriptor. */
static unsigned long
-size_of_loc_descr (loc)
- dw_loc_descr_ref loc;
+size_of_loc_descr (dw_loc_descr_ref loc)
{
unsigned long size = 1;
/* Return the size of a series of location descriptors. */
static unsigned long
-size_of_locs (loc)
- dw_loc_descr_ref loc;
+size_of_locs (dw_loc_descr_ref loc)
{
unsigned long size;
/* Output location description stack opcode's operands (if any). */
static void
-output_loc_operands (loc)
- dw_loc_descr_ref loc;
+output_loc_operands (dw_loc_descr_ref loc)
{
dw_val_ref val1 = &loc->dw_loc_oprnd1;
dw_val_ref val2 = &loc->dw_loc_oprnd2;
/* Output a sequence of location operations. */
static void
-output_loc_sequence (loc)
- dw_loc_descr_ref loc;
+output_loc_sequence (dw_loc_descr_ref loc)
{
for (; loc != NULL; loc = loc->dw_loc_next)
{
description based on a cfi entry with a complex address. */
static void
-output_cfa_loc (cfi)
- dw_cfi_ref cfi;
+output_cfa_loc (dw_cfi_ref cfi)
{
dw_loc_descr_ref loc;
unsigned long size;
a dw_cfa_location. */
static struct dw_loc_descr_struct *
-build_cfa_loc (cfa)
- dw_cfa_location *cfa;
+build_cfa_loc (dw_cfa_location *cfa)
{
struct dw_loc_descr_struct *head, *tmp;
descriptor sequence. */
static void
-get_cfa_from_loc_descr (cfa, loc)
- dw_cfa_location *cfa;
- struct dw_loc_descr_struct *loc;
+get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
{
struct dw_loc_descr_struct *ptr;
cfa->offset = 0;
#ifdef DWARF2_DEBUGGING_INFO
/* .debug_str support. */
-static int output_indirect_string PARAMS ((void **, void *));
-
-static void dwarf2out_init PARAMS ((const char *));
-static void dwarf2out_finish PARAMS ((const char *));
-static void dwarf2out_define PARAMS ((unsigned int, const char *));
-static void dwarf2out_undef PARAMS ((unsigned int, const char *));
-static void dwarf2out_start_source_file PARAMS ((unsigned, const char *));
-static void dwarf2out_end_source_file PARAMS ((unsigned));
-static void dwarf2out_begin_block PARAMS ((unsigned, unsigned));
-static void dwarf2out_end_block PARAMS ((unsigned, unsigned));
-static bool dwarf2out_ignore_block PARAMS ((tree));
-static void dwarf2out_global_decl PARAMS ((tree));
-static void dwarf2out_abstract_function PARAMS ((tree));
+static int output_indirect_string (void **, void *);
+
+static void dwarf2out_init (const char *);
+static void dwarf2out_finish (const char *);
+static void dwarf2out_define (unsigned int, const char *);
+static void dwarf2out_undef (unsigned int, const char *);
+static void dwarf2out_start_source_file (unsigned, const char *);
+static void dwarf2out_end_source_file (unsigned);
+static void dwarf2out_begin_block (unsigned, unsigned);
+static void dwarf2out_end_block (unsigned, unsigned);
+static bool dwarf2out_ignore_block (tree);
+static void dwarf2out_global_decl (tree);
+static void dwarf2out_abstract_function (tree);
/* The debug hooks structure. */
/* A pointer to the base of a list of references to DIE's that
are uniquely identified by their tag, presence/absence of
children DIE's, and list of attribute/value pairs. */
-static GTY((length ("abbrev_die_table_allocated")))
+static GTY((length ("abbrev_die_table_allocated")))
dw_die_ref *abbrev_die_table;
/* Number of elements currently allocated for abbrev_die_table. */
/* A pointer to the base of a table that contains line information
for each source code line in .text in the compilation unit. */
-static GTY((length ("line_info_table_allocated")))
+static GTY((length ("line_info_table_allocated")))
dw_line_info_ref line_info_table;
/* Number of elements currently allocated for line_info_table. */
/* Forward declarations for functions defined in this file. */
-static int is_pseudo_reg PARAMS ((rtx));
-static tree type_main_variant PARAMS ((tree));
-static int is_tagged_type PARAMS ((tree));
-static const char *dwarf_tag_name PARAMS ((unsigned));
-static const char *dwarf_attr_name PARAMS ((unsigned));
-static const char *dwarf_form_name PARAMS ((unsigned));
+static int is_pseudo_reg (rtx);
+static tree type_main_variant (tree);
+static int is_tagged_type (tree);
+static const char *dwarf_tag_name (unsigned);
+static const char *dwarf_attr_name (unsigned);
+static const char *dwarf_form_name (unsigned);
#if 0
-static const char *dwarf_type_encoding_name PARAMS ((unsigned));
+static const char *dwarf_type_encoding_name (unsigned);
#endif
-static tree decl_ultimate_origin PARAMS ((tree));
-static tree block_ultimate_origin PARAMS ((tree));
-static tree decl_class_context PARAMS ((tree));
-static void add_dwarf_attr PARAMS ((dw_die_ref, dw_attr_ref));
-static inline enum dw_val_class AT_class PARAMS ((dw_attr_ref));
-static void add_AT_flag PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned));
-static inline unsigned AT_flag PARAMS ((dw_attr_ref));
-static void add_AT_int PARAMS ((dw_die_ref,
- enum dwarf_attribute, long));
-static inline long int AT_int PARAMS ((dw_attr_ref));
-static void add_AT_unsigned PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned long));
-static inline unsigned long AT_unsigned PARAMS ((dw_attr_ref));
-static void add_AT_long_long PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned long,
- unsigned long));
-static void add_AT_float PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned, long *));
-static hashval_t debug_str_do_hash PARAMS ((const void *));
-static int debug_str_eq PARAMS ((const void *, const void *));
-static void add_AT_string PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- const char *));
-static inline const char *AT_string PARAMS ((dw_attr_ref));
-static int AT_string_form PARAMS ((dw_attr_ref));
-static void add_AT_die_ref PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- dw_die_ref));
-static inline dw_die_ref AT_ref PARAMS ((dw_attr_ref));
-static inline int AT_ref_external PARAMS ((dw_attr_ref));
-static inline void set_AT_ref_external PARAMS ((dw_attr_ref, int));
-static void add_AT_fde_ref PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned));
-static void add_AT_loc PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- dw_loc_descr_ref));
-static inline dw_loc_descr_ref AT_loc PARAMS ((dw_attr_ref));
-static void add_AT_loc_list PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- dw_loc_list_ref));
-static inline dw_loc_list_ref AT_loc_list PARAMS ((dw_attr_ref));
-static void add_AT_addr PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- rtx));
-static inline rtx AT_addr PARAMS ((dw_attr_ref));
-static void add_AT_lbl_id PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- const char *));
-static void add_AT_lbl_offset PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- const char *));
-static void add_AT_offset PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned long));
-static void add_AT_range_list PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- unsigned long));
-static inline const char *AT_lbl PARAMS ((dw_attr_ref));
-static dw_attr_ref get_AT PARAMS ((dw_die_ref,
- enum dwarf_attribute));
-static const char *get_AT_low_pc PARAMS ((dw_die_ref));
-static const char *get_AT_hi_pc PARAMS ((dw_die_ref));
-static const char *get_AT_string PARAMS ((dw_die_ref,
- enum dwarf_attribute));
-static int get_AT_flag PARAMS ((dw_die_ref,
- enum dwarf_attribute));
-static unsigned get_AT_unsigned PARAMS ((dw_die_ref,
- enum dwarf_attribute));
-static inline dw_die_ref get_AT_ref PARAMS ((dw_die_ref,
- enum dwarf_attribute));
-static bool is_c_family PARAMS ((void));
-static bool is_cxx PARAMS ((void));
-static bool is_java PARAMS ((void));
-static bool is_fortran PARAMS ((void));
-static bool is_ada PARAMS ((void));
-static void remove_AT PARAMS ((dw_die_ref,
- enum dwarf_attribute));
-static inline void free_die PARAMS ((dw_die_ref));
-static void remove_children PARAMS ((dw_die_ref));
-static void add_child_die PARAMS ((dw_die_ref, dw_die_ref));
-static dw_die_ref new_die PARAMS ((enum dwarf_tag, dw_die_ref,
- tree));
-static dw_die_ref lookup_type_die PARAMS ((tree));
-static void equate_type_number_to_die PARAMS ((tree, dw_die_ref));
-static dw_die_ref lookup_decl_die PARAMS ((tree));
-static void equate_decl_number_to_die PARAMS ((tree, dw_die_ref));
-static void print_spaces PARAMS ((FILE *));
-static void print_die PARAMS ((dw_die_ref, FILE *));
-static void print_dwarf_line_table PARAMS ((FILE *));
-static void reverse_die_lists PARAMS ((dw_die_ref));
-static void reverse_all_dies PARAMS ((dw_die_ref));
-static dw_die_ref push_new_compile_unit PARAMS ((dw_die_ref, dw_die_ref));
-static dw_die_ref pop_compile_unit PARAMS ((dw_die_ref));
-static void loc_checksum PARAMS ((dw_loc_descr_ref,
- struct md5_ctx *));
-static void attr_checksum PARAMS ((dw_attr_ref,
- struct md5_ctx *,
- int *));
-static void die_checksum PARAMS ((dw_die_ref,
- struct md5_ctx *,
- int *));
-static int same_loc_p PARAMS ((dw_loc_descr_ref,
- dw_loc_descr_ref, int *));
-static int same_dw_val_p PARAMS ((dw_val_node *, dw_val_node *,
- int *));
-static int same_attr_p PARAMS ((dw_attr_ref, dw_attr_ref, int *));
-static int same_die_p PARAMS ((dw_die_ref, dw_die_ref, int *));
-static int same_die_p_wrap PARAMS ((dw_die_ref, dw_die_ref));
-static void compute_section_prefix PARAMS ((dw_die_ref));
-static int is_type_die PARAMS ((dw_die_ref));
-static int is_comdat_die PARAMS ((dw_die_ref));
-static int is_symbol_die PARAMS ((dw_die_ref));
-static void assign_symbol_names PARAMS ((dw_die_ref));
-static void break_out_includes PARAMS ((dw_die_ref));
-static hashval_t htab_cu_hash PARAMS ((const void *));
-static int htab_cu_eq PARAMS ((const void *, const void *));
-static void htab_cu_del PARAMS ((void *));
-static int check_duplicate_cu PARAMS ((dw_die_ref, htab_t, unsigned *));
-static void record_comdat_symbol_number PARAMS ((dw_die_ref, htab_t, unsigned));
-static void add_sibling_attributes PARAMS ((dw_die_ref));
-static void build_abbrev_table PARAMS ((dw_die_ref));
-static void output_location_lists PARAMS ((dw_die_ref));
-static int constant_size PARAMS ((long unsigned));
-static unsigned long size_of_die PARAMS ((dw_die_ref));
-static void calc_die_sizes PARAMS ((dw_die_ref));
-static void mark_dies PARAMS ((dw_die_ref));
-static void unmark_dies PARAMS ((dw_die_ref));
-static void unmark_all_dies PARAMS ((dw_die_ref));
-static unsigned long size_of_pubnames PARAMS ((void));
-static unsigned long size_of_aranges PARAMS ((void));
-static enum dwarf_form value_format PARAMS ((dw_attr_ref));
-static void output_value_format PARAMS ((dw_attr_ref));
-static void output_abbrev_section PARAMS ((void));
-static void output_die_symbol PARAMS ((dw_die_ref));
-static void output_die PARAMS ((dw_die_ref));
-static void output_compilation_unit_header PARAMS ((void));
-static void output_comp_unit PARAMS ((dw_die_ref, int));
-static const char *dwarf2_name PARAMS ((tree, int));
-static void add_pubname PARAMS ((tree, dw_die_ref));
-static void output_pubnames PARAMS ((void));
-static void add_arange PARAMS ((tree, dw_die_ref));
-static void output_aranges PARAMS ((void));
-static unsigned int add_ranges PARAMS ((tree));
-static void output_ranges PARAMS ((void));
-static void output_line_info PARAMS ((void));
-static void output_file_names PARAMS ((void));
-static dw_die_ref base_type_die PARAMS ((tree));
-static tree root_type PARAMS ((tree));
-static int is_base_type PARAMS ((tree));
-static bool is_ada_subrange_type PARAMS ((tree));
-static dw_die_ref subrange_type_die PARAMS ((tree));
-static dw_die_ref modified_type_die PARAMS ((tree, int, int, dw_die_ref));
-static int type_is_enum PARAMS ((tree));
-static unsigned int reg_number PARAMS ((rtx));
-static dw_loc_descr_ref reg_loc_descriptor PARAMS ((rtx));
-static dw_loc_descr_ref one_reg_loc_descriptor PARAMS ((unsigned int));
-static dw_loc_descr_ref multiple_reg_loc_descriptor PARAMS ((rtx, rtx));
-static dw_loc_descr_ref int_loc_descriptor PARAMS ((HOST_WIDE_INT));
-static dw_loc_descr_ref based_loc_descr PARAMS ((unsigned, long));
-static int is_based_loc PARAMS ((rtx));
-static dw_loc_descr_ref mem_loc_descriptor PARAMS ((rtx, enum machine_mode mode));
-static dw_loc_descr_ref concat_loc_descriptor PARAMS ((rtx, rtx));
-static dw_loc_descr_ref loc_descriptor PARAMS ((rtx));
-static dw_loc_descr_ref loc_descriptor_from_tree PARAMS ((tree, int));
-static HOST_WIDE_INT ceiling PARAMS ((HOST_WIDE_INT, unsigned int));
-static tree field_type PARAMS ((tree));
-static unsigned int simple_type_align_in_bits PARAMS ((tree));
-static unsigned int simple_decl_align_in_bits PARAMS ((tree));
-static unsigned HOST_WIDE_INT simple_type_size_in_bits PARAMS ((tree));
-static HOST_WIDE_INT field_byte_offset PARAMS ((tree));
-static void add_AT_location_description PARAMS ((dw_die_ref,
- enum dwarf_attribute,
- dw_loc_descr_ref));
-static void add_data_member_location_attribute PARAMS ((dw_die_ref, tree));
-static void add_const_value_attribute PARAMS ((dw_die_ref, rtx));
-static rtx rtl_for_decl_location PARAMS ((tree));
-static void add_location_or_const_value_attribute PARAMS ((dw_die_ref, tree));
-static void tree_add_const_value_attribute PARAMS ((dw_die_ref, tree));
-static void add_name_attribute PARAMS ((dw_die_ref, const char *));
-static void add_comp_dir_attribute PARAMS ((dw_die_ref));
-static void add_bound_info PARAMS ((dw_die_ref,
- enum dwarf_attribute, tree));
-static void add_subscript_info PARAMS ((dw_die_ref, tree));
-static void add_byte_size_attribute PARAMS ((dw_die_ref, tree));
-static void add_bit_offset_attribute PARAMS ((dw_die_ref, tree));
-static void add_bit_size_attribute PARAMS ((dw_die_ref, tree));
-static void add_prototyped_attribute PARAMS ((dw_die_ref, tree));
-static void add_abstract_origin_attribute PARAMS ((dw_die_ref, tree));
-static void add_pure_or_virtual_attribute PARAMS ((dw_die_ref, tree));
-static void add_src_coords_attributes PARAMS ((dw_die_ref, tree));
-static void add_name_and_src_coords_attributes PARAMS ((dw_die_ref, tree));
-static void push_decl_scope PARAMS ((tree));
-static void pop_decl_scope PARAMS ((void));
-static dw_die_ref scope_die_for PARAMS ((tree, dw_die_ref));
-static inline int local_scope_p PARAMS ((dw_die_ref));
-static inline int class_scope_p PARAMS ((dw_die_ref));
-static void add_type_attribute PARAMS ((dw_die_ref, tree, int, int,
- dw_die_ref));
-static const char *type_tag PARAMS ((tree));
-static tree member_declared_type PARAMS ((tree));
+static tree decl_ultimate_origin (tree);
+static tree block_ultimate_origin (tree);
+static tree decl_class_context (tree);
+static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
+static inline enum dw_val_class AT_class (dw_attr_ref);
+static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
+static inline unsigned AT_flag (dw_attr_ref);
+static void add_AT_int (dw_die_ref, enum dwarf_attribute, long);
+static inline long int AT_int (dw_attr_ref);
+static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned long);
+static inline unsigned long AT_unsigned (dw_attr_ref);
+static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
+ unsigned long);
+static void add_AT_float (dw_die_ref, enum dwarf_attribute, unsigned, long *);
+static hashval_t debug_str_do_hash (const void *);
+static int debug_str_eq (const void *, const void *);
+static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
+static inline const char *AT_string (dw_attr_ref);
+static int AT_string_form (dw_attr_ref);
+static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
+static inline dw_die_ref AT_ref (dw_attr_ref);
+static inline int AT_ref_external (dw_attr_ref);
+static inline void set_AT_ref_external (dw_attr_ref, int);
+static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
+static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
+static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
+static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
+ dw_loc_list_ref);
+static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
+static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
+static inline rtx AT_addr (dw_attr_ref);
+static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
+static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *);
+static void add_AT_offset (dw_die_ref, enum dwarf_attribute, unsigned long);
+static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
+ unsigned long);
+static inline const char *AT_lbl (dw_attr_ref);
+static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
+static const char *get_AT_low_pc (dw_die_ref);
+static const char *get_AT_hi_pc (dw_die_ref);
+static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
+static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
+static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
+static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
+static bool is_c_family (void);
+static bool is_cxx (void);
+static bool is_java (void);
+static bool is_fortran (void);
+static bool is_ada (void);
+static void remove_AT (dw_die_ref, enum dwarf_attribute);
+static inline void free_die (dw_die_ref);
+static void remove_children (dw_die_ref);
+static void add_child_die (dw_die_ref, dw_die_ref);
+static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
+static dw_die_ref lookup_type_die (tree);
+static void equate_type_number_to_die (tree, dw_die_ref);
+static dw_die_ref lookup_decl_die (tree);
+static void equate_decl_number_to_die (tree, dw_die_ref);
+static void print_spaces (FILE *);
+static void print_die (dw_die_ref, FILE *);
+static void print_dwarf_line_table (FILE *);
+static void reverse_die_lists (dw_die_ref);
+static void reverse_all_dies (dw_die_ref);
+static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
+static dw_die_ref pop_compile_unit (dw_die_ref);
+static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
+static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
+static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
+static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
+static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
+static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
+static int same_die_p (dw_die_ref, dw_die_ref, int *);
+static int same_die_p_wrap (dw_die_ref, dw_die_ref);
+static void compute_section_prefix (dw_die_ref);
+static int is_type_die (dw_die_ref);
+static int is_comdat_die (dw_die_ref);
+static int is_symbol_die (dw_die_ref);
+static void assign_symbol_names (dw_die_ref);
+static void break_out_includes (dw_die_ref);
+static hashval_t htab_cu_hash (const void *);
+static int htab_cu_eq (const void *, const void *);
+static void htab_cu_del (void *);
+static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
+static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
+static void add_sibling_attributes (dw_die_ref);
+static void build_abbrev_table (dw_die_ref);
+static void output_location_lists (dw_die_ref);
+static int constant_size (long unsigned);
+static unsigned long size_of_die (dw_die_ref);
+static void calc_die_sizes (dw_die_ref);
+static void mark_dies (dw_die_ref);
+static void unmark_dies (dw_die_ref);
+static void unmark_all_dies (dw_die_ref);
+static unsigned long size_of_pubnames (void);
+static unsigned long size_of_aranges (void);
+static enum dwarf_form value_format (dw_attr_ref);
+static void output_value_format (dw_attr_ref);
+static void output_abbrev_section (void);
+static void output_die_symbol (dw_die_ref);
+static void output_die (dw_die_ref);
+static void output_compilation_unit_header (void);
+static void output_comp_unit (dw_die_ref, int);
+static const char *dwarf2_name (tree, int);
+static void add_pubname (tree, dw_die_ref);
+static void output_pubnames (void);
+static void add_arange (tree, dw_die_ref);
+static void output_aranges (void);
+static unsigned int add_ranges (tree);
+static void output_ranges (void);
+static void output_line_info (void);
+static void output_file_names (void);
+static dw_die_ref base_type_die (tree);
+static tree root_type (tree);
+static int is_base_type (tree);
+static bool is_ada_subrange_type (tree);
+static dw_die_ref subrange_type_die (tree);
+static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
+static int type_is_enum (tree);
+static unsigned int reg_number (rtx);
+static dw_loc_descr_ref reg_loc_descriptor (rtx);
+static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
+static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
+static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
+static dw_loc_descr_ref based_loc_descr (unsigned, long);
+static int is_based_loc (rtx);
+static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
+static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
+static dw_loc_descr_ref loc_descriptor (rtx);
+static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
+static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
+static tree field_type (tree);
+static unsigned int simple_type_align_in_bits (tree);
+static unsigned int simple_decl_align_in_bits (tree);
+static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
+static HOST_WIDE_INT field_byte_offset (tree);
+static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
+ dw_loc_descr_ref);
+static void add_data_member_location_attribute (dw_die_ref, tree);
+static void add_const_value_attribute (dw_die_ref, rtx);
+static rtx rtl_for_decl_location (tree);
+static void add_location_or_const_value_attribute (dw_die_ref, tree);
+static void tree_add_const_value_attribute (dw_die_ref, tree);
+static void add_name_attribute (dw_die_ref, const char *);
+static void add_comp_dir_attribute (dw_die_ref);
+static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
+static void add_subscript_info (dw_die_ref, tree);
+static void add_byte_size_attribute (dw_die_ref, tree);
+static void add_bit_offset_attribute (dw_die_ref, tree);
+static void add_bit_size_attribute (dw_die_ref, tree);
+static void add_prototyped_attribute (dw_die_ref, tree);
+static void add_abstract_origin_attribute (dw_die_ref, tree);
+static void add_pure_or_virtual_attribute (dw_die_ref, tree);
+static void add_src_coords_attributes (dw_die_ref, tree);
+static void add_name_and_src_coords_attributes (dw_die_ref, tree);
+static void push_decl_scope (tree);
+static void pop_decl_scope (void);
+static dw_die_ref scope_die_for (tree, dw_die_ref);
+static inline int local_scope_p (dw_die_ref);
+static inline int class_scope_p (dw_die_ref);
+static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
+static const char *type_tag (tree);
+static tree member_declared_type (tree);
#if 0
-static const char *decl_start_label PARAMS ((tree));
+static const char *decl_start_label (tree);
#endif
-static void gen_array_type_die PARAMS ((tree, dw_die_ref));
-static void gen_set_type_die PARAMS ((tree, dw_die_ref));
+static void gen_array_type_die (tree, dw_die_ref);
+static void gen_set_type_die (tree, dw_die_ref);
#if 0
-static void gen_entry_point_die PARAMS ((tree, dw_die_ref));
+static void gen_entry_point_die (tree, dw_die_ref);
#endif
-static void gen_inlined_enumeration_type_die PARAMS ((tree, dw_die_ref));
-static void gen_inlined_structure_type_die PARAMS ((tree, dw_die_ref));
-static void gen_inlined_union_type_die PARAMS ((tree, dw_die_ref));
-static void gen_enumeration_type_die PARAMS ((tree, dw_die_ref));
-static dw_die_ref gen_formal_parameter_die PARAMS ((tree, dw_die_ref));
-static void gen_unspecified_parameters_die PARAMS ((tree, dw_die_ref));
-static void gen_formal_types_die PARAMS ((tree, dw_die_ref));
-static void gen_subprogram_die PARAMS ((tree, dw_die_ref));
-static void gen_variable_die PARAMS ((tree, dw_die_ref));
-static void gen_label_die PARAMS ((tree, dw_die_ref));
-static void gen_lexical_block_die PARAMS ((tree, dw_die_ref, int));
-static void gen_inlined_subroutine_die PARAMS ((tree, dw_die_ref, int));
-static void gen_field_die PARAMS ((tree, dw_die_ref));
-static void gen_ptr_to_mbr_type_die PARAMS ((tree, dw_die_ref));
-static dw_die_ref gen_compile_unit_die PARAMS ((const char *));
-static void gen_string_type_die PARAMS ((tree, dw_die_ref));
-static void gen_inheritance_die PARAMS ((tree, tree, dw_die_ref));
-static void gen_member_die PARAMS ((tree, dw_die_ref));
-static void gen_struct_or_union_type_die PARAMS ((tree, dw_die_ref));
-static void gen_subroutine_type_die PARAMS ((tree, dw_die_ref));
-static void gen_typedef_die PARAMS ((tree, dw_die_ref));
-static void gen_type_die PARAMS ((tree, dw_die_ref));
-static void gen_tagged_type_instantiation_die PARAMS ((tree, dw_die_ref));
-static void gen_block_die PARAMS ((tree, dw_die_ref, int));
-static void decls_for_scope PARAMS ((tree, dw_die_ref, int));
-static int is_redundant_typedef PARAMS ((tree));
-static void gen_decl_die PARAMS ((tree, dw_die_ref));
-static unsigned lookup_filename PARAMS ((const char *));
-static void init_file_table PARAMS ((void));
-static void retry_incomplete_types PARAMS ((void));
-static void gen_type_die_for_member PARAMS ((tree, tree, dw_die_ref));
-static void splice_child_die PARAMS ((dw_die_ref, dw_die_ref));
-static int file_info_cmp PARAMS ((const void *, const void *));
-static dw_loc_list_ref new_loc_list PARAMS ((dw_loc_descr_ref,
- const char *, const char *,
- const char *, unsigned));
-static void add_loc_descr_to_loc_list PARAMS ((dw_loc_list_ref *,
- dw_loc_descr_ref,
- const char *, const char *, const char *));
-static void output_loc_list PARAMS ((dw_loc_list_ref));
-static char *gen_internal_sym PARAMS ((const char *));
-
-static void prune_unmark_dies PARAMS ((dw_die_ref));
-static void prune_unused_types_mark PARAMS ((dw_die_ref, int));
-static void prune_unused_types_walk PARAMS ((dw_die_ref));
-static void prune_unused_types_walk_attribs PARAMS ((dw_die_ref));
-static void prune_unused_types_prune PARAMS ((dw_die_ref));
-static void prune_unused_types PARAMS ((void));
-static int maybe_emit_file PARAMS ((int));
+static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
+static void gen_inlined_structure_type_die (tree, dw_die_ref);
+static void gen_inlined_union_type_die (tree, dw_die_ref);
+static void gen_enumeration_type_die (tree, dw_die_ref);
+static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
+static void gen_unspecified_parameters_die (tree, dw_die_ref);
+static void gen_formal_types_die (tree, dw_die_ref);
+static void gen_subprogram_die (tree, dw_die_ref);
+static void gen_variable_die (tree, dw_die_ref);
+static void gen_label_die (tree, dw_die_ref);
+static void gen_lexical_block_die (tree, dw_die_ref, int);
+static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
+static void gen_field_die (tree, dw_die_ref);
+static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
+static dw_die_ref gen_compile_unit_die (const char *);
+static void gen_string_type_die (tree, dw_die_ref);
+static void gen_inheritance_die (tree, tree, dw_die_ref);
+static void gen_member_die (tree, dw_die_ref);
+static void gen_struct_or_union_type_die (tree, dw_die_ref);
+static void gen_subroutine_type_die (tree, dw_die_ref);
+static void gen_typedef_die (tree, dw_die_ref);
+static void gen_type_die (tree, dw_die_ref);
+static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
+static void gen_block_die (tree, dw_die_ref, int);
+static void decls_for_scope (tree, dw_die_ref, int);
+static int is_redundant_typedef (tree);
+static void gen_decl_die (tree, dw_die_ref);
+static unsigned lookup_filename (const char *);
+static void init_file_table (void);
+static void retry_incomplete_types (void);
+static void gen_type_die_for_member (tree, tree, dw_die_ref);
+static void splice_child_die (dw_die_ref, dw_die_ref);
+static int file_info_cmp (const void *, const void *);
+static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
+ const char *, const char *, unsigned);
+static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
+ const char *, const char *,
+ const char *);
+static void output_loc_list (dw_loc_list_ref);
+static char *gen_internal_sym (const char *);
+
+static void prune_unmark_dies (dw_die_ref);
+static void prune_unused_types_mark (dw_die_ref, int);
+static void prune_unused_types_walk (dw_die_ref);
+static void prune_unused_types_walk_attribs (dw_die_ref);
+static void prune_unused_types_prune (dw_die_ref);
+static void prune_unused_types (void);
+static int maybe_emit_file (int);
/* Section names used to hold DWARF debugging information. */
#ifndef DEBUG_INFO_SECTION
/* We allow a language front-end to designate a function that is to be
called to "demangle" any name before it it put into a DIE. */
-static const char *(*demangle_name_func) PARAMS ((const char *));
+static const char *(*demangle_name_func) (const char *);
void
-dwarf2out_set_demangle_name_func (func)
- const char *(*func) PARAMS ((const char *));
+dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
{
demangle_name_func = func;
}
/* Test if rtl node points to a pseudo register. */
static inline int
-is_pseudo_reg (rtl)
- rtx rtl;
+is_pseudo_reg (rtx rtl)
{
return ((GET_CODE (rtl) == REG && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
|| (GET_CODE (rtl) == SUBREG
removed. */
static inline tree
-type_main_variant (type)
- tree type;
+type_main_variant (tree type)
{
type = TYPE_MAIN_VARIANT (type);
/* Return nonzero if the given type node represents a tagged type. */
static inline int
-is_tagged_type (type)
- tree type;
+is_tagged_type (tree type)
{
enum tree_code code = TREE_CODE (type);
/* Convert a DIE tag into its string name. */
static const char *
-dwarf_tag_name (tag)
- unsigned tag;
+dwarf_tag_name (unsigned int tag)
{
switch (tag)
{
/* Convert a DWARF attribute code into its string name. */
static const char *
-dwarf_attr_name (attr)
- unsigned attr;
+dwarf_attr_name (unsigned int attr)
{
switch (attr)
{
/* Convert a DWARF value form code into its string name. */
static const char *
-dwarf_form_name (form)
- unsigned form;
+dwarf_form_name (unsigned int form)
{
switch (form)
{
#if 0
static const char *
-dwarf_type_encoding_name (enc)
- unsigned enc;
+dwarf_type_encoding_name (unsigned enc)
{
switch (enc)
{
given block. */
static tree
-decl_ultimate_origin (decl)
- tree decl;
+decl_ultimate_origin (tree decl)
{
/* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
nodes in the function to point to themselves; ignore that if
given block. */
static tree
-block_ultimate_origin (block)
- tree block;
+block_ultimate_origin (tree block)
{
tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
parameter. */
static tree
-decl_class_context (decl)
- tree decl;
+decl_class_context (tree decl)
{
tree context = NULL_TREE;
addition order, and correct that in reverse_all_dies. */
static inline void
-add_dwarf_attr (die, attr)
- dw_die_ref die;
- dw_attr_ref attr;
+add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
{
if (die != NULL && attr != NULL)
{
}
static inline enum dw_val_class
-AT_class (a)
- dw_attr_ref a;
+AT_class (dw_attr_ref a)
{
return a->dw_attr_val.val_class;
}
/* Add a flag value attribute to a DIE. */
static inline void
-add_AT_flag (die, attr_kind, flag)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned flag;
+add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline unsigned
-AT_flag (a)
- dw_attr_ref a;
+AT_flag (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_flag)
return a->dw_attr_val.v.val_flag;
/* Add a signed integer attribute value to a DIE. */
static inline void
-add_AT_int (die, attr_kind, int_val)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- long int int_val;
+add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, long int int_val)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline long int
-AT_int (a)
- dw_attr_ref a;
+AT_int (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_const)
return a->dw_attr_val.v.val_int;
/* Add an unsigned integer attribute value to a DIE. */
static inline void
-add_AT_unsigned (die, attr_kind, unsigned_val)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned long unsigned_val;
+add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
+ long unsigned int unsigned_val)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline unsigned long
-AT_unsigned (a)
- dw_attr_ref a;
+AT_unsigned (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_unsigned_const)
return a->dw_attr_val.v.val_unsigned;
/* Add an unsigned double integer attribute value to a DIE. */
static inline void
-add_AT_long_long (die, attr_kind, val_hi, val_low)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned long val_hi;
- unsigned long val_low;
+add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
+ long unsigned int val_hi, long unsigned int val_low)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
/* Add a floating point attribute value to a DIE and return it. */
static inline void
-add_AT_float (die, attr_kind, length, array)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned length;
- long *array;
+add_AT_float (dw_die_ref die, enum dwarf_attribute attr_kind,
+ unsigned int length, long int *array)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
/* Hash and equality functions for debug_str_hash. */
static hashval_t
-debug_str_do_hash (x)
- const void * x;
+debug_str_do_hash (const void *x)
{
return htab_hash_string (((const struct indirect_string_node *)x)->str);
}
static int
-debug_str_eq (x1, x2)
- const void * x1;
- const void * x2;
+debug_str_eq (const void *x1, const void *x2)
{
return strcmp ((((const struct indirect_string_node *)x1)->str),
(const char *)x2) == 0;
/* Add a string attribute value to a DIE. */
static inline void
-add_AT_string (die, attr_kind, str)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- const char *str;
+add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
struct indirect_string_node *node;
void **slot;
if (! debug_str_hash)
- debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
+ debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
debug_str_eq, NULL);
slot = htab_find_slot_with_hash (debug_str_hash, str,
}
static inline const char *
-AT_string (a)
- dw_attr_ref a;
+AT_string (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_str)
return a->dw_attr_val.v.val_str->str;
or out-of-line in .debug_str section. */
static int
-AT_string_form (a)
- dw_attr_ref a;
+AT_string_form (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_str)
{
/* Add a DIE reference attribute value to a DIE. */
static inline void
-add_AT_die_ref (die, attr_kind, targ_die)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- dw_die_ref targ_die;
+add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline dw_die_ref
-AT_ref (a)
- dw_attr_ref a;
+AT_ref (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_die_ref)
return a->dw_attr_val.v.val_die_ref.die;
}
static inline int
-AT_ref_external (a)
- dw_attr_ref a;
+AT_ref_external (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_die_ref)
return a->dw_attr_val.v.val_die_ref.external;
}
static inline void
-set_AT_ref_external (a, i)
- dw_attr_ref a;
- int i;
+set_AT_ref_external (dw_attr_ref a, int i)
{
if (a && AT_class (a) == dw_val_class_die_ref)
a->dw_attr_val.v.val_die_ref.external = i;
/* Add an FDE reference attribute value to a DIE. */
static inline void
-add_AT_fde_ref (die, attr_kind, targ_fde)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned targ_fde;
+add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
/* Add a location description attribute value to a DIE. */
static inline void
-add_AT_loc (die, attr_kind, loc)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- dw_loc_descr_ref loc;
+add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline dw_loc_descr_ref
-AT_loc (a)
- dw_attr_ref a;
+AT_loc (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_loc)
return a->dw_attr_val.v.val_loc;
}
static inline void
-add_AT_loc_list (die, attr_kind, loc_list)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- dw_loc_list_ref loc_list;
+add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline dw_loc_list_ref
-AT_loc_list (a)
- dw_attr_ref a;
+AT_loc_list (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_loc_list)
return a->dw_attr_val.v.val_loc_list;
/* Add an address constant attribute value to a DIE. */
static inline void
-add_AT_addr (die, attr_kind, addr)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- rtx addr;
+add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline rtx
-AT_addr (a)
- dw_attr_ref a;
+AT_addr (dw_attr_ref a)
{
if (a && AT_class (a) == dw_val_class_addr)
return a->dw_attr_val.v.val_addr;
/* Add a label identifier attribute value to a DIE. */
static inline void
-add_AT_lbl_id (die, attr_kind, lbl_id)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- const char *lbl_id;
+add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
/* Add a section offset attribute value to a DIE. */
static inline void
-add_AT_lbl_offset (die, attr_kind, label)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- const char *label;
+add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
/* Add an offset attribute value to a DIE. */
static inline void
-add_AT_offset (die, attr_kind, offset)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned long offset;
+add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, long unsigned int offset)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
/* Add an range_list attribute value to a DIE. */
static void
-add_AT_range_list (die, attr_kind, offset)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- unsigned long offset;
+add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
+ long unsigned int offset)
{
dw_attr_ref attr = (dw_attr_ref) ggc_alloc (sizeof (dw_attr_node));
}
static inline const char *
-AT_lbl (a)
- dw_attr_ref a;
+AT_lbl (dw_attr_ref a)
{
if (a && (AT_class (a) == dw_val_class_lbl_id
|| AT_class (a) == dw_val_class_lbl_offset))
/* Get the attribute of type attr_kind. */
static inline dw_attr_ref
-get_AT (die, attr_kind)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
+get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
{
dw_attr_ref a;
dw_die_ref spec = NULL;
cannot be represented as an assembler label identifier. */
static inline const char *
-get_AT_low_pc (die)
- dw_die_ref die;
+get_AT_low_pc (dw_die_ref die)
{
dw_attr_ref a = get_AT (die, DW_AT_low_pc);
cannot be represented as an assembler label identifier. */
static inline const char *
-get_AT_hi_pc (die)
- dw_die_ref die;
+get_AT_hi_pc (dw_die_ref die)
{
dw_attr_ref a = get_AT (die, DW_AT_high_pc);
NULL if it is not present. */
static inline const char *
-get_AT_string (die, attr_kind)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
+get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
{
dw_attr_ref a = get_AT (die, attr_kind);
if it is not present. */
static inline int
-get_AT_flag (die, attr_kind)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
+get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
{
dw_attr_ref a = get_AT (die, attr_kind);
if it is not present. */
static inline unsigned
-get_AT_unsigned (die, attr_kind)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
+get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
{
dw_attr_ref a = get_AT (die, attr_kind);
}
static inline dw_die_ref
-get_AT_ref (die, attr_kind)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
+get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
{
dw_attr_ref a = get_AT (die, attr_kind);
/* Return TRUE if the language is C or C++. */
static inline bool
-is_c_family ()
+is_c_family (void)
{
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
/* Return TRUE if the language is C++. */
static inline bool
-is_cxx ()
+is_cxx (void)
{
return (get_AT_unsigned (comp_unit_die, DW_AT_language)
== DW_LANG_C_plus_plus);
/* Return TRUE if the language is Fortran. */
static inline bool
-is_fortran ()
+is_fortran (void)
{
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
/* Return TRUE if the language is Java. */
static inline bool
-is_java ()
+is_java (void)
{
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
/* Return TRUE if the language is Ada. */
static inline bool
-is_ada ()
+is_ada (void)
{
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
-
+
return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
}
/* Free up the memory used by A. */
-static inline void free_AT PARAMS ((dw_attr_ref));
+static inline void free_AT (dw_attr_ref);
static inline void
-free_AT (a)
- dw_attr_ref a;
+free_AT (dw_attr_ref a)
{
if (AT_class (a) == dw_val_class_str)
if (a->dw_attr_val.v.val_str->refcount)
/* Remove the specified attribute if present. */
static void
-remove_AT (die, attr_kind)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
+remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
{
dw_attr_ref *p;
dw_attr_ref removed = NULL;
/* Free up the memory used by DIE. */
static inline void
-free_die (die)
- dw_die_ref die;
+free_die (dw_die_ref die)
{
remove_children (die);
}
/* Discard the children of this DIE. */
static void
-remove_children (die)
- dw_die_ref die;
+remove_children (dw_die_ref die)
{
dw_die_ref child_die = die->die_child;
addition order, and correct that in reverse_all_dies. */
static inline void
-add_child_die (die, child_die)
- dw_die_ref die;
- dw_die_ref child_die;
+add_child_die (dw_die_ref die, dw_die_ref child_die)
{
if (die != NULL && child_die != NULL)
{
is the specification, to the front of PARENT's list of children. */
static void
-splice_child_die (parent, child)
- dw_die_ref parent, child;
+splice_child_die (dw_die_ref parent, dw_die_ref child)
{
dw_die_ref *p;
/* Return a pointer to a newly created DIE node. */
static inline dw_die_ref
-new_die (tag_value, parent_die, t)
- enum dwarf_tag tag_value;
- dw_die_ref parent_die;
- tree t;
+new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
{
dw_die_ref die = (dw_die_ref) ggc_alloc_cleared (sizeof (die_node));
/* Return the DIE associated with the given type specifier. */
static inline dw_die_ref
-lookup_type_die (type)
- tree type;
+lookup_type_die (tree type)
{
return TYPE_SYMTAB_DIE (type);
}
/* Equate a DIE to a given type specifier. */
static inline void
-equate_type_number_to_die (type, type_die)
- tree type;
- dw_die_ref type_die;
+equate_type_number_to_die (tree type, dw_die_ref type_die)
{
TYPE_SYMTAB_DIE (type) = type_die;
}
/* Return the DIE associated with a given declaration. */
static inline dw_die_ref
-lookup_decl_die (decl)
- tree decl;
+lookup_decl_die (tree decl)
{
unsigned decl_id = DECL_UID (decl);
/* Equate a DIE to a particular declaration. */
static void
-equate_decl_number_to_die (decl, decl_die)
- tree decl;
- dw_die_ref decl_die;
+equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
{
unsigned int decl_id = DECL_UID (decl);
unsigned int num_allocated;
/* Indent the line the number of spaces given by print_indent. */
static inline void
-print_spaces (outfile)
- FILE *outfile;
+print_spaces (FILE *outfile)
{
fprintf (outfile, "%*s", print_indent, "");
}
This routine is a debugging aid only. */
static void
-print_die (die, outfile)
- dw_die_ref die;
- FILE *outfile;
+print_die (dw_die_ref die, FILE *outfile)
{
dw_attr_ref a;
dw_die_ref c;
This routine is a debugging aid only. */
static void
-print_dwarf_line_table (outfile)
- FILE *outfile;
+print_dwarf_line_table (FILE *outfile)
{
unsigned i;
dw_line_info_ref line_info;
/* Print the information collected for a given DIE. */
void
-debug_dwarf_die (die)
- dw_die_ref die;
+debug_dwarf_die (dw_die_ref die)
{
print_die (die, stderr);
}
This routine is a debugging aid only. */
void
-debug_dwarf ()
+debug_dwarf (void)
{
print_indent = 0;
print_die (comp_unit_die, stderr);
they are in order of addition. */
static void
-reverse_die_lists (die)
- dw_die_ref die;
+reverse_die_lists (dw_die_ref die)
{
dw_die_ref c, cp, cn;
dw_attr_ref a, ap, an;
recursively reverse all the dies. This is that routine. */
static void
-reverse_all_dies (die)
- dw_die_ref die;
+reverse_all_dies (dw_die_ref die)
{
dw_die_ref c;
DIE that marks the start of the DIEs for this include file. */
static dw_die_ref
-push_new_compile_unit (old_unit, bincl_die)
- dw_die_ref old_unit, bincl_die;
+push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
{
const char *filename = get_AT_string (bincl_die, DW_AT_name);
dw_die_ref new_unit = gen_compile_unit_die (filename);
/* Close an include-file CU and reopen the enclosing one. */
static dw_die_ref
-pop_compile_unit (old_unit)
- dw_die_ref old_unit;
+pop_compile_unit (dw_die_ref old_unit)
{
dw_die_ref new_unit = old_unit->die_sib;
/* Calculate the checksum of a location expression. */
static inline void
-loc_checksum (loc, ctx)
- dw_loc_descr_ref loc;
- struct md5_ctx *ctx;
+loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
{
CHECKSUM (loc->dw_loc_opc);
CHECKSUM (loc->dw_loc_oprnd1);
/* Calculate the checksum of an attribute. */
static void
-attr_checksum (at, ctx, mark)
- dw_attr_ref at;
- struct md5_ctx *ctx;
- int *mark;
+attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
{
dw_loc_descr_ref loc;
rtx r;
/* Calculate the checksum of a DIE. */
static void
-die_checksum (die, ctx, mark)
- dw_die_ref die;
- struct md5_ctx *ctx;
- int *mark;
+die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
{
dw_die_ref c;
dw_attr_ref a;
/* Do the location expressions look same? */
static inline int
-same_loc_p (loc1, loc2, mark)
- dw_loc_descr_ref loc1;
- dw_loc_descr_ref loc2;
- int *mark;
+same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
{
return loc1->dw_loc_opc == loc2->dw_loc_opc
&& same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
/* Do the values look the same? */
static int
-same_dw_val_p (v1, v2, mark)
- dw_val_node *v1;
- dw_val_node *v2;
- int *mark;
+same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
{
dw_loc_descr_ref loc1, loc2;
rtx r1, r2;
/* Do the attributes look the same? */
static int
-same_attr_p (at1, at2, mark)
- dw_attr_ref at1;
- dw_attr_ref at2;
- int *mark;
+same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
{
if (at1->dw_attr != at2->dw_attr)
return 0;
/* Do the dies look the same? */
static int
-same_die_p (die1, die2, mark)
- dw_die_ref die1;
- dw_die_ref die2;
- int *mark;
+same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
{
dw_die_ref c1, c2;
dw_attr_ref a1, a2;
/* Do the dies look the same? Wrapper around same_die_p. */
static int
-same_die_p_wrap (die1, die2)
- dw_die_ref die1;
- dw_die_ref die2;
+same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
{
int mark = 0;
int ret = same_die_p (die1, die2, &mark);
children, and set comdat_symbol_id accordingly. */
static void
-compute_section_prefix (unit_die)
- dw_die_ref unit_die;
+compute_section_prefix (dw_die_ref unit_die)
{
const char *die_name = get_AT_string (unit_die, DW_AT_name);
const char *base = die_name ? lbasename (die_name) : "anonymous";
/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
static int
-is_type_die (die)
- dw_die_ref die;
+is_type_die (dw_die_ref die)
{
switch (die->die_tag)
{
compilations (functions). */
static int
-is_comdat_die (c)
- dw_die_ref c;
+is_comdat_die (dw_die_ref c)
{
/* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
we do for stabs. The advantage is a greater likelihood of sharing between
compilation unit. */
static int
-is_symbol_die (c)
- dw_die_ref c;
+is_symbol_die (dw_die_ref c)
{
return (is_type_die (c)
|| (get_AT (c, DW_AT_declaration)
}
static char *
-gen_internal_sym (prefix)
- const char *prefix;
+gen_internal_sym (const char *prefix)
{
char buf[256];
/* Assign symbols to all worthy DIEs under DIE. */
static void
-assign_symbol_names (die)
- dw_die_ref die;
+assign_symbol_names (dw_die_ref die)
{
dw_die_ref c;
/* Routines to manipulate hash table of CUs. */
static hashval_t
-htab_cu_hash (of)
- const void *of;
+htab_cu_hash (const void *of)
{
const struct cu_hash_table_entry *entry = of;
}
static int
-htab_cu_eq (of1, of2)
- const void *of1;
- const void *of2;
+htab_cu_eq (const void *of1, const void *of2)
{
const struct cu_hash_table_entry *entry1 = of1;
const struct die_struct *entry2 = of2;
}
static void
-htab_cu_del (what)
- void *what;
+htab_cu_del (void *what)
{
struct cu_hash_table_entry *next, *entry = what;
/* Check whether we have already seen this CU and set up SYM_NUM
accordingly. */
static int
-check_duplicate_cu (cu, htable, sym_num)
- dw_die_ref cu;
- htab_t htable;
- unsigned *sym_num;
+check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
{
struct cu_hash_table_entry dummy;
struct cu_hash_table_entry **slot, *entry, *last = &dummy;
/* Record SYM_NUM to record of CU in HTABLE. */
static void
-record_comdat_symbol_number (cu, htable, sym_num)
- dw_die_ref cu;
- htab_t htable;
- unsigned sym_num;
+record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
{
struct cu_hash_table_entry **slot, *entry;
bracketed by BINCL/EINCL. */
static void
-break_out_includes (die)
- dw_die_ref die;
+break_out_includes (dw_die_ref die)
{
dw_die_ref *ptr;
dw_die_ref unit = NULL;
avoid generating sibling attributes for DIE's without children. */
static void
-add_sibling_attributes (die)
- dw_die_ref die;
+add_sibling_attributes (dw_die_ref die)
{
dw_die_ref c;
/* Output all location lists for the DIE and its children. */
static void
-output_location_lists (die)
- dw_die_ref die;
+output_location_lists (dw_die_ref die)
{
dw_die_ref c;
dw_attr_ref d_attr;
die are visited recursively. */
static void
-build_abbrev_table (die)
- dw_die_ref die;
+build_abbrev_table (dw_die_ref die)
{
unsigned long abbrev_id;
unsigned int n_alloc;
/* Return the power-of-two number of bytes necessary to represent VALUE. */
static int
-constant_size (value)
- long unsigned value;
+constant_size (long unsigned int value)
{
int log;
.debug_info section. */
static unsigned long
-size_of_die (die)
- dw_die_ref die;
+size_of_die (dw_die_ref die)
{
unsigned long size = 0;
dw_attr_ref a;
die_offset field in each DIE. */
static void
-calc_die_sizes (die)
- dw_die_ref die;
+calc_die_sizes (dw_die_ref die)
{
dw_die_ref c;
and use that as the flag, but ran into ordering problems. */
static void
-mark_dies (die)
- dw_die_ref die;
+mark_dies (dw_die_ref die)
{
dw_die_ref c;
if (die->die_mark)
abort ();
-
+
die->die_mark = 1;
for (c = die->die_child; c; c = c->die_sib)
mark_dies (c);
/* Clear the marks for a die and its children. */
static void
-unmark_dies (die)
- dw_die_ref die;
+unmark_dies (dw_die_ref die)
{
dw_die_ref c;
if (!die->die_mark)
abort ();
-
+
die->die_mark = 0;
for (c = die->die_child; c; c = c->die_sib)
unmark_dies (c);
/* Clear the marks for a die, its children and referred dies. */
static void
-unmark_all_dies (die)
- dw_die_ref die;
+unmark_all_dies (dw_die_ref die)
{
dw_die_ref c;
dw_attr_ref a;
compilation unit. */
static unsigned long
-size_of_pubnames ()
+size_of_pubnames (void)
{
unsigned long size;
unsigned i;
/* Return the size of the information in the .debug_aranges section. */
static unsigned long
-size_of_aranges ()
+size_of_aranges (void)
{
unsigned long size;
/* Select the encoding of an attribute value. */
static enum dwarf_form
-value_format (a)
- dw_attr_ref a;
+value_format (dw_attr_ref a)
{
switch (a->dw_attr_val.val_class)
{
/* Output the encoding of an attribute value. */
static void
-output_value_format (a)
- dw_attr_ref a;
+output_value_format (dw_attr_ref a)
{
enum dwarf_form form = value_format (a);
table. */
static void
-output_abbrev_section ()
+output_abbrev_section (void)
{
unsigned long abbrev_id;
/* Output a symbol we can use to refer to this DIE from another CU. */
static inline void
-output_die_symbol (die)
- dw_die_ref die;
+output_die_symbol (dw_die_ref die)
{
char *sym = die->die_symbol;
this location list node, which is done for the head of the list only. */
static inline dw_loc_list_ref
-new_loc_list (expr, begin, end, section, gensym)
- dw_loc_descr_ref expr;
- const char *begin;
- const char *end;
- const char *section;
- unsigned gensym;
+new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
+ const char *section, unsigned int gensym)
{
dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
/* Add a location description expression to a location list. */
static inline void
-add_loc_descr_to_loc_list (list_head, descr, begin, end, section)
- dw_loc_list_ref *list_head;
- dw_loc_descr_ref descr;
- const char *begin;
- const char *end;
- const char *section;
+add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
+ const char *begin, const char *end,
+ const char *section)
{
dw_loc_list_ref *d;
/* Output the location list given to us. */
static void
-output_loc_list (list_head)
- dw_loc_list_ref list_head;
+output_loc_list (dw_loc_list_ref list_head)
{
dw_loc_list_ref curr = list_head;
the definitions of each child DIE. */
static void
-output_die (die)
- dw_die_ref die;
+output_die (dw_die_ref die)
{
dw_attr_ref a;
dw_die_ref c;
.debug_info section, and precedes the DIE descriptions. */
static void
-output_compilation_unit_header ()
+output_compilation_unit_header (void)
{
if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
dw2_asm_output_data (4, 0xffffffff,
/* Output the compilation unit DIE and its children. */
static void
-output_comp_unit (die, output_if_empty)
- dw_die_ref die;
- int output_if_empty;
+output_comp_unit (dw_die_ref die, int output_if_empty)
{
const char *secname;
char *oldsym, *tmp;
"A::f(int)". Let's drop the argument list, and maybe the scope. */
static const char *
-dwarf2_name (decl, scope)
- tree decl;
- int scope;
+dwarf2_name (tree decl, int scope)
{
return (*lang_hooks.decl_printable_name) (decl, scope ? 1 : 0);
}
/* Add a new entry to .debug_pubnames if appropriate. */
static void
-add_pubname (decl, die)
- tree decl;
- dw_die_ref die;
+add_pubname (tree decl, dw_die_ref die)
{
pubname_ref p;
visible procedures. */
static void
-output_pubnames ()
+output_pubnames (void)
{
unsigned i;
unsigned long pubnames_length = size_of_pubnames ();
/* Add a new entry to .debug_aranges if appropriate. */
static void
-add_arange (decl, die)
- tree decl;
- dw_die_ref die;
+add_arange (tree decl, dw_die_ref die)
{
if (! DECL_SECTION_NAME (decl))
return;
if (arange_table_in_use == arange_table_allocated)
{
arange_table_allocated += ARANGE_TABLE_INCREMENT;
- arange_table = ggc_realloc (arange_table,
- (arange_table_allocated
+ arange_table = ggc_realloc (arange_table,
+ (arange_table_allocated
* sizeof (dw_die_ref)));
memset (arange_table + arange_table_in_use, 0,
ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
text section generated for this compilation unit. */
static void
-output_aranges ()
+output_aranges (void)
{
unsigned i;
unsigned long aranges_length = size_of_aranges ();
was placed. */
static unsigned int
-add_ranges (block)
- tree block;
+add_ranges (tree block)
{
unsigned int in_use = ranges_table_in_use;
}
static void
-output_ranges ()
+output_ranges (void)
{
unsigned i;
static const char *const start_fmt = "Offset 0x%x";
the directories in the path. */
static int
-file_info_cmp (p1, p2)
- const void *p1;
- const void *p2;
+file_info_cmp (const void *p1, const void *p2)
{
const struct file_info *s1 = p1;
const struct file_info *s2 = p2;
slowdowns with many input files. */
static void
-output_file_names ()
+output_file_names (void)
{
struct file_info *files;
struct dir_info *dirs;
information goes into the .debug_line section. */
static void
-output_line_info ()
+output_line_info (void)
{
char l1[20], l2[20], p1[20], p2[20];
char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
Dwarf base (fundamental) types. */
static dw_die_ref
-base_type_die (type)
- tree type;
+base_type_die (tree type)
{
dw_die_ref base_type_result;
const char *type_name;
root type of the given type without the qualifiers. */
static tree
-root_type (type)
- tree type;
+root_type (tree type)
{
if (TREE_CODE (type) == ERROR_MARK)
return error_mark_node;
given input type is a Dwarf "fundamental" type. Otherwise return null. */
static inline int
-is_base_type (type)
- tree type;
+is_base_type (tree type)
{
switch (TREE_CODE (type))
{
ERROR_MARK node. */
static inline unsigned HOST_WIDE_INT
-simple_type_size_in_bits (type)
- tree type;
+simple_type_size_in_bits (tree type)
{
if (TREE_CODE (type) == ERROR_MARK)
return BITS_PER_WORD;
emitted as a subrange type. */
static inline bool
-is_ada_subrange_type (type)
- tree type;
+is_ada_subrange_type (tree type)
{
/* We do this for INTEGER_TYPEs that have names, parent types, and when
we are compiling Ada code. */
to a DIE that describes the given type. */
static dw_die_ref
-subrange_type_die (type)
- tree type;
+subrange_type_die (tree type)
{
dw_die_ref subtype_die;
dw_die_ref subrange_die;
tree name = TYPE_NAME (type);
-
+
subtype_die = base_type_die (TREE_TYPE (type));
if (TREE_CODE (name) == TYPE_DECL)
entry that chains various modifiers in front of the given type. */
static dw_die_ref
-modified_type_die (type, is_const_type, is_volatile_type, context_die)
- tree type;
- int is_const_type;
- int is_volatile_type;
- dw_die_ref context_die;
+modified_type_die (tree type, int is_const_type, int is_volatile_type,
+ dw_die_ref context_die)
{
enum tree_code code = TREE_CODE (type);
dw_die_ref mod_type_die = NULL;
an enumerated type. */
static inline int
-type_is_enum (type)
- tree type;
+type_is_enum (tree type)
{
return TREE_CODE (type) == ENUMERAL_TYPE;
}
/* Return the register number described by a given RTL node. */
static unsigned int
-reg_number (rtl)
- rtx rtl;
+reg_number (rtx rtl)
{
unsigned regno = REGNO (rtl);
zero if there is none. */
static dw_loc_descr_ref
-reg_loc_descriptor (rtl)
- rtx rtl;
+reg_loc_descriptor (rtx rtl)
{
unsigned reg;
rtx regs;
a given hard register number. */
static dw_loc_descr_ref
-one_reg_loc_descriptor (regno)
- unsigned int regno;
+one_reg_loc_descriptor (unsigned int regno)
{
if (regno <= 31)
return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
designates a value that spans more than one register. */
static dw_loc_descr_ref
-multiple_reg_loc_descriptor (rtl, regs)
- rtx rtl, regs;
+multiple_reg_loc_descriptor (rtx rtl, rtx regs)
{
int nregs, size, i;
unsigned reg;
/* Return a location descriptor that designates a constant. */
static dw_loc_descr_ref
-int_loc_descriptor (i)
- HOST_WIDE_INT i;
+int_loc_descriptor (HOST_WIDE_INT i)
{
enum dwarf_location_atom op;
/* Return a location descriptor that designates a base+offset location. */
static dw_loc_descr_ref
-based_loc_descr (reg, offset)
- unsigned reg;
- long int offset;
+based_loc_descr (unsigned int reg, long int offset)
{
dw_loc_descr_ref loc_result;
/* For the "frame base", we use the frame pointer or stack pointer
/* Return true if this RTL expression describes a base+offset calculation. */
static inline int
-is_based_loc (rtl)
- rtx rtl;
+is_based_loc (rtx rtl)
{
return (GET_CODE (rtl) == PLUS
&& ((GET_CODE (XEXP (rtl, 0)) == REG
Return 0 if we can't represent the location. */
static dw_loc_descr_ref
-mem_loc_descriptor (rtl, mode)
- rtx rtl;
- enum machine_mode mode;
+mem_loc_descriptor (rtx rtl, enum machine_mode mode)
{
dw_loc_descr_ref mem_loc_result = NULL;
case LABEL_REF:
/* Some ports can transform a symbol ref into a label ref, because
- the symbol ref is too far away and has to be dumped into a constant
- pool. */
+ the symbol ref is too far away and has to be dumped into a constant
+ pool. */
case CONST:
case SYMBOL_REF:
/* Alternatively, the symbol in the constant pool might be referenced
This is typically a complex variable. */
static dw_loc_descr_ref
-concat_loc_descriptor (x0, x1)
- rtx x0, x1;
+concat_loc_descriptor (rtx x0, rtx x1)
{
dw_loc_descr_ref cc_loc_result = NULL;
dw_loc_descr_ref x0_ref = loc_descriptor (x0);
If we don't know how to describe it, return 0. */
static dw_loc_descr_ref
-loc_descriptor (rtl)
- rtx rtl;
+loc_descriptor (rtx rtl)
{
dw_loc_descr_ref loc_result = NULL;
descriptor, return 0. */
static dw_loc_descr_ref
-loc_descriptor_from_tree (loc, addressp)
- tree loc;
- int addressp;
+loc_descriptor_from_tree (tree loc, int addressp)
{
dw_loc_descr_ref ret, ret1;
int indirect_p = 0;
which is not less than the value itself. */
static inline HOST_WIDE_INT
-ceiling (value, boundary)
- HOST_WIDE_INT value;
- unsigned int boundary;
+ceiling (HOST_WIDE_INT value, unsigned int boundary)
{
return (((value + boundary - 1) / boundary) * boundary);
}
ERROR_MARK node. */
static inline tree
-field_type (decl)
- tree decl;
+field_type (tree decl)
{
tree type;
be an ERROR_MARK node. */
static inline unsigned
-simple_type_align_in_bits (type)
- tree type;
+simple_type_align_in_bits (tree type)
{
return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
}
static inline unsigned
-simple_decl_align_in_bits (decl)
- tree decl;
+simple_decl_align_in_bits (tree decl)
{
return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
}
just yet). */
static HOST_WIDE_INT
-field_byte_offset (decl)
- tree decl;
+field_byte_offset (tree decl)
{
unsigned int type_align_in_bits;
unsigned int decl_align_in_bits;
generated by the routine `data_member_location_attribute' below. */
static inline void
-add_AT_location_description (die, attr_kind, descr)
- dw_die_ref die;
- enum dwarf_attribute attr_kind;
- dw_loc_descr_ref descr;
+add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
+ dw_loc_descr_ref descr)
{
if (descr != 0)
add_AT_loc (die, attr_kind, descr);
function below.) */
static void
-add_data_member_location_attribute (die, decl)
- dw_die_ref die;
- tree decl;
+add_data_member_location_attribute (dw_die_ref die, tree decl)
{
long offset;
dw_loc_descr_ref loc_descr = 0;
constants do not necessarily get memory "homes". */
static void
-add_const_value_attribute (die, rtl)
- dw_die_ref die;
- rtx rtl;
+add_const_value_attribute (dw_die_ref die, rtx rtl)
{
switch (GET_CODE (rtl))
{
}
static rtx
-rtl_for_decl_location (decl)
- tree decl;
+rtl_for_decl_location (tree decl)
{
rtx rtl;
function call evaluates to a compile-time constant address. */
static void
-add_location_or_const_value_attribute (die, decl)
- dw_die_ref die;
- tree decl;
+add_location_or_const_value_attribute (dw_die_ref die, tree decl)
{
rtx rtl;
dw_loc_descr_ref descr;
}
add_AT_location_description (die, DW_AT_location, descr);
break;
-
+
default:
abort ();
}
we should tell the debugger about the constant value. */
static void
-tree_add_const_value_attribute (var_die, decl)
- dw_die_ref var_die;
- tree decl;
+tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
{
tree init = DECL_INITIAL (decl);
tree type = TREE_TYPE (decl);
the value of the attribute. */
static void
-add_name_attribute (die, name_string)
- dw_die_ref die;
- const char *name_string;
+add_name_attribute (dw_die_ref die, const char *name_string)
{
if (name_string != NULL && *name_string != 0)
{
/* Generate a DW_AT_comp_dir attribute for DIE. */
static void
-add_comp_dir_attribute (die)
- dw_die_ref die;
+add_comp_dir_attribute (dw_die_ref die)
{
const char *wd = getpwd ();
if (wd != NULL)
a representation for that bound. */
static void
-add_bound_info (subrange_die, bound_attr, bound)
- dw_die_ref subrange_die;
- enum dwarf_attribute bound_attr;
- tree bound;
+add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
{
switch (TREE_CODE (bound))
{
includes information about the element type of type given array type. */
static void
-add_subscript_info (type_die, type)
- dw_die_ref type_die;
- tree type;
+add_subscript_info (dw_die_ref type_die, tree type)
{
#ifndef MIPS_DEBUGGING_INFO
unsigned dimension_number;
/* ??? If upper is NULL, the array has unspecified length,
but it does have a lower bound. This happens with Fortran
dimension arr(N:*)
- Since the debugger is definitely going to need to know N
+ Since the debugger is definitely going to need to know N
to produce useful results, go ahead and output the lower
bound solo, and hope the debugger can cope. */
}
static void
-add_byte_size_attribute (die, tree_node)
- dw_die_ref die;
- tree tree_node;
+add_byte_size_attribute (dw_die_ref die, tree tree_node)
{
unsigned size;
(See `byte_size_attribute' above). */
static inline void
-add_bit_offset_attribute (die, decl)
- dw_die_ref die;
- tree decl;
+add_bit_offset_attribute (dw_die_ref die, tree decl)
{
HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
tree type = DECL_BIT_FIELD_TYPE (decl);
which specifies the length in bits of the given field. */
static inline void
-add_bit_size_attribute (die, decl)
- dw_die_ref die;
- tree decl;
+add_bit_size_attribute (dw_die_ref die, tree decl)
{
/* Must be a field and a bit field. */
if (TREE_CODE (decl) != FIELD_DECL
attribute, if arg types are given for the parameters of a function. */
static inline void
-add_prototyped_attribute (die, func_type)
- dw_die_ref die;
- tree func_type;
+add_prototyped_attribute (dw_die_ref die, tree func_type)
{
if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
&& TYPE_ARG_TYPES (func_type) != NULL)
equate table. */
static inline void
-add_abstract_origin_attribute (die, origin)
- dw_die_ref die;
- tree origin;
+add_abstract_origin_attribute (dw_die_ref die, tree origin)
{
dw_die_ref origin_die = NULL;
/* We do not currently support the pure_virtual attribute. */
static inline void
-add_pure_or_virtual_attribute (die, func_decl)
- dw_die_ref die;
- tree func_decl;
+add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
{
if (DECL_VINDEX (func_decl))
{
/* Add source coordinate attributes for the given decl. */
static void
-add_src_coords_attributes (die, decl)
- dw_die_ref die;
- tree decl;
+add_src_coords_attributes (dw_die_ref die, tree decl)
{
unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
given decl, but only if it actually has a name. */
static void
-add_name_and_src_coords_attributes (die, decl)
- dw_die_ref die;
- tree decl;
+add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
{
tree decl_name;
/* Push a new declaration scope. */
static void
-push_decl_scope (scope)
- tree scope;
+push_decl_scope (tree scope)
{
VARRAY_PUSH_TREE (decl_scope_table, scope);
}
/* Pop a declaration scope. */
static inline void
-pop_decl_scope ()
+pop_decl_scope (void)
{
if (VARRAY_ACTIVE_SIZE (decl_scope_table) <= 0)
abort ();
the current active scope. */
static dw_die_ref
-scope_die_for (t, context_die)
- tree t;
- dw_die_ref context_die;
+scope_die_for (tree t, dw_die_ref context_die)
{
dw_die_ref scope_die = NULL;
tree containing_scope;
/* Returns nonzero if CONTEXT_DIE is internal to a function. */
static inline int
-local_scope_p (context_die)
- dw_die_ref context_die;
+local_scope_p (dw_die_ref context_die)
{
for (; context_die; context_die = context_die->die_parent)
if (context_die->die_tag == DW_TAG_inlined_subroutine
/* Returns nonzero if CONTEXT_DIE is a class. */
static inline int
-class_scope_p (context_die)
- dw_die_ref context_die;
+class_scope_p (dw_die_ref context_die)
{
return (context_die
&& (context_die->die_tag == DW_TAG_structure_type
by 'type', and adds a DW_AT_type attribute below the given die. */
static void
-add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
- dw_die_ref object_die;
- tree type;
- int decl_const;
- int decl_volatile;
- dw_die_ref context_die;
+add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
+ int decl_volatile, dw_die_ref context_die)
{
enum tree_code code = TREE_CODE (type);
dw_die_ref type_die = NULL;
was declared without a tag. */
static const char *
-type_tag (type)
- tree type;
+type_tag (tree type)
{
const char *name = 0;
for bit field types. */
static inline tree
-member_declared_type (member)
- tree member;
+member_declared_type (tree member)
{
return (DECL_BIT_FIELD_TYPE (member)
? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
#if 0
static const char *
-decl_start_label (decl)
- tree decl;
+decl_start_label (tree decl)
{
rtx x;
const char *fnname;
the declaration trees passed in from dwarf2out_decl(). */
static void
-gen_array_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_array_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref scope_die = scope_die_for (type, context_die);
dw_die_ref array_die;
}
static void
-gen_set_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_set_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die
= new_die (DW_TAG_set_type, scope_die_for (type, context_die), type);
#if 0
static void
-gen_entry_point_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_entry_point_die (tree decl, dw_die_ref context_die)
{
tree origin = decl_ultimate_origin (decl);
dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
emit full debugging info for them. */
static void
-retry_incomplete_types ()
+retry_incomplete_types (void)
{
int i;
/* Generate a DIE to represent an inlined instance of an enumeration type. */
static void
-gen_inlined_enumeration_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
/* Generate a DIE to represent an inlined instance of a structure type. */
static void
-gen_inlined_structure_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
/* Generate a DIE to represent an inlined instance of a union type. */
static void
-gen_inlined_union_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_inlined_union_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
DIE. */
static void
-gen_enumeration_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_enumeration_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die = lookup_type_die (type);
argument type of some subprogram type. */
static dw_die_ref
-gen_formal_parameter_die (node, context_die)
- tree node;
- dw_die_ref context_die;
+gen_formal_parameter_die (tree node, dw_die_ref context_die)
{
dw_die_ref parm_die
= new_die (DW_TAG_formal_parameter, context_die, node);
at the end of an (ANSI prototyped) formal parameters list. */
static void
-gen_unspecified_parameters_die (decl_or_type, context_die)
- tree decl_or_type;
- dw_die_ref context_die;
+gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
{
new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
}
those which appear as part of a function *definition*). */
static void
-gen_formal_types_die (function_or_method_type, context_die)
- tree function_or_method_type;
- dw_die_ref context_die;
+gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
{
tree link;
tree formal_type = NULL;
trick; we need to attach the member declaration by hand. */
static void
-gen_type_die_for_member (type, member, context_die)
- tree type, member;
- dw_die_ref context_die;
+gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
{
gen_type_die (type, context_die);
may later generate inlined and/or out-of-line instances of. */
static void
-dwarf2out_abstract_function (decl)
- tree decl;
+dwarf2out_abstract_function (tree decl)
{
dw_die_ref old_die;
tree save_fn;
block-local). */
static void
-gen_subprogram_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_subprogram_die (tree decl, dw_die_ref context_die)
{
char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
tree origin = decl_ultimate_origin (decl);
/* Generate a DIE to represent a declared data object. */
static void
-gen_variable_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_variable_die (tree decl, dw_die_ref context_die)
{
tree origin = decl_ultimate_origin (decl);
dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
/* Generate a DIE to represent a label identifier. */
static void
-gen_label_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_label_die (tree decl, dw_die_ref context_die)
{
tree origin = decl_ultimate_origin (decl);
dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
/* Generate a DIE for a lexical block. */
static void
-gen_lexical_block_die (stmt, context_die, depth)
- tree stmt;
- dw_die_ref context_die;
- int depth;
+gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
{
dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
char label[MAX_ARTIFICIAL_LABEL_BYTES];
/* Generate a DIE for an inlined subprogram. */
static void
-gen_inlined_subroutine_die (stmt, context_die, depth)
- tree stmt;
- dw_die_ref context_die;
- int depth;
+gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
{
if (! BLOCK_ABSTRACT (stmt))
{
/* Generate a DIE for a field in a record, or structure. */
static void
-gen_field_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_field_die (tree decl, dw_die_ref context_die)
{
dw_die_ref decl_die;
if (TREE_TYPE (decl) == error_mark_node)
return;
-
+
decl_die = new_die (DW_TAG_member, context_die, decl);
add_name_and_src_coords_attributes (decl_die, decl);
add_type_attribute (decl_die, member_declared_type (decl),
represent certain things in other languages (e.g. Pascal) someday. */
static void
-gen_pointer_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_pointer_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref ptr_die
= new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
represent certain things in other languages (e.g. Pascal) someday. */
static void
-gen_reference_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_reference_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref ref_die
= new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
/* Generate a DIE for a pointer to a member type. */
static void
-gen_ptr_to_mbr_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type,
/* Generate the DIE for the compilation unit. */
static dw_die_ref
-gen_compile_unit_die (filename)
- const char *filename;
+gen_compile_unit_die (const char *filename)
{
dw_die_ref die;
char producer[250];
/* Generate a DIE for a string type. */
static void
-gen_string_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_string_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die
= new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
/* Generate the DIE for a base class. */
static void
-gen_inheritance_die (binfo, access, context_die)
- tree binfo, access;
- dw_die_ref context_die;
+gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
{
dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
/* Generate a DIE for a class member. */
static void
-gen_member_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_member_die (tree type, dw_die_ref context_die)
{
tree member;
tree binfo = TYPE_BINFO (type);
member DIEs needed by later specification DIEs. */
static void
-gen_struct_or_union_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
{
dw_die_ref type_die = lookup_type_die (type);
dw_die_ref scope_die = 0;
/* Generate a DIE for a subroutine _type_. */
static void
-gen_subroutine_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_subroutine_type_die (tree type, dw_die_ref context_die)
{
tree return_type = TREE_TYPE (type);
dw_die_ref subr_die
/* Generate a DIE for a type definition. */
static void
-gen_typedef_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_typedef_die (tree decl, dw_die_ref context_die)
{
dw_die_ref type_die;
tree origin;
/* Generate a type description DIE. */
static void
-gen_type_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_type_die (tree type, dw_die_ref context_die)
{
int need_pop;
/* Generate a DIE for a tagged type instantiation. */
static void
-gen_tagged_type_instantiation_die (type, context_die)
- tree type;
- dw_die_ref context_die;
+gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
{
if (type == NULL_TREE || type == error_mark_node)
return;
things which are local to the given block. */
static void
-gen_block_die (stmt, context_die, depth)
- tree stmt;
- dw_die_ref context_die;
- int depth;
+gen_block_die (tree stmt, dw_die_ref context_die, int depth)
{
int must_output_die = 0;
tree origin;
all of its sub-blocks. */
static void
-decls_for_scope (stmt, context_die, depth)
- tree stmt;
- dw_die_ref context_die;
- int depth;
+decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
{
tree decl;
tree subblocks;
/* Is this a typedef we can avoid emitting? */
static inline int
-is_redundant_typedef (decl)
- tree decl;
+is_redundant_typedef (tree decl)
{
if (TYPE_DECL_IS_STUB (decl))
return 1;
/* Generate Dwarf debug information for a decl described by DECL. */
static void
-gen_decl_die (decl, context_die)
- tree decl;
- dw_die_ref context_die;
+gen_decl_die (tree decl, dw_die_ref context_die)
{
tree origin;
/* Add Ada "use" clause information for SGI Workshop debugger. */
void
-dwarf2out_add_library_unit_info (filename, context_list)
- const char *filename;
- const char *context_list;
+dwarf2out_add_library_unit_info (const char *filename, const char *context_list)
{
unsigned int file_index;
compilation proper has finished. */
static void
-dwarf2out_global_decl (decl)
- tree decl;
+dwarf2out_global_decl (tree decl)
{
/* Output DWARF2 information for file-scope tentative data object
declarations, file-scope (extern) function declarations (which had no
/* Write the debugging output for DECL. */
void
-dwarf2out_decl (decl)
- tree decl;
+dwarf2out_decl (tree decl)
{
dw_die_ref context_die = comp_unit_die;
a lexical block. */
static void
-dwarf2out_begin_block (line, blocknum)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int blocknum;
+dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
+ unsigned int blocknum)
{
function_section (current_function_decl);
ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
lexical block. */
static void
-dwarf2out_end_block (line, blocknum)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int blocknum;
+dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
{
function_section (current_function_decl);
ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
we may end up calling them anyway. */
static bool
-dwarf2out_ignore_block (block)
- tree block;
+dwarf2out_ignore_block (tree block)
{
tree decl;
all searches. */
static unsigned
-lookup_filename (file_name)
- const char *file_name;
+lookup_filename (const char *file_name)
{
size_t i, n;
char *save_file_name;
}
static int
-maybe_emit_file (fileno)
- int fileno;
+maybe_emit_file (int fileno)
{
if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
{
}
static void
-init_file_table ()
+init_file_table (void)
{
/* Allocate the initial hunk of the file_table. */
VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
'line_info_table' for later output of the .debug_line section. */
static void
-dwarf2out_source_line (line, filename)
- unsigned int line;
- const char *filename;
+dwarf2out_source_line (unsigned int line, const char *filename)
{
if (debug_info_level >= DINFO_LEVEL_NORMAL
&& line != 0)
ggc_realloc (separate_line_info_table,
separate_line_info_table_allocated
* sizeof (dw_separate_line_info_entry));
- memset ((separate_line_info_table
- + separate_line_info_table_in_use),
+ memset ((separate_line_info_table
+ + separate_line_info_table_in_use),
0,
- (LINE_INFO_TABLE_INCREMENT
+ (LINE_INFO_TABLE_INCREMENT
* sizeof (dw_separate_line_info_entry)));
}
/* Record the beginning of a new source file. */
static void
-dwarf2out_start_source_file (lineno, filename)
- unsigned int lineno;
- const char *filename;
+dwarf2out_start_source_file (unsigned int lineno, const char *filename)
{
if (flag_eliminate_dwarf2_dups && !is_main_source)
{
/* Record the end of a source file. */
static void
-dwarf2out_end_source_file (lineno)
- unsigned int lineno ATTRIBUTE_UNUSED;
+dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
{
if (flag_eliminate_dwarf2_dups)
/* Record the end of the file for break_out_includes. */
initial whitespace, #, whitespace, directive-name, whitespace part. */
static void
-dwarf2out_define (lineno, buffer)
- unsigned lineno ATTRIBUTE_UNUSED;
- const char *buffer ATTRIBUTE_UNUSED;
+dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
+ const char *buffer ATTRIBUTE_UNUSED)
{
if (debug_info_level >= DINFO_LEVEL_VERBOSE)
{
initial whitespace, #, whitespace, directive-name, whitespace part. */
static void
-dwarf2out_undef (lineno, buffer)
- unsigned lineno ATTRIBUTE_UNUSED;
- const char *buffer ATTRIBUTE_UNUSED;
+dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
+ const char *buffer ATTRIBUTE_UNUSED)
{
if (debug_info_level >= DINFO_LEVEL_VERBOSE)
{
/* Set up for Dwarf output at the start of compilation. */
static void
-dwarf2out_init (filename)
- const char *filename ATTRIBUTE_UNUSED;
+dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
{
init_file_table ();
/* Allocate the initial hunk of the decl_die_table. */
- decl_die_table = ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT
+ decl_die_table = ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref));
decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
decl_die_table_in_use = 0;
ht_forall. Emit one queued .debug_str string. */
static int
-output_indirect_string (h, v)
- void **h;
- void *v ATTRIBUTE_UNUSED;
+output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
{
struct indirect_string_node *node = (struct indirect_string_node *) *h;
Be cool if the mark isn't set. */
static void
-prune_unmark_dies (die)
- dw_die_ref die;
+prune_unmark_dies (dw_die_ref die)
{
dw_die_ref c;
die->die_mark = 0;
it references as attributes and mark them as used. */
static void
-prune_unused_types_walk_attribs (die)
- dw_die_ref die;
+prune_unused_types_walk_attribs (dw_die_ref die)
{
dw_attr_ref a;
to DIE's children. */
static void
-prune_unused_types_mark (die, dokids)
- dw_die_ref die;
- int dokids;
+prune_unused_types_mark (dw_die_ref die, int dokids)
{
dw_die_ref c;
/* Walk the tree DIE and mark types that we actually use. */
static void
-prune_unused_types_walk (die)
- dw_die_ref die;
+prune_unused_types_walk (dw_die_ref die)
{
dw_die_ref c;
/* Remove from the tree DIE any dies that aren't marked. */
static void
-prune_unused_types_prune (die)
- dw_die_ref die;
+prune_unused_types_prune (dw_die_ref die)
{
dw_die_ref c, p, n;
if (!die->die_mark)
/* Remove dies representing declarations that we never use. */
static void
-prune_unused_types ()
+prune_unused_types (void)
{
unsigned int i;
limbo_die_node *node;
and generate the DWARF-2 debugging info. */
static void
-dwarf2out_finish (filename)
- const char *filename;
+dwarf2out_finish (const char *filename)
{
limbo_die_node *node, *next_node;
dw_die_ref die = 0;
/* dwarf2out.h - Various declarations for functions found in dwarf2out.c
- Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2000, 2003
+ Free Software Foundation, Inc.
This file is part of GCC.
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
-extern void dwarf2out_decl PARAMS ((tree));
-extern void dwarf2out_frame_debug PARAMS ((rtx));
+extern void dwarf2out_decl (tree);
+extern void dwarf2out_frame_debug (rtx);
-extern void debug_dwarf PARAMS ((void));
+extern void debug_dwarf (void);
struct die_struct;
-extern void debug_dwarf_die PARAMS ((struct die_struct *));
-extern void dwarf2out_set_demangle_name_func PARAMS ((const char *(*) (const char *)));
-extern void dwarf2out_add_library_unit_info PARAMS ((const char *, const char *));
+extern void debug_dwarf_die (struct die_struct *);
+extern void dwarf2out_set_demangle_name_func (const char *(*) (const char *));
+extern void dwarf2out_add_library_unit_info (const char *, const char *);
/* Forward declarations for functions defined in this file. */
-static void dwarfout_init PARAMS ((const char *));
-static void dwarfout_finish PARAMS ((const char *));
-static void dwarfout_define PARAMS ((unsigned int, const char *));
-static void dwarfout_undef PARAMS ((unsigned int, const char *));
-static void dwarfout_start_source_file PARAMS ((unsigned, const char *));
-static void dwarfout_start_source_file_check PARAMS ((unsigned, const char *));
-static void dwarfout_end_source_file PARAMS ((unsigned));
-static void dwarfout_end_source_file_check PARAMS ((unsigned));
-static void dwarfout_begin_block PARAMS ((unsigned, unsigned));
-static void dwarfout_end_block PARAMS ((unsigned, unsigned));
-static void dwarfout_end_epilogue PARAMS ((unsigned int, const char *));
-static void dwarfout_source_line PARAMS ((unsigned int, const char *));
-static void dwarfout_end_prologue PARAMS ((unsigned int, const char *));
-static void dwarfout_end_function PARAMS ((unsigned int));
-static void dwarfout_function_decl PARAMS ((tree));
-static void dwarfout_global_decl PARAMS ((tree));
-static void dwarfout_deferred_inline_function PARAMS ((tree));
-static void dwarfout_file_scope_decl PARAMS ((tree , int));
-static const char *dwarf_tag_name PARAMS ((unsigned));
-static const char *dwarf_attr_name PARAMS ((unsigned));
-static const char *dwarf_stack_op_name PARAMS ((unsigned));
-static const char *dwarf_typemod_name PARAMS ((unsigned));
-static const char *dwarf_fmt_byte_name PARAMS ((unsigned));
-static const char *dwarf_fund_type_name PARAMS ((unsigned));
-static tree decl_ultimate_origin PARAMS ((tree));
-static tree block_ultimate_origin PARAMS ((tree));
-static tree decl_class_context PARAMS ((tree));
+static void dwarfout_init (const char *);
+static void dwarfout_finish (const char *);
+static void dwarfout_define (unsigned int, const char *);
+static void dwarfout_undef (unsigned int, const char *);
+static void dwarfout_start_source_file (unsigned, const char *);
+static void dwarfout_start_source_file_check (unsigned, const char *);
+static void dwarfout_end_source_file (unsigned);
+static void dwarfout_end_source_file_check (unsigned);
+static void dwarfout_begin_block (unsigned, unsigned);
+static void dwarfout_end_block (unsigned, unsigned);
+static void dwarfout_end_epilogue (unsigned int, const char *);
+static void dwarfout_source_line (unsigned int, const char *);
+static void dwarfout_end_prologue (unsigned int, const char *);
+static void dwarfout_end_function (unsigned int);
+static void dwarfout_function_decl (tree);
+static void dwarfout_global_decl (tree);
+static void dwarfout_deferred_inline_function (tree);
+static void dwarfout_file_scope_decl (tree , int);
+static const char *dwarf_tag_name (unsigned);
+static const char *dwarf_attr_name (unsigned);
+static const char *dwarf_stack_op_name (unsigned);
+static const char *dwarf_typemod_name (unsigned);
+static const char *dwarf_fmt_byte_name (unsigned);
+static const char *dwarf_fund_type_name (unsigned);
+static tree decl_ultimate_origin (tree);
+static tree block_ultimate_origin (tree);
+static tree decl_class_context (tree);
#if 0
-static void output_unsigned_leb128 PARAMS ((unsigned long));
-static void output_signed_leb128 PARAMS ((long));
+static void output_unsigned_leb128 (unsigned long);
+static void output_signed_leb128 (long);
#endif
-static int fundamental_type_code PARAMS ((tree));
-static tree root_type_1 PARAMS ((tree, int));
-static tree root_type PARAMS ((tree));
-static void write_modifier_bytes_1 PARAMS ((tree, int, int, int));
-static void write_modifier_bytes PARAMS ((tree, int, int));
-static inline int type_is_fundamental PARAMS ((tree));
-static void equate_decl_number_to_die_number PARAMS ((tree));
-static inline void equate_type_number_to_die_number PARAMS ((tree));
-static void output_reg_number PARAMS ((rtx));
-static void output_mem_loc_descriptor PARAMS ((rtx));
-static void output_loc_descriptor PARAMS ((rtx));
-static void output_bound_representation PARAMS ((tree, unsigned, int));
-static void output_enumeral_list PARAMS ((tree));
-static inline HOST_WIDE_INT ceiling PARAMS ((HOST_WIDE_INT, unsigned int));
-static inline tree field_type PARAMS ((tree));
-static inline unsigned int simple_type_align_in_bits PARAMS ((tree));
-static inline unsigned HOST_WIDE_INT simple_type_size_in_bits PARAMS ((tree));
-static HOST_WIDE_INT field_byte_offset PARAMS ((tree));
-static inline void sibling_attribute PARAMS ((void));
-static void location_attribute PARAMS ((rtx));
-static void data_member_location_attribute PARAMS ((tree));
-static void const_value_attribute PARAMS ((rtx));
-static void location_or_const_value_attribute PARAMS ((tree));
-static inline void name_attribute PARAMS ((const char *));
-static inline void fund_type_attribute PARAMS ((unsigned));
-static void mod_fund_type_attribute PARAMS ((tree, int, int));
-static inline void user_def_type_attribute PARAMS ((tree));
-static void mod_u_d_type_attribute PARAMS ((tree, int, int));
+static int fundamental_type_code (tree);
+static tree root_type_1 (tree, int);
+static tree root_type (tree);
+static void write_modifier_bytes_1 (tree, int, int, int);
+static void write_modifier_bytes (tree, int, int);
+static inline int type_is_fundamental (tree);
+static void equate_decl_number_to_die_number (tree);
+static inline void equate_type_number_to_die_number (tree);
+static void output_reg_number (rtx);
+static void output_mem_loc_descriptor (rtx);
+static void output_loc_descriptor (rtx);
+static void output_bound_representation (tree, unsigned, char);
+static void output_enumeral_list (tree);
+static inline HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
+static inline tree field_type (tree);
+static inline unsigned int simple_type_align_in_bits (tree);
+static inline unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
+static HOST_WIDE_INT field_byte_offset (tree);
+static inline void sibling_attribute (void);
+static void location_attribute (rtx);
+static void data_member_location_attribute (tree);
+static void const_value_attribute (rtx);
+static void location_or_const_value_attribute (tree);
+static inline void name_attribute (const char *);
+static inline void fund_type_attribute (unsigned);
+static void mod_fund_type_attribute (tree, int, int);
+static inline void user_def_type_attribute (tree);
+static void mod_u_d_type_attribute (tree, int, int);
#ifdef USE_ORDERING_ATTRIBUTE
-static inline void ordering_attribute PARAMS ((unsigned));
+static inline void ordering_attribute (unsigned);
#endif /* defined(USE_ORDERING_ATTRIBUTE) */
-static void subscript_data_attribute PARAMS ((tree));
-static void byte_size_attribute PARAMS ((tree));
-static inline void bit_offset_attribute PARAMS ((tree));
-static inline void bit_size_attribute PARAMS ((tree));
-static inline void element_list_attribute PARAMS ((tree));
-static inline void stmt_list_attribute PARAMS ((const char *));
-static inline void low_pc_attribute PARAMS ((const char *));
-static inline void high_pc_attribute PARAMS ((const char *));
-static inline void body_begin_attribute PARAMS ((const char *));
-static inline void body_end_attribute PARAMS ((const char *));
-static inline void language_attribute PARAMS ((unsigned));
-static inline void member_attribute PARAMS ((tree));
+static void subscript_data_attribute (tree);
+static void byte_size_attribute (tree);
+static inline void bit_offset_attribute (tree);
+static inline void bit_size_attribute (tree);
+static inline void element_list_attribute (tree);
+static inline void stmt_list_attribute (const char *);
+static inline void low_pc_attribute (const char *);
+static inline void high_pc_attribute (const char *);
+static inline void body_begin_attribute (const char *);
+static inline void body_end_attribute (const char *);
+static inline void language_attribute (unsigned);
+static inline void member_attribute (tree);
#if 0
-static inline void string_length_attribute PARAMS ((tree));
+static inline void string_length_attribute (tree);
#endif
-static inline void comp_dir_attribute PARAMS ((const char *));
-static inline void sf_names_attribute PARAMS ((const char *));
-static inline void src_info_attribute PARAMS ((const char *));
-static inline void mac_info_attribute PARAMS ((const char *));
-static inline void prototyped_attribute PARAMS ((tree));
-static inline void producer_attribute PARAMS ((const char *));
-static inline void inline_attribute PARAMS ((tree));
-static inline void containing_type_attribute PARAMS ((tree));
-static inline void abstract_origin_attribute PARAMS ((tree));
+static inline void comp_dir_attribute (const char *);
+static inline void sf_names_attribute (const char *);
+static inline void src_info_attribute (const char *);
+static inline void mac_info_attribute (const char *);
+static inline void prototyped_attribute (tree);
+static inline void producer_attribute (const char *);
+static inline void inline_attribute (tree);
+static inline void containing_type_attribute (tree);
+static inline void abstract_origin_attribute (tree);
#ifdef DWARF_DECL_COORDINATES
-static inline void src_coords_attribute PARAMS ((unsigned, unsigned));
+static inline void src_coords_attribute (unsigned, unsigned);
#endif /* defined(DWARF_DECL_COORDINATES) */
-static inline void pure_or_virtual_attribute PARAMS ((tree));
-static void name_and_src_coords_attributes PARAMS ((tree));
-static void type_attribute PARAMS ((tree, int, int));
-static const char *type_tag PARAMS ((tree));
-static inline void dienum_push PARAMS ((void));
-static inline void dienum_pop PARAMS ((void));
-static inline tree member_declared_type PARAMS ((tree));
-static const char *function_start_label PARAMS ((tree));
-static void output_array_type_die PARAMS ((void *));
-static void output_set_type_die PARAMS ((void *));
+static inline void pure_or_virtual_attribute (tree);
+static void name_and_src_coords_attributes (tree);
+static void type_attribute (tree, int, int);
+static const char *type_tag (tree);
+static inline void dienum_push (void);
+static inline void dienum_pop (void);
+static inline tree member_declared_type (tree);
+static const char *function_start_label (tree);
+static void output_array_type_die (void *);
+static void output_set_type_die (void *);
#if 0
-static void output_entry_point_die PARAMS ((void *));
+static void output_entry_point_die (void *);
#endif
-static void output_inlined_enumeration_type_die PARAMS ((void *));
-static void output_inlined_structure_type_die PARAMS ((void *));
-static void output_inlined_union_type_die PARAMS ((void *));
-static void output_enumeration_type_die PARAMS ((void *));
-static void output_formal_parameter_die PARAMS ((void *));
-static void output_global_subroutine_die PARAMS ((void *));
-static void output_global_variable_die PARAMS ((void *));
-static void output_label_die PARAMS ((void *));
-static void output_lexical_block_die PARAMS ((void *));
-static void output_inlined_subroutine_die PARAMS ((void *));
-static void output_local_variable_die PARAMS ((void *));
-static void output_member_die PARAMS ((void *));
+static void output_inlined_enumeration_type_die (void *);
+static void output_inlined_structure_type_die (void *);
+static void output_inlined_union_type_die (void *);
+static void output_enumeration_type_die (void *);
+static void output_formal_parameter_die (void *);
+static void output_global_subroutine_die (void *);
+static void output_global_variable_die (void *);
+static void output_label_die (void *);
+static void output_lexical_block_die (void *);
+static void output_inlined_subroutine_die (void *);
+static void output_local_variable_die (void *);
+static void output_member_die (void *);
#if 0
-static void output_pointer_type_die PARAMS ((void *));
-static void output_reference_type_die PARAMS ((void *));
+static void output_pointer_type_die (void *);
+static void output_reference_type_die (void *);
#endif
-static void output_ptr_to_mbr_type_die PARAMS ((void *));
-static void output_compile_unit_die PARAMS ((void *));
-static void output_string_type_die PARAMS ((void *));
-static void output_inheritance_die PARAMS ((void *));
-static void output_structure_type_die PARAMS ((void *));
-static void output_local_subroutine_die PARAMS ((void *));
-static void output_subroutine_type_die PARAMS ((void *));
-static void output_typedef_die PARAMS ((void *));
-static void output_union_type_die PARAMS ((void *));
-static void output_unspecified_parameters_die PARAMS ((void *));
-static void output_padded_null_die PARAMS ((void *));
-static void output_die PARAMS ((void (*)(void *), void *));
-static void end_sibling_chain PARAMS ((void));
-static void output_formal_types PARAMS ((tree));
-static void pend_type PARAMS ((tree));
-static int type_ok_for_scope PARAMS ((tree, tree));
-static void output_pending_types_for_scope PARAMS ((tree));
-static void output_type PARAMS ((tree, tree));
-static void output_tagged_type_instantiation PARAMS ((tree));
-static void output_block PARAMS ((tree, int));
-static void output_decls_for_scope PARAMS ((tree, int));
-static void output_decl PARAMS ((tree, tree));
-static void shuffle_filename_entry PARAMS ((filename_entry *));
-static void generate_new_sfname_entry PARAMS ((void));
-static unsigned lookup_filename PARAMS ((const char *));
-static void generate_srcinfo_entry PARAMS ((unsigned, unsigned));
-static void generate_macinfo_entry PARAMS ((unsigned int, rtx,
- const char *));
-static int is_pseudo_reg PARAMS ((rtx));
-static tree type_main_variant PARAMS ((tree));
-static int is_tagged_type PARAMS ((tree));
-static int is_redundant_typedef PARAMS ((tree));
-static void add_incomplete_type PARAMS ((tree));
-static void retry_incomplete_types PARAMS ((void));
+static void output_ptr_to_mbr_type_die (void *);
+static void output_compile_unit_die (void *);
+static void output_string_type_die (void *);
+static void output_inheritance_die (void *);
+static void output_structure_type_die (void *);
+static void output_local_subroutine_die (void *);
+static void output_subroutine_type_die (void *);
+static void output_typedef_die (void *);
+static void output_union_type_die (void *);
+static void output_unspecified_parameters_die (void *);
+static void output_padded_null_die (void *);
+static void output_die (void (*)(void *), void *);
+static void end_sibling_chain (void);
+static void output_formal_types (tree);
+static void pend_type (tree);
+static int type_ok_for_scope (tree, tree);
+static void output_pending_types_for_scope (tree);
+static void output_type (tree, tree);
+static void output_tagged_type_instantiation (tree);
+static void output_block (tree, int);
+static void output_decls_for_scope (tree, int);
+static void output_decl (tree, tree);
+static void shuffle_filename_entry (filename_entry *);
+static void generate_new_sfname_entry (void);
+static unsigned lookup_filename (const char *);
+static void generate_srcinfo_entry (unsigned, unsigned);
+static void generate_macinfo_entry (unsigned int, rtx, const char *);
+static int is_pseudo_reg (rtx);
+static tree type_main_variant (tree);
+static int is_tagged_type (tree);
+static int is_redundant_typedef (tree);
+static void add_incomplete_type (tree);
+static void retry_incomplete_types (void);
\f
/* Definitions of defaults for assembler-dependent names of various
pseudo-ops and section names.
/************************ general utility functions **************************/
static inline int
-is_pseudo_reg (rtl)
- rtx rtl;
+is_pseudo_reg (rtx rtl)
{
return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
|| ((GET_CODE (rtl) == SUBREG)
}
static inline tree
-type_main_variant (type)
- tree type;
+type_main_variant (tree type)
{
type = TYPE_MAIN_VARIANT (type);
/* Return nonzero if the given type node represents a tagged type. */
static inline int
-is_tagged_type (type)
- tree type;
+is_tagged_type (tree type)
{
enum tree_code code = TREE_CODE (type);
}
static const char *
-dwarf_tag_name (tag)
- unsigned tag;
+dwarf_tag_name (unsigned int tag)
{
switch (tag)
{
}
static const char *
-dwarf_attr_name (attr)
- unsigned attr;
+dwarf_attr_name (unsigned int attr)
{
switch (attr)
{
}
static const char *
-dwarf_stack_op_name (op)
- unsigned op;
+dwarf_stack_op_name (unsigned int op)
{
switch (op)
{
}
static const char *
-dwarf_typemod_name (mod)
- unsigned mod;
+dwarf_typemod_name (unsigned int mod)
{
switch (mod)
{
}
static const char *
-dwarf_fmt_byte_name (fmt)
- unsigned fmt;
+dwarf_fmt_byte_name (unsigned int fmt)
{
switch (fmt)
{
}
static const char *
-dwarf_fund_type_name (ft)
- unsigned ft;
+dwarf_fund_type_name (unsigned int ft)
{
switch (ft)
{
served as the original seed for the given block. */
static tree
-decl_ultimate_origin (decl)
- tree decl;
+decl_ultimate_origin (tree decl)
{
#ifdef ENABLE_CHECKING
if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
served as the original seed for the given block. */
static tree
-block_ultimate_origin (block)
- tree block;
+block_ultimate_origin (tree block)
{
tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
parameter. */
static tree
-decl_class_context (decl)
- tree decl;
+decl_class_context (tree decl)
{
tree context = NULL_TREE;
if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
#if 0
static void
-output_unsigned_leb128 (value)
- unsigned long value;
+output_unsigned_leb128 (unsigned long value)
{
unsigned long orig_value = value;
}
static void
-output_signed_leb128 (value)
- long value;
+output_signed_leb128 (long value)
{
long orig_value = value;
int negative = (value < 0);
draft specification is probably never even useful in practice. */
static int
-fundamental_type_code (type)
- tree type;
+fundamental_type_code (tree type)
{
if (TREE_CODE (type) == ERROR_MARK)
return 0;
qualifiers. */
static tree
-root_type_1 (type, count)
- tree type;
- int count;
+root_type_1 (tree type, int count)
{
/* Give up after searching 1000 levels, in case this is a recursive
pointer type. Such types are possible in Ada, but it is not possible
}
static tree
-root_type (type)
- tree type;
+root_type (tree type)
{
type = root_type_1 (type, 0);
if (type != error_mark_node)
of zero or more Dwarf "type-modifier" bytes applicable to the type. */
static void
-write_modifier_bytes_1 (type, decl_const, decl_volatile, count)
- tree type;
- int decl_const;
- int decl_volatile;
- int count;
+write_modifier_bytes_1 (tree type, int decl_const, int decl_volatile, int count)
{
if (TREE_CODE (type) == ERROR_MARK)
return;
}
static void
-write_modifier_bytes (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
+write_modifier_bytes (tree type, int decl_const, int decl_volatile)
{
write_modifier_bytes_1 (type, decl_const, decl_volatile, 0);
}
given input type is a Dwarf "fundamental" type. Otherwise return zero. */
static inline int
-type_is_fundamental (type)
- tree type;
+type_is_fundamental (tree type)
{
switch (TREE_CODE (type))
{
UID number. */
static void
-equate_decl_number_to_die_number (decl)
- tree decl;
+equate_decl_number_to_die_number (tree decl)
{
/* In the case where we are generating a DIE for some ..._DECL node
which represents either some inline function declaration or some
UID number. */
static inline void
-equate_type_number_to_die_number (type)
- tree type;
+equate_type_number_to_die_number (tree type)
{
char type_label[MAX_ARTIFICIAL_LABEL_BYTES];
char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static void
-output_reg_number (rtl)
- rtx rtl;
+output_reg_number (rtx rtl)
{
unsigned regno = REGNO (rtl);
if (regno >= DWARF_FRAME_REGISTERS)
{
- warning_with_decl (dwarf_last_decl,
+ warning_with_decl (dwarf_last_decl,
"internal regno botch: `%s' has regno = %d\n",
regno);
regno = 0;
RTL tree, turning it into Dwarf postfix code as it goes. */
static void
-output_mem_loc_descriptor (rtl)
- rtx rtl;
+output_mem_loc_descriptor (rtx rtl)
{
/* Note that for a dynamically sized array, the location we will
generate a description of here will be the lowest numbered location
generate the (dynamic) address of the object onto the address stack. */
static void
-output_loc_descriptor (rtl)
- rtx rtl;
+output_loc_descriptor (rtx rtl)
{
switch (GET_CODE (rtl))
{
}
/* Given a tree node describing an array bound (either lower or upper)
- output a representation for that bound. */
+ output a representation for that bound. DIM_NUM is used for
+ multi-dimensional arrays and U_OR_L disgnates upper or lower
+ bound. */
static void
-output_bound_representation (bound, dim_num, u_or_l)
- tree bound;
- unsigned dim_num; /* For multi-dimensional arrays. */
- char u_or_l; /* Designates upper or lower bound. */
+output_bound_representation (tree bound, unsigned int dim_num, char u_or_l)
{
switch (TREE_CODE (bound))
{
|| TREE_CODE (bound) == CONVERT_EXPR)
bound = TREE_OPERAND (bound, 0);
- if (TREE_CODE (bound) == SAVE_EXPR
+ if (TREE_CODE (bound) == SAVE_EXPR
&& SAVE_EXPR_RTL (bound))
output_loc_descriptor
(eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
enumeration_type_die. */
static void
-output_enumeral_list (link)
- tree link;
+output_enumeral_list (tree link)
{
if (link)
{
which is not less than the value itself. */
static inline HOST_WIDE_INT
-ceiling (value, boundary)
- HOST_WIDE_INT value;
- unsigned int boundary;
+ceiling (HOST_WIDE_INT value, unsigned int boundary)
{
return (((value + boundary - 1) / boundary) * boundary);
}
`integer_type_node' if the given node turns out to be an ERROR_MARK node. */
static inline tree
-field_type (decl)
- tree decl;
+field_type (tree decl)
{
tree type;
BITS_PER_WORD if the node actually turns out to be an ERROR_MARK node. */
static inline unsigned int
-simple_type_align_in_bits (type)
- tree type;
+simple_type_align_in_bits (tree type)
{
return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
}
to be an ERROR_MARK node. */
static inline unsigned HOST_WIDE_INT
-simple_type_size_in_bits (type)
- tree type;
+simple_type_size_in_bits (tree type)
{
tree type_size_tree;
(We can't handle the latter case just yet.) */
static HOST_WIDE_INT
-field_byte_offset (decl)
- tree decl;
+field_byte_offset (tree decl)
{
unsigned int type_align_in_bytes;
unsigned int type_align_in_bits;
/* Generate an AT_sibling attribute. */
static inline void
-sibling_attribute ()
+sibling_attribute (void)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
are generated by the routine `data_member_location_attribute' below. */
static void
-location_attribute (rtl)
- rtx rtl;
+location_attribute (rtx rtl)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
(See the `bit_offset_attribute' function below.) */
static void
-data_member_location_attribute (t)
- tree t;
+data_member_location_attribute (tree t)
{
unsigned object_offset_in_bytes;
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
declared constants do not necessarily get memory "homes". */
static void
-const_value_attribute (rtl)
- rtx rtl;
+const_value_attribute (rtx rtl)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
call evaluates to a compile-time constant address. */
static void
-location_or_const_value_attribute (decl)
- tree decl;
+location_or_const_value_attribute (tree decl)
{
rtx rtl;
the value of the attribute. */
static inline void
-name_attribute (name_string)
- const char *name_string;
+name_attribute (const char *name_string)
{
if (name_string && *name_string)
{
}
static inline void
-fund_type_attribute (ft_code)
- unsigned ft_code;
+fund_type_attribute (unsigned int ft_code)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type);
ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code);
}
static void
-mod_fund_type_attribute (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
+mod_fund_type_attribute (tree type, int decl_const, int decl_volatile)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static inline void
-user_def_type_attribute (type)
- tree type;
+user_def_type_attribute (tree type)
{
char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
}
static void
-mod_u_d_type_attribute (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
+mod_u_d_type_attribute (tree type, int decl_const, int decl_volatile)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
#ifdef USE_ORDERING_ATTRIBUTE
static inline void
-ordering_attribute (ordering)
- unsigned ordering;
+ordering_attribute (unsigned ordering)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering);
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering);
includes information about the element type of type given array type. */
static void
-subscript_data_attribute (type)
- tree type;
+subscript_data_attribute (tree type)
{
unsigned dimension_number;
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static void
-byte_size_attribute (tree_node)
- tree tree_node;
+byte_size_attribute (tree tree_node)
{
unsigned size;
bit-field. (See `byte_size_attribute' above.) */
static inline void
-bit_offset_attribute (decl)
- tree decl;
+bit_offset_attribute (tree decl)
{
HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
tree type = DECL_BIT_FIELD_TYPE (decl);
which specifies the length in bits of the given field. */
static inline void
-bit_size_attribute (decl)
- tree decl;
+bit_size_attribute (tree decl)
{
/* Must be a field and a bit field. */
if (TREE_CODE (decl) != FIELD_DECL
type. */
static inline void
-element_list_attribute (element)
- tree element;
+element_list_attribute (tree element)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
DIEs with a TAG_compile_unit tag. */
static inline void
-stmt_list_attribute (label)
- const char *label;
+stmt_list_attribute (const char *label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
for a subroutine DIE. */
static inline void
-low_pc_attribute (asm_low_label)
- const char *asm_low_label;
+low_pc_attribute (const char *asm_low_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
subroutine DIE. */
static inline void
-high_pc_attribute (asm_high_label)
- const char *asm_high_label;
+high_pc_attribute (const char *asm_high_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
/* Generate an AT_body_begin attribute for a subroutine DIE. */
static inline void
-body_begin_attribute (asm_begin_label)
- const char *asm_begin_label;
+body_begin_attribute (const char *asm_begin_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
/* Generate an AT_body_end attribute for a subroutine DIE. */
static inline void
-body_end_attribute (asm_end_label)
- const char *asm_end_label;
+body_end_attribute (const char *asm_end_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
are used only within TAG_compile_unit DIEs. */
static inline void
-language_attribute (language_code)
- unsigned language_code;
+language_attribute (unsigned int language_code)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language);
ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code);
}
static inline void
-member_attribute (context)
- tree context;
+member_attribute (tree context)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
#endif
static inline void
-string_length_attribute (upper_bound)
- tree upper_bound;
+string_length_attribute (tree upper_bound)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
#endif
static inline void
-comp_dir_attribute (dirname)
- const char *dirname;
+comp_dir_attribute (const char *dirname)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
}
static inline void
-sf_names_attribute (sf_names_start_label)
- const char *sf_names_start_label;
+sf_names_attribute (const char *sf_names_start_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
}
static inline void
-src_info_attribute (src_info_start_label)
- const char *src_info_start_label;
+src_info_attribute (const char *src_info_start_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
}
static inline void
-mac_info_attribute (mac_info_start_label)
- const char *mac_info_start_label;
+mac_info_attribute (const char *mac_info_start_label)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
}
static inline void
-prototyped_attribute (func_type)
- tree func_type;
+prototyped_attribute (tree func_type)
{
if ((strcmp (lang_hooks.name, "GNU C") == 0)
&& (TYPE_ARG_TYPES (func_type) != NULL))
}
static inline void
-producer_attribute (producer)
- const char *producer;
+producer_attribute (const char *producer)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, producer);
}
static inline void
-inline_attribute (decl)
- tree decl;
+inline_attribute (tree decl)
{
if (DECL_INLINE (decl))
{
}
static inline void
-containing_type_attribute (containing_type)
- tree containing_type;
+containing_type_attribute (tree containing_type)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static inline void
-abstract_origin_attribute (origin)
- tree origin;
+abstract_origin_attribute (tree origin)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
#ifdef DWARF_DECL_COORDINATES
static inline void
-src_coords_attribute (src_fileno, src_lineno)
- unsigned src_fileno;
- unsigned src_lineno;
+src_coords_attribute (unsigned src_fileno, unsigned src_lineno)
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords);
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno);
#endif /* defined(DWARF_DECL_COORDINATES) */
static inline void
-pure_or_virtual_attribute (func_decl)
- tree func_decl;
+pure_or_virtual_attribute (tree func_decl)
{
if (DECL_VIRTUAL_P (func_decl))
{
given decl, but only if it actually has a name. */
static void
-name_and_src_coords_attributes (decl)
- tree decl;
+name_and_src_coords_attributes (tree decl)
{
tree decl_name = DECL_NAME (decl);
routine writes out these "type descriptor" parts. */
static void
-type_attribute (type, decl_const, decl_volatile)
- tree type;
- int decl_const;
- int decl_volatile;
+type_attribute (tree type, int decl_const, int decl_volatile)
{
enum tree_code code = TREE_CODE (type);
int root_type_modified;
type was declared without a tag. */
static const char *
-type_tag (type)
- tree type;
+type_tag (tree type)
{
const char *name = 0;
}
static inline void
-dienum_push ()
+dienum_push (void)
{
/* Start by checking if the pending_sibling_stack needs to be expanded.
If necessary, expand it. */
NEXT_DIE_NUM. */
static inline void
-dienum_pop ()
+dienum_pop (void)
{
pending_siblings--;
}
static inline tree
-member_declared_type (member)
- tree member;
+member_declared_type (tree member)
{
return (DECL_BIT_FIELD_TYPE (member))
? DECL_BIT_FIELD_TYPE (member)
in the source file. */
static const char *
-function_start_label (decl)
- tree decl;
+function_start_label (tree decl)
{
rtx x;
const char *fnname;
/* Note that every type of DIE (except a null DIE) gets a sibling. */
static void
-output_array_type_die (arg)
- void *arg;
+output_array_type_die (void *arg)
{
tree type = arg;
}
static void
-output_set_type_die (arg)
- void *arg;
+output_set_type_die (void *arg)
{
tree type = arg;
/* Implement this when there is a GNU FORTRAN or GNU Ada front end. */
static void
-output_entry_point_die (arg)
- void *arg;
+output_entry_point_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
/* Output a DIE to represent an inlined instance of an enumeration type. */
static void
-output_inlined_enumeration_type_die (arg)
- void *arg;
+output_inlined_enumeration_type_die (void *arg)
{
tree type = arg;
/* Output a DIE to represent an inlined instance of a structure type. */
static void
-output_inlined_structure_type_die (arg)
- void *arg;
+output_inlined_structure_type_die (void *arg)
{
tree type = arg;
/* Output a DIE to represent an inlined instance of a union type. */
static void
-output_inlined_union_type_die (arg)
- void *arg;
+output_inlined_union_type_die (void *arg)
{
tree type = arg;
This information is encoded into the element_list attribute. */
static void
-output_enumeration_type_die (arg)
- void *arg;
+output_enumeration_type_die (void *arg)
{
tree type = arg;
formal argument type of some subprogram type. */
static void
-output_formal_parameter_die (arg)
- void *arg;
+output_formal_parameter_die (void *arg)
{
tree node = arg;
or block-local) which has "external linkage" (according to ANSI-C). */
static void
-output_global_subroutine_die (arg)
- void *arg;
+output_global_subroutine_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
or block-local) which has "external linkage" (according to ANSI-C). */
static void
-output_global_variable_die (arg)
- void *arg;
+output_global_variable_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
}
static void
-output_label_die (arg)
- void *arg;
+output_label_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
}
static void
-output_lexical_block_die (arg)
- void *arg;
+output_lexical_block_die (void *arg)
{
tree stmt = arg;
}
static void
-output_inlined_subroutine_die (arg)
- void *arg;
+output_inlined_subroutine_die (void *arg)
{
tree stmt = arg;
or block-local) which has "internal linkage" (according to ANSI-C). */
static void
-output_local_variable_die (arg)
- void *arg;
+output_local_variable_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
}
static void
-output_member_die (arg)
- void *arg;
+output_member_die (void *arg)
{
tree decl = arg;
someday. */
static void
-output_pointer_type_die (arg)
- void *arg;
+output_pointer_type_die (void *arg)
{
tree type = arg;
}
static void
-output_reference_type_die (arg)
- void *arg;
+output_reference_type_die (void *arg)
{
tree type = arg;
#endif
static void
-output_ptr_to_mbr_type_die (arg)
- void *arg;
+output_ptr_to_mbr_type_die (void *arg)
{
tree type = arg;
}
static void
-output_compile_unit_die (arg)
- void *arg;
+output_compile_unit_die (void *arg)
{
const char *main_input_filename = arg;
const char *language_string = lang_hooks.name;
}
static void
-output_string_type_die (arg)
- void *arg;
+output_string_type_die (void *arg)
{
tree type = arg;
}
static void
-output_inheritance_die (arg)
- void *arg;
+output_inheritance_die (void *arg)
{
tree binfo = ((tree *)arg)[0];
tree access = ((tree *)arg)[1];
}
static void
-output_structure_type_die (arg)
- void *arg;
+output_structure_type_die (void *arg)
{
tree type = arg;
or block-local) which has "internal linkage" (according to ANSI-C). */
static void
-output_local_subroutine_die (arg)
- void *arg;
+output_local_subroutine_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
}
static void
-output_subroutine_type_die (arg)
- void *arg;
+output_subroutine_type_die (void *arg)
{
tree type = arg;
tree return_type = TREE_TYPE (type);
}
static void
-output_typedef_die (arg)
- void *arg;
+output_typedef_die (void *arg)
{
tree decl = arg;
tree origin = decl_ultimate_origin (decl);
}
static void
-output_union_type_die (arg)
- void *arg;
+output_union_type_die (void *arg)
{
tree type = arg;
at the end of an (ANSI prototyped) formal parameters list. */
static void
-output_unspecified_parameters_die (arg)
- void *arg;
+output_unspecified_parameters_die (void *arg)
{
tree decl_or_type = arg;
}
static void
-output_padded_null_die (arg)
- void *arg ATTRIBUTE_UNUSED;
+output_padded_null_die (void *arg ATTRIBUTE_UNUSED)
{
ASM_OUTPUT_ALIGN (asm_out_file, 2); /* 2**2 == 4 */
}
of the DIE, there must always be a terminator label for the DIE. */
static void
-output_die (die_specific_output_function, param)
- void (*die_specific_output_function) PARAMS ((void *));
- void *param;
+output_die (void (*die_specific_output_function) (void *), void *param)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static void
-end_sibling_chain ()
+end_sibling_chain (void)
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
the formal parameter list. */
static void
-output_formal_types (function_or_method_type)
- tree function_or_method_type;
+output_formal_types (tree function_or_method_type)
{
tree link;
tree formal_type = NULL;
/* Remember a type in the pending_types_list. */
static void
-pend_type (type)
- tree type;
+pend_type (tree type)
{
if (pending_types == pending_types_allocated)
{
true scope of the types we temporarily pended. */
static inline int
-type_ok_for_scope (type, scope)
- tree type;
- tree scope;
+type_ok_for_scope (tree type, tree scope)
{
/* Tagged types (i.e. struct, union, and enum types) must always be
output only in the scopes where they actually belong (or else the
of them too. */
static void
-output_pending_types_for_scope (containing_scope)
- tree containing_scope;
+output_pending_types_for_scope (tree containing_scope)
{
unsigned i;
/* Remember a type in the incomplete_types_list. */
static void
-add_incomplete_type (type)
- tree type;
+add_incomplete_type (tree type)
{
if (incomplete_types == incomplete_types_allocated)
{
emit full debugging info for them. */
static void
-retry_incomplete_types ()
+retry_incomplete_types (void)
{
tree type;
}
static void
-output_type (type, containing_scope)
- tree type;
- tree containing_scope;
+output_type (tree type, tree containing_scope)
{
if (type == 0 || type == error_mark_node)
return;
if (COMPLETE_TYPE_P (type))
{
tree binfo = TYPE_BINFO (type);
-
+
/* First output info about the base classes. */
if (binfo)
{
}
static void
-output_tagged_type_instantiation (type)
- tree type;
+output_tagged_type_instantiation (tree type)
{
if (type == 0 || type == error_mark_node)
return;
the things which are local to the given block. */
static void
-output_block (stmt, depth)
- tree stmt;
- int depth;
+output_block (tree stmt, int depth)
{
int must_output_die = 0;
tree origin;
a `binding contour') and (recursively) all of it's sub-blocks. */
static void
-output_decls_for_scope (stmt, depth)
- tree stmt;
- int depth;
+output_decls_for_scope (tree stmt, int depth)
{
/* Ignore blocks never really used to make RTL. */
/* Is this a typedef we can avoid emitting? */
static inline int
-is_redundant_typedef (decl)
- tree decl;
+is_redundant_typedef (tree decl)
{
if (TYPE_DECL_IS_STUB (decl))
return 1;
/* Output Dwarf .debug information for a decl described by DECL. */
static void
-output_decl (decl, containing_scope)
- tree decl;
- tree containing_scope;
+output_decl (tree decl, tree containing_scope)
{
/* Make a note of the decl node we are going to be working on. We may
need to give the user the source coordinates of where it appeared in
function. */
{
- void (*func) PARAMS ((void *));
+ void (*func) (void *);
register tree origin = decl_ultimate_origin (decl);
if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
\f
/* Output debug information for a function. */
static void
-dwarfout_function_decl (decl)
- tree decl;
+dwarfout_function_decl (tree decl)
{
dwarfout_file_scope_decl (decl, 0);
}
/* Debug information for a global DECL. Called from toplev.c after
compilation proper has finished. */
static void
-dwarfout_global_decl (decl)
- tree decl;
+dwarfout_global_decl (tree decl)
{
/* Output DWARF information for file-scope tentative data object
declarations, file-scope (extern) function declarations (which
being output at this point. (We're putting that off until we need
to do it.) */
static void
-dwarfout_deferred_inline_function (decl)
- tree decl;
+dwarfout_deferred_inline_function (tree decl)
{
/* Generate the DWARF info for the "abstract" instance of a function
which we may later generate inlined and/or out-of-line instances
}
static void
-dwarfout_file_scope_decl (decl, set_finalizing)
- tree decl;
- int set_finalizing;
+dwarfout_file_scope_decl (tree decl, int set_finalizing)
{
if (TREE_CODE (decl) == ERROR_MARK)
return;
for a lexical block. */
static void
-dwarfout_begin_block (line, blocknum)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int blocknum;
+dwarfout_begin_block (unsigned int line ATTRIBUTE_UNUSED,
+ unsigned int blocknum)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
for a lexical block. */
static void
-dwarfout_end_block (line, blocknum)
- unsigned int line ATTRIBUTE_UNUSED;
- unsigned int blocknum;
+dwarfout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
to their home locations). */
static void
-dwarfout_end_prologue (line, file)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *file ATTRIBUTE_UNUSED;
+dwarfout_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
+ const char *file ATTRIBUTE_UNUSED)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
the real body of the function ends (just before the epilogue code). */
static void
-dwarfout_end_function (line)
- unsigned int line ATTRIBUTE_UNUSED;
+dwarfout_end_function (unsigned int line ATTRIBUTE_UNUSED)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
has been generated. */
static void
-dwarfout_end_epilogue (line, file)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *file ATTRIBUTE_UNUSED;
+dwarfout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
+ const char *file ATTRIBUTE_UNUSED)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static void
-shuffle_filename_entry (new_zeroth)
- filename_entry *new_zeroth;
+shuffle_filename_entry (filename_entry *new_zeroth)
{
filename_entry temp_entry;
filename_entry *limit_p;
/* Create a new (string) entry for the .debug_sfnames section. */
static void
-generate_new_sfname_entry ()
+generate_new_sfname_entry (void)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
before them.) */
static unsigned
-lookup_filename (file_name)
- const char *file_name;
+lookup_filename (const char *file_name)
{
filename_entry *search_p;
filename_entry *limit_p = &filename_table[ft_entries];
}
static void
-generate_srcinfo_entry (line_entry_num, files_entry_num)
- unsigned line_entry_num;
- unsigned files_entry_num;
+generate_srcinfo_entry (unsigned int line_entry_num, unsigned int files_entry_num)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
}
static void
-dwarfout_source_line (line, filename)
- unsigned int line;
- const char *filename;
+dwarfout_source_line (unsigned int line, const char *filename)
{
if (debug_info_level >= DINFO_LEVEL_NORMAL
/* We can't emit line number info for functions in separate sections,
/* Generate an entry in the .debug_macinfo section. */
static void
-generate_macinfo_entry (type, offset, string)
- unsigned int type;
- rtx offset;
- const char *string;
+generate_macinfo_entry (unsigned int type, rtx offset, const char *string)
{
if (! use_gnu_debug_info_extensions)
return;
/* Wrapper for toplev.c callback to check debug info level. */
static void
-dwarfout_start_source_file_check (line, filename)
- unsigned int line;
- const char *filename;
+dwarfout_start_source_file_check (unsigned int line, const char *filename)
{
if (debug_info_level == DINFO_LEVEL_VERBOSE)
dwarfout_start_source_file (line, filename);
}
static void
-dwarfout_start_source_file (line, filename)
- unsigned int line ATTRIBUTE_UNUSED;
- const char *filename;
+dwarfout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
+ const char *filename)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
const char *label1, *label2;
/* Wrapper for toplev.c callback to check debug info level. */
static void
-dwarfout_end_source_file_check (lineno)
- unsigned lineno;
+dwarfout_end_source_file_check (unsigned int lineno)
{
if (debug_info_level == DINFO_LEVEL_VERBOSE)
dwarfout_end_source_file (lineno);
}
static void
-dwarfout_end_source_file (lineno)
- unsigned lineno;
+dwarfout_end_source_file (unsigned int lineno)
{
generate_macinfo_entry (MACINFO_resume, GEN_INT (lineno), "");
}
whitespace part. */
static void
-dwarfout_define (lineno, buffer)
- unsigned lineno;
- const char *buffer;
+dwarfout_define (unsigned int lineno, const char *buffer)
{
static int initialized = 0;
whitespace part. */
static void
-dwarfout_undef (lineno, buffer)
- unsigned lineno;
- const char *buffer;
+dwarfout_undef (unsigned int lineno, const char *buffer)
{
generate_macinfo_entry (MACINFO_undef, GEN_INT (lineno), buffer);
}
/* Set up for Dwarf output at the start of compilation. */
static void
-dwarfout_init (main_input_filename)
- const char *main_input_filename;
+dwarfout_init (const char *main_input_filename)
{
warning ("support for the DWARF1 debugging format is deprecated");
/* Output stuff that dwarf requires at the end of every file. */
static void
-dwarfout_finish (main_input_filename)
- const char *main_input_filename ATTRIBUTE_UNUSED;
+dwarfout_finish (const char *main_input_filename ATTRIBUTE_UNUSED)
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
projects / thirdparty / gcc.git / commitdiff
