mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-19 15:54:18 +00:00
Code Issues Projects Releases Wiki Activity
Files
b43968c2fe7ec4ab5c1ec6d924f2e786fab1a07f
mercury/compiler/unique_modes.m
Zoltan Somogyi 8b8b3b7d3f Replace the some() HLDS goal with a more general scope() goal, which can be 
Estimated hours taken: 12
Branches: main

Replace the some() HLDS goal with a more general scope() goal, which can be
used not just for existential quantification but also for other purposes.

The main such purposes are new goal types that allow the programmer
to annotate arbitrary goals, and not just whole procedure bodies, with the
equivalents of promise_pure/promise_semipure and promise_only_solution:

	promise_pure ( <impure/semipure goal> )
	promise_semipure ( <impure goal> )

	promise_equivalent_solutions [OutVar1, OutVar2] (
		<cc_multi/cc_nondet goal that computed OutVar1 & OutVar2>
	)

Both are intended to be helpful in writing constraint solvers, as well as in
other situations.

doc/reference_manual.texi:
	Document the new constructs.

library/ops.m:
	Add the keywords of the new constructs to the list of operators.
	Since they work similarly to the "some" operator, they have the same
	precedence.

compiler/hlds_goal.m:
	Replace the some(Vars, SubGoal) HLDS construct, with its optional
	keep_this_commit attribute, with the new scope(Reason, SubGoal)
	construct. The Reason argument may say that this scope is an
	existential quantification, but it can also say that it represents
	a purity promise, the introduction of a single-solution context
	with promise_equivalent_solutions, or a decision by a compiler pass.

	It can also say that the scope represents a set of goals that all arise
	from the unraveling of a unification between a variable and a ground
	term. This was intended to speed up mode checking by significantly
	reducing the number of delays and wakeups, but the cost of the scopes
	themselves turned out to be bigger than the gain in modechecking speed.

	Update the goal_path_step type to refer to scope goals instead of just
	existential quantification.

compiler/prog_data.m:
	Add new function symbols to the type we use to represent goals in items
	to stand for the new Mercury constructs.

compiler/prog_io_goal.m:
	Add code to read in the new language constructs.

compiler/prog_io_util.m:
	Add a utility predicate for use by the new code in prog_io_goal.m.

compiler/make_hlds.m:
	Convert the item representation of the new constructs to the HLDS
	representation.

	Document how the from_ground_term scope reason would work, but do not
	enable the code.

compiler/purity.m:
	When checking the purity of goals, respect the new promise_pure and
	promise_semipure scopes. Generate warnings if such scopes are
	redundant.

compiler/det_analysis.m:
	Make the insides of promise_equivalent_solutions goals single solution
	contexts.

compiler/det_report.m:
	Provide mechanisms for reporting inappropriate usage of
	promise_equivalent_solutions goals.

compiler/instmap.m:
	Add a utility predicate for use by one of the modules above.

compiler/deep_profiling.m:
	Use one of the new scope reasons to prevent simplify from optimizing
	away commits of goals that have been made impure, instead of the old
	keep_this_commit goal feature.

compiler/modes.m:
	Handle from_ground_term scopes when present; for now, they won't be
	present, since make_hlds isn't creating them.

compiler/options.m:
	Add two new compiler options, for use by implementors only, to allow
	finer control over the amount of output one gets with --debug-modes.
	(I used them when debugging the performance of the from_ground_term
	scope reason.) The options are --debug-modes-minimal and
	--debug-modes-verbose.

compiler/handle_options.m:
	Make the options that are meaningful only in the presence of
	--debug-modes imply --debug-modes, since this allows more convenient
	(shorter) invocations.

compiler/mode_debug.m:
	Respect the new options when deciding how much data to print
	when debugging of the mode checking process is enabled.

compiler/switch_detect.m:
	Rename a predicate to make it differ from another predicate by more
	than just its arity.

compiler/passes_aux.m:
	Bring this module up to date with our current style guidelines,
	by using state variable syntax where appropriate.

