This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[RFC/PATCH] Standardize on "for (;;)" for unbounded loops
- From: Roger Sayle <roger at eyesopen dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Sun, 29 Oct 2006 10:54:13 -0700 (MST)
- Subject: [RFC/PATCH] Standardize on "for (;;)" for unbounded loops
Now that we're back in stage 1, I'd like to (re)propose the following
minor tweak to GCC's coding style. There are several different ways
of expressing infinite/unbounded loops in C, including the following:
[1] while (1)
...;
[2] do
...
while (1);
[3] for (;;)
...;
[4] while (true)
...;
[5] for ( ; ; )
...;
Indeed, all of these forms are currently found in GCC's source code.
I'd like to suggest as an extension to our current style guidelines,
that we select one of the above as the preferred form, and recommend
its use in new contributions.
Of course, such a choice is often purely a matter of taste, and it's
perhaps the consistency that is more important in defining good style.
I'm happy to go along with the community consensus, but my personal
vote would be for form [3] above, for three petty reasons. The first
is that some (brain-dead?) compilers issue diagnostic warnings for
the use of "while (1)". For example, with the "-fullwarn" compiler
option (the equivalent of -Wall), the MIPSPro compiler issues the
message:
cc-1209 cc: REMARK File = while1.c, Line = 5
The controlling expression is constant.
while (1)
^
Using the "for(;;)" form silences this complaint. The second reason is
that by chosing the "for(;;)" form, we avoid any ambiguity or conflict
with our current coding style recommendation, for preferring "true"
over "1" in Boolean contexts, as part of the "integer" -> "bool"
transition. Finally, and most trivial of all, "for (;;)" is less
typing than "while (1)" or "while (true)" :->
To turn the proposal into something a little more concrete, the patch
below standardizes the middle-end on the use of a single consistent
style. This patch has been tested on x86_64-unknown-linux-gnu, with
a full bootstrap and regression test, all default languages, with no
new regressions.
These changes are mechanical and trivial, so I've no objection to
holding off on this patch until later in stage 1, and also don't
mind any instance being (accidentally) reverted as part of a branch
merge. All current code can be grandfathered in. The intent is
purely to define a consistent style, and reach the point where the
majority usage follows that style.
Thoughts?
2006-10-28 Roger Sayle <roger@eyesopen.com>
* bitmap.h (bmp_iter_set_init, bmp_iter_and_init,
bmp_iter_and_compl_init, bmp_iter_set, bmp_iter_and,
bmp_iter_and_compl): Consistently use "for (;;)" for infinite
loops.
* alias.c (find_base_decl): Likewise.
* bb-reorder.c (connect_traces): Likewise.
* builtins.c (get_pointer_alignment, validate_arglist): Likewise.
* calls.c (fixup_tail_calls): Likewise.
* cfganal.c (connect_infinite_loops_to_exit): Likewise.
* cfgbuild.c (find_bb_boundaries): Likewise.
* cfgcleanup.c (flow_find_cross_jump): Likewise.
* cfglayout.c (insn_scope, locator_line, locator_file,
cfg_layout_can_duplicate_bb_p): Likewise.
* cfgloopanal.c (dfs): Likewise.
* cfgloopmanip.c (fix_loop_structure): Likewise.
* cfgrtl.c (delete_insn_chain): Likewise.
* combine.c (expand_field_assignment, simplify_comparison): Likewise.
* cse.c (use_related_value, cse_insn): Likewise.
* df-core.c (df_iterative_dataflow): Likewise.
* dominance.c (calc_dfs_tree_nonrec): Likewise.
* domwalk.c (walk_dominator_tree): Likewise.
* dwarf2out.c (file_info_cmp): Likewise.
* emit-rtl.c (make_safe_from, try_split, emit_insn_after_setloc,
emit_jump_insn_after_setloc, emit_call_insn_after_setloc,
emit_insn_before_setloc, emit_jump_insn_before_setloc,
emit_call_insn_before_setloc): Likewise.
* except.c (collect_eh_region_array, dump_eh_tree, verify_eh_tree):
Likewise.
* expr.c (get_inner_reference, safe_from_p): Likewise.
* flow.c (verify_wide_reg, update_life_info): Likewise.
* fold-const.c (make_range, tree_Expr_nonnegative_p): Likewise.
* gcse.c (find_avail_set, insert_insn_end_bb,
remove_reachable_equiv_notes): Likewise.
* ggc-page.c (ggc_allocated_p): Likewise.
* global.c (global_conflicts): Likewise.
* haifa-sched.c (add_to_speculative_block, dep_weak, unlink_bb_notes,
add_jump_dependencies): Likewise.
* ifcvt.c (count_bb_insns, cheap_bb_rtx_cost_p): Likewise.
* ipa-type-escape.c (discover_unique_type): Likewise.
* jump.c (delete_for_peephole): Likewise.
* local-alloc.c (block_alloc): Likewise.
* loop-iv.c (simplify_using_initial_values): Likewise.
* pointer-set.c (pointer_set_contains, insert_aux): Likewise.
* print-rtl.c (debug_rtx_range): Likewise.
* read-rtl.c (read_skip_spaces, read_name, read_quoted_string):
Likewise.
* real.c (real_to_decimal, real_from_string): Likewise.
* regmove.c (mark_flags_life_zones): Likewise.
* reload.c (find_equiv_reg): Likewise.
* rtl-factoring.c (collect_pattern_seqs): Likewise.
* sbitmap.c (sbitmap_last_set_bit): Likewise.
* sched-deps.c (ds_merge, check_dep_status): Likewise.
* sched-rgn.c (find_rgns): Likewise.
* stmt.c (balance_case_nodes): Likewise.
* tree-browser.c (TB_getline): Likewise.
* tree.c (skip_simple_arithmetic, tree_fold_gcd): Likewise.
* tree-dfa.c (get_ref_base_and_extent): Likewise.
* tree-pretty-print.c (dump_omp_clauses, dump_generic_node): Likewise.
* tree-scalar-evolution.c (analyze_scalar_evolution_in_loop):
Likewise.
* tree-sra.c (sra_walk_expr, instantiate_missing_elements,
generate_element_init_1): Likewise.
* tree-ssa-ccp.c (ccp_decl_initial_min_invariant): Likewise.
* tree-ssa-forwprop.c (forward_propagate_into_cond): Likewise.
* tree-ssa-loop-im.c (determine_lsm, fill_always_executed_in):
Likewise.
* tree-ssa-loop-unswitch.c (simplify_using_entry_checks,
tree_unswitch_single_loop): Likewise.
* tree-tailcall.c (independent_of_stmt_p, find_tail_calls):
Likewise.
* varasm.c (decide_addr_const): Likewise.
Index: bitmap.h
===================================================================
*** bitmap.h (revision 118098)
--- bitmap.h (working copy)
***************
*** 1,5 ****
/* Functions to support general ended bitmaps.
! Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Functions to support general ended bitmaps.
! Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** bmp_iter_set_init (bitmap_iterator *bi,
*** 208,214 ****
bi->elt2 = NULL;
/* Advance elt1 until it is not before the block containing start_bit. */
! while (1)
{
if (!bi->elt1)
{
--- 208,214 ----
bi->elt2 = NULL;
/* Advance elt1 until it is not before the block containing start_bit. */
! for (;;)
{
if (!bi->elt1)
{
*************** bmp_iter_and_init (bitmap_iterator *bi,
*** 251,257 ****
/* Advance elt1 until it is not before the block containing
start_bit. */
! while (1)
{
if (!bi->elt1)
{
--- 251,257 ----
/* Advance elt1 until it is not before the block containing
start_bit. */
! for (;;)
{
if (!bi->elt1)
{
*************** bmp_iter_and_init (bitmap_iterator *bi,
*** 265,271 ****
}
/* Advance elt2 until it is not before elt1. */
! while (1)
{
if (!bi->elt2)
{
--- 265,271 ----
}
/* Advance elt2 until it is not before elt1. */
! for (;;)
{
if (!bi->elt2)
{
*************** bmp_iter_and_compl_init (bitmap_iterator
*** 318,324 ****
bi->elt2 = map2->first;
/* Advance elt1 until it is not before the block containing start_bit. */
! while (1)
{
if (!bi->elt1)
{
--- 318,324 ----
bi->elt2 = map2->first;
/* Advance elt1 until it is not before the block containing start_bit. */
! for (;;)
{
if (!bi->elt1)
{
*************** bmp_iter_set (bitmap_iterator *bi, unsig
*** 391,397 ****
/ BITMAP_WORD_BITS * BITMAP_WORD_BITS);
bi->word_no++;
! while (1)
{
/* Find the next nonzero word in this elt. */
while (bi->word_no != BITMAP_ELEMENT_WORDS)
--- 391,397 ----
/ BITMAP_WORD_BITS * BITMAP_WORD_BITS);
bi->word_no++;
! for (;;)
{
/* Find the next nonzero word in this elt. */
while (bi->word_no != BITMAP_ELEMENT_WORDS)
*************** bmp_iter_and (bitmap_iterator *bi, unsig
*** 438,444 ****
/ BITMAP_WORD_BITS * BITMAP_WORD_BITS);
bi->word_no++;
! while (1)
{
/* Find the next nonzero word in this elt. */
while (bi->word_no != BITMAP_ELEMENT_WORDS)
--- 438,444 ----
/ BITMAP_WORD_BITS * BITMAP_WORD_BITS);
bi->word_no++;
! for (;;)
{
/* Find the next nonzero word in this elt. */
while (bi->word_no != BITMAP_ELEMENT_WORDS)
*************** bmp_iter_and_compl (bitmap_iterator *bi,
*** 505,511 ****
/ BITMAP_WORD_BITS * BITMAP_WORD_BITS);
bi->word_no++;
! while (1)
{
/* Find the next nonzero word in this elt. */
while (bi->word_no != BITMAP_ELEMENT_WORDS)
--- 505,511 ----
/ BITMAP_WORD_BITS * BITMAP_WORD_BITS);
bi->word_no++;
! for (;;)
{
/* Find the next nonzero word in this elt. */
while (bi->word_no != BITMAP_ELEMENT_WORDS)
Index: alias.c
===================================================================
*** alias.c (revision 118098)
--- alias.c (working copy)
*************** find_base_decl (tree t)
*** 435,441 ****
bool
component_uses_parent_alias_set (tree t)
{
! while (1)
{
/* If we're at the end, it vacuously uses its own alias set. */
if (!handled_component_p (t))
--- 435,441 ----
bool
component_uses_parent_alias_set (tree t)
{
! for (;;)
{
/* If we're at the end, it vacuously uses its own alias set. */
if (!handled_component_p (t))
Index: bb-reorder.c
===================================================================
*** bb-reorder.c (revision 118098)
--- bb-reorder.c (working copy)
***************
*** 1,5 ****
/* Basic block reordering routines for the GNU compiler.
! Copyright (C) 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Basic block reordering routines for the GNU compiler.
! Copyright (C) 2000, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** connect_traces (int n_traces, struct tra
*** 997,1003 ****
last_trace = t;
/* Find the successor traces. */
! while (1)
{
/* Find the continuation of the chain. */
edge_iterator ei;
--- 998,1004 ----
last_trace = t;
/* Find the successor traces. */
! for (;;)
{
/* Find the continuation of the chain. */
edge_iterator ei;
Index: builtins.c
===================================================================
*** builtins.c (revision 118098)
--- builtins.c (working copy)
*************** get_pointer_alignment (tree exp, unsigne
*** 243,249 ****
align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
align = MIN (align, max_align);
! while (1)
{
switch (TREE_CODE (exp))
{
--- 243,249 ----
align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
align = MIN (align, max_align);
! for (;;)
{
switch (TREE_CODE (exp))
{
*************** validate_arglist (tree arglist, ...)
*** 9308,9314 ****
va_start (ap, arglist);
! do
{
code = va_arg (ap, enum tree_code);
switch (code)
--- 9308,9314 ----
va_start (ap, arglist);
! for (;;)
{
code = va_arg (ap, enum tree_code);
switch (code)
*************** validate_arglist (tree arglist, ...)
*** 9339,9345 ****
}
arglist = TREE_CHAIN (arglist);
}
- while (1);
/* We need gotos here since we can only have one VA_CLOSE in a
function. */
--- 9339,9344 ----
Index: calls.c
===================================================================
*** calls.c (revision 118098)
--- calls.c (working copy)
***************
*** 1,6 ****
/* Convert function calls to rtl insns, for GNU C compiler.
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Convert function calls to rtl insns, for GNU C compiler.
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** fixup_tail_calls (void)
*** 3094,3100 ****
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
break;
! while (1)
{
rtx note = find_reg_note (insn, REG_EQUIV, 0);
if (note)
--- 3094,3100 ----
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
break;
! for (;;)
{
rtx note = find_reg_note (insn, REG_EQUIV, 0);
if (note)
Index: cfganal.c
===================================================================
*** cfganal.c (revision 118098)
--- cfganal.c (working copy)
***************
*** 1,6 ****
/* Control flow graph analysis code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,7 ----
/* Control flow graph analysis code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** connect_infinite_loops_to_exit (void)
*** 630,636 ****
flow_dfs_compute_reverse_add_bb (&dfs_ds, EXIT_BLOCK_PTR);
/* Repeatedly add fake edges, updating the unreachable nodes. */
! while (1)
{
unvisited_block = flow_dfs_compute_reverse_execute (&dfs_ds,
unvisited_block);
--- 631,637 ----
flow_dfs_compute_reverse_add_bb (&dfs_ds, EXIT_BLOCK_PTR);
/* Repeatedly add fake edges, updating the unreachable nodes. */
! for (;;)
{
unvisited_block = flow_dfs_compute_reverse_execute (&dfs_ds,
unvisited_block);
Index: cfgbuild.c
===================================================================
*** cfgbuild.c (revision 118098)
--- cfgbuild.c (working copy)
***************
*** 1,6 ****
/* Control flow graph building code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,7 ----
/* Control flow graph building code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** find_bb_boundaries (basic_block bb)
*** 643,649 ****
insn = NEXT_INSN (insn);
/* Scan insn chain and try to find new basic block boundaries. */
! while (1)
{
enum rtx_code code = GET_CODE (insn);
--- 644,650 ----
insn = NEXT_INSN (insn);
/* Scan insn chain and try to find new basic block boundaries. */
! for (;;)
{
enum rtx_code code = GET_CODE (insn);
Index: cfgcleanup.c
===================================================================
*** cfgcleanup.c (revision 118098)
--- cfgcleanup.c (working copy)
***************
*** 1,6 ****
/* Control flow optimization code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,7 ----
/* Control flow optimization code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** flow_find_cross_jump (int mode ATTRIBUTE
*** 1084,1090 ****
i2 = PREV_INSN (i2);
}
! while (true)
{
/* Ignore notes. */
while (!INSN_P (i1) && i1 != BB_HEAD (bb1))
--- 1085,1091 ----
i2 = PREV_INSN (i2);
}
! for (;;)
{
/* Ignore notes. */
while (!INSN_P (i1) && i1 != BB_HEAD (bb1))
Index: cfglayout.c
===================================================================
*** cfglayout.c (revision 118098)
--- cfglayout.c (working copy)
***************
*** 1,5 ****
/* Basic block reordering routines for the GNU compiler.
! Copyright (C) 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Basic block reordering routines for the GNU compiler.
! Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** insn_scope (rtx insn)
*** 439,445 ****
if (!max || !loc)
return NULL;
! while (1)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, block_locators_locs, pos);
--- 440,446 ----
if (!max || !loc)
return NULL;
! for (;;)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, block_locators_locs, pos);
*************** locator_line (int loc)
*** 466,472 ****
if (!max || !loc)
return 0;
! while (1)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, line_locators_locs, pos);
--- 467,473 ----
if (!max || !loc)
return 0;
! for (;;)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, line_locators_locs, pos);
*************** locator_file (int loc)
*** 500,506 ****
if (!max || !loc)
return NULL;
! while (1)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, file_locators_locs, pos);
--- 501,507 ----
if (!max || !loc)
return NULL;
! for (;;)
{
int pos = (min + max) / 2;
int tmp = VEC_index (int, file_locators_locs, pos);
*************** cfg_layout_can_duplicate_bb_p (basic_blo
*** 928,934 ****
if (targetm.cannot_copy_insn_p)
{
rtx insn = BB_HEAD (bb);
! while (1)
{
if (INSN_P (insn) && targetm.cannot_copy_insn_p (insn))
return false;
--- 929,935 ----
if (targetm.cannot_copy_insn_p)
{
rtx insn = BB_HEAD (bb);
! for (;;)
{
if (INSN_P (insn) && targetm.cannot_copy_insn_p (insn))
return false;
Index: cfgloopanal.c
===================================================================
*** cfgloopanal.c (revision 118098)
--- cfgloopanal.c (working copy)
*************** dfs (struct graph *g, int *qs, int nq, i
*** 171,177 ****
e = FST_EDGE (v);
top = 0;
! while (1)
{
while (e && g->vertices[EDGE_DEST (e)].component != -1)
e = NEXT_EDGE (e);
--- 171,177 ----
e = FST_EDGE (v);
top = 0;
! for (;;)
{
while (e && g->vertices[EDGE_DEST (e)].component != -1)
e = NEXT_EDGE (e);
Index: cfgloopmanip.c
===================================================================
*** cfgloopmanip.c (revision 118098)
--- cfgloopmanip.c (working copy)
***************
*** 1,5 ****
/* Loop manipulation code for GNU compiler.
! Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Loop manipulation code for GNU compiler.
! Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** fix_loop_structure (struct loops *loops,
*** 1438,1444 ****
/* Rescan the bodies of loops, starting from the outermost. */
loop = loops->tree_root;
! while (1)
{
if (loop->inner)
loop = loop->inner;
--- 1438,1444 ----
/* Rescan the bodies of loops, starting from the outermost. */
loop = loops->tree_root;
! for (;;)
{
if (loop->inner)
loop = loop->inner;
Index: cfgrtl.c
===================================================================
*** cfgrtl.c (revision 118098)
--- cfgrtl.c (working copy)
***************
*** 1,6 ****
/* Control flow graph manipulation code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,7 ----
/* Control flow graph manipulation code for GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** delete_insn_chain (rtx start, rtx finish
*** 205,211 ****
/* Unchain the insns one by one. It would be quicker to delete all of these
with a single unchaining, rather than one at a time, but we need to keep
the NOTE's. */
! while (1)
{
next = NEXT_INSN (start);
if (NOTE_P (start) && !can_delete_note_p (start))
--- 206,212 ----
/* Unchain the insns one by one. It would be quicker to delete all of these
with a single unchaining, rather than one at a time, but we need to keep
the NOTE's. */
! for (;;)
{
next = NEXT_INSN (start);
if (NOTE_P (start) && !can_delete_note_p (start))
Index: combine.c
===================================================================
*** combine.c (revision 118098)
--- combine.c (working copy)
*************** expand_field_assignment (rtx x)
*** 5801,5807 ****
enum machine_mode compute_mode;
/* Loop until we find something we can't simplify. */
! while (1)
{
if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
&& GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
--- 5801,5807 ----
enum machine_mode compute_mode;
/* Loop until we find something we can't simplify. */
! for (;;)
{
if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
&& GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
*************** simplify_comparison (enum rtx_code code,
*** 9520,9526 ****
enum machine_mode mode, tmode;
/* Try a few ways of applying the same transformation to both operands. */
! while (1)
{
#ifndef WORD_REGISTER_OPERATIONS
/* The test below this one won't handle SIGN_EXTENDs on these machines,
--- 9520,9526 ----
enum machine_mode mode, tmode;
/* Try a few ways of applying the same transformation to both operands. */
! for (;;)
{
#ifndef WORD_REGISTER_OPERATIONS
/* The test below this one won't handle SIGN_EXTENDs on these machines,
Index: cse.c
===================================================================
*** cse.c (revision 118098)
--- cse.c (working copy)
***************
*** 1,6 ****
/* Common subexpression elimination for GNU compiler.
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,7 ----
/* Common subexpression elimination for GNU compiler.
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** use_related_value (rtx x, struct table_e
*** 2100,2106 ****
equivalent register. */
p = relt;
! while (1)
{
/* This loop is strange in that it is executed in two different cases.
The first is when X is already in the table. Then it is searching
--- 2101,2107 ----
equivalent register. */
p = relt;
! for (;;)
{
/* This loop is strange in that it is executed in two different cases.
The first is when X is already in the table. Then it is searching
*************** cse_insn (rtx insn, rtx libcall_insn)
*** 5530,5536 ****
/* Terminate loop when replacement made. This must terminate since
the current contents will be tested and will always be valid. */
! while (1)
{
rtx trial;
--- 5531,5537 ----
/* Terminate loop when replacement made. This must terminate since
the current contents will be tested and will always be valid. */
! for (;;)
{
rtx trial;
Index: df-core.c
===================================================================
*** df-core.c (revision 118098)
--- df-core.c (working copy)
*************** df_iterative_dataflow (struct dataflow *
*** 661,667 ****
dataflow->problem->init_fun (dataflow, blocks_to_init);
! while (1)
{
/* For forward problems, you want to pass in reverse postorder
--- 661,667 ----
dataflow->problem->init_fun (dataflow, blocks_to_init);
! for (;;)
{
/* For forward problems, you want to pass in reverse postorder
Index: dominance.c
===================================================================
*** dominance.c (revision 118098)
--- dominance.c (working copy)
***************
*** 1,5 ****
/* Calculate (post)dominators in slightly super-linear time.
! Copyright (C) 2000, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Michael Matz (matz@ifh.de).
This file is part of GCC.
--- 1,5 ----
/* Calculate (post)dominators in slightly super-linear time.
! Copyright (C) 2000, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
Contributed by Michael Matz (matz@ifh.de).
This file is part of GCC.
*************** calc_dfs_tree_nonrec (struct dom_info *d
*** 232,238 ****
}
/* When the stack is empty we break out of this loop. */
! while (1)
{
basic_block bn;
--- 232,238 ----
}
/* When the stack is empty we break out of this loop. */
! for (;;)
{
basic_block bn;
Index: domwalk.c
===================================================================
*** domwalk.c (revision 118098)
--- domwalk.c (working copy)
***************
*** 1,5 ****
/* Generic dominator tree walker
! Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
--- 1,5 ----
/* Generic dominator tree walker
! Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
*************** walk_dominator_tree (struct dom_walk_dat
*** 149,155 ****
basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks * 2);
int sp = 0;
! while (true)
{
/* Don't worry about unreachable blocks. */
if (EDGE_COUNT (bb->preds) > 0 || bb == ENTRY_BLOCK_PTR)
--- 149,155 ----
basic_block *worklist = XNEWVEC (basic_block, n_basic_blocks * 2);
int sp = 0;
! for (;;)
{
/* Don't worry about unreachable blocks. */
if (EDGE_COUNT (bb->preds) > 0 || bb == ENTRY_BLOCK_PTR)
Index: dwarf2out.c
===================================================================
*** dwarf2out.c (revision 118098)
--- dwarf2out.c (working copy)
*************** file_info_cmp (const void *p1, const voi
*** 7613,7619 ****
cp1 = (unsigned char *) s1->path;
cp2 = (unsigned char *) s2->path;
! while (1)
{
++cp1;
++cp2;
--- 7613,7619 ----
cp1 = (unsigned char *) s1->path;
cp2 = (unsigned char *) s2->path;
! for (;;)
{
++cp1;
++cp2;
Index: emit-rtl.c
===================================================================
*** emit-rtl.c (revision 118098)
--- emit-rtl.c (working copy)
*************** set_used_flags (rtx x)
*** 2630,2636 ****
rtx
make_safe_from (rtx x, rtx other)
{
! while (1)
switch (GET_CODE (other))
{
case SUBREG:
--- 2630,2636 ----
rtx
make_safe_from (rtx x, rtx other)
{
! for (;;)
switch (GET_CODE (other))
{
case SUBREG:
*************** try_split (rtx pat, rtx trial, int last)
*** 3134,3140 ****
/* Avoid infinite loop if any insn of the result matches
the original pattern. */
insn_last = seq;
! while (1)
{
if (INSN_P (insn_last)
&& rtx_equal_p (PATTERN (insn_last), pat))
--- 3134,3140 ----
/* Avoid infinite loop if any insn of the result matches
the original pattern. */
insn_last = seq;
! for (;;)
{
if (INSN_P (insn_last)
&& rtx_equal_p (PATTERN (insn_last), pat))
*************** emit_insn_after_setloc (rtx pattern, rtx
*** 4131,4137 ****
return last;
after = NEXT_INSN (after);
! while (1)
{
if (active_insn_p (after) && !INSN_LOCATOR (after))
INSN_LOCATOR (after) = loc;
--- 4131,4137 ----
return last;
after = NEXT_INSN (after);
! for (;;)
{
if (active_insn_p (after) && !INSN_LOCATOR (after))
INSN_LOCATOR (after) = loc;
*************** emit_jump_insn_after_setloc (rtx pattern
*** 4162,4168 ****
return last;
after = NEXT_INSN (after);
! while (1)
{
if (active_insn_p (after) && !INSN_LOCATOR (after))
INSN_LOCATOR (after) = loc;
--- 4162,4168 ----
return last;
after = NEXT_INSN (after);
! for (;;)
{
if (active_insn_p (after) && !INSN_LOCATOR (after))
INSN_LOCATOR (after) = loc;
*************** emit_call_insn_after_setloc (rtx pattern
*** 4193,4199 ****
return last;
after = NEXT_INSN (after);
! while (1)
{
if (active_insn_p (after) && !INSN_LOCATOR (after))
INSN_LOCATOR (after) = loc;
--- 4193,4199 ----
return last;
after = NEXT_INSN (after);
! for (;;)
{
if (active_insn_p (after) && !INSN_LOCATOR (after))
INSN_LOCATOR (after) = loc;
*************** emit_insn_before_setloc (rtx pattern, rt
*** 4225,4231 ****
return last;
first = NEXT_INSN (first);
! while (1)
{
if (active_insn_p (first) && !INSN_LOCATOR (first))
INSN_LOCATOR (first) = loc;
--- 4225,4231 ----
return last;
first = NEXT_INSN (first);
! for (;;)
{
if (active_insn_p (first) && !INSN_LOCATOR (first))
INSN_LOCATOR (first) = loc;
*************** emit_jump_insn_before_setloc (rtx patter
*** 4257,4263 ****
return last;
first = NEXT_INSN (first);
! while (1)
{
if (active_insn_p (first) && !INSN_LOCATOR (first))
INSN_LOCATOR (first) = loc;
--- 4257,4263 ----
return last;
first = NEXT_INSN (first);
! for (;;)
{
if (active_insn_p (first) && !INSN_LOCATOR (first))
INSN_LOCATOR (first) = loc;
*************** emit_call_insn_before_setloc (rtx patter
*** 4289,4295 ****
return last;
first = NEXT_INSN (first);
! while (1)
{
if (active_insn_p (first) && !INSN_LOCATOR (first))
INSN_LOCATOR (first) = loc;
--- 4289,4295 ----
return last;
first = NEXT_INSN (first);
! for (;;)
{
if (active_insn_p (first) && !INSN_LOCATOR (first))
INSN_LOCATOR (first) = loc;
Index: except.c
===================================================================
*** except.c (revision 118098)
--- except.c (working copy)
***************
*** 1,6 ****
/* Implements exception handling.
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@cygnus.com>.
This file is part of GCC.
--- 1,7 ----
/* Implements exception handling.
Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@cygnus.com>.
This file is part of GCC.
*************** collect_eh_region_array (void)
*** 641,647 ****
cfun->eh->last_region_number + 1);
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
! while (1)
{
VEC_replace (eh_region, cfun->eh->region_array, i->region_number, i);
--- 642,648 ----
cfun->eh->last_region_number + 1);
VEC_replace (eh_region, cfun->eh->region_array, 0, 0);
! for (;;)
{
VEC_replace (eh_region, cfun->eh->region_array, i->region_number, i);
*************** dump_eh_tree (FILE *out, struct function
*** 3814,3820 ****
return;
fprintf (out, "Eh tree:\n");
! while (1)
{
fprintf (out, " %*s %i %s", depth * 2, "",
i->region_number, type_name [(int)i->type]);
--- 3815,3821 ----
return;
fprintf (out, "Eh tree:\n");
! for (;;)
{
fprintf (out, " %*s %i %s", depth * 2, "",
i->region_number, type_name [(int)i->type]);
*************** verify_eh_tree (struct function *fun)
*** 3870,3876 ****
}
}
! while (1)
{
if (VEC_index (eh_region, cfun->eh->region_array, i->region_number) != i)
{
--- 3871,3877 ----
}
}
! for (;;)
{
if (VEC_index (eh_region, cfun->eh->region_array, i->region_number) != i)
{
Index: expr.c
===================================================================
*** expr.c (revision 118098)
--- expr.c (working copy)
*************** get_inner_reference (tree exp, HOST_WIDE
*** 5692,5698 ****
/* Compute cumulative bit-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
! while (1)
{
switch (TREE_CODE (exp))
{
--- 5692,5698 ----
/* Compute cumulative bit-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
! for (;;)
{
switch (TREE_CODE (exp))
{
*************** safe_from_p (rtx x, tree exp, int top_p)
*** 6119,6125 ****
case tcc_exceptional:
if (TREE_CODE (exp) == TREE_LIST)
{
! while (1)
{
if (TREE_VALUE (exp) && !safe_from_p (x, TREE_VALUE (exp), 0))
return 0;
--- 6119,6125 ----
case tcc_exceptional:
if (TREE_CODE (exp) == TREE_LIST)
{
! for (;;)
{
if (TREE_VALUE (exp) && !safe_from_p (x, TREE_VALUE (exp), 0))
return 0;
Index: flow.c
===================================================================
*** flow.c (revision 118098)
--- flow.c (working copy)
*************** verify_wide_reg (int regno, basic_block
*** 471,477 ****
{
rtx head = BB_HEAD (bb), end = BB_END (bb);
! while (1)
{
if (INSN_P (head))
{
--- 471,477 ----
{
rtx head = BB_HEAD (bb), end = BB_END (bb);
! for (;;)
{
if (INSN_P (head))
{
*************** update_life_info (sbitmap blocks, enum u
*** 591,597 ****
/* For a global update, we go through the relaxation process again. */
if (extent != UPDATE_LIFE_LOCAL)
{
! for ( ; ; )
{
int changed = 0;
--- 591,597 ----
/* For a global update, we go through the relaxation process again. */
if (extent != UPDATE_LIFE_LOCAL)
{
! for (;;)
{
int changed = 0;
Index: fold-const.c
===================================================================
*** fold-const.c (revision 118098)
--- fold-const.c (working copy)
*************** make_range (tree exp, int *pin_p, tree *
*** 3800,3806 ****
in_p = 0;
low = high = build_int_cst (TREE_TYPE (exp), 0);
! while (1)
{
code = TREE_CODE (exp);
exp_type = TREE_TYPE (exp);
--- 3800,3806 ----
in_p = 0;
low = high = build_int_cst (TREE_TYPE (exp), 0);
! for (;;)
{
code = TREE_CODE (exp);
exp_type = TREE_TYPE (exp);
*************** tree_expr_nonnegative_p (tree t)
*** 12115,12121 ****
/* Otherwise, the initializer sets the slot in some way. One common
way is an assignment statement at the end of the initializer. */
! while (1)
{
if (TREE_CODE (t) == BIND_EXPR)
t = expr_last (BIND_EXPR_BODY (t));
--- 12115,12121 ----
/* Otherwise, the initializer sets the slot in some way. One common
way is an assignment statement at the end of the initializer. */
! for (;;)
{
if (TREE_CODE (t) == BIND_EXPR)
t = expr_last (BIND_EXPR_BODY (t));
Index: gcse.c
===================================================================
*** gcse.c (revision 118098)
--- gcse.c (working copy)
***************
*** 1,6 ****
/* Global common subexpression elimination/Partial redundancy elimination
and global constant/copy propagation for GNU compiler.
! Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Global common subexpression elimination/Partial redundancy elimination
and global constant/copy propagation for GNU compiler.
! Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** find_avail_set (int regno, rtx insn)
*** 2714,2720 ****
This can not happen since the set of (reg Y) would have killed the
set of (reg X) making it unavailable at the start of this block. */
! while (1)
{
rtx src;
struct expr *set = lookup_set (regno, &set_hash_table);
--- 2714,2720 ----
This can not happen since the set of (reg Y) would have killed the
set of (reg X) making it unavailable at the start of this block. */
! for (;;)
{
rtx src;
struct expr *set = lookup_set (regno, &set_hash_table);
*************** insert_insn_end_bb (struct expr *expr, b
*** 4085,4091 ****
else
new_insn = emit_insn_after_noloc (pat, insn);
! while (1)
{
if (INSN_P (pat))
{
--- 4085,4091 ----
else
new_insn = emit_insn_after_noloc (pat, insn);
! for (;;)
{
if (INSN_P (pat))
{
*************** remove_reachable_equiv_notes (basic_bloc
*** 6239,6246 ****
sbitmap_zero (visited);
! act = (EDGE_COUNT (ei_container (ei)) > 0 ? EDGE_I (ei_container (ei), 0) : NULL);
! while (1)
{
if (!act)
{
--- 6239,6248 ----
sbitmap_zero (visited);
! act = EDGE_COUNT (ei_container (ei)) > 0
! ? EDGE_I (ei_container (ei), 0)
! : NULL;
! for (;;)
{
if (!act)
{
Index: ggc-page.c
===================================================================
*** ggc-page.c (revision 118098)
--- ggc-page.c (working copy)
***************
*** 1,5 ****
/* "Bag-of-pages" garbage collector for the GNU compiler.
! Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* "Bag-of-pages" garbage collector for the GNU compiler.
! Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** ggc_allocated_p (const void *p)
*** 561,567 ****
#else
page_table table = G.lookup;
size_t high_bits = (size_t) p & ~ (size_t) 0xffffffff;
! while (1)
{
if (table == NULL)
return 0;
--- 561,567 ----
#else
page_table table = G.lookup;
size_t high_bits = (size_t) p & ~ (size_t) 0xffffffff;
! for (;;)
{
if (table == NULL)
return 0;
Index: global.c
===================================================================
*** global.c (revision 118098)
--- global.c (working copy)
***************
*** 1,6 ****
/* Allocate registers for pseudo-registers that span basic blocks.
Copyright (C) 1987, 1988, 1991, 1994, 1996, 1997, 1998,
! 1999, 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Allocate registers for pseudo-registers that span basic blocks.
Copyright (C) 1987, 1988, 1991, 1994, 1996, 1997, 1998,
! 1999, 2000, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** global_conflicts (void)
*** 799,805 ****
and hard regs are born or die. When one is born,
record a conflict with all others currently live. */
! while (1)
{
RTX_CODE code = GET_CODE (insn);
rtx link;
--- 799,805 ----
and hard regs are born or die. When one is born,
record a conflict with all others currently live. */
! for (;;)
{
RTX_CODE code = GET_CODE (insn);
rtx link;
Index: haifa-sched.c
===================================================================
*** haifa-sched.c (revision 118098)
--- haifa-sched.c (working copy)
*************** add_to_speculative_block (rtx insn)
*** 3488,3494 ****
{
add_back_forw_dep (twin, check, REG_DEP_TRUE, DEP_TRUE);
! do
{
link = XEXP (link, 1);
if (link)
--- 3488,3494 ----
{
add_back_forw_dep (twin, check, REG_DEP_TRUE, DEP_TRUE);
! for (;;)
{
link = XEXP (link, 1);
if (link)
*************** add_to_speculative_block (rtx insn)
*** 3500,3506 ****
else
break;
}
- while (1);
}
while (link);
--- 3500,3505 ----
*************** dep_weak (ds_t ds)
*** 3556,3562 ****
int n = 0;
dt = FIRST_SPEC_TYPE;
! do
{
if (ds & dt)
{
--- 3555,3561 ----
int n = 0;
dt = FIRST_SPEC_TYPE;
! for (;;)
{
if (ds & dt)
{
*************** dep_weak (ds_t ds)
*** 3568,3574 ****
break;
dt <<= SPEC_TYPE_SHIFT;
}
- while (1);
gcc_assert (n);
while (--n)
--- 3567,3572 ----
*************** unlink_bb_notes (basic_block first, basi
*** 4146,4152 ****
bb_header[last->next_bb->index] = 0;
first = first->next_bb;
! do
{
rtx prev, label, note, next;
--- 4144,4150 ----
bb_header[last->next_bb->index] = 0;
first = first->next_bb;
! for (;;)
{
rtx prev, label, note, next;
*************** unlink_bb_notes (basic_block first, basi
*** 4171,4177 ****
last = last->prev_bb;
}
- while (1);
}
/* Restore basic block notes.
--- 4169,4174 ----
*************** calc_priorities (rtx insn)
*** 4531,4537 ****
static void
add_jump_dependencies (rtx insn, rtx jump)
{
! do
{
insn = NEXT_INSN (insn);
if (insn == jump)
--- 4528,4534 ----
static void
add_jump_dependencies (rtx insn, rtx jump)
{
! for (;;)
{
insn = NEXT_INSN (insn);
if (insn == jump)
*************** add_jump_dependencies (rtx insn, rtx jum
*** 4540,4546 ****
if (!INSN_DEPEND (insn))
add_back_forw_dep (jump, insn, REG_DEP_ANTI, DEP_ANTI);
}
- while (1);
gcc_assert (LOG_LINKS (jump));
}
--- 4537,4542 ----
Index: ifcvt.c
===================================================================
*** ifcvt.c (revision 118098)
--- ifcvt.c (working copy)
*************** count_bb_insns (basic_block bb)
*** 120,126 ****
int count = 0;
rtx insn = BB_HEAD (bb);
! while (1)
{
if (CALL_P (insn) || NONJUMP_INSN_P (insn))
count++;
--- 120,126 ----
int count = 0;
rtx insn = BB_HEAD (bb);
! for (;;)
{
if (CALL_P (insn) || NONJUMP_INSN_P (insn))
count++;
*************** cheap_bb_rtx_cost_p (basic_block bb, int
*** 143,149 ****
int count = 0;
rtx insn = BB_HEAD (bb);
! while (1)
{
if (NONJUMP_INSN_P (insn))
{
--- 143,149 ----
int count = 0;
rtx insn = BB_HEAD (bb);
! for (;;)
{
if (NONJUMP_INSN_P (insn))
{
Index: ipa-type-escape.c
===================================================================
*** ipa-type-escape.c (revision 118098)
--- ipa-type-escape.c (working copy)
*************** discover_unique_type (tree type)
*** 206,212 ****
brand->name = get_name_of_type (type);
! while (1)
{
brand->seq = i++;
result = splay_tree_lookup (all_canon_types, (splay_tree_key) brand);
--- 206,212 ----
brand->name = get_name_of_type (type);
! for (;;)
{
brand->seq = i++;
result = splay_tree_lookup (all_canon_types, (splay_tree_key) brand);
Index: jump.c
===================================================================
*** jump.c (revision 118098)
--- jump.c (working copy)
***************
*** 1,6 ****
/* Optimize jump instructions, for GNU compiler.
! Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
! 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Optimize jump instructions, for GNU compiler.
! Copyright (C) 1987, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
! 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** delete_for_peephole (rtx from, rtx to)
*** 1528,1534 ****
{
rtx insn = from;
! while (1)
{
rtx next = NEXT_INSN (insn);
rtx prev = PREV_INSN (insn);
--- 1528,1534 ----
{
rtx insn = from;
! for (;;)
{
rtx next = NEXT_INSN (insn);
rtx prev = PREV_INSN (insn);
Index: local-alloc.c
===================================================================
*** local-alloc.c (revision 118098)
--- local-alloc.c (working copy)
*************** block_alloc (int b)
*** 1292,1298 ****
/* Count the instructions in the basic block. */
insn = BB_END (BASIC_BLOCK (b));
! while (1)
{
if (!NOTE_P (insn))
{
--- 1292,1298 ----
/* Count the instructions in the basic block. */
insn = BB_END (BASIC_BLOCK (b));
! for (;;)
{
if (!NOTE_P (insn))
{
*************** block_alloc (int b)
*** 1318,1324 ****
It computes which registers to tie. */
insn = BB_HEAD (BASIC_BLOCK (b));
! while (1)
{
if (!NOTE_P (insn))
insn_number++;
--- 1318,1324 ----
It computes which registers to tie. */
insn = BB_HEAD (BASIC_BLOCK (b));
! for (;;)
{
if (!NOTE_P (insn))
insn_number++;
Index: loop-iv.c
===================================================================
*** loop-iv.c (revision 118098)
--- loop-iv.c (working copy)
***************
*** 1,5 ****
/* Rtl-level induction variable analysis.
! Copyright (C) 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Rtl-level induction variable analysis.
! Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** simplify_using_initial_values (struct lo
*** 1765,1771 ****
altered = ALLOC_REG_SET (®_obstack);
! while (1)
{
insn = BB_END (e->src);
if (any_condjump_p (insn))
--- 1765,1771 ----
altered = ALLOC_REG_SET (®_obstack);
! for (;;)
{
insn = BB_END (e->src);
if (any_condjump_p (insn))
Index: pointer-set.c
===================================================================
*** pointer-set.c (revision 118098)
--- pointer-set.c (working copy)
*************** pointer_set_contains (struct pointer_set
*** 99,105 ****
{
size_t n = hash1 (p, pset->n_slots, pset->log_slots);
! while (true)
{
if (pset->slots[n] == p)
return 1;
--- 99,105 ----
{
size_t n = hash1 (p, pset->n_slots, pset->log_slots);
! for (;;)
{
if (pset->slots[n] == p)
return 1;
*************** static int
*** 121,127 ****
insert_aux (void *p, void **slots, size_t n_slots, size_t log_slots)
{
size_t n = hash1 (p, n_slots, log_slots);
! while (true)
{
if (slots[n] == p)
return 1;
--- 121,127 ----
insert_aux (void *p, void **slots, size_t n_slots, size_t log_slots)
{
size_t n = hash1 (p, n_slots, log_slots);
! for (;;)
{
if (slots[n] == p)
return 1;
Index: print-rtl.c
===================================================================
*** print-rtl.c (revision 118098)
--- print-rtl.c (working copy)
***************
*** 1,6 ****
/* Print RTL for GCC.
Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000, 2002, 2003,
! 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Print RTL for GCC.
Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999, 2000, 2002, 2003,
! 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** debug_rtx_list (rtx x, int n)
*** 692,698 ****
void
debug_rtx_range (rtx start, rtx end)
{
! while (1)
{
debug_rtx (start);
fprintf (stderr, "\n");
--- 692,698 ----
void
debug_rtx_range (rtx start, rtx end)
{
! for (;;)
{
debug_rtx (start);
fprintf (stderr, "\n");
Index: read-rtl.c
===================================================================
*** read-rtl.c (revision 118098)
--- read-rtl.c (working copy)
***************
*** 1,6 ****
/* RTL reader for GCC.
Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
! 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* RTL reader for GCC.
Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
! 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This file is part of GCC.
*************** read_skip_spaces (FILE *infile)
*** 828,834 ****
{
int c;
! while (1)
{
c = getc (infile);
switch (c)
--- 828,834 ----
{
int c;
! for (;;)
{
c = getc (infile);
switch (c)
*************** read_name (char *str, FILE *infile)
*** 884,890 ****
c = read_skip_spaces (infile);
p = str;
! while (1)
{
if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r' || c == EOF)
break;
--- 884,890 ----
c = read_skip_spaces (infile);
p = str;
! for (;;)
{
if (c == ' ' || c == '\n' || c == '\t' || c == '\f' || c == '\r' || c == EOF)
break;
*************** read_quoted_string (FILE *infile)
*** 984,990 ****
{
int c;
! while (1)
{
c = getc (infile); /* Read the string */
if (c == '\n')
--- 984,990 ----
{
int c;
! for (;;)
{
c = getc (infile); /* Read the string */
if (c == '\n')
Index: real.c
===================================================================
*** real.c (revision 118098)
--- real.c (working copy)
***************
*** 1,6 ****
/* real.c - software floating point emulation.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
! 2000, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Stephen L. Moshier (moshier@world.std.com).
Re-written by Richard Henderson <rth@redhat.com>
--- 1,6 ----
/* real.c - software floating point emulation.
Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
! 2000, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
Contributed by Stephen L. Moshier (moshier@world.std.com).
Re-written by Richard Henderson <rth@redhat.com>
*************** real_to_decimal (char *str, const REAL_V
*** 1577,1583 ****
decimal zeros. */
v = r;
! while (1)
{
/* Stop if we'd shift bits off the bottom. */
if (v.sig[0] & 7)
--- 1577,1583 ----
decimal zeros. */
v = r;
! for (;;)
{
/* Stop if we'd shift bits off the bottom. */
if (v.sig[0] & 7)
*************** real_from_string (REAL_VALUE_TYPE *r, co
*** 1818,1824 ****
while (*str == '0')
str++;
! while (1)
{
d = hex_value (*str);
if (d == _hex_bad)
--- 1818,1824 ----
while (*str == '0')
str++;
! for (;;)
{
d = hex_value (*str);
if (d == _hex_bad)
*************** real_from_string (REAL_VALUE_TYPE *r, co
*** 1844,1850 ****
while (*str == '0')
str++, exp -= 4;
}
! while (1)
{
d = hex_value (*str);
if (d == _hex_bad)
--- 1844,1850 ----
while (*str == '0')
str++, exp -= 4;
}
! for (;;)
{
d = hex_value (*str);
if (d == _hex_bad)
Index: regmove.c
===================================================================
*** regmove.c (revision 118098)
--- regmove.c (working copy)
***************
*** 1,6 ****
/* Move registers around to reduce number of move instructions needed.
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,7 ----
/* Move registers around to reduce number of move instructions needed.
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** mark_flags_life_zones (rtx flags)
*** 272,278 ****
}
#endif
! while (1)
{
/* Process liveness in reverse order of importance --
alive, death, birth. This lets more important info
--- 273,279 ----
}
#endif
! for (;;)
{
/* Process liveness in reverse order of importance --
alive, death, birth. This lets more important info
Index: reload.c
===================================================================
*** reload.c (revision 118098)
--- reload.c (working copy)
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6640,6646 ****
a value into or out of GOAL.
Stop and give up if we reach a label. */
! while (1)
{
p = PREV_INSN (p);
num++;
--- 6640,6646 ----
a value into or out of GOAL.
Stop and give up if we reach a label. */
! for (;;)
{
p = PREV_INSN (p);
num++;
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6829,6835 ****
until INSN is reached. */
p = insn;
! while (1)
{
p = PREV_INSN (p);
if (p == where)
--- 6829,6835 ----
until INSN is reached. */
p = insn;
! for (;;)
{
p = PREV_INSN (p);
if (p == where)
Index: rtl-factoring.c
===================================================================
*** rtl-factoring.c (revision 118098)
--- rtl-factoring.c (working copy)
*************** collect_pattern_seqs (void)
*** 464,470 ****
/* Propagate liveness info and mark insns where a stack reg is live. */
insn = BB_END (bb);
! while (1)
{
int reg;
for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; reg++)
--- 464,470 ----
/* Propagate liveness info and mark insns where a stack reg is live. */
insn = BB_END (bb);
! for (;;)
{
int reg;
for (reg = FIRST_STACK_REG; reg <= LAST_STACK_REG; reg++)
Index: sbitmap.c
===================================================================
*** sbitmap.c (revision 118098)
--- sbitmap.c (working copy)
***************
*** 1,5 ****
/* Simple bitmaps.
! Copyright (C) 1999, 2000, 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,6 ----
/* Simple bitmaps.
! Copyright (C) 1999, 2000, 2002, 2003, 2004, 2006
! Free Software Foundation, Inc.
This file is part of GCC.
*************** sbitmap_last_set_bit (sbitmap bmap)
*** 716,722 ****
SBITMAP_ELT_TYPE mask
= (SBITMAP_ELT_TYPE) 1 << (SBITMAP_ELT_BITS - 1);
! while (1)
{
if ((word & mask) != 0)
return index;
--- 717,723 ----
SBITMAP_ELT_TYPE mask
= (SBITMAP_ELT_TYPE) 1 << (SBITMAP_ELT_BITS - 1);
! for (;;)
{
if ((word & mask) != 0)
return index;
Index: sched-deps.c
===================================================================
*** sched-deps.c (revision 118098)
--- sched-deps.c (working copy)
*************** ds_merge (ds_t ds1, ds_t ds2)
*** 2095,2101 ****
ds = (ds1 & DEP_TYPES) | (ds2 & DEP_TYPES);
t = FIRST_SPEC_TYPE;
! do
{
if ((ds1 & t) && !(ds2 & t))
ds |= ds1 & t;
--- 2095,2101 ----
ds = (ds1 & DEP_TYPES) | (ds2 & DEP_TYPES);
t = FIRST_SPEC_TYPE;
! for (;;)
{
if ((ds1 & t) && !(ds2 & t))
ds |= ds1 & t;
*************** ds_merge (ds_t ds1, ds_t ds2)
*** 2117,2123 ****
break;
t <<= SPEC_TYPE_SHIFT;
}
- while (1);
return ds;
}
--- 2117,2122 ----
*************** check_dep_status (enum reg_note dt, ds_t
*** 2154,2160 ****
ds_t type = FIRST_SPEC_TYPE;
/* Check that dependence weakness is in proper range. */
! do
{
if (ds & type)
get_dep_weak (ds, type);
--- 2153,2159 ----
ds_t type = FIRST_SPEC_TYPE;
/* Check that dependence weakness is in proper range. */
! for (;;)
{
if (ds & type)
get_dep_weak (ds, type);
*************** check_dep_status (enum reg_note dt, ds_t
*** 2163,2169 ****
break;
type <<= SPEC_TYPE_SHIFT;
}
- while (1);
}
if (ds & BEGIN_SPEC)
--- 2162,2167 ----
Index: sched-rgn.c
===================================================================
*** sched-rgn.c (revision 118098)
--- sched-rgn.c (working copy)
***************
*** 1,6 ****
/* Instruction scheduling pass.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
--- 1,7 ----
/* Instruction scheduling pass.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
! 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
and currently maintained by, Jim Wilson (wilson@cygnus.com)
*************** find_rgns (void)
*** 561,567 ****
current_edge = ei_start (single_succ (ENTRY_BLOCK_PTR)->succs);
sp = -1;
! while (1)
{
if (EDGE_PASSED (current_edge))
{
--- 562,568 ----
current_edge = ei_start (single_succ (ENTRY_BLOCK_PTR)->succs);
sp = -1;
! for (;;)
{
if (EDGE_PASSED (current_edge))
{
Index: stmt.c
===================================================================
*** stmt.c (revision 118098)
--- stmt.c (working copy)
*************** balance_case_nodes (case_node_ptr *head,
*** 2731,2737 ****
Here I gets half the total cost. */
int n_moved = 0;
i = (cost + 1) / 2;
! while (1)
{
/* Skip nodes while their cost does not reach that amount. */
if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
--- 2731,2737 ----
Here I gets half the total cost. */
int n_moved = 0;
i = (cost + 1) / 2;
! for (;;)
{
/* Skip nodes while their cost does not reach that amount. */
if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
*************** balance_case_nodes (case_node_ptr *head,
*** 2763,2769 ****
where ranges count as 2.
Here I gets half the total cost. */
i = (i + ranges + 1) / 2;
! while (1)
{
/* Skip nodes while their cost does not reach that amount. */
if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
--- 2763,2769 ----
where ranges count as 2.
Here I gets half the total cost. */
i = (i + ranges + 1) / 2;
! for (;;)
{
/* Skip nodes while their cost does not reach that amount. */
if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
Index: tree-browser.c
===================================================================
*** tree-browser.c (revision 118098)
--- tree-browser.c (working copy)
***************
*** 1,5 ****
/* Tree browser.
! Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
This file is part of GCC.
--- 1,5 ----
/* Tree browser.
! Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
This file is part of GCC.
*************** TB_getline (char **lineptr, long *n, FIL
*** 984,990 ****
copy = size;
p = line;
! while (1)
{
long len;
--- 984,990 ----
copy = size;
p = line;
! for (;;)
{
long len;
Index: tree.c
===================================================================
*** tree.c (revision 118098)
--- tree.c (working copy)
*************** skip_simple_arithmetic (tree expr)
*** 2067,2073 ****
it will allow better simplification and GCSE will be able to merge the
computations if they actually occur. */
inner = expr;
! while (1)
{
if (UNARY_CLASS_P (inner))
inner = TREE_OPERAND (inner, 0);
--- 2067,2073 ----
it will allow better simplification and GCSE will be able to merge the
computations if they actually occur. */
inner = expr;
! for (;;)
{
if (UNARY_CLASS_P (inner))
inner = TREE_OPERAND (inner, 0);
*************** tree_fold_gcd (tree a, tree b)
*** 7163,7169 ****
b = fold_build2 (MULT_EXPR, type, b,
build_int_cst (type, -1));
! while (1)
{
a_mod_b = fold_build2 (FLOOR_MOD_EXPR, type, a, b);
--- 7163,7169 ----
b = fold_build2 (MULT_EXPR, type, b,
build_int_cst (type, -1));
! for (;;)
{
a_mod_b = fold_build2 (FLOOR_MOD_EXPR, type, a, b);
Index: tree-dfa.c
===================================================================
*** tree-dfa.c (revision 118098)
--- tree-dfa.c (working copy)
***************
*** 1,5 ****
/* Data flow functions for trees.
! Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
--- 1,6 ----
/* Data flow functions for trees.
! Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
! Free Software Foundation, Inc.
Contributed by Diego Novillo <dnovillo@redhat.com>
This file is part of GCC.
*************** get_ref_base_and_extent (tree exp, HOST_
*** 897,903 ****
/* Compute cumulative bit-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
! while (1)
{
switch (TREE_CODE (exp))
{
--- 898,904 ----
/* Compute cumulative bit-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
! for (;;)
{
switch (TREE_CODE (exp))
{
Index: tree-pretty-print.c
===================================================================
*** tree-pretty-print.c (revision 118098)
--- tree-pretty-print.c (working copy)
*************** dump_omp_clauses (pretty_printer *buffer
*** 391,397 ****
return;
pp_space (buffer);
! while (1)
{
dump_omp_clause (buffer, clause, spc, flags);
clause = OMP_CLAUSE_CHAIN (clause);
--- 391,397 ----
return;
pp_space (buffer);
! for (;;)
{
dump_omp_clause (buffer, clause, spc, flags);
clause = OMP_CLAUSE_CHAIN (clause);
*************** dump_generic_node (pretty_printer *buffe
*** 1468,1474 ****
break;
case LOOP_EXPR:
! pp_string (buffer, "while (1)");
if (!(flags & TDF_SLIM))
{
newline_and_indent (buffer, spc+2);
--- 1468,1474 ----
break;
case LOOP_EXPR:
! pp_string (buffer, "for (;;)");
if (!(flags & TDF_SLIM))
{
newline_and_indent (buffer, spc+2);
Index: tree-scalar-evolution.c
===================================================================
*** tree-scalar-evolution.c (revision 118098)
--- tree-scalar-evolution.c (working copy)
***************
*** 1,5 ****
/* Scalar evolution detector.
! Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
This file is part of GCC.
--- 1,5 ----
/* Scalar evolution detector.
! Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
Contributed by Sebastian Pop <s.pop@laposte.net>
This file is part of GCC.
*************** analyze_scalar_evolution_in_loop (struct
*** 2037,2043 ****
if (folded_casts)
*folded_casts = false;
! while (1)
{
tmp = analyze_scalar_evolution (use_loop, ev);
ev = resolve_mixers (use_loop, tmp);
--- 2037,2043 ----
if (folded_casts)
*folded_casts = false;
! for (;;)
{
tmp = analyze_scalar_evolution (use_loop, ev);
ev = resolve_mixers (use_loop, tmp);
Index: tree-sra.c
===================================================================
*** tree-sra.c (revision 118098)
--- tree-sra.c (working copy)
*************** sra_walk_expr (tree *expr_p, block_stmt_
*** 718,724 ****
we can't scalarize, we reset EXPR. This has the effect of making it
appear that we're referring to the larger expression as a whole. */
! while (1)
switch (TREE_CODE (inner))
{
case VAR_DECL:
--- 718,724 ----
we can't scalarize, we reset EXPR. This has the effect of making it
appear that we're referring to the larger expression as a whole. */
! for (;;)
switch (TREE_CODE (inner))
{
case VAR_DECL:
*************** instantiate_missing_elements (struct sra
*** 1329,1335 ****
max = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
subtype = TREE_TYPE (type);
! while (1)
{
instantiate_missing_elements_1 (elt, i, subtype);
if (tree_int_cst_equal (i, max))
--- 1329,1335 ----
max = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
subtype = TREE_TYPE (type);
! for (;;)
{
instantiate_missing_elements_1 (elt, i, subtype);
if (tree_int_cst_equal (i, max))
*************** generate_element_init_1 (struct sra_elt
*** 1806,1812 ****
tree lower = TREE_OPERAND (purpose, 0);
tree upper = TREE_OPERAND (purpose, 1);
! while (1)
{
sub = lookup_element (elt, lower, NULL, NO_INSERT);
if (sub != NULL)
--- 1806,1812 ----
tree lower = TREE_OPERAND (purpose, 0);
tree upper = TREE_OPERAND (purpose, 1);
! for (;;)
{
sub = lookup_element (elt, lower, NULL, NO_INSERT);
if (sub != NULL)
Index: tree-ssa-ccp.c
===================================================================
*** tree-ssa-ccp.c (revision 118098)
--- tree-ssa-ccp.c (working copy)
*************** ccp_decl_initial_min_invariant (tree t)
*** 286,292 ****
if (TREE_CODE (t) == ADDR_EXPR)
{
/* Inline and unroll is_gimple_addressable. */
! while (1)
{
t = TREE_OPERAND (t, 0);
if (is_gimple_id (t))
--- 286,292 ----
if (TREE_CODE (t) == ADDR_EXPR)
{
/* Inline and unroll is_gimple_addressable. */
! for (;;)
{
t = TREE_OPERAND (t, 0);
if (is_gimple_id (t))
Index: tree-ssa-forwprop.c
===================================================================
*** tree-ssa-forwprop.c (revision 118098)
--- tree-ssa-forwprop.c (working copy)
***************
*** 1,5 ****
/* Forward propagation of expressions for single use variables.
! Copyright (C) 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Forward propagation of expressions for single use variables.
! Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** forward_propagate_into_cond (tree cond_e
*** 533,539 ****
{
gcc_assert (TREE_CODE (cond_expr) == COND_EXPR);
! while (1)
{
tree test_var = NULL_TREE;
tree cond = COND_EXPR_COND (cond_expr);
--- 533,539 ----
{
gcc_assert (TREE_CODE (cond_expr) == COND_EXPR);
! for (;;)
{
tree test_var = NULL_TREE;
tree cond = COND_EXPR_COND (cond_expr);
Index: tree-ssa-loop-im.c
===================================================================
*** tree-ssa-loop-im.c (revision 118098)
--- tree-ssa-loop-im.c (working copy)
***************
*** 1,5 ****
/* Loop invariant motion.
! Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Loop invariant motion.
! Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** determine_lsm (struct loops *loops)
*** 1405,1411 ****
suitable. */
loop = loops->tree_root->inner;
! while (1)
{
determine_lsm_loop (loop);
--- 1405,1411 ----
suitable. */
loop = loops->tree_root->inner;
! for (;;)
{
determine_lsm_loop (loop);
*************** fill_always_executed_in (struct loop *lo
*** 1480,1486 ****
}
}
! while (1)
{
last->aux = loop;
if (last == loop->header)
--- 1480,1486 ----
}
}
! for (;;)
{
last->aux = loop;
if (last == loop->header)
Index: tree-ssa-loop-unswitch.c
===================================================================
*** tree-ssa-loop-unswitch.c (revision 118098)
--- tree-ssa-loop-unswitch.c (working copy)
***************
*** 1,5 ****
/* Loop unswitching.
! Copyright (C) 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Loop unswitching.
! Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** simplify_using_entry_checks (struct loop
*** 153,159 ****
edge e = loop_preheader_edge (loop);
tree stmt;
! while (1)
{
stmt = last_stmt (e->src);
if (stmt
--- 153,159 ----
edge e = loop_preheader_edge (loop);
tree stmt;
! for (;;)
{
stmt = last_stmt (e->src);
if (stmt
*************** tree_unswitch_single_loop (struct loops
*** 213,219 ****
i = 0;
bbs = get_loop_body (loop);
! while (1)
{
/* Find a bb to unswitch on. */
for (; i < loop->num_nodes; i++)
--- 213,219 ----
i = 0;
bbs = get_loop_body (loop);
! for (;;)
{
/* Find a bb to unswitch on. */
for (; i < loop->num_nodes; i++)
Index: tree-tailcall.c
===================================================================
*** tree-tailcall.c (revision 118098)
--- tree-tailcall.c (working copy)
***************
*** 1,5 ****
/* Tail call optimization on trees.
! Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
This file is part of GCC.
--- 1,5 ----
/* Tail call optimization on trees.
! Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GCC.
*************** independent_of_stmt_p (tree expr, tree a
*** 216,222 ****
bb->aux = &bb->aux;
bb->aux = &bb->aux;
! while (1)
{
at = SSA_NAME_DEF_STMT (expr);
bb = bb_for_stmt (at);
--- 216,222 ----
bb->aux = &bb->aux;
bb->aux = &bb->aux;
! for (;;)
{
at = SSA_NAME_DEF_STMT (expr);
bb = bb_for_stmt (at);
*************** find_tail_calls (basic_block bb, struct
*** 473,479 ****
abb = bb;
absi = bsi;
! while (1)
{
bsi_next (&absi);
--- 473,479 ----
abb = bb;
absi = bsi;
! for (;;)
{
bsi_next (&absi);
Index: varasm.c
===================================================================
*** varasm.c (revision 118098)
--- varasm.c (working copy)
*************** decode_addr_const (tree exp, struct addr
*** 2359,2365 ****
int offset = 0;
rtx x;
! while (1)
{
if (TREE_CODE (target) == COMPONENT_REF
&& host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
--- 2359,2365 ----
int offset = 0;
rtx x;
! for (;;)
{
if (TREE_CODE (target) == COMPONENT_REF
&& host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
Roger
--