The start_sequence/end_sequence interface was a big improvement over
the previous state, but one slightly awkward thing about it is that
you have to call get_insns before end_sequence in order to get the
insn sequence itself:
To get the contents of the sequence just made, you must call
`get_insns' *before* calling here.
We therefore have quite a lot of code like this:
insns = get_insns ();
end_sequence ();
return insns;
It would seem simpler to write:
return end_sequence ();
instead.
I can see three main potential objections to this:
(1) It isn't obvious whether ending the sequence would return the first
or the last instruction. But although some code reads *both* the
first and the last instruction, I can't think of a specific case
where code would want *only* the last instruction. All the emit
functions take the first instruction rather than the last.
(2) The "end" in end_sequence might imply the C++ meaning of an exclusive
endpoint iterator. But for an insn sequence, the exclusive endpoint
is always the null pointer, so it would never need to be returned.
That said, we could rename the function to something like
"finish_sequence" or "complete_sequence" if this is an issue.
(3) There might have been an intention that start_sequence/end_sequence
could in future reclaim memory for unwanted sequences, and so an
explicit get_insns was used to indicate that the caller does want
the sequence.
But that sort of memory reclaimation has never been added,
and now that the codebase is C++, it would be easier to handle
using RAII. I think reclaiming memory would be difficult to do in
any case, since some code records the individual instructions that
they emit, rather than using get_insns.
---
gcc/emit-rtl.cc | 14 ++++++++------
gcc/rtl.h | 2 +-
2 files changed, 9 insertions(+), 7 deletions(-)
diff --git a/gcc/emit-rtl.cc b/gcc/emit-rtl.cc
index 3e2c4309dee..d86fb23b29a 100644
--- a/gcc/emit-rtl.cc
+++ b/gcc/emit-rtl.cc
@@ -5722,22 +5722,22 @@ pop_topmost_sequence (void)
end_sequence ();
}
-/* After emitting to a sequence, restore previous saved state.
-
- To get the contents of the sequence just made, you must call
- `get_insns' *before* calling here.
+/* After emitting to a sequence, restore the previous saved state and return
+ the start of the completed sequence.
If the compiler might have deferred popping arguments while
generating this sequence, and this sequence will not be immediately
inserted into the instruction stream, use do_pending_stack_adjust
- before calling get_insns. That will ensure that the deferred
+ before calling this function. That will ensure that the deferred
pops are inserted into this sequence, and not into some random
location in the instruction stream. See INHIBIT_DEFER_POP for more
information about deferred popping of arguments. */
-void
+rtx_insn *
end_sequence (void)
{
+ rtx_insn *insns = get_insns ();
+
struct sequence_stack *tem = get_current_sequence ()->next;
set_first_insn (tem->first);
@@ -5747,6 +5747,8 @@ end_sequence (void)
memset (tem, 0, sizeof (*tem));
tem->next = free_sequence_stack;
free_sequence_stack = tem;
+
+ return insns;
}
/* Return true if currently emitting into a sequence. */
diff --git a/gcc/rtl.h b/gcc/rtl.h
index cc25aed1f49..5623a4b06b4 100644
--- a/gcc/rtl.h
+++ b/gcc/rtl.h
@@ -3306,7 +3306,7 @@ extern rtx_insn *get_last_nonnote_insn (void);
extern void start_sequence (void);
extern void push_to_sequence (rtx_insn *);
extern void push_to_sequence2 (rtx_insn *, rtx_insn *);
-extern void end_sequence (void);
+extern rtx_insn *end_sequence (void);
#if TARGET_SUPPORTS_WIDE_INT == 0
extern double_int rtx_to_double_int (const_rtx);
#endif
--
2.43.0
