-Wsign-compare -Wsign-conversion -Wstack-protector @gol
-Wstrict-aliasing -Wstrict-aliasing=n @gol
-Wstrict-overflow -Wstrict-overflow=@var{n} @gol
+-Wsuggest-attribute=@r{[}const@r{|}pure@r{]} @gol
-Wswitch -Wswitch-default -Wswitch-enum -Wsync-nand @gol
-Wsystem-headers -Wtrigraphs -Wtype-limits -Wundef -Wuninitialized @gol
-Wunknown-pragmas -Wno-pragmas @gol
false positives.
@end table
+@item -Wsuggest-attribute=@r{[}const@r{|}pure@r{]}
+@opindex Wsuggest-attribute=
+@opindex Wno-suggest-attribute=
+Warn for cases where adding an attribute may be beneficial. The
+attributes currently supported are listed below.
+
+@table @gcctabopt
+@item -Wsuggest-attribute=pure
+@itemx -Wsuggest-attribute=const
+@opindex Wsuggest-attribute=pure
+@opindex Wno-suggest-attribute=pure
+@opindex Wsuggest-attribute=const
+@opindex Wno-suggest-attribute=const
+
+Warn about functions which might be candidates for attributes
+@code{pure} or @code{const}. The compiler only warns for functions
+visible in other compilation units or if it cannot prove that the
+function returns normally. A function returns normally if it doesn't
+contain an infinite loop nor returns abnormally by throwing, calling
+@code{abort()} or trapping. This analysis requires option
+@option{-fipa-pure-const}, which is enabled by default at @option{-O}
+and higher. Higher optimization levels improve the accuracy of the
+analysis.
+@end table
+
@item -Warray-bounds
@opindex Wno-array-bounds
@opindex Warray-bounds
This option is only active when @option{-ftree-vrp} is active
-(default for -O2 and above). It warns about subscripts to arrays
+(default for @option{-O2} and above). It warns about subscripts to arrays
that are always out of bounds. This warning is enabled by @option{-Wall}.
@item -Wno-div-by-zero
#include "output.h"
#include "flags.h"
#include "timevar.h"
+#include "toplev.h"
#include "diagnostic.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;
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
/* 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
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)
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;
}
switch (this_state)
{
case IPA_CONST:
- if (!TREE_READONLY (w->decl) && dump_file)
- fprintf (dump_file, "Function found to be %sconst: %s\n",
- this_looping ? "looping " : "",
- cgraph_node_name (w));
+ if (!TREE_READONLY (w->decl))
+ {
+ warn_function_const (w->decl, !this_looping);
+ 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)
- fprintf (dump_file, "Function found to be %spure: %s\n",
- this_looping ? "looping " : "",
- cgraph_node_name (w));
+ if (!DECL_PURE_P (w->decl))
+ {
+ warn_function_pure (w->decl, !this_looping);
+ 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;
NULL /* variable_transform */
};
-/* 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. */
+/* Return true if function should be skipped for local pure const analysis. */
-static unsigned int
-local_pure_const (void)
+static bool
+skip_function_for_local_pure_const (struct cgraph_node *node)
{
- bool changed = false;
- funct_state l;
- 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 (dump_file)
fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
- return 0;
+ return true;
}
- node = cgraph_node (current_function_decl);
if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
{
if (dump_file)
- fprintf (dump_file, "Function has wrong visibility; ignoring\n");
- return 0;
+ 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;
+
+ node = cgraph_node (current_function_decl);
+ skip = skip_function_for_local_pure_const (node);
+ if (!warn_suggest_attribute_const
+ && !warn_suggest_attribute_pure
+ && 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);
- cgraph_set_looping_const_or_pure_flag (node, l->looping);
- changed = true;
+ warn_function_const (current_function_decl, !l->looping);
+ if (!skip)
+ {
+ 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 " : "",
else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
&& !l->looping)
{
- cgraph_set_looping_const_or_pure_flag (node, false);
- changed = true;
+ if (!skip)
+ {
+ 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,
break;
case IPA_PURE:
- if (!TREE_READONLY (current_function_decl))
+ if (!DECL_PURE_P (current_function_decl))
{
- cgraph_set_pure_flag (node, true);
- cgraph_set_looping_const_or_pure_flag (node, l->looping);
- changed = true;
+ if (!skip)
+ {
+ 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 " : "",
else if (DECL_LOOPING_CONST_OR_PURE_P (current_function_decl)
&& !l->looping)
{
- cgraph_set_looping_const_or_pure_flag (node, false);
- changed = true;
+ if (!skip)
+ {
+ 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,
OSDN Git Service
