rpms/gcc
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

4.8.0-3

Browse Source
This commit is contained in:
Jakub Jelinek 2013-04-19 17:31:47 +02:00
parent c0371f2be9
commit 3b9c960514
5 changed files with 355 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -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

19
gcc.spec
View File

@ -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@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@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,

306
gcc48-pr56999.patch Normal file
View File

@ -0,0 +1,306 @@
2013-04-18 Vladimir Makarov <vmakarov@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@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, &reg_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, &reg_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 ();
+}

31
gcc48-pr57000.patch Normal file
View File

@ -0,0 +1,31 @@
2013-04-19 Richard Biener <rguenther@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" } } */

2
sources
View File

@ -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