From 3b9c96051437bddb79be7f979e7b300effba9a37 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 19 Apr 2013 17:31:47 +0200 Subject: [PATCH] 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(-) create mode 100644 gcc48-pr56999.patch create mode 100644 gcc48-pr57000.patch 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 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 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 + + 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 + + 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 ++ struct Vector ++ { ++ T *mBegin; ++ T *begin () { return mBegin; } ++ T & operator[] (unsigned i) { return begin ()[i]; } ++ template ++ __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 (kindInt); } ++ bool isValid () const; ++ }; ++ struct RecompileInfo ++ { ++ unsigned outputIndex; ++ CompilerOutput *compilerOutput (TypeCompartment & types) const; ++ CompilerOutput *compilerOutput (JSContext *cx) const; ++ }; ++ struct TypeCompartment ++ { ++ Vector *constrainedOutputs; ++ Vector *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 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 + + 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