[gcc] 4.8.0-3
Jakub Jelinek
jakub at fedoraproject.org
Fri Apr 19 15:31:56 UTC 2013
commit 3b9c96051437bddb79be7f979e7b300effba9a37
Author: Jakub Jelinek <jakub at redhat.com>
Date: Fri Apr 19 17:31:47 2013 +0200
4.8.0-3
.gitignore | 1 +
gcc.spec | 19 +++-
gcc48-pr56999.patch | 306 +++++++++++++++++++++++++++++++++++++++++++++++++++
gcc48-pr57000.patch | 31 +++++
sources | 2 +-
5 files changed, 355 insertions(+), 4 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index 84fa564..03c6066 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,3 +69,4 @@
/gcc-4.8.0-20130320.tar.bz2
/gcc-4.8.0-20130322.tar.bz2
/gcc-4.8.0-20130412.tar.bz2
+/gcc-4.8.0-20130419.tar.bz2
diff --git a/gcc.spec b/gcc.spec
index 019ce2b..8d091fc 100644
--- a/gcc.spec
+++ b/gcc.spec
@@ -1,9 +1,9 @@
-%global DATE 20130412
-%global SVNREV 197896
+%global DATE 20130419
+%global SVNREV 198097
%global gcc_version 4.8.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 2
+%global gcc_release 3
%global _unpackaged_files_terminate_build 0
%global multilib_64_archs sparc64 ppc64 s390x x86_64
%ifarch %{ix86} x86_64 ia64 ppc ppc64 alpha
@@ -193,6 +193,8 @@ Patch9: gcc48-cloog-dl2.patch
Patch10: gcc48-pr38757.patch
Patch11: gcc48-libstdc++-docs.patch
Patch12: gcc48-no-add-needed.patch
+Patch13: gcc48-pr56999.patch
+Patch14: gcc48-pr57000.patch
Patch1000: fastjar-0.97-segfault.patch
Patch1001: fastjar-0.97-len1.patch
@@ -746,6 +748,8 @@ package or when debugging this package.
%patch11 -p0 -b .libstdc++-docs~
%endif
%patch12 -p0 -b .no-add-needed~
+%patch13 -p0 -b .pr56999~
+%patch14 -p0 -b .pr57000~
%if 0%{?_enable_debug_packages}
cat > split-debuginfo.sh <<\EOF
@@ -2979,6 +2983,15 @@ fi
%{_prefix}/libexec/gcc/%{gcc_target_platform}/%{gcc_version}/plugin
%changelog
+* Fri Apr 19 2013 Jakub Jelinek <jakub at redhat.com> 4.8.0-3
+- update from the 4.8 branch
+ - PRs c++/56388, fortran/56816, fortran/56994, rtl-optimization/56992,
+ target/56890, target/56903, target/56948, tree-optimization/56962,
+ tree-optimization/56984
+- fix up LRA caused miscompilation of xulrunner on i?86
+ (#949553, PR rtl-optimization/56999)
+- reassoc fix for -Ofast -frounding-math (PR tree-optimization/57000)
+
* Fri Apr 12 2013 Jakub Jelinek <jakub at redhat.com> 4.8.0-2
- update from the 4.8 branch
- PRs c++/35722, c++/45282, c++/52014, c++/52374, c++/52748, c++/54277,
diff --git a/gcc48-pr56999.patch b/gcc48-pr56999.patch
new file mode 100644
index 0000000..d8e15a6
--- /dev/null
+++ b/gcc48-pr56999.patch
@@ -0,0 +1,306 @@
+2013-04-18 Vladimir Makarov <vmakarov at redhat.com>
+
+ PR rtl-optimization/56999
+ * lra-coalesce.c (coalescable_pseudo_p): Remove 2nd parameter and
+ related code.
+ (lra_coalesce): Remove split_origin_bitmap and related code.
+ * lra.c (lra): Coalesce after undoing inheritance. Recreate live
+ ranges if necessary.
+
+2013-04-18 Jakub Jelinek <jakub at redhat.com>
+
+ PR rtl-optimization/56999
+ * g++.dg/opt/pr56999.C: New test.
+
+--- gcc/lra-coalesce.c (revision 198081)
++++ gcc/lra-coalesce.c (revision 198083)
+@@ -201,24 +201,14 @@ update_live_info (bitmap lr_bitmap)
+ }
+ }
+
+-/* Return true if pseudo REGNO can be potentially coalesced. Use
+- SPLIT_PSEUDO_BITMAP to find pseudos whose live ranges were
+- split. */
++/* Return true if pseudo REGNO can be potentially coalesced. */
+ static bool
+-coalescable_pseudo_p (int regno, bitmap split_origin_bitmap)
++coalescable_pseudo_p (int regno)
+ {
+ lra_assert (regno >= FIRST_PSEUDO_REGISTER);
+- /* Don't coalesce inheritance pseudos because spilled inheritance
+- pseudos will be removed in subsequent 'undo inheritance'
+- pass. */
+- return (lra_reg_info[regno].restore_regno < 0
+- /* We undo splits for spilled pseudos whose live ranges were
+- split. So don't coalesce them, it is not necessary and
+- the undo transformations would be wrong. */
+- && ! bitmap_bit_p (split_origin_bitmap, regno)
+- /* We don't want to coalesce regnos with equivalences, at
++ return (/* We don't want to coalesce regnos with equivalences, at
+ least without updating this info. */
+- && ira_reg_equiv[regno].constant == NULL_RTX
++ ira_reg_equiv[regno].constant == NULL_RTX
+ && ira_reg_equiv[regno].memory == NULL_RTX
+ && ira_reg_equiv[regno].invariant == NULL_RTX);
+ }
+@@ -230,12 +220,10 @@ lra_coalesce (void)
+ {
+ basic_block bb;
+ rtx mv, set, insn, next, *sorted_moves;
+- int i, mv_num, sregno, dregno, restore_regno;
+- unsigned int regno;
++ int i, mv_num, sregno, dregno;
+ int coalesced_moves;
+ int max_regno = max_reg_num ();
+- bitmap_head involved_insns_bitmap, split_origin_bitmap;
+- bitmap_iterator bi;
++ bitmap_head involved_insns_bitmap;
+
+ timevar_push (TV_LRA_COALESCE);
+
+@@ -249,11 +237,6 @@ lra_coalesce (void)
+ first_coalesced_pseudo[i] = next_coalesced_pseudo[i] = i;
+ sorted_moves = XNEWVEC (rtx, get_max_uid ());
+ mv_num = 0;
+- /* Collect pseudos whose live ranges were split. */
+- bitmap_initialize (&split_origin_bitmap, ®_obstack);
+- EXECUTE_IF_SET_IN_BITMAP (&lra_split_regs, 0, regno, bi)
+- if ((restore_regno = lra_reg_info[regno].restore_regno) >= 0)
+- bitmap_set_bit (&split_origin_bitmap, restore_regno);
+ /* Collect moves. */
+ coalesced_moves = 0;
+ FOR_EACH_BB (bb)
+@@ -265,15 +248,13 @@ lra_coalesce (void)
+ && (sregno = REGNO (SET_SRC (set))) >= FIRST_PSEUDO_REGISTER
+ && (dregno = REGNO (SET_DEST (set))) >= FIRST_PSEUDO_REGISTER
+ && mem_move_p (sregno, dregno)
+- && coalescable_pseudo_p (sregno, &split_origin_bitmap)
+- && coalescable_pseudo_p (dregno, &split_origin_bitmap)
++ && coalescable_pseudo_p (sregno) && coalescable_pseudo_p (dregno)
+ && ! side_effects_p (set)
+ && !(lra_intersected_live_ranges_p
+ (lra_reg_info[sregno].live_ranges,
+ lra_reg_info[dregno].live_ranges)))
+ sorted_moves[mv_num++] = insn;
+ }
+- bitmap_clear (&split_origin_bitmap);
+ qsort (sorted_moves, mv_num, sizeof (rtx), move_freq_compare_func);
+ /* Coalesced copies, most frequently executed first. */
+ bitmap_initialize (&coalesced_pseudos_bitmap, ®_obstack);
+--- gcc/lra.c (revision 198081)
++++ gcc/lra.c (revision 198083)
+@@ -2295,11 +2295,20 @@ lra (FILE *f)
+ lra_assign ();
+ else
+ {
+- /* Do coalescing only for regular algorithms. */
+- if (! lra_assign () && lra_coalesce ())
+- live_p = false;
++ bool spill_p = !lra_assign ();
++
+ if (lra_undo_inheritance ())
+ live_p = false;
++ if (spill_p)
++ {
++ if (! live_p)
++ {
++ lra_create_live_ranges (true);
++ live_p = true;
++ }
++ if (lra_coalesce ())
++ live_p = false;
++ }
+ if (! live_p)
+ lra_clear_live_ranges ();
+ }
+--- gcc/testsuite/g++.dg/opt/pr56999.C (revision 0)
++++ gcc/testsuite/g++.dg/opt/pr56999.C (revision 198083)
+@@ -0,0 +1,188 @@
++// PR rtl-optimization/56999
++// { dg-do run }
++// { dg-options "-O2" }
++// { dg-additional-options "-fpic" { target fpic } }
++// { dg-additional-options "-march=i686 -mtune=atom" { target ia32 } }
++// { dg-require-visibility "" }
++
++extern "C" void abort (void);
++extern "C" void exit (int);
++volatile bool do_exit = true;
++struct JSScript;
++struct JITScript { int i; };
++#pragma GCC visibility push(hidden)
++typedef struct JSCompartment JSCompartment;
++typedef struct JSContext JSContext;
++namespace js
++{
++ struct ContextFriendFields
++ {
++ JSCompartment *compartment;
++ };
++ struct TempAllocPolicy
++ {
++ };
++ template <class T>
++ struct Vector
++ {
++ T *mBegin;
++ T *begin () { return mBegin; }
++ T & operator[] (unsigned i) { return begin ()[i]; }
++ template <class U>
++ __attribute__((noinline, noclone))
++ bool append (U) { asm volatile ("" : : : "memory"); if (do_exit) abort (); return false; }
++ };
++ namespace types
++ {
++ struct TypeCompartment;
++ }
++ namespace mjit
++ {
++ }
++ namespace ion
++ {
++ struct IonScript;
++ }
++ namespace types
++ {
++ struct CompilerOutput
++ {
++ enum Kind { MethodJIT, ParallelIon };
++ JSScript *script;
++ unsigned kindInt : 2;
++ bool constructing : 1;
++ bool barriers : 1;
++ bool pendingRecompilation : 1;
++ Kind kind () const { return static_cast <Kind> (kindInt); }
++ bool isValid () const;
++ };
++ struct RecompileInfo
++ {
++ unsigned outputIndex;
++ CompilerOutput *compilerOutput (TypeCompartment & types) const;
++ CompilerOutput *compilerOutput (JSContext *cx) const;
++ };
++ struct TypeCompartment
++ {
++ Vector <CompilerOutput> *constrainedOutputs;
++ Vector <RecompileInfo> *pendingRecompiles;
++ void addPendingRecompile (JSContext *cx, const RecompileInfo & info);
++ };
++ }
++}
++struct JSScript
++{
++ struct JITScriptHandle
++ {
++ static volatile JITScript *UNJITTABLE __attribute__((visibility ("default")));
++ JITScript *value;
++ bool isValid () { return value != UNJITTABLE; }
++ JITScript *getValid () { return value; }
++ };
++ struct JITScriptSet
++ {
++ JITScriptHandle jitHandleNormal, jitHandleNormalBarriered;
++ JITScriptHandle jitHandleCtor, jitHandleCtorBarriered;
++ JITScriptHandle jitNull1, jitNull2;
++ };
++ JITScriptSet *mJITInfo;
++ void *ion;
++ JITScriptHandle *jitHandle (bool constructing, bool barriers)
++ {
++ return constructing ? (barriers ? &mJITInfo->jitHandleCtorBarriered
++ : &mJITInfo->jitHandleCtor)
++ : (barriers ? &mJITInfo->jitHandleNormalBarriered
++ : &mJITInfo->jitHandleNormal);
++ }
++ JITScript *getJIT (bool constructing, bool barriers)
++ {
++ JITScriptHandle *jith = jitHandle (constructing, barriers);
++ return jith->isValid () ? jith->getValid () : __null;
++ }
++};
++struct JSContext : js::ContextFriendFields
++{
++};
++namespace js
++{
++ __attribute__((noinline, noclone))
++ void CancelOffThreadIonCompile (JSCompartment *, JSScript *)
++ {
++ if (do_exit)
++ exit (0);
++ }
++}
++struct JSCompartment
++{
++ js::types::TypeCompartment types;
++};
++namespace js
++{
++ namespace types
++ {
++ inline bool CompilerOutput::isValid () const
++ {
++ if (!script)
++ return false;
++ switch (kind ())
++ {
++ case MethodJIT:
++ {
++ JITScript *jit = script->getJIT (constructing, barriers);
++ if (!jit)
++ return false;
++ }
++ case ParallelIon:
++ return true;
++ }
++ return false;
++ }
++ inline CompilerOutput *RecompileInfo::compilerOutput (TypeCompartment & types) const
++ {
++ return &(*types.constrainedOutputs)[outputIndex];
++ }
++ inline CompilerOutput *RecompileInfo::compilerOutput (JSContext *cx) const
++ {
++ return compilerOutput (cx->compartment->types);
++ }
++ }
++}
++using namespace js::types;
++__attribute__((noinline, noclone)) void
++TypeCompartment::addPendingRecompile (JSContext *cx, const RecompileInfo & info)
++{
++ CompilerOutput *co = info.compilerOutput (cx);
++ if (co->pendingRecompilation)
++ if (co->isValid ())
++ CancelOffThreadIonCompile (cx->compartment, co->script);
++ if (co->isValid ())
++ pendingRecompiles->append (info);
++}
++volatile JITScript *JSScript::JITScriptHandle::UNJITTABLE;
++int
++main ()
++{
++ JSContext cx;
++ JSCompartment com;
++ RecompileInfo info;
++ cx.compartment = &com;
++ info.outputIndex = 0;
++ js::Vector<CompilerOutput> v;
++ JITScript js;
++ JSScript::JITScriptSet set;
++ __builtin_memset (&set, 0, sizeof set);
++ set.jitHandleCtor.value = &js;
++ JSScript s;
++ s.mJITInfo = &set;
++ CompilerOutput co;
++ co.kindInt = 0;
++ co.constructing = true;
++ co.barriers = false;
++ co.pendingRecompilation = true;
++ co.script = &s;
++ v.mBegin = &co;
++ com.types.constrainedOutputs = &v;
++ com.types.pendingRecompiles = __null;
++ com.types.addPendingRecompile (&cx, info);
++ abort ();
++}
diff --git a/gcc48-pr57000.patch b/gcc48-pr57000.patch
new file mode 100644
index 0000000..714e046
--- /dev/null
+++ b/gcc48-pr57000.patch
@@ -0,0 +1,31 @@
+2013-04-19 Richard Biener <rguenther at suse.de>
+
+ PR tree-optimization/57000
+ * tree-ssa-reassoc.c (pass_reassoc): Add TODO_update_ssa_only_virtuals.
+
+ * gcc.dg/tree-ssa/reassoc-27.c: New testcase.
+
+--- gcc/tree-ssa-reassoc.c (revision 198086)
++++ gcc/tree-ssa-reassoc.c (revision 198087)
+@@ -4293,6 +4293,7 @@ struct gimple_opt_pass pass_reassoc =
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_verify_ssa
++ | TODO_update_ssa_only_virtuals
+ | TODO_verify_flow
+ | TODO_ggc_collect /* todo_flags_finish */
+ }
+--- gcc/testsuite/gcc.dg/tree-ssa/reassoc-27.c (revision 0)
++++ gcc/testsuite/gcc.dg/tree-ssa/reassoc-27.c (revision 198087)
+@@ -0,0 +1,11 @@
++/* { dg-do compile } */
++/* { dg-options "-O -ffast-math -frounding-math -fdump-tree-optimized" } */
++
++double baz (double foo, double bar)
++{
++ return foo * foo * foo * foo * bar * bar * bar * bar;
++}
++
++/* We should re-associate this as (foo * bar)**3. */
++/* { dg-final { scan-tree-dump-times " \\\* " 3 "optimized" } } */
++/* { dg-final { cleanup-tree-dump "optimized" } } */
diff --git a/sources b/sources
index ad3fec3..0c67df0 100644
--- a/sources
+++ b/sources
@@ -1,4 +1,4 @@
be78a47bd82523250eb3e91646db5b3d cloog-0.18.0.tar.gz
2659f09c2e43ef8b7d4406321753f1b2 fastjar-0.97.tar.gz
-736cd6277ae8ea1462edd5d0dd7926c4 gcc-4.8.0-20130412.tar.bz2
+fc7593f5789278c5b6db56ab6f34fee3 gcc-4.8.0-20130419.tar.bz2
bce1586384d8635a76d2f017fb067cd2 isl-0.11.1.tar.bz2
More information about the scm-commits
mailing list