+2002-05-09 Kazu Hirata <kazu@cs.umass.edu>
+
+ * sbitmap.c: Fix formatting.
+ * scan.c: Likewise.
+ * scan-decls.c: Likewise.
+ * sched-deps.c: Likewise.
+ * sched-ebb.c: Likewise.
+ * sched-rgn.c: Likewise.
+ * sched-vis.c: Likewise.
+ * sdbout.c: Likewise.
+ * sibcall.c: Likewise.
+ * simplify-rtx.c: Likewise.
+ * ssa.c: Likewise.
+ * ssa-ccp.c: Likewise.
+ * ssa-dce.c: Likewise.
+ * stmt.c: Likewise.
+ * stor-layout.c: Likewise.
+ * stringpool.c: Likewise.
+
2002-05-09 David S. Miller <davem@redhat.com>
* config/sparc/sol2.h (ASM_CPU_SPEC): Handle -mcpu=v9.
/* Simple bitmaps.
- Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2002 Free Software Foundation, Inc.
This file is part of GCC.
sbitmap_ptr dstp = dst->elms;
sbitmap_ptr ap = a->elms;
sbitmap_ptr bp = b->elms;
-
+
for (i = 0; i < n; i++)
*dstp++ = *ap++ & ~*bp++;
}
for (e = b->succ; e != 0; e = e->succ_next)
{
if (e->dest == EXIT_BLOCK_PTR)
- continue;
+ continue;
sbitmap_copy (dst, src[e->dest->index]);
break;
for (e = b->pred; e != 0; e = e->pred_next)
{
if (e->src == ENTRY_BLOCK_PTR)
- continue;
+ continue;
sbitmap_copy (dst, src[e->src->index]);
break;
for (e = b->succ; e != 0; e = e->succ_next)
{
if (e->dest == EXIT_BLOCK_PTR)
- continue;
+ continue;
sbitmap_copy (dst, src[e->dest->index]);
break;
for (e = b->pred; e != 0; e = e->pred_next)
{
if (e->src== ENTRY_BLOCK_PTR)
- continue;
+ continue;
sbitmap_copy (dst, src[e->src->index]);
break;
if (e->src == ENTRY_BLOCK_PTR)
continue;
-
+
p = src[e->src->index]->elms;
r = dst->elms;
for (i = 0; i < set_size; i++)
/* This function scans a C source file (actually, the output of cpp),
reading from FP. It looks for function declarations, and
- external variable declarations.
+ external variable declarations.
The following grammar (as well as some extra stuff) is recognized:
/* ... fall through ... */
case CPP_OPEN_BRACE: case CPP_CLOSE_BRACE:
goto new_statement;
-
+
case CPP_EOF:
return 0;
if (new_size <= cur_size)
return;
-
+
str->base = xrealloc (str->base, new_size);
str->ptr = str->base + cur_size;
str->limit = str->base + new_size;
s = src->base;
while (--count >= 0) *d++ = *s++;
dst->ptr = d;
- *d = 0;
+ *d = 0;
}
int
else if (TEST_BIT (output_dependency_cache[INSN_LUID (insn)],
INSN_LUID (elem)))
present_dep_type = REG_DEP_OUTPUT;
- else
+ else
present_p = 0;
if (present_p && (int) dep_type >= (int) present_dep_type)
return;
one, then change the existing dependence to this type. */
if ((int) dep_type < (int) REG_NOTE_KIND (link))
PUT_REG_NOTE_KIND (link, dep_type);
-
+
#ifdef INSN_SCHEDULING
/* If we are adding a dependency to INSN's LOG_LINKs, then
note that in the bitmap caches of dependency information. */
}
/* If this instruction can throw an exception, then moving it changes
- where block boundaries fall. This is mighty confusing elsewhere.
+ where block boundaries fall. This is mighty confusing elsewhere.
Therefore, prevent such an instruction from being moved. */
if (can_throw_internal (insn))
reg_pending_barrier = true;
/* Instruction scheduling pass.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
/* Schedule every region in the subroutine. */
for (i = 0; i < n_basic_blocks; i++)
- {
+ {
rtx head = BASIC_BLOCK (i)->head;
rtx tail;
/* Update_loop_relations(blk, hdr): Check if the loop headed by max_hdr[blk]
is still an inner loop. Put in max_hdr[blk] the header of the most inner
loop containing blk. */
-#define UPDATE_LOOP_RELATIONS(blk, hdr) \
-{ \
- if (max_hdr[blk] == -1) \
- max_hdr[blk] = hdr; \
- else if (dfs_nr[max_hdr[blk]] > dfs_nr[hdr]) \
- RESET_BIT (inner, hdr); \
- else if (dfs_nr[max_hdr[blk]] < dfs_nr[hdr]) \
- { \
- RESET_BIT (inner,max_hdr[blk]); \
- max_hdr[blk] = hdr; \
- } \
+#define UPDATE_LOOP_RELATIONS(blk, hdr) \
+{ \
+ if (max_hdr[blk] == -1) \
+ max_hdr[blk] = hdr; \
+ else if (dfs_nr[max_hdr[blk]] > dfs_nr[hdr]) \
+ RESET_BIT (inner, hdr); \
+ else if (dfs_nr[max_hdr[blk]] < dfs_nr[hdr]) \
+ { \
+ RESET_BIT (inner,max_hdr[blk]); \
+ max_hdr[blk] = hdr; \
+ } \
}
/* Find regions for interblock scheduling.
if (CONTAINING_RGN (TO_BLOCK (nxt_out_edge)) !=
CONTAINING_RGN (BB_TO_BLOCK (bb)))
++nr_rgn_out_edges;
- SET_BIT (pot_split[bb], EDGE_TO_BIT (nxt_out_edge));
+ SET_BIT (pot_split[bb], EDGE_TO_BIT (nxt_out_edge));
nxt_out_edge = NEXT_OUT (nxt_out_edge);
}
/* Non-zero if block bb_to is equal to, or reachable from block bb_from. */
#define IS_REACHABLE(bb_from, bb_to) \
-(bb_from == bb_to \
+ (bb_from == bb_to \
|| IS_RGN_ENTRY (bb_from) \
- || (TEST_BIT (ancestor_edges[bb_to], \
- EDGE_TO_BIT (IN_EDGES (BB_TO_BLOCK (bb_from))))))
+ || (TEST_BIT (ancestor_edges[bb_to], \
+ EDGE_TO_BIT (IN_EDGES (BB_TO_BLOCK (bb_from))))))
/* Non-zero iff the address is comprised from at most 1 register. */
#define CONST_BASED_ADDRESS_P(x) \
(GET_CODE (x) == REG \
- || ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS \
- || (GET_CODE (x) == LO_SUM)) \
- && (CONSTANT_P (XEXP (x, 0)) \
+ || ((GET_CODE (x) == PLUS || GET_CODE (x) == MINUS \
+ || (GET_CODE (x) == LO_SUM)) \
+ && (CONSTANT_P (XEXP (x, 0)) \
|| CONSTANT_P (XEXP (x, 1)))))
/* Turns on the fed_by_spec_load flag for insns fed by load_insn. */
succ_deps->last_pending_memory_flush
= concat_INSN_LIST (pred_deps->last_pending_memory_flush,
succ_deps->last_pending_memory_flush);
-
+
succ_deps->pending_lists_length += pred_deps->pending_lists_length;
succ_deps->pending_flush_length += pred_deps->pending_flush_length;
INSN_DEP_COUNT (insn),
INSN_PRIORITY (insn),
insn_cost (insn, 0, 0));
-
+
if (recog_memoized (insn) < 0)
fprintf (sched_dump, "nothing");
else
init_regions ();
current_sched_info = ®ion_sched_info;
-
+
/* Schedule every region in the subroutine. */
for (rgn = 0; rgn < nr_regions; rgn++)
schedule_region (rgn);
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
- && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
- {
+ && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
+ {
t1[0] = '!';
print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
}
else
- print_value (t1, COND_EXEC_TEST (x), verbose);
+ print_value (t1, COND_EXEC_TEST (x), verbose);
print_pattern (t2, COND_EXEC_CODE (x), verbose);
sprintf (buf, "(%s) %s", t1, t2);
break;
if (!DECL_RTL_SET_P (decl))
return;
- SET_DECL_RTL (decl,
+ SET_DECL_RTL (decl,
eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
if (TREE_PUBLIC (decl))
{
PUT_SDB_VAL (XEXP (value, 0));
- PUT_SDB_SCL (C_EXT);
+ PUT_SDB_SCL (C_EXT);
}
else
{
PUT_SDB_VAL (XEXP (value, 0));
- PUT_SDB_SCL (C_STAT);
+ PUT_SDB_SCL (C_STAT);
}
}
else if (regno >= 0)
if (DECL_NAME (t) && IDENTIFIER_POINTER (DECL_NAME (t)) != 0
&& !strcmp (IDENTIFIER_POINTER (DECL_NAME (t)), "__vtbl_ptr_type"))
sdbout_symbol (t, 0);
-#endif
+#endif
#ifdef SDB_ALLOW_FORWARD_REFERENCES
ggc_add_tree_root (&anonymous_types, 1);
/* If we didn't get a single hard register (e.g. a parallel), give up. */
if (GET_CODE (hard) != REG)
return 0;
-
+
/* Stack adjustment done after call may appear here. */
insn = skip_stack_adjustment (insn);
if (! insn)
insn = NEXT_INSN (insn);
if (! insn)
return 0;
-
+
/* We're looking for a source of the hard return register. */
set = single_set (insn);
if (! set || SET_SRC (set) != hard)
/* The destination must be the same as the called function's return
value to ensure that any return value is put in the same place by the
- current function and the function we're calling.
+ current function and the function we're calling.
Further, the source must be the same as the pseudo into which the
called function's return value was copied. Otherwise we're returning
pass above from deleting it as unused. */
if (XEXP (PATTERN (insn), 3))
LABEL_PRESERVE_P (XEXP (PATTERN (insn), 3)) = 0;
-
+
/* "Delete" the placeholder insn. */
remove_insn (insn);
}
if (n_basic_blocks == 0)
return;
- /* If we are using sjlj exceptions, we may need to add a call to
+ /* If we are using sjlj exceptions, we may need to add a call to
_Unwind_SjLj_Unregister at exit of the function. Which means
that we cannot do any sibcall transformations. */
if (USING_SJLJ_EXCEPTIONS && current_function_has_exception_handlers ())
sibling call optimizations, but not tail recursion.
Similarly if we use varargs or stdarg since they implicitly
may take the address of an argument. */
- if (current_function_calls_alloca
+ if (current_function_calls_alloca
|| current_function_varargs || current_function_stdarg)
sibcall = 0;
successful_sibling_call = 1;
replaced_call_placeholder = 1;
- replace_call_placeholder (insn,
- tailrecursion != 0
+ replace_call_placeholder (insn,
+ tailrecursion != 0
? sibcall_use_tail_recursion
: sibcall != 0
? sibcall_use_sibcall
tree arg;
/* A sibling call sequence invalidates any REG_EQUIV notes made for
- this function's incoming arguments.
+ this function's incoming arguments.
At the start of RTL generation we know the only REG_EQUIV notes
in the rtl chain are those for incoming arguments, so we can safely
- flush any REG_EQUIV note.
+ flush any REG_EQUIV note.
This is (slight) overkill. We could keep track of the highest
argument we clobber and be more selective in removing notes, but it
/* A sibling call sequence also may invalidate RTX_UNCHANGING_P
flag of some incoming arguments MEM RTLs, because it can write into
those slots. We clear all those bits now.
-
+
This is (slight) overkill, we could keep track of which arguments
we actually write into. */
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
/* Similarly, invalidate RTX_UNCHANGING_P for any incoming
arguments passed in registers. */
- for (arg = DECL_ARGUMENTS (current_function_decl);
- arg;
+ for (arg = DECL_ARGUMENTS (current_function_decl);
+ arg;
arg = TREE_CHAIN (arg))
{
if (REG_P (DECL_RTL (arg)))
}
}
- /* There may have been NOTE_INSN_BLOCK_{BEGIN,END} notes in the
+ /* There may have been NOTE_INSN_BLOCK_{BEGIN,END} notes in the
CALL_PLACEHOLDER alternatives that we didn't emit. Rebuild the
lexical block tree to correspond to the notes that still exist. */
if (replaced_call_placeholder)
virtual regs here because the simplify_*_operation routines are called
by integrate.c, which is called before virtual register instantiation.
- ?!? FIXED_BASE_PLUS_P and NONZERO_BASE_PLUS_P need to move into
+ ?!? FIXED_BASE_PLUS_P and NONZERO_BASE_PLUS_P need to move into
a header file so that their definitions can be shared with the
simplification routines in simplify-rtx.c. Until then, do not
change these macros without also changing the copy in simplify-rtx.c. */
}
\f
-/* Make a binary operation by properly ordering the operands and
+/* Make a binary operation by properly ordering the operands and
seeing if the expression folds. */
rtx
rtx op0 = simplify_replace_rtx (XEXP (x, 0), old, new);
return
- simplify_gen_ternary (code, mode,
+ simplify_gen_ternary (code, mode,
(op_mode != VOIDmode
? op_mode
: GET_MODE (op0)),
return convert_memory_address (Pmode, op);
break;
#endif
-
+
default:
break;
}
}
/* If one of the operands is a PLUS or a MINUS, see if we can
- simplify this by the associative law.
+ simplify this by the associative law.
Don't use the associative law for floating point.
The inaccuracy makes it nonassociative,
and subtle programs can break if operations are associated. */
#endif
return xop00;
}
- break;
+ break;
case MINUS:
/* We can't assume x-x is 0 even with non-IEEE floating point,
return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
/* If one of the operands is a PLUS or a MINUS, see if we can
- simplify this by the associative law.
+ simplify this by the associative law.
Don't use the associative law for floating point.
The inaccuracy makes it nonassociative,
and subtle programs can break if operations are associated. */
if (! REAL_VALUES_EQUAL (d, dconst0))
{
REAL_ARITHMETIC (d, rtx_to_tree_code (DIV), dconst1, d);
- return gen_rtx_MULT (mode, op0,
+ return gen_rtx_MULT (mode, op0,
CONST_DOUBLE_FROM_REAL_VALUE (d, mode));
}
}
break;
case SMIN:
- if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (trueop1) == CONST_INT
+ if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (trueop1) == CONST_INT
&& INTVAL (trueop1) == (HOST_WIDE_INT) 1 << (width -1)
&& ! side_effects_p (op0))
return op1;
else if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
return op0;
break;
-
+
case SMAX:
if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (trueop1) == CONST_INT
&& ((unsigned HOST_WIDE_INT) INTVAL (trueop1)
else if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
return op0;
break;
-
+
case UMAX:
if (trueop1 == constm1_rtx && ! side_effects_p (op0))
return op1;
default:
abort ();
}
-
+
return 0;
}
Rather than test for specific case, we do this by a brute-force method
and do all possible simplifications until no more changes occur. Then
- we rebuild the operation.
+ we rebuild the operation.
- If FORCE is true, then always generate the rtx. This is used to
+ If FORCE is true, then always generate the rtx. This is used to
canonicalize stuff emitted from simplify_gen_binary. Note that this
can still fail if the rtx is too complex. It won't fail just because
the result is not 'simpler' than the input, however. */
int i, j;
memset ((char *) ops, 0, sizeof ops);
-
+
/* Set up the two operands and then expand them until nothing has been
changed. If we run out of room in our array, give up; this should
almost never happen. */
tem = simplify_binary_operation (ncode, mode, lhs, rhs);
- /* Reject "simplifications" that just wrap the two
+ /* Reject "simplifications" that just wrap the two
arguments in a CONST. Failure to do so can result
in infinite recursion with simplify_binary_operation
when it calls us to simplify CONST operations. */
is also an improvement, so accept it. */
if (!force
&& (n_ops + n_consts > input_ops
- || (n_ops + n_consts == input_ops && n_consts <= input_consts)))
+ || (n_ops + n_consts == input_ops && n_consts <= input_consts)))
return NULL_RTX;
/* Put a non-negated operand first. If there aren't any, make all
l0u = l0s = INTVAL (trueop0);
h0u = h0s = HWI_SIGN_EXTEND (l0s);
}
-
+
if (GET_CODE (trueop1) == CONST_DOUBLE)
{
l1u = l1s = CONST_DOUBLE_LOW (trueop1);
&& INTEGRAL_MODE_P (mode))
return const0_rtx;
break;
-
+
default:
break;
}
{
HOST_WIDE_INT t = INTVAL (op1);
HOST_WIDE_INT f = INTVAL (op2);
-
+
if (t == STORE_FLAG_VALUE && f == 0)
code = GET_CODE (op0);
else if (t == 0 && f == STORE_FLAG_VALUE)
val = part ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op);
offset %= HOST_BITS_PER_WIDE_INT;
- /* We've already picked the word we want from a double, so
+ /* We've already picked the word we want from a double, so
pretend this is actually an integer. */
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
maintain and improve. It's totally silly that when we add a
simplification that it needs to be added to 4 places (3 for RTL
simplification and 1 for tree simplification. */
-
+
rtx
simplify_rtx (x)
rtx x;
case 'x':
/* The only case we try to handle is a SUBREG. */
if (code == SUBREG)
- return simplify_gen_subreg (mode, SUBREG_REG (x),
+ return simplify_gen_subreg (mode, SUBREG_REG (x),
GET_MODE (SUBREG_REG (x)),
SUBREG_BYTE (x));
return NULL;
Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
Original framework by Daniel Berlin <dan@cgsoftware.com>
Fleshed out and major cleanups by Jeff Law <law@redhat.com>
-
+
This file is part of GCC.
-
+
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
-
+
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
-
+
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
5. Another simple SSA DCE pass to remove dead code exposed
by CCP.
- When we exit, we are still in SSA form.
+ When we exit, we are still in SSA form.
Potential further enhancements:
VARYING
} latticevalue;
-/* Main structure for CCP.
+/* Main structure for CCP.
Contains the lattice value and, if it's a constant, the constant
value. */
/* If the current value of PHI_NODE is UNDEFINED and one
node in PHI_NODE is CONSTANT, then the new value of the
PHI is that CONSTANT. Note this can turn into VARYING
- if we find another distinct constant later. */
+ if we find another distinct constant later. */
if (phi_node_lattice_val == UNDEFINED
&& phi_node_expr == NULL
&& current_parm_lattice_val == CONSTANT)
}
/* Hard registers are not put in SSA form and thus we must consider
- them varying. All the more reason to avoid hard registers in
+ them varying. All the more reason to avoid hard registers in
RTL until as late as possible in the compilation. */
if (GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER)
{
rtx simplified = NULL;
/* We've got some kind of INSN. If it's simple, try to evaluate
- it and record the results.
+ it and record the results.
We already know this insn is a single_set and that it sets
a pseudo register. So we just need to extract the source
defs_to_undefined (insn);
break;
}
-
+
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
defs_to_undefined (insn);
break;
}
-
+
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
defs_to_undefined (insn);
break;
}
-
+
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
src0, src1, src2);
break;
}
-
+
default:
defs_to_varying (insn);
}
values[REGNO (dest)].const_value = simplified;
}
else
- defs_to_varying (insn);
+ defs_to_varying (insn);
}
}
currinsn = NEXT_INSN (currinsn);
}
-
+
/* Don't forget the last insn in the block. */
if (INSN_P (currinsn))
visit_expression (currinsn, succ_block);
-
+
/* If we haven't looked at the next block, and it has a
single successor, add it onto the worklist. This is because
if we only have one successor, we know it gets executed,
/* Pick an entry off the worklist (it does not matter which
entry we pick). */
- member = sbitmap_first_set_bit (ssa_edges);
+ member = sbitmap_first_set_bit (ssa_edges);
RESET_BIT (ssa_edges, member);
/* Iterate through all the uses of this entry. */
{
if (TEST_BIT (executable_blocks, BLOCK_NUM (useinsn)))
visit_phi_node (useinsn, BLOCK_FOR_INSN (useinsn));
- }
+ }
else
{
if (TEST_BIT (executable_blocks, BLOCK_NUM (useinsn)))
}
/* Examine each edge to see if we were able to prove any were
- not executable.
+ not executable.
If an edge is not executable, then we can remove its alternative
in PHI nodes as the destination of the edge, we can simplify the
remove_phi_alternative (PATTERN (insn), edge->src);
if (rtl_dump_file)
fprintf (rtl_dump_file,
- "Removing alternative for bb %d of phi %d\n",
+ "Removing alternative for bb %d of phi %d\n",
edge->src->index, SSA_NAME (PATTERN (insn)));
insn = NEXT_INSN (insn);
}
}
}
}
-
+
/* Perform substitution of known values for pseudo registers.
??? Note we do not do simplifications or constant folding here, it
anyway. Consider that if the simplification would result in an
expression that produces a constant value that the value would
have been discovered and recorded already.
-
+
We perform two transformations. First, we initialize pseudos to their
known constant values at their definition point. Second, we try to
replace uses with the known constant value. */
&& (GET_CODE (useinsn) == INSN
|| GET_CODE (useinsn) == JUMP_INSN))
{
-
+
if (validate_replace_src (regno_reg_rtx [i],
values[i].const_value,
useinsn))
{
if (rtl_dump_file)
- fprintf (rtl_dump_file,
+ fprintf (rtl_dump_file,
"Register %d in insn %d replaced with constant\n",
i, INSN_UID (useinsn));
INSN_CODE (useinsn) = -1;
BLOCK_FOR_INSN (useinsn),
useinsn);
}
-
+
}
}
}
for (i = 0; i < VARRAY_SIZE (ssa_definition); i++)
{
if (i < FIRST_PSEUDO_REGISTER)
- values[i].lattice_val = VARYING;
+ values[i].lattice_val = VARYING;
else
values[i].lattice_val = UNDEFINED;
values[i].const_value = NULL;
sbitmap_free (ssa_edges);
ssa_edges = NULL;
-
+
free_edge_list (edges);
edges = NULL;
== NOTE_INSN_DELETED))
|| side_effects_p (PATTERN (VARRAY_RTX (ssa_definition, reg))))
continue;
-
+
/* Iterate over the uses of this register. If we can not find
any uses that have not been deleted, then the definition of
this register is dead. */
/* If we did not find a use of this register, then the definition
of this register is dead. */
-
+
if (! found_use)
{
rtx def = VARRAY_RTX (ssa_definition, reg);
/* Update the use-def chains in the df_analyzer as needed. */
df_analyse (df_analyzer, 0,
- DF_RD_CHAIN | DF_RU_CHAIN | DF_REG_INFO | DF_HARD_REGS);
+ DF_RD_CHAIN | DF_RU_CHAIN | DF_REG_INFO | DF_HARD_REGS);
}
return !0;
else
switch (GET_CODE (x))
- {
+ {
case CALL_INSN:
case BARRIER:
case PREFETCH:
remove_edge (temp);
}
- /* Create an edge from this block to the post dominator.
+ /* Create an edge from this block to the post dominator.
What about the PHI nodes at the target? */
make_edge (bb, pdom_bb, 0);
else if (!JUMP_P (insn))
delete_insn_bb (insn);
});
-
+
/* Remove fake edges from the CFG. */
remove_fake_edges ();
#include "output.h"
#include "ssa.h"
-/* TODO:
+/* TODO:
Handle subregs better, maybe. For now, if a reg that's set in a
subreg expression is duplicated going into SSA form, an extra copy
PARAMS ((int regno, int b));
static void insert_phi_nodes
PARAMS ((sbitmap *idfs, sbitmap *evals, int nregs));
-static void create_delayed_rename
+static void create_delayed_rename
PARAMS ((struct rename_context *, rtx *));
-static void apply_delayed_renames
+static void apply_delayed_renames
PARAMS ((struct rename_context *));
-static int rename_insn_1
+static int rename_insn_1
PARAMS ((rtx *ptr, void *data));
-static void rename_block
+static void rename_block
PARAMS ((int b, int *idom));
-static void rename_registers
+static void rename_registers
PARAMS ((int nregs, int *idom));
static inline int ephi_add_node
PARAMS ((int t, sbitmap visited, sbitmap *pred, sbitmap *succ, rtx *nodes));
static void eliminate_phi
PARAMS ((edge e, partition reg_partition));
-static int make_regs_equivalent_over_bad_edges
+static int make_regs_equivalent_over_bad_edges
PARAMS ((int bb, partition reg_partition));
/* These are used only in the conservative register partitioning
algorithms. */
-static int make_equivalent_phi_alternatives_equivalent
+static int make_equivalent_phi_alternatives_equivalent
PARAMS ((int bb, partition reg_partition));
-static partition compute_conservative_reg_partition
+static partition compute_conservative_reg_partition
PARAMS ((void));
static int record_canonical_element_1
PARAMS ((void **srfp, void *data));
static int check_hard_regs_in_partition
PARAMS ((partition reg_partition));
-static int rename_equivalent_regs_in_insn
+static int rename_equivalent_regs_in_insn
PARAMS ((rtx *ptr, void *data));
/* These are used in the register coalescing algorithm. */
PARAMS ((basic_block bb, partition p, conflict_graph conflicts));
static partition compute_coalesced_reg_partition
PARAMS ((void));
-static int mark_reg_in_phi
+static int mark_reg_in_phi
PARAMS ((rtx *ptr, void *data));
static void mark_phi_and_copy_regs
PARAMS ((regset phi_set));
-static int rename_equivalent_regs_in_insn
+static int rename_equivalent_regs_in_insn
PARAMS ((rtx *ptr, void *data));
-static void rename_equivalent_regs
+static void rename_equivalent_regs
PARAMS ((partition reg_partition));
/* Deal with hard registers. */
}
/* Computing the Dominance Frontier:
-
- As decribed in Morgan, section 3.5, this may be done simply by
+
+ As decribed in Morgan, section 3.5, this may be done simply by
walking the dominator tree bottom-up, computing the frontier for
the children before the parent. When considering a block B,
there are two cases:
}
}
-/* Rename the registers to conform to SSA.
+/* Rename the registers to conform to SSA.
This is essentially the algorithm presented in Figure 7.8 of Morgan,
with a few changes to reduce pattern search time in favour of a bit
{
struct rename_set_data *r;
r = (struct rename_set_data *) xmalloc (sizeof(*r));
-
+
if (GET_CODE (*reg_loc) != REG
|| !CONVERT_REGISTER_TO_SSA_P (REGNO (*reg_loc)))
abort ();
/* This is part of a rather ugly hack to allow the pre-ssa regno to be
reused. If, during processing, a register has not yet been touched,
ssa_rename_to[regno][machno] will be NULL. Now, in the course of pushing
- and popping values from ssa_rename_to, when we would ordinarily
+ and popping values from ssa_rename_to, when we would ordinarily
pop NULL back in, we pop RENAME_NO_RTX. We treat this exactly the
same as NULL, except that it signals that the original regno has
already been reused. */
for (r = c->new_renames; r != NULL; r = r->next)
{
int new_regno;
-
+
/* Failure here means that someone has a PARALLEL that sets
a register twice (bad!). */
if (ssa_rename_to_lookup (r->old_reg) != r->prev_reg)
}
}
-/* Part one of the first step of rename_block, called through for_each_rtx.
+/* Part one of the first step of rename_block, called through for_each_rtx.
Mark pseudos that are set for later update. Transform uses of pseudos. */
static int
(set (subreg (reg foo)) ...)
into
(sequence [(set (reg foo_1) (reg foo))
- (set (subreg (reg foo_1)) ...)])
+ (set (subreg (reg foo_1)) ...)])
FIXME: Much of the time this is too much. For some constructs
we know that the output register is strictly an output
{
rtx i, reg;
reg = dest;
-
+
while (GET_CODE (reg) == STRICT_LOW_PART
|| GET_CODE (reg) == SUBREG
|| GET_CODE (reg) == SIGN_EXTRACT
|| GET_CODE (reg) == ZERO_EXTRACT)
reg = XEXP (reg, 0);
-
+
if (GET_CODE (reg) == REG
&& CONVERT_REGISTER_TO_SSA_P (REGNO (reg)))
{
}
/* Stop traversing. */
return -1;
- }
+ }
else
/* Continue traversing. */
return 0;
/* Step One: Walk the basic block, adding new names for sets and
replacing uses. */
-
+
next = b->head;
last = b->end;
do
{
rtx seq;
int i;
-
+
emit (PATTERN (insn));
seq = gen_sequence ();
/* We really want a SEQUENCE of SETs, not a SEQUENCE
PATTERN (insn) = seq;
}
end_sequence ();
-
+
apply_delayed_renames (&context);
set_data = context.done_renames;
}
next = set_data->next;
free (set_data);
set_data = next;
- }
+ }
}
static void
ssa_rename_to_pseudo = (rtx *) alloca (nregs * sizeof(rtx));
memset ((char *) ssa_rename_to_pseudo, 0, nregs * sizeof(rtx));
- memset ((char *) ssa_rename_to_hard, 0,
+ memset ((char *) ssa_rename_to_hard, 0,
FIRST_PSEUDO_REGISTER * NUM_MACHINE_MODES * sizeof (rtx));
rename_block (0, idom);
- /* ??? Update basic_block_live_at_start, and other flow info
+ /* ??? Update basic_block_live_at_start, and other flow info
as needed. */
ssa_rename_to_pseudo = NULL;
EXECUTE_IF_SET_IN_SBITMAP (succ[t], 0, s,
{
if (! TEST_BIT (visited, s))
- tstack = ephi_forward (s, visited, succ, tstack);
+ tstack = ephi_forward (s, visited, succ, tstack);
});
*tstack++ = t;
int p;
/* Iterate through the predecessor list looking for unvisited nodes.
- If there are any, we have a cycle, and must deal with that. At
+ If there are any, we have a cycle, and must deal with that. At
the same time, look for a visited predecessor. If there is one,
we won't need to create a temporary. */
emit_move_insn (nodes[p], reg_u);
}
});
- }
- else
+ }
+ else
{
/* No cycle. Just copy the value from a successor. */
if (n_nodes == 0)
return;
- /* Build the auxiliary graph R(B).
+ /* Build the auxiliary graph R(B).
The nodes of the graph are the members of the register partition
present in Phi(B). There is an edge from FIND(T0)->FIND(T1) for
reg = regno_reg_rtx[partition_find (reg_partition, REGNO (reg))];
tgt = regno_reg_rtx[partition_find (reg_partition, REGNO (tgt))];
- /* If the two registers are already in the same partition,
+ /* If the two registers are already in the same partition,
nothing will need to be done. */
if (reg != tgt)
{
sbitmap_zero (visited);
- /* As we find a solution to the tsort, collect the implementation
+ /* As we find a solution to the tsort, collect the implementation
insns in a sequence. */
start_sequence ();
-
+
while (tstack != stack)
{
i = *--tstack;
/* For basic block B, consider all phi insns which provide an
alternative corresponding to an incoming abnormal critical edge.
Place the phi alternative corresponding to that abnormal critical
- edge in the same register class as the destination of the set.
+ edge in the same register class as the destination of the set.
From Morgan, p. 178:
- For each abnormal critical edge (C, B),
- if T0 = phi (T1, ..., Ti, ..., Tm) is a phi node in B,
- and C is the ith predecessor of B,
- then T0 and Ti must be equivalent.
+ For each abnormal critical edge (C, B),
+ if T0 = phi (T1, ..., Ti, ..., Tm) is a phi node in B,
+ and C is the ith predecessor of B,
+ then T0 and Ti must be equivalent.
Return non-zero iff any such cases were found for which the two
regs were not already in the same class. */
phi = first_insn_after_basic_block_note (b);
/* Scan all the phi nodes. */
- for (;
+ for (;
PHI_NODE_P (phi);
phi = next_nonnote_insn (phi))
{
rtx tgt = SET_DEST (set);
/* The set target is expected to be an SSA register. */
- if (GET_CODE (tgt) != REG
+ if (GET_CODE (tgt) != REG
|| !CONVERT_REGISTER_TO_SSA_P (REGNO (tgt)))
abort ();
tgt_regno = REGNO (tgt);
continue;
/* The phi alternative is expected to be an SSA register. */
- if (GET_CODE (*alt) != REG
+ if (GET_CODE (*alt) != REG
|| !CONVERT_REGISTER_TO_SSA_P (REGNO (*alt)))
abort ();
alt_regno = REGNO (*alt);
/* If the set destination and the phi alternative aren't
already in the same class... */
- if (partition_find (reg_partition, tgt_regno)
+ if (partition_find (reg_partition, tgt_regno)
!= partition_find (reg_partition, alt_regno))
{
/* ... make them such. */
/* It is illegal to unify a hard register with a
different register. */
abort ();
-
- partition_union (reg_partition,
+
+ partition_union (reg_partition,
tgt_regno, alt_regno);
++changed;
}
phi = first_insn_after_basic_block_note (b);
/* Scan all the phi nodes. */
- for (;
+ for (;
PHI_NODE_P (phi);
phi = next_nonnote_insn (phi))
{
rtx set2 = PATTERN (phi2);
/* The regno of the destination of the set. */
int tgt2_regno = REGNO (SET_DEST (set2));
-
+
/* Are the set destinations equivalent regs? */
if (partition_find (reg_partition, tgt_regno) ==
partition_find (reg_partition, tgt2_regno))
/* If the alternatives aren't already in the same
class ... */
- if (partition_find (reg_partition, REGNO (*alt))
+ if (partition_find (reg_partition, REGNO (*alt))
!= partition_find (reg_partition, REGNO (*alt2)))
{
/* ... make them so. */
a different register. */
abort ();
- partition_union (reg_partition,
+ partition_union (reg_partition,
REGNO (*alt), REGNO (*alt2));
++changed;
}
/* We don't actually work with hard registers, but it's easier to
carry them around anyway rather than constantly doing register
number arithmetic. */
- partition p =
+ partition p =
partition_new (ssa_definition->num_elements);
/* The first priority is to make sure registers that might have to
edges. */
for (bb = n_basic_blocks; --bb >= 0; )
changed += make_regs_equivalent_over_bad_edges (bb, p);
-
+
/* Now we have to insure that corresponding arguments of phi nodes
assigning to corresponding regs are equivalent. Iterate until
nothing changes. */
abnormal critical edges (which isn't possible).
2. Figure out which regs are involved (in the LHS or RHS) of
- copies and phi nodes. Compute conflicts among these regs.
+ copies and phi nodes. Compute conflicts among these regs.
3. Walk around the instruction stream, placing two regs in the
same class of the partition if one appears on the LHS and the
other on the RHS of a copy or phi node and the two regs don't
conflict. The conflict information of course needs to be
- updated.
+ updated.
4. If anything has changed, there may be new opportunities to
coalesce regs, so go back to 2.
/* If REG1 and REG2 don't conflict in CONFLICTS, place them in the
same class of partition P, if they aren't already. Update
- CONFLICTS appropriately.
+ CONFLICTS appropriately.
Returns one if REG1 and REG2 were placed in the same class but were
- not previously; zero otherwise.
+ not previously; zero otherwise.
See Morgan figure 11.15. */
-static int
+static int
coalesce_if_unconflicting (p, conflicts, reg1, reg2)
partition p;
conflict_graph conflicts;
REG2. */
reg1 = partition_find (p, reg1);
reg2 = partition_find (p, reg2);
-
+
/* If they're already in the same class, there's nothing to do. */
if (reg1 == reg2)
return 0;
/* Find the new canonical reg for the merged class. */
reg = partition_find (p, reg1);
-
+
/* Merge conflicts from the two previous classes. */
conflict_graph_merge_regs (conflicts, reg, reg1);
conflict_graph_merge_regs (conflicts, reg, reg2);
/* Coalesce only if the reg modes are the same. As long as
each reg's rtx is unique, it can have only one mode, so two
- pseudos of different modes can't be coalesced into one.
+ pseudos of different modes can't be coalesced into one.
FIXME: We can probably get around this by inserting SUBREGs
where appropriate, but for now we don't bother. */
/* Found a copy; see if we can use the same reg for both the
source and destination (and thus eliminate the copy,
ultimately). */
- changed += coalesce_if_unconflicting (p, conflicts,
+ changed += coalesce_if_unconflicting (p, conflicts,
REGNO (src), REGNO (dest));
}
int src_regno;
void *data;
{
- struct phi_coalesce_context *context =
+ struct phi_coalesce_context *context =
(struct phi_coalesce_context *) data;
-
+
/* Attempt to use the same reg, if they don't conflict. */
- context->changed
- += coalesce_if_unconflicting (context->p, context->conflicts,
+ context->changed
+ += coalesce_if_unconflicting (context->p, context->conflicts,
dest_regno, src_regno);
return 0;
}
/* For each alternative in a phi function corresponding to basic block
BB (in phi nodes in successor block to BB), place the reg in the
phi alternative and the reg to which the phi value is set into the
- same class in partition P, if allowed by CONFLICTS.
+ same class in partition P, if allowed by CONFLICTS.
Return the number of changes that were made to P.
-
+
See Morgan figure 11.14. */
static int
}
/* Compute and return a partition of pseudos. Where possible,
- non-conflicting pseudos are placed in the same class.
+ non-conflicting pseudos are placed in the same class.
The caller is responsible for deallocating the returned partition. */
regset_head phi_set_head;
regset phi_set = &phi_set_head;
- partition p =
+ partition p =
partition_new (ssa_definition->num_elements);
/* The first priority is to make sure registers that might have to
{
basic_block block = BASIC_BLOCK (bb);
changed += coalesce_regs_in_copies (block, p, conflicts);
- changed +=
+ changed +=
coalesce_regs_in_successor_phi_nodes (block, p, conflicts);
}
unsigned int new_regno = partition_find (reg_partition, regno);
rtx canonical_element_rtx = ssa_rename_from_lookup (new_regno);
- if (canonical_element_rtx != NULL_RTX &&
+ if (canonical_element_rtx != NULL_RTX &&
HARD_REGISTER_P (canonical_element_rtx))
{
if (REGNO (canonical_element_rtx) != regno)
((struct ssa_rename_from_hash_table_data *) data)->canonical_elements;
partition reg_partition =
((struct ssa_rename_from_hash_table_data *) data)->reg_partition;
-
+
SET_BIT (canonical_elements, partition_find (reg_partition, reg));
return 1;
}
insn = next;
if (INSN_P (insn))
{
- for_each_rtx (&PATTERN (insn),
- rename_equivalent_regs_in_insn,
+ for_each_rtx (&PATTERN (insn),
+ rename_equivalent_regs_in_insn,
reg_partition);
- for_each_rtx (®_NOTES (insn),
- rename_equivalent_regs_in_insn,
+ for_each_rtx (®_NOTES (insn),
+ rename_equivalent_regs_in_insn,
reg_partition);
if (GET_CODE (PATTERN (insn)) == SEQUENCE)
/* Need global_live_at_{start,end} up to date. There should not be
any significant dead code at this point, except perhaps dead
- stores. So do not take the time to perform dead code elimination.
+ stores. So do not take the time to perform dead code elimination.
Register coalescing needs death notes, so generate them. */
life_analysis (insns, NULL, PROP_DEATH_NOTES);
/* If we've reached the end of the block, stop. */
else if (insn == BLOCK_END (bb))
break;
- else
+ else
insn = NEXT_INSN (insn);
}
}
void *data;
{
edge e;
-
+
if (bb == EXIT_BLOCK_PTR)
return 0;
rtx insn;
basic_block successor = e->dest;
- if (successor == ENTRY_BLOCK_PTR
+ if (successor == ENTRY_BLOCK_PTR
|| successor == EXIT_BLOCK_PTR)
continue;
rtx phi_set = PATTERN (insn);
rtx *alternative = phi_alternative (phi_set, bb->index);
rtx phi_src;
-
+
/* This phi function may not have an alternative
corresponding to the incoming edge, indicating the
assigned variable is not defined along the edge. */
phi_src = *alternative;
/* Invoke the callback. */
- result = (*fn) (insn, REGNO (SET_DEST (phi_set)),
+ result = (*fn) (insn, REGNO (SET_DEST (phi_set)),
REGNO (phi_src), data);
/* Terminate if requested. */
return 1;
if (!HARD_REGISTER_NUM_P (orig_reg1) && HARD_REGISTER_NUM_P (orig_reg2))
return 1;
-
+
return 0;
}
ggc_mark_tree (n->data.block.cleanups);
ggc_mark_tree (n->data.block.outer_cleanups);
- for (l = n->data.block.label_chain; l != NULL; l = l->next)
+ for (l = n->data.block.label_chain; l != NULL; l = l->next)
{
ggc_mark (l);
ggc_mark_tree (l->label);
emit_indirect_jump (handler_slot);
}
- /* Search backwards to the jump insn and mark it as a
+ /* Search backwards to the jump insn and mark it as a
non-local goto. */
for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
{
as a placeholder. */
{
- rtx original_before_jump
- = last_insn ? last_insn : get_last_insn ();
+ rtx original_before_jump
+ = last_insn ? last_insn : get_last_insn ();
rtx start;
rtx end;
tree block;
= block;
}
- start_sequence ();
- start = emit_note (NULL, NOTE_INSN_BLOCK_BEG);
+ start_sequence ();
+ start = emit_note (NULL, NOTE_INSN_BLOCK_BEG);
if (cfun->x_whole_function_mode_p)
NOTE_BLOCK (start) = block;
fixup->before_jump = emit_note (NULL, NOTE_INSN_DELETED);
end = emit_note (NULL, NOTE_INSN_BLOCK_END);
if (cfun->x_whole_function_mode_p)
NOTE_BLOCK (end) = block;
- fixup->context = block;
- end_sequence ();
- emit_insns_after (start, original_before_jump);
+ fixup->context = block;
+ end_sequence ();
+ emit_insns_after (start, original_before_jump);
}
fixup->block_start_count = current_block_start_count;
case '=':
error ("operand constraint contains incorrectly positioned '+' or '='");
return false;
-
+
case '%':
if (operand_num + 1 == ninputs + noutputs)
{
*allows_reg = true;
*allows_mem = true;
break;
-
+
case 'p': case 'r':
*allows_reg = true;
break;
OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
Each output or input has an expression in the TREE_VALUE and
and a tree list in TREE_PURPOSE which in turn contains a constraint
- name in TREE_VALUE (or NULL_TREE) and a constraint string
+ name in TREE_VALUE (or NULL_TREE) and a constraint string
in TREE_PURPOSE.
CLOBBERS is a list of STRING_CST nodes each naming a hard register
that is clobbered by this insn.
if ((! allows_mem && GET_CODE (output_rtx[i]) == MEM)
|| GET_CODE (output_rtx[i]) == CONCAT)
{
- real_output_rtx[i] = protect_from_queue (output_rtx[i], 1);
+ real_output_rtx[i] = protect_from_queue (output_rtx[i], 1);
output_rtx[i] = gen_reg_rtx (GET_MODE (output_rtx[i]));
if (is_inout)
emit_move_insn (output_rtx[i], real_output_rtx[i]);
body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
: GET_MODE (output_rtx[0])),
- TREE_STRING_POINTER (string),
+ TREE_STRING_POINTER (string),
empty_string, 0, argvec, constraintvec,
filename, line);
/* A subroutine of resolve_operand_names. P points to the '[' for a
potential named operand of the form [<name>]. In place, replace
- the name and brackets with a number. Return a pointer to the
+ the name and brackets with a number. Return a pointer to the
balance of the string after substitution. */
static char *
the end of the entry condtional. Without this, our lexical scan
can't tell the difference between an entry conditional and a
body conditional that exits the loop. Mistaking the two means
- that we can misplace the NOTE_INSN_LOOP_CONT note, which can
+ that we can misplace the NOTE_INSN_LOOP_CONT note, which can
screw up loop unrolling.
Things will be oh so much better when loop optimization is done
/* Likewise for debug scopes. In this case we'll either (1) move
all of the notes if they are properly nested or (2) leave the
- notes alone and only rotate the loop at high optimization
+ notes alone and only rotate the loop at high optimization
levels when we expect to scrog debug info. */
else if (NOTE_LINE_NUMBER (etc_note) == NOTE_INSN_BLOCK_BEG)
debug_blocks++;
}
/* Like expand_exit_loop_if_false except also emit a note marking
- the end of the conditional. Should only be used immediately
+ the end of the conditional. Should only be used immediately
after expand_loop_start. */
int
/* Treat this like a return of no value from a function that
returns a value. */
expand_null_return ();
- return;
+ return;
}
else if (TREE_CODE (retval) == RESULT_DECL)
retval_rhs = retval;
chain && !tree_int_cst_equal (n->low, TREE_VALUE (chain));
chain = TREE_CHAIN (chain))
;
-
+
if (!chain)
{
if (TYPE_NAME (type) == 0)
chain && !tree_int_cst_equal (n->high, TREE_VALUE (chain));
chain = TREE_CHAIN (chain))
;
-
+
if (!chain)
{
if (TYPE_NAME (type) == 0)
/* Free CN, and its children. */
-static void
+static void
free_case_nodes (cn)
case_node_ptr cn;
{
- if (cn)
+ if (cn)
{
free_case_nodes (cn->left);
free_case_nodes (cn->right);
{
index_type = thiscase->data.case_stmt.nominal_type;
- /* Index jumptables from zero for suitable values of
+ /* Index jumptables from zero for suitable values of
minval to avoid a subtraction. */
- if (! optimize_size
- && compare_tree_int (minval, 0) > 0
- && compare_tree_int (minval, 3) < 0)
- {
- minval = integer_zero_node;
- range = maxval;
- }
+ if (! optimize_size
+ && compare_tree_int (minval, 0) > 0
+ && compare_tree_int (minval, 3) < 0)
+ {
+ minval = integer_zero_node;
+ range = maxval;
+ }
if (! try_tablejump (index_type, index_expr, minval, range,
table_label, default_label))
abort ();
}
-
+
/* Get table of labels to jump to, in order of case index. */
ncases = tree_low_cst (range, 0) + 1;
value since that should fit in a HOST_WIDE_INT while the
actual values may not. */
HOST_WIDE_INT i_low
- = tree_low_cst (fold (build (MINUS_EXPR, index_type,
- n->low, minval)), 1);
+ = tree_low_cst (fold (build (MINUS_EXPR, index_type,
+ n->low, minval)), 1);
HOST_WIDE_INT i_high
- = tree_low_cst (fold (build (MINUS_EXPR, index_type,
- n->high, minval)), 1);
+ = tree_low_cst (fold (build (MINUS_EXPR, index_type,
+ n->high, minval)), 1);
HOST_WIDE_INT i;
for (i = i_low; i <= i_high; i ++)
new_bound = expand_expr (fold (build (MINUS_EXPR, type,
high, low)),
NULL_RTX, mode, 0);
-
+
emit_cmp_and_jump_insns (new_index, new_bound, GT, NULL_RTX,
mode, 1, default_label);
}
}
if (immediate_size_expand)
- /* NULL_RTX is not defined; neither is the rtx type.
+ /* NULL_RTX is not defined; neither is the rtx type.
Also, we would like to pass const0_rtx here, but don't have it. */
expand_expr (size, expand_expr (integer_zero_node, NULL_RTX, VOIDmode, 0),
VOIDmode, 0);
case MODE_RANDOM:
if (mode == BLKmode)
- break;
+ break;
/* ... fall through ... */
&& (DECL_ALIGN (decl) == 0
|| (! (code == FIELD_DECL && DECL_PACKED (decl))
&& TYPE_ALIGN (type) > DECL_ALIGN (decl))))
- {
+ {
DECL_ALIGN (decl) = TYPE_ALIGN (type);
DECL_USER_ALIGN (decl) = 0;
}
}
}
- /* See if we can use an ordinary integer mode for a bit-field.
+ /* See if we can use an ordinary integer mode for a bit-field.
Conditions are: a fixed size that is correct for another mode
and occupying a complete byte or bytes on proper boundary. */
if (code == FIELD_DECL && DECL_BIT_FIELD (decl)
/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or
QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which
is to be passed to all other layout functions for this record. It is the
- responsibility of the caller to call `free' for the storage returned.
+ responsibility of the caller to call `free' for the storage returned.
Note that garbage collection is not permitted until we finish laying
out the record. */
start_record_layout (t)
tree t;
{
- record_layout_info rli
+ record_layout_info rli
= (record_layout_info) xmalloc (sizeof (struct record_layout_info_s));
rli->t = t;
= size_binop (PLUS_EXPR, *poffset,
size_binop (MULT_EXPR, convert (sizetype, extra_aligns),
size_int (off_align / BITS_PER_UNIT)));
-
+
*pbitpos
= size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align));
}
unsigned int desired_align;
layout_decl (field, 0);
-
+
DECL_FIELD_OFFSET (field) = size_zero_node;
DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node;
SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT);
entire union to have `int' alignment. */
if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field))
{
- rli->record_align = MAX (rli->record_align,
+ rli->record_align = MAX (rli->record_align,
TYPE_ALIGN (TREE_TYPE (field)));
rli->unpadded_align = MAX (rli->unpadded_align,
TYPE_ALIGN (TREE_TYPE (field)));
if (TREE_CODE (rli->t) == UNION_TYPE)
rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
- rli->offset = fold (build (COND_EXPR, sizetype,
+ rli->offset = fold (build (COND_EXPR, sizetype,
DECL_QUALIFIER (field),
DECL_SIZE_UNIT (field), rli->offset));
}
unsigned int user_align;
/* The type of this field. */
tree type = TREE_TYPE (field);
-
+
if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK)
return;
}
else
desired_align = 1;
- }
+ }
else
#ifdef PCC_BITFIELD_TYPE_MATTERS
if (PCC_BITFIELD_TYPE_MATTERS && type != error_mark_node
if (warn_padded && TREE_CONSTANT (unpadded_size)
&& simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0)
warning ("padding struct size to alignment boundary");
-
+
if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE
&& TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary
&& TREE_CONSTANT (unpadded_size))
return;
bitpos = int_bit_position (field);
-
+
/* Must be BLKmode if any field crosses a word boundary,
since extract_bit_field can't handle that in registers. */
if (bitpos / BITS_PER_WORD
/* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
records and unions, finish_record_layout already called this
function. */
- if (TREE_CODE (type) != RECORD_TYPE
+ if (TREE_CODE (type) != RECORD_TYPE
&& TREE_CODE (type) != UNION_TYPE
&& TREE_CODE (type) != QUAL_UNION_TYPE)
finalize_type_size (type);
/* Identical to get_identifier, except that the length is assumed
known. */
-
+
tree
get_identifier_with_length (text, length)
const char *text;
projects / thirdparty / gcc.git / commitdiff
