re PR target/65697 (__atomic memory barriers not strong enough for __sync builtins)

[gcc.git] / gcc / cfg.c

diff --git a/gcc/cfg.c b/gcc/cfg.c
index f5af1084d3414a1646625fae43d3ceabc2ba305a..fb13b7de06a19bee08477cc18027769b55cf1cae 100644 (file)
--- a/gcc/cfg.c
+++ b/gcc/cfg.c
@@ -1,5 +1,5 @@
 /* Control flow graph manipulation code for GNU compiler.
-   Copyright (C) 1987-2014 Free Software Foundation, Inc.
+   Copyright (C) 1987-2015 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -50,10 +50,18 @@ along with GCC; see the file COPYING3.  If not see
 #include "system.h"
 #include "coretypes.h"
 #include "obstack.h"
-#include "ggc.h"
-#include "hash-table.h"
 #include "alloc-pool.h"
+#include "alias.h"
+#include "symtab.h"
+#include "options.h"
 #include "tree.h"
+#include "predict.h"
+#include "tm.h"
+#include "hard-reg-set.h"
+#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "cfganal.h"
 #include "basic-block.h"
 #include "df.h"
 #include "cfgloop.h" /* FIXME: For struct loop.  */
@@ -486,7 +494,7 @@ dump_edge_info (FILE *file, edge e, int flags, int do_succ)
   if (e->count && do_details)
     {
       fputs (" count:", file);
-      fprintf (file, "%"PRId64, e->count);
+      fprintf (file, "%" PRId64, e->count);
     }
 
   if (e->flags && do_details)
@@ -734,7 +742,7 @@ dump_bb_info (FILE *outf, basic_block bb, int indent, int flags,
       if (flags & TDF_DETAILS)
        {
          struct function *fun = DECL_STRUCT_FUNCTION (current_function_decl);
-         fprintf (outf, ", count " "%"PRId64,
+         fprintf (outf, ", count " "%" PRId64,
                   (int64_t) bb->count);
          fprintf (outf, ", freq %i", bb->frequency);
          if (maybe_hot_bb_p (fun, bb))
@@ -1015,49 +1023,46 @@ struct htab_bb_copy_original_entry
   int index2;
 };
 
-struct bb_copy_hasher : typed_noop_remove <htab_bb_copy_original_entry>
+struct bb_copy_hasher : nofree_ptr_hash <htab_bb_copy_original_entry>
 {
-  typedef htab_bb_copy_original_entry value_type;
-  typedef htab_bb_copy_original_entry compare_type;
-  static inline hashval_t hash (const value_type *);
-  static inline bool equal (const value_type *existing,
-                           const compare_type * candidate);
+  static inline hashval_t hash (const htab_bb_copy_original_entry *);
+  static inline bool equal (const htab_bb_copy_original_entry *existing,
+                           const htab_bb_copy_original_entry * candidate);
 };
 
 inline hashval_t
-bb_copy_hasher::hash (const value_type *data)
+bb_copy_hasher::hash (const htab_bb_copy_original_entry *data)
 {
   return data->index1;
 }
 
 inline bool
-bb_copy_hasher::equal (const value_type *data, const compare_type *data2)
+bb_copy_hasher::equal (const htab_bb_copy_original_entry *data,
+                      const htab_bb_copy_original_entry *data2)
 {
   return data->index1 == data2->index1;
 }
 
 /* Data structures used to maintain mapping between basic blocks and
    copies.  */
-static hash_table <bb_copy_hasher> bb_original;
-static hash_table <bb_copy_hasher> bb_copy;
+static hash_table<bb_copy_hasher> *bb_original;
+static hash_table<bb_copy_hasher> *bb_copy;
 
 /* And between loops and copies.  */
-static hash_table <bb_copy_hasher> loop_copy;
-static alloc_pool original_copy_bb_pool;
-
+static hash_table<bb_copy_hasher> *loop_copy;
+static pool_allocator<htab_bb_copy_original_entry> *original_copy_bb_pool;
 
 /* Initialize the data structures to maintain mapping between blocks
    and its copies.  */
 void
 initialize_original_copy_tables (void)
 {
-  gcc_assert (!original_copy_bb_pool);
-  original_copy_bb_pool
-    = create_alloc_pool ("original_copy",
-                        sizeof (struct htab_bb_copy_original_entry), 10);
-  bb_original.create (10);
-  bb_copy.create (10);
-  loop_copy.create (10);
+
+  original_copy_bb_pool = new pool_allocator<htab_bb_copy_original_entry>
+    ("original_copy", 10);
+  bb_original = new hash_table<bb_copy_hasher> (10);
+  bb_copy = new hash_table<bb_copy_hasher> (10);
+  loop_copy = new hash_table<bb_copy_hasher> (10);
 }
 
 /* Free the data structures to maintain mapping between blocks and
@@ -1066,17 +1071,20 @@ void
 free_original_copy_tables (void)
 {
   gcc_assert (original_copy_bb_pool);
-  bb_copy.dispose ();
-  bb_original.dispose ();
-  loop_copy.dispose ();
-  free_alloc_pool (original_copy_bb_pool);
+  delete bb_copy;
+  bb_copy = NULL;
+  delete bb_original;
+  bb_copy = NULL;
+  delete loop_copy;
+  loop_copy = NULL;
+  delete original_copy_bb_pool;
   original_copy_bb_pool = NULL;
 }
 
 /* Removes the value associated with OBJ from table TAB.  */
 
 static void
-copy_original_table_clear (hash_table <bb_copy_hasher> tab, unsigned obj)
+copy_original_table_clear (hash_table<bb_copy_hasher> *tab, unsigned obj)
 {
   htab_bb_copy_original_entry **slot;
   struct htab_bb_copy_original_entry key, *elt;
@@ -1085,20 +1093,20 @@ copy_original_table_clear (hash_table <bb_copy_hasher> tab, unsigned obj)
     return;
 
   key.index1 = obj;
-  slot = tab.find_slot (&key, NO_INSERT);
+  slot = tab->find_slot (&key, NO_INSERT);
   if (!slot)
     return;
 
   elt = *slot;
-  tab.clear_slot (slot);
-  pool_free (original_copy_bb_pool, elt);
+  tab->clear_slot (slot);
+  original_copy_bb_pool->remove (elt);
 }
 
 /* Sets the value associated with OBJ in table TAB to VAL.
    Do nothing when data structures are not initialized.  */
 
 static void
-copy_original_table_set (hash_table <bb_copy_hasher> tab,
+copy_original_table_set (hash_table<bb_copy_hasher> *tab,
                         unsigned obj, unsigned val)
 {
   struct htab_bb_copy_original_entry **slot;
@@ -1108,11 +1116,10 @@ copy_original_table_set (hash_table <bb_copy_hasher> tab,
     return;
 
   key.index1 = obj;
-  slot = tab.find_slot (&key, INSERT);
+  slot = tab->find_slot (&key, INSERT);
   if (!*slot)
     {
-      *slot = (struct htab_bb_copy_original_entry *)
-               pool_alloc (original_copy_bb_pool);
+      *slot = original_copy_bb_pool->allocate ();
       (*slot)->index1 = obj;
     }
   (*slot)->index2 = val;
@@ -1136,7 +1143,7 @@ get_bb_original (basic_block bb)
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = bb->index;
-  entry = bb_original.find (&key);
+  entry = bb_original->find (&key);
   if (entry)
     return BASIC_BLOCK_FOR_FN (cfun, entry->index2);
   else
@@ -1161,7 +1168,7 @@ get_bb_copy (basic_block bb)
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = bb->index;
-  entry = bb_copy.find (&key);
+  entry = bb_copy->find (&key);
   if (entry)
     return BASIC_BLOCK_FOR_FN (cfun, entry->index2);
   else
@@ -1191,7 +1198,7 @@ get_loop_copy (struct loop *loop)
   gcc_assert (original_copy_bb_pool);
 
   key.index1 = loop->num;
-  entry = loop_copy.find (&key);
+  entry = loop_copy->find (&key);
   if (entry)
     return get_loop (cfun, entry->index2);
   else