From 561373393ee7750164f6855685497198910de3af Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 23 Jun 2009 16:57:18 +0000 Subject: [PATCH] 4.4.0-10 --- .cvsignore | 2 +- gcc.spec | 2 +- gcc44-rh503816-1.patch | 827 +++++++++++++++++++++++++++++++++++++++++ gcc44-rh503816-2.patch | 491 ++++++++++++++++++++++++ gcc44-rh506099.patch | 92 ----- sources | 2 +- 6 files changed, 1321 insertions(+), 95 deletions(-) create mode 100644 gcc44-rh503816-1.patch create mode 100644 gcc44-rh503816-2.patch delete mode 100644 gcc44-rh506099.patch diff --git a/.cvsignore b/.cvsignore index e1dbe7a..a8827f4 100644 --- a/.cvsignore +++ b/.cvsignore @@ -1,2 +1,2 @@ fastjar-0.97.tar.gz -gcc-4.4.0-20090615.tar.bz2 +gcc-4.4.0-20090623.tar.bz2 diff --git a/gcc.spec b/gcc.spec index 44ccd46..c66a8ab 100644 --- a/gcc.spec +++ b/gcc.spec @@ -3,7 +3,7 @@ %global gcc_version 4.4.0 # Note, gcc_release must be integer, if you want to add suffixes to # %{release}, append them after %{gcc_release} on Release: line. -%global gcc_release 9 +%global gcc_release 10 %global _unpackaged_files_terminate_build 0 %global multilib_64_archs sparc64 ppc64 s390x x86_64 %global include_gappletviewer 1 diff --git a/gcc44-rh503816-1.patch b/gcc44-rh503816-1.patch new file mode 100644 index 0000000..7516f85 --- /dev/null +++ b/gcc44-rh503816-1.patch @@ -0,0 +1,827 @@ +2009-06-21 Jakub Jelinek + + * var-tracking.c (struct shared_hash_def, shared_hash): New types. + (dataflow_set): Change vars type from htab_t to shared_hash. + (shared_hash_pool, empty_shared_hash): New variables. + (vars_clear): Removed. + (shared_hash_shared, shared_hash_htab, shared_hash_copy, + shared_hash_find_slot_unshare, shared_hash_find_slot, + shared_hash_find_slot_noinsert, shared_hash_find): New + static inlines. + (shared_hash_unshare, shared_hash_destroy): New functions. + (unshare_variable): Unshare set->vars if shared, use + shared_hash_htab. + (vars_copy): Use htab_traverse_noresize instead of htab_traverse. + (get_init_value, find_src_set_src, dump_dataflow_set, + clobber_variable_part, emit_notes_for_differences): Use + shared_hash_htab. + (dataflow_set_init): Remove second argument, set vars to + empty_shared_hash instead of creating a new htab. + (dataflow_set_clear): Call shared_hash_destroy and set vars + to empty_shared_hash instead of calling vars_clear. + (dataflow_set_copy): Don't call vars_copy, instead just share + the src htab with dst. + (variable_union): Use shared_hash_*, use initially NO_INSERT + lookup if set->vars is shared. Don't keep slot cleared before + calling unshare_variable. Unshare set->vars if needed. + Even ->refcount == 1 vars must be unshared if set->vars is shared + and var needs to be modified. + (variable_canonicalize): New function. + (dataflow_set_union): If dst->vars is empty, just share src->vars + with dst->vars and traverse with variable_canonicalize to canonicalize + and unshare what is needed. + (dataflow_set_different): If old_set and new_set use the same shared + htab, they aren't different. If number of htab elements is different, + htabs are different. Use shared_hash_*. + (dataflow_set_destroy): Call shared_hash_destroy instead of + htab_delete. + (compute_bb_dataflow, emit_notes_in_bb, vt_emit_notes): Don't pass + second argument to dataflow_set_init. + (vt_initialize): Likewise. Initialize shared_hash_pool and + empty_shared_hash, move bb in/out initialization afterwards. + Use variable_htab_free instead of NULL as changed_variables del hook. + (variable_was_changed): Change type of second argument to pointer to + dataflow_set. When inserting var into changed_variables, bump + refcount. Unshare set->vars if set is shared htab and slot needs to + be cleared. + (set_variable_part): Use shared_hash_*, use initially NO_INSERT + lookup if set->vars is shared. Unshare set->vars if needed. + Even ->refcount == 1 vars must be unshared if set->vars is shared + and var needs to be modified. Adjust variable_was_changed caller. + (delete_variable_part): Use shared_hash_*. Even ->refcount == 1 + vars must be unshared if set->vars is shared and var needs to be + modified. Adjust variable_was_changed caller. + (emit_note_insn_var_location): Don't pool_free var. + (emit_notes_for_differences_1): Initialize empty_var->refcount to 0 + instead of 1. + (vt_finalize): Call htab_delete on empty_shared_hash->htab and + free_alloc_pool on shared_hash_pool. + + * hashtab.c (htab_traverse): Don't call htab_expand for + nearly empty hashtabs with sizes 7, 13 or 31. + +--- gcc/var-tracking.c (revision 148758) ++++ gcc/var-tracking.c (revision 148760) +@@ -182,6 +182,17 @@ typedef struct attrs_def + HOST_WIDE_INT offset; + } *attrs; + ++/* Structure holding a refcounted hash table. If refcount > 1, ++ it must be first unshared before modified. */ ++typedef struct shared_hash_def ++{ ++ /* Reference count. */ ++ int refcount; ++ ++ /* Actual hash table. */ ++ htab_t htab; ++} *shared_hash; ++ + /* Structure holding the IN or OUT set for a basic block. */ + typedef struct dataflow_set_def + { +@@ -192,7 +203,7 @@ typedef struct dataflow_set_def + attrs regs[FIRST_PSEUDO_REGISTER]; + + /* Variable locations. */ +- htab_t vars; ++ shared_hash vars; + } dataflow_set; + + /* The structure (one for each basic block) containing the information +@@ -280,12 +291,18 @@ static alloc_pool var_pool; + /* Alloc pool for struct location_chain_def. */ + static alloc_pool loc_chain_pool; + ++/* Alloc pool for struct shared_hash_def. */ ++static alloc_pool shared_hash_pool; ++ + /* Changed variables, notes will be emitted for them. */ + static htab_t changed_variables; + + /* Shall notes be emitted? */ + static bool emit_notes; + ++/* Empty shared hashtable. */ ++static shared_hash empty_shared_hash; ++ + /* Local function prototypes. */ + static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INT *, + HOST_WIDE_INT *); +@@ -305,7 +322,6 @@ static void attrs_list_insert (attrs *, + static void attrs_list_copy (attrs *, attrs); + static void attrs_list_union (attrs *, attrs); + +-static void vars_clear (htab_t); + static variable unshare_variable (dataflow_set *set, variable var, + enum var_init_status); + static int vars_copy_1 (void **, void *); +@@ -321,11 +337,12 @@ static void var_mem_delete_and_set (data + enum var_init_status, rtx); + static void var_mem_delete (dataflow_set *, rtx, bool); + +-static void dataflow_set_init (dataflow_set *, int); ++static void dataflow_set_init (dataflow_set *); + static void dataflow_set_clear (dataflow_set *); + static void dataflow_set_copy (dataflow_set *, dataflow_set *); + static int variable_union_info_cmp_pos (const void *, const void *); + static int variable_union (void **, void *); ++static int variable_canonicalize (void **, void *); + static void dataflow_set_union (dataflow_set *, dataflow_set *); + static bool variable_part_different_p (variable_part *, variable_part *); + static bool variable_different_p (variable, variable, bool); +@@ -352,7 +369,7 @@ static void dump_vars (htab_t); + static void dump_dataflow_set (dataflow_set *); + static void dump_dataflow_sets (void); + +-static void variable_was_changed (variable, htab_t); ++static void variable_was_changed (variable, dataflow_set *); + static void set_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT, + enum var_init_status, rtx); + static void clobber_variable_part (dataflow_set *, rtx, tree, HOST_WIDE_INT, +@@ -742,12 +759,107 @@ attrs_list_union (attrs *dstp, attrs src + } + } + +-/* Delete all variables from hash table VARS. */ ++/* Shared hashtable support. */ ++ ++/* Return true if VARS is shared. */ ++ ++static inline bool ++shared_hash_shared (shared_hash vars) ++{ ++ return vars->refcount > 1; ++} ++ ++/* Return the hash table for VARS. */ ++ ++static inline htab_t ++shared_hash_htab (shared_hash vars) ++{ ++ return vars->htab; ++} ++ ++/* Copy variables into a new hash table. */ ++ ++static shared_hash ++shared_hash_unshare (shared_hash vars) ++{ ++ shared_hash new_vars = (shared_hash) pool_alloc (shared_hash_pool); ++ gcc_assert (vars->refcount > 1); ++ new_vars->refcount = 1; ++ new_vars->htab ++ = htab_create (htab_elements (vars->htab) + 3, variable_htab_hash, ++ variable_htab_eq, variable_htab_free); ++ vars_copy (new_vars->htab, vars->htab); ++ vars->refcount--; ++ return new_vars; ++} ++ ++/* Increment reference counter on VARS and return it. */ ++ ++static inline shared_hash ++shared_hash_copy (shared_hash vars) ++{ ++ vars->refcount++; ++ return vars; ++} ++ ++/* Decrement reference counter and destroy hash table if not shared ++ anymore. */ + + static void +-vars_clear (htab_t vars) ++shared_hash_destroy (shared_hash vars) + { +- htab_empty (vars); ++ gcc_assert (vars->refcount > 0); ++ if (--vars->refcount == 0) ++ { ++ htab_delete (vars->htab); ++ pool_free (shared_hash_pool, vars); ++ } ++} ++ ++/* Unshare *PVARS if shared and return slot for DECL. If INS is ++ INSERT, insert it if not already present. */ ++ ++static inline void ** ++shared_hash_find_slot_unshare (shared_hash *pvars, tree decl, ++ enum insert_option ins) ++{ ++ if (shared_hash_shared (*pvars)) ++ *pvars = shared_hash_unshare (*pvars); ++ return htab_find_slot_with_hash (shared_hash_htab (*pvars), decl, ++ VARIABLE_HASH_VAL (decl), ins); ++} ++ ++/* Return slot for DECL, if it is already present in the hash table. ++ If it is not present, insert it only VARS is not shared, otherwise ++ return NULL. */ ++ ++static inline void ** ++shared_hash_find_slot (shared_hash vars, tree decl) ++{ ++ return htab_find_slot_with_hash (shared_hash_htab (vars), decl, ++ VARIABLE_HASH_VAL (decl), ++ shared_hash_shared (vars) ++ ? NO_INSERT : INSERT); ++} ++ ++/* Return slot for DECL only if it is already present in the hash table. */ ++ ++static inline void ** ++shared_hash_find_slot_noinsert (shared_hash vars, tree decl) ++{ ++ return htab_find_slot_with_hash (shared_hash_htab (vars), decl, ++ VARIABLE_HASH_VAL (decl), NO_INSERT); ++} ++ ++/* Return variable for DECL or NULL if not already present in the hash ++ table. */ ++ ++static inline variable ++shared_hash_find (shared_hash vars, tree decl) ++{ ++ return (variable) ++ htab_find_with_hash (shared_hash_htab (vars), decl, ++ VARIABLE_HASH_VAL (decl)); + } + + /* Return a copy of a variable VAR and insert it to dataflow set SET. */ +@@ -801,9 +913,7 @@ unshare_variable (dataflow_set *set, var + new_var->var_part[i].cur_loc = NULL; + } + +- slot = htab_find_slot_with_hash (set->vars, new_var->decl, +- VARIABLE_HASH_VAL (new_var->decl), +- INSERT); ++ slot = shared_hash_find_slot_unshare (&set->vars, new_var->decl, INSERT); + *slot = new_var; + return new_var; + } +@@ -834,8 +944,7 @@ vars_copy_1 (void **slot, void *data) + static void + vars_copy (htab_t dst, htab_t src) + { +- vars_clear (dst); +- htab_traverse (src, vars_copy_1, dst); ++ htab_traverse_noresize (src, vars_copy_1, dst); + } + + /* Map a decl to its main debug decl. */ +@@ -874,7 +983,6 @@ var_reg_set (dataflow_set *set, rtx loc, + static int + get_init_value (dataflow_set *set, rtx loc, tree decl) + { +- void **slot; + variable var; + int i; + int ret_val = VAR_INIT_STATUS_UNKNOWN; +@@ -882,11 +990,9 @@ get_init_value (dataflow_set *set, rtx l + if (! flag_var_tracking_uninit) + return VAR_INIT_STATUS_INITIALIZED; + +- slot = htab_find_slot_with_hash (set->vars, decl, VARIABLE_HASH_VAL (decl), +- NO_INSERT); +- if (slot) ++ var = shared_hash_find (set->vars, decl); ++ if (var) + { +- var = * (variable *) slot; + for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++) + { + location_chain nextp; +@@ -1050,11 +1156,10 @@ var_mem_delete (dataflow_set *set, rtx l + VARS_SIZE is the initial size of hash table VARS. */ + + static void +-dataflow_set_init (dataflow_set *set, int vars_size) ++dataflow_set_init (dataflow_set *set) + { + init_attrs_list_set (set->regs); +- set->vars = htab_create (vars_size, variable_htab_hash, variable_htab_eq, +- variable_htab_free); ++ set->vars = shared_hash_copy (empty_shared_hash); + set->stack_adjust = 0; + } + +@@ -1068,7 +1173,8 @@ dataflow_set_clear (dataflow_set *set) + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + attrs_list_clear (&set->regs[i]); + +- vars_clear (set->vars); ++ shared_hash_destroy (set->vars); ++ set->vars = shared_hash_copy (empty_shared_hash); + } + + /* Copy the contents of dataflow set SRC to DST. */ +@@ -1081,7 +1187,8 @@ dataflow_set_copy (dataflow_set *dst, da + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + attrs_list_copy (&dst->regs[i], src->regs[i]); + +- vars_copy (dst->vars, src->vars); ++ shared_hash_destroy (dst->vars); ++ dst->vars = shared_hash_copy (src->vars); + dst->stack_adjust = src->stack_adjust; + } + +@@ -1129,15 +1236,14 @@ variable_union_info_cmp_pos (const void + static int + variable_union (void **slot, void *data) + { +- variable src, dst, *dstp; ++ variable src, dst; ++ void **dstp; + dataflow_set *set = (dataflow_set *) data; + int i, j, k; + + src = *(variable *) slot; +- dstp = (variable *) htab_find_slot_with_hash (set->vars, src->decl, +- VARIABLE_HASH_VAL (src->decl), +- INSERT); +- if (!*dstp) ++ dstp = shared_hash_find_slot (set->vars, src->decl); ++ if (!dstp || !*dstp) + { + src->refcount++; + +@@ -1162,16 +1268,23 @@ variable_union (void **slot, void *data) + if (! flag_var_tracking_uninit) + status = VAR_INIT_STATUS_INITIALIZED; + ++ if (dstp) ++ *dstp = (void *) src; + unshare_variable (set, src, status); + } + else +- *dstp = src; ++ { ++ if (!dstp) ++ dstp = shared_hash_find_slot_unshare (&set->vars, src->decl, ++ INSERT); ++ *dstp = (void *) src; ++ } + + /* Continue traversing the hash table. */ + return 1; + } + else +- dst = *dstp; ++ dst = (variable) *dstp; + + gcc_assert (src->n_var_parts); + +@@ -1196,7 +1309,8 @@ variable_union (void **slot, void *data) + thus there are at most MAX_VAR_PARTS different offsets. */ + gcc_assert (k <= MAX_VAR_PARTS); + +- if (dst->refcount > 1 && dst->n_var_parts != k) ++ if ((dst->refcount > 1 || shared_hash_shared (set->vars)) ++ && dst->n_var_parts != k) + { + enum var_init_status status = VAR_INIT_STATUS_UNKNOWN; + +@@ -1226,7 +1340,7 @@ variable_union (void **slot, void *data) + /* If DST is shared compare the location chains. + If they are different we will modify the chain in DST with + high probability so make a copy of DST. */ +- if (dst->refcount > 1) ++ if (dst->refcount > 1 || shared_hash_shared (set->vars)) + { + for (node = src->var_part[i].loc_chain, + node2 = dst->var_part[j].loc_chain; node && node2; +@@ -1379,6 +1493,46 @@ variable_union (void **slot, void *data) + return 1; + } + ++/* Like variable_union, but only used when doing dataflow_set_union ++ into an empty hashtab. To allow sharing, dst is initially shared ++ with src (so all variables are "copied" from src to dst hashtab), ++ so only unshare_variable for variables that need canonicalization ++ are needed. */ ++ ++static int ++variable_canonicalize (void **slot, void *data) ++{ ++ variable src; ++ dataflow_set *set = (dataflow_set *) data; ++ int k; ++ ++ src = *(variable *) slot; ++ ++ /* If CUR_LOC of some variable part is not the first element of ++ the location chain we are going to change it so we have to make ++ a copy of the variable. */ ++ for (k = 0; k < src->n_var_parts; k++) ++ { ++ gcc_assert (!src->var_part[k].loc_chain == !src->var_part[k].cur_loc); ++ if (src->var_part[k].loc_chain) ++ { ++ gcc_assert (src->var_part[k].cur_loc); ++ if (src->var_part[k].cur_loc != src->var_part[k].loc_chain->loc) ++ break; ++ } ++ } ++ if (k < src->n_var_parts) ++ { ++ enum var_init_status status = VAR_INIT_STATUS_UNKNOWN; ++ ++ if (! flag_var_tracking_uninit) ++ status = VAR_INIT_STATUS_INITIALIZED; ++ ++ unshare_variable (set, src, status); ++ } ++ return 1; ++} ++ + /* Compute union of dataflow sets SRC and DST and store it to DST. */ + + static void +@@ -1389,7 +1543,14 @@ dataflow_set_union (dataflow_set *dst, d + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + attrs_list_union (&dst->regs[i], src->regs[i]); + +- htab_traverse (src->vars, variable_union, dst); ++ if (dst->vars == empty_shared_hash) ++ { ++ shared_hash_destroy (dst->vars); ++ dst->vars = shared_hash_copy (src->vars); ++ htab_traverse (shared_hash_htab (src->vars), variable_canonicalize, dst); ++ } ++ else ++ htab_traverse (shared_hash_htab (src->vars), variable_union, dst); + } + + /* Flag whether two dataflow sets being compared contain different data. */ +@@ -1522,15 +1683,24 @@ dataflow_set_different_2 (void **slot, v + static bool + dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set) + { ++ if (old_set->vars == new_set->vars) ++ return false; ++ ++ if (htab_elements (shared_hash_htab (old_set->vars)) ++ != htab_elements (shared_hash_htab (new_set->vars))) ++ return true; ++ + dataflow_set_different_value = false; + +- htab_traverse (old_set->vars, dataflow_set_different_1, new_set->vars); ++ htab_traverse (shared_hash_htab (old_set->vars), dataflow_set_different_1, ++ shared_hash_htab (new_set->vars)); + if (!dataflow_set_different_value) + { + /* We have compared the variables which are in both hash tables + so now only check whether there are some variables in NEW_SET->VARS + which are not in OLD_SET->VARS. */ +- htab_traverse (new_set->vars, dataflow_set_different_2, old_set->vars); ++ htab_traverse (shared_hash_htab (new_set->vars), dataflow_set_different_2, ++ shared_hash_htab (old_set->vars)); + } + return dataflow_set_different_value; + } +@@ -1545,7 +1715,7 @@ dataflow_set_destroy (dataflow_set *set) + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + attrs_list_clear (&set->regs[i]); + +- htab_delete (set->vars); ++ shared_hash_destroy (set->vars); + set->vars = NULL; + } + +@@ -1985,7 +2155,6 @@ find_src_set_src (dataflow_set *set, rtx + { + tree decl = NULL_TREE; /* The variable being copied around. */ + rtx set_src = NULL_RTX; /* The value for "decl" stored in "src". */ +- void **slot; + variable var; + location_chain nextp; + int i; +@@ -1998,12 +2167,9 @@ find_src_set_src (dataflow_set *set, rtx + + if (src && decl) + { +- slot = htab_find_slot_with_hash (set->vars, decl, +- VARIABLE_HASH_VAL (decl), NO_INSERT); +- +- if (slot) ++ var = shared_hash_find (set->vars, decl); ++ if (var) + { +- var = *(variable *) slot; + found = false; + for (i = 0; i < var->n_var_parts && !found; i++) + for (nextp = var->var_part[i].loc_chain; nextp && !found; +@@ -2031,7 +2197,7 @@ compute_bb_dataflow (basic_block bb) + dataflow_set *in = &VTI (bb)->in; + dataflow_set *out = &VTI (bb)->out; + +- dataflow_set_init (&old_out, htab_elements (VTI (bb)->out.vars) + 3); ++ dataflow_set_init (&old_out); + dataflow_set_copy (&old_out, out); + dataflow_set_copy (out, in); + +@@ -2323,7 +2489,7 @@ dump_dataflow_set (dataflow_set *set) + dump_attrs_list (set->regs[i]); + } + } +- dump_vars (set->vars); ++ dump_vars (shared_hash_htab (set->vars)); + fprintf (dump_file, "\n"); + } + +@@ -2345,10 +2511,10 @@ dump_dataflow_sets (void) + } + + /* Add variable VAR to the hash table of changed variables and +- if it has no locations delete it from hash table HTAB. */ ++ if it has no locations delete it from SET's hash table. */ + + static void +-variable_was_changed (variable var, htab_t htab) ++variable_was_changed (variable var, dataflow_set *set) + { + hashval_t hash = VARIABLE_HASH_VAL (var->decl); + +@@ -2359,36 +2525,39 @@ variable_was_changed (variable var, htab + slot = (variable *) htab_find_slot_with_hash (changed_variables, + var->decl, hash, INSERT); + +- if (htab && var->n_var_parts == 0) ++ if (set && var->n_var_parts == 0) + { + variable empty_var; +- void **old; + + empty_var = (variable) pool_alloc (var_pool); + empty_var->decl = var->decl; + empty_var->refcount = 1; + empty_var->n_var_parts = 0; + *slot = empty_var; +- +- old = htab_find_slot_with_hash (htab, var->decl, hash, +- NO_INSERT); +- if (old) +- htab_clear_slot (htab, old); ++ goto drop_var; + } + else + { ++ var->refcount++; + *slot = var; + } + } + else + { +- gcc_assert (htab); ++ gcc_assert (set); + if (var->n_var_parts == 0) + { +- void **slot = htab_find_slot_with_hash (htab, var->decl, hash, +- NO_INSERT); ++ void **slot; ++ ++ drop_var: ++ slot = shared_hash_find_slot_noinsert (set->vars, var->decl); + if (slot) +- htab_clear_slot (htab, slot); ++ { ++ if (shared_hash_shared (set->vars)) ++ slot = shared_hash_find_slot_unshare (&set->vars, var->decl, ++ NO_INSERT); ++ htab_clear_slot (shared_hash_htab (set->vars), slot); ++ } + } + } + } +@@ -2438,12 +2607,12 @@ set_variable_part (dataflow_set *set, rt + location_chain node, next; + location_chain *nextp; + variable var; +- void **slot; +- +- slot = htab_find_slot_with_hash (set->vars, decl, +- VARIABLE_HASH_VAL (decl), INSERT); +- if (!*slot) ++ void **slot = shared_hash_find_slot (set->vars, decl); ++ ++ if (!slot || !*slot) + { ++ if (!slot) ++ slot = shared_hash_find_slot_unshare (&set->vars, decl, INSERT); + /* Create new variable information. */ + var = (variable) pool_alloc (var_pool); + var->decl = decl; +@@ -2479,13 +2648,12 @@ set_variable_part (dataflow_set *set, rt + if (set_src != NULL) + node->set_src = set_src; + +- *slot = var; + return; + } + else + { + /* We have to make a copy of a shared variable. */ +- if (var->refcount > 1) ++ if (var->refcount > 1 || shared_hash_shared (set->vars)) + var = unshare_variable (set, var, initialized); + } + } +@@ -2494,7 +2662,7 @@ set_variable_part (dataflow_set *set, rt + /* We have not found the location part, new one will be created. */ + + /* We have to make a copy of the shared variable. */ +- if (var->refcount > 1) ++ if (var->refcount > 1 || shared_hash_shared (set->vars)) + var = unshare_variable (set, var, initialized); + + /* We track only variables whose size is <= MAX_VAR_PARTS bytes +@@ -2548,7 +2716,7 @@ set_variable_part (dataflow_set *set, rt + if (var->var_part[pos].cur_loc == NULL) + { + var->var_part[pos].cur_loc = loc; +- variable_was_changed (var, set->vars); ++ variable_was_changed (var, set); + } + } + +@@ -2561,16 +2729,14 @@ static void + clobber_variable_part (dataflow_set *set, rtx loc, tree decl, + HOST_WIDE_INT offset, rtx set_src) + { +- void **slot; ++ variable var; + + if (! decl || ! DECL_P (decl)) + return; + +- slot = htab_find_slot_with_hash (set->vars, decl, VARIABLE_HASH_VAL (decl), +- NO_INSERT); +- if (slot) ++ var = shared_hash_find (set->vars, decl); ++ if (var) + { +- variable var = (variable) *slot; + int pos = find_variable_location_part (var, offset, NULL); + + if (pos >= 0) +@@ -2627,13 +2793,9 @@ static void + delete_variable_part (dataflow_set *set, rtx loc, tree decl, + HOST_WIDE_INT offset) + { +- void **slot; +- +- slot = htab_find_slot_with_hash (set->vars, decl, VARIABLE_HASH_VAL (decl), +- NO_INSERT); +- if (slot) ++ variable var = shared_hash_find (set->vars, decl);; ++ if (var) + { +- variable var = (variable) *slot; + int pos = find_variable_location_part (var, offset, NULL); + + if (pos >= 0) +@@ -2642,7 +2804,7 @@ delete_variable_part (dataflow_set *set, + location_chain *nextp; + bool changed; + +- if (var->refcount > 1) ++ if (var->refcount > 1 || shared_hash_shared (set->vars)) + { + /* If the variable contains the location part we have to + make a copy of the variable. */ +@@ -2705,7 +2867,7 @@ delete_variable_part (dataflow_set *set, + } + } + if (changed) +- variable_was_changed (var, set->vars); ++ variable_was_changed (var, set); + } + } + } +@@ -2864,14 +3026,6 @@ emit_note_insn_var_location (void **varp + + htab_clear_slot (changed_variables, varp); + +- /* When there are no location parts the variable has been already +- removed from hash table and a new empty variable was created. +- Free the empty variable. */ +- if (var->n_var_parts == 0) +- { +- pool_free (var_pool, var); +- } +- + /* Continue traversing the hash table. */ + return 1; + } +@@ -2910,7 +3064,7 @@ emit_notes_for_differences_1 (void **slo + + empty_var = (variable) pool_alloc (var_pool); + empty_var->decl = old_var->decl; +- empty_var->refcount = 1; ++ empty_var->refcount = 0; + empty_var->n_var_parts = 0; + variable_was_changed (empty_var, NULL); + } +@@ -2952,8 +3106,12 @@ static void + emit_notes_for_differences (rtx insn, dataflow_set *old_set, + dataflow_set *new_set) + { +- htab_traverse (old_set->vars, emit_notes_for_differences_1, new_set->vars); +- htab_traverse (new_set->vars, emit_notes_for_differences_2, old_set->vars); ++ htab_traverse (shared_hash_htab (old_set->vars), ++ emit_notes_for_differences_1, ++ shared_hash_htab (new_set->vars)); ++ htab_traverse (shared_hash_htab (new_set->vars), ++ emit_notes_for_differences_2, ++ shared_hash_htab (old_set->vars)); + emit_notes_for_changes (insn, EMIT_NOTE_BEFORE_INSN); + } + +@@ -2965,7 +3123,7 @@ emit_notes_in_bb (basic_block bb) + int i; + dataflow_set set; + +- dataflow_set_init (&set, htab_elements (VTI (bb)->in.vars) + 3); ++ dataflow_set_init (&set); + dataflow_set_copy (&set, &VTI (bb)->in); + + for (i = 0; i < VTI (bb)->n_mos; i++) +@@ -3098,7 +3256,7 @@ vt_emit_notes (void) + delete_variable_part). */ + emit_notes = true; + +- dataflow_set_init (&empty, 7); ++ dataflow_set_init (&empty); + last_out = ∅ + + FOR_EACH_BB (bb) +@@ -3343,14 +3501,6 @@ vt_initialize (void) + } + } + +- /* Init the IN and OUT sets. */ +- FOR_ALL_BB (bb) +- { +- VTI (bb)->visited = false; +- dataflow_set_init (&VTI (bb)->in, 7); +- dataflow_set_init (&VTI (bb)->out, 7); +- } +- + attrs_pool = create_alloc_pool ("attrs_def pool", + sizeof (struct attrs_def), 1024); + var_pool = create_alloc_pool ("variable_def pool", +@@ -3358,8 +3508,24 @@ vt_initialize (void) + loc_chain_pool = create_alloc_pool ("location_chain_def pool", + sizeof (struct location_chain_def), + 1024); ++ shared_hash_pool = create_alloc_pool ("shared_hash_def pool", ++ sizeof (struct shared_hash_def), 256); ++ empty_shared_hash = (shared_hash) pool_alloc (shared_hash_pool); ++ empty_shared_hash->refcount = 1; ++ empty_shared_hash->htab ++ = htab_create (1, variable_htab_hash, variable_htab_eq, ++ variable_htab_free); + changed_variables = htab_create (10, variable_htab_hash, variable_htab_eq, +- NULL); ++ variable_htab_free); ++ ++ /* Init the IN and OUT sets. */ ++ FOR_ALL_BB (bb) ++ { ++ VTI (bb)->visited = false; ++ dataflow_set_init (&VTI (bb)->in); ++ dataflow_set_init (&VTI (bb)->out); ++ } ++ + vt_add_function_parameters (); + } + +@@ -3381,10 +3547,12 @@ vt_finalize (void) + dataflow_set_destroy (&VTI (bb)->out); + } + free_aux_for_blocks (); ++ htab_delete (empty_shared_hash->htab); ++ htab_delete (changed_variables); + free_alloc_pool (attrs_pool); + free_alloc_pool (var_pool); + free_alloc_pool (loc_chain_pool); +- htab_delete (changed_variables); ++ free_alloc_pool (shared_hash_pool); + } + + /* The entry point to variable tracking pass. */ +--- libiberty/hashtab.c (revision 148758) ++++ libiberty/hashtab.c (revision 148760) +@@ -759,7 +759,8 @@ htab_traverse_noresize (htab_t htab, hta + void + htab_traverse (htab_t htab, htab_trav callback, PTR info) + { +- if (htab_elements (htab) * 8 < htab_size (htab)) ++ size_t size = htab_size (htab); ++ if (htab_elements (htab) * 8 < size && size > 32) + htab_expand (htab); + + htab_traverse_noresize (htab, callback, info); diff --git a/gcc44-rh503816-2.patch b/gcc44-rh503816-2.patch new file mode 100644 index 0000000..5ee452a --- /dev/null +++ b/gcc44-rh503816-2.patch @@ -0,0 +1,491 @@ +2009-06-23 Jakub Jelinek + + * var-tracking.c (unshare_variable): Force initialized to + be VAR_INIT_STATUS_INITIALIZED unless flag_var_tracking_uninit. + (set_variable_part): Likewise. + (struct variable_union_info): Remove pos_src field. + (vui_vec, vui_allocated): New variables. + (variable_union): Pass VAR_INIT_STATUS_UNKNOWN to unshare_variable + unconditionally. Avoid XCVECNEW/free for every sorting, for dst_l + == 1 use a simpler sorting algorithm. Compute pos field right + away, don't fill in pos_src. For dst_l == 2 avoid qsort. + Avoid quadratic comparison if !flag_var_tracking_uninit. + (variable_canonicalize): Pass VAR_INIT_STATUS_UNKNOWN to + unshare_variable unconditionally. + (dataflow_set_different_2): Removed. + (dataflow_set_different): Don't traverse second hash table. + (compute_bb_dataflow): Pass VAR_INIT_STATUS_UNINITIALIZED + unconditionally to var_reg_set or var_mem_set. + (emit_notes_in_bb): Likewise. + (delete_variable_part): Pass VAR_INIT_STATUS_UNKNOWN to + unshare_variable. + (emit_note_insn_var_location): Don't set initialized to + VAR_INIT_STATUS_INITIALIZED early. + (vt_finalize): Free vui_vec if needed, clear vui_vec and + vui_allocated. + +--- gcc/var-tracking.c (revision 148851) ++++ gcc/var-tracking.c (revision 148852) +@@ -347,7 +347,6 @@ static void dataflow_set_union (dataflow + static bool variable_part_different_p (variable_part *, variable_part *); + static bool variable_different_p (variable, variable, bool); + static int dataflow_set_different_1 (void **, void *); +-static int dataflow_set_different_2 (void **, void *); + static bool dataflow_set_different (dataflow_set *, dataflow_set *); + static void dataflow_set_destroy (dataflow_set *); + +@@ -878,6 +877,9 @@ unshare_variable (dataflow_set *set, var + var->refcount--; + new_var->n_var_parts = var->n_var_parts; + ++ if (! flag_var_tracking_uninit) ++ initialized = VAR_INIT_STATUS_INITIALIZED; ++ + for (i = 0; i < var->n_var_parts; i++) + { + location_chain node; +@@ -1202,11 +1204,14 @@ struct variable_union_info + /* The sum of positions in the input chains. */ + int pos; + +- /* The position in the chains of SRC and DST dataflow sets. */ +- int pos_src; ++ /* The position in the chain of DST dataflow set. */ + int pos_dst; + }; + ++/* Buffer for location list sorting and its allocated size. */ ++static struct variable_union_info *vui_vec; ++static int vui_allocated; ++ + /* Compare function for qsort, order the structures by POS element. */ + + static int +@@ -1263,14 +1268,9 @@ variable_union (void **slot, void *data) + } + if (k < src->n_var_parts) + { +- enum var_init_status status = VAR_INIT_STATUS_UNKNOWN; +- +- if (! flag_var_tracking_uninit) +- status = VAR_INIT_STATUS_INITIALIZED; +- + if (dstp) + *dstp = (void *) src; +- unshare_variable (set, src, status); ++ unshare_variable (set, src, VAR_INIT_STATUS_UNKNOWN); + } + else + { +@@ -1311,13 +1311,7 @@ variable_union (void **slot, void *data) + + if ((dst->refcount > 1 || shared_hash_shared (set->vars)) + && dst->n_var_parts != k) +- { +- enum var_init_status status = VAR_INIT_STATUS_UNKNOWN; +- +- if (! flag_var_tracking_uninit) +- status = VAR_INIT_STATUS_INITIALIZED; +- dst = unshare_variable (set, dst, status); +- } ++ dst = unshare_variable (set, dst, VAR_INIT_STATUS_UNKNOWN); + + i = src->n_var_parts - 1; + j = dst->n_var_parts - 1; +@@ -1366,70 +1360,152 @@ variable_union (void **slot, void *data) + dst_l = 0; + for (node = dst->var_part[j].loc_chain; node; node = node->next) + dst_l++; +- vui = XCNEWVEC (struct variable_union_info, src_l + dst_l); + +- /* Fill in the locations from DST. */ +- for (node = dst->var_part[j].loc_chain, jj = 0; node; +- node = node->next, jj++) ++ if (dst_l == 1) + { +- vui[jj].lc = node; +- vui[jj].pos_dst = jj; ++ /* The most common case, much simpler, no qsort is needed. */ ++ location_chain dstnode = dst->var_part[j].loc_chain; ++ dst->var_part[k].loc_chain = dstnode; ++ dst->var_part[k].offset = dst->var_part[j].offset; ++ node2 = dstnode; ++ for (node = src->var_part[i].loc_chain; node; node = node->next) ++ if (!((REG_P (dstnode->loc) ++ && REG_P (node->loc) ++ && REGNO (dstnode->loc) == REGNO (node->loc)) ++ || rtx_equal_p (dstnode->loc, node->loc))) ++ { ++ location_chain new_node; + +- /* Value larger than a sum of 2 valid positions. */ +- vui[jj].pos_src = src_l + dst_l; ++ /* Copy the location from SRC. */ ++ new_node = (location_chain) pool_alloc (loc_chain_pool); ++ new_node->loc = node->loc; ++ new_node->init = node->init; ++ if (!node->set_src || MEM_P (node->set_src)) ++ new_node->set_src = NULL; ++ else ++ new_node->set_src = node->set_src; ++ node2->next = new_node; ++ node2 = new_node; ++ } ++ node2->next = NULL; + } +- +- /* Fill in the locations from SRC. */ +- n = dst_l; +- for (node = src->var_part[i].loc_chain, ii = 0; node; +- node = node->next, ii++) ++ else + { +- /* Find location from NODE. */ +- for (jj = 0; jj < dst_l; jj++) ++ if (src_l + dst_l > vui_allocated) + { +- if ((REG_P (vui[jj].lc->loc) +- && REG_P (node->loc) +- && REGNO (vui[jj].lc->loc) == REGNO (node->loc)) +- || rtx_equal_p (vui[jj].lc->loc, node->loc)) +- { +- vui[jj].pos_src = ii; +- break; +- } ++ vui_allocated = MAX (vui_allocated * 2, src_l + dst_l); ++ vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec, ++ vui_allocated); + } +- if (jj >= dst_l) /* The location has not been found. */ ++ vui = vui_vec; ++ ++ /* Fill in the locations from DST. */ ++ for (node = dst->var_part[j].loc_chain, jj = 0; node; ++ node = node->next, jj++) + { +- location_chain new_node; ++ vui[jj].lc = node; ++ vui[jj].pos_dst = jj; + +- /* Copy the location from SRC. */ +- new_node = (location_chain) pool_alloc (loc_chain_pool); +- new_node->loc = node->loc; +- new_node->init = node->init; +- if (!node->set_src || MEM_P (node->set_src)) +- new_node->set_src = NULL; +- else +- new_node->set_src = node->set_src; +- vui[n].lc = new_node; +- vui[n].pos_src = ii; +- vui[n].pos_dst = src_l + dst_l; +- n++; ++ /* Pos plus value larger than a sum of 2 valid positions. */ ++ vui[jj].pos = jj + src_l + dst_l; + } +- } + +- for (ii = 0; ii < src_l + dst_l; ii++) +- vui[ii].pos = vui[ii].pos_src + vui[ii].pos_dst; ++ /* Fill in the locations from SRC. */ ++ n = dst_l; ++ for (node = src->var_part[i].loc_chain, ii = 0; node; ++ node = node->next, ii++) ++ { ++ /* Find location from NODE. */ ++ for (jj = 0; jj < dst_l; jj++) ++ { ++ if ((REG_P (vui[jj].lc->loc) ++ && REG_P (node->loc) ++ && REGNO (vui[jj].lc->loc) == REGNO (node->loc)) ++ || rtx_equal_p (vui[jj].lc->loc, node->loc)) ++ { ++ vui[jj].pos = jj + ii; ++ break; ++ } ++ } ++ if (jj >= dst_l) /* The location has not been found. */ ++ { ++ location_chain new_node; + +- qsort (vui, n, sizeof (struct variable_union_info), +- variable_union_info_cmp_pos); ++ /* Copy the location from SRC. */ ++ new_node = (location_chain) pool_alloc (loc_chain_pool); ++ new_node->loc = node->loc; ++ new_node->init = node->init; ++ if (!node->set_src || MEM_P (node->set_src)) ++ new_node->set_src = NULL; ++ else ++ new_node->set_src = node->set_src; ++ vui[n].lc = new_node; ++ vui[n].pos_dst = src_l + dst_l; ++ vui[n].pos = ii + src_l + dst_l; ++ n++; ++ } ++ } + +- /* Reconnect the nodes in sorted order. */ +- for (ii = 1; ii < n; ii++) +- vui[ii - 1].lc->next = vui[ii].lc; +- vui[n - 1].lc->next = NULL; ++ if (dst_l == 2) ++ { ++ /* Special case still very common case. For dst_l == 2 ++ all entries dst_l ... n-1 are sorted, with for i >= dst_l ++ vui[i].pos == i + src_l + dst_l. */ ++ if (vui[0].pos > vui[1].pos) ++ { ++ /* Order should be 1, 0, 2... */ ++ dst->var_part[k].loc_chain = vui[1].lc; ++ vui[1].lc->next = vui[0].lc; ++ if (n >= 3) ++ { ++ vui[0].lc->next = vui[2].lc; ++ vui[n - 1].lc->next = NULL; ++ } ++ else ++ vui[0].lc->next = NULL; ++ ii = 3; ++ } ++ else ++ { ++ dst->var_part[k].loc_chain = vui[0].lc; ++ if (n >= 3 && vui[2].pos < vui[1].pos) ++ { ++ /* Order should be 0, 2, 1, 3... */ ++ vui[0].lc->next = vui[2].lc; ++ vui[2].lc->next = vui[1].lc; ++ if (n >= 4) ++ { ++ vui[1].lc->next = vui[3].lc; ++ vui[n - 1].lc->next = NULL; ++ } ++ else ++ vui[1].lc->next = NULL; ++ ii = 4; ++ } ++ else ++ { ++ /* Order should be 0, 1, 2... */ ++ ii = 1; ++ vui[n - 1].lc->next = NULL; ++ } ++ } ++ for (; ii < n; ii++) ++ vui[ii - 1].lc->next = vui[ii].lc; ++ } ++ else ++ { ++ qsort (vui, n, sizeof (struct variable_union_info), ++ variable_union_info_cmp_pos); + +- dst->var_part[k].loc_chain = vui[0].lc; +- dst->var_part[k].offset = dst->var_part[j].offset; ++ /* Reconnect the nodes in sorted order. */ ++ for (ii = 1; ii < n; ii++) ++ vui[ii - 1].lc->next = vui[ii].lc; ++ vui[n - 1].lc->next = NULL; ++ dst->var_part[k].loc_chain = vui[0].lc; ++ } + +- free (vui); ++ dst->var_part[k].offset = dst->var_part[j].offset; ++ } + i--; + j--; + } +@@ -1477,17 +1553,18 @@ variable_union (void **slot, void *data) + dst->var_part[k].cur_loc = NULL; + } + +- for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++) +- { +- location_chain node, node2; +- for (node = src->var_part[i].loc_chain; node; node = node->next) +- for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next) +- if (rtx_equal_p (node->loc, node2->loc)) +- { +- if (node->init > node2->init) +- node2->init = node->init; +- } +- } ++ if (flag_var_tracking_uninit) ++ for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++) ++ { ++ location_chain node, node2; ++ for (node = src->var_part[i].loc_chain; node; node = node->next) ++ for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next) ++ if (rtx_equal_p (node->loc, node2->loc)) ++ { ++ if (node->init > node2->init) ++ node2->init = node->init; ++ } ++ } + + /* Continue traversing the hash table. */ + return 1; +@@ -1522,14 +1599,7 @@ variable_canonicalize (void **slot, void + } + } + if (k < src->n_var_parts) +- { +- enum var_init_status status = VAR_INIT_STATUS_UNKNOWN; +- +- if (! flag_var_tracking_uninit) +- status = VAR_INIT_STATUS_INITIALIZED; +- +- unshare_variable (set, src, status); +- } ++ unshare_variable (set, src, VAR_INIT_STATUS_UNKNOWN); + return 1; + } + +@@ -1650,34 +1720,6 @@ dataflow_set_different_1 (void **slot, v + return 1; + } + +-/* Compare variable *SLOT with the same variable in hash table DATA +- and set DATAFLOW_SET_DIFFERENT_VALUE if they are different. */ +- +-static int +-dataflow_set_different_2 (void **slot, void *data) +-{ +- htab_t htab = (htab_t) data; +- variable var1, var2; +- +- var1 = *(variable *) slot; +- var2 = (variable) htab_find_with_hash (htab, var1->decl, +- VARIABLE_HASH_VAL (var1->decl)); +- if (!var2) +- { +- dataflow_set_different_value = true; +- +- /* Stop traversing the hash table. */ +- return 0; +- } +- +- /* If both variables are defined they have been already checked for +- equivalence. */ +- gcc_assert (!variable_different_p (var1, var2, false)); +- +- /* Continue traversing the hash table. */ +- return 1; +-} +- + /* Return true if dataflow sets OLD_SET and NEW_SET differ. */ + + static bool +@@ -1694,14 +1736,9 @@ dataflow_set_different (dataflow_set *ol + + htab_traverse (shared_hash_htab (old_set->vars), dataflow_set_different_1, + shared_hash_htab (new_set->vars)); +- if (!dataflow_set_different_value) +- { +- /* We have compared the variables which are in both hash tables +- so now only check whether there are some variables in NEW_SET->VARS +- which are not in OLD_SET->VARS. */ +- htab_traverse (shared_hash_htab (new_set->vars), dataflow_set_different_2, +- shared_hash_htab (old_set->vars)); +- } ++ /* No need to traverse the second hashtab, if both have the same number ++ of elements and the second one had all entries found in the first one, ++ then it can't have any extra entries. */ + return dataflow_set_different_value; + } + +@@ -2215,15 +2252,11 @@ compute_bb_dataflow (basic_block bb) + case MO_USE: + { + rtx loc = VTI (bb)->mos[i].u.loc; +- enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED; +- +- if (! flag_var_tracking_uninit) +- status = VAR_INIT_STATUS_INITIALIZED; + + if (GET_CODE (loc) == REG) +- var_reg_set (out, loc, status, NULL); ++ var_reg_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL); + else if (GET_CODE (loc) == MEM) +- var_mem_set (out, loc, status, NULL); ++ var_mem_set (out, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL); + } + break; + +@@ -2262,10 +2295,12 @@ compute_bb_dataflow (basic_block bb) + if (! flag_var_tracking_uninit) + src_status = VAR_INIT_STATUS_INITIALIZED; + else +- src_status = find_src_status (in, set_src); ++ { ++ src_status = find_src_status (in, set_src); + +- if (src_status == VAR_INIT_STATUS_UNKNOWN) +- src_status = find_src_status (out, set_src); ++ if (src_status == VAR_INIT_STATUS_UNKNOWN) ++ src_status = find_src_status (out, set_src); ++ } + + set_src = find_src_set_src (in, set_src); + +@@ -2609,6 +2644,9 @@ set_variable_part (dataflow_set *set, rt + variable var; + void **slot = shared_hash_find_slot (set->vars, decl); + ++ if (! flag_var_tracking_uninit) ++ initialized = VAR_INIT_STATUS_INITIALIZED; ++ + if (!slot || !*slot) + { + if (!slot) +@@ -2815,10 +2853,8 @@ delete_variable_part (dataflow_set *set, + && REGNO (node->loc) == REGNO (loc)) + || rtx_equal_p (node->loc, loc)) + { +- enum var_init_status status = VAR_INIT_STATUS_UNKNOWN; +- if (! flag_var_tracking_uninit) +- status = VAR_INIT_STATUS_INITIALIZED; +- var = unshare_variable (set, var, status); ++ var = unshare_variable (set, var, ++ VAR_INIT_STATUS_UNKNOWN); + break; + } + } +@@ -2893,9 +2929,6 @@ emit_note_insn_var_location (void **varp + + gcc_assert (var->decl); + +- if (! flag_var_tracking_uninit) +- initialized = VAR_INIT_STATUS_INITIALIZED; +- + complete = true; + last_limit = 0; + n_var_parts = 0; +@@ -3148,14 +3181,11 @@ emit_notes_in_bb (basic_block bb) + case MO_USE: + { + rtx loc = VTI (bb)->mos[i].u.loc; +- +- enum var_init_status status = VAR_INIT_STATUS_UNINITIALIZED; +- if (! flag_var_tracking_uninit) +- status = VAR_INIT_STATUS_INITIALIZED; ++ + if (GET_CODE (loc) == REG) +- var_reg_set (&set, loc, status, NULL); ++ var_reg_set (&set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL); + else +- var_mem_set (&set, loc, status, NULL); ++ var_mem_set (&set, loc, VAR_INIT_STATUS_UNINITIALIZED, NULL); + + emit_notes_for_changes (insn, EMIT_NOTE_AFTER_INSN); + } +@@ -3553,6 +3583,10 @@ vt_finalize (void) + free_alloc_pool (var_pool); + free_alloc_pool (loc_chain_pool); + free_alloc_pool (shared_hash_pool); ++ if (vui_vec) ++ free (vui_vec); ++ vui_vec = NULL; ++ vui_allocated = 0; + } + + /* The entry point to variable tracking pass. */ diff --git a/gcc44-rh506099.patch b/gcc44-rh506099.patch deleted file mode 100644 index dfae818..0000000 --- a/gcc44-rh506099.patch +++ /dev/null @@ -1,92 +0,0 @@ -2009-06-15 Jakub Jelinek - - * tree-object-size.c (addr_object_size): Fix a pasto in the last - change. - - * gcc.dg/builtin-object-size-7.c: New test. - ---- gcc/tree-object-size.c.jj 2009-06-12 10:36:08.000000000 +0200 -+++ gcc/tree-object-size.c 2009-06-15 18:40:17.000000000 +0200 -@@ -316,7 +316,7 @@ addr_object_size (struct object_size_inf - && tree_int_cst_lt (pt_var_size, bytes2)) - bytes2 = size_zero_node; - else -- bytes2 = size_binop (MINUS_EXPR, var_size, bytes2); -+ bytes2 = size_binop (MINUS_EXPR, pt_var_size, bytes2); - bytes = size_binop (MIN_EXPR, bytes, bytes2); - } - } ---- gcc/testsuite/gcc.dg/builtin-object-size-7.c.jj 2009-06-15 18:54:33.000000000 +0200 -+++ gcc/testsuite/gcc.dg/builtin-object-size-7.c 2009-06-15 18:55:58.000000000 +0200 -@@ -0,0 +1,71 @@ -+/* { dg-do run } */ -+/* { dg-options "-O2" } */ -+ -+typedef __SIZE_TYPE__ size_t; -+extern void *malloc (size_t); -+extern void abort (void); -+ -+struct A -+{ -+ int i, j, k; -+ char buf[255]; -+ int l, m, n, o; -+}; -+ -+int -+main (void) -+{ -+ const size_t s = sizeof (struct A); -+ const size_t o = __builtin_offsetof (struct A, buf); -+ struct A *a = malloc (s); -+ struct A *b = malloc (o + 212); -+ if (__builtin_object_size (a->buf, 0) != s - o) -+ abort (); -+ if (__builtin_object_size (a->buf, 1) != sizeof (a->buf)) -+ abort (); -+ if (__builtin_object_size (a->buf, 2) != s - o) -+ abort (); -+ if (__builtin_object_size (a->buf, 3) != sizeof (a->buf)) -+ abort (); -+ if (__builtin_object_size (&a->buf[0], 0) != s - o) -+ abort (); -+ if (__builtin_object_size (&a->buf[0], 1) != sizeof (a->buf)) -+ abort (); -+ if (__builtin_object_size (&a->buf[0], 2) != s - o) -+ abort (); -+ if (__builtin_object_size (&a->buf[0], 3) != sizeof (a->buf)) -+ abort (); -+ if (__builtin_object_size (&a->buf[6], 0) != s - o - 6) -+ abort (); -+ if (__builtin_object_size (&a->buf[6], 1) != sizeof (a->buf) - 6) -+ abort (); -+ if (__builtin_object_size (&a->buf[6], 2) != s - o - 6) -+ abort (); -+ if (__builtin_object_size (&a->buf[6], 3) != sizeof (a->buf) - 6) -+ abort (); -+ if (__builtin_object_size (b->buf, 0) != 212) -+ abort (); -+ if (__builtin_object_size (b->buf, 1) != 212) -+ abort (); -+ if (__builtin_object_size (b->buf, 2) != 212) -+ abort (); -+ if (__builtin_object_size (b->buf, 3) != 212) -+ abort (); -+ if (__builtin_object_size (&b->buf[0], 0) != 212) -+ abort (); -+ if (__builtin_object_size (&b->buf[0], 1) != 212) -+ abort (); -+ if (__builtin_object_size (&b->buf[0], 2) != 212) -+ abort (); -+ if (__builtin_object_size (&b->buf[0], 3) != 212) -+ abort (); -+ if (__builtin_object_size (&b->buf[28], 0) != 212 - 28) -+ abort (); -+ if (__builtin_object_size (&b->buf[28], 1) != 212 - 28) -+ abort (); -+ if (__builtin_object_size (&b->buf[28], 2) != 212 - 28) -+ abort (); -+ if (__builtin_object_size (&b->buf[28], 3) != 212 - 28) -+ abort (); -+ return 0; -+} diff --git a/sources b/sources index ead4d64..f587f74 100644 --- a/sources +++ b/sources @@ -1,2 +1,2 @@ 2659f09c2e43ef8b7d4406321753f1b2 fastjar-0.97.tar.gz -28d5e6534dfd516f8902f7997e7c7530 gcc-4.4.0-20090615.tar.bz2 +543201581f650293ac88ed716cd53597 gcc-4.4.0-20090623.tar.bz2