* dbxout.c: Fix comment formatting.
* dependence.c: Likewise.
* df.c: Likewise.
* diagnostic.c: Likewise.
* dominance.c: Likewise.
* doprint.c: Likewise.
* dwarf2out.c: Likewise.
* dwarfout.c: Likewise.
* emit-rtl.c: Likewise.
* except.c: Likewise.
* explow.c: Likewise.
* expmed.c: Likewise.
* expr.c: Likewise.
* flow.c: Likewise.
* fold-const.c: Likewise.
* function.c: Likewise.
From-SVN: r44729
+2001-08-08 Kazu Hirata <kazu@hxi.com>
+
+ * dbxout.c: Fix comment formatting.
+ * dependence.c: Likewise.
+ * df.c: Likewise.
+ * diagnostic.c: Likewise.
+ * dominance.c: Likewise.
+ * doprint.c: Likewise.
+ * dwarf2out.c: Likewise.
+ * dwarfout.c: Likewise.
+ * emit-rtl.c: Likewise.
+ * except.c: Likewise.
+ * explow.c: Likewise.
+ * expmed.c: Likewise.
+ * expr.c: Likewise.
+ * flow.c: Likewise.
+ * fold-const.c: Likewise.
+ * function.c: Likewise.
+
2001-08-08 Franz Sirl <Franz.Sirl-kernel@lauterbach.com>
* global.c (retry_global_alloc): Avoid shadowing allocno.
did_output = 1;
#else
/* In dbx format, the syms of a block come before the N_LBRAC.
- If nothing is output, we don't need the N_LBRAC, either. */
+ If nothing is output, we don't need the N_LBRAC, either. */
did_output = 0;
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
did_output = dbxout_syms (BLOCK_VARS (block));
/* Given a def/use one can chase the next chain to follow the def/use
for that variable. Alternately one can sequentially follow each
- element of def_use_chain. */
+ element of def_use_chain. */
typedef struct def_use
{
/* Given a loop* one can chase the next_nest chain to follow the nested
loops for that loop. Alternately one can sequentially follow each
element of loop_chain and check outer_loop to get all loops
- contained within a certain loop. */
+ contained within a certain loop. */
typedef struct loop
{
enum loop_status_type status;
/* loop* for loop contained in this loop */
struct loop *next_nest;
- /* induction variables for this loop. Currently only the index variable. */
+ /* induction variables for this loop. Currently only the index variable. */
struct induction *ind;
} loop;
-/* Pointed to by loop. One per induction variable. */
+/* Pointed to by loop. One per induction variable. */
typedef struct induction
{
int low_bound;
/* upper bound */
int high_bound;
- /* next induction variable for this loop. Currently null. */
+ /* next induction variable for this loop. Currently null. */
struct induction *next;
} induction;
-/* Pointed to by def/use. One per dependence. */
+/* Pointed to by def/use. One per dependence. */
typedef struct dependence
{
int offset;
/* our name */
const char *variable;
- /* next subscript term. Currently null. */
+ /* next subscript term. Currently null. */
struct subscript *next;
} subscript;
-/* Remember the destination the front end encountered. */
+/* Remember the destination the front end encountered. */
static tree dest_to_remember;
void end_dependence_analysis PARAMS ((void));
/* Build dependence chain 'dep_chain', which is used by have_dependence_p,
- for the function given by EXP. */
+ for the function given by EXP. */
void
init_dependence_analysis (exp)
}
/* Update LOOP_DEF if for loop's COND_NODE and INCR_NODE define an index that
- is a normalized induction variable. */
+ is a normalized induction variable. */
static int
find_induction_variable (init_node, cond_node, incr_node, loop_def)
/* Return the ordinal subscript position for IND_VAR if it is an induction
- variable contained in OUTER_LOOP, otherwise return -1. */
+ variable contained in OUTER_LOOP, otherwise return -1. */
static int
have_induction_variable (outer_loop, ind_var)
return -1;
}
-/* Chain the nodes of 'loop_chain'. */
+/* Chain the nodes of 'loop_chain'. */
static void
link_loops ()
}
}
-/* Check the dependence for each member of 'def_use_chain'. */
+/* Check the dependence for each member of 'def_use_chain'. */
static void
get_node_dependence ()
}
}
-/* Check the dependence for definition DU. */
+/* Check the dependence for definition DU. */
static void
check_node_dependence (du)
}
}
-/* Get the COEFFICIENTS and offset for def/use DU. */
+/* Get the COEFFICIENTS and offset for def/use DU. */
static int
get_coefficients (du, coefficients)
return array_count;
}
-/* Get the COEFFICIENTS and offset for NODE having TYPE and defined in DU. */
+/* Get the COEFFICIENTS and offset for NODE having TYPE and defined in DU. */
static int
get_one_coefficient (node, coefficients, du, type)
return 0;
}
-/* Adjust the COEFFICIENTS as if loop LOOP_PTR were normalized to start at 0. */
+/* Adjust the COEFFICIENTS as if loop LOOP_PTR were normalized to start at 0. */
static void
normalize_coefficients (coefficients, loop_ptr, count)
coef_diff = icoefficients[sub].offset - ocoefficients[sub].offset;
/* strong_siv requires equal coefficients. weak_crossing_siv requires
coefficients to have equal absolute value. weak_zero_siv uses the
- nonzero coefficient. */
+ nonzero coefficient. */
if (ocoefficients[sub].coefficient == INT_MIN)
coef = icoefficients[sub].coefficient;
}
}
/* ?? gcd does not yield direction and distance. Wolfe's direction
- vector hierarchy can be used to give this. */
+ vector hierarchy can be used to give this. */
}
/* Find the gcd of X and Y using Euclid's algorithm */
}
}
-/* Dump ARRAY_REF NODE. */
+/* Dump ARRAY_REF NODE. */
static void
dump_array_ref (node)
}
}
-/* Dump def/use DU. */
+/* Dump def/use DU. */
#if 0
static void
}
}
-/* Dump dependence info. */
+/* Dump dependence info. */
static void
dump_node_dependence (void)
/* Return the index into 'dep_chain' if there is a dependency for destination
dest_to_remember (set by remember_dest_for_dependence) and source node.
- Called by the front end, which adds the index onto a MEM rtx. */
+ Called by the front end, which adds the index onto a MEM rtx. */
int
search_dependence (node)
return 0;
}
-/* Remember a destination NODE for search_dependence. */
+/* Remember a destination NODE for search_dependence. */
void
remember_dest_for_dependence (node)
#endif
/* Return 1 along with the dependence DIRECTION and DISTANCE if there is a
- dependence from dest_rtx to src_rtx. */
+ dependence from dest_rtx to src_rtx. */
int
have_dependence_p (dest_rtx, src_rtx, direction, distance)
return 0;
}
-/* Cleanup when dependency analysis is complete. */
+/* Cleanup when dependency analysis is complete. */
void
end_dependence_analysis ()
/* Catch the def of the register being modified. */
df_ref_record (df, XEXP (x, 0), &XEXP (x, 0), bb, insn, DF_REF_REG_DEF);
- /* ... Fall through to handle uses ... */
+ /* ... Fall through to handle uses ... */
default:
break;
\f
/* Use depth first order, and the worklist, to figure out what block
- to look at next. */
+ to look at next. */
static int
df_visit_next (df, blocks)
#define diagnostic_args output_buffer_ptr_to_format_args (diagnostic_buffer)
#define diagnostic_msg output_buffer_text_cursor (diagnostic_buffer)
-/* Prototypes. */
+/* Prototypes. */
static void diagnostic_finish PARAMS ((output_buffer *));
static void output_do_verbatim PARAMS ((output_buffer *,
const char *, va_list *));
va_end (ap);
}
-/* Same as above but within the context FILE and LINE. */
+/* Same as above but within the context FILE and LINE. */
void
pedwarn_with_file_and_line VPARAMS ((const char *file, int line,
is true for every basic block bb, but not the opposite. */
basic_block *dfs_to_bb;
- /* This is the next free DFS number when creating the DFS tree or forest. */
+ /* This is the next free DFS number when creating the DFS tree or forest. */
unsigned int dfsnum;
/* The number of nodes in the DFS tree (==dfsnum-1). */
unsigned int nodes;
basic_block bb;
enum cdi_direction reverse;
{
- /* We never call this with bb==EXIT_BLOCK_PTR (ENTRY_BLOCK_PTR if 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. */
edge e;
TBB child_i, my_i = 0;
#include "system.h"
#undef _doprnt
-#ifdef TEST /* Make sure to use the internal one. */
+#ifdef TEST /* Make sure to use the internal one. */
#define _doprnt my_doprnt
#endif
do { \
const int value = abs (va_arg (ap, int)); \
char buf[32]; \
- ptr++; /* Go past the asterisk. */ \
- *sptr = '\0'; /* NULL terminate sptr. */ \
+ ptr++; /* Go past the asterisk. */ \
+ *sptr = '\0'; /* NULL terminate sptr. */ \
sprintf(buf, "%d", value); \
strcat(sptr, buf); \
while (*sptr) sptr++; \
do { \
int result; \
TYPE value = va_arg (ap, TYPE); \
- *sptr++ = *ptr++; /* Copy the type specifier. */ \
- *sptr = '\0'; /* NULL terminate sptr. */ \
+ *sptr++ = *ptr++; /* Copy the type specifier. */ \
+ *sptr = '\0'; /* NULL terminate sptr. */ \
result = fprintf(stream, specifier, value); \
if (result == -1) \
return -1; \
while (*ptr != '\0')
{
- if (*ptr != '%') /* While we have regular characters, print them. */
+ if (*ptr != '%') /* While we have regular characters, print them. */
PRINT_CHAR(*ptr);
else /* We got a format specifier! */
{
char * sptr = specifier;
int wide_width = 0, short_width = 0;
- *sptr++ = *ptr++; /* Copy the % and move forward. */
+ *sptr++ = *ptr++; /* Copy the % and move forward. */
- while (strchr ("-+ #0", *ptr)) /* Move past flags. */
+ while (strchr ("-+ #0", *ptr)) /* Move past flags. */
*sptr++ = *ptr++;
if (*ptr == '*')
COPY_VA_INT;
else
- while (ISDIGIT(*ptr)) /* Handle explicit numeric value. */
+ while (ISDIGIT(*ptr)) /* Handle explicit numeric value. */
*sptr++ = *ptr++;
if (*ptr == '.')
{
- *sptr++ = *ptr++; /* Copy and go past the period. */
+ *sptr++ = *ptr++; /* Copy and go past the period. */
if (*ptr == '*')
COPY_VA_INT;
else
- while (ISDIGIT(*ptr)) /* Handle explicit numeric value. */
+ while (ISDIGIT(*ptr)) /* Handle explicit numeric value. */
*sptr++ = *ptr++;
}
while (strchr ("hlL", *ptr))
{
/* Short values are promoted to int, so just copy it
as an int and trust the C library printf to cast it
- to the right width. */
+ to the right width. */
if (short_width)
PRINT_TYPE(int);
else
#if defined(__GNUC__) || defined(HAVE_LONG_LONG)
PRINT_TYPE(long long);
#else
- PRINT_TYPE(long); /* Fake it and hope for the best. */
+ PRINT_TYPE(long); /* Fake it and hope for the best. */
#endif
break;
} /* End of switch (wide_width) */
#if defined(__GNUC__) || defined(HAVE_LONG_DOUBLE)
PRINT_TYPE(long double);
#else
- PRINT_TYPE(double); /* Fake it and hope for the best. */
+ PRINT_TYPE(double); /* Fake it and hope for the best. */
#endif
}
}
}
/* Given a SET, calculate the amount of stack adjustment it
- contains. */
+ contains. */
static long
stack_adjust_offset (pattern)
|| GET_CODE (PATTERN (insn)) == SEQUENCE)
{
/* There may be stack adjustments inside compound insns. Search
- for them. */
+ for them. */
int j;
offset = 0;
/* Location lists are ranges + location descriptions for that range,
so you can track variables that are in different places over
- their entire life. */
+ their entire life. */
typedef struct dw_loc_list_struct
{
dw_loc_list_ref dw_loc_next;
/* Return a new location list, given the begin and end range, and the
expression. gensym tells us whether to generate a new internal
symbol for this location list node, which is done for the head of
- the list only. */
+ the list only. */
static inline dw_loc_list_ref
new_loc_list (expr, begin, end, section, gensym)
register dw_loc_descr_ref expr;
{
register dw_loc_list_ref *d;
- /* Find the end of the chain. */
+ /* Find the end of the chain. */
for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
;
/* Add a new location list node to the list */
}
}
-/* Record the beginning of a new source file. */
+/* Record the beginning of a new source file. */
static void
dwarf2out_start_source_file (lineno, filename)
/* Output location list section if necessary. */
if (have_location_lists)
{
- /* Output the location lists info. */
+ /* Output the location lists info. */
named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG, 1);
output_location_lists (die);
have_location_lists = 0;
output_ranges ();
}
- /* Have to end the primary source file. */
+ /* Have to end the primary source file. */
if (debug_info_level >= DINFO_LEVEL_VERBOSE)
{
named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG, 1);
comprehend that a missing upper bound specification in a
array type used for a storage class `auto' local array variable
indicates that the upper bound is both unknown (at compile-
- time) and unknowable (at run-time) due to optimization. */
+ time) and unknowable (at run-time) due to optimization. */
if (! optimize)
{
The value we deduce is then used (by the callers of this routine) to
generate AT_location and AT_bit_offset attributes for fields (both
- bit-fields and, in the case of AT_location, regular fields as well). */
+ bit-fields and, in the case of AT_location, regular fields as well). */
/* Figure out the bit-distance from the start of the structure to the
"deepest" bit of the bit-field. */
/* Generate a SUBREG representing the least-significant part
* of REG if MODE is smaller than mode of REG, otherwise
- * paradoxical SUBREG. */
+ * paradoxical SUBREG. */
rtx
gen_lowpart_SUBREG (mode, reg)
enum machine_mode mode;
if (mode == VOIDmode)
abort ();
- /* If OP is narrower than a word, fail. */
+ /* If OP is narrower than a word, fail. */
if (mode != BLKmode
&& (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
return 0;
- /* If we want a word outside OP, return zero. */
+ /* If we want a word outside OP, return zero. */
if (mode != BLKmode
&& (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
return const0_rtx;
}
/* Go through all virtual stack slots of a function and mark them as
- not shared. */
+ not shared. */
static void
reset_used_decls (blk)
tree blk;
}
/* Place a note of KIND on insn INSN with DATUM as the datum. If a
- note of this type already exists, remove it first. */
+ note of this type already exists, remove it first. */
void
set_unique_reg_note (insn, kind, datum)
if (len == 1
&& ! RTX_FRAME_RELATED_P (first_insn)
&& GET_CODE (first_insn) == INSN
- /* Don't throw away any reg notes. */
+ /* Don't throw away any reg notes. */
&& REG_NOTES (first_insn) == 0)
return PATTERN (first_insn);
expand_builtin_unwind_init ()
{
/* Set this so all the registers get saved in our frame; we need to be
- able to copy the saved values for any registers from frames we unwind. */
+ able to copy the saved values for any registers from frames we unwind. */
current_function_has_nonlocal_label = 1;
#ifdef SETUP_FRAME_ADDRESSES
MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
/* If we are making an object of this type, we know that it is a scalar if
- the type is not an aggregate. */
+ the type is not an aggregate. */
if (objectp && ! AGGREGATE_TYPE_P (type))
MEM_SCALAR_P (ref) = 1;
otherwise 0.
OUTGOING is 1 if on a machine with register windows this function
should return the register in which the function will put its result
- and 0 otherwise. */
+ and 0 otherwise. */
rtx
hard_function_value (valtype, func, outgoing)
/* Note that ABS doesn't yield a positive number for INT_MIN, but
that is compensated by the subsequent overflow when subtracting
- one / negating. */
+ one / negating. */
if (abs_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
tem = expand_unop (mode, abs_optab, op0, subtarget, 1);
case LABELED_BLOCK_EXPR:
if (LABELED_BLOCK_BODY (exp))
expand_expr_stmt (LABELED_BLOCK_BODY (exp));
- /* Should perhaps use expand_label, but this is simpler and safer. */
+ /* Should perhaps use expand_label, but this is simpler and safer. */
do_pending_stack_adjust ();
emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
return const0_rtx;
if (e1->flags & EDGE_COMPLEX)
return false;
- /* Look for the common insn sequence, part the first ... */
+ /* Look for the common insn sequence, part the first ... */
if (!outgoing_edges_match (src1, src2))
return false;
If so, this memory write is dead (remember, we're walking
backwards from the end of the block to the start). Since
rtx_equal_p does not check the alias set or flags, we also
- must have the potential for them to conflict (anti_dependence). */
+ must have the potential for them to conflict (anti_dependence). */
for (temp = pbi->mem_set_list; temp != 0; temp = XEXP (temp, 1))
if (anti_dependence (r, XEXP (temp, 0)))
{
for (i = n_basic_blocks - 1; i >= 0; i--)
{
basic_block bb = BASIC_BLOCK (i);
- /* Check correctness of edge lists. */
+ /* Check correctness of edge lists. */
edge e;
int has_fallthru = 0;
/* Count number of edges along trace from loop header to
root of pre-header extended basic block. Usually this is
- only one or two edges. */
+ only one or two edges. */
num++;
while (ebb->pred->src != ENTRY_BLOCK_PTR && ! ebb->pred->pred_next)
{
*conp = 0;
*litp = 0;
- /* Strip any conversions that don't change the machine mode or signedness. */
+ /* Strip any conversions that don't change the machine mode or signedness. */
STRIP_SIGN_NOPS (in);
if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
*conp = op1, neg_conp_p = neg1_p, op1 = 0;
/* If we haven't dealt with either operand, this is not a case we can
- decompose. Otherwise, VAR is either of the ones remaining, if any. */
+ decompose. Otherwise, VAR is either of the ones remaining, if any. */
if (op0 != 0 && op1 != 0)
var = in;
else if (op0 != 0)
break;
}
- /* ... fall through ... */
+ /* ... fall through ... */
case ROUND_DIV_EXPR:
if (int2h == 0 && int2l == 1)
break;
}
- /* ... fall through ... */
+ /* ... fall through ... */
case ROUND_MOD_EXPR:
overflow = div_and_round_double (code, uns,
args.code = code;
if (do_float_handler (const_binop_1, (PTR) &args))
- /* Receive output from const_binop_1. */
+ /* Receive output from const_binop_1. */
t = args.t;
else
{
- /* We got an exception from const_binop_1. */
+ /* We got an exception from const_binop_1. */
t = copy_node (arg1);
overflow = 1;
}
/* This structure is used to communicate arguments to fold_convert_1. */
struct fc_args
{
- tree arg1; /* Input: value to convert. */
- tree type; /* Input: type to convert value to. */
- tree t; /* Ouput: result of conversion. */
+ tree arg1; /* Input: value to convert. */
+ tree type; /* Input: type to convert value to. */
+ tree t; /* Ouput: result of conversion. */
};
/* Function to convert floating-point constants, protected by floating
case 'r':
/* If either of the pointer (or reference) expressions we are dereferencing
- contain a side effect, these cannot be equal. */
+ contain a side effect, these cannot be equal. */
if (TREE_SIDE_EFFECTS (arg0)
|| TREE_SIDE_EFFECTS (arg1))
return 0;
the same. But, this is computer arithmetic, where numbers are finite.
We can therefore make the transformation of any unbounded range with
the value Z, Z being greater than any representable number. This permits
- us to treat unbounded ranges as equal. */
+ us to treat unbounded ranges as equal. */
sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
switch (code)
/* The last case is if we are a multiply. In that case, we can
apply the distributive law to commute the multiply and addition
- if the multiplication of the constants doesn't overflow. */
+ if the multiplication of the constants doesn't overflow. */
if (code == MULT_EXPR)
return fold (build (tcode, ctype, fold (build (code, ctype,
convert (ctype, op0),
&& integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
return omit_one_operand (type, integer_zero_node, op0);
- /* ... fall through ... */
+ /* ... fall through ... */
case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR: case EXACT_DIV_EXPR:
associate each group together, the constants with literals,
then the result with variables. This increases the chances of
literals being recombined later and of generating relocatable
- expressions for the sum of a constant and literal. */
+ expressions for the sum of a constant and literal. */
var0 = split_tree (arg0, code, &con0, &lit0, 0);
var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
&& 0 != (tem = const_binop (code, build_real (type, dconst1),
arg1, 0)))
return fold (build (MULT_EXPR, type, arg0, tem));
- /* Find the reciprocal if optimizing and the result is exact. */
+ /* Find the reciprocal if optimizing and the result is exact. */
else if (optimize)
{
REAL_VALUE_TYPE r;
truth and/or operations and the transformation will still be
valid. Also note that we only care about order for the
ANDIF and ORIF operators. If B contains side effects, this
- might change the truth-value of A. */
+ might change the truth-value of A. */
if (TREE_CODE (arg0) == TREE_CODE (arg1)
&& (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
|| TREE_CODE (arg0) == TRUTH_ORIF_EXPR
< TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
return 0;
- /* .. fall through ... */
+ /* .. fall through ... */
case SAVE_EXPR:
return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
alias set for the memory. */
set_mem_alias_set (p->slot, type ? get_alias_set (type) : 0);
- /* If a type is specified, set the relevant flags. */
+ /* If a type is specified, set the relevant flags. */
if (type != 0)
{
RTX_UNCHANGING_P (p->slot) = TYPE_READONLY (type);
/* Given a trampoline address, round it then apply any
platform-specific adjustments so that the result can be used for a
- function call . */
+ function call . */
static rtx
adjust_trampoline_addr (tramp)
projects / thirdparty / gcc.git / commitdiff