compiler/*.m:
	Minor changes to conform to the change in the HLDS and/or parse tree
	goal type.

mdbcomp/program_representation.m:
	Rename the some goal to the scope goal, and the same for path steps,
	to keep them in sync with the HLDS.

browser/declarative_tree.m:
	Conform to the change in goal representations.

tests/hard_coded/promise_equivalent_solutions_test.{m,exp}:
	A new test case to test the handling of the
	promise_equivalent_solutions construct.

tests/hard_coded/Mmakefile:
	Enable the new test.

tests/hard_coded/purity/promise_pure_test.{m,exp}:
	A new test case to test the handling of the promise_pure and
	promise_semipure constructs.

tests/hard_coded/purity/Mmakefile:
	Enable the new test.

tests/invalid/promise_equivalent_solutions.{m,err_exp}:
	A new test case to test the error messages for improper use of the
	promise_pure and promise_semipure constructs.

tests/invalid/Mmakefile:
	Enable the new test.
2005-03-24 05:34:41 +00:00

851 lines
30 KiB
Mathematica
Raw Blame History

%-----------------------------------------------------------------------------%
% Copyright (C) 1996-2005 The University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%-----------------------------------------------------------------------------%
% file: unique_modes.m
% main author: fjh
% This module checks that variables with a unique mode (as opposed to
% a mostly-unique mode) really are unique, and not nondet live - i.e.,
% that they cannot be referenced on backtracking.
% (Actually the term "nondet live" is a bit of a misnomer, because
% really we are just interested in whether something can be referenced
% on backtracking, and this can occur after backtracking in semidet
% code too, not just in nondet code.)
% Basically we just traverse each goal, keeping track of which variables
% are nondet live. At each procedure call, we check that any arguments
% whose initial insts are required to be unique are not nondet live.
% If they are, we first try selecting a different mode of the same
% predicate, and if that fails, then we report an error message.
% Variables can become nondet live in several places:
% in negations, in the conditions of if-then-elses,
% in disjunctions, and at nondet calls.
% These are the only places at which we can resume execution
% after backtracking.
% XXX we currently make the conservative assumption that
% any non-local variable in a disjunction or nondet call
% is nondet-live - and stays nondet-live.
%-----------------------------------------------------------------------------%
:- module check_hlds__unique_modes.
:- interface.
:- import_module check_hlds__mode_info.
:- import_module hlds__hlds_goal.
:- import_module hlds__hlds_module.
:- import_module hlds__hlds_pred.
:- import_module bool.
:- import_module io.
% check every predicate in a module
:- pred unique_modes__check_module(module_info::in, module_info::out,
io::di, io::uo) is det.
% just check a single procedure
:- pred unique_modes__check_proc(proc_id::in, pred_id::in, module_info::in,
module_info::out, bool::out, io::di, io::uo) is det.
% just check a single goal
:- pred unique_modes__check_goal(hlds_goal::in, hlds_goal::out,
mode_info::in, mode_info::out, io::di, io::uo) is det.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- implementation.
:- import_module check_hlds__inst_match.
:- import_module check_hlds__inst_util.
:- import_module check_hlds__mode_debug.
:- import_module check_hlds__mode_errors.
:- import_module check_hlds__mode_util.
:- import_module check_hlds__modecheck_call.
:- import_module check_hlds__modecheck_unify.
:- import_module check_hlds__modes.
:- import_module check_hlds__unify_proc.
:- import_module hlds__hlds_data.
:- import_module hlds__hlds_out.
:- import_module hlds__instmap.
:- import_module hlds__passes_aux.
:- import_module parse_tree__mercury_to_mercury.
:- import_module parse_tree__prog_data.
:- import_module parse_tree__prog_mode.
:- import_module parse_tree__prog_out.
:- import_module mdbcomp__prim_data.
:- import_module assoc_list.
:- import_module bag.
:- import_module int.
:- import_module list.
:- import_module map.
:- import_module require.
:- import_module set.
:- import_module std_util.
:- import_module string.
:- import_module term.
:- import_module varset.
%-----------------------------------------------------------------------------%
unique_modes__check_module(!ModuleInfo, !IO) :-
check_pred_modes(check_unique_modes, may_change_called_proc,
!ModuleInfo, _UnsafeToContinue, !IO).
unique_modes__check_proc(ProcId, PredId, !ModuleInfo, Changed, !IO) :-
modecheck_proc(ProcId, PredId, check_unique_modes,
may_change_called_proc, !ModuleInfo, NumErrors, Changed, !IO),
( NumErrors \= 0 ->
io__set_exit_status(1, !IO)
;
true
).
% XXX we currently make the conservative assumption that
% any non-local variable in a disjunction or nondet call
% is nondet-live - and stays nondet-live.
unique_modes__check_goal(Goal0, Goal, !ModeInfo, !IO) :-
%
% store the current context in the mode_info
%
Goal0 = GoalExpr0 - GoalInfo0,
goal_info_get_context(GoalInfo0, Context),
term__context_init(EmptyContext),
( Context = EmptyContext ->
true
;
mode_info_set_context(Context, !ModeInfo)
),
%
% Grab the original instmap
%
mode_info_get_instmap(!.ModeInfo, InstMap0),
%
% Grab the original bag of nondet-live vars
%
mode_info_get_nondet_live_vars(!.ModeInfo, NondetLiveVars0),
%
% If the goal is not nondet, then nothing is nondet-live,
% so reset the bag of nondet-live vars to be empty.
%
goal_info_get_determinism(GoalInfo0, Detism),
( determinism_components(Detism, _, at_most_many) ->
true
;
mode_info_set_nondet_live_vars(bag__init, !ModeInfo)
),
%
% Modecheck the goal
%
unique_modes__check_goal_2(GoalExpr0, GoalInfo0, GoalExpr,
!ModeInfo, !IO),
%
% Restore the original bag of nondet-live vars
%
mode_info_set_nondet_live_vars(NondetLiveVars0, !ModeInfo),
%
% Grab the final instmap, compute the change in insts
% over this goal, and save that instmap_delta in the goal_info.
%
compute_goal_instmap_delta(InstMap0, GoalExpr, GoalInfo0, GoalInfo,
!ModeInfo),
Goal = GoalExpr - GoalInfo.
% Make all nondet-live variables whose current inst
% is `unique' become `mostly_unique'.
%
:- pred make_all_nondet_live_vars_mostly_uniq(mode_info::in, mode_info::out)
is det.
make_all_nondet_live_vars_mostly_uniq(ModeInfo0, ModeInfo) :-
mode_info_get_instmap(ModeInfo0, FullInstMap0),
( instmap__is_reachable(FullInstMap0) ->
instmap__vars_list(FullInstMap0, AllVars),
select_nondet_live_vars(AllVars, ModeInfo0, NondetLiveVars),
make_var_list_mostly_uniq(NondetLiveVars, ModeInfo0, ModeInfo)
;
ModeInfo = ModeInfo0
).
:- pred select_live_vars(list(prog_var)::in, mode_info::in,
list(prog_var)::out) is det.
select_live_vars([], _, []).
select_live_vars([Var|Vars], ModeInfo, LiveVars) :-
( mode_info_var_is_live(ModeInfo, Var, live) ->
LiveVars = [Var | LiveVars1],
select_live_vars(Vars, ModeInfo, LiveVars1)
;
select_live_vars(Vars, ModeInfo, LiveVars)
).
:- pred select_nondet_live_vars(list(prog_var)::in, mode_info::in,
list(prog_var)::out) is det.
select_nondet_live_vars([], _, []).
select_nondet_live_vars([Var|Vars], ModeInfo, NondetLiveVars) :-
( mode_info_var_is_nondet_live(ModeInfo, Var, live) ->
NondetLiveVars = [Var | NondetLiveVars1],
select_nondet_live_vars(Vars, ModeInfo, NondetLiveVars1)
;
select_nondet_live_vars(Vars, ModeInfo, NondetLiveVars)
).
% Given a list of variables, a delta instmap, and a mode_info,
% select all the variables whose inst changed in the delta instmap
% (other than changes which just add information,
% e.g. `ground -> bound(42)'.)
%
:- pred select_changed_inst_vars(list(prog_var)::in, instmap_delta::in,
mode_info::in, list(prog_var)::out) is det.
select_changed_inst_vars([], _DeltaInstMap, _ModeInfo, []).
select_changed_inst_vars([Var | Vars], DeltaInstMap, ModeInfo, ChangedVars) :-
mode_info_get_module_info(ModeInfo, ModuleInfo),
mode_info_get_instmap(ModeInfo, InstMap0),
instmap__lookup_var(InstMap0, Var, Inst0),
mode_info_get_var_types(ModeInfo, VarTypes),
map__lookup(VarTypes, Var, Type),
(
instmap_delta_is_reachable(DeltaInstMap),
instmap_delta_search_var(DeltaInstMap, Var, Inst),
\+ inst_matches_final(Inst, Inst0, Type, ModuleInfo)
->
ChangedVars = [Var | ChangedVars1],
select_changed_inst_vars(Vars, DeltaInstMap, ModeInfo,
ChangedVars1)
;
select_changed_inst_vars(Vars, DeltaInstMap, ModeInfo,
ChangedVars)
).
:- pred make_var_list_mostly_uniq(list(prog_var)::in,
mode_info::in, mode_info::out) is det.
make_var_list_mostly_uniq([], !ModeInfo).
make_var_list_mostly_uniq([Var | Vars], !ModeInfo) :-
make_var_mostly_uniq(Var, !ModeInfo),
make_var_list_mostly_uniq(Vars, !ModeInfo).
:- pred make_var_mostly_uniq(prog_var::in,
mode_info::in, mode_info::out) is det.
make_var_mostly_uniq(Var, !ModeInfo) :-
mode_info_get_instmap(!.ModeInfo, InstMap0),
mode_info_get_module_info(!.ModeInfo, ModuleInfo0),
(
%
% only variables which are `unique' need to be changed
%
instmap__is_reachable(InstMap0),
instmap__vars_list(InstMap0, Vars),
list__member(Var, Vars),
instmap__lookup_var(InstMap0, Var, Inst0),
inst_expand(ModuleInfo0, Inst0, Inst1),
( Inst1 = ground(unique, _)
; Inst1 = bound(unique, _)
; Inst1 = any(unique)
)
->
make_mostly_uniq_inst(Inst0, Inst, ModuleInfo0, ModuleInfo),
mode_info_set_module_info(ModuleInfo, !ModeInfo),
instmap__set(InstMap0, Var, Inst, InstMap),
mode_info_set_instmap(InstMap, !ModeInfo)
;
true
).
:- pred unique_modes__check_goal_2(hlds_goal_expr::in, hlds_goal_info::in,
hlds_goal_expr::out, mode_info::in, mode_info::out,
io::di, io::uo) is det.
unique_modes__check_goal_2(conj(List0), _GoalInfo0, conj(List), !ModeInfo,
!IO) :-
mode_checkpoint(enter, "conj", !ModeInfo, !IO),
( List0 = [] -> % for efficiency, optimize common case
List = []
;
mode_info_add_goals_live_vars(List0, !ModeInfo),
unique_modes__check_conj(List0, List, !ModeInfo, !IO)
),
mode_checkpoint(exit, "conj", !ModeInfo, !IO).
unique_modes__check_goal_2(par_conj(List0), GoalInfo0, par_conj(List),
!ModeInfo, !IO) :-
mode_checkpoint(enter, "par_conj", !ModeInfo, !IO),
goal_info_get_nonlocals(GoalInfo0, NonLocals),
mode_info_add_live_vars(NonLocals, !ModeInfo),
% Build a multiset of the nonlocals of the conjuncts
% so that we can figure out which variables must be
% made shared at the start of the parallel conjunction.
make_par_conj_nonlocal_multiset(List0, NonLocalsBag),
unique_modes__check_par_conj(List0, NonLocalsBag, List, InstMapList,
!ModeInfo, !IO),
instmap__unify(NonLocals, InstMapList, !ModeInfo),
mode_info_remove_live_vars(NonLocals, !ModeInfo),
mode_checkpoint(exit, "par_conj", !ModeInfo, !IO).
unique_modes__check_goal_2(disj(List0), GoalInfo0, disj(List), !ModeInfo,
!IO) :-
mode_checkpoint(enter, "disj", !ModeInfo, !IO),
( List0 = [] ->
List = [],
instmap__init_unreachable(InstMap),
mode_info_set_instmap(InstMap, !ModeInfo)
;
%
% If the disjunction creates a choice point (i.e. is model_non),
% then mark all the variables which are live at the
% start of the disjunction and whose inst is `unique'
% as instead being only `mostly_unique', since those variables
% may be needed again after we backtrack to that choice point
% and resume forward execution again.
%
% Note: for model_det or model_semi disjunctions,
% we may do some "shallow" backtracking from semidet
% disjuncts. But we handle that seperately for each
% disjunct, in unique_modes__check_disj.
%
goal_info_get_nonlocals(GoalInfo0, NonLocals),
goal_info_get_determinism(GoalInfo0, Determinism),
% does this disjunction create a choice point?
( determinism_components(Determinism, _, at_most_many) ->
mode_info_add_live_vars(NonLocals, !ModeInfo),
make_all_nondet_live_vars_mostly_uniq(!ModeInfo),
mode_info_remove_live_vars(NonLocals, !ModeInfo)
;
true
),
%
% Now just modecheck each disjunct in turn, and then
% merge the resulting instmaps.
%
unique_modes__check_disj(List0, Determinism, NonLocals,
List, InstMapList, !ModeInfo, !IO),
instmap__merge(NonLocals, InstMapList, disj, !ModeInfo)
),
mode_checkpoint(exit, "disj", !ModeInfo, !IO).
unique_modes__check_goal_2(if_then_else(Vars, Cond0, Then0, Else0), GoalInfo0,
Goal, !ModeInfo, !IO) :-
mode_checkpoint(enter, "if-then-else", !ModeInfo, !IO),
goal_info_get_nonlocals(GoalInfo0, NonLocals),
goal_get_nonlocals(Cond0, Cond_Vars),
goal_get_nonlocals(Then0, Then_Vars),
goal_get_nonlocals(Else0, Else_Vars),
mode_info_get_instmap(!.ModeInfo, InstMap0),
mode_info_lock_vars(if_then_else, NonLocals, !ModeInfo),
%
% At this point, we should set the inst of any `unique'
% variables which occur in the condition and which
% are live to `mostly_unique'. However, if a variable's
% inst was unchanged over the condition (i.e. it remains
% `unique' on exit from the condition), then it is
% safe to leave it as `unique' on entry to the condition.
% The only case we need to set it to `mostly_unique' is
% if the condition would clobber it.
%
% XXX actually that is not true; the code below does
% the wrong thing for examples such as this one:
%
% :- mode p(di).
% p(Var) :-
% (if
% (if semidet_succeed then
% clobber(Var), fail
% else
% true
% )
% then
% blah
% else
% use(Var)
% ).
%
mode_info_add_live_vars(Else_Vars, !ModeInfo),
set__to_sorted_list(Cond_Vars, Cond_Vars_List),
select_live_vars(Cond_Vars_List, !.ModeInfo, Cond_Live_Vars),
Cond0 = _ - Cond0_GoalInfo,
goal_info_get_instmap_delta(Cond0_GoalInfo, Cond0_DeltaInstMap),
select_changed_inst_vars(Cond_Live_Vars, Cond0_DeltaInstMap,
!.ModeInfo, ChangedVars),
make_var_list_mostly_uniq(ChangedVars, !ModeInfo),
mode_info_remove_live_vars(Else_Vars, !ModeInfo),
mode_info_add_live_vars(Then_Vars, !ModeInfo),
unique_modes__check_goal(Cond0, Cond, !ModeInfo, !IO),
mode_info_remove_live_vars(Then_Vars, !ModeInfo),
mode_info_unlock_vars(if_then_else, NonLocals, !ModeInfo),
mode_info_get_instmap(!.ModeInfo, InstMapCond),
( instmap__is_reachable(InstMapCond) ->
unique_modes__check_goal(Then0, Then, !ModeInfo, !IO),
mode_info_get_instmap(!.ModeInfo, InstMapThen)
;
% We should not mode-analyse the goal, since it is unreachable.
% Instead we optimize the goal away, so that later passes
% won't complain about it not having unique mode information.
true_goal(Then),
InstMapThen = InstMapCond
),
mode_info_set_instmap(InstMap0, !ModeInfo),
unique_modes__check_goal(Else0, Else, !ModeInfo, !IO),
mode_info_get_instmap(!.ModeInfo, InstMapElse),
mode_info_set_instmap(InstMap0, !ModeInfo),
instmap__merge(NonLocals, [InstMapThen, InstMapElse], if_then_else,
!ModeInfo),
Goal = if_then_else(Vars, Cond, Then, Else),
mode_checkpoint(exit, "if-then-else", !ModeInfo, !IO).
unique_modes__check_goal_2(not(SubGoal0), GoalInfo0, not(SubGoal),
!ModeInfo, !IO) :-
mode_checkpoint(enter, "not", !ModeInfo, !IO),
mode_info_get_instmap(!.ModeInfo, InstMap0),
%
% We need to mark all the variables which are live
% after the negation as nondet-live for the negated
% goal, since if the negated goal fails, then the
% negation will succeed, and so these variables
% can be accessed again after backtracking.
%
goal_info_get_nonlocals(GoalInfo0, NonLocals),
set__to_sorted_list(NonLocals, NonLocalsList),
select_live_vars(NonLocalsList, !.ModeInfo, LiveNonLocals),
make_var_list_mostly_uniq(LiveNonLocals, !ModeInfo),
%
% But nothing is forward-live for the negated goal, since
% if the goal succeeds then execution will immediately backtrack.
% So we need to set the live variables set to empty here.
%
mode_info_get_live_vars(!.ModeInfo, LiveVars0),
mode_info_set_live_vars(bag__init, !ModeInfo),
%
% We need to lock the non-local variables, to ensure
% that the negation does not bind them.
%
mode_info_lock_vars(negation, NonLocals, !ModeInfo),
unique_modes__check_goal(SubGoal0, SubGoal, !ModeInfo, !IO),
mode_info_unlock_vars(negation, NonLocals, !ModeInfo),
mode_info_set_live_vars(LiveVars0, !ModeInfo),
mode_info_set_instmap(InstMap0, !ModeInfo),
mode_checkpoint(exit, "not", !ModeInfo, !IO).
unique_modes__check_goal_2(scope(Reason, SubGoal0), _,
scope(Reason, SubGoal), !ModeInfo, !IO) :-
mode_checkpoint(enter, "some", !ModeInfo, !IO),
unique_modes__check_goal(SubGoal0, SubGoal, !ModeInfo, !IO),
mode_checkpoint(exit, "some", !ModeInfo, !IO).
unique_modes__check_goal_2(generic_call(GenericCall, Args, Modes, Det),
_GoalInfo0, Goal, !ModeInfo, !IO) :-
mode_checkpoint(enter, "generic_call", !ModeInfo, !IO),
hlds_goal__generic_call_id(GenericCall, CallId),
mode_info_set_call_context(call(CallId), !ModeInfo),
( determinism_components(Det, _, at_most_zero) ->
NeverSucceeds = yes
;
NeverSucceeds = no
),
(
GenericCall = higher_order(_, _, _, _),
ArgOffset = 1
;
% Class method calls are introduced by the compiler
% and should be mode correct.
GenericCall = class_method(_, _, _, _),
ArgOffset = 0
;
% Casts are introduced by the compiler
% and should be mode correct.
GenericCall = unsafe_cast,
ArgOffset = 0
;
GenericCall = aditi_builtin(_, _),
ArgOffset = 0
),
unique_modes__check_call_modes(Args, Modes, ArgOffset, Det,
NeverSucceeds, !ModeInfo),
Goal = generic_call(GenericCall, Args, Modes, Det),
mode_info_unset_call_context(!ModeInfo),
mode_checkpoint(exit, "generic_call", !ModeInfo, !IO).
unique_modes__check_goal_2(call(PredId, ProcId0, Args, Builtin, CallContext,
PredName), _GoalInfo0, Goal, !ModeInfo, !IO) :-
mdbcomp__prim_data__sym_name_to_string(PredName, PredNameString),
string__append("call ", PredNameString, CallString),
mode_checkpoint(enter, CallString, !ModeInfo, !IO),
mode_info_get_call_id(!.ModeInfo, PredId, CallId),
mode_info_set_call_context(call(call(CallId)), !ModeInfo),
unique_modes__check_call(PredId, ProcId0, Args, ProcId, !ModeInfo),
Goal = call(PredId, ProcId, Args, Builtin, CallContext, PredName),
mode_info_unset_call_context(!ModeInfo),
mode_checkpoint(exit, "call", !ModeInfo, !IO).
unique_modes__check_goal_2(unify(LHS0, RHS0, _, UnifyInfo0, UnifyContext),
GoalInfo0, Goal, !ModeInfo, !IO) :-
mode_checkpoint(enter, "unify", !ModeInfo, !IO),
mode_info_set_call_context(unify(UnifyContext), !ModeInfo),
modecheck_unification(LHS0, RHS0, UnifyInfo0, UnifyContext, GoalInfo0,
Goal, !ModeInfo, !IO),
mode_info_unset_call_context(!ModeInfo),
mode_checkpoint(exit, "unify", !ModeInfo, !IO).
unique_modes__check_goal_2(switch(Var, CanFail, Cases0), GoalInfo0,
switch(Var, CanFail, Cases), !ModeInfo, !IO) :-
mode_checkpoint(enter, "switch", !ModeInfo, !IO),
( Cases0 = [] ->
Cases = [],
instmap__init_unreachable(InstMap),
mode_info_set_instmap(InstMap, !ModeInfo)
;
goal_info_get_nonlocals(GoalInfo0, NonLocals),
unique_modes__check_case_list(Cases0, Var, Cases, InstMapList,
!ModeInfo, !IO),
instmap__merge(NonLocals, InstMapList, disj, !ModeInfo)
),
mode_checkpoint(exit, "switch", !ModeInfo, !IO).
% to modecheck a pragma_c_code, we just modecheck the proc for
% which it is the goal.
unique_modes__check_goal_2(foreign_proc(Attributes, PredId, ProcId0,
Args, ExtraArgs, PragmaCode),
_GoalInfo, Goal, !ModeInfo, !IO) :-
mode_checkpoint(enter, "foreign_proc", !ModeInfo, !IO),
mode_info_get_call_id(!.ModeInfo, PredId, CallId),
mode_info_set_call_context(call(call(CallId)), !ModeInfo),
ArgVars = list__map(foreign_arg_var, Args),
unique_modes__check_call(PredId, ProcId0, ArgVars, ProcId, !ModeInfo),
Goal = foreign_proc(Attributes, PredId, ProcId, Args, ExtraArgs,
PragmaCode),
mode_info_unset_call_context(!ModeInfo),
mode_checkpoint(exit, "foreign_proc", !ModeInfo, !IO).
unique_modes__check_goal_2(shorthand(_), _, _, !ModeInfo, !IO) :-
% these should have been expanded out by now
error("unique_modes__check_goal_2: unexpected shorthand").
:- pred unique_modes__check_call(pred_id::in, proc_id::in, list(prog_var)::in,
proc_id::out, mode_info::in, mode_info::out) is det.
unique_modes__check_call(PredId, ProcId0, ArgVars, ProcId, !ModeInfo) :-
%
% set the error list to empty for use below
% (saving the old error list and instmap in variables)
%
mode_info_get_errors(!.ModeInfo, OldErrors),
mode_info_get_instmap(!.ModeInfo, InstMap0),
mode_info_set_errors([], !ModeInfo),
%
% first off, try using the existing mode
%
mode_info_get_module_info(!.ModeInfo, ModuleInfo),
module_info_pred_proc_info(ModuleInfo, PredId, ProcId0,
PredInfo, ProcInfo),
compute_arg_offset(PredInfo, ArgOffset),
proc_info_argmodes(ProcInfo, ProcArgModes0),
proc_info_interface_determinism(ProcInfo, InterfaceDeterminism),
proc_info_never_succeeds(ProcInfo, NeverSucceeds),
unique_modes__check_call_modes(ArgVars, ProcArgModes0, ArgOffset,
InterfaceDeterminism, NeverSucceeds, !ModeInfo),
( ProcInfo ^ mode_errors = [_|_] ->
% mode error in callee for this mode
WaitingVars = set__list_to_set(ArgVars),
mode_info_get_instmap(!.ModeInfo, InstMap),
instmap__lookup_vars(ArgVars, InstMap, ArgInsts),
mode_info_error(WaitingVars,
mode_error_in_callee(ArgVars, ArgInsts,
PredId, ProcId0,
ProcInfo ^ mode_errors),
!ModeInfo)
;
true
),
%
% see whether or not that worked
% (and restore the old error list)
%
mode_info_get_errors(!.ModeInfo, Errors),
mode_info_set_errors(OldErrors, !ModeInfo),
mode_info_get_may_change_called_proc(!.ModeInfo, MayChangeCalledProc),
( Errors = [] ->
ProcId = ProcId0
; MayChangeCalledProc = may_not_change_called_proc ->
% We're not allowed to try a different procedure
% here, so just return all the errors.
ProcId = ProcId0,
list__append(OldErrors, Errors, AllErrors),
mode_info_set_errors(AllErrors, !ModeInfo)
;
%
% If it didn't work, restore the original instmap,
% and then call modecheck_call_pred.
% That will try all the modes, and will infer
% new ones if necessary.
%
% We set the declared determinism for newly inferred
% modes to be the same as the determinism inferred for
% the existing mode selected by ordinary (non-unique)
% mode analysis. This means that determinism analysis
% will report an error if the determinism changes
% as a result of unique mode analysis. That is OK,
% because uniqueness should not affect determinism.
%
mode_info_set_instmap(InstMap0, !ModeInfo),
proc_info_inferred_determinism(ProcInfo, Determinism),
modecheck_call_pred(PredId, yes(Determinism), ProcId0, ProcId,
ArgVars, NewArgVars, ExtraGoals, !ModeInfo),
( NewArgVars = ArgVars, ExtraGoals = no_extra_goals ->
true
;
% this shouldn't happen, since modes.m should do
% all the handling of implied modes
% XXX it might happen, though, if the user
% XXX writes strange code; we should report
% XXX a proper error here
error("unique_modes.m: call to implied mode?")
)
).
% to check a call, we just look up the required initial insts
% for the arguments of the call, and then check for each
% argument if the variable is nondet-live and the required initial
% inst was unique.
:- pred unique_modes__check_call_modes(list(prog_var)::in, list(mode)::in,
int::in, determinism::in, bool::in, mode_info::in, mode_info::out)
is det.
unique_modes__check_call_modes(ArgVars, ProcArgModes, ArgOffset,
Determinism, NeverSucceeds, !ModeInfo) :-
mode_info_get_module_info(!.ModeInfo, ModuleInfo),
mode_list_get_initial_insts(ProcArgModes, ModuleInfo,
InitialInsts),
NeedExactMatch = no,
modecheck_var_has_inst_list(ArgVars, InitialInsts,
NeedExactMatch, ArgOffset, InstVarSub, !ModeInfo),
mode_list_get_final_insts(ProcArgModes, ModuleInfo, FinalInsts0),
inst_list_apply_substitution(FinalInsts0, InstVarSub, FinalInsts),
modecheck_set_var_inst_list(ArgVars, InitialInsts, FinalInsts,
ArgOffset, NewArgVars, ExtraGoals, !ModeInfo),
( NewArgVars = ArgVars, ExtraGoals = no_extra_goals ->
true
;
% this shouldn't happen, since modes.m should do
% all the handling of implied modes
error("unique_modes.m: call to implied mode?")
),
( NeverSucceeds = yes ->
instmap__init_unreachable(InstMap),
mode_info_set_instmap(InstMap, !ModeInfo)
;
%
% Check whether we are at a call to a nondet predicate.
% If so, mark all the currently nondet-live variables
% whose inst is `unique' as instead being only `mostly_unique'.
%
( determinism_components(Determinism, _, at_most_many) ->
make_all_nondet_live_vars_mostly_uniq(!ModeInfo)
;
true
)
).
%-----------------------------------------------------------------------------%
:- pred unique_modes__check_conj(list(hlds_goal)::in, list(hlds_goal)::out,
mode_info::in, mode_info::out, io::di, io::uo) is det.
% Just process each conjunct in turn.
% Note that we don't do any reordering of conjuncts here.
unique_modes__check_conj([], [], !ModeInfo, !IO).
unique_modes__check_conj([Goal0 | Goals0], [Goal | Goals], !ModeInfo, !IO) :-
goal_get_nonlocals(Goal0, NonLocals),
mode_info_remove_live_vars(NonLocals, !ModeInfo),
unique_modes__check_goal(Goal0, Goal, !ModeInfo, !IO),
mode_info_get_instmap(!.ModeInfo, InstMap),
( instmap__is_unreachable(InstMap) ->
% We should not mode-analyse the remaining goals, since they
% are unreachable. Instead we optimize them away, so that
% later passes won't complain about them not having
% unique mode information.
mode_info_remove_goals_live_vars(Goals0, !ModeInfo),
Goals = []
;
unique_modes__check_conj(Goals0, Goals, !ModeInfo, !IO)
).
%-----------------------------------------------------------------------------%
% make_par_conj_nonlocal_multiset builds a multiset (bag) of all
% the nonlocals of the conjuncts.
:- pred make_par_conj_nonlocal_multiset(list(hlds_goal)::in,
bag(prog_var)::out) is det.
make_par_conj_nonlocal_multiset([], Empty) :-
bag__init(Empty).
make_par_conj_nonlocal_multiset([Goal | Goals], NonLocalsMultiSet) :-
make_par_conj_nonlocal_multiset(Goals, NonLocalsMultiSet0),
goal_get_nonlocals(Goal, NonLocals),
set__to_sorted_list(NonLocals, NonLocalsList),
bag__from_list(NonLocalsList, NonLocalsMultiSet1),
bag__union(NonLocalsMultiSet0, NonLocalsMultiSet1,
NonLocalsMultiSet).
% To unique-modecheck a parallel conjunction, we find the variables
% that are nonlocal to more than one conjunct and make them shared,
% then we unique-modecheck the conjuncts.
%
% The variables that occur in more than one conjunct must be shared
% because otherwise it would be possible to make them become clobbered
% which would introduce an implicit dependency between the conjuncts
% which we do not allow.
:- pred unique_modes__check_par_conj(list(hlds_goal)::in, bag(prog_var)::in,
list(hlds_goal)::out, list(pair(instmap, set(prog_var)))::out,
mode_info::in, mode_info::out, io::di, io::uo) is det.
unique_modes__check_par_conj(Goals0, NonLocalVarsBag, Goals, Instmaps,
!ModeInfo, !IO) :-
unique_modes__check_par_conj_0(NonLocalVarsBag, !ModeInfo),
unique_modes__check_par_conj_1(Goals0, Goals, Instmaps, !ModeInfo,
!IO).
% Figure out which variables occur in more than one
% conjunct and make them shared.
:- pred unique_modes__check_par_conj_0(bag(prog_var)::in,
mode_info::in, mode_info::out) is det.
unique_modes__check_par_conj_0(NonLocalVarsBag, !ModeInfo) :-
bag__to_assoc_list(NonLocalVarsBag, NonLocalVarsList),
list__filter_map((pred(Pair::in, Var::out) is semidet :-
Pair = Var - Multiplicity,
Multiplicity > 1
), NonLocalVarsList, SharedList),
mode_info_get_instmap(!.ModeInfo, InstMap0),
instmap__lookup_vars(SharedList, InstMap0, VarInsts),
mode_info_get_module_info(!.ModeInfo, ModuleInfo0),
make_shared_inst_list(VarInsts, SharedVarInsts,
ModuleInfo0, ModuleInfo1),
mode_info_set_module_info(ModuleInfo1, !ModeInfo),
instmap__set_vars(InstMap0, SharedList, SharedVarInsts, InstMap1),
mode_info_set_instmap(InstMap1, !ModeInfo).
% Just process each conjunct in turn.
% Because we have already done modechecking, we know that
% there are no attempts to bind a variable in multiple
% parallel conjuncts, so we don't need to lock/unlock variables.
:- pred unique_modes__check_par_conj_1(list(hlds_goal)::in,
list(hlds_goal)::out, list(pair(instmap, set(prog_var)))::out,
mode_info::in, mode_info::out, io::di, io::uo) is det.
unique_modes__check_par_conj_1([], [], [], !ModeInfo, !IO).
unique_modes__check_par_conj_1([Goal0 | Goals0], [Goal | Goals],
[InstMap - NonLocals|InstMaps], !ModeInfo, !IO) :-
goal_get_nonlocals(Goal0, NonLocals),
mode_info_get_instmap(!.ModeInfo, InstMap0),
unique_modes__check_goal(Goal0, Goal, !ModeInfo, !IO),
mode_info_get_instmap(!.ModeInfo, InstMap),
mode_info_set_instmap(InstMap0, !ModeInfo),
unique_modes__check_par_conj_1(Goals0, Goals, InstMaps,
!ModeInfo, !IO).
%-----------------------------------------------------------------------------%
% Process each of the disjunctions in turn, making sure to restore
% the original instmap before processing the next one.
% Collect up a list of the resulting instmaps.
:- pred unique_modes__check_disj(list(hlds_goal)::in, determinism::in,
set(prog_var)::in, list(hlds_goal)::out, list(instmap)::out,
mode_info::in, mode_info::out, io::di, io::uo) is det.
unique_modes__check_disj([], _, _, [], [], !ModeInfo, !IO).
unique_modes__check_disj([Goal0 | Goals0], DisjDetism, DisjNonLocals,
[Goal | Goals], [InstMap | InstMaps], !ModeInfo, !IO) :-
mode_info_get_instmap(!.ModeInfo, InstMap0),
(
%
% If the disjunction was model_nondet, then we already marked
% all the non-locals as only being mostly-unique, so we
% don't need to do anything special here...
%
\+ determinism_components(DisjDetism, _, at_most_many),
%
% ... but for model_semi or model_det disjunctions, if the
% _disjunct_ can fail, then we still might backtrack to another
% disjunct, so again in that case we need to mark all the
% non-locals as being only mostly-unique rather than unique.
%
Goal0 = _ - GoalInfo0,
goal_info_get_determinism(GoalInfo0, Determinism),
determinism_components(Determinism, CanFail, _),
CanFail = can_fail
->
mode_info_add_live_vars(DisjNonLocals, !ModeInfo),
make_all_nondet_live_vars_mostly_uniq(!ModeInfo),
mode_info_remove_live_vars(DisjNonLocals, !ModeInfo)
;
true
),
unique_modes__check_goal(Goal0, Goal, !ModeInfo, !IO),
mode_info_get_instmap(!.ModeInfo, InstMap),
mode_info_set_instmap(InstMap0, !ModeInfo),
unique_modes__check_disj(Goals0, DisjDetism, DisjNonLocals,
Goals, InstMaps, !ModeInfo, !IO).
%-----------------------------------------------------------------------------%
:- pred unique_modes__check_case_list(list(case)::in, prog_var::in,
list(case)::out, list(instmap)::out, mode_info::in, mode_info::out,
io::di, io::uo) is det.
unique_modes__check_case_list([], _Var, [], [], !ModeInfo, !IO).
unique_modes__check_case_list([Case0 | Cases0], Var, [Case | Cases],
[InstMap | InstMaps], !ModeInfo, !IO) :-
Case0 = case(ConsId, Goal0),
Case = case(ConsId, Goal),
mode_info_get_instmap(!.ModeInfo, InstMap0),
% record the fact that Var was bound to ConsId in the
% instmap before processing this case
modecheck_functor_test(Var, ConsId, !ModeInfo),
mode_info_get_instmap(!.ModeInfo, InstMap1),
( instmap__is_reachable(InstMap1) ->
unique_modes__check_goal(Goal0, Goal1, !ModeInfo, !IO)
;
% We should not mode-analyse the goal, since it is unreachable.
% Instead we optimize the goal away, so that later passes
% won't complain about it not having unique mode information.
true_goal(Goal1)
),
mode_info_get_instmap(!.ModeInfo, InstMap),
fixup_switch_var(Var, InstMap0, InstMap, Goal1, Goal),
mode_info_set_instmap(InstMap0, !ModeInfo),
unique_modes__check_case_list(Cases0, Var, Cases, InstMaps,
!ModeInfo, !IO).
%-----------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink