aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMartin Matuska <mm@FreeBSD.org>2011-03-10 13:59:17 +0000
committerMartin Matuska <mm@FreeBSD.org>2011-03-10 13:59:17 +0000
commit0e5d163d93004259465517b8c58ecda57537d2f9 (patch)
treebd0b88102eb344ebbe4baf27724c362578cf50b6
parent497e80a371f70c0bdf4bf3ca609adaa065080794 (diff)
downloadsrc-0e5d163d93004259465517b8c58ecda57537d2f9.tar.gz
src-0e5d163d93004259465517b8c58ecda57537d2f9.zip
Vendor upgrade of gcc 4.2 to last GPLv2 revision.
PR: gnu/153298 Obtained from: gcc (gcc-4_2-branch, rev. 127959)
Notes
Notes: svn path=/vendor/gcc/dist/; revision=219451
-rw-r--r--gcc/BASE-VER2
-rw-r--r--gcc/ChangeLog118
-rw-r--r--gcc/DATESTAMP2
-rw-r--r--gcc/DEV-PHASE1
-rw-r--r--gcc/config/mips/predicates.md4
-rw-r--r--gcc/config/rs6000/rs6000.c35
-rw-r--r--gcc/config/s390/s390.md4
-rw-r--r--gcc/cp/ChangeLog63
-rw-r--r--gcc/cp/call.c22
-rw-r--r--gcc/cp/cp-tree.h2
-rw-r--r--gcc/cp/cxx-pretty-print.c4
-rw-r--r--gcc/cp/decl.c2
-rw-r--r--gcc/cp/decl2.c10
-rw-r--r--gcc/cp/error.c16
-rw-r--r--gcc/cp/lex.c15
-rw-r--r--gcc/cp/name-lookup.c47
-rw-r--r--gcc/cp/pt.c13
-rw-r--r--gcc/cp/semantics.c9
-rw-r--r--gcc/cp/typeck.c1
-rw-r--r--gcc/doc/contrib.texi4
-rw-r--r--gcc/dwarf2out.c40
-rw-r--r--gcc/expr.c73
-rw-r--r--gcc/fold-const.c4
-rw-r--r--gcc/gimplify.c18
-rw-r--r--gcc/reload1.c9
-rw-r--r--gcc/simplify-rtx.c3
-rw-r--r--gcc/target-def.h5
-rw-r--r--gcc/target.h4
-rw-r--r--gcc/targhooks.c16
-rw-r--r--gcc/targhooks.h2
-rw-r--r--gcc/tree-if-conv.c10
-rw-r--r--gcc/tree-ssa-structalias.c92
-rw-r--r--gcc/tree-vect-analyze.c59
-rw-r--r--gcc/tree-vect-patterns.c5
-rw-r--r--gcc/tree.c3
-rw-r--r--gcc/tree.h6
-rw-r--r--libstdc++/ChangeLog15
-rw-r--r--libstdc++/include/std/std_valarray.h2
-rw-r--r--libstdc++/include/tr1/random6
39 files changed, 688 insertions, 58 deletions
diff --git a/gcc/BASE-VER b/gcc/BASE-VER
index fae6e3d04b2c..af8c8ec7c134 100644
--- a/gcc/BASE-VER
+++ b/gcc/BASE-VER
@@ -1 +1 @@
-4.2.1
+4.2.2
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 136b464191e0..d0dec77ba171 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,121 @@
+2007-08-31 Jakub Jelinek <jakub@redhat.com>
+
+ PR rtl-optimization/33148
+ * simplify-rtx.c (simplify_unary_operation_1): Only optimize
+ (neg (lt X 0)) if X has scalar int mode.
+
+ PR debug/32914
+ * dwarf2out.c (rtl_for_decl_init): If vector decl has CONSTRUCTOR
+ initializer, use build_vector_from_ctor if possible to create
+ VECTOR_CST out of it. If vector initializer is not VECTOR_CST
+ even after this, return NULL.
+
+2007-08-27 Jason Merrill <jason@redhat.com>
+
+ PR c++/31337
+ * gimplify.c (gimplify_modify_expr): Discard the assignment of
+ zero-sized types after calling gimplify_modify_expr_rhs.
+
+2007-08-24 Jakub Jelinek <jakub@redhat.com>
+
+ PR debug/32610
+ * dwarf2out.c (gen_decl_die): Don't call
+ gen_tagged_type_instantiation_die if decl doesn't have tagged type.
+
+2007-08-24 Richard Guenther <rguenther@suse.de>
+
+ * expr.c (get_inner_reference): Remove unused variable.
+
+2007-08-24 Richard Guenther <rguenther@suse.de>
+
+ * expr.c (get_inner_reference): Do computation of bitoffset
+ from offset in a way we can detect overflow reliably.
+
+2007-08-22 Richard Guenther <rguenther@suse.de>
+
+ PR middle-end/32563
+ * tree.c (host_integerp): Treat sizetype as signed as it is
+ sign-extended.
+
+2007-08-20 Adam Nemet <anemet@caviumnetworks.com>
+
+ * config/mips/predicates.md (const_call_insn_operand): Invoke
+ SYMBOL_REF_LONG_CALL_P only on SYMBOL_REFs.
+
+2007-08-17 Chen liqin <liqin@sunnorth.com.cn>
+
+ * config/score/score.md : Update pattern tablejump.
+ * config/score/score.c : Update score_initialize_trampoline
+ function.
+ * config/score/score.h (TRAMPOLINE_TEMPLATE): Added macro.
+ (TRAMPOLINE_INSNS, TRAMPOLINE_SIZE) Update macro.
+ * doc/contrib.texi: Add my entry.
+
+2007-08-02 Andreas Krebbel <krebbel1@de.ibm.com>
+
+ * config/s390/s390.md ("*xordi3_cconly"): Change xr to xg.
+
+2007-08-01 Andreas Krebbel <krebbel1@de.ibm.com>
+
+ * config/s390/s390.md (TF in GPR splitter): Change operand_subword
+ parameter to TFmode.
+
+2007-07-30 Mark Mitchell <mark@codesourcery.com>
+
+ * BASE-VER: Bump.
+ * DEV-PHASE: Mark as prerelease.
+
+2007-07-25 Steve Ellcey <sje@cup.hp.com>
+
+ PR target/32218
+ * tree-vect-patterns.c (vect_pattern_recog_1): Check for valid type.
+
+2007-07-25 Dorit Nuzman <dorit@il.ibm.com>
+ Devang Patel <dpatel@apple.com>
+
+ PR tree-optimization/25413
+ * targhooks.c (default_builtin_vector_alignment_reachable): New.
+ * targhooks.h (default_builtin_vector_alignment_reachable): New.
+ * tree.h (contains_packed_reference): New.
+ * expr.c (contains_packed_reference): New.
+ * tree-vect-analyze.c (vector_alignment_reachable_p): New.
+ (vect_enhance_data_refs_alignment): Call
+ vector_alignment_reachable_p.
+ * target.h (vector_alignment_reachable): New builtin.
+ * target-def.h (TARGET_VECTOR_ALIGNMENT_REACHABLE): New.
+ * config/rs6000/rs6000.c (rs6000_vector_alignment_reachable): New.
+ (TARGET_VECTOR_ALIGNMENT_REACHABLE): Define.
+
+2007-07-24 Richard Guenther <rguenther@suse.de>
+
+ Backport from mainline:
+ 2007-07-16 Richard Guenther <rguenther@suse.de>
+ Uros Bizjak <ubizjak@gmail.com>
+
+ * tree-if-conv.c (find_phi_replacement_condition): Unshare "*cond"
+ before forcing it to gimple operand.
+
+2007-07-24 Richard Guenther <rguenther@suse.de>
+
+ PR tree-optimization/32723
+ Backport from mainline:
+ 2007-03-09 Daniel Berlin <dberlin@dberlin.org>
+
+ * tree-ssa-structalias.c (shared_bitmap_info_t): New structure.
+ (shared_bitmap_table): New variable.
+ (shared_bitmap_hash): New function.
+ (shared_bitmap_eq): Ditto
+ (shared_bitmap_lookup): Ditto.
+ (shared_bitmap_add): Ditto.
+ (find_what_p_points_to): Rewrite to use shared bitmap hashtable.
+ (init_alias_vars): Init shared bitmap hashtable.
+ (delete_points_to_sets): Delete shared bitmap hashtable.
+
+2007-07-23 Bernd Schmidt <bernd.schmidt@analog.com>
+
+ * reload1.c (choose_reload_regs): Set reload_spill_index for regs
+ chosen during find_reloads.
+
2007-07-19 Release Manager
* GCC 4.2.1 released.
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP
index 38e56c588fe2..a3fd8a5d04e7 100644
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20070719
+20070831
diff --git a/gcc/DEV-PHASE b/gcc/DEV-PHASE
index e69de29bb2d1..373fbc60bb98 100644
--- a/gcc/DEV-PHASE
+++ b/gcc/DEV-PHASE
@@ -0,0 +1 @@
+prerelease
diff --git a/gcc/config/mips/predicates.md b/gcc/config/mips/predicates.md
index 9a6756c20a2f..bbc8e3cf813e 100644
--- a/gcc/config/mips/predicates.md
+++ b/gcc/config/mips/predicates.md
@@ -116,7 +116,9 @@
/* If -mlong-calls, force all calls to use register addressing. Also,
if this function has the long_call attribute, we must use register
addressing. */
- return !TARGET_LONG_CALLS && !SYMBOL_REF_LONG_CALL_P (op);
+ return (!TARGET_LONG_CALLS
+ && !(GET_CODE (op) == SYMBOL_REF
+ && SYMBOL_REF_LONG_CALL_P (op)));
case SYMBOL_GOT_GLOBAL:
/* Without explicit relocs, there is no special syntax for
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 6670a2034f20..5e705d00774d 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -664,6 +664,7 @@ static int rs6000_use_sched_lookahead (void);
static tree rs6000_builtin_mask_for_load (void);
static void def_builtin (int, const char *, tree, int);
+static bool rs6000_vector_alignment_reachable (tree, bool);
static void rs6000_init_builtins (void);
static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
@@ -915,6 +916,9 @@ static const char alt_reg_names[][8] =
#undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
#define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
+#undef TARGET_VECTOR_ALIGNMENT_REACHABLE
+#define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
+
#undef TARGET_INIT_BUILTINS
#define TARGET_INIT_BUILTINS rs6000_init_builtins
@@ -1584,6 +1588,37 @@ rs6000_builtin_mask_for_load (void)
return 0;
}
+
+/* Return true iff, data reference of TYPE can reach vector alignment (16)
+ after applying N number of iterations. This routine does not determine
+ how may iterations are required to reach desired alignment. */
+
+static bool
+rs6000_vector_alignment_reachable (tree type ATTRIBUTE_UNUSED, bool is_packed)
+{
+ if (is_packed)
+ return false;
+
+ if (TARGET_32BIT)
+ {
+ if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
+ return true;
+
+ if (rs6000_alignment_flags == MASK_ALIGN_POWER)
+ return true;
+
+ return false;
+ }
+ else
+ {
+ if (TARGET_MACHO)
+ return false;
+
+ /* Assuming that all other types are naturally aligned. CHECKME! */
+ return true;
+ }
+}
+
/* Handle generic options of the form -mfoo=yes/no.
NAME is the option name.
VALUE is the option value.
diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md
index 23484098f790..e8eb20684688 100644
--- a/gcc/config/s390/s390.md
+++ b/gcc/config/s390/s390.md
@@ -1500,7 +1500,7 @@
&& !s_operand (operands[1], VOIDmode)"
[(set (match_dup 0) (match_dup 1))]
{
- rtx addr = operand_subword (operands[0], 1, 0, DFmode);
+ rtx addr = operand_subword (operands[0], 1, 0, TFmode);
s390_load_address (addr, XEXP (operands[1], 0));
operands[1] = replace_equiv_address (operands[1], addr);
})
@@ -5624,7 +5624,7 @@
"s390_match_ccmode(insn, CCTmode) && TARGET_64BIT"
"@
xgr\t%0,%2
- xr\t%0,%2"
+ xg\t%0,%2"
[(set_attr "op_type" "RRE,RXY")])
(define_insn "*xordi3_extimm"
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 34c036f01c17..39875472b86c 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,66 @@
+2007-08-24 Jakub Jelinek <jakub@redhat.com>
+
+ PR c++/31941
+ * error.c (resolve_virtual_fun_from_obj_type_ref): Handle
+ TARGET_VTABLE_USES_DESCRIPTORS targets properly.
+
+ PR c++/32898
+ * name-lookup.c (set_decl_namespace): lookup_qualified_name failure
+ is error_mark_node rather than NULL_TREE.
+ * pt.c (check_explicit_specialization): Likewise.
+
+2007-08-22 Jason Merrill <jason@redhat.com>
+
+ PR c++/29365
+ * pt.c (outermost_tinst_level): New function.
+ * lex.c (in_main_input_context): New function.
+ * cp-tree.h: Declare it.
+ * decl2.c (constrain_class_visibility): Use it to avoid warning
+ about uses of the anonymous namespace in the main input file.
+
+2007-08-20 Jakub Jelinek <jakub@redhat.com>
+
+ PR c++/32992
+ * typeck.c (check_return_expr): Don't NRV optimize vars in
+ anonymous unions.
+ * decl.c (finish_function): Comment fix.
+
+2007-08-18 Paolo Carlini <pcarlini@suse.de>
+
+ PR c++/32112
+ * error.c (dump_decl): Deal with UNBOUND_CLASS_TEMPLATE.
+ * cxx-pretty-print.c (pp_cxx_unqualified_id): Likewise.
+
+2007-08-10 Paolo Carlini <pcarlini@suse.de>
+
+ PR c++/17763
+ * error.c (dump_expr): Consistently use the *_cxx_*
+ variants of the pretty-print functions.
+
+2007-07-30 Paolo Carlini <pcarlini@suse.de>
+
+ PR c++/32108
+ * semantics.c (finish_label_stmt): Reject the __label__
+ extension outside function scopes.
+
+2007-07-28 Simon Martin <simartin@users.sourceforge.net>
+ Mark Mitchell <mark@codesourcery.com>
+
+ PR c++/30917
+ * name-lookup.c (lookup_name_real): Non namespace-scope bindings can be
+ hidden due to friend declarations in local classes.
+
+2007-07-27 Mark Mitchell <mark@codesourcery.com>
+
+ PR c++/32346
+ * call.c (convert_for_arg_passing): Only widen bitfields to their
+ declared types if necessary.
+
+2007-07-24 Paolo Carlini <pcarlini@suse.de>
+
+ PR c++/30535
+ * pt.c (unify): Never pass error_mark_node to template_decl_level.
+
2007-07-19 Release Manager
* GCC 4.2.1 released.
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 862c3d0ecca1..848f3c894c8e 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -4674,7 +4674,27 @@ type_passed_as (tree type)
tree
convert_for_arg_passing (tree type, tree val)
{
- val = convert_bitfield_to_declared_type (val);
+ tree bitfield_type;
+
+ /* If VAL is a bitfield, then -- since it has already been converted
+ to TYPE -- it cannot have a precision greater than TYPE.
+
+ If it has a smaller precision, we must widen it here. For
+ example, passing "int f:3;" to a function expecting an "int" will
+ not result in any conversion before this point.
+
+ If the precision is the same we must not risk widening. For
+ example, the COMPONENT_REF for a 32-bit "long long" bitfield will
+ often have type "int", even though the C++ type for the field is
+ "long long". If the value is being passed to a function
+ expecting an "int", then no conversions will be required. But,
+ if we call convert_bitfield_to_declared_type, the bitfield will
+ be converted to "long long". */
+ bitfield_type = is_bitfield_expr_with_lowered_type (val);
+ if (bitfield_type
+ && TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type))
+ val = convert_to_integer (TYPE_MAIN_VARIANT (bitfield_type), val);
+
if (val == error_mark_node)
;
/* Pass classes with copy ctors by invisible reference. */
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 9e0342a3903a..deea897c465b 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4079,6 +4079,7 @@ extern void yyerror (const char *);
extern void yyhook (int);
extern bool cxx_init (void);
extern void cxx_finish (void);
+extern bool in_main_input_context (void);
/* in method.c */
extern void init_method (void);
@@ -4161,6 +4162,7 @@ extern tree build_non_dependent_args (tree);
extern bool reregister_specialization (tree, tree, tree);
extern tree fold_non_dependent_expr (tree);
extern bool explicit_class_specialization_p (tree);
+extern tree outermost_tinst_level (void);
/* in repo.c */
extern void init_repo (void);
diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c
index 5ceca61a4cb3..5f6150aab76a 100644
--- a/gcc/cp/cxx-pretty-print.c
+++ b/gcc/cp/cxx-pretty-print.c
@@ -204,6 +204,10 @@ pp_cxx_unqualified_id (cxx_pretty_printer *pp, tree t)
pp_cxx_unqualified_id (pp, TEMPLATE_PARM_DECL (t));
break;
+ case UNBOUND_CLASS_TEMPLATE:
+ pp_cxx_unqualified_id (pp, TYPE_NAME (t));
+ break;
+
default:
pp_unsupported_tree (pp, t);
break;
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 28e653b0751e..b837b1451538 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -11273,7 +11273,7 @@ finish_function (int flags)
gcc_assert (stmts_are_full_exprs_p ());
/* Set up the named return value optimization, if we can. Candidate
- variables are selected in check_return_value. */
+ variables are selected in check_return_expr. */
if (current_function_return_value)
{
tree r = current_function_return_value;
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 00bcc16b7a5a..310dc83159dd 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -1860,9 +1860,12 @@ constrain_class_visibility (tree type)
int subvis = type_visibility (ftype);
if (subvis == VISIBILITY_ANON)
- warning (0, "\
+ {
+ if (!in_main_input_context ())
+ warning (0, "\
%qT has a field %qD whose type uses the anonymous namespace",
type, t);
+ }
else if (IS_AGGR_TYPE (ftype)
&& vis < VISIBILITY_HIDDEN
&& subvis >= VISIBILITY_HIDDEN)
@@ -1877,9 +1880,12 @@ constrain_class_visibility (tree type)
int subvis = type_visibility (TREE_TYPE (t));
if (subvis == VISIBILITY_ANON)
- warning (0, "\
+ {
+ if (!in_main_input_context())
+ warning (0, "\
%qT has a base %qT whose type uses the anonymous namespace",
type, TREE_TYPE (t));
+ }
else if (vis < VISIBILITY_HIDDEN
&& subvis >= VISIBILITY_HIDDEN)
warning (OPT_Wattributes, "\
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 2962fe655f64..c169cabedb64 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -901,6 +901,10 @@ dump_decl (tree t, int flags)
pp_type_id (cxx_pp, t);
break;
+ case UNBOUND_CLASS_TEMPLATE:
+ dump_type (t, flags);
+ break;
+
default:
pp_unsupported_tree (cxx_pp, t);
/* Fall through to error. */
@@ -1301,10 +1305,14 @@ static tree
resolve_virtual_fun_from_obj_type_ref (tree ref)
{
tree obj_type = TREE_TYPE (OBJ_TYPE_REF_OBJECT (ref));
- int index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
+ HOST_WIDE_INT index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
tree fun = BINFO_VIRTUALS (TYPE_BINFO (TREE_TYPE (obj_type)));
- while (index--)
+ while (index)
+ {
fun = TREE_CHAIN (fun);
+ index -= (TARGET_VTABLE_USES_DESCRIPTORS
+ ? TARGET_VTABLE_USES_DESCRIPTORS : 1);
+ }
return BV_FN (fun);
}
@@ -1420,13 +1428,13 @@ dump_expr (tree t, int flags)
if (TREE_CODE (ob) == ADDR_EXPR)
{
dump_expr (TREE_OPERAND (ob, 0), flags | TFF_EXPR_IN_PARENS);
- pp_dot (cxx_pp);
+ pp_cxx_dot (cxx_pp);
}
else if (TREE_CODE (ob) != PARM_DECL
|| strcmp (IDENTIFIER_POINTER (DECL_NAME (ob)), "this"))
{
dump_expr (ob, flags | TFF_EXPR_IN_PARENS);
- pp_arrow (cxx_pp);
+ pp_cxx_arrow (cxx_pp);
}
args = TREE_CHAIN (args);
}
diff --git a/gcc/cp/lex.c b/gcc/cp/lex.c
index d14a1baa926e..65dcd7d6023d 100644
--- a/gcc/cp/lex.c
+++ b/gcc/cp/lex.c
@@ -827,3 +827,18 @@ make_aggr_type (enum tree_code code)
return t;
}
+
+/* Returns true if we are currently in the main source file, or in a
+ template instantiation started from the main source file. */
+
+bool
+in_main_input_context (void)
+{
+ tree tl = outermost_tinst_level();
+
+ if (tl)
+ return strcmp (main_input_filename,
+ LOCATION_FILE (TINST_LOCATION (tl))) == 0;
+ else
+ return strcmp (main_input_filename, input_filename) == 0;
+}
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 3016bb0ad560..744dd5c489ec 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -2924,7 +2924,7 @@ set_decl_namespace (tree decl, tree scope, bool friendp)
/* See whether this has been declared in the namespace. */
old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
- if (!old)
+ if (old == error_mark_node)
/* No old declaration at all. */
goto complain;
if (!is_overloaded_fn (decl))
@@ -3996,8 +3996,49 @@ lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
if (binding)
{
- /* Only namespace-scope bindings can be hidden. */
- gcc_assert (!hidden_name_p (binding));
+ if (hidden_name_p (binding))
+ {
+ /* A non namespace-scope binding can only be hidden if
+ we are in a local class, due to friend declarations.
+ In particular, consider:
+
+ void f() {
+ struct A {
+ friend struct B;
+ void g() { B* b; } // error: B is hidden
+ }
+ struct B {};
+ }
+
+ The standard says that "B" is a local class in "f"
+ (but not nested within "A") -- but that name lookup
+ for "B" does not find this declaration until it is
+ declared directly with "f".
+
+ In particular:
+
+ [class.friend]
+
+ If a friend declaration appears in a local class and
+ the name specified is an unqualified name, a prior
+ declaration is looked up without considering scopes
+ that are outside the innermost enclosing non-class
+ scope. For a friend class declaration, if there is no
+ prior declaration, the class that is specified
+ belongs to the innermost enclosing non-class scope,
+ but if it is subsequently referenced, its name is not
+ found by name lookup until a matching declaration is
+ provided in the innermost enclosing nonclass scope.
+ */
+ gcc_assert (current_class_type &&
+ LOCAL_CLASS_P (current_class_type));
+
+ /* This binding comes from a friend declaration in the local
+ class. The standard (11.4.8) states that the lookup can
+ only succeed if there is a non-hidden declaration in the
+ current scope, which is not the case here. */
+ POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
+ }
val = binding;
break;
}
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 477265d49d0d..ac28afa4136f 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -1971,7 +1971,7 @@ check_explicit_specialization (tree declarator,
context. */
fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
false, true);
- if (!fns || !is_overloaded_fn (fns))
+ if (fns == error_mark_node || !is_overloaded_fn (fns))
{
error ("%qD is not a template function", dname);
fns = error_mark_node;
@@ -5288,6 +5288,15 @@ reopen_tinst_level (tree level)
pop_tinst_level ();
}
+/* Returns the TINST_LEVEL which gives the original instantiation
+ context. */
+
+tree
+outermost_tinst_level (void)
+{
+ return tree_last (current_tinst_level);
+}
+
/* DECL is a friend FUNCTION_DECL or TEMPLATE_DECL. ARGS is the
vector of template arguments, as for tsubst.
@@ -10453,6 +10462,8 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict)
case TEMPLATE_TEMPLATE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
tparm = TREE_VALUE (TREE_VEC_ELT (tparms, 0));
+ if (tparm == error_mark_node)
+ return 1;
if (TEMPLATE_TYPE_LEVEL (parm)
!= template_decl_level (tparm))
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 8ad197858d0f..9c37b36cea34 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1320,8 +1320,13 @@ finish_label_stmt (tree name)
void
finish_label_decl (tree name)
{
- tree decl = declare_local_label (name);
- add_decl_expr (decl);
+ if (!at_function_scope_p ())
+ {
+ error ("__label__ declarations are only allowed in function scopes");
+ return;
+ }
+
+ add_decl_expr (declare_local_label (name));
}
/* When DECL goes out of scope, make sure that CLEANUP is executed. */
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 4ae2f073abde..6f0777274cef 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -6604,6 +6604,7 @@ check_return_expr (tree retval, bool *no_warning)
&& TREE_CODE (retval) == VAR_DECL
&& DECL_CONTEXT (retval) == current_function_decl
&& ! TREE_STATIC (retval)
+ && ! DECL_ANON_UNION_VAR_P (retval)
&& (DECL_ALIGN (retval)
>= DECL_ALIGN (DECL_RESULT (current_function_decl)))
&& same_type_p ((TYPE_MAIN_VARIANT
diff --git a/gcc/doc/contrib.texi b/gcc/doc/contrib.texi
index 16c8af58de4b..7e3d4b11e170 100644
--- a/gcc/doc/contrib.texi
+++ b/gcc/doc/contrib.texi
@@ -514,6 +514,10 @@ patches.
Robert Lipe for OpenServer support, new testsuites, testing, etc.
@item
+Chen Liqin for various S+core related fixes/improvement, and for
+maintaining the S+core port.
+
+@item
Weiwen Liu for testing and various bug fixes.
@item
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index 30bb90f1b5b9..4416fd645b18 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -10065,6 +10065,43 @@ rtl_for_decl_init (tree init, tree type)
else if (initializer_constant_valid_p (init, type)
&& ! walk_tree (&init, reference_to_unused, NULL, NULL))
{
+ /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
+ possible. */
+ if (TREE_CODE (type) == VECTOR_TYPE)
+ switch (TREE_CODE (init))
+ {
+ case VECTOR_CST:
+ break;
+ case CONSTRUCTOR:
+ if (TREE_CONSTANT (init))
+ {
+ VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
+ bool constant_p = true;
+ tree value;
+ unsigned HOST_WIDE_INT ix;
+
+ /* Even when ctor is constant, it might contain non-*_CST
+ elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
+ belong into VECTOR_CST nodes. */
+ FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
+ if (!CONSTANT_CLASS_P (value))
+ {
+ constant_p = false;
+ break;
+ }
+
+ if (constant_p)
+ {
+ init = build_vector_from_ctor (type, elts);
+ break;
+ }
+ }
+ /* FALLTHRU */
+
+ default:
+ return NULL;
+ }
+
rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
/* If expand_expr returns a MEM, it wasn't immediate. */
@@ -13197,7 +13234,8 @@ gen_decl_die (tree decl, dw_die_ref context_die)
was generated within the original definition of an inline function) we
have to generate a special (abbreviated) DW_TAG_structure_type,
DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
- if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
+ if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE
+ && is_tagged_type (TREE_TYPE (decl)))
{
gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
break;
diff --git a/gcc/expr.c b/gcc/expr.c
index c6bc4263b86d..1773fa179a8f 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -5654,7 +5654,6 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
enum machine_mode mode = VOIDmode;
tree offset = size_zero_node;
tree bit_offset = bitsize_zero_node;
- tree tem;
/* First get the mode, signedness, and size. We do this from just the
outermost expression. */
@@ -5690,6 +5689,8 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
*pbitsize = tree_low_cst (size_tree, 1);
}
+ *pmode = mode;
+
/* Compute cumulative bit-offset for nested component-refs and array-refs,
and find the ultimate containing object. */
while (1)
@@ -5774,21 +5775,69 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
done:
/* If OFFSET is constant, see if we can return the whole thing as a
- constant bit position. Otherwise, split it up. */
- if (host_integerp (offset, 0)
- && 0 != (tem = size_binop (MULT_EXPR,
- fold_convert (bitsizetype, offset),
- bitsize_unit_node))
- && 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
- && host_integerp (tem, 0))
- *pbitpos = tree_low_cst (tem, 0), *poffset = 0;
- else
- *pbitpos = tree_low_cst (bit_offset, 0), *poffset = offset;
+ constant bit position. Make sure to handle overflow during
+ this conversion. */
+ if (host_integerp (offset, 0))
+ {
+ double_int tem = double_int_mul (tree_to_double_int (offset),
+ uhwi_to_double_int (BITS_PER_UNIT));
+ tem = double_int_add (tem, tree_to_double_int (bit_offset));
+ if (double_int_fits_in_shwi_p (tem))
+ {
+ *pbitpos = double_int_to_shwi (tem);
+ *poffset = NULL_TREE;
+ return exp;
+ }
+ }
+
+ /* Otherwise, split it up. */
+ *pbitpos = tree_low_cst (bit_offset, 0);
+ *poffset = offset;
- *pmode = mode;
return exp;
}
+/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
+ look for whether EXP or any nested component-refs within EXP is marked
+ as PACKED. */
+
+bool
+contains_packed_reference (tree exp)
+{
+ bool packed_p = false;
+
+ while (1)
+ {
+ switch (TREE_CODE (exp))
+ {
+ case COMPONENT_REF:
+ {
+ tree field = TREE_OPERAND (exp, 1);
+ packed_p = DECL_PACKED (field)
+ || TYPE_PACKED (TREE_TYPE (field))
+ || TYPE_PACKED (TREE_TYPE (exp));
+ if (packed_p)
+ goto done;
+ }
+ break;
+
+ case BIT_FIELD_REF:
+ case ARRAY_REF:
+ case ARRAY_RANGE_REF:
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ case VIEW_CONVERT_EXPR:
+ break;
+
+ default:
+ goto done;
+ }
+ exp = TREE_OPERAND (exp, 0);
+ }
+ done:
+ return packed_p;
+}
+
/* Return a tree of sizetype representing the size, in bytes, of the element
of EXP, an ARRAY_REF. */
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index ea16eae741b7..0753caa15368 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -9387,6 +9387,7 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
/* ~X | X is -1. */
if (TREE_CODE (arg0) == BIT_NOT_EXPR
+ && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
&& operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
{
t1 = build_int_cst (type, -1);
@@ -9396,6 +9397,7 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
/* X | ~X is -1. */
if (TREE_CODE (arg1) == BIT_NOT_EXPR
+ && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
&& operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
{
t1 = build_int_cst (type, -1);
@@ -9503,6 +9505,7 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
/* ~X ^ X is -1. */
if (TREE_CODE (arg0) == BIT_NOT_EXPR
+ && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
&& operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
{
t1 = build_int_cst (type, -1);
@@ -9512,6 +9515,7 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
/* X ^ ~X is -1. */
if (TREE_CODE (arg1) == BIT_NOT_EXPR
+ && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
&& operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
{
t1 = build_int_cst (type, -1);
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index e6c0d1f241db..80dcd1ac5f2a 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -3532,8 +3532,16 @@ gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
|| TREE_CODE (*expr_p) == INIT_EXPR);
- /* For zero sized types only gimplify the left hand side and right hand side
- as statements and throw away the assignment. */
+ /* See if any simplifications can be done based on what the RHS is. */
+ ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
+ want_value);
+ if (ret != GS_UNHANDLED)
+ return ret;
+
+ /* For zero sized types only gimplify the left hand side and right hand
+ side as statements and throw away the assignment. Do this after
+ gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
+ types properly. */
if (zero_sized_type (TREE_TYPE (*from_p)))
{
gimplify_stmt (from_p);
@@ -3544,12 +3552,6 @@ gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
return GS_ALL_DONE;
}
- /* See if any simplifications can be done based on what the RHS is. */
- ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
- want_value);
- if (ret != GS_UNHANDLED)
- return ret;
-
/* If the value being copied is of variable width, compute the length
of the copy into a WITH_SIZE_EXPR. Note that we need to do this
before gimplifying any of the operands so that we can resolve any
diff --git a/gcc/reload1.c b/gcc/reload1.c
index a2449da0969c..20da1b67b419 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -5451,7 +5451,14 @@ choose_reload_regs (struct insn_chain *chain)
for (j = 0; j < n_reloads; j++)
{
reload_order[j] = j;
- reload_spill_index[j] = -1;
+ if (rld[j].reg_rtx != NULL_RTX)
+ {
+ gcc_assert (REG_P (rld[j].reg_rtx)
+ && HARD_REGISTER_P (rld[j].reg_rtx));
+ reload_spill_index[j] = REGNO (rld[j].reg_rtx);
+ }
+ else
+ reload_spill_index[j] = -1;
if (rld[j].nregs > 1)
{
diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 10be1e18d767..b088d9208784 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -589,7 +589,8 @@ simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op)
/* (neg (lt x 0)) is (ashiftrt X C) if STORE_FLAG_VALUE is 1. */
/* (neg (lt x 0)) is (lshiftrt X C) if STORE_FLAG_VALUE is -1. */
if (GET_CODE (op) == LT
- && XEXP (op, 1) == const0_rtx)
+ && XEXP (op, 1) == const0_rtx
+ && SCALAR_INT_MODE_P (GET_MODE (XEXP (op, 0))))
{
enum machine_mode inner = GET_MODE (XEXP (op, 0));
int isize = GET_MODE_BITSIZE (inner);
diff --git a/gcc/target-def.h b/gcc/target-def.h
index 0361a788e8ae..653d6fd9b0ba 100644
--- a/gcc/target-def.h
+++ b/gcc/target-def.h
@@ -337,9 +337,12 @@ Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
TARGET_SCHED_SET_SCHED_FLAGS}
#define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD 0
+#define TARGET_VECTOR_ALIGNMENT_REACHABLE \
+ default_builtin_vector_alignment_reachable
#define TARGET_VECTORIZE \
- {TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD}
+ {TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD, \
+ TARGET_VECTOR_ALIGNMENT_REACHABLE}
#define TARGET_DEFAULT_TARGET_FLAGS 0
diff --git a/gcc/target.h b/gcc/target.h
index d0a38f2a59b1..f407bb7573df 100644
--- a/gcc/target.h
+++ b/gcc/target.h
@@ -375,6 +375,10 @@ struct gcc_target
by the vectorizer, and return the decl of the target builtin
function. */
tree (* builtin_mask_for_load) (void);
+
+ /* Return true if vector alignment is reachable (by peeling N
+ interations) for the given type. */
+ bool (* vector_alignment_reachable) (tree, bool);
} vectorize;
/* The initial value of target_flags. */
diff --git a/gcc/targhooks.c b/gcc/targhooks.c
index b164c842b974..796bd2d6f3dc 100644
--- a/gcc/targhooks.c
+++ b/gcc/targhooks.c
@@ -604,4 +604,20 @@ default_reloc_rw_mask (void)
return flag_pic ? 3 : 0;
}
+bool
+default_builtin_vector_alignment_reachable (tree type, bool is_packed)
+{
+ if (is_packed)
+ return false;
+
+ /* Assuming that types whose size is > pointer-size are not guaranteed to be
+ naturally aligned. */
+ if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
+ return false;
+
+ /* Assuming that types whose size is <= pointer-size
+ are naturally aligned. */
+ return true;
+}
+
#include "gt-targhooks.h"
diff --git a/gcc/targhooks.h b/gcc/targhooks.h
index 7884f159ee44..7f990e9a138d 100644
--- a/gcc/targhooks.h
+++ b/gcc/targhooks.h
@@ -57,6 +57,8 @@ extern const char * default_invalid_within_doloop (rtx);
extern bool default_narrow_bitfield (void);
+extern bool default_builtin_vector_alignment_reachable (tree, bool);
+
/* These are here, and not in hooks.[ch], because not all users of
hooks.h include tm.h, and thus we don't have CUMULATIVE_ARGS. */
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index 5b4a9a33c0be..722721ade929 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -743,7 +743,7 @@ find_phi_replacement_condition (struct loop *loop,
if (TREE_CODE (*cond) == TRUTH_NOT_EXPR)
/* We can be smart here and choose inverted
condition without switching bbs. */
- *cond = invert_truthvalue (*cond);
+ *cond = invert_truthvalue (*cond);
else
/* Select non loop header bb. */
first_edge = second_edge;
@@ -762,9 +762,11 @@ find_phi_replacement_condition (struct loop *loop,
/* Create temp. for the condition. Vectorizer prefers to have gimple
value as condition. Various targets use different means to communicate
- condition in vector compare operation. Using gimple value allows compiler
- to emit vector compare and select RTL without exposing compare's result. */
- *cond = force_gimple_operand (*cond, &new_stmts, false, NULL_TREE);
+ condition in vector compare operation. Using gimple value allows
+ compiler to emit vector compare and select RTL without exposing
+ compare's result. */
+ *cond = force_gimple_operand (unshare_expr (*cond), &new_stmts,
+ false, NULL_TREE);
if (new_stmts)
bsi_insert_before (bsi, new_stmts, BSI_SAME_STMT);
if (!is_gimple_reg (*cond) && !is_gimple_condexpr (*cond))
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index d2bc09ba3b06..29811ca0ade7 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -4350,6 +4350,75 @@ intra_create_variable_infos (void)
process_constraint (new_constraint (lhs, rhs));
}
+/* Structure used to put solution bitmaps in a hashtable so they can
+ be shared among variables with the same points-to set. */
+
+typedef struct shared_bitmap_info
+{
+ bitmap pt_vars;
+ hashval_t hashcode;
+} *shared_bitmap_info_t;
+
+static htab_t shared_bitmap_table;
+
+/* Hash function for a shared_bitmap_info_t */
+
+static hashval_t
+shared_bitmap_hash (const void *p)
+{
+ const shared_bitmap_info_t bi = (shared_bitmap_info_t) p;
+ return bi->hashcode;
+}
+
+/* Equality function for two shared_bitmap_info_t's. */
+
+static int
+shared_bitmap_eq (const void *p1, const void *p2)
+{
+ const shared_bitmap_info_t sbi1 = (shared_bitmap_info_t) p1;
+ const shared_bitmap_info_t sbi2 = (shared_bitmap_info_t) p2;
+ return bitmap_equal_p (sbi1->pt_vars, sbi2->pt_vars);
+}
+
+/* Lookup a bitmap in the shared bitmap hashtable, and return an already
+ existing instance if there is one, NULL otherwise. */
+
+static bitmap
+shared_bitmap_lookup (bitmap pt_vars)
+{
+ void **slot;
+ struct shared_bitmap_info sbi;
+
+ sbi.pt_vars = pt_vars;
+ sbi.hashcode = bitmap_hash (pt_vars);
+
+ slot = htab_find_slot_with_hash (shared_bitmap_table, &sbi,
+ sbi.hashcode, NO_INSERT);
+ if (!slot)
+ return NULL;
+ else
+ return ((shared_bitmap_info_t) *slot)->pt_vars;
+}
+
+
+/* Add a bitmap to the shared bitmap hashtable. */
+
+static void
+shared_bitmap_add (bitmap pt_vars)
+{
+ void **slot;
+ shared_bitmap_info_t sbi = XNEW (struct shared_bitmap_info);
+
+ sbi->pt_vars = pt_vars;
+ sbi->hashcode = bitmap_hash (pt_vars);
+
+ slot = htab_find_slot_with_hash (shared_bitmap_table, sbi,
+ sbi->hashcode, INSERT);
+ gcc_assert (!*slot);
+ *slot = (void *) sbi;
+}
+
+
/* Set bits in INTO corresponding to the variable uids in solution set
FROM, which came from variable PTR.
For variables that are actually dereferenced, we also use type
@@ -4460,7 +4529,9 @@ find_what_p_points_to (tree p)
struct ptr_info_def *pi = get_ptr_info (p);
unsigned int i;
bitmap_iterator bi;
-
+ bitmap finished_solution;
+ bitmap result;
+
/* This variable may have been collapsed, let's get the real
variable. */
vi = get_varinfo (find (vi->id));
@@ -4492,10 +4563,20 @@ find_what_p_points_to (tree p)
if (pi->pt_anything)
return false;
- if (!pi->pt_vars)
- pi->pt_vars = BITMAP_GGC_ALLOC ();
+ finished_solution = BITMAP_GGC_ALLOC ();
+ set_uids_in_ptset (vi->decl, finished_solution, vi->solution);
+ result = shared_bitmap_lookup (finished_solution);
- set_uids_in_ptset (vi->decl, pi->pt_vars, vi->solution);
+ if (!result)
+ {
+ shared_bitmap_add (finished_solution);
+ pi->pt_vars = finished_solution;
+ }
+ else
+ {
+ pi->pt_vars = result;
+ bitmap_clear (finished_solution);
+ }
if (bitmap_empty_p (pi->pt_vars))
pi->pt_vars = NULL;
@@ -4691,6 +4772,8 @@ init_alias_vars (void)
vi_for_tree = pointer_map_create ();
memset (&stats, 0, sizeof (stats));
+ shared_bitmap_table = htab_create (511, shared_bitmap_hash,
+ shared_bitmap_eq, free);
init_base_vars ();
}
@@ -4923,6 +5006,7 @@ delete_points_to_sets (void)
varinfo_t v;
int i;
+ htab_delete (shared_bitmap_table);
if (dump_file && (dump_flags & TDF_STATS))
fprintf (dump_file, "Points to sets created:%d\n",
stats.points_to_sets_created);
diff --git a/gcc/tree-vect-analyze.c b/gcc/tree-vect-analyze.c
index f247cd9ab31f..17cb9de1e5fc 100644
--- a/gcc/tree-vect-analyze.c
+++ b/gcc/tree-vect-analyze.c
@@ -25,6 +25,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
#include "tm.h"
#include "ggc.h"
#include "tree.h"
+#include "target.h"
#include "basic-block.h"
#include "diagnostic.h"
#include "tree-flow.h"
@@ -911,6 +912,57 @@ vect_verify_datarefs_alignment (loop_vec_info loop_vinfo)
}
+/* Function vector_alignment_reachable_p
+
+ Return true if vector alignment for DR is reachable by peeling
+ a few loop iterations. Return false otherwise. */
+
+static bool
+vector_alignment_reachable_p (struct data_reference *dr)
+{
+ tree stmt = DR_STMT (dr);
+ stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+ tree vectype = STMT_VINFO_VECTYPE (stmt_info);
+
+ /* If misalignment is known at the compile time then allow peeling
+ only if natural alignment is reachable through peeling. */
+ if (known_alignment_for_access_p (dr) && !aligned_access_p (dr))
+ {
+ HOST_WIDE_INT elmsize =
+ int_cst_value (TYPE_SIZE_UNIT (TREE_TYPE (vectype)));
+ if (vect_print_dump_info (REPORT_DETAILS))
+ {
+ fprintf (vect_dump, "data size =" HOST_WIDE_INT_PRINT_DEC, elmsize);
+ fprintf (vect_dump, ". misalignment = %d. ", DR_MISALIGNMENT (dr));
+ }
+ if (DR_MISALIGNMENT (dr) % elmsize)
+ {
+ if (vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "data size does not divide the misalignment.\n");
+ return false;
+ }
+ }
+
+ if (!known_alignment_for_access_p (dr))
+ {
+ tree type = (TREE_TYPE (DR_REF (dr)));
+ tree ba = DR_BASE_OBJECT (dr);
+ bool is_packed = false;
+
+ if (ba)
+ is_packed = contains_packed_reference (ba);
+
+ if (vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "Unknown misalignment, is_packed = %d",is_packed);
+ if (targetm.vectorize.vector_alignment_reachable (type, is_packed))
+ return true;
+ else
+ return false;
+ }
+
+ return true;
+}
+
/* Function vect_enhance_data_refs_alignment
This pass will use loop versioning and loop peeling in order to enhance
@@ -1056,8 +1108,11 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
for (i = 0; VEC_iterate (data_reference_p, datarefs, i, dr); i++)
if (!DR_IS_READ (dr) && !aligned_access_p (dr))
{
- dr0 = dr;
- do_peeling = true;
+ do_peeling = vector_alignment_reachable_p (dr);
+ if (do_peeling)
+ dr0 = dr;
+ if (!do_peeling && vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "vector alignment may not be reachable");
break;
}
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index 9ac11b07bd35..1c57c59ebb9b 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -499,8 +499,9 @@ vect_pattern_recog_1 (
|| (icode = optab->handlers[(int) vec_mode].insn_code) ==
CODE_FOR_nothing
|| (type_out
- && (insn_data[icode].operand[0].mode !=
- TYPE_MODE (get_vectype_for_scalar_type (type_out)))))
+ && (!get_vectype_for_scalar_type (type_out)
+ || (insn_data[icode].operand[0].mode !=
+ TYPE_MODE (get_vectype_for_scalar_type (type_out))))))
return;
}
diff --git a/gcc/tree.c b/gcc/tree.c
index 90b860ce1afb..a4f0616323bc 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -4540,7 +4540,8 @@ host_integerp (tree t, int pos)
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
|| (! pos && TREE_INT_CST_HIGH (t) == -1
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
- && !TYPE_UNSIGNED (TREE_TYPE (t)))
+ && (!TYPE_UNSIGNED (TREE_TYPE (t))
+ || TYPE_IS_SIZETYPE (TREE_TYPE (t))))
|| (pos && TREE_INT_CST_HIGH (t) == 0)));
}
diff --git a/gcc/tree.h b/gcc/tree.h
index 760a4507c228..7861514dc26b 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4112,6 +4112,12 @@ extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
tree *, enum machine_mode *, int *, int *,
bool);
+/* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
+ look for whether EXP or any nested component-refs within EXP is marked
+ as PACKED. */
+
+extern bool contains_packed_reference (tree exp);
+
/* Return 1 if T is an expression that get_inner_reference handles. */
extern int handled_component_p (tree);
diff --git a/libstdc++/ChangeLog b/libstdc++/ChangeLog
index 7aa047877ffc..d915bcf66fbe 100644
--- a/libstdc++/ChangeLog
+++ b/libstdc++/ChangeLog
@@ -1,3 +1,18 @@
+2007-08-28 Paolo Carlini <pcarlini@suse.de>
+
+ PR libstdc++/33128
+ * include/tr1/random (uniform_int<>::_M_call): Deal with
+ __urng() returning negative values.
+ * testsuite/tr1/5_numerical_facilities/random/uniform_int/33128.cc:
+ New.
+
+2007-08-17 Johannes Willkomm <willkomm@sc.rwth-aachen.de>
+
+ PR libstdc++/33084
+ * include/std/valarray (operator _Op(const _Tp&,
+ const valarray<>&)): Fix typo.
+ * testsuite/26_numerics/numeric_arrays/valarray/33084.cc: New.
+
2007-07-19 Release Manager
* GCC 4.2.1 released.
diff --git a/libstdc++/include/std/std_valarray.h b/libstdc++/include/std/std_valarray.h
index 87f30ec4e028..6ef21500fc67 100644
--- a/libstdc++/include/std/std_valarray.h
+++ b/libstdc++/include/std/std_valarray.h
@@ -1010,7 +1010,7 @@ _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
{ \
typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \
typedef typename __fun<_Name, _Tp>::result_type _Rt; \
- return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \
+ return _Expr<_Closure, _Rt>(_Closure(__t, __v)); \
}
_DEFINE_BINARY_OPERATOR(+, __plus)
diff --git a/libstdc++/include/tr1/random b/libstdc++/include/tr1/random
index 56ea508575d3..c97f16d2a2d7 100644
--- a/libstdc++/include/tr1/random
+++ b/libstdc++/include/tr1/random
@@ -1618,7 +1618,11 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
result_type
_M_call(_UniformRandomNumberGenerator& __urng,
result_type __min, result_type __max, true_type)
- { return result_type(__urng() % (__max - __min + 1)) + __min; }
+ {
+ typedef typename __gnu_cxx::__add_unsigned<typename
+ _UniformRandomNumberGenerator::result_type>::__type __utype;
+ return result_type(__utype(__urng()) % (__max - __min + 1)) + __min;
+ }
template<typename _UniformRandomNumberGenerator>
result_type