* gbl-ctors.h: Fix formatting.
* gcc.c: Likewise.
* gccspec.c: Likewise.
* gcov.c: Likewise.
* gcov-io.h: Likewise.
* gcse.c: Likewise.
* ggc-common.c: Likewise.
* ggc.h: Likewise.
* ggc-page.c: Likewise.
* ggc-simple.c: Likewise.
* global.c: Likewise.
* graph.h: Likewise.
* gthr-dce.h: Likewise.
* gthr.h: Likewise.
* gthr-posix.h: Likewise.
* gthr-rtems.h: Likewise.
* gthr-solaris.h: Likewise.
* gthr-win32.h: Likewise.
From-SVN: r54240
+2002-06-04 Kazu Hirata <kazu@cs.umass.edu>
+
+ * gbl-ctors.h: Fix formatting.
+ * gcc.c: Likewise.
+ * gccspec.c: Likewise.
+ * gcov.c: Likewise.
+ * gcov-io.h: Likewise.
+ * gcse.c: Likewise.
+ * ggc-common.c: Likewise.
+ * ggc.h: Likewise.
+ * ggc-page.c: Likewise.
+ * ggc-simple.c: Likewise.
+ * global.c: Likewise.
+ * graph.h: Likewise.
+ * gthr-dce.h: Likewise.
+ * gthr.h: Likewise.
+ * gthr-posix.h: Likewise.
+ * gthr-rtems.h: Likewise.
+ * gthr-solaris.h: Likewise.
+ * gthr-win32.h: Likewise.
+
2002-06-03 Geoffrey Keating <geoffk@redhat.com>
Merge from pch-branch:
2002-06-02 Kazu Hirata <kazu@cs.umass.edu>
- * emit-rtl.c: Likewise.
+ * emit-rtl.c: Fix formatting.
* errors.h: Likewise.
* except.c: Likewise.
* explow.c: Likewise.
for (nptrs = 0; __CTOR_LIST__[nptrs + 1] != 0; nptrs++); \
for (i = nptrs; i >= 1; i--) \
__CTOR_LIST__[i] (); \
-} while (0)
+} while (0)
#endif
}
modify_target[] = MODIFY_TARGET_NAME;
#endif
-
+
/* The number of errors that have occurred; the link phase will not be
run if this is non-zero. */
static int error_count = 0;
{
const char *p = libgcc_spec;
int in_sep = 1;
-
+
/* Transform the extant libgcc_spec into one that uses the shared libgcc
when given the proper command line arguments. */
while (*p)
{
- if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
+ if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
{
init_gcc_specs (&obstack,
#ifdef NO_SHARED_LIBGCC_MULTILIB
{
const char *const *j;
- if (verbose_only_flag)
- {
+ if (verbose_only_flag)
+ {
for (j = commands[i].argv; *j; j++)
{
const char *p;
}
fputc ('"', stderr);
}
- }
- else
+ }
+ else
for (j = commands[i].argv; *j; j++)
fprintf (stderr, " %s", *j);
}
fflush (stderr);
if (verbose_only_flag != 0)
- return 0;
+ return 0;
#ifdef DEBUG
notice ("\nGo ahead? (y or n) ");
fflush (stderr);
add_linker_option ("--help", 6);
}
else if (strcmp (argv[i], "-ftarget-help") == 0)
- {
- /* translate_options() has turned --target-help into -ftarget-help. */
- target_help_flag = 1;
+ {
+ /* translate_options() has turned --target-help into -ftarget-help. */
+ target_help_flag = 1;
- /* We will be passing a dummy file on to the sub-processes. */
- n_infiles++;
- n_switches++;
+ /* We will be passing a dummy file on to the sub-processes. */
+ n_infiles++;
+ n_switches++;
/* CPP driver cannot obtain switch from cc1_options. */
if (is_cpp_driver)
add_preprocessor_option ("--target-help", 13);
- add_assembler_option ("--target-help", 13);
- add_linker_option ("--target-help", 13);
- }
+ add_assembler_option ("--target-help", 13);
+ add_linker_option ("--target-help", 13);
+ }
else if (! strcmp (argv[i], "-pass-exit-codes"))
{
pass_exit_codes = 1;
tmp[++ len] = 0;
value = tmp;
}
-
+
/* As a kludge, if the arg is "[foo/]stageN/", just
add "[foo/]include" to the include prefix. */
if ((len == 7
if (is_modify_target_name)
break;
-#endif
+#endif
n_switches++;
/* -save-temps overrides -pipe, so that temp files are produced */
if (save_temps_flag)
error ("warning: -pipe ignored because -save-temps specified");
- /* -time overrides -pipe because we can't get correct stats when
+ /* -time overrides -pipe because we can't get correct stats when
multiple children are running at once. */
else if (report_times)
error ("warning: -pipe ignored because -time specified");
}
suffix_length += strlen (TARGET_OBJECT_SUFFIX);
}
-
+
/* If the input_filename has the same suffix specified
for the %g, %u, or %U, and -save-temps is specified,
we could end up using that file as an intermediate
gcc -save-temps foo.s would clobber foo.s with the
output of cpp0). So check for this condition and
generate a temp file as the intermediate. */
-
+
if (save_temps_flag)
{
temp_filename_length = basename_length + suffix_length;
if (strcmp (temp_filename, input_filename) != 0)
{
struct stat st_temp;
-
+
/* Note, set_input() resets input_stat_set to 0. */
if (input_stat_set == 0)
{
if (input_stat_set >= 0)
input_stat_set = 1;
}
-
+
/* If we have the stat for the input_filename
and we can do the stat for the temp_filename
then the they could still refer to the same
file if st_dev/st_ino's are the same. */
-
+
if (input_stat_set != 1
|| stat (temp_filename, &st_temp) < 0
|| input_stat.st_dev != st_temp.st_dev
|| input_stat.st_ino != st_temp.st_ino)
- {
+ {
temp_filename = save_string (temp_filename,
temp_filename_length + 1);
obstack_grow (&obstack, temp_filename,
case 'C':
{
const char *const spec
- = (input_file_compiler->cpp_spec
- ? input_file_compiler->cpp_spec
+ = (input_file_compiler->cpp_spec
+ ? input_file_compiler->cpp_spec
: cpp_spec);
value = do_spec_1 (spec, 0, NULL);
if (value != 0)
obstack_1grow (&obstack, '%');
break;
- case '.':
- {
- unsigned len = 0;
+ case '.':
+ {
+ unsigned len = 0;
- while (p[len] && p[len] != ' ' && p[len] != '%')
- len++;
- suffix_subst = save_string (p - 1, len + 1);
- p += len;
- }
+ while (p[len] && p[len] != ' ' && p[len] != '%')
+ len++;
+ suffix_subst = save_string (p - 1, len + 1);
+ p += len;
+ }
break;
-
+
case '*':
if (soft_matched_part)
{
}
else
input_suffix = "";
-
+
/* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
we will need to do a stat on the input_filename. The
INPUT_STAT_SET signals that the stat is needed. */
input_file_compiler
= lookup_compiler (infiles[i].name, input_filename_length,
infiles[i].language);
-
+
if (input_file_compiler)
{
/* Ok, we found an applicable compiler. Run its spec. */
&& !strcmp (cp->suffix,
name + length - strlen (cp->suffix))
))
- break;
+ break;
}
#if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
}
else
{
- int len;
+ int len;
/* If the filename ends in .m or .mi, we are compiling ObjC
and want to pass -shared-libgcc. */
if (value && value != -1)
return 1;
- for(; i < bytes ; i++)
+ for(; i < bytes ; i++)
dest[i] = 0;
dest[bytes - 1] |= upper_bit;
return 0;
__read_long (&function_name_len, bbg_file, 4);
function_name = xmalloc (function_name_len + 1);
fread (function_name, 1, function_name_len + 1, bbg_file);
-
+
/* Skip padding. */
tmp = (function_name_len + 1) % 4;
fseek (bbg_file, 4 - tmp, SEEK_CUR);
__read_long (&tmp, bbg_file, 4); /* ignore -1. */
-
+
/* Read the cfg checksum. */
__read_long (&cfg_checksum, bbg_file, 4);
__read_long (&flag_bits, bbg_file, 4);
if (flag_bits & 0x1)
arcptr->on_tree++;
- else
+ else
instr_arcs++;
arcptr->fake = !! (flag_bits & 0x2);
arcptr->fall_through = !! (flag_bits & 0x4);
a_ptr = (struct arcdata *) xmalloc (sizeof (struct arcdata));
a_ptr->total = total;
if (total == 0)
- a_ptr->hits = 0;
+ a_ptr->hits = 0;
else
- a_ptr->hits = arcptr->arc_count;
+ a_ptr->hits = arcptr->arc_count;
a_ptr->call_insn = arcptr->fake;
if (output_function_summary)
((a_ptr->hits * 100)
+ (a_ptr->total >> 1))
/ a_ptr->total);
- fnotice (gcov_file,
- "branch %d taken = %s%%\n", i, c);
+ fnotice (gcov_file,
+ "branch %d taken = %s%%\n", i, c);
}
}
}
#include "basic-block.h"
#include "output.h"
#include "function.h"
-#include "expr.h"
+#include "expr.h"
#include "except.h"
#include "ggc.h"
#include "params.h"
#define REG_SET_TABLE_SLOP 100
/* This is a list of expressions which are MEMs and will be used by load
- or store motion.
+ or store motion.
Load motion tracks MEMs which aren't killed by
anything except itself. (ie, loads and stores to a single location).
- We can then allow movement of these MEM refs with a little special
+ We can then allow movement of these MEM refs with a little special
allowance. (all stores copy the same value to the reaching reg used
for the loads). This means all values used to store into memory must have
- no side effects so we can re-issue the setter value.
+ no side effects so we can re-issue the setter value.
Store Motion uses this structure as an expression table to track stores
which look interesting, and might be moveable towards the exit block. */
static void alloc_pre_mem PARAMS ((int, int));
static void free_pre_mem PARAMS ((void));
static void compute_pre_data PARAMS ((void));
-static int pre_expr_reaches_here_p PARAMS ((basic_block, struct expr *,
+static int pre_expr_reaches_here_p PARAMS ((basic_block, struct expr *,
basic_block));
static void insert_insn_end_bb PARAMS ((struct expr *, basic_block, int));
static void pre_insert_copy_insn PARAMS ((struct expr *, rtx));
static void free_code_hoist_mem PARAMS ((void));
static void compute_code_hoist_vbeinout PARAMS ((void));
static void compute_code_hoist_data PARAMS ((void));
-static int hoist_expr_reaches_here_p PARAMS ((basic_block, int, basic_block,
+static int hoist_expr_reaches_here_p PARAMS ((basic_block, int, basic_block,
char *));
static void hoist_code PARAMS ((void));
static int one_code_hoisting_pass PARAMS ((void));
static inline struct ls_expr * next_ls_expr PARAMS ((struct ls_expr *));
static int simple_mem PARAMS ((rtx));
static void invalidate_any_buried_refs PARAMS ((rtx));
-static void compute_ld_motion_mems PARAMS ((void));
+static void compute_ld_motion_mems PARAMS ((void));
static void trim_ld_motion_mems PARAMS ((void));
static void update_ld_motion_stores PARAMS ((struct expr *));
static void reg_set_info PARAMS ((rtx, rtx, void *));
static void insert_insn_start_bb PARAMS ((rtx, basic_block));
static int insert_store PARAMS ((struct ls_expr *, edge));
static void replace_store_insn PARAMS ((rtx, rtx, basic_block));
-static void delete_store PARAMS ((struct ls_expr *,
+static void delete_store PARAMS ((struct ls_expr *,
basic_block));
static void free_store_memory PARAMS ((void));
static void store_motion PARAMS ((void));
setjmp, so just punt to be safe. */
if (current_function_calls_setjmp)
return 0;
-
+
/* Assume that we do not need to run jump optimizations after gcse. */
run_jump_opt_after_gcse = 0;
/* If allocating memory for the cprop bitmap would take up too much
storage it's better just to disable the optimization. */
- if ((n_basic_blocks
+ if ((n_basic_blocks
* SBITMAP_SET_SIZE (max_gcse_regno)
* sizeof (SBITMAP_ELT_TYPE)) > MAX_GCSE_MEMORY)
{
if (optimize_size)
changed |= one_classic_gcse_pass (pass + 1);
else
- {
+ {
changed |= one_pre_gcse_pass (pass + 1);
/* We may have just created new basic blocks. Release and
recompute various things which are sized on the number of
for space, we use a classic gcse algorithm instead of partial
redundancy algorithms). */
if (optimize_size)
- {
+ {
max_gcse_regno = max_reg_num ();
alloc_gcse_mem (f);
changed |= one_code_hoisting_pass ();
if (max_pass_bytes < bytes_used)
max_pass_bytes = bytes_used;
- }
+ }
if (file)
{
the expr hash table; if nonzero this routine looks at the set hash table.
Additionally, TRANSP is computed as ~TRANSP, since this is really cprop's
ABSALTERED. */
-
+
static void
compute_local_properties (transp, comp, antloc, setp)
sbitmap *transp;
{
unsigned int i, hash_table_size;
struct expr **hash_table;
-
+
/* Initialize any bitmaps that were passed in. */
if (transp)
{
if (info->last_bb != current_bb)
return 1;
- if (avail_p)
+ if (avail_p)
return info->last_set < INSN_CUID (insn);
else
return info->first_set >= INSN_CUID (insn);
return;
/* If we are setting a MEM in our list of specially recognized MEMs,
- don't mark as killed this time. */
-
+ don't mark as killed this time. */
+
if (dest == gcse_mem_operand && pre_ldst_mems != NULL)
{
if (!find_rtx_in_ldst (dest))
return 1;
/* SETTER must be an INSN of some kind that sets memory. Call
- note_stores to examine each hunk of memory that is modified.
+ note_stores to examine each hunk of memory that is modified.
The note_stores interface is pretty limited, so we have to
communicate via global variables. Yuk. */
{
unsigned hash = 0;
const unsigned char *p = (const unsigned char *) ps;
-
+
if (p)
while (*p)
hash += *p++;
/* Add EXPR to end of this hash chain. */
last_expr->next_same_hash = cur_expr;
- /* Set the fields of the expr element. */
+ /* Set the fields of the expr element. */
cur_expr->expr = x;
cur_expr->bitmap_index = n_exprs++;
cur_expr->next_same_hash = NULL;
unsigned int *hash_val;
struct expr *expr;
- flat_table
+ flat_table
= (struct expr **) xcalloc (total_size, sizeof (struct expr *));
hash_val = (unsigned int *) xmalloc (total_size * sizeof (unsigned int));
Note we store a pair of elements in the list, so they have to be
taken off pairwise. */
-static void
+static void
canon_list_insert (dest, unused1, v_insn)
rtx dest ATTRIBUTE_UNUSED;
rtx unused1 ATTRIBUTE_UNUSED;
dest_addr = get_addr (XEXP (dest, 0));
dest_addr = canon_rtx (dest_addr);
- insn = (rtx) v_insn;
+ insn = (rtx) v_insn;
bb = BLOCK_NUM (insn);
- canon_modify_mem_list[bb] =
+ canon_modify_mem_list[bb] =
alloc_EXPR_LIST (VOIDmode, dest_addr, canon_modify_mem_list[bb]);
- canon_modify_mem_list[bb] =
+ canon_modify_mem_list[bb] =
alloc_EXPR_LIST (VOIDmode, dest, canon_modify_mem_list[bb]);
bitmap_set_bit (canon_modify_mem_list_set, bb);
}
/* Note that traversals of this loop (other than for free-ing)
will break after encountering a CALL_INSN. So, there's no
need to insert a pair of items, as canon_list_insert does. */
- canon_modify_mem_list[bb] =
- alloc_INSN_LIST (insn, canon_modify_mem_list[bb]);
+ canon_modify_mem_list[bb] =
+ alloc_INSN_LIST (insn, canon_modify_mem_list[bb]);
bitmap_set_bit (canon_modify_mem_list_set, bb);
}
else
if (GET_CODE (insn) == CALL_INSN)
{
bool clobbers_all = false;
-#ifdef NON_SAVING_SETJMP
+#ifdef NON_SAVING_SETJMP
if (NON_SAVING_SETJMP
&& find_reg_note (insn, REG_SETJMP, NULL_RTX))
clobbers_all = true;
if (INSN_P (insn))
{
if (find_reg_note (insn, REG_LIBCALL, NULL_RTX))
- in_libcall_block = 1;
- else if (set_p && find_reg_note (insn, REG_RETVAL, NULL_RTX))
- in_libcall_block = 0;
- hash_scan_insn (insn, set_p, in_libcall_block);
- if (!set_p && find_reg_note (insn, REG_RETVAL, NULL_RTX))
- in_libcall_block = 0;
+ in_libcall_block = 1;
+ else if (set_p && find_reg_note (insn, REG_RETVAL, NULL_RTX))
+ in_libcall_block = 0;
+ hash_scan_insn (insn, set_p, in_libcall_block);
+ if (!set_p && find_reg_note (insn, REG_RETVAL, NULL_RTX))
+ in_libcall_block = 0;
}
}
return 1;
case MEM:
- if (load_killed_in_block_p (BLOCK_FOR_INSN (insn),
+ if (load_killed_in_block_p (BLOCK_FOR_INSN (insn),
INSN_CUID (insn), x, 0))
return 0;
else
}
}
-/* Compute the reaching definitions as in
+/* Compute the reaching definitions as in
Compilers Principles, Techniques, and Tools. Aho, Sethi, Ullman,
Chapter 10. It is the same algorithm as used for computing available
expressions but applied to the gens and kills of reaching definitions. */
else
{
visited[pred_bb->index] = 1;
- if (expr_reaches_here_p_work (occr, expr, pred_bb, check_self_loop,
+ if (expr_reaches_here_p_work (occr, expr, pred_bb, check_self_loop,
visited))
return 1;
char *visited = (char *) xcalloc (last_basic_block, 1);
rval = expr_reaches_here_p_work (occr, expr, bb, check_self_loop, visited);
-
+
free (visited);
return rval;
}
basic_block bb = BLOCK_FOR_INSN (insn);
if (expr->avail_occr->next == NULL)
- {
+ {
if (BLOCK_FOR_INSN (expr->avail_occr->insn) == bb)
/* The available expression is actually itself
(i.e. a loop in the flow graph) so do nothing. */
else
{
/* Pattern is computed more than once.
- Search backwards from this insn to see how many of these
+ Search backwards from this insn to see how many of these
computations actually reach this insn. */
struct occr *occr;
rtx insn_computes_expr = NULL;
return 0;
}
- *addr_this_reg = this_reg;
+ *addr_this_reg = this_reg;
}
return number_of_reaching_defs;
REGNO (SET_DEST (PATTERN (NEXT_INSN
(insn_computes_expr)))));
fprintf (gcse_file, "set in insn %d\n",
- INSN_UID (insn_computes_expr));
+ INSN_UID (insn_computes_expr));
}
}
}
dest = XEXP (list_entry, 0);
list_entry = XEXP (list_entry, 1);
dest_addr = XEXP (list_entry, 0);
-
+
if (canon_true_dependence (dest, GET_MODE (dest), dest_addr,
x, rtx_addr_varies_p))
{
/* SET1 contains the last set found that can be returned to the caller for
use in a substitution. */
struct expr *set1 = 0;
-
+
/* Loops are not possible here. To get a loop we would need two sets
available at the start of the block containing INSN. ie we would
need two sets like this available at the start of the block:
/* If no available set was found we've reached the end of the
(possibly empty) copy chain. */
if (set == 0)
- break;
+ break;
if (GET_CODE (set->expr) != SET)
abort ();
/* We know the set is available.
Now check that SRC is ANTLOC (i.e. none of the source operands
- have changed since the start of the block).
+ have changed since the start of the block).
If the source operand changed, we may still use it for the next
iteration of this loop, but we may not use it for substitutions. */
it is the instruction that immediately preceeds JUMP, and must be a
single SET of a register. FROM is what we will try to replace,
SRC is the constant we will try to substitute for it. Returns nonzero
- if a change was made. */
+ if a change was made. */
static int
cprop_jump (bb, setcc, jump, from, src)
register. */
if (rtx_equal_p (new, new_set))
return 0;
-
+
/* If this is now a no-op delete it, otherwise this must be a valid insn. */
if (new == pc_rtx)
delete_insn (jump);
reg_use_count = 0;
note_uses (&PATTERN (insn), find_used_regs, NULL);
-
+
note = find_reg_equal_equiv_note (insn);
/* We may win even when propagating constants into notes. */
set = find_avail_set (regno, insn);
if (! set)
continue;
-
+
pat = set->expr;
/* ??? We might be able to handle PARALLELs. Later. */
if (GET_CODE (pat) != SET)
if (alter_jumps
&& (sset = single_set (insn)) != NULL
&& any_condjump_p (NEXT_INSN (insn))
- && onlyjump_p (NEXT_INSN (insn)))
+ && onlyjump_p (NEXT_INSN (insn)))
{
rtx dest = SET_DEST (sset);
if ((REG_P (dest) || CC0_P (dest))
for (i = 0; i < reg_use_count; i++)
{
struct reg_use *reg_used = ®_use_table[i];
- unsigned int regno = REGNO (reg_used->reg_rtx);
+ unsigned int regno = REGNO (reg_used->reg_rtx);
basic_block dest, old_dest;
- struct expr *set;
- rtx src, new;
+ struct expr *set;
+ rtx src, new;
- if (regno >= max_gcse_regno)
- continue;
+ if (regno >= max_gcse_regno)
+ continue;
- set = find_bypass_set (regno, e->src->index);
+ set = find_bypass_set (regno, e->src->index);
if (! set)
continue;
- src = SET_SRC (pc_set (jump));
+ src = SET_SRC (pc_set (jump));
if (setcc != NULL)
src = simplify_replace_rtx (src,
- SET_DEST (PATTERN (setcc)),
- SET_SRC (PATTERN (setcc)));
+ SET_DEST (PATTERN (setcc)),
+ SET_SRC (PATTERN (setcc)));
new = simplify_replace_rtx (src, reg_used->reg_rtx,
- SET_SRC (set->expr));
+ SET_SRC (set->expr));
- if (new == pc_rtx)
+ if (new == pc_rtx)
dest = FALLTHRU_EDGE (bb)->dest;
else if (GET_CODE (new) == LABEL_REF)
dest = BRANCH_EDGE (bb)->dest;
changed = 0;
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb->next_bb,
- EXIT_BLOCK_PTR, next_bb)
+ EXIT_BLOCK_PTR, next_bb)
{
/* Check for more than one predecessor. */
if (bb->pred && bb->pred->pred_next)
sbitmap_vector_free (antloc);
antloc = NULL;
sbitmap_vector_free (ae_kill);
- ae_kill = NULL;
+ ae_kill = NULL;
sbitmap_free (trapping_expr);
}
\f
\f
/* Given an expr, generate RTL which we can insert at the end of a BB,
- or on an edge. Set the block number of any insns generated to
+ or on an edge. Set the block number of any insns generated to
the value of BB. */
static rtx
expression to make sure we don't have any sharing issues. */
else if (insn_invalid_p (emit_insn (gen_rtx_SET (VOIDmode, reg, exp))))
abort ();
-
+
pat = gen_sequence ();
end_sequence ();
return pat;
}
-
+
/* Add EXPR to the end of basic block BB.
This is used by both the PRE and code hoisting.
Check this. */
if (GET_CODE (insn) == INSN && pre
&& !TEST_BIT (antloc[bb->index], expr->bitmap_index)
- && !TEST_BIT (transp[bb->index], expr->bitmap_index))
+ && !TEST_BIT (transp[bb->index], expr->bitmap_index))
abort ();
/* If this is a jump table, then we can't insert stuff here. Since
/* Keeping in mind SMALL_REGISTER_CLASSES and parameters in registers,
we search backward and place the instructions before the first
parameter is loaded. Do this for everyone for consistency and a
- presumtion that we'll get better code elsewhere as well.
+ presumtion that we'll get better code elsewhere as well.
It should always be the case that we can put these instructions
anywhere in the basic block with performing PRE optimizations.
if (pre
&& !TEST_BIT (antloc[bb->index], expr->bitmap_index)
- && !TEST_BIT (transp[bb->index], expr->bitmap_index))
+ && !TEST_BIT (transp[bb->index], expr->bitmap_index))
abort ();
/* Since different machines initialize their parameter registers
continue;
/* Or if the expression doesn't reach the deleted one. */
- if (! pre_expr_reaches_here_p (BLOCK_FOR_INSN (avail->insn),
+ if (! pre_expr_reaches_here_p (BLOCK_FOR_INSN (avail->insn),
expr,
BLOCK_FOR_INSN (occr->insn)))
continue;
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_LABEL, XEXP (x, 0),
REG_NOTES (insn));
if (LABEL_P (XEXP (x, 0)))
- LABEL_NUSES (XEXP (x, 0))++;
+ LABEL_NUSES (XEXP (x, 0))++;
return;
}
if (GET_CODE (XEXP (expr->expr, 0)) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (XEXP (expr->expr, 0)))
continue;
-
+
/* ??? Optimally, we would use interprocedural alias
analysis to determine if this mem is actually killed
by this call. */
basic_block bb, current_block;
sbitmap *nonnull_local = npi->nonnull_local;
sbitmap *nonnull_killed = npi->nonnull_killed;
-
+
/* Compute local properties, nonnull and killed. A register will have
the nonnull property if at the end of the current block its value is
known to be nonnull. The killed property indicates that somewhere in
delete_insn (last_insn);
if (compare_and_branch == 2)
- delete_insn (earliest);
+ delete_insn (earliest);
purge_dead_edges (bb);
/* Don't check this block again. (Note that BLOCK_END is
- invalid here; we deleted the last instruction in the
+ invalid here; we deleted the last instruction in the
block.) */
block_reg[bb->index] = 0;
}
So, if every path leading to a conditional branch has an available memory
reference of that form, then we know the register can not have the value
- zero at the conditional branch.
+ zero at the conditional branch.
So we merely need to compute the local properies and propagate that data
around the cfg, then optimize where possible.
if (!condition
|| (GET_CODE (condition) != NE && GET_CODE (condition) != EQ)
|| GET_CODE (XEXP (condition, 1)) != CONST_INT
- || (XEXP (condition, 1)
+ || (XEXP (condition, 1)
!= CONST0_RTX (GET_MODE (XEXP (condition, 0)))))
continue;
{
edge pred;
int visited_allocated_locally = 0;
-
+
if (visited == NULL)
{
break;
}
}
- if (visited_allocated_locally)
+ if (visited_allocated_locally)
free (visited);
return (pred == NULL);
continue;
/* Note if the expression would reach the dominated block
- unimpared if it was placed at the end of BB.
+ unimpared if it was placed at the end of BB.
Keep track of how many times this expression is hoistable
from a dominated block into BB. */
}
}
}
-
+
/* If we found nothing to hoist, then quit now. */
if (! found)
continue;
abort ();
insn = occr->insn;
-
+
set = single_set (insn);
if (! set)
abort ();
}
'i' is both loaded and stored to in the loop. Normally, gcse cannot move
- the load out since its live around the loop, and stored at the bottom
- of the loop.
+ the load out since its live around the loop, and stored at the bottom
+ of the loop.
- The 'Load Motion' referred to and implemented in this file is
+ The 'Load Motion' referred to and implemented in this file is
an enhancement to gcse which when using edge based lcm, recognizes
this situation and allows gcse to move the load out of the loop.
ptr->hash_index = 0;
pre_ldst_mems = ptr;
}
-
+
return ptr;
}
/* Free up an individual ldst entry. */
-static void
+static void
free_ldst_entry (ptr)
struct ls_expr * ptr;
{
static void
free_ldst_mems ()
{
- while (pre_ldst_mems)
+ while (pre_ldst_mems)
{
struct ls_expr * tmp = pre_ldst_mems;
rtx x;
{
struct ls_expr * ptr;
-
+
for (ptr = pre_ldst_mems; ptr != NULL; ptr = ptr->next)
if (expr_equiv_p (ptr->pattern, x) && ! ptr->invalid)
return ptr;
side effects. These are the types of loads we consider for the
ld_motion list, otherwise we let the usual aliasing take care of it. */
-static int
+static int
simple_mem (x)
rtx x;
{
if (GET_CODE (x) != MEM)
return 0;
-
+
if (MEM_VOLATILE_P (x))
return 0;
-
+
if (GET_MODE (x) == BLKmode)
return 0;
if (!rtx_varies_p (XEXP (x, 0), 0))
return 1;
-
+
return 0;
}
-/* Make sure there isn't a buried reference in this pattern anywhere.
- If there is, invalidate the entry for it since we're not capable
- of fixing it up just yet.. We have to be sure we know about ALL
+/* Make sure there isn't a buried reference in this pattern anywhere.
+ If there is, invalidate the entry for it since we're not capable
+ of fixing it up just yet.. We have to be sure we know about ALL
loads since the aliasing code will allow all entries in the
ld_motion list to not-alias itself. If we miss a load, we will get
- the wrong value since gcse might common it and we won't know to
+ the wrong value since gcse might common it and we won't know to
fix it up. */
static void
/* Recursively process the insn. */
fmt = GET_RTX_FORMAT (GET_CODE (x));
-
+
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
/* Find all the 'simple' MEMs which are used in LOADs and STORES. Simple
being defined as MEM loads and stores to symbols, with no
- side effects and no registers in the expression. If there are any
+ side effects and no registers in the expression. If there are any
uses/defs which don't match this criteria, it is invalidated and
trimmed out later. */
-static void
+static void
compute_ld_motion_mems ()
{
struct ls_expr * ptr;
basic_block bb;
rtx insn;
-
+
pre_ldst_mems = NULL;
FOR_EACH_BB (bb)
/* Make sure there isn't a buried load somewhere. */
invalidate_any_buried_refs (src);
}
-
+
/* Check for stores. Don't worry about aliased ones, they
will block any movement we might do later. We only care
about this exact pattern since those are the only
if (GET_CODE (dest) == MEM && simple_mem (dest))
{
ptr = ldst_entry (dest);
-
+
if (GET_CODE (src) != MEM
&& GET_CODE (src) != ASM_OPERANDS)
ptr->stores = alloc_INSN_LIST (insn, ptr->stores);
}
}
-/* Remove any references that have been either invalidated or are not in the
+/* Remove any references that have been either invalidated or are not in the
expression list for pre gcse. */
static void
{
int del = ptr->invalid;
struct expr * expr = NULL;
-
+
/* Delete if entry has been made invalid. */
- if (!del)
+ if (!del)
{
unsigned int i;
-
+
del = 1;
/* Delete if we cannot find this mem in the expression list. */
for (i = 0; i < expr_hash_table_size && del; i++)
{
- for (expr = expr_hash_table[i];
- expr != NULL;
+ for (expr = expr_hash_table[i];
+ expr != NULL;
expr = expr->next_same_hash)
if (expr_equiv_p (expr->expr, ptr->pattern))
{
}
}
}
-
+
if (del)
{
if (last != NULL)
if ((mem_ptr = find_rtx_in_ldst (expr->expr)))
{
- /* We can try to find just the REACHED stores, but is shouldn't
- matter to set the reaching reg everywhere... some might be
+ /* We can try to find just the REACHED stores, but is shouldn't
+ matter to set the reaching reg everywhere... some might be
dead and should be eliminated later. */
/* We replace SET mem = expr with
SET reg = expr
- SET mem = reg , where reg is the
+ SET mem = reg , where reg is the
reaching reg used in the load. */
rtx list = mem_ptr->stores;
-
+
for ( ; list != NULL_RTX; list = XEXP (list, 1))
{
rtx insn = XEXP (list, 0);
/* If we've already copied it, continue. */
if (expr->reaching_reg == src)
continue;
-
+
if (gcse_file)
{
fprintf (gcse_file, "PRE: store updated with reaching reg ");
print_inline_rtx (gcse_file, insn, 8);
fprintf (gcse_file, "\n");
}
-
+
copy = gen_move_insn ( reg, SET_SRC (pat));
new = emit_insn_before (copy, insn);
record_one_set (REGNO (reg), new);
\f
/* Store motion code. */
-/* This is used to communicate the target bitvector we want to use in the
+/* This is used to communicate the target bitvector we want to use in the
reg_set_info routine when called via the note_stores mechanism. */
static sbitmap * regvec;
SET_BIT (*regvec, REGNO (dest));
}
-/* Return non-zero if the register operands of expression X are killed
+/* Return non-zero if the register operands of expression X are killed
anywhere in basic block BB. */
static int
i = GET_RTX_LENGTH (code) - 1;
fmt = GET_RTX_FORMAT (code);
-
+
for (; i >= 0; i--)
{
if (fmt[i] == 'e')
x = tem;
goto repeat;
}
-
+
if (! store_ops_ok (tem, bb))
return 0;
}
else if (fmt[i] == 'E')
{
int j;
-
+
for (j = 0; j < XVECLEN (x, i); j++)
{
if (! store_ops_ok (XVECEXP (x, i, j), bb))
return;
dest = SET_DEST (dest);
-
+
if (GET_CODE (dest) != MEM || MEM_VOLATILE_P (dest)
|| GET_MODE (dest) == BLKmode)
return;
if (GET_CODE (insn) == CALL_INSN)
{
bool clobbers_all = false;
-#ifdef NON_SAVING_SETJMP
+#ifdef NON_SAVING_SETJMP
if (NON_SAVING_SETJMP
&& find_reg_note (insn, REG_SETJMP, NULL_RTX))
clobbers_all = true;
|| TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
SET_BIT (reg_set_in_block[bb->index], regno);
}
-
+
pat = PATTERN (insn);
note_stores (pat, reg_set_info, NULL);
-
+
/* Now that we've marked regs, look for stores. */
if (GET_CODE (pat) == SET)
find_moveable_store (insn);
}
ret = enumerate_ldsts ();
-
+
if (gcse_file)
{
fprintf (gcse_file, "Store Motion Expressions.\n");
print_ldst_list (gcse_file);
}
-
+
return ret;
}
return 0;
}
-/* Go through the entire insn X, looking for any loads which might alias
+/* Go through the entire insn X, looking for any loads which might alias
STORE_PATTERN. Return 1 if found. */
static int
if (!x)
return 0;
- if (GET_CODE (x) == SET)
+ if (GET_CODE (x) == SET)
x = SET_SRC (x);
if (GET_CODE (x) == MEM)
/* Recursively process the insn. */
fmt = GET_RTX_FORMAT (GET_CODE (x));
-
+
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0 && !ret; i--)
{
if (fmt[i] == 'e')
return ret;
}
-/* Check if INSN kills the store pattern X (is aliased with it).
+/* Check if INSN kills the store pattern X (is aliased with it).
Return 1 if it it does. */
-static int
+static int
store_killed_in_insn (x, insn)
rtx x, insn;
{
if (GET_RTX_CLASS (GET_CODE (insn)) != 'i')
return 0;
-
+
if (GET_CODE (insn) == CALL_INSN)
{
/* A normal or pure call might read from pattern,
but a const call will not. */
return ! CONST_OR_PURE_CALL_P (insn) || pure_call_p (insn);
}
-
+
if (GET_CODE (PATTERN (insn)) == SET)
{
rtx pat = PATTERN (insn);
/* Returns 1 if the expression X is loaded or clobbered on or after INSN
within basic block BB. */
-static int
+static int
store_killed_after (x, insn, bb)
rtx x, insn;
basic_block bb;
{
rtx last = bb->end;
-
+
if (insn == last)
return 0;
/* Check if the register operands of the store are OK in this block.
- Note that if registers are changed ANYWHERE in the block, we'll
- decide we can't move it, regardless of whether it changed above
+ Note that if registers are changed ANYWHERE in the block, we'll
+ decide we can't move it, regardless of whether it changed above
or below the store. This could be improved by checking the register
operands while lookinng for aliasing in each insn. */
if (!store_ops_ok (XEXP (x, 0), bb))
for ( ; insn && insn != NEXT_INSN (last); insn = NEXT_INSN (insn))
if (store_killed_in_insn (x, insn))
return 1;
-
+
return 0;
}
/* Returns 1 if the expression X is loaded or clobbered on or before INSN
within basic block BB. */
-static int
+static int
store_killed_before (x, insn, bb)
rtx x, insn;
basic_block bb;
if (insn == first)
return store_killed_in_insn (x, insn);
-
+
/* Check if the register operands of the store are OK in this block.
- Note that if registers are changed ANYWHERE in the block, we'll
- decide we can't move it, regardless of whether it changed above
+ Note that if registers are changed ANYWHERE in the block, we'll
+ decide we can't move it, regardless of whether it changed above
or below the store. This could be improved by checking the register
operands while lookinng for aliasing in each insn. */
if (!store_ops_ok (XEXP (x, 0), bb))
for ( ; insn && insn != PREV_INSN (first); insn = PREV_INSN (insn))
if (store_killed_in_insn (x, insn))
return 1;
-
+
return 0;
}
determine which ones are not killed by aliasing, and generate
the appropriate vectors for gen and killed. */
static void
-build_store_vectors ()
+build_store_vectors ()
{
basic_block bb, b;
rtx insn, st;
sbitmap_vector_zero (st_antloc, last_basic_block);
for (ptr = first_ls_expr (); ptr != NULL; ptr = next_ls_expr (ptr))
- {
+ {
/* Put all the stores into either the antic list, or the avail list,
or both. */
rtx store_list = ptr->stores;
{
insn = XEXP (st, 0);
bb = BLOCK_FOR_INSN (insn);
-
+
if (!store_killed_after (ptr->pattern, insn, bb))
{
/* If we've already seen an availale expression in this block,
AVAIL_STORE_LIST (ptr) = alloc_INSN_LIST (insn,
AVAIL_STORE_LIST (ptr));
}
-
+
if (!store_killed_before (ptr->pattern, insn, bb))
{
SET_BIT (st_antloc[BLOCK_NUM (insn)], ptr->index);
ANTIC_STORE_LIST (ptr));
}
}
-
+
/* Free the original list of store insns. */
free_INSN_LIST_list (&store_list);
}
-
+
ae_kill = (sbitmap *) sbitmap_vector_alloc (last_basic_block, num_stores);
sbitmap_vector_zero (ae_kill, last_basic_block);
{
/* The anticipatable expression is not killed if it's gen'd. */
/*
- We leave this check out for now. If we have a code sequence
+ We leave this check out for now. If we have a code sequence
in a block which looks like:
ST MEMa = x
L y = MEMa
We should flag this as having an ANTIC expression, NOT
transparent, NOT killed, and AVAIL.
Unfortunately, since we haven't re-written all loads to
- use the reaching reg, we'll end up doing an incorrect
+ use the reaching reg, we'll end up doing an incorrect
Load in the middle here if we push the store down. It happens in
gcc.c-torture/execute/960311-1.c with -O3
If we always kill it in this case, we'll sometimes do
we better mark the store killed here, or we might not store to
it at all. If we knew it was abort, we wouldn't have to store,
but we don't know that for sure. */
- if (gcse_file)
+ if (gcse_file)
{
fprintf (gcse_file, "ST_avail and ST_antic (shown under loads..)\n");
print_ldst_list (gcse_file);
}
}
-/* Insert an instruction at the begining of a basic block, and update
+/* Insert an instruction at the begining of a basic block, and update
the BLOCK_HEAD if needed. */
-static void
+static void
insert_insn_start_bb (insn, bb)
rtx insn;
basic_block bb;
reg = expr->reaching_reg;
insn = gen_move_insn (expr->pattern, reg);
-
+
/* If we are inserting this expression on ALL predecessor edges of a BB,
insert it at the start of the BB, and reset the insert bits on the other
edges so we don't try to insert it on the other edges. */
insert_insn_start_bb (insn, bb);
return 0;
}
-
+
/* We can't insert on this edge, so we'll insert at the head of the
successors block. See Morgan, sec 10.5. */
if ((e->flags & EDGE_ABNORMAL) == EDGE_ABNORMAL)
}
insert_insn_on_edge (insn, e);
-
+
if (gcse_file)
{
fprintf (gcse_file, "STORE_MOTION insert insn on edge (%d, %d):\n",
print_inline_rtx (gcse_file, insn, 6);
fprintf (gcse_file, "\n");
}
-
+
return 1;
}
basic_block bb;
{
rtx insn;
-
+
insn = gen_move_insn (reg, SET_SRC (PATTERN (del)));
insn = emit_insn_after (insn, del);
-
+
if (gcse_file)
{
- fprintf (gcse_file,
+ fprintf (gcse_file,
"STORE_MOTION delete insn in BB %d:\n ", bb->index);
print_inline_rtx (gcse_file, del, 6);
fprintf (gcse_file, "\nSTORE MOTION replaced with insn:\n ");
print_inline_rtx (gcse_file, insn, 6);
fprintf (gcse_file, "\n");
}
-
+
delete_insn (del);
}
if (expr->reaching_reg == NULL_RTX)
expr->reaching_reg = gen_reg_rtx (GET_MODE (expr->pattern));
-
- /* If there is more than 1 store, the earlier ones will be dead,
- but it doesn't hurt to replace them here. */
+
+ /* If there is more than 1 store, the earlier ones will be dead,
+ but it doesn't hurt to replace them here. */
reg = expr->reaching_reg;
-
+
for (i = AVAIL_STORE_LIST (expr); i; i = XEXP (i, 1))
{
del = XEXP (i, 0);
if (BLOCK_FOR_INSN (del) == bb)
{
- /* We know there is only one since we deleted redundant
+ /* We know there is only one since we deleted redundant
ones during the available computation. */
replace_store_insn (reg, del, bb);
break;
/* Free memory used by store motion. */
-static void
+static void
free_store_memory ()
{
free_ldst_mems ();
-
+
if (ae_gen)
sbitmap_vector_free (ae_gen);
if (ae_kill)
sbitmap_vector_free (pre_delete_map);
if (reg_set_in_block)
sbitmap_vector_free (reg_set_in_block);
-
+
ae_gen = ae_kill = transp = st_antloc = NULL;
pre_insert_map = pre_delete_map = reg_set_in_block = NULL;
}
add_noreturn_fake_exit_edges ();
build_store_vectors ();
- edge_list = pre_edge_rev_lcm (gcse_file, num_stores, transp, ae_gen,
- st_antloc, ae_kill, &pre_insert_map,
+ edge_list = pre_edge_rev_lcm (gcse_file, num_stores, transp, ae_gen,
+ st_antloc, ae_kill, &pre_insert_map,
&pre_delete_map);
/* Now we want to insert the new stores which are going to be needed. */
static struct ggc_root *roots;
/* Add BASE as a new garbage collection root. It is an array of
- length NELT with each element SIZE bytes long. CB is a
+ length NELT with each element SIZE bytes long. CB is a
function that will be called with a pointer to each element
of the array; it is the intention that CB call the appropriate
routine to mark gc-able memory for that element. */
const struct ggc_cache_tab *const *ct;
const struct ggc_cache_tab *cti;
size_t i;
-
+
for (rt = gt_ggc_deletable_rtab; *rt; rt++)
for (rti = *rt; rti->base != NULL; rti++)
memset (rti->base, 0, rti->stride);
int i;
rtx next_rtx;
- do
+ do
{
enum rtx_code code = GET_CODE (r);
/* This gets set to a child rtx to eliminate tail recursion. */
case 'e': case 'u':
exp = XEXP (r, i);
if (ggc_test_and_set_mark (exp))
- {
- if (next_rtx == NULL)
- next_rtx = exp;
- else
+ {
+ if (next_rtx == NULL)
+ next_rtx = exp;
+ else
ggc_mark_rtx_children (exp);
- }
+ }
break;
case 'V': case 'E':
gt_ggc_m_rtvec_def (XVEC (r, i));
}
/* Print the statistics for trees. */
- fprintf (stream, "\n%-17s%10s %16s %10s\n", "Tree",
+ fprintf (stream, "\n%-17s%10s %16s %10s\n", "Tree",
"Number", "Bytes", "% Total");
for (code = 0; code < MAX_TREE_CODES; ++code)
- if (ggc_stats->num_trees[code])
+ if (ggc_stats->num_trees[code])
{
fprintf (stream, "%-17s%10u%16ld%c %10.3f\n",
tree_code_name[code],
ggc_stats->num_trees[code],
SCALE (ggc_stats->size_trees[code]),
LABEL (ggc_stats->size_trees[code]),
- (100 * ((double) ggc_stats->size_trees[code])
+ (100 * ((double) ggc_stats->size_trees[code])
/ ggc_stats->total_size_trees));
}
fprintf (stream,
LABEL (ggc_stats->total_size_trees));
/* Print the statistics for RTL. */
- fprintf (stream, "\n%-17s%10s %16s %10s\n", "RTX",
+ fprintf (stream, "\n%-17s%10s %16s %10s\n", "RTX",
"Number", "Bytes", "% Total");
for (code = 0; code < NUM_RTX_CODE; ++code)
- if (ggc_stats->num_rtxs[code])
+ if (ggc_stats->num_rtxs[code])
{
fprintf (stream, "%-17s%10u%16ld%c %10.3f\n",
rtx_name[code],
ggc_stats->num_rtxs[code],
SCALE (ggc_stats->size_rtxs[code]),
LABEL (ggc_stats->size_rtxs[code]),
- (100 * ((double) ggc_stats->size_rtxs[code])
+ (100 * ((double) ggc_stats->size_rtxs[code])
/ ggc_stats->total_size_rtxs));
}
fprintf (stream,
#define USING_MALLOC_PAGE_GROUPS
#endif
-/* Stategy:
+/* Stategy:
This garbage-collecting allocator allocates objects on one of a set
of pages. Each page can allocate objects of a single size only;
Each page-entry also has a context depth, which is used to track
pushing and popping of allocation contexts. Only objects allocated
- in the current (highest-numbered) context may be collected.
+ in the current (highest-numbered) context may be collected.
Page entries are arranged in an array of singly-linked lists. The
array is indexed by the allocation size, in bits, of the pages on
The bottommost HOST_PAGE_SIZE_BITS are ignored, since page-entry
pages are aligned on system page boundaries. The next most
significant PAGE_L2_BITS and PAGE_L1_BITS are the second and first
- index values in the lookup table, respectively.
+ index values in the lookup table, respectively.
For 32-bit architectures and the settings below, there are no
leftover bits. For architectures with wider pointers, the lookup
/* A page_entry records the status of an allocation page. This
structure is dynamically sized to fit the bitmap in_use_p. */
-typedef struct page_entry
+typedef struct page_entry
{
/* The next page-entry with objects of the same size, or NULL if
this is the last page-entry. */
return base[L1] && base[L1][L2];
}
-/* Traverse the page table and find the entry for a page.
+/* Traverse the page table and find the entry for a page.
Die (probably) if the object wasn't allocated via GC. */
static inline page_entry *
set_page_table_entry (page, entry);
if (GGC_DEBUG_LEVEL >= 2)
- fprintf (G.debug_file,
+ fprintf (G.debug_file,
"Allocating page at %p, object size=%lu, data %p-%p\n",
(PTR) entry, (unsigned long) OBJECT_SIZE (order), page,
page + entry_size - 1);
page_entry *entry;
{
if (GGC_DEBUG_LEVEL >= 2)
- fprintf (G.debug_file,
+ fprintf (G.debug_file,
"Deallocating page at %p, data %p-%p\n", (PTR) entry,
entry->page, entry->page + entry->bytes - 1);
if (g->in_use == 0)
{
*gp = g->next;
- G.bytes_mapped -= g->alloc_size;
+ G.bytes_mapped -= g->alloc_size;
free (g->allocation);
}
else
/* This table provides a fast way to determine ceil(log_2(size)) for
allocation requests. The minimum allocation size is eight bytes. */
-static unsigned char size_lookup[257] =
+static unsigned char size_lookup[257] =
{
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4,
- 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4,
+ 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+ 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
- 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
{
struct page_entry *new_entry;
new_entry = alloc_page (order);
-
+
/* If this is the only entry, it's also the tail. */
if (entry == NULL)
G.page_tails[order] = new_entry;
-
+
/* Put new pages at the head of the page list. */
new_entry->next = entry;
entry = new_entry;
unsigned hint = entry->next_bit_hint;
word = hint / HOST_BITS_PER_LONG;
bit = hint % HOST_BITS_PER_LONG;
-
+
/* If the hint didn't work, scan the bitmap from the beginning. */
if ((entry->in_use_p[word] >> bit) & 1)
{
G.allocated += OBJECT_SIZE (order);
if (GGC_DEBUG_LEVEL >= 3)
- fprintf (G.debug_file,
+ fprintf (G.debug_file,
"Allocating object, requested size=%lu, actual=%lu at %p on %p\n",
(unsigned long) size, (unsigned long) OBJECT_SIZE (order), result,
(PTR) entry);
bit = (((const char *) p) - entry->page) / OBJECT_SIZE (entry->order);
word = bit / HOST_BITS_PER_LONG;
mask = (unsigned long) 1 << (bit % HOST_BITS_PER_LONG);
-
+
/* If the bit was previously set, skip it. */
if (entry->in_use_p[word] & mask)
return 1;
return 0;
}
-/* Return 1 if P has been marked, zero otherwise.
+/* Return 1 if P has been marked, zero otherwise.
P must have been allocated by the GC allocator; it mustn't point to
static objects, stack variables, or memory allocated with malloc. */
bit = (((const char *) p) - entry->page) / OBJECT_SIZE (entry->order);
word = bit / HOST_BITS_PER_LONG;
mask = (unsigned long) 1 << (bit % HOST_BITS_PER_LONG);
-
+
return (entry->in_use_p[word] & mask) != 0;
}
unsigned int i;
size_t num_objects;
- /* Because the past-the-end bit in in_use_p is always set, we
+ /* Because the past-the-end bit in in_use_p is always set, we
pretend there is one additional object. */
num_objects = OBJECTS_PER_PAGE (p->order) + 1;
p->num_free_objects = num_objects;
/* Combine the IN_USE_P and SAVE_IN_USE_P arrays. */
- for (i = 0;
+ for (i = 0;
i < CEIL (BITMAP_SIZE (num_objects),
sizeof (*p->in_use_p));
++i)
abort ();
}
-/* Decrement the `GC context'. All objects allocated since the
+/* Decrement the `GC context'. All objects allocated since the
previous ggc_push_context are migrated to the outer context. */
void
memset (p->in_use_p, 0, bitmap_size);
/* Make sure the one-past-the-end bit is always set. */
- p->in_use_p[num_objects / HOST_BITS_PER_LONG]
+ p->in_use_p[num_objects / HOST_BITS_PER_LONG]
= ((unsigned long) 1 << (num_objects % HOST_BITS_PER_LONG));
}
}
size_t live_objects;
page_entry *p, *previous;
int done;
-
+
p = G.pages[order];
if (p == NULL)
continue;
previous = p;
p = next;
- }
+ }
while (! done);
/* Now, restore the in_use_p vectors for any pages from contexts
sweep phase. */
G.allocated = 0;
- /* Release the pages we freed the last time we collected, but didn't
+ /* Release the pages we freed the last time we collected, but didn't
reuse in the interim. */
release_pages ();
clear_marks ();
ggc_mark_roots ();
-
+
#ifdef GGC_POISON
poison_pages ();
#endif
/* Clear the statistics. */
memset (&stats, 0, sizeof (stats));
-
+
/* Make sure collection will really occur. */
G.allocated_last_gc = 0;
there as part of the total allocated memory. */
release_pages ();
- /* Collect some information about the various sizes of
+ /* Collect some information about the various sizes of
allocation. */
fprintf (stderr, "\n%-5s %10s %10s %10s\n",
"Size", "Allocated", "Used", "Overhead");
for (p = G.pages[i]; p; p = p->next)
{
allocated += p->bytes;
- in_use +=
+ in_use +=
(OBJECTS_PER_PAGE (i) - p->num_free_objects) * OBJECT_SIZE (i);
overhead += (sizeof (page_entry) - sizeof (long)
ggc_get_size (p)
const void *p;
{
- struct ggc_mem *x
+ struct ggc_mem *x
= (struct ggc_mem *) ((const char *)p - offsetof (struct ggc_mem, u));
return x->size;
}
/* Called once to initialize the garbage collector. */
-void
+void
init_ggc ()
{
G.allocated_last_gc = GGC_MIN_LAST_ALLOCATED;
/* Finish a GC context. Any uncollected memory in the new context
will be merged with the old context. */
-void
+void
ggc_pop_context ()
{
G.context--;
for (i = 0; i < indent; ++i)
putc (' ', stderr);
fprintf (stderr, "%lx %p\n", (unsigned long)PTR_KEY (p), p);
-
+
if (p->sub[1])
debug_ggc_tree (p->sub[1], indent + 1);
}
/* Clear the statistics. */
memset (&stats, 0, sizeof (stats));
-
+
/* Make sure collection will really occur. */
G.allocated_last_gc = 0;
extern void ggc_add_root PARAMS ((void *base, int nelt,
int size, void (*)(void *)));
-/* Structures for the easy way to mark roots.
+/* Structures for the easy way to mark roots.
In an array, terminated by having base == NULL.*/
struct ggc_root_tab {
void *base;
pointers in this data structure should not be traversed. */
extern int ggc_set_mark PARAMS ((const void *));
-/* Return 1 if P has been marked, zero otherwise.
+/* Return 1 if P has been marked, zero otherwise.
P must have been allocated by the GC allocator; it mustn't point to
static objects, stack variables, or memory allocated with malloc. */
extern int ggc_marked_p PARAMS ((const void *));
/* This structure contains the statistics common to all collectors.
Particular collectors can extend this structure. */
-typedef struct ggc_statistics
+typedef struct ggc_statistics
{
/* The Ith element is the number of nodes allocated with code I. */
unsigned num_trees[256];
- /* The Ith element is the number of bytes allocated by nodes with
+ /* The Ith element is the number of bytes allocated by nodes with
code I. */
size_t size_trees[256];
/* The Ith element is the number of nodes allocated with code I. */
unsigned num_rtxs[256];
- /* The Ith element is the number of bytes allocated by nodes with
+ /* The Ith element is the number of bytes allocated by nodes with
code I. */
size_t size_rtxs[256];
/* The total size of the tree nodes allocated. */
1. Assign allocation-numbers (allocnos) to the pseudo-registers
still needing allocations and to the pseudo-registers currently
allocated by local-alloc which may be spilled by reload.
- Set up tables reg_allocno and allocno_reg to map
+ Set up tables reg_allocno and allocno_reg to map
reg numbers to allocnos and vice versa.
max_allocno gets the number of allocnos in use.
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (regs_ever_live[i])
local_reg_n_refs[i] = 0, local_reg_freq[i] = 0;
-
+
allocno_row_words = (max_allocno + INT_BITS - 1) / INT_BITS;
/* We used to use alloca here, but the size of what it would try to
}
qsort (allocno_order, max_allocno, sizeof (int), allocno_compare);
-
+
prune_preferences ();
if (file)
\f
/* Prune the preferences for global registers to exclude registers that cannot
be used.
-
+
Compute `regs_someone_prefers', which is a bitmask of the hard registers
that are preferred by conflicting registers of lower priority. If possible,
we will avoid using these registers. */
-
+
static void
prune_preferences ()
{
int i;
int num;
int *allocno_to_order = (int *) xmalloc (max_allocno * sizeof (int));
-
+
/* Scan least most important to most important.
For each allocno, remove from preferences registers that cannot be used,
either because of conflicts or register type. Then compute all registers
COPY_HARD_REG_SET (used, used1);
IOR_COMPL_HARD_REG_SET (used, regs_used_so_far);
IOR_HARD_REG_SET (used, allocno[num].regs_someone_prefers);
-
+
best_reg = -1;
for (i = FIRST_PSEUDO_REGISTER, pass = 0;
pass <= 1 && i >= FIRST_PSEUDO_REGISTER;
Remove from the preferred registers and conflicting registers. Note that
additional conflicts may have been added after `prune_preferences' was
- called.
+ called.
First do this for those register with copy preferences, then all
preferred registers. */
}
no_prefs:
- /* If we haven't succeeded yet, try with caller-saves.
+ /* If we haven't succeeded yet, try with caller-saves.
We need not check to see if the current function has nonlocal
labels because we don't put any pseudos that are live over calls in
registers in that case. */
CLEAR_HARD_REG_SET (new_losers);
else
COPY_HARD_REG_SET (new_losers, losers);
-
+
IOR_HARD_REG_SET(new_losers, losing_caller_save_reg_set);
find_reg (num, new_losers, alt_regs_p, 1, retrying);
if (reg_renumber[allocno[num].reg] >= 0)
/* We explicitly evaluate the divide results into temporary
variables so as to avoid excess precision problems that occur
on an i386-unknown-sysv4.2 (unixware) host. */
-
+
double tmp1 = ((double) local_reg_freq[regno]
/ local_reg_live_length[regno]);
double tmp2 = ((double) allocno[num].freq
that SRC is a register. If SRC or the first operand of SRC is a register,
try to set a preference. If one of the two is a hard register and the other
is a pseudo-register, mark the preference.
-
+
Note that we are not as aggressive as local-alloc in trying to tie a
pseudo-register to a hard register. */
FOR_EACH_BB (bb)
{
- regset r = bb->global_live_at_start;
+ regset r = bb->global_live_at_start;
if (REGNO_REG_SET_P (r, from))
{
CLEAR_REGNO_REG_SET (r, from);
if (GET_CODE (reg) != REG)
return;
-
+
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
{
: reg_renumber[i] >= 0)
SET_REGNO_REG_SET (live_relevant_regs, i);
});
- }
+ }
if (GET_CODE (first) != NOTE && GET_CODE (first) != BARRIER)
{
for (i = 0; i < max_allocno; i++)
{
if (reg_renumber[allocno[allocno_order[i]].reg] >= 0)
- continue;
+ continue;
nregs++;
}
fprintf (file, ";; %d regs to allocate:", nregs);
FILE *file;
{
int i, j;
-
+
fprintf (file, ";; Register dispositions:\n");
for (i = FIRST_PSEUDO_REGISTER, j = 0; i < max_regno; i++)
if (reg_renumber[i] >= 0)
{
fprintf (file, "%d in %d ", i, reg_renumber[i]);
- if (++j % 6 == 0)
+ if (++j % 6 == 0)
fprintf (file, "\n");
}
-/* Header file for graph routines.
+/* Header file for graph routines.
Copyright (C) 1999 Free Software Foundation, Inc.
This file is part of GCC.
if (!__gthread_active_p ())
return NULL;
-
+
if ( !(pthread_create(&new_thread_handle, pthread_attr_default,
- (void *)func, arg)) )
+ (void *)func, arg)) )
{
/* ??? May not work! (64bit) */
thread_id = *(objc_thread_t *)&new_thread_handle;
}
else
thread_id = NULL;
-
+
return thread_id;
}
sys_priority = (PRI_BG_MIN_NP + PRI_BG_MAX_NP) / 2;
break;
}
-
+
/* Change the priority. */
if (pthread_setprio(pthread_self(), sys_priority) >= 0)
return 0;
if (__gthread_active_p ())
{
if ((sys_priority = pthread_getprio(pthread_self())) >= 0)
- {
+ {
if (sys_priority >= PRI_FG_MIN_NP
&& sys_priority <= PRI_FG_MAX_NP)
return OBJC_THREAD_INTERACTIVE_PRIORITY;
mutex->backend = objc_malloc(sizeof(pthread_mutex_t));
if (pthread_mutex_init((pthread_mutex_t *)mutex->backend,
- pthread_mutexattr_default))
- {
- objc_free(mutex->backend);
- mutex->backend = NULL;
- return -1;
- }
+ pthread_mutexattr_default))
+ {
+ objc_free(mutex->backend);
+ mutex->backend = NULL;
+ return -1;
+ }
}
return 0;
if (__gthread_active_p ())
{
if (pthread_mutex_destroy((pthread_mutex_t *)mutex->backend))
- return -1;
+ return -1;
objc_free(mutex->backend);
mutex->backend = NULL;
#pragma weak pthread_setspecific
#pragma weak pthread_create
-#pragma weak pthread_mutex_lock
-#pragma weak pthread_mutex_trylock
-#pragma weak pthread_mutex_unlock
+#pragma weak pthread_mutex_lock
+#pragma weak pthread_mutex_trylock
+#pragma weak pthread_mutex_unlock
#ifdef _LIBOBJC
/* Objective C. */
{
/* Initialize the thread storage key */
if (pthread_key_create(&_objc_thread_storage, NULL) == 0)
- {
- /* The normal default detach state for threads is
- * PTHREAD_CREATE_JOINABLE which causes threads to not die
- * when you think they should. */
- if (pthread_attr_init(&_objc_thread_attribs) == 0
- && pthread_attr_setdetachstate(&_objc_thread_attribs,
- PTHREAD_CREATE_DETACHED) == 0)
- return 0;
- }
+ {
+ /* The normal default detach state for threads is
+ * PTHREAD_CREATE_JOINABLE which causes threads to not die
+ * when you think they should. */
+ if (pthread_attr_init(&_objc_thread_attribs) == 0
+ && pthread_attr_setdetachstate(&_objc_thread_attribs,
+ PTHREAD_CREATE_DETACHED) == 0)
+ return 0;
+ }
}
return -1;
if (!__gthread_active_p ())
return NULL;
-
+
if ( !(pthread_create(&new_thread_handle, NULL, (void *)func, arg)) )
thread_id = (objc_thread_t) new_thread_handle;
else
thread_id = NULL;
-
+
return thread_id;
}
if (pthread_getschedparam(thread_id, &policy, ¶ms) == 0)
{
- if ((priority_max = sched_get_priority_max(policy)) != 0)
- return -1;
-
- if ((priority_min = sched_get_priority_min(policy)) != 0)
- return -1;
-
- if (priority > priority_max)
- priority = priority_max;
- else if (priority < priority_min)
- priority = priority_min;
- params.sched_priority = priority;
-
- /*
- * The solaris 7 and several other man pages incorrectly state that
- * this should be a pointer to policy but pthread.h is universally
- * at odds with this.
- */
- if (pthread_setschedparam(thread_id, policy, ¶ms) == 0)
- return 0;
+ if ((priority_max = sched_get_priority_max(policy)) != 0)
+ return -1;
+
+ if ((priority_min = sched_get_priority_min(policy)) != 0)
+ return -1;
+
+ if (priority > priority_max)
+ priority = priority_max;
+ else if (priority < priority_min)
+ priority = priority_min;
+ params.sched_priority = priority;
+
+ /*
+ * The solaris 7 and several other man pages incorrectly state that
+ * this should be a pointer to policy but pthread.h is universally
+ * at odds with this.
+ */
+ if (pthread_setschedparam(thread_id, policy, ¶ms) == 0)
+ return 0;
}
return -1;
}
struct sched_param params;
if (pthread_getschedparam(pthread_self(), &policy, ¶ms) == 0)
- return params.sched_priority;
+ return params.sched_priority;
else
- return -1;
+ return -1;
}
else
return OBJC_THREAD_INTERACTIVE_PRIORITY;
static inline int
__gthread_objc_mutex_lock(objc_mutex_t mutex)
{
- if (__gthread_active_p ()
+ if (__gthread_active_p ()
&& pthread_mutex_lock((pthread_mutex_t *)mutex->backend) != 0)
{
return -1;
static inline int
__gthread_objc_mutex_trylock(objc_mutex_t mutex)
{
- if (__gthread_active_p ()
+ if (__gthread_active_p ()
&& pthread_mutex_trylock((pthread_mutex_t *)mutex->backend) != 0)
{
return -1;
static inline int
__gthread_objc_mutex_unlock(objc_mutex_t mutex)
{
- if (__gthread_active_p ()
+ if (__gthread_active_p ()
&& pthread_mutex_unlock((pthread_mutex_t *)mutex->backend) != 0)
{
return -1;
typedef void *__gthread_mutex_t;
/*
- * External functions provided by RTEMS. They are very similar to their POSIX
+ * External functions provided by RTEMS. They are very similar to their POSIX
* counterparts. A "Wrapper API" is being use to avoid dependency on any RTEMS
* header files.
*/
if (!__gthread_active_p ())
return NULL;
-
+
if (thr_create(NULL, 0, (void *)func, arg,
- THR_DETACHED | THR_NEW_LWP,
+ THR_DETACHED | THR_NEW_LWP,
&new_thread_id) == 0)
thread_id = *(objc_thread_t *)&new_thread_id;
else
thread_id = NULL;
-
+
return thread_id;
}
if (!__gthread_active_p ())
return OBJC_THREAD_INTERACTIVE_PRIORITY;
-
+
if (thr_getprio(thr_self(), &sys_priority) == 0)
{
if (sys_priority >= 250)
{
if (__gthread_active_p ())
return cond_init((cond_t *)(&(condition->backend)), USYNC_THREAD,
- NULL);
+ NULL);
else
return 0;
}
{
if (__gthread_active_p ())
return cond_wait((cond_t *)(&(condition->backend)),
- (mutex_t *)(&(mutex->backend)));
+ (mutex_t *)(&(mutex->backend)));
else
return 0;
}
#define GCC_GTHR_WIN32_H
/* Windows32 threads specific definitions. The windows32 threading model
- does not map well into pthread-inspired gcc's threading model, and so
+ does not map well into pthread-inspired gcc's threading model, and so
there are caveats one needs to be aware of.
1. The destructor supplied to __gthread_key_create is ignored for
- generic x86-win32 ports. This will certainly cause memory leaks
- due to unreclaimed eh contexts (sizeof (eh_context) is at least
+ generic x86-win32 ports. This will certainly cause memory leaks
+ due to unreclaimed eh contexts (sizeof (eh_context) is at least
24 bytes for x86 currently).
This memory leak may be significant for long-running applications
linked in if -mthreads option is specified, that runs the dtors in
the reverse order of registration when each thread exits. If
-mthreads option is not given, a stub is linked in instead of the
- DLL, which results in memory leak. Other x86-win32 ports can use
+ DLL, which results in memory leak. Other x86-win32 ports can use
the same technique of course to avoid the leak.
2. The error codes returned are non-POSIX like, and cast into ints.
- This may cause incorrect error return due to truncation values on
+ This may cause incorrect error return due to truncation values on
hw where sizeof (DWORD) > sizeof (int).
-
- 3. We might consider using Critical Sections instead of Windows32
- mutexes for better performance, but emulating __gthread_mutex_trylock
+
+ 3. We might consider using Critical Sections instead of Windows32
+ mutexes for better performance, but emulating __gthread_mutex_trylock
interface becomes more complicated (Win9x does not support
TryEnterCriticalSectioni, while NT does).
-
+
The basic framework should work well enough. In the long term, GCC
needs to use Structured Exception Handling on Windows32. */
#ifdef _LIBOBJC
/* This is necessary to prevent windef.h (included from windows.h) from
- defining it's own BOOL as a typedef. */
+ defining it's own BOOL as a typedef. */
#ifndef __OBJC__
#define __OBJC__
#endif
#include <windows.h>
-/* Now undef the windows BOOL. */
+/* Now undef the windows BOOL. */
#undef BOOL
/* Key structure for maintaining thread specific storage */
HANDLE win32_handle;
if (!(win32_handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)func,
- arg, 0, &thread_id)))
+ arg, 0, &thread_id)))
thread_id = 0;
-
+
return (objc_thread_t)thread_id;
}
int sys_priority;
sys_priority = GetThreadPriority(GetCurrentThread());
-
+
switch (sys_priority)
{
case THREAD_PRIORITY_HIGHEST:
default:
case THREAD_PRIORITY_BELOW_NORMAL:
return OBJC_THREAD_BACKGROUND_PRIORITY;
-
+
case THREAD_PRIORITY_IDLE:
case THREAD_PRIORITY_LOWEST:
return OBJC_THREAD_LOW_PRIORITY;
#endif
/* Mingw runtime >= v0.3 provides a magic variable that is set to non-zero
- if -mthreads option was specified, or 0 otherwise. This is to get around
+ if -mthreads option was specified, or 0 otherwise. This is to get around
the lack of weak symbols in PE-COFF. */
extern int _CRT_MT;
#endif
if (! once->done)
{
if (InterlockedIncrement (&(once->started)) == 0)
- {
+ {
(*func) ();
once->done = TRUE;
}
else
{
- /* Another thread is currently executing the code, so wait for it
- to finish; yield the CPU in the meantime. If performance
- does become an issue, the solution is to use an Event that
- we wait on here (and set above), but that implies a place to
- create the event before this routine is called. */
+ /* Another thread is currently executing the code, so wait for it
+ to finish; yield the CPU in the meantime. If performance
+ does become an issue, the solution is to use an Event that
+ we wait on here (and set above), but that implies a place to
+ create the event before this routine is called. */
while (! once->done)
Sleep (0);
}
}
-
+
return 0;
}
/* Windows32 thread local keys don't support destructors; this leads to
- leaks, especially in threaded applications making extensive use of
+ leaks, especially in threaded applications making extensive use of
C++ EH. Mingw uses a thread-support DLL to work-around this problem. */
static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
}
/* Currently, this routine is called only for Mingw runtime, and if
- -mthreads option is chosen to link in the thread support DLL. */
+ -mthreads option is chosen to link in the thread support DLL. */
static inline int
__gthread_key_dtor (__gthread_key_t key, void *ptr)
{
static inline void
__gthread_mutex_init_function (__gthread_mutex_t *mutex)
{
- /* Create unnamed mutex with default security attr and no initial owner. */
+ /* Create unnamed mutex with default security attr and no initial owner. */
*mutex = CreateMutex (NULL, 0, NULL);
}
/* If this file is compiled with threads support, it must
#define __GTHREADS 1
to indicate that threads support is present. Also it has define
- function
+ function
int __gthread_active_p ()
that returns 1 if thread system is active, 0 if not.
projects / thirdparty / gcc.git / commitdiff
