Fix gcc-mirror#3.

marxin · marxin · commit 34db894a67a4 · 2017-05-29T10:07:27.000+02:00
diff --git a/gcc/asan.c b/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
diff --git a/gcc/c-family/c-attribs.c b/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)
 {
diff --git a/gcc/cp/decl2.c b/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)
diff --git a/gcc/ipa-inline.c b/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
diff --git a/gcc/tree.c b/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;
 }
 
diff --git a/gcc/tree.h b/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.  */
diff --git a/gcc/tsan.c b/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 (); }
diff --git a/gcc/ubsan.c b/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);

Original file line number	Diff line number	Diff line change
`@@ -553,6 +553,8 @@ handle_cold_attribute (tree *node, tree name, tree ARG_UNUSED (args),`
`553`	`553`	`return NULL_TREE;`
`554`	`554`	`}`
`555`	`555`
	`556`	`+/* Exclude FLAGS from options enabled by -fsanitize. */`
	`557`	`+`
`556`	`558`	`void`
`557`	`559`	`add_no_sanitize_value (unsigned int flags)`
`558`	`560`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3737,7 +3737,7 @@ one_static_initialization_or_destruction (tree decl, tree init, bool initp)`
`3737`	`3737`	`if (init)`
`3738`	`3738`	`{`
`3739`	`3739`	`finish_expr_stmt (init);`
`3740`		`- if (sanitize_flags_p (SANITIZE_ADDRESS, decl))`
	`3740`	`+ if (sanitize_flags_p (SANITIZE_ADDRESS))`
`3741`	`3741`	`{`
`3742`	`3742`	`varpool_node *vnode = varpool_node::get (decl);`
`3743`	`3743`	`if (vnode)`
Original file line number	Diff line number	Diff line change
`@@ -14442,14 +14442,9 @@ nonnull_arg_p (const_tree arg)`
`14442`	`14442`	`return false;`
`14443`	`14443`	`}`
`14444`	`14444`
`14445`		`-/* Return true when flag_sanitize & FLAG is non-zero. */`
`14446`		`-`
`14447`	`14445`	`bool`
`14448`		`-sanitize_flags_p (unsigned int flag, const_tree fn)`
	`14446`	`+sanitize_flags_p (unsigned int flag)`
`14449`	`14447`	`{`
`14450`		`- if (fn == NULL)`
`14451`		`- return false;`
`14452`		`-`
`14453`	`14448`	`return flag_sanitize_local & flag;`
`14454`	`14449`	`}`
`14455`	`14450`
Original file line number	Diff line number	Diff line change
`@@ -894,9 +894,9 @@ class pass_tsan : public gimple_opt_pass`
`894`	`894`
`895`	`895`	`/* opt_pass methods: */`
`896`	`896`	`opt_pass * clone () { return new pass_tsan (m_ctxt); }`
`897`		`- virtual bool gate (function *fn)`
	`897`	`+ virtual bool gate (function *)`
`898`	`898`	`{`
`899`		`- return sanitize_flags_p (SANITIZE_THREAD, fn->decl);`
	`899`	`+ return sanitize_flags_p (SANITIZE_THREAD);`
`900`	`900`	`}`
`901`	`901`
`902`	`902`	`virtual unsigned int execute (function *) { return tsan_pass (); }`
`@@ -934,9 +934,9 @@ class pass_tsan_O0 : public gimple_opt_pass`
`934`	`934`	`{}`
`935`	`935`
`936`	`936`	`/* opt_pass methods: */`
`937`		`- virtual bool gate (function *fn)`
	`937`	`+ virtual bool gate (function *)`
`938`	`938`	`{`
`939`		`- return (sanitize_flags_p (SANITIZE_THREAD, fn->decl) && !optimize);`
	`939`	`+ return (sanitize_flags_p (SANITIZE_THREAD) && !optimize);`
`940`	`940`	`}`
`941`	`941`
`942`	`942`	`virtual unsigned int execute (function *) { return tsan_pass (); }`
Original file line number	Diff line number	Diff line change
`@@ -1949,14 +1949,14 @@ class pass_ubsan : public gimple_opt_pass`
`1949`	`1949`	`{}`
`1950`	`1950`
`1951`	`1951`	`/* opt_pass methods: */`
`1952`		`- virtual bool gate (function *fn)`
	`1952`	`+ virtual bool gate (function *)`
`1953`	`1953`	`{`
`1954`	`1954`	`return sanitize_flags_p ((SANITIZE_NULL \| SANITIZE_SI_OVERFLOW`
`1955`	`1955`	`\| SANITIZE_BOOL \| SANITIZE_ENUM`
`1956`	`1956`	`\| SANITIZE_ALIGNMENT`
`1957`	`1957`	`\| SANITIZE_NONNULL_ATTRIBUTE`
`1958`	`1958`	`\| SANITIZE_RETURNS_NONNULL_ATTRIBUTE`
`1959`		`- \| SANITIZE_OBJECT_SIZE), fn->decl);`
	`1959`	`+ \| SANITIZE_OBJECT_SIZE));`
`1960`	`1960`	`}`
`1961`	`1961`
`1962`	`1962`	`virtual unsigned int execute (function *);`
`@@ -1983,41 +1983,41 @@ pass_ubsan::execute (function *fun)`
`1983`	`1983`	`continue;`
`1984`	`1984`	`}`
`1985`	`1985`
`1986`		`- if ((sanitize_flags_p (SANITIZE_SI_OVERFLOW, fun->decl))`
	`1986`	`+ if ((sanitize_flags_p (SANITIZE_SI_OVERFLOW))`
`1987`	`1987`	`&& is_gimple_assign (stmt))`
`1988`	`1988`	`instrument_si_overflow (gsi);`
`1989`	`1989`
`1990`		`- if (sanitize_flags_p (SANITIZE_NULL \| SANITIZE_ALIGNMENT, fun->decl))`
	`1990`	`+ if (sanitize_flags_p (SANITIZE_NULL \| SANITIZE_ALIGNMENT))`
`1991`	`1991`	`{`
`1992`	`1992`	`if (gimple_store_p (stmt))`
`1993`	`1993`	`instrument_null (gsi, true);`
`1994`	`1994`	`if (gimple_assign_single_p (stmt))`
`1995`	`1995`	`instrument_null (gsi, false);`
`1996`	`1996`	`}`
`1997`	`1997`
`1998`		`- if (sanitize_flags_p (SANITIZE_BOOL \| SANITIZE_ENUM, fun->decl)`
	`1998`	`+ if (sanitize_flags_p (SANITIZE_BOOL \| SANITIZE_ENUM)`
`1999`	`1999`	`&& gimple_assign_load_p (stmt))`
`2000`	`2000`	`{`
`2001`	`2001`	`instrument_bool_enum_load (&gsi);`
`2002`	`2002`	`bb = gimple_bb (stmt);`
`2003`	`2003`	`}`
`2004`	`2004`
`2005`		`- if (sanitize_flags_p (SANITIZE_NONNULL_ATTRIBUTE, fun->decl)`
	`2005`	`+ if (sanitize_flags_p (SANITIZE_NONNULL_ATTRIBUTE)`
`2006`	`2006`	`&& is_gimple_call (stmt)`
`2007`	`2007`	`&& !gimple_call_internal_p (stmt))`
`2008`	`2008`	`{`
`2009`	`2009`	`instrument_nonnull_arg (&gsi);`
`2010`	`2010`	`bb = gimple_bb (stmt);`
`2011`	`2011`	`}`
`2012`	`2012`
`2013`		`- if (sanitize_flags_p (SANITIZE_RETURNS_NONNULL_ATTRIBUTE, fun->decl)`
	`2013`	`+ if (sanitize_flags_p (SANITIZE_RETURNS_NONNULL_ATTRIBUTE)`
`2014`	`2014`	`&& gimple_code (stmt) == GIMPLE_RETURN)`
`2015`	`2015`	`{`
`2016`	`2016`	`instrument_nonnull_return (&gsi);`
`2017`	`2017`	`bb = gimple_bb (stmt);`
`2018`	`2018`	`}`
`2019`	`2019`
`2020`		`- if (sanitize_flags_p (SANITIZE_OBJECT_SIZE, fun->decl))`
	`2020`	`+ if (sanitize_flags_p (SANITIZE_OBJECT_SIZE))`
`2021`	`2021`	`{`
`2022`	`2022`	`if (gimple_store_p (stmt))`
`2023`	`2023`	`instrument_object_size (&gsi, true);`