updated variadic printf/scanf checking
Subsystems (2)
I'm reposting this as an RFC as there has been quite a bit of work on this to get scanf in and to try and simplify the code, fix a few bugs found when checking the kernel. Depending on the reviews I will post this for inclusion.
I am also looking at some work to try and make printf and scanf extensible with the interesting types the kernel adds to printk, either by a new flag or by some sort of attribute. This is not included in this set.
I think the tests need some more work on scanf, otherwise it seems to work well with the kernel, and not really found any further issues other than the odd signed/unsigned and type.
RFC v4 1/4 parse: initial parsing of __attribute__((format))
Add code to parse the __attribute__((format)) used to indicate that a variadic function takes a printf-style format string and where those are. Save the data in ctype ready for checking when such an function is encoutered.
--
v2:
- apply comments about arg names and early-exit from function
- remove the KW_UNUSED
v3:
- merged the scanf bits back in here as scanf is now inclided
--- parse.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- symbol.h | 17 +++++++++++-- 2 files changed, 86 insertions(+), 3 deletions(-)
parse.c +71 -1
@@ -86,7 +86,7 @@ static attr_t attribute_cleanup, attribute_designated_init, attribute_transparent_union, ignore_attribute, - attribute_mode, attribute_force; + attribute_mode, attribute_force, attribute_format;typedef struct symbol *to_mode_t (struct symbol *);
@@ -389,6 +389,10 @@ static struct symbol_op attr_force_op = { .attribute = attribute_force, }; +static struct symbol_op attr_format_op = { + .attribute = attribute_format, +}; +static struct symbol_op address_space_op = { .attribute = attribute_address_space, };
@@ -448,6 +452,16 @@ static struct symbol_op mode_word_op = { .to_mode = to_word_mode }; +static struct symbol_op attr_printf_op = { + .type =KW_FORMAT , + .class =FMT_PRINTF , +}; + +static struct symbol_op attr_scanf_op = { + .type =KW_FORMAT , + .class =FMT_SCANF , +}; +/* * Define the keyword and their effects. * The entries in the 'typedef' and put in NS_TYPEDEF and
@@ -565,6 +579,9 @@ static struct init_keyword { D("pure", &attr_fun_op, .mods = MOD_PURE), A("const", &attr_fun_op, .mods = MOD_PURE), D("gnu_inline", &attr_fun_op, .mods = MOD_GNU_INLINE), +D ("format" , &attr_format_op), +D ("printf" , &attr_printf_op), +D ("scanf" , &attr_scanf_op),/* Modes */ D("mode", &mode_op),
@@ -1235,6 +1252,57 @@ static struct token *attribute_address_space(struct token *token, struct symbolreturn token; } +static int invalid_format_args (long long start,long long at) +{ +return start <0 || at <0 || start >USHRT_MAX || at >USHRT_MAX || + (start == at && start >0 ) || + (start ==0 && at ==0 ); +} + +static struct token *attribute_format (struct token *token,struct symbol *attr,struct decl_state *ctx) +{ +struct expression *arg_type, *arg_fmt, *arg_argpos; +struct symbol *fmt_sym =NULL ; +long long start, at; + +/* expecting format ( type, fmt, va_args at) */ + + token =expect (token,'(' ,"after format attribute" ); +if (token_type (token) ==TOKEN_IDENT ) + fmt_sym =lookup_keyword (token->ident,NS_KEYWORD ); +if (fmt_sym && (!fmt_sym->op || fmt_sym->op->type !=KW_FORMAT )) + fmt_sym =NULL ; + + token =conditional_expression (token, &arg_type); + token =expect (token,',' ,"format attribute type" ); + token =conditional_expression (token, &arg_fmt); + token =expect (token,',' ,"format attribute type position" ); + token =conditional_expression (token, &arg_argpos); + token =expect (token,')' ,"format attribute arg position" ); + +if (!fmt_sym || !arg_type || !arg_fmt || !arg_argpos) { +warning (token->pos,"missing format attribute argument(s)" ); +return token; + } + + start =get_expression_value (arg_argpos); + at =get_expression_value (arg_fmt); + +if (invalid_format_args (start, at)) { +warning (token->pos,"bad format positions" ); + }else if (start ==0 ) { +/* nothing to do here, is va_list function */ + }else if (start < at) { +warning (token->pos,"format cannot be after va_args" ); + }else { + ctx->ctype.format.index = at; + ctx->ctype.format.first = start; + ctx->ctype.format.type = fmt_sym->op->class; + } + +return token; +} +static struct symbol *to_QI_mode (struct symbol *ctype) {if (ctype->ctype.base_type != &int_type)
@@ -3025,6 +3093,8 @@ struct token *external_declaration(struct token *token, struct symbol_list **lisif (!(decl->ctype.modifiers &MOD_STATIC )) decl->ctype.modifiers |=MOD_EXTERN ; + + base_type->ctype.format = decl->ctype.format; }else if (base_type == &void_ctype && !(decl->ctype.modifiers &MOD_EXTERN )) {sparse_error (token->pos,"void declaration" ); }
symbol.h +15 -2
@@ -83,8 +83,8 @@ enum keyword {KW_ASM =1 <<5 ,KW_MODE =1 <<6 ,KW_STATIC =1 <<7 , -// KW UNUSED = 1 << 8, - KW_EXACT = 1 << 9, +KW_EXACT =1 <<8 , + KW_FORMAT = 1 << 9, }; struct context {
@@ -96,12 +96,25 @@ extern struct context *alloc_context(void); DECLARE_PTR_LIST(context_list, struct context); +/* the types of formatting from __attribute__((format)) */ +enum { +FMT_PRINTF =1 , +FMT_SCANF =2 , +}; + +struct attr_format { +unsigned short type; +unsigned short index;/* index in argument list for format string */ +unsigned short first;/* where first variadic argument is */ +}; +struct ctype {struct symbol *base_type;unsigned long modifiers;unsigned long alignment;struct context_list *contexts;struct ident *as; +struct attr_format format; };struct decl_state {
Signature · 1 line
2.37.2.352.g3c44437643
RFC v4 2/4 add -Wformat
In reply to Ben DooksAdd option to enable/disable format checking (and default it to off)
--- options.c | 2 ++ options.h | 1 + sparse.1 | 8 ++++++++ 3 files changed, 11 insertions(+)
options.c +2 -0
@@ -106,6 +106,7 @@ int Wflexible_array_array = 1;int Wflexible_array_nested =0 ;int Wflexible_array_sizeof =0 ;int Wflexible_array_union =0 ; +int Wformat =0 ;int Wimplicit_int =1 ;int Winit_cstring =0 ;int Wint_to_pointer_cast =1 ;
@@ -865,6 +866,7 @@ static const struct flag warnings[] = { { "flexible-array-nested", &Wflexible_array_nested }, { "flexible-array-sizeof", &Wflexible_array_sizeof }, { "flexible-array-union", &Wflexible_array_union }, + { "format", &Wformat }, { "implicit-int", &Wimplicit_int }, { "init-cstring", &Winit_cstring }, { "int-to-pointer-cast", &Wint_to_pointer_cast },
options.h +1 -0
@@ -106,6 +106,7 @@ extern int Wflexible_array_array;extern int Wflexible_array_nested;extern int Wflexible_array_sizeof;extern int Wflexible_array_union; +extern int Wformat;extern int Wimplicit_int;extern int Winit_cstring;extern int Wint_to_pointer_cast;
sparse.1 +8 -0
@@ -285,6 +285,14 @@ To have any effect, at least one of \fB-Wflexible-array-array\fR, be enabled. Sparse does issue these warnings by default. +.B \-Wformat +Warn about parameter mismatch to any variadic function which specifies +where the format string is specified with the +.BI __attribute__((format( type, message, va_start ))) +attribute. + +Sparse does not issue these warnings by default. To turn them on, use +\fB\-W-format\fR. . .TP .B \-Winit\-cstring
Signature · 1 line
2.37.2.352.g3c44437643
RFC v4 3/4 evaluate: check variadic argument types against formatting info
In reply to Ben DooksThe variadic argumebt code did not check any of the variadic arguments as it did not previously know the possible type. Now we have the possible formatting information stored in the ctype, we can do some checks on the printf formatting types.
--
V2:
- try and reduce size/if nesting of parse_printf_get_fmt()
- change return for parse_format_printf() and try and simplify
- reworked the test code to reduce numner of test functions
- bailed out early if verification isn't ok
V3:
- fixed issue with kernel testing
- fixed logic error in one check
V4:
- rewritten to deal with scanf
- made some of the format code common and tried to simplify
- fixed bugs found with checking linux-kernel#
Note, this is quite a re-write from the original so probably will need re-reviewing
--- Makefile | 1 + builtin.c | 4 +- evaluate.c | 14 +- evaluate.h | 10 +- verify-format.c | 571 ++++++++++++++++++++++++++++++++++++++++++++++++ verify-format.h | 6 + 6 files changed, 599 insertions(+), 7 deletions(-) create mode 100644 verify-format.c create mode 100644 verify-format.h
Makefile +1 -0
@@ -90,6 +90,7 @@ LIB_OBJS += tokenize.o LIB_OBJS += unssa.o LIB_OBJS += utils.o LIB_OBJS += version.o +LIB_OBJS += verify-format.o PROGRAMS := PROGRAMS += compile
builtin.c +2 -2
@@ -439,7 +439,7 @@ static int evaluate_generic_int_op(struct expression *expr)NEXT_PTR_LIST (t); }END_FOR_EACH_PTR (arg);FINISH_PTR_LIST (t); -return evaluate_arguments (types, expr->args); +return evaluate_arguments (NULL , types, expr->args); err:sparse_error (arg->pos,"non-integer type for argument %d:" , n);
@@ -503,7 +503,7 @@ static int eval_atomic_common(struct expression *expr)if (!expr->ctype)// set the return type, if needed expr->ctype = ctype; -return evaluate_arguments (types, expr->args); +return evaluate_arguments (NULL , types, expr->args); err:sparse_error (arg->pos,"invalid type for argument %d:" , n);
evaluate.c +10 -4
@@ -42,6 +42,7 @@#include "symbol.h" #include "target.h" #include "expression.h" +#include "verify-format.h" struct symbol *current_fn;
@@ -1387,8 +1388,8 @@ static int whitelist_pointers(struct symbol *t1, struct symbol *t2)return !Wtypesign; } -static int check_assignment_types (struct symbol *target,struct expression **rp, -const char **typediff) +int check_assignment_types (struct symbol *target,struct expression **rp, +const char **typediff) {struct symbol *source =degenerate (*rp);struct symbol *t, *s;
@@ -2325,7 +2326,8 @@ static struct symbol *evaluate_alignof(struct expression *expr)return size_t_ctype; } -int evaluate_arguments (struct symbol_list *argtypes,struct expression_list *head) +int evaluate_arguments (struct symbol *fn,struct symbol_list *argtypes, +struct expression_list *head) {struct expression *expr;struct symbol *argtype;
@@ -2366,6 +2368,10 @@ int evaluate_arguments(struct symbol_list *argtypes, struct expression_list *heaNEXT_PTR_LIST (argtype); }END_FOR_EACH_PTR (expr);FINISH_PTR_LIST (argtype); + +if (fn && Wformat) +verify_format_attribute (fn, head); +return 1 ; }
@@ -3192,7 +3198,7 @@ static struct symbol *evaluate_call(struct expression *expr)if (!sym->op->args (expr))return NULL ; }else { -if (!evaluate_arguments (ctype->arguments, arglist)) +if (!evaluate_arguments (ctype, ctype->arguments, arglist))return NULL ; args =expression_list_size (expr->args); fnargs =symbol_list_size (ctype->arguments);
evaluate.h +9 -1
@@ -28,8 +28,16 @@ void evaluate_symbol_list(struct symbol_list *list);/// // evaluate the arguments of a function +// @fn: the symbol of the prototype // @argtypes: the list of the types in the prototype // @args: the list of the effective arguments -int evaluate_arguments (struct symbol_list *argtypes,struct expression_list *args); +int evaluate_arguments (struct symbol *fn,struct symbol_list *argtypes,struct expression_list *args); +/// +// check if assignment types are compatible +// @target: the target assignment +// @rp: the expression +// @typediff: the resulant message if different type +int check_assignment_types (struct symbol *target,struct expression **rp, +const char **typediff);#endif
verify-format.c new file +571 -0
571 lines not on this page · raw message
verify-format.h new file +6 -0
@@ -0,0 +1,6 @@ +#ifndef VERIFY_FORMAT_H +#define VERIFY_FORMAT_H + +void verify_format_attribute (struct symbol *fn,struct expression_list *args); + +#endif
Signature · 1 line
2.37.2.352.g3c44437643
RFC v4 4/4 tests: add varargs printf format tests
In reply to Ben DooksAdd some tests for the new printf format checking code. Note, these do not all pass yet.
--- validation/varargs-format-addrspace1.c | 36 ++++++++ validation/varargs-format-bad.c | 18 ++++ validation/varargs-format-checking.c | 21 +++++ validation/varargs-format-position.c | 32 +++++++ validation/varargs-format-prefix.c | 19 ++++ validation/varargs-format-tests.c | 82 +++++++++++++++++ validation/varargs-type-formattest.c | 117 +++++++++++++++++++++++++ 7 files changed, 325 insertions(+) create mode 100644 validation/varargs-format-addrspace1.c create mode 100644 validation/varargs-format-bad.c create mode 100644 validation/varargs-format-checking.c create mode 100644 validation/varargs-format-position.c create mode 100644 validation/varargs-format-prefix.c create mode 100644 validation/varargs-format-tests.c create mode 100644 validation/varargs-type-formattest.c
validation/varargs-format-addrspace1.c new file +36 -0
@@ -0,0 +1,36 @@ + +extern int variadic (char *msg, ...) __attribute__((format (printf,1 ,2 ))); +extern int variadic2 (char *msg,int , ...) __attribute__((format (printf,1 ,3 ))); +extern int variadic3 (int ,char *msg, ...) __attribute__((format (printf,2 ,3 ))); + +static void test (void ) { +void __attribute__((noderef,address_space (1 ))) *a; +void *b; + +variadic ("%s\n" , a); +variadic ("%s\n" , b); +variadic ("%s %s\n" , b, a); +variadic2 ("%s %s\n" ,1 , b, a); +variadic3 (1 ,"%s %s\n" , b, a); +variadic3 (1 ,"%s %p\n" , b, a); +} + +/* +* check-name: variadic formatting test with address-space to %s +* check-command: sparse -Wformat $file +* +* check-error-start +varargs-format-addrspace1.c:10:26: warning: incorrect type in argument 2 (different address spaces) +varargs-format-addrspace1.c:10:26: expected char const * +varargs-format-addrspace1.c:10:26: got void [noderef] <asn:1> *a +varargs-format-addrspace1.c:12:32: warning: incorrect type in argument 3 (different address spaces) +varargs-format-addrspace1.c:12:32: expected char const * +varargs-format-addrspace1.c:12:32: got void [noderef] <asn:1> *a +varargs-format-addrspace1.c:13:36: warning: incorrect type in argument 4 (different address spaces) +varargs-format-addrspace1.c:13:36: expected char const * +varargs-format-addrspace1.c:13:36: got void [noderef] <asn:1> *a +varargs-format-addrspace1.c:14:36: warning: incorrect type in argument 4 (different address spaces) +varargs-format-addrspace1.c:14:36: expected char const * +varargs-format-addrspace1.c:14:36: got void [noderef] <asn:1> *a +* check-error-end +*/
validation/varargs-format-bad.c new file +18 -0
@@ -0,0 +1,18 @@ + +extern int variadic (char *msg, ...) __attribute__((format (printf,0 ,0 ))); +extern int variadic2 (char *msg,int , ...) __attribute__((format (printf,2 ,2 ))); +extern int variadic3 (char *msg,int , ...) __attribute__((format (printf,2 ,1 ))); + +static void test (void ) { +} + +/* +* check-name: variadic formatting test with bad formatting parameters +* check-command: sparse -Wformat $file +* +* check-error-start +varargs-format-bad.c:2:73: warning: bad format positions +varargs-format-bad.c:3:80: warning: bad format positions +varargs-format-bad.c:4:80: warning: format cannot be after va_args +* check-error-end +*/
validation/varargs-format-checking.c new file +21 -0
@@ -0,0 +1,21 @@ + +extern void pf (char *msg, ...) __attribute__((format (printf,1 ,2 ))); + +static void test (void ) { +pf ("%u %lu %llu\n" ,1U ,1UL ,1ULL ); +pf ("%d %ld %lld\n" ,1 ,1L ,1LL ); +pf ("%x %lx %llx\n" ,1U ,1UL ,1ULL ); +pf ("%d %ld %lld\n" ,1 ,1L ,1L ); +} + +/* +* check-name: variadic formatting test type checking +* check-command: sparse -Wformat $file +* check-known-to-fail +* +* check-error-start +varargs-format-checking.c:8:36: warning: incorrect type in argument 4 (different types) +varargs-format-checking.c:8:36: expected long long +varargs-format-checking.c:8:36: got long +* check-error-end +*/
validation/varargs-format-position.c new file +32 -0
@@ -0,0 +1,32 @@ + +extern void pf (char *msg, ...) __attribute__((format (printf,1 ,2 ))); + +static void test (void ) { +pf ("%2$d %u\n" ,1U ,1L ); +pf ("%3$d %2$u\n" ,1U ,1 ); +pf ("%1$d %2$d\n" ,1L ,1 ); +} + +/* +* check-name: variadic formatting test position checking +* check-command: sparse -Wformat $file +* check-known-to-fail +* +* check-error-start +varargs-format-position.c:5:29: warning: incorrect type in argument 3 (different types) +varargs-format-position.c:5:29: expected int +varargs-format-position.c:5:29: got long +varargs-format-position.c:5:12: warning: format 3: position: no position specified +varargs-format-position.c:5:29: warning: incorrect type in argument 3 (different types) +varargs-format-position.c:5:29: expected unsigned int +varargs-format-position.c:5:29: got long +varargs-format-position.c:6:12: warning: no argument at position '4' +varargs-format-position.c:6:31: warning: incorrect type in argument 3 (different types) +varargs-format-position.c:6:31: expected unsigned int +varargs-format-position.c:6:31: got int +varargs-format-position.c:7:27: warning: incorrect type in argument 2 (different types) +varargs-format-position.c:7:27: expected int +varargs-format-position.c:7:27: got long +* check-error-end +* +*/
validation/varargs-format-prefix.c new file +19 -0
@@ -0,0 +1,19 @@ + +extern int __attribute__((format (printf,1 ,2 )))variadic (char *msg, ...); + +static int test (void ) { +void __attribute__((noderef,address_space (1 ))) *a; + +variadic ("%s\n" , a); +} + +/* +* check-name: variadic formatting test prefix based __attribute__ +* check-command: sparse -Wformat $file +* +* check-error-start +varargs-format-prefix.c:7:26: warning: incorrect type in argument 2 (different address spaces) +varargs-format-prefix.c:7:26: expected char const * +varargs-format-prefix.c:7:26: got void [noderef] <asn:1> *a +* check-error-end +*/
validation/varargs-format-tests.c new file +82 -0
82 lines not on this page · raw message
validation/varargs-type-formattest.c new file +117 -0
117 lines not on this page · raw message
Signature · 1 line
2.37.2.352.g3c44437643