CbC/CbC_gcc: gcc/ipa-pure-const.c comparison

comparison gcc/ipa-pure-const.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Callgraph based analysis of static variables.
-Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright (C) 2004, 2005, 2007, 2008, 2009, 2010
+Free Software Foundation, Inc.
 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "gimple.h"
 #include "cgraph.h"
 #include "output.h"
 #include "flags.h"
 #include "timevar.h"
+#include "toplev.h"
 #include "diagnostic.h"
+#include "gimple-pretty-print.h"
 #include "langhooks.h"
 #include "target.h"
 #include "lto-streamer.h"
 #include "cfgloop.h"
 #include "tree-scalar-evolution.h"
+#include "intl.h"
+#include "opts.h"
 static struct pointer_set_t *visited_nodes;
 /* Lattice values for const and pure functions.  Everything starts out
 being const, then may drop to pure and then neither depending on
 /* Holders of ipa cgraph hooks: */
 static struct cgraph_node_hook_list *function_insertion_hook_holder;
 static struct cgraph_2node_hook_list *node_duplication_hook_holder;
 static struct cgraph_node_hook_list *node_removal_hook_holder;
+/* Try to guess if function body will always be visible to compiler
+when compiling the call and whether compiler will be able
+to propagate the information by itself.  */
+static bool
+function_always_visible_to_compiler_p (tree decl)
+{
+return (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl));
+}
+/* Emit suggestion about attribute ATTRIB_NAME for DECL.  KNOWN_FINITE
+is true if the function is known to be finite.  The diagnostic is
+controlled by OPTION.  WARNED_ABOUT is a pointer_set unique for
+OPTION, this function may initialize it and it is always returned
+by the function.  */
+static struct pointer_set_t *
+suggest_attribute (int option, tree decl, bool known_finite,
+		   struct pointer_set_t *warned_about,
+		   const char * attrib_name)
+{
+if (!option_enabled (option))
+return warned_about;
+if (TREE_THIS_VOLATILE (decl)
+|| (known_finite && function_always_visible_to_compiler_p (decl)))
+return warned_about;
+if (!warned_about)
+warned_about = pointer_set_create ();
+if (pointer_set_contains (warned_about, decl))
+return warned_about;
+pointer_set_insert (warned_about, decl);
+warning_at (DECL_SOURCE_LOCATION (decl),
+	      option,
+	      known_finite
+	      ? _("function might be candidate for attribute %<%s%>")
+	      : _("function might be candidate for attribute %<%s%>"
+		  " if it is known to return normally"), attrib_name);
+return warned_about;
+}
+/* Emit suggestion about __attribute_((pure)) for DECL.  KNOWN_FINITE
+is true if the function is known to be finite.  */
+static void
+warn_function_pure (tree decl, bool known_finite)
+{
+static struct pointer_set_t *warned_about;
+warned_about
+= suggest_attribute (OPT_Wsuggest_attribute_pure, decl,
+			 known_finite, warned_about, "pure");
+}
+/* Emit suggestion about __attribute_((const)) for DECL.  KNOWN_FINITE
+is true if the function is known to be finite.  */
+static void
+warn_function_const (tree decl, bool known_finite)
+{
+static struct pointer_set_t *warned_about;
+warned_about
+= suggest_attribute (OPT_Wsuggest_attribute_const, decl,
+			 known_finite, warned_about, "const");
+}
 /* Init the function state.  */
 static void
 finish_state (void)
 {
 if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
 return;
 /* If the variable has the "used" attribute, treat it as if it had a
 been touched by the devil.  */
-if (lookup_attribute ("used", DECL_ATTRIBUTES (t)))
+if (DECL_PRESERVE_P (t))
 {
 local->pure_const_state = IPA_NEITHER;
 if (dump_file)
 fprintf (dump_file, "    Used static/global variable is not const/pure\n");
 return;
 	  }
 }
 /* When not in IPA mode, we can still handle self recursion.  */
 if (!ipa && callee_t == current_function_decl)
-local->looping = true;
+{
+if (dump_file)
+fprintf (dump_file, "    Recursive call can loop.\n");
+local->looping = true;
+}
 /* Either calle is unknown or we are doing local analysis.
 Look to see if there are any bits available for the callee (such as by
 declaration or because it is builtin) and process solely on the basis of
 those bits. */
 else if (!ipa || !callee_t)
 local->can_throw = true;
 	}
 if (flags & ECF_CONST)
 	{
 if (callee_t && DECL_LOOPING_CONST_OR_PURE_P (callee_t))
-local->looping = true;
+	    {
+	      if (dump_file)
+		fprintf (dump_file, "    calls looping pure.\n");
+local->looping = true;
+	    }
 	 }
 else if (flags & ECF_PURE)
 	{
 if (callee_t && DECL_LOOPING_CONST_OR_PURE_P (callee_t))
-local->looping = true;
+	    {
+	      if (dump_file)
+		fprintf (dump_file, "    calls looping const.\n");
+local->looping = true;
+	    }
 	  if (dump_file)
 	    fprintf (dump_file, "    pure function call in not const\n");
 	  if (local->pure_const_state == IPA_CONST)
 	    local->pure_const_state = IPA_PURE;
 	}
 break;
 case GIMPLE_ASM:
 for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
 	{
 	  tree op = gimple_asm_clobber_op (stmt, i);
-	  if (simple_cst_equal(TREE_VALUE (op), memory_identifier_string) == 1)
+	  if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
 	    {
 if (dump_file)
 fprintf (dump_file, "    memory asm clobber is not const/pure");
 	      /* Abandon all hope, ye who enter here. */
 	      local->pure_const_state = IPA_NEITHER;
 /* There are some shared nodes, in particular the initializers on
 static declarations.  We do not need to scan them more than once
 since all we would be interested in are the addressof
 operations.  */
 visited_nodes = pointer_set_create ();
-set_function_state (node, analyze_function (node, true));
+if (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE)
+set_function_state (node, analyze_function (node, true));
 pointer_set_destroy (visited_nodes);
 visited_nodes = NULL;
 }
 /* Called when new clone is inserted to callgraph late.  */
 /* Serialize the ipa info for lto.  */
 static void
-pure_const_write_summary (cgraph_node_set set)
+pure_const_write_summary (cgraph_node_set set,
+			  varpool_node_set vset ATTRIBUTE_UNUSED)
 {
 struct cgraph_node *node;
 struct lto_simple_output_block *ob
 = lto_create_simple_output_block (LTO_section_ipa_pure_const);
 unsigned int count = 0;
 	  w_l->looping = this_looping;
 	  switch (this_state)
 	    {
 	    case IPA_CONST:
-	      if (!TREE_READONLY (w->decl) && dump_file)
+	      if (!TREE_READONLY (w->decl))
-		fprintf (dump_file, "Function found to be %sconst: %s\n",
+		{
-			 this_looping ? "looping " : "",
+		  warn_function_const (w->decl, !this_looping);
-			 cgraph_node_name (w));
+		  if (dump_file)
+		    fprintf (dump_file, "Function found to be %sconst: %s\n",
+			     this_looping ? "looping " : "",
+			     cgraph_node_name (w));
+		}
 	      cgraph_set_readonly_flag (w, true);
 	      cgraph_set_looping_const_or_pure_flag (w, this_looping);
 	      break;
 	    case IPA_PURE:
-	      if (!DECL_PURE_P (w->decl) && dump_file)
+	      if (!DECL_PURE_P (w->decl))
-		fprintf (dump_file, "Function found to be %spure: %s\n",
+		{
-			 this_looping ? "looping " : "",
+		  warn_function_pure (w->decl, !this_looping);
-			 cgraph_node_name (w));
+		  if (dump_file)
+		    fprintf (dump_file, "Function found to be %spure: %s\n",
+			     this_looping ? "looping " : "",
+			     cgraph_node_name (w));
+		}
 	      cgraph_set_pure_flag (w, true);
 	      cgraph_set_looping_const_or_pure_flag (w, this_looping);
 	      break;
 	    default:
 0                                     /* todo_flags_finish */
 },
 generate_summary,		        /* generate_summary */
 pure_const_write_summary,		/* write_summary */
 pure_const_read_summary,		/* read_summary */
-NULL,					/* function_read_summary */
+NULL,					/* write_optimization_summary */
+NULL,					/* read_optimization_summary */
 NULL,					/* stmt_fixup */
 0,					/* TODOs */
 NULL,			                /* function_transform */
 NULL					/* variable_transform */
 };
+/* Return true if function should be skipped for local pure const analysis.  */
+static bool
+skip_function_for_local_pure_const (struct cgraph_node *node)
+{
+/* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
+we must not promote functions that are called by already processed functions.  */
+if (function_called_by_processed_nodes_p ())
+{
+if (dump_file)
+fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
+return true;
+}
+if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
+{
+if (dump_file)
+fprintf (dump_file, "Function is not available or overwrittable; not analyzing.\n");
+return true;
+}
+return false;
+}
 /* Simple local pass for pure const discovery reusing the analysis from
 ipa_pure_const.   This pass is effective when executed together with
 other optimization passes in early optimization pass queue.  */
 static unsigned int
 local_pure_const (void)
 {
 bool changed = false;
 funct_state l;
+bool skip;
 struct cgraph_node *node;
-/* Because we do not schedule pass_fixup_cfg over whole program after early optimizations
-we must not promote functions that are called by already processed functions.  */
-if (function_called_by_processed_nodes_p ())
-{
-if (dump_file)
-fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
-return 0;
-}
 node = cgraph_node (current_function_decl);
-if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
+skip = skip_function_for_local_pure_const (node);
-{
+if (!warn_suggest_attribute_const
-if (dump_file)
+&& !warn_suggest_attribute_pure
-fprintf (dump_file, "Function has wrong visibility; ignoring\n");
+&& skip)
 return 0;
-}
 l = analyze_function (node, false);
 switch (l->pure_const_state)
 {
 case IPA_CONST:
 if (!TREE_READONLY (current_function_decl))
 	{
-	  cgraph_set_readonly_flag (node, true);
+	  warn_function_const (current_function_decl, !l->looping);
-	  cgraph_set_looping_const_or_pure_flag (node, l->looping);
+	  if (!skip)
-	  changed = true;
+	    {
+	      cgraph_set_readonly_flag (node, true);
+	      cgraph_set_looping_const_or_pure_flag (node, l->looping);
+	      changed = true;
+	    }
 	  if (dump_file)
 	    fprintf (dump_file, "Function found to be %sconst: %s\n",
 		     l->looping ? "looping " : "",
 		     lang_hooks.decl_printable_name (current_function_decl,
 						     2));
 	}
 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
 	       && !l->looping)
 	{
-	  cgraph_set_looping_const_or_pure_flag (node, false);
+	  if (!skip)
-	  changed = true;
+	    {
+	      cgraph_set_looping_const_or_pure_flag (node, false);
+	      changed = true;
+	    }
 	  if (dump_file)
 	    fprintf (dump_file, "Function found to be non-looping: %s\n",
 		     lang_hooks.decl_printable_name (current_function_decl,
 						     2));
 	}
 break;
 case IPA_PURE:
-if (!TREE_READONLY (current_function_decl))
+if (!DECL_PURE_P (current_function_decl))
 	{
-	  cgraph_set_pure_flag (node, true);
+	  if (!skip)
-	  cgraph_set_looping_const_or_pure_flag (node, l->looping);
+	    {
-	  changed = true;
+	      cgraph_set_pure_flag (node, true);
+	      cgraph_set_looping_const_or_pure_flag (node, l->looping);
+	      changed = true;
+	    }
+	  warn_function_pure (current_function_decl, !l->looping);
 	  if (dump_file)
 	    fprintf (dump_file, "Function found to be %spure: %s\n",
 		     l->looping ? "looping " : "",
 		     lang_hooks.decl_printable_name (current_function_decl,
 						     2));
 	}
 else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
 	       && !l->looping)
 	{
-	  cgraph_set_looping_const_or_pure_flag (node, false);
+	  if (!skip)
-	  changed = true;
+	    {
+	      cgraph_set_looping_const_or_pure_flag (node, false);
+	      changed = true;
+	    }
 	  if (dump_file)
 	    fprintf (dump_file, "Function found to be non-looping: %s\n",
 		     lang_hooks.decl_printable_name (current_function_decl,
 						     2));
 	}

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ipa-pure-const.c @ 63:b7f97abdc517 gcc-4.6-20100522