mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-16 22:35:41 +00:00
The debugger's retry command at the moment works only from a final port for
Estimated hours taken: 60
The debugger's retry command at the moment works only from a final port for
the call to be retried, the reason being that the RTTI does not have the
information required to make sure that the state of the stacks is reset
correctly. If you invoke retry from a non-final port, the current
implementation skips forward to a final port and then does the retry;
this does not work if you get a core dump or a infinite loop during the forward
skip. This change adds the required info to the RTTI and thus enables
direct retries from the middle of calls.
The information added has two components. First, if a procedure that lives on
the nondet stack allocates any temporary nondet stack frames, then it must
record the old value of maxfr in a stack slot so that retry can restore it.
Second, if a procedure is tabled, then it must record the call table tip node
corresponding to the actual input arguments, so we can reset this node to
uninitialized (if we don't, then the retried call will find the active call
marker and report an infinite loop error).
The support for retries across minimal model calls is not finished yet.
Finding out what the right thing to do in such cases is a research project,
one that cannot even be started until minimal model tabling works reliably
in the *absence* of retries. However, such retries do grossly wrong things
at the moment; this change is a definite improvement. It attempts to perform
the retry from the fail port, since that is the only time when the minimal
model tabling data structures are quiescent. The "fail" command I added to
the debugger command set to let this be done is not complete yet and is
therefore undocumented; the problem is that a call to a model_non predicate
in a committed choice context will not get to the fail port. I added goal paths
to return layouts so that we will eventually be able to tell when execution
leaves a committed choice context surrounding an ancestor of a model_non
predicate call, but this functionality is not yet implemented.
compiler/stack_layout.m:
Generate the three new fields: the evaluation method, (maybe) the id
of the stack slot containing the saved value of maxfr, and (maybe)
the id of the stack slot containing the call table tip.
compiler/continuation_info.m:
Record the information about the new fields for later use by
stack_layout.m.
Add a new field to record the goal path of calls for their return
layouts.
Fix a screwed comment for the continuation_info data structure.
compiler/llds.m:
Add a new field to call() instructions to hold the goal path of the
call.
Add a utility function for use by trace.m.
compiler/call_gen.m:
Fill in this new field.
compiler/trace.m:
compiler/live_vars.m:
Reserve the fixed stack slot for the saved maxfr if necessary,
and if the call table tip node is needed, make sure that the variable
holding its address is allocated a low-numbered stack slot (otherwise,
its number may not fit into the MR_int_least8_t field in the
proc_layout).
compiler/trace.m:
If necessary, fill in the saved maxfr slot.
If necessary, initialize the call table tip slot.
compiler/hlds_goal.m:
Add a goal feature which marks its goal as defining the variable
representing the call table tip node.
Add a field to the goal path step representing quantification;
the field says whether the quantification changes the determinism of
the goal (i.e. whether it cuts away solutions).
compiler/hlds_pred.m:
compiler/hlds_out.m:
Add two fields to proc_infos which (a) record which variable, if any,
holds the call table tip node, and (b) record whether the procedure's
layout structure needs to reserve a slot for the saved value of maxfr.
compiler/table_gen.m:
Put this feature on the appropriate goal.
Also, rename a predicate to make it reflect its purpose better.
compiler/code_gen.m:
Generate code to put the call table tip variable in its stack slot
immediately after it has been generated.
Add a sanity check to ensure that if a procedure that lives on the det
stack can create a temporary nondet frame, and debugging is enabled,
then it did have a stack slot reserved for the saved maxfr.
compiler/code_util.m:
Add a predicate to make a conservative prediction of whether a
procedure may allocate a temporary nondet stack frame. We cannot
just generate the code and see, because the code generator needs to
know which variables live in which stack slots, and we cannot decide
that until we know whether we need a stack slot for the saved value of
maxfr.
Make an unrelated predicate semidet procedure use a det helper, in
order to make it more robust in the face of changes to the HLDS
(e.g. it was missing code for handling bi_implications).
compiler/code_info.m:
Record whether a procedure has in fact created a temporary nondet stack
frame.
compiler/handle_options.m:
Disable hijacks if debugging is enabled. The code we now use to
restore the stacks for direct retries works only if the retry does not
"backtrack" over a hijacked nondet stack frame whose hijack has not
been undone. Note that code compiled without debugging may still hijack
nondet stack frames. Execution may reemerge from the nondebugged region
in one of two ways. If the nondebugged code returns, then it will have
undone hijack, and the retry code will work. If the nondebugged code
calls debugged code, there will be a region on the stacks containing
no debugging information, and the retry command will refuse to perform
retries that go into or beyond this region. Both cases preserve
correctness.
compiler/*.m:
Trivial changes to conform to changes in data structures.
runtime/mercury_stack_layout.h:
Add three new fields to proc layouts: the numbers of the stack slots
(if any) storing the saved maxfr and the call table tip, and a
representation of the procedure's evaluation method.
runtime/mercury_stack_trace.[ch]:
Now that return layouts contain goal paths, print them in stack dumps
only if the include_trace_data flag is set (in mdb, this requires the
-d flag of the "stack" command).
Pass this flag around directly, instead of encoding its value in
the NULL vs non-NULL values of sp and curfr.
runtime/mercury_regorder.h:
Provide a mechanism to access the values of the first few rN registers
from a save area, for use in debugging low-level C code in the runtime
and the trace directories.
trace/mercury_trace.[ch]:
Reimplement MR_trace_retry to allow retries from the middle.
If the stack segment being retried over contains minimal model
procedures, we must still arrange to skip to the end of the retried
call. If this call is a minimal model generator, skipping to just any
final port is not sufficient to guarantee correctness on retry; to
ensure that subgoal is complete, we must skip to a fail port.
trace/mercury_trace.[ch]:
trace/mercury_trace_internal.c:
Implement a debugger command, "fail", which skips to the fail port or
the exception port of the specified ancestor. Since procedures that are
not model_non are not guaranteed to get to such a port, this
command reports an error if the specified call is not model_non.
Actually, even calls to model_non procedures may not get to the fail
port, as explained above; this is why the command is not yet
documented.
trace/mercury_trace.c:
trace/mercury_trace_util.[ch]:
Move some functions to print parts of the Mercury abstract machine
state from mercury_trace to mercury_trace_util, so that they are
available for use in debugging e.g. mercury_trace_declarative.
trace/mercury_trace_internal.c:
trace/mercury_trace_external.c:
trace/mercury_trace_declarative.c:
Use the new implementation of retries. At the moment, only the
internal debugger implements the full functionality. The declarative
debugger issues retry commands only from situations where the missing
functionality is not (yet) needed. The external debugger should
continue to work correctly, but Erwan may wish to update it to
exploit the availability of the fail command.
trace/mercury_trace*.[ch]:
Fix MR_prefixes, and a signed/unsigned mismatch.
doc/user_guide.texi:
Document the new "fail" command, but comment it out for now.
tests/debugger/retry.{m,inp,exp,exp2}:
A new test case for exercising retry.
tests/debugger/Mmakefile:
Enable the new test case.
tests/debugger/*.exp:
Update the expected output, given the extra info now output e.g. for
exception events and detailed stack traces.
This commit is contained in:
Zoltan Somogyi
@@ -103,6 +103,9 @@
|
||||
:- pred code_util__goal_list_may_allocate_heap(list(hlds_goal)).
|
||||
:- mode code_util__goal_list_may_allocate_heap(in) is semidet.
|
||||
|
||||
:- pred code_util__goal_may_alloc_temp_frame(hlds_goal).
|
||||
:- mode code_util__goal_may_alloc_temp_frame(in) is semidet.
|
||||
|
||||
% Negate a condition.
|
||||
% This is used mostly just to make the generated code more readable.
|
||||
|
||||
@@ -445,52 +448,160 @@ code_util__compiler_generated(PredInfo) :-
|
||||
|
||||
%-----------------------------------------------------------------------------%
|
||||
|
||||
% This code may _look_ nondeterministic, but it's really semidet,
|
||||
% and Mercury is smart enough to know this.
|
||||
code_util__goal_may_allocate_heap(Goal) :-
|
||||
code_util__goal_may_allocate_heap(Goal, yes).
|
||||
|
||||
code_util__goal_may_allocate_heap(Goal - _GoalInfo) :-
|
||||
code_util__goal_may_allocate_heap_2(Goal).
|
||||
code_util__goal_list_may_allocate_heap(Goals) :-
|
||||
code_util__goal_list_may_allocate_heap(Goals, yes).
|
||||
|
||||
:- pred code_util__goal_may_allocate_heap_2(hlds_goal_expr).
|
||||
:- mode code_util__goal_may_allocate_heap_2(in) is semidet.
|
||||
:- pred code_util__goal_may_allocate_heap(hlds_goal::in, bool::out) is det.
|
||||
|
||||
code_util__goal_may_allocate_heap_2(generic_call(_, _, _, _)).
|
||||
code_util__goal_may_allocate_heap_2(call(_, _, _, Builtin, _, _)) :-
|
||||
Builtin \= inline_builtin.
|
||||
code_util__goal_may_allocate_heap_2(
|
||||
unify(_, _, _, construct(_,_,Args,_,_,_,_), _)) :-
|
||||
Args = [_|_].
|
||||
code_util__goal_may_allocate_heap_2(some(_Vars, _, Goal)) :-
|
||||
code_util__goal_may_allocate_heap(Goal).
|
||||
code_util__goal_may_allocate_heap_2(not(Goal)) :-
|
||||
code_util__goal_may_allocate_heap(Goal).
|
||||
code_util__goal_may_allocate_heap_2(conj(Goals)) :-
|
||||
code_util__goal_list_may_allocate_heap(Goals).
|
||||
code_util__goal_may_allocate_heap_2(disj(Goals, _)) :-
|
||||
code_util__goal_list_may_allocate_heap(Goals).
|
||||
code_util__goal_may_allocate_heap_2(switch(_Var, _Det, Cases, _)) :-
|
||||
code_util__cases_may_allocate_heap(Cases).
|
||||
code_util__goal_may_allocate_heap_2(if_then_else(_Vars, A, B, C, _)) :-
|
||||
(
|
||||
code_util__goal_may_allocate_heap(A)
|
||||
;
|
||||
code_util__goal_may_allocate_heap(B)
|
||||
code_util__goal_may_allocate_heap(Goal - _GoalInfo, May) :-
|
||||
code_util__goal_may_allocate_heap_2(Goal, May).
|
||||
|
||||
:- pred code_util__goal_may_allocate_heap_2(hlds_goal_expr::in, bool::out)
|
||||
is det.
|
||||
|
||||
code_util__goal_may_allocate_heap_2(generic_call(_, _, _, _), yes).
|
||||
code_util__goal_may_allocate_heap_2(call(_, _, _, Builtin, _, _), May) :-
|
||||
( Builtin = inline_builtin ->
|
||||
May = no
|
||||
;
|
||||
code_util__goal_may_allocate_heap(C)
|
||||
May = yes
|
||||
).
|
||||
code_util__goal_may_allocate_heap_2(unify(_, _, _, Unification, _), May) :-
|
||||
( Unification = construct(_,_,Args,_,_,_,_), Args = [_|_] ->
|
||||
May = yes
|
||||
;
|
||||
May = no
|
||||
).
|
||||
% We cannot safely say that a C code fragment does not allocate memory
|
||||
% without knowing all the #defined macros that expand to incr_hp and
|
||||
% variants thereof.
|
||||
code_util__goal_may_allocate_heap_2(pragma_foreign_code(_,_,_,_,_,_,_,_), yes).
|
||||
code_util__goal_may_allocate_heap_2(some(_Vars, _, Goal), May) :-
|
||||
code_util__goal_may_allocate_heap(Goal, May).
|
||||
code_util__goal_may_allocate_heap_2(not(Goal), May) :-
|
||||
code_util__goal_may_allocate_heap(Goal, May).
|
||||
code_util__goal_may_allocate_heap_2(conj(Goals), May) :-
|
||||
code_util__goal_list_may_allocate_heap(Goals, May).
|
||||
code_util__goal_may_allocate_heap_2(par_conj(_, _), yes).
|
||||
code_util__goal_may_allocate_heap_2(disj(Goals, _), May) :-
|
||||
code_util__goal_list_may_allocate_heap(Goals, May).
|
||||
code_util__goal_may_allocate_heap_2(switch(_Var, _Det, Cases, _), May) :-
|
||||
code_util__cases_may_allocate_heap(Cases, May).
|
||||
code_util__goal_may_allocate_heap_2(if_then_else(_Vars, C, T, E, _), May) :-
|
||||
( code_util__goal_may_allocate_heap(C, yes) ->
|
||||
May = yes
|
||||
; code_util__goal_may_allocate_heap(T, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_may_allocate_heap(E, May)
|
||||
).
|
||||
code_util__goal_may_allocate_heap_2(bi_implication(G1, G2), May) :-
|
||||
( code_util__goal_may_allocate_heap(G1, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_may_allocate_heap(G2, May)
|
||||
).
|
||||
|
||||
:- pred code_util__cases_may_allocate_heap(list(case)).
|
||||
:- mode code_util__cases_may_allocate_heap(in) is semidet.
|
||||
:- pred code_util__goal_list_may_allocate_heap(list(hlds_goal)::in, bool::out)
|
||||
is det.
|
||||
|
||||
code_util__cases_may_allocate_heap([case(_, Goal) | _]) :-
|
||||
code_util__goal_may_allocate_heap(Goal).
|
||||
code_util__cases_may_allocate_heap([_ | Cases]) :-
|
||||
code_util__cases_may_allocate_heap(Cases).
|
||||
code_util__goal_list_may_allocate_heap([], no).
|
||||
code_util__goal_list_may_allocate_heap([Goal | Goals], May) :-
|
||||
( code_util__goal_may_allocate_heap(Goal, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_list_may_allocate_heap(Goals, May)
|
||||
).
|
||||
|
||||
code_util__goal_list_may_allocate_heap([Goal | _]) :-
|
||||
code_util__goal_may_allocate_heap(Goal).
|
||||
code_util__goal_list_may_allocate_heap([_ | Goals]) :-
|
||||
code_util__goal_list_may_allocate_heap(Goals).
|
||||
:- pred code_util__cases_may_allocate_heap(list(case)::in, bool::out) is det.
|
||||
|
||||
code_util__cases_may_allocate_heap([], no).
|
||||
code_util__cases_may_allocate_heap([case(_, Goal) | Cases], May) :-
|
||||
( code_util__goal_may_allocate_heap(Goal, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__cases_may_allocate_heap(Cases, May)
|
||||
).
|
||||
|
||||
%-----------------------------------------------------------------------------%
|
||||
|
||||
code_util__goal_may_alloc_temp_frame(Goal) :-
|
||||
code_util__goal_may_alloc_temp_frame(Goal, yes).
|
||||
|
||||
:- pred code_util__goal_may_alloc_temp_frame(hlds_goal::in, bool::out) is det.
|
||||
|
||||
code_util__goal_may_alloc_temp_frame(Goal - _GoalInfo, May) :-
|
||||
code_util__goal_may_alloc_temp_frame_2(Goal, May).
|
||||
|
||||
:- pred code_util__goal_may_alloc_temp_frame_2(hlds_goal_expr::in, bool::out)
|
||||
is det.
|
||||
|
||||
code_util__goal_may_alloc_temp_frame_2(generic_call(_, _, _, _), no).
|
||||
code_util__goal_may_alloc_temp_frame_2(call(_, _, _, _, _, _), no).
|
||||
code_util__goal_may_alloc_temp_frame_2(unify(_, _, _, _, _), no).
|
||||
% We cannot safely say that a C code fragment does not allocate
|
||||
% temporary nondet frames without knowing all the #defined macros
|
||||
% that expand to mktempframe and variants thereof. The performance
|
||||
% impact of being too conservative is probably not too bad.
|
||||
code_util__goal_may_alloc_temp_frame_2(pragma_foreign_code(_,_,_,_,_,_,_,_),
|
||||
yes).
|
||||
code_util__goal_may_alloc_temp_frame_2(some(_Vars, _, Goal), May) :-
|
||||
Goal = _ - GoalInfo,
|
||||
goal_info_get_code_model(GoalInfo, CodeModel),
|
||||
( CodeModel = model_non ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_may_alloc_temp_frame(Goal, May)
|
||||
).
|
||||
code_util__goal_may_alloc_temp_frame_2(not(Goal), May) :-
|
||||
code_util__goal_may_alloc_temp_frame(Goal, May).
|
||||
code_util__goal_may_alloc_temp_frame_2(conj(Goals), May) :-
|
||||
code_util__goal_list_may_alloc_temp_frame(Goals, May).
|
||||
code_util__goal_may_alloc_temp_frame_2(par_conj(Goals, _), May) :-
|
||||
code_util__goal_list_may_alloc_temp_frame(Goals, May).
|
||||
code_util__goal_may_alloc_temp_frame_2(disj(Goals, _), May) :-
|
||||
code_util__goal_list_may_alloc_temp_frame(Goals, May).
|
||||
code_util__goal_may_alloc_temp_frame_2(switch(_Var, _Det, Cases, _), May) :-
|
||||
code_util__cases_may_alloc_temp_frame(Cases, May).
|
||||
code_util__goal_may_alloc_temp_frame_2(if_then_else(_Vars, C, T, E, _), May) :-
|
||||
( code_util__goal_may_alloc_temp_frame(C, yes) ->
|
||||
May = yes
|
||||
; code_util__goal_may_alloc_temp_frame(T, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_may_alloc_temp_frame(E, May)
|
||||
).
|
||||
code_util__goal_may_alloc_temp_frame_2(bi_implication(G1, G2), May) :-
|
||||
( code_util__goal_may_alloc_temp_frame(G1, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_may_alloc_temp_frame(G2, May)
|
||||
).
|
||||
|
||||
:- pred code_util__goal_list_may_alloc_temp_frame(list(hlds_goal)::in,
|
||||
bool::out) is det.
|
||||
|
||||
code_util__goal_list_may_alloc_temp_frame([], no).
|
||||
code_util__goal_list_may_alloc_temp_frame([Goal | Goals], May) :-
|
||||
( code_util__goal_may_alloc_temp_frame(Goal, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__goal_list_may_alloc_temp_frame(Goals, May)
|
||||
).
|
||||
|
||||
:- pred code_util__cases_may_alloc_temp_frame(list(case)::in, bool::out)
|
||||
is det.
|
||||
|
||||
code_util__cases_may_alloc_temp_frame([], no).
|
||||
code_util__cases_may_alloc_temp_frame([case(_, Goal) | Cases], May) :-
|
||||
( code_util__goal_may_alloc_temp_frame(Goal, yes) ->
|
||||
May = yes
|
||||
;
|
||||
code_util__cases_may_alloc_temp_frame(Cases, May)
|
||||
).
|
||||
|
||||
%-----------------------------------------------------------------------------%
|
||||
|
||||
|
||||
Reference in New Issue
Block a user