fix "unreplaced" warnings caused by using typeof() on inline functions
PATCH 1/1 fix "unreplaced" warnings caused by using typeof() on inline functions
From: Luc Van Oostenryck <[email protected]>
Currently, sparse do all its inlining at the tree level, during constant expansion. To not mix-up the evaluation of the original function body in case the address of an inline function is taken or when the function can't otherwise be inlined, the statements and symbols lists of inline functions are kept in separated fields. Then, if the original body must be evaluated it must first be 'uninlined' to have a copy in the usual fields.
This make sense when dealing with the definition of the function. But, when using typeof() on functions, the resulting type doesn't refer to this definition, it's just a copy of the type and only of the type. There shouldn't be any reasons to uninline anything. However, the distinction between 'full function' and 'type only' is not made during evaluation and the uninlining attempt produce a lot of "warning: unreplaced symbol '...'" because of the lack of a corresponding definition.
Fix this by not doing the uninlining if the symbol lack a definition.
Note: It would maybe be more appropriate for EXPR_TYPE to use
a stripped-own version of evaluate_symbol() doing only the examination of the return and argument types, bypassing the attempt to uninline the body and evaluate the initializer and the statements since there is none of those for an EXPR_TYPE.
--- evaluate.c | 2 +- validation/inline-early/unreplaced-abstract.c | 28 +++++++++++++++++++ validation/optim/devirtualize0.c | 17 +++++++++++ 3 files changed, 46 insertions(+), 1 deletion(-) create mode 100644 validation/inline-early/unreplaced-abstract.c create mode 100644 validation/optim/devirtualize0.c
evaluate.c +1 -1
@@ -3555,7 +3555,7 @@ static struct symbol *evaluate_symbol(struct symbol *sym) current_fn = sym;examine_fn_arguments (base_type); -if (!base_type->stmt && base_type->inline_stmt) +if (!base_type->stmt && base_type->inline_stmt && sym->definition)uninline (sym);if (base_type->stmt)evaluate_statement (base_type->stmt);
validation/inline-early/unreplaced-abstract.c new file +28 -0
@@ -0,0 +1,28 @@ +static inline void f0 (void ) { } +static inline long f1 (long a) {return a +1 ;} + +_Static_assert([typeof(f0)] != [typeof(f1)]); + + +static inline void g0 (void ) { } +static inline long g1 (long a) {return a +1 ;} + +extern long goo (long a); +long goo (long a) +{ +g0 (); +return g1 (a); +} + +_Static_assert([typeof(g0)] != [typeof(g1)]); + +extern long moo (long a); +long moo (long a) +{ +typeof (f1) *f = g1; +return f (a); +} + +/* +* check-name: unreplaced-abstract +*/
validation/optim/devirtualize0.c new file +17 -0
@@ -0,0 +1,17 @@ +static inline long f1 (long x) {return x +1 ;} + +extern long foo (long a); +long foo (long a) +{ +typeof (f1) *f = f1; +return f (a); +} + +/* +* check-name: devirtualize0 +* check-command: test-linearize -Wno-decl $file +* check-known-to-fail +* +* check-output-ignore +* check-output-excludes: call\\. +*/
Signature · 1 line
2.36.1
Quoted 19 lines · Luc Van Oostenryck
From: Luc Van Oostenryck <[email protected]>
Currently, sparse do all its inlining at the tree level, during constant expansion. To not mix-up the evaluation of the original function body in case the address of an inline function is taken or when the function can't otherwise be inlined, the statements and symbols lists of inline functions are kept in separated fields. Then, if the original body must be evaluated it must first be 'uninlined' to have a copy in the usual fields.
This make sense when dealing with the definition of the function. But, when using
typeof()on functions, the resulting type doesn't refer to this definition, it's just a copy of the type and only of the type. There shouldn't be any reasons to uninline anything. However, the distinction between 'full function' and 'type only' is not made during evaluation and the uninlining attempt produce a lot of "warning: unreplaced symbol '...'" because of the lack of a corresponding definition.
Quoted 7 lines
Fix this by not doing the uninlining if the symbol lack a definition.
Note: It would maybe be more appropriate for
EXPR_TYPEto use
a stripped-own version ofevaluate_symbol()doing only the examination of the return and argument types, bypassing the attempt to uninline the body and evaluate the initializer and the statements since there is none of those for anEXPR_TYPE.
Uwe, can we get a Debian package with this fix, it's really a tons of such messages when compile kernel with C=1?
Signature · 2 lines
With Best Regards, Andy Shevchenko
Quoted 22 lines · Andy Shevchenko
Quoted 21 lines · Luc Van Oostenryck
From: Luc Van Oostenryck <[email protected]>
Currently, sparse do all its inlining at the tree level, during constant expansion. To not mix-up the evaluation of the original function body in case the address of an inline function is taken or when the function can't otherwise be inlined, the statements and symbols lists of inline functions are kept in separated fields. Then, if the original body must be evaluated it must first be 'uninlined' to have a copy in the usual fields.
This make sense when dealing with the definition of the function. But, when using
typeof()on functions, the resulting type doesn't refer to this definition, it's just a copy of the type and only of the type. There shouldn't be any reasons to uninline anything. However, the distinction between 'full function' and 'type only' is not made during evaluation and the uninlining attempt produce a lot of "warning: unreplaced symbol '...'" because of the lack of a corresponding definition.Fix this by not doing the uninlining if the symbol lack a definition.
Quoted 8 lines
Quoted 5 lines
Note: It would maybe be more appropriate for
EXPR_TYPEto use
a stripped-own version ofevaluate_symbol()doing only the examination of the return and argument types, bypassing the attempt to uninline the body and evaluate the initializer and the statements since there is none of those for anEXPR_TYPE.Uwe, can we get a Debian package with this fix, it's really a tons of such messages when compile kernel with C=1?
Luc, do you consider it sensible to create a 0.6.4 variant of sparse that includes this fix? Are there any more patches that you'd deem sensible to inlucde? Does that mean it's time for a 0.6.5 release?
Best regards
Uwe
Quoted 22 lines · Andy Shevchenko
Quoted 21 lines · Luc Van Oostenryck
From: Luc Van Oostenryck <[email protected]>
Currently, sparse do all its inlining at the tree level, during constant expansion. To not mix-up the evaluation of the original function body in case the address of an inline function is taken or when the function can't otherwise be inlined, the statements and symbols lists of inline functions are kept in separated fields. Then, if the original body must be evaluated it must first be 'uninlined' to have a copy in the usual fields.
This make sense when dealing with the definition of the function. But, when using
typeof()on functions, the resulting type doesn't refer to this definition, it's just a copy of the type and only of the type. There shouldn't be any reasons to uninline anything. However, the distinction between 'full function' and 'type only' is not made during evaluation and the uninlining attempt produce a lot of "warning: unreplaced symbol '...'" because of the lack of a corresponding definition.Fix this by not doing the uninlining if the symbol lack a definition.
Quoted 8 lines
Quoted 5 lines
Note: It would maybe be more appropriate for
EXPR_TYPEto use
a stripped-own version ofevaluate_symbol()doing only the examination of the return and argument types, bypassing the attempt to uninline the body and evaluate the initializer and the statements since there is none of those for anEXPR_TYPE.Uwe, can we get a Debian package with this fix, it's really a tons of such messages when compile kernel with C=1?
As of today it seems Debian still has old sparse version...
Signature · 2 lines
With Best Regards, Andy Shevchenko