struct nonnull_arg_ctx
{
+ /* Location of the call. */
location_t loc;
+ /* The function whose arguments are being checked and its type (used
+ for calls through function pointers). */
+ const_tree fndecl, fntype;
+ /* True if a warning has been issued. */
bool warned_p;
};
-/* Check the argument list of a function call for null in argument slots
- that are marked as requiring a non-null pointer argument. The NARGS
- arguments are passed in the array ARGARRAY. Return true if we have
- warned. */
+/* Check the argument list of a function call to CTX.FNDECL of CTX.FNTYPE
+ for null in argument slots that are marked as requiring a non-null
+ pointer argument. The NARGS arguments are passed in the array ARGARRAY.
+ Return true if we have warned. */
static bool
-check_function_nonnull (location_t loc, tree attrs, int nargs, tree *argarray)
+check_function_nonnull (nonnull_arg_ctx &ctx, int nargs, tree *argarray)
{
- tree a;
- int i;
+ int firstarg = 0;
+ if (TREE_CODE (ctx.fntype) == METHOD_TYPE)
+ {
+ /* In calls to C++ non-static member functions check the this
+ pointer regardless of whether the function is declared with
+ attribute nonnull. */
+ firstarg = 1;
+ check_function_arguments_recurse (check_nonnull_arg, &ctx, argarray[0],
+ firstarg);
+ }
- attrs = lookup_attribute ("nonnull", attrs);
+ tree attrs = lookup_attribute ("nonnull", TYPE_ATTRIBUTES (ctx.fntype));
if (attrs == NULL_TREE)
- return false;
+ return ctx.warned_p;
- a = attrs;
+ tree a = attrs;
/* See if any of the nonnull attributes has no arguments. If so,
then every pointer argument is checked (in which case the check
for pointer type is done in check_nonnull_arg). */
a = lookup_attribute ("nonnull", TREE_CHAIN (a));
while (a != NULL_TREE && TREE_VALUE (a) != NULL_TREE);
- struct nonnull_arg_ctx ctx = { loc, false };
if (a != NULL_TREE)
- for (i = 0; i < nargs; i++)
+ for (int i = firstarg; i < nargs; i++)
check_function_arguments_recurse (check_nonnull_arg, &ctx, argarray[i],
i + 1);
else
{
/* Walk the argument list. If we encounter an argument number we
should check for non-null, do it. */
- for (i = 0; i < nargs; i++)
+ for (int i = firstarg; i < nargs; i++)
{
for (a = attrs; ; a = TREE_CHAIN (a))
{
return;
/* Diagnose the simple cases of null arguments. */
- if (integer_zerop (fold_for_warn (param)))
+ if (!integer_zerop (fold_for_warn (param)))
+ return;
+
+ auto_diagnostic_group adg;
+
+ const location_t loc = EXPR_LOC_OR_LOC (param, pctx->loc);
+
+ if (TREE_CODE (pctx->fntype) == METHOD_TYPE)
+ --param_num;
+
+ bool warned;
+ if (param_num == 0)
+ {
+ warned = warning_at (loc, OPT_Wnonnull,
+ "%qs pointer null", "this");
+ if (pctx->fndecl)
+ inform (DECL_SOURCE_LOCATION (pctx->fndecl),
+ "in a call to non-static member function %qD",
+ pctx->fndecl);
+ }
+ else
{
- warning_at (pctx->loc, OPT_Wnonnull, "null argument where non-null "
- "required (argument %lu)", (unsigned long) param_num);
- pctx->warned_p = true;
+ warned = warning_at (loc, OPT_Wnonnull,
+ "argument %u null where non-null expected",
+ (unsigned) param_num);
+ if (pctx->fndecl)
+ inform (DECL_SOURCE_LOCATION (pctx->fndecl),
+ "in a call to function %qD declared %qs",
+ pctx->fndecl, "nonnull");
}
+
+ if (warned)
+ pctx->warned_p = true;
}
/* Helper for attribute handling; fetch the operand number from
bool warned_p = false;
/* Check for null being passed in a pointer argument that must be
- non-null. We also need to do this if format checking is enabled. */
-
+ non-null. In C++, this includes the this pointer. We also need
+ to do this if format checking is enabled. */
if (warn_nonnull)
- warned_p = check_function_nonnull (loc, TYPE_ATTRIBUTES (fntype),
- nargs, argarray);
+ {
+ nonnull_arg_ctx ctx = { loc, fndecl, fntype, false };
+ warned_p = check_function_nonnull (ctx, nargs, argarray);
+ }
/* Check for errors in format strings. */
if (!fntype)
return;
+ auto_diagnostic_group adg;
+
/* A string describing the attributes that the warnings issued by this
function apply to. Used to print one informational note per function
call, rather than one per warning. That reduces clutter. */
attribute nonnull when the function accepts null pointers
only when the corresponding size is zero. */
bool warned = false;
- location_t loc = EXPR_LOCATION (exp);
+ const location_t loc = EXPR_LOC_OR_LOC (ptr, EXPR_LOCATION (exp));
if (tree_int_cst_equal (sizrng[0], sizrng[1]))
warned = warning_at (loc, OPT_Wnonnull,
"%Kargument %i is null but the corresponding "
foo (void)
{
memcpy (0, 0, 0);
- /* { dg-warning "null argument where non-null required\[^\n\r\]*argument 1" "" { target *-*-* } .-1 } */
- /* { dg-warning "null argument where non-null required\[^\n\r\]*argument 2" "" { target *-*-* } .-2 } */
+ /* { dg-warning "argument 1 null where non-null expected" "" { target *-*-* } .-1 } */
+ /* { dg-warning "argument 2 null where non-null expected" "" { target *-*-* } .-2 } */
bar (0, 0, 0, 0, 0);
- /* { dg-warning "null argument where non-null required\[^\n\r\]*argument 1" "" { target *-*-* } .-1 } */
- /* { dg-warning "null argument where non-null required\[^\n\r\]*argument 3" "" { target *-*-* } .-2 } */
- /* { dg-warning "null argument where non-null required\[^\n\r\]*argument 4" "" { target *-*-* } .-3 } */
- /* { dg-warning "null argument where non-null required\[^\n\r\]*argument 5" "" { target *-*-* } .-4 } */
+ /* { dg-warning "argument 1 null where non-null expected" "" { target *-*-* } .-1 } */
+ /* { dg-warning "argument 3 null where non-null expected" "" { target *-*-* } .-2 } */
+ /* { dg-warning "argument 4 null where non-null expected" "" { target *-*-* } .-3 } */
+ /* { dg-warning "argument 5 null where non-null expected" "" { target *-*-* } .-4 } */
}
/* { dg-options "-Wnonnull" } */
void foox (char*, ...) __attribute__ ((nonnull (1)));
-#define foo(p) foox (p, "p is null") /* { dg-warning "null argument" } */
+#define foo(p) foox (p, "p is null") /* { dg-warning "argument 1 null" } */
void baz (void)
{
void f()
{
f1("%p", nullptr);
- f2(nullptr); // { dg-warning "null argument where non-null required " }
+ f2(nullptr); // { dg-warning "argument 1 null where non-null expected " }
f3("x", "y", __null); // { dg-warning "missing sentinel in function call" }
f3("x", "y", nullptr);
decltype(nullptr) mynull = 0;
f1("%p", mynull);
- f2(mynull); // { dg-warning "null argument where non-null required " }
+ f2(mynull); // { dg-warning "argument 1 null where non-null expected " }
f3("x", "y", mynull);
}
void test_nonnull (void)
{
- f<void>(0, 0, 0); // { dg-warning "null argument where non-null required \\\(argument 1\\\)" }
+ f<void>(0, 0, 0); // { dg-warning "argument 1 null where non-null expected" }
- f<int>(0, 0, 0); // { dg-bogus "null argument" }
+ f<int>(0, 0, 0); // { dg-bogus "null" }
f<float>(0, 0, 0);
- // { dg-bogus "null argument where non-null required \\\(argument 1\\\)" "" { target *-*-* } .-1 }
- // { dg-warning "null argument where non-null required \\\(argument 3\\\)" "" { target *-*-* } .-2 }
+ // { dg-bogus "argument 1 null where non-null expected" "" { target *-*-* } .-1 }
+ // { dg-warning "argument 3 null where non-null expected" "" { target *-*-* } .-2 }
}
void
fun1 (void (foo::*f) (int *) __attribute__ ((nonnull (2))))
{
- (x.*f) ((int *) 0); // { dg-warning "null argument" }
+ (x.*f) ((int *) 0); // { dg-warning "argument 1 null" }
}
void
fun2 (void (foo::*f) () __attribute__ ((nonnull, unused))) // { dg-bogus "unused" }
{
- (x.*g) ((int *) 0); // { dg-warning "null argument" }
+ (x.*g) ((int *) 0); // { dg-warning "argument 1 null" }
}
void foo () throw ()
{
- strftime (0,0,0,0); // { dg-warning "null argument where non-null required" }
+ strftime (0,0,0,0); // { dg-warning "argument \(1|3|4\) null where non-null expected" }
// { dg-warning "too many arguments for format" "" { target *-*-* } .-1 }
}
void
g ()
{
- f<S1>(0); // { dg-warning "null argument where non-null required" }
- f<S2>(0); // { dg-warning "null argument where non-null required" }
+ f<S1>(0); // { dg-warning "argument 1 null where non-null expected" }
+ f<S2>(0); // { dg-warning "argument 1 null where non-null expected" }
}
main ()
{
int *const p = 0;
- declared_not_defined (p); // { dg-warning "null argument where non-null required" }
- declared_and_defined (p); // { dg-warning "null argument where non-null required" }
+ declared_not_defined (p); // { dg-warning "argument 1 null where non-null expected" }
+ declared_and_defined (p); // { dg-warning "argument 1 null where non-null expected" }
}
void *
--- /dev/null
+/* PR c++/86568 - -Wnonnull warnings should highlight the relevant argument
+ not the closing parenthesis.
+ { dg-do compile }
+ { dg-options "-O2 -Wall" } */
+
+#define NONNULL __attribute__ ((nonnull))
+
+#if __cplusplus < 201103L
+# define nullptr __null
+#endif
+
+struct S
+{
+ void
+ f0 (const void*) const; // { dg-message "in a call to non-static member function 'void S::f0\\(const void\\*\\) const'" }
+
+ void
+ f1 (const void*) const; // { dg-message "in a call to non-static member function 'void S::f1\\(const void\\*\\) const'" }
+
+ void
+ f2 (const void*) const; // { dg-message "in a call to non-static member function 'void S::f2\\(const void\\*\\) const'" }
+
+ NONNULL void
+ f3 (const void*, const void*); // { dg-message "in a call to function 'void S::f3\\(const void\\*, const void\\*\\)' declared 'nonnull'" }
+
+ NONNULL void
+ f4 (const void*, const void*); // { dg-message "in a call to function 'void S::f4\\(const void\\*, const void\\*\\)' declared 'nonnull'" }
+
+ NONNULL void
+ f5 (const void*, const void*); // { dg-message "in a call to function 'void S::f5\\\(const void\\*, const void\\*\\)' declared 'nonnull'" }
+
+ NONNULL void
+ f6 (const void*, const void*); // { dg-message "in a call to function 'void S::f6\\\(const void\\*, const void\\*\\)' declared 'nonnull'" }
+};
+
+void warn_nullptr_this ()
+{
+ ((S*)nullptr)->f0 (""); // { dg-warning "3:'this' pointer null" "pr86568" { xfail *-*-* } }
+ // { dg-warning "this' pointer null" "pr86568" { target *-*-* } .-1 }
+}
+
+void warn_null_this_cst ()
+{
+ S* const null = 0;
+ null->f1 (""); // { dg-warning "3:'this' pointer null" }
+}
+
+void warn_null_this_var ()
+{
+ S* null = 0;
+ null->f2 (&null); // { dg-warning "3:'this' pointer null" "pr86568" { xfail *-*-* } }
+ // { dg-warning "'this' pointer null" "pr86568" { target *-*-* } .-1 }
+}
+
+void warn_nullptr (S s)
+{
+ s.f3 (nullptr, &s); // { dg-warning "9:argument 1 null where non-null expected" "pr86568" { xfail *-*-* } }
+ // { dg-warning "argument 1 null where non-null expected" "pr86568" { target *-*-* } .-1 }
+ s.f3 (&s, nullptr); // { dg-warning "13:argument 2 null where non-null expected" "pr86568" { xfail *-*-* } }
+ // { dg-warning "argument 2 null where non-null expected" "pr86568" { target *-*-* } .-1 }
+}
+
+
+void warn_null_cst (S s)
+{
+ void* const null = 0;
+ s.f4 (null, &s); // { dg-warning "9:argument 1 null where non-null expected" }
+ s.f4 (&s, null); // { dg-warning "13:argument 2 null where non-null expected" }
+}
+
+void warn_null_var (S s)
+{
+ void* null = 0;
+ s.f5 (null, &s); // { dg-warning "9:argument 1 null where non-null expected" "pr86568" { xfail *-*-* } }
+ // { dg-warning "argument 1 null where non-null expected" "pr86568" { target *-*-* } .-1 }
+ s.f5 (&s, null); // { dg-warning "16:argument 2 null where non-null expected" "pr86568" { xfail *-*-* } }
+ // { dg-warning "argument 2 null where non-null expected" "pr86568" { target *-*-* } .-1 }
+}
+
+void warn_null_cond (S s, void *null)
+{
+ if (null)
+ return;
+
+ s.f6 (null, &s); // { dg-warning "9:argument 1 null where non-null expected" "pr86568" { xfail *-*-* } }
+ // { dg-warning "argument 1 null where non-null expected" "pr86568" { target *-*-* } .-1 }
+ s.f6 (&s, null); // { dg-warning "13:argument 2 null where non-null expected" "pr86568" { xfail *-*-* } }
+ // { dg-warning "argument 2 null where non-null expected" "pr86568" { target *-*-* } .-1 }
+}
+
+
+typedef NONNULL void Fvp (const void*, const void*);
+
+void warn_fptr_null_cst (Fvp *p)
+{
+ void* const null = 0;
+ p (null, ""); // { dg-warning "6:argument 1 null where non-null expected" }
+ p ("", null); // { dg-warning "10:argument 2 null where non-null expected" }
+}
+
+typedef NONNULL void (S::*SMemFvp) (const void*, const void*);
+
+void warn_memfptr_null_cst (S *p, SMemFvp pmf)
+{
+ void* const null = 0;
+ (p->*pmf) (null, ""); // { dg-warning "14:argument 1 null where non-null expected" }
+ (p->*pmf) ("", null); // { dg-warning "18:argument 2 null where non-null expected" }
+}
void test (MyArray *object)
{
[object addObject: object];
- [object addObject: nil]; /* { dg-warning "null argument where non-null required" } */
+ [object addObject: nil]; /* { dg-warning "\\\[-Wnonnull" } */
[object insertObject: object atIndex: 4];
- [object insertObject: nil atIndex: 4]; /* { dg-warning "null argument where non-null required" } */
+ [object insertObject: nil atIndex: 4]; /* { dg-warning "\\\[-Wnonnull" } */
[object insertObject: object atIndex: 2 andObject: object atIndex: 3];
- [object insertObject: nil atIndex: 2 andObject: object atIndex: 3]; /* { dg-warning "null argument where non-null required" } */
- [object insertObject: object atIndex: 2 andObject: nil atIndex: 3]; /* { dg-warning "null argument where non-null required" } */
+ [object insertObject: nil atIndex: 2 andObject: object atIndex: 3]; /* { dg-warning "\\\[-Wnonnull" } */
+ [object insertObject: object atIndex: 2 andObject: nil atIndex: 3]; /* { dg-warning "\\\[-Wnonnull" } */
}
void test (MyArray *object)
{
[object addObject: object];
- [object addObject: nil]; /* { dg-warning "null argument where non-null required" } */
+ [object addObject: nil]; /* { dg-warning "\\\[-Wnonnull" } */
[object insertObject: object atIndex: 4];
- [object insertObject: nil atIndex: 4]; /* { dg-warning "null argument where non-null required" } */
+ [object insertObject: nil atIndex: 4]; /* { dg-warning "\\\[-Wnonnull" } */
[object insertObject: object atIndex: 2 andObject: object atIndex: 3];
- [object insertObject: nil atIndex: 2 andObject: object atIndex: 3]; /* { dg-warning "null argument where non-null required" } */
- [object insertObject: object atIndex: 2 andObject: nil atIndex: 3]; /* { dg-warning "null argument where non-null required" } */
+ [object insertObject: nil atIndex: 2 andObject: object atIndex: 3]; /* { dg-warning "\\\[-Wnonnull" } */
+ [object insertObject: object atIndex: 2 andObject: nil atIndex: 3]; /* { dg-warning "\\\[-Wnonnull" } */
}
if (!is_gimple_call (stmt) || gimple_no_warning_p (stmt))
continue;
- if (warn_nonnull)
+ tree fntype = gimple_call_fntype (stmt);
+ bitmap nonnullargs = get_nonnull_args (fntype);
+ if (!nonnullargs)
+ continue;
+
+ tree fndecl = gimple_call_fndecl (stmt);
+
+ for (unsigned i = 0; i < gimple_call_num_args (stmt); i++)
{
- bitmap nonnullargs
- = get_nonnull_args (gimple_call_fntype (stmt));
- if (nonnullargs)
+ tree arg = gimple_call_arg (stmt, i);
+ if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
+ continue;
+ if (!integer_zerop (arg))
+ continue;
+ if (!bitmap_empty_p (nonnullargs)
+ && !bitmap_bit_p (nonnullargs, i))
+ continue;
+
+ /* In C++ non-static member functions argument 0 refers
+ to the implicit this pointer. Use the same one-based
+ numbering for ordinary arguments. */
+ unsigned argno = TREE_CODE (fntype) == METHOD_TYPE ? i : i + 1;
+ location_t loc = (EXPR_HAS_LOCATION (arg)
+ ? EXPR_LOCATION (arg)
+ : gimple_location (stmt));
+ auto_diagnostic_group d;
+ if (argno == 0)
{
- for (unsigned i = 0; i < gimple_call_num_args (stmt); i++)
- {
- tree arg = gimple_call_arg (stmt, i);
- if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
- continue;
- if (!integer_zerop (arg))
- continue;
- if (!bitmap_empty_p (nonnullargs)
- && !bitmap_bit_p (nonnullargs, i))
- continue;
-
- location_t loc = gimple_location (stmt);
- auto_diagnostic_group d;
- if (warning_at (loc, OPT_Wnonnull,
- "%Gargument %u null where non-null "
- "expected", stmt, i + 1))
- {
- tree fndecl = gimple_call_fndecl (stmt);
- if (fndecl && DECL_IS_BUILTIN (fndecl))
- inform (loc, "in a call to built-in function %qD",
- fndecl);
- else if (fndecl)
- inform (DECL_SOURCE_LOCATION (fndecl),
- "in a call to function %qD declared here",
- fndecl);
-
- }
- }
- BITMAP_FREE (nonnullargs);
+ if (warning_at (loc, OPT_Wnonnull,
+ "%G%qs pointer null", stmt, "this")
+ && fndecl)
+ inform (DECL_SOURCE_LOCATION (fndecl),
+ "in a call to non-static member function %qD",
+ fndecl);
+ continue;
}
+
+ if (!warning_at (loc, OPT_Wnonnull,
+ "%Gargument %u null where non-null "
+ "expected", stmt, argno))
+ continue;
+
+ tree fndecl = gimple_call_fndecl (stmt);
+ if (fndecl && DECL_IS_BUILTIN (fndecl))
+ inform (loc, "in a call to built-in function %qD",
+ fndecl);
+ else if (fndecl)
+ inform (DECL_SOURCE_LOCATION (fndecl),
+ "in a call to function %qD declared %qs",
+ fndecl, "nonnull");
}
+ BITMAP_FREE (nonnullargs);
}
}
return 0;
if (fntype == NULL_TREE)
return NULL;
+ bitmap argmap = NULL;
+ if (TREE_CODE (fntype) == METHOD_TYPE)
+ {
+ /* The this pointer in C++ non-static member functions is
+ implicitly nonnull whether or not it's declared as such. */
+ argmap = BITMAP_ALLOC (NULL);
+ bitmap_set_bit (argmap, 0);
+ }
+
tree attrs = TYPE_ATTRIBUTES (fntype);
if (!attrs)
- return NULL;
-
- bitmap argmap = NULL;
+ return argmap;
/* A function declaration can specify multiple attribute nonnull,
each with zero or more arguments. The loop below creates a bitmap
int entryvals;
};
+/* Type for dependencies actively used when expand FROM into cur_loc. */
+typedef vec<loc_exp_dep, va_heap, vl_embed> deps_vec;
+
/* This data structure is allocated for one-part variables at the time
of emitting notes. */
struct onepart_aux
/* The depth of the cur_loc expression. */
expand_depth depth;
/* Dependencies actively used when expand FROM into cur_loc. */
- vec<loc_exp_dep, va_heap, vl_embed> deps;
+ deps_vec deps;
};
/* Structure describing one part of variable. */
: NULL)
#define VAR_LOC_FROM(var) (VAR_LOC_1PAUX (var)->from)
#define VAR_LOC_DEPTH(var) (VAR_LOC_1PAUX (var)->depth)
-#define VAR_LOC_DEP_VEC(var) (VAR_LOC_1PAUX (var) \
- ? &VAR_LOC_1PAUX (var)->deps \
- : NULL)
+#define VAR_LOC_DEP_VEC(var) var_loc_dep_vec (var)
+
+/* Implements the VAR_LOC_DEP_VEC above as a function to work around
+ a bogus -Wnonnull (PR c/95554). */
+static inline deps_vec*
+var_loc_dep_vec (variable *var)
+{
+ return VAR_LOC_1PAUX (var) ? &VAR_LOC_1PAUX (var)->deps : NULL;
+}
typedef unsigned int dvuid;
return;
allocsize = offsetof (struct onepart_aux, deps)
- + vec<loc_exp_dep, va_heap, vl_embed>::embedded_size (count);
+ + deps_vec::embedded_size (count);
if (VAR_LOC_1PAUX (var))
{
projects / thirdparty / gcc.git / commitdiff
