source: patches/gcc-4.4.1-branch_update-1.patch@ 0bf41523

gcc/resource.c

@@ -945 +945 @@
 
   /* If we found a basic block, get the live registers from it and update
      them with anything set or killed between its start and the insn before
-     TARGET.  Otherwise, we must assume everything is live.  */
+     TARGET; this custom life analysis is really about registers so we need
+     to use the LR problem.  Otherwise, we must assume everything is live.  */
   if (b != -1)
     {
-      regset regs_live = df_get_live_in (BASIC_BLOCK (b));
+      regset regs_live = DF_LR_IN (BASIC_BLOCK (b));
       rtx start_insn, stop_insn;
 
       /* Compute hard regs live at start of block.  */
@@ -1052 +1053 @@
                 {
                   HARD_REG_SET extra_live;
 
-                  REG_SET_TO_HARD_REG_SET (extra_live, df_get_live_in (bb));
+                  REG_SET_TO_HARD_REG_SET (extra_live, DF_LR_IN (bb));
                   IOR_HARD_REG_SET (current_live_regs, extra_live);
                 }
             }

gcc/testsuite/gcc.c-torture/compile/pr40321.c

@@ +1 @@
+struct X { int flag; int pos; };
+int foo(struct X *a, struct X *b)
+{
+  while (1)
+    {
+      if (a->flag)
+        break;
+      ({ struct X *tmp = a; a = b; b = tmp; });
+    }
+
+  return a->pos + b->pos;
+}

gcc/testsuite/g++.dg/torture/pr40321.C

@@ +1 @@
+/* { dg-do compile } */
+
+struct VectorD2
+{
+  VectorD2() : x(0), y(0) { }
+  VectorD2(int _x, int _y) : x(_x), y(_y) { }
+  int x, y;
+  int GetLength2() const { return x*x + y*y; };
+  VectorD2 operator+(const VectorD2 vec) const {
+      return VectorD2(x+vec.x,y+vec.y);
+  }
+};
+struct Shape
+{
+  enum Type { ST_RECT, ST_CIRCLE } type;
+  VectorD2 pos;
+  VectorD2 radius;
+  bool CollisionWith(const Shape& s) const;
+};
+bool Shape::CollisionWith(const Shape& s) const
+{
+  if(type == ST_CIRCLE && s.type == ST_RECT)
+    return s.CollisionWith(*this);
+  return (pos + s.pos).GetLength2() < (radius + s.radius).GetLength2();
+}

gcc/tree-ssa-pre.c

@@ -3507 +3507 @@
 }
 
 
-/* Add OP to EXP_GEN (block), and possibly to the maximal set if it is
-   not defined by a phi node.
-   PHI nodes can't go in the maximal sets because they are not in
-   TMP_GEN, so it is possible to get into non-monotonic situations
-   during ANTIC calculation, because it will *add* bits.  */
+/* Add OP to EXP_GEN (block), and possibly to the maximal set.  */
 
 static void
 add_to_exp_gen (basic_block block, tree op)
@@ -3523 +3519 @@
         return;
       result = get_or_alloc_expr_for_name (op);
       bitmap_value_insert_into_set (EXP_GEN (block), result);
-      if (TREE_CODE (op) != SSA_NAME
-          || gimple_code (SSA_NAME_DEF_STMT (op)) != GIMPLE_PHI)
-        bitmap_value_insert_into_set (maximal_set, result);
+      bitmap_value_insert_into_set (maximal_set, result);
     }
 }
 
@@ -3544 +3538 @@
       add_to_value (get_expr_value_id (e), e);
       bitmap_insert_into_set (PHI_GEN (block), e);
       bitmap_value_insert_into_set (AVAIL_OUT (block), e);
+      if (!in_fre)
+        {
+          unsigned i;
+          for (i = 0; i < gimple_phi_num_args (phi); ++i)
+            {
+              tree arg = gimple_phi_arg_def (phi, i);
+              if (TREE_CODE (arg) == SSA_NAME)
+                {
+                  e = get_or_alloc_expr_for_name (arg);
+                  add_to_value (get_expr_value_id (e), e);
+                  bitmap_value_insert_into_set (maximal_set, e);
+                }
+            }
+        }
     }
 }
 
@@ -4254 +4262 @@
       FOR_ALL_BB (bb)
         {
           print_bitmap_set (dump_file, EXP_GEN (bb), "exp_gen", bb->index);
-          print_bitmap_set (dump_file, TMP_GEN (bb), "tmp_gen",
-                                  bb->index);
-          print_bitmap_set (dump_file, AVAIL_OUT (bb), "avail_out",
-                                  bb->index);
+          print_bitmap_set (dump_file, PHI_GEN (bb), "phi_gen", bb->index);
+          print_bitmap_set (dump_file, TMP_GEN (bb), "tmp_gen", bb->index);
+          print_bitmap_set (dump_file, AVAIL_OUT (bb), "avail_out", bb->index);
         }
+
+      print_bitmap_set (dump_file, maximal_set, "maximal", 0);
     }
 
   /* Insert can get quite slow on an incredibly large number of basic

gcc/version.c

@@ -14 +14 @@
    Makefile.  */
 
 const char version_string[] = BASEVER DATESTAMP DEVPHASE REVISION;
-const char pkgversion_string[] = PKGVERSION;
+const char pkgversion_string[] = "(GCC for Cross-LFS 4.4.1.20090722) ";

libstdc++-v3/include/std/valarray

@@ -1 +1 @@
 // The template and inlines for the -*- C++ -*- valarray class.
 
 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2009
+// 2006, 2007, 2008, 2009
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -647 +647 @@
   template<typename _Tp>
     inline
     valarray<_Tp>::valarray(initializer_list<_Tp> __l)
-      : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size()))
+    : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size()))
     { std::__valarray_copy_construct (__l.begin(), __l.end(), _M_data); }
 #endif
 
@@ -681 +681 @@
     {
       _GLIBCXX_DEBUG_ASSERT(_M_size == __l.size());
       std::__valarray_copy(__l.begin(), __l.size(), _M_data);
+      return *this;
     }
 #endif