Fix gcc-mirror#3.

Author: marxin

gcc/asan.c

@@ -3190,9 +3190,9 @@ asan_instrument (void)
 }
 
 static bool
-gate_asan (function *fn)
+gate_asan ()
 {
-  return sanitize_flags_p (SANITIZE_ADDRESS, fn->decl);
+  return sanitize_flags_p (SANITIZE_ADDRESS);
 }
 
 namespace {
@@ -3219,7 +3219,7 @@ class pass_asan : public gimple_opt_pass
 
   /* opt_pass methods: */
   opt_pass * clone () { return new pass_asan (m_ctxt); }
-  virtual bool gate (function *fn) { return gate_asan (fn); }
+  virtual bool gate (function *) { return gate_asan (); }
   virtual unsigned int execute (function *) { return asan_instrument (); }
 
 }; // class pass_asan
@@ -3255,7 +3255,7 @@ class pass_asan_O0 : public gimple_opt_pass
   {}
 
   /* opt_pass methods: */
-  virtual bool gate (function *fn) { return !optimize && gate_asan (fn); }
+  virtual bool gate (function *) { return !optimize && gate_asan (); }
   virtual unsigned int execute (function *) { return asan_instrument (); }
 
 }; // class pass_asan_O0

gcc/c-family/c-attribs.c

@@ -553,6 +553,8 @@ handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),
   return NULL_TREE;
 }
 
+/* Exclude FLAGS from options enabled by -fsanitize.  */
+
 void
 add_no_sanitize_value (unsigned int flags)
 {

gcc/cp/decl2.c

@@ -3737,7 +3737,7 @@ one_static_initialization_or_destruction (tree decl, tree init, bool initp)
       if (init)
 	{
 	  finish_expr_stmt (init);
-	  if (sanitize_flags_p (SANITIZE_ADDRESS, decl))
+	  if (sanitize_flags_p (SANITIZE_ADDRESS))
 	    {
 	      varpool_node *vnode = varpool_node::get (decl);
 	      if (vnode)

gcc/ipa-inline.c

@@ -252,18 +252,6 @@ report_inline_failed_reason (struct cgraph_edge *e)
     }
 }
 
- /* Decide whether sanitizer-related attributes allow inlining. */
-
-static bool
-sanitize_attrs_match_for_inline_p (const_tree caller, const_tree callee)
-{
-  if (!caller || !callee)
-    return true;
-
-  return sanitize_flags_p (SANITIZE_ADDRESS, caller)
-    == sanitize_flags_p (SANITIZE_ADDRESS, callee);
-}
-
 /* Used for flags where it is safe to inline when caller's value is
    grater than callee's.  */
 #define check_maybe_up(flag) \
@@ -285,6 +273,18 @@ sanitize_attrs_match_for_inline_p (const_tree caller, const_tree callee)
       (opts_for_fn (caller->decl)->x_##flag		\
        != opts_for_fn (callee->decl)->x_##flag)
 
+ /* Decide whether sanitizer-related attributes allow inlining. */
+
+static bool
+sanitize_attrs_match_for_inline_p (const_tree caller, const_tree callee)
+{
+  if (!caller || !callee)
+    return true;
+
+  return ((opts_for_fn (caller)->x_flag_sanitize_local & SANITIZE_ADDRESS)
+	  == (opts_for_fn (callee)->x_flag_sanitize_local & SANITIZE_ADDRESS));
+}
+
  /* Decide if we can inline the edge and possibly update
    inline_failed reason.  
    We check whether inlining is possible at all and whether

gcc/tree.c

@@ -14442,14 +14442,9 @@ nonnull_arg_p (const_tree arg)
   return false;
 }
 
-/* Return true when flag_sanitize & FLAG is non-zero.  */
-
 bool
-sanitize_flags_p (unsigned int flag, const_tree fn)
+sanitize_flags_p (unsigned int flag)
 {
-  if (fn == NULL)
-    return false;
-
   return flag_sanitize_local & flag;
 }
 

gcc/tree.h

@@ -4248,9 +4248,8 @@ extern tree merge_dllimport_decl_attributes (tree, tree);
 /* Handle a "dllimport" or "dllexport" attribute.  */
 extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
 
-
-extern bool sanitize_flags_p (unsigned int flag,
-			      const_tree fn = current_function_decl);
+/* Return true when FLAG is enabled in -fsanitize option values.  */
+extern bool sanitize_flags_p (unsigned int flag);
 
 /* Returns true iff CAND and BASE have equivalent language-specific
    qualifiers.  */

gcc/tsan.c

@@ -894,9 +894,9 @@ class pass_tsan : public gimple_opt_pass
 
   /* opt_pass methods: */
   opt_pass * clone () { return new pass_tsan (m_ctxt); }
-  virtual bool gate (function *fn)
+  virtual bool gate (function *)
 {
-  return sanitize_flags_p (SANITIZE_THREAD, fn->decl);
+  return sanitize_flags_p (SANITIZE_THREAD);
 }
 
   virtual unsigned int execute (function *) { return tsan_pass (); }
@@ -934,9 +934,9 @@ class pass_tsan_O0 : public gimple_opt_pass
   {}
 
   /* opt_pass methods: */
-  virtual bool gate (function *fn)
+  virtual bool gate (function *)
     {
-      return (sanitize_flags_p (SANITIZE_THREAD, fn->decl) && !optimize);
+      return (sanitize_flags_p (SANITIZE_THREAD) && !optimize);
     }
 
   virtual unsigned int execute (function *) { return tsan_pass (); }

gcc/ubsan.c

@@ -1949,14 +1949,14 @@ class pass_ubsan : public gimple_opt_pass
   {}
 
   /* opt_pass methods: */
-  virtual bool gate (function *fn)
+  virtual bool gate (function *)
     {
       return sanitize_flags_p ((SANITIZE_NULL | SANITIZE_SI_OVERFLOW
 				| SANITIZE_BOOL | SANITIZE_ENUM
 				| SANITIZE_ALIGNMENT
 				| SANITIZE_NONNULL_ATTRIBUTE
 				| SANITIZE_RETURNS_NONNULL_ATTRIBUTE
-				| SANITIZE_OBJECT_SIZE), fn->decl);
+				| SANITIZE_OBJECT_SIZE));
     }
 
   virtual unsigned int execute (function *);
@@ -1983,41 +1983,41 @@ pass_ubsan::execute (function *fun)
 	      continue;
 	    }
 
-	  if ((sanitize_flags_p (SANITIZE_SI_OVERFLOW, fun->decl))
+	  if ((sanitize_flags_p (SANITIZE_SI_OVERFLOW))
 	      && is_gimple_assign (stmt))
 	    instrument_si_overflow (gsi);
 
-	  if (sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT, fun->decl))
+	  if (sanitize_flags_p (SANITIZE_NULL | SANITIZE_ALIGNMENT))
 	    {
 	      if (gimple_store_p (stmt))
 		instrument_null (gsi, true);
 	      if (gimple_assign_single_p (stmt))
 		instrument_null (gsi, false);
 	    }
 
-	  if (sanitize_flags_p (SANITIZE_BOOL | SANITIZE_ENUM, fun->decl)
+	  if (sanitize_flags_p (SANITIZE_BOOL | SANITIZE_ENUM)
 	      && gimple_assign_load_p (stmt))
 	    {
 	      instrument_bool_enum_load (&gsi);
 	      bb = gimple_bb (stmt);
 	    }
 
-	  if (sanitize_flags_p (SANITIZE_NONNULL_ATTRIBUTE, fun->decl)
+	  if (sanitize_flags_p (SANITIZE_NONNULL_ATTRIBUTE)
 	      && is_gimple_call (stmt)
 	      && !gimple_call_internal_p (stmt))
 	    {
 	      instrument_nonnull_arg (&gsi);
 	      bb = gimple_bb (stmt);
 	    }
 
-	  if (sanitize_flags_p (SANITIZE_RETURNS_NONNULL_ATTRIBUTE, fun->decl)
+	  if (sanitize_flags_p (SANITIZE_RETURNS_NONNULL_ATTRIBUTE)
 	      && gimple_code (stmt) == GIMPLE_RETURN)
 	    {
 	      instrument_nonnull_return (&gsi);
 	      bb = gimple_bb (stmt);
 	    }
 
-	  if (sanitize_flags_p (SANITIZE_OBJECT_SIZE, fun->decl))
+	  if (sanitize_flags_p (SANITIZE_OBJECT_SIZE))
 	    {
 	      if (gimple_store_p (stmt))
 		instrument_object_size (&gsi, true);