| Message ID | ory20ivw8z.fsf@lxoliva.fsfla.org |
|---|---|
| State | New |
| Headers | show |
| Series | set loc on call even if result is discarded | expand |
On 4/6/22 15:37, Alexandre Oliva wrote: Need to adjust this subject line, as well. > This patch fixes a divergence in line numbers in diagnostics and, > presumably, debug information, between targets whose cdtors return > this and those that don't. > > The problem was visible in g++.dg/cpp2a/constexpr-dtor3.C: while the > dtor call in the cleanup for f4 was expected at the closing brace, on > returning-this targets it came up at the assignment. > > The reason is convoluted: statements in cleanups have their location > information removed, to avoid bumpy debugger behavior, and then set to > the location of the end of the scope. > > The cleanup dtor call has its locus cleared in both kinds of targets, > but the end-of-scope locus doesn't make it on returning-this targets. > The calls are wrapped with a cast-to-void to discard the unused return > value, and the existing logic only attached the locus to the > conversion NOP_EXPR. > > The call thus remains locus-less. When constexpr logic copies and > evals the body, it sets unset locations; while copying cleanups, the > locus is taken from the cleanup expression, rather than matching the > end-of-scope locus set by the parser. So we end up with different > locations. > > This patch sets the locus of the call even when it's wrapped by a > convert-to-void NOP_EXPR, so it won't diverge any more. > > Regstrapped on x86_64-linux-gnu, also verified the testcase fix on > arm-eabi. Ok to install? > > > for gcc/ChangeLog > > * tree.cc (protected_set_expr_location): Propagate locus to > call wrapped in cast-to-void. I'm reluctant to put this C++-specific change in a simple function shared by all languages; how about handling it in set_cleanup_locs instead? > --- > gcc/tree.cc | 13 ++++++++++++- > 1 file changed, 12 insertions(+), 1 deletion(-) > > diff --git a/gcc/tree.cc b/gcc/tree.cc > index ec200e9a7eb43..228d279ab0aa1 100644 > --- a/gcc/tree.cc > +++ b/gcc/tree.cc > @@ -5372,7 +5372,18 @@ void > protected_set_expr_location (tree t, location_t loc) > { > if (CAN_HAVE_LOCATION_P (t)) > - SET_EXPR_LOCATION (t, loc); > + { > + SET_EXPR_LOCATION (t, loc); > + /* Avoid locus differences for C++ cdtor calls depending on whether > + cdtor_returns_this: a conversion to void is added to discard the return > + value, and this conversion ends up carrying the location, and when it > + gets discarded, the location is lost. So hold it in the call as > + well. */ > + if (TREE_CODE (t) == NOP_EXPR > + && TREE_TYPE (t) == void_type_node > + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) > + SET_EXPR_LOCATION (TREE_OPERAND (t, 0), loc); > + } > else if (t && TREE_CODE (t) == STATEMENT_LIST) > { > t = expr_single (t); > >
On Apr 6, 2022, Jason Merrill <jason@redhat.com> wrote: > On 4/6/22 15:37, Alexandre Oliva wrote: > Need to adjust this subject line, as well. *nod*, thanks >> * tree.cc (protected_set_expr_location): Propagate locus to >> call wrapped in cast-to-void. > I'm reluctant to put this C++-specific change in a simple function > shared by all languages; Perhaps it benefits other languages as well? The effect is presumably desirable on other languages too: setting a cast-to-void's location seems completely ineffective, as it's eventually thrown away, and perhaps propagating the location to any operand (rather than just calls) would carry out the intent of [protected_]set_expr_location more effectively. It doesn't feel right to require every caller to worry about that. > how about handling it in set_cleanup_locs instead? Like this? That seems reasonable to me. I'll give it a spin. diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index a7f6449dafd2e..43627ed30afcb 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -609,7 +609,17 @@ set_cleanup_locs (tree stmts, location_t loc) { if (TREE_CODE (stmts) == CLEANUP_STMT) { - protected_set_expr_location (CLEANUP_EXPR (stmts), loc); + tree t = CLEANUP_EXPR (stmts); + protected_set_expr_location (t, loc); + /* Avoid locus differences for C++ cdtor calls depending on whether + cdtor_returns_this: a conversion to void is added to discard the return + value, and this conversion ends up carrying the location, and when it + gets discarded, the location is lost. So hold it in the call as + well. */ + if (TREE_CODE (t) == NOP_EXPR + && TREE_TYPE (t) == void_type_node + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) + protected_set_expr_location (TREE_OPERAND (t, 0), loc); set_cleanup_locs (CLEANUP_BODY (stmts), loc); } else if (TREE_CODE (stmts) == STATEMENT_LIST)
On Fri, Apr 8, 2022 at 12:49 AM Alexandre Oliva via Gcc-patches <gcc-patches@gcc.gnu.org> wrote: > > On Apr 6, 2022, Jason Merrill <jason@redhat.com> wrote: > > > On 4/6/22 15:37, Alexandre Oliva wrote: > > Need to adjust this subject line, as well. > > *nod*, thanks > > >> * tree.cc (protected_set_expr_location): Propagate locus to > >> call wrapped in cast-to-void. > > > I'm reluctant to put this C++-specific change in a simple function > > shared by all languages; > > Perhaps it benefits other languages as well? The effect is presumably > desirable on other languages too: setting a cast-to-void's location > seems completely ineffective, as it's eventually thrown away, and > perhaps propagating the location to any operand (rather than just calls) > would carry out the intent of [protected_]set_expr_location more > effectively. It doesn't feel right to require every caller to worry > about that. Hmm, but then maybe it would be better the task of the code actually throwing away the cast? I agree the original proposed location to fix this looks bad. > > how about handling it in set_cleanup_locs instead? > > Like this? That seems reasonable to me. I'll give it a spin. > > diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc > index a7f6449dafd2e..43627ed30afcb 100644 > --- a/gcc/cp/semantics.cc > +++ b/gcc/cp/semantics.cc > @@ -609,7 +609,17 @@ set_cleanup_locs (tree stmts, location_t loc) > { > if (TREE_CODE (stmts) == CLEANUP_STMT) > { > - protected_set_expr_location (CLEANUP_EXPR (stmts), loc); > + tree t = CLEANUP_EXPR (stmts); > + protected_set_expr_location (t, loc); > + /* Avoid locus differences for C++ cdtor calls depending on whether > + cdtor_returns_this: a conversion to void is added to discard the return > + value, and this conversion ends up carrying the location, and when it > + gets discarded, the location is lost. So hold it in the call as > + well. */ > + if (TREE_CODE (t) == NOP_EXPR > + && TREE_TYPE (t) == void_type_node > + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) > + protected_set_expr_location (TREE_OPERAND (t, 0), loc); > set_cleanup_locs (CLEANUP_BODY (stmts), loc); > } > else if (TREE_CODE (stmts) == STATEMENT_LIST) > > > -- > Alexandre Oliva, happy hacker https://FSFLA.org/blogs/lxo/ > Free Software Activist GNU Toolchain Engineer > Disinformation flourishes because many people care deeply about injustice > but very few check the facts. Ask me about <https://stallmansupport.org>
On 4/7/22 18:48, Alexandre Oliva wrote: > On Apr 6, 2022, Jason Merrill <jason@redhat.com> wrote: > >> On 4/6/22 15:37, Alexandre Oliva wrote: >> Need to adjust this subject line, as well. > > *nod*, thanks > >>> * tree.cc (protected_set_expr_location): Propagate locus to >>> call wrapped in cast-to-void. > >> I'm reluctant to put this C++-specific change in a simple function >> shared by all languages; > > Perhaps it benefits other languages as well? The effect is presumably > desirable on other languages too: setting a cast-to-void's location > seems completely ineffective, as it's eventually thrown away, and > perhaps propagating the location to any operand (rather than just calls) > would carry out the intent of [protected_]set_expr_location more > effectively. It doesn't feel right to require every caller to worry > about that. > >> how about handling it in set_cleanup_locs instead? > > Like this? That seems reasonable to me. I'll give it a spin. Yes, or perhaps STRIP_NOPS and set the location on whatever is left. OK either way. > diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc > index a7f6449dafd2e..43627ed30afcb 100644 > --- a/gcc/cp/semantics.cc > +++ b/gcc/cp/semantics.cc > @@ -609,7 +609,17 @@ set_cleanup_locs (tree stmts, location_t loc) > { > if (TREE_CODE (stmts) == CLEANUP_STMT) > { > - protected_set_expr_location (CLEANUP_EXPR (stmts), loc); > + tree t = CLEANUP_EXPR (stmts); > + protected_set_expr_location (t, loc); > + /* Avoid locus differences for C++ cdtor calls depending on whether > + cdtor_returns_this: a conversion to void is added to discard the return > + value, and this conversion ends up carrying the location, and when it > + gets discarded, the location is lost. So hold it in the call as > + well. */ > + if (TREE_CODE (t) == NOP_EXPR > + && TREE_TYPE (t) == void_type_node > + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) > + protected_set_expr_location (TREE_OPERAND (t, 0), loc); > set_cleanup_locs (CLEANUP_BODY (stmts), loc); > } > else if (TREE_CODE (stmts) == STATEMENT_LIST) > >
On Apr 9, 2022, Jason Merrill <jason@redhat.com> wrote: >>> how about handling it in set_cleanup_locs instead? >> Like this? That seems reasonable to me. I'll give it a spin. > Yes, or perhaps STRIP_NOPS and set the location on whatever is left. > OK either way. Hmm, I'm not sure leaving the loc unset on the NOP_EXPR won't have ill effects, so here's what I'm installing. Thanks! c++: Set loc on call even if result is discarded This patch fixes a divergence in line numbers in diagnostics and, presumably, debug information, between targets whose cdtors return this and those that don't. The problem was visible in g++.dg/cpp2a/constexpr-dtor3.C: while the dtor call in the cleanup for f4 was expected at the closing brace, on returning-this targets it came up at the assignment. The reason is convoluted: statements in cleanups have their location information removed, to avoid bumpy debugger behavior, and then set to the location of the end of the scope. The cleanup dtor call has its locus cleared in both kinds of targets, but the end-of-scope locus doesn't make it on returning-this targets. The calls are wrapped with a cast-to-void to discard the unused return value, and the existing logic only attached the locus to the conversion NOP_EXPR. The call thus remains locus-less. When constexpr logic copies and evals the body, it sets unset locations; while copying cleanups, the locus is taken from the cleanup expression, rather than matching the end-of-scope locus set by the parser. So we end up with different locations. This patch sets the locus of the call even when it's wrapped by a convert-to-void NOP_EXPR, so it won't diverge any more. for gcc/cp/ChangeLog * semantics.cc (set_cleanup_locs): Propagate locus to call wrapped in cast-to-void. --- gcc/cp/semantics.cc | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index a7f6449dafd2e..43627ed30afcb 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -609,7 +609,17 @@ set_cleanup_locs (tree stmts, location_t loc) { if (TREE_CODE (stmts) == CLEANUP_STMT) { - protected_set_expr_location (CLEANUP_EXPR (stmts), loc); + tree t = CLEANUP_EXPR (stmts); + protected_set_expr_location (t, loc); + /* Avoid locus differences for C++ cdtor calls depending on whether + cdtor_returns_this: a conversion to void is added to discard the return + value, and this conversion ends up carrying the location, and when it + gets discarded, the location is lost. So hold it in the call as + well. */ + if (TREE_CODE (t) == NOP_EXPR + && TREE_TYPE (t) == void_type_node + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) + protected_set_expr_location (TREE_OPERAND (t, 0), loc); set_cleanup_locs (CLEANUP_BODY (stmts), loc); } else if (TREE_CODE (stmts) == STATEMENT_LIST)
diff --git a/gcc/tree.cc b/gcc/tree.cc index ec200e9a7eb43..228d279ab0aa1 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -5372,7 +5372,18 @@ void protected_set_expr_location (tree t, location_t loc) { if (CAN_HAVE_LOCATION_P (t)) - SET_EXPR_LOCATION (t, loc); + { + SET_EXPR_LOCATION (t, loc); + /* Avoid locus differences for C++ cdtor calls depending on whether + cdtor_returns_this: a conversion to void is added to discard the return + value, and this conversion ends up carrying the location, and when it + gets discarded, the location is lost. So hold it in the call as + well. */ + if (TREE_CODE (t) == NOP_EXPR + && TREE_TYPE (t) == void_type_node + && TREE_CODE (TREE_OPERAND (t, 0)) == CALL_EXPR) + SET_EXPR_LOCATION (TREE_OPERAND (t, 0), loc); + } else if (t && TREE_CODE (t) == STATEMENT_LIST) { t = expr_single (t);