mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-24 05:43:53 +00:00
bbb2535eb5
With almost 6000 lines, mercury_to_mercury.m was one of the biggest modules
of compiler, but it was far from cohesive. This diff carves seven new modules
out of it, each of which is much more cohesive. The stuff remaining in
mercury_to_mercury.m is still not as cohesive as one would like, but it is
now small enough that moving its individually-cohesive parts into modules
of their own would be overkill.
Three consequences of the old mercury_to_mercury.m's lack of cohesion
were that
- the order of predicate declarations often did not match the order of
their implementation;
- related predicates were not grouped together;
- even when they were grouped together, the order of those groups
was often random.
This diff fixes all three of these problems for all eight successor modules
of mercury_to_mercury.m: the seven new modules, and the new
mercury_to_mercury.m itself.
In some cases, this diff adds or improves the documentation of the predicates
in mercury_to_mercury.m's successor modules. In some other cases, it just
documents the lack of documentation :-(. In yet other cases, it removes
"documentation" that says nothing that isn't obvious from the predicate's name.
There are some algorithmic changes, but they are all trivial.
compiler/parse_tree_out.m:
New module containing the code to print out the top levels of parse trees,
including most sorts of items.
compiler/parse_tree_out_clause.m:
New module containing the code to print out clauses and goals.
compiler/parse_tree_out_pragma.m:
New module containing the code to print out pragmas.
compiler/parse_tree_out_pred_decl.m:
New module containing the code to print out predicate, function and
mode declarations. It is separate from parse_tree_out.m because a
significant number of compiler modules need only its functionality,
and not parse_tree_out.m's functionality.
compiler/parse_tree_out_inst.m:
New module containing the code to print out insts and modes.
compiler/parse_tree_out_term.m:
New module containing the code to print out variables and terms.
compiler/parse_tree_out_info.m:
New module containing the infrastructure of both mercury_to_mercury.m
and the other new modules.
compiler/parse_tree.m:
Include the new modules.
compiler/notes/compiler_design.html:
Document the new modules.
compiler/Mercury.options:
Transfer an option from mercury_to_mercury.m to the successor module
that needs it.
compiler/*.m:
Import one of the new modules either as well as, or instead of,
mercury_to_mercury.m. In most cases, we need to import only one
or two of mercury_to_mercury.m's successor modules; nowhere do we
need to import all eight.
Clean up some code in termination.m around a call to one of the
new modules.
tools/speedtest:
Replace mercury_to_mercury.m on the list of the ten largest modules
of the compiler.
1235 lines
52 KiB
Mathematica
1235 lines
52 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 2000-2012 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: unneeded_code.m.
|
|
% Author: zs.
|
|
%
|
|
% This module implements two related source-to-source transforms,
|
|
% both of which focus on goals that produce some variables, where these
|
|
% variables are not always required by the following computation.
|
|
%
|
|
% If there are no computation paths on which the variables produced by a goal
|
|
% may be needed, then the first transform deletes that goal.
|
|
%
|
|
% If the variables produced by a goal may be needed on some but not all
|
|
% computation paths, then the second transform moves that goal to the starts
|
|
% of those computation paths, thus avoiding the cost of executing the goal
|
|
% on all other computation paths. (This is related to the concept of partial
|
|
% redundancy elimination (PRE) for imperative languages.)
|
|
%
|
|
% Mercury has two constructs that make it possible for a variable to be needed
|
|
% on some computation paths but not others: switches and if-then-elses.
|
|
%
|
|
% In the case of switches, the alternative computation paths are those
|
|
% corresponding to the possible values of the switched-on variable, and
|
|
% not just the switch arms. Even if all switch arms need a variable, it
|
|
% is an optimization to copy the code generating that variable to the starts of
|
|
% all the switch arms if the switch is can_fail, i.e. there are some function
|
|
% symbols that the switched-on variable can be bound to that do not have arms.
|
|
%
|
|
% In the case of if-then-elses, the alternatives are the then part and
|
|
% the else part. Any variable needed by the condition is needed in both those
|
|
% computation paths.
|
|
%
|
|
% From the point of view of this transform, disjunctions are not branched
|
|
% control structures, because entering a disjunct does not preclude later
|
|
% entering another disjunct. Any variable needed by any disjunct must therefore
|
|
% be produced before control enters the disjunction. (In theory, a disjunct
|
|
% that cannot fail in a model_semi disjunction prevents entry to the following
|
|
% disjuncts, but any such following disjuncts will have been removed long ago
|
|
% by simplification.)
|
|
%
|
|
% Note that by avoiding the execution of a goal that appears in the original
|
|
% source code of the program, both these transforms can in general change the
|
|
% operational semantics of the program. Therefore a goal can only be eliminated
|
|
% or moved if the goal is has no observable effect except the result it
|
|
% generates (i.e is pure, cannot fail, cannot loop, cannot raise an exception),
|
|
% which is usually true only of goals composed entirely of builtins, or if
|
|
% the semantics options explicitly permit the change in the operational
|
|
% semantics, which will usually be an improvement (e.g. avoiding an infinite
|
|
% loop or an unnecessary exception).
|
|
%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module transform_hlds.unneeded_code.
|
|
:- interface.
|
|
|
|
:- import_module hlds.hlds_module.
|
|
:- import_module hlds.hlds_pred.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred unneeded_process_proc_msg(pred_proc_id::in,
|
|
proc_info::in, proc_info::out, module_info::in, module_info::out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module check_hlds.inst_match.
|
|
:- import_module check_hlds.mode_util.
|
|
:- import_module hlds.goal_form.
|
|
:- import_module hlds.goal_path.
|
|
:- import_module hlds.hlds_goal.
|
|
:- import_module hlds.hlds_out.
|
|
:- import_module hlds.hlds_out.hlds_out_goal.
|
|
:- import_module hlds.hlds_out.hlds_out_util.
|
|
:- import_module hlds.instmap.
|
|
:- import_module hlds.make_goal.
|
|
:- import_module hlds.passes_aux.
|
|
:- import_module hlds.quantification.
|
|
:- import_module hlds.vartypes.
|
|
:- import_module libs.globals.
|
|
:- import_module libs.options.
|
|
:- import_module mdbcomp.goal_path.
|
|
:- import_module parse_tree.parse_tree_out_info.
|
|
:- import_module parse_tree.prog_data.
|
|
:- import_module parse_tree.set_of_var.
|
|
|
|
:- import_module assoc_list.
|
|
:- import_module bool.
|
|
:- import_module int.
|
|
:- import_module io.
|
|
:- import_module list.
|
|
:- import_module map.
|
|
:- import_module pair.
|
|
:- import_module require.
|
|
:- import_module set.
|
|
:- import_module string.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% The branch_alts and branch_point types record the information the
|
|
% transform needs to know about a particular branched control
|
|
% structure: where it is, what kind it is, and how many alternatives
|
|
% it has.
|
|
%
|
|
:- type branch_point
|
|
---> branch_point(
|
|
% The id of the branch point.
|
|
goal_id,
|
|
|
|
% What kind of goal the branch point is, and many branches
|
|
% it has. Note that the second argument is a function of
|
|
% the first.
|
|
branch_alts
|
|
).
|
|
|
|
:- type branch_alts
|
|
---> alt_ite
|
|
% If-then-elses always have two alternatives: the then branch
|
|
% (numbered 1) and the else branch (numbered 2).
|
|
|
|
; alt_switch(maybe_switch_num_functors).
|
|
% The number of alternatives in a switch is equal to the number of
|
|
% function symbols in the type of the switched-on variable. This
|
|
% number is given by the argument integer, if present; if the
|
|
% argument is "no", then the number of function symbols in the type
|
|
% is effectively infinite (this can happen for builtin types
|
|
% such as "int"). If the switch cannot_fail, then this will be
|
|
% equal to the number of cases; if the switch can_fail, there
|
|
% will be strictly fewer cases than this.
|
|
|
|
% The location type identifies one arm of a branched control structure.
|
|
% The branched control structure id is a branch_point instead of a
|
|
% simple goal_path because without the branch_alts info, the
|
|
% transformation cannot tell if a given set of branches of a branched
|
|
% control structure covers all possible execution paths or not.
|
|
%
|
|
:- type location
|
|
---> location(
|
|
branch_point, % To which branched control structure
|
|
% does the location belong.
|
|
int % The branch within that control structure.
|
|
).
|
|
|
|
% The where_needed_map type maps each variable to the set of
|
|
% computation branches where it is needed. If a variable is needed
|
|
% everywhere, then the computation producing it cannot be eliminated
|
|
% or moved. If it is not needed at all, its producer can be eliminated.
|
|
% If it is needed on some but not all branches, then the producer
|
|
% can be moved to the starts of those branches (or, preferably,
|
|
% to the first point in those branches that need them, but we do not do
|
|
% that yet).
|
|
%
|
|
% The set of branches to whose starts the producer can be moved
|
|
% is represented as a map from the id of the branched control
|
|
% structure to the set of branch numbers within that branched control
|
|
% structure. If the branched control structure at goal path gp is
|
|
% mapped to a set including N, then the producer of that variable
|
|
% may be moved to the start of the goal with goal path <gp>;sN;
|
|
% (if the control structure is a switch) or <gp>;t; or <gp>;e;
|
|
% (if the control structure is an if-then-else).
|
|
%
|
|
% Since <gp>;sN; is conjoined with e.g. <gp>;sN;<gp2>;sM;
|
|
% it would be a mode error (variable having two conjoined producers)
|
|
% for the transformed code to have the producer of some variable
|
|
% inserted at the start of both those goals. It is therefore an
|
|
% invariant that a where_needed structure mapping gp to N
|
|
% will not contain any keys whose goal_path includes <gp>;sN;
|
|
% or its if-then-else equivalent.
|
|
%
|
|
% An example:
|
|
%
|
|
% % switch on X at goal path gp
|
|
% ( % s1
|
|
% X = a,
|
|
% ... code that needs Y and Z ...
|
|
% ; % s2
|
|
% X = b,
|
|
% ( Y = f ->
|
|
% ... code that needs only Z ...
|
|
% ;
|
|
% ... code that does not need Y or Z ...
|
|
% )
|
|
% )
|
|
%
|
|
% X is needed everywhere, since even if X is bound to c, its value must
|
|
% be tested.
|
|
%
|
|
% Y is needed everywhere iff the type of X contains only a and b,
|
|
% otherwise it is needed only in the <gp>;s1; and <gp>;s2; switch arms.
|
|
%
|
|
% Z is needed in <gp>;s1; and <gp>;s2;t; but is not needed in the
|
|
% <gp>;s2;e; else arm. Therefore the where_needed_branches map for Z
|
|
% will map gp to 1 and <gp>;s2; to 1.
|
|
%
|
|
:- type where_needed_map == map(prog_var, where_needed).
|
|
|
|
:- type where_needed
|
|
---> everywhere
|
|
; branches(where_needed_branches).
|
|
|
|
:- type where_needed_branches == map(branch_point, set(int)).
|
|
|
|
% The refined_goal_map structure maps branch goals to the list of
|
|
% producers that should be moved to the start of that branch.
|
|
% The order is important, since some of the producers in such a list
|
|
% may depend on variables produced by other goals that precede them
|
|
% in the list.
|
|
%
|
|
:- type refined_goal_map == map(pair(goal_id, int), list(hlds_goal)).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
unneeded_process_proc_msg(PredProcId, !ProcInfo, !ModuleInfo) :-
|
|
% The transformation considers every nonlocal variable of a goal
|
|
% that is bound on entry to be consumed by that goal. If the nonlocal set
|
|
% contains any such variables that are not actually needed by the goal,
|
|
% then the transformation will not be as effective as it could be.
|
|
% Therefore we preprocess the procedure body to ensure that the nonlocals
|
|
% sets are accurate reflections of the true needs of goals.
|
|
|
|
trace [io(!IO)] (
|
|
write_proc_progress_message("% Removing dead code in ",
|
|
PredProcId, !.ModuleInfo, !IO)
|
|
),
|
|
unneeded_pre_process_proc(!ProcInfo),
|
|
PredProcId = proc(PredId, _),
|
|
unneeded_process_proc(!ProcInfo, !ModuleInfo, PredId, 1, Successful),
|
|
trace [io(!IO)] (
|
|
(
|
|
Successful = yes,
|
|
write_proc_progress_message("% done.\n",
|
|
PredProcId, !.ModuleInfo, !IO)
|
|
;
|
|
Successful = no,
|
|
write_proc_progress_message("% none found.\n",
|
|
PredProcId, !.ModuleInfo, !IO)
|
|
)
|
|
).
|
|
|
|
:- pred unneeded_pre_process_proc(proc_info::in, proc_info::out) is det.
|
|
|
|
unneeded_pre_process_proc(!ProcInfo) :-
|
|
proc_info_get_headvars(!.ProcInfo, HeadVars),
|
|
proc_info_get_goal(!.ProcInfo, Goal0),
|
|
proc_info_get_varset(!.ProcInfo, VarSet0),
|
|
proc_info_get_vartypes(!.ProcInfo, VarTypes0),
|
|
proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0),
|
|
implicitly_quantify_clause_body_general(ordinary_nonlocals_no_lambda,
|
|
HeadVars, _Warnings, Goal0, Goal,
|
|
VarSet0, VarSet, VarTypes0, VarTypes, RttiVarMaps0, RttiVarMaps),
|
|
proc_info_set_goal(Goal, !ProcInfo),
|
|
proc_info_set_varset(VarSet, !ProcInfo),
|
|
proc_info_set_vartypes(VarTypes, !ProcInfo),
|
|
proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo).
|
|
|
|
% The source-to-source transform operates in two phases.
|
|
%
|
|
% The first phase traverses the procedure body, keeping track of which
|
|
% variables are needed where. When it finds a goal that can be deleted,
|
|
% it deletes it by replacing it with the goal `true'. When it finds a goal
|
|
% that can be moved, it does the same, but also records in the RefinedGoalsMap
|
|
% that the deleted goal must later be inserted at the starts of the branches
|
|
% where its outputs may be needed, and accordingly notes that its own inputs
|
|
% are needed in those branches.
|
|
%
|
|
% The second phase traverses the modified problem body, and inserts the
|
|
% goals in the RefinedGoalsMap at the starts of the indicated branches.
|
|
% This phase identified the indicated branches by the goal_path annotations
|
|
% on their parents. These may be out of date since the first phase will have
|
|
% deleted some goals, but since neither phase modifies the goal_path annotation
|
|
% on a goal once that goal has been inserted into the RefinedGoalsMap,
|
|
% this does not matter.
|
|
%
|
|
% Neither phase traverses the internals of a goal that has been moved.
|
|
% To make sure that such goals are optimized whenever possible, the algorithm
|
|
% invokes itself recursively whenever it was able to successfully (delete or)
|
|
% move a goal. This cannot lead to infinite recursion, since each iteration
|
|
% will strictly reduce the number of computation paths on which a subgoal
|
|
% of the procedure body is executed. Since both the number of subgoals and
|
|
% computation paths are finite, the recursion must end.
|
|
|
|
:- type uc_option_values
|
|
---> uc_option_values(
|
|
uc_fully_strict :: bool,
|
|
uc_reorder_conj :: bool,
|
|
uc_copy_limit :: int,
|
|
uc_debug :: bool
|
|
).
|
|
|
|
:- type unneeded_code_info
|
|
---> unneeded_code_info(
|
|
uci_module_info :: module_info,
|
|
uci_vartypes :: vartypes,
|
|
uci_options :: uc_option_values,
|
|
uci_containing_goal_map :: containing_goal_map
|
|
).
|
|
|
|
:- pred unneeded_process_proc(proc_info::in, proc_info::out,
|
|
module_info::in, module_info::out, pred_id::in, int::in, bool::out) is det.
|
|
|
|
unneeded_process_proc(!ProcInfo, !ModuleInfo, PredId, Pass, Successful) :-
|
|
fill_goal_id_slots_in_proc(!.ModuleInfo, ContainingGoalMap, !ProcInfo),
|
|
proc_info_get_goal(!.ProcInfo, Goal0),
|
|
proc_info_get_varset(!.ProcInfo, VarSet0),
|
|
proc_info_get_vartypes(!.ProcInfo, VarTypes0),
|
|
proc_info_get_initial_instmap(!.ProcInfo, !.ModuleInfo, InitInstMap),
|
|
Goal0 = hlds_goal(_, GoalInfo0),
|
|
InstMapDelta = goal_info_get_instmap_delta(GoalInfo0),
|
|
instmap.apply_instmap_delta(InitInstMap, InstMapDelta, FinalInstMap),
|
|
proc_info_instantiated_head_vars(!.ModuleInfo, !.ProcInfo, NeededVarsList),
|
|
map.init(WhereNeededMap0),
|
|
NeededEverywhere = (pred(Var::in, NeededMap0::in, NeededMap::out) is det :-
|
|
map.det_insert(Var, everywhere, NeededMap0, NeededMap)
|
|
),
|
|
list.foldl(NeededEverywhere, NeededVarsList,
|
|
WhereNeededMap0, WhereNeededMap1),
|
|
module_info_get_globals(!.ModuleInfo, Globals),
|
|
globals.lookup_bool_option(Globals, reorder_conj, ReorderConj),
|
|
globals.lookup_bool_option(Globals, fully_strict, FullyStrict),
|
|
globals.lookup_int_option(Globals, unneeded_code_copy_limit, Limit),
|
|
globals.lookup_bool_option(Globals, unneeded_code_debug, Debug),
|
|
Options = uc_option_values(FullyStrict, ReorderConj, Limit, Debug),
|
|
(
|
|
Debug = no
|
|
;
|
|
Debug = yes,
|
|
trace [io(!IO)] (
|
|
module_info_pred_info(!.ModuleInfo, PredId, PredInfo),
|
|
PredName = pred_info_name(PredInfo),
|
|
globals.lookup_accumulating_option(Globals,
|
|
unneeded_code_debug_pred_name, DebugPredNames),
|
|
(
|
|
DebugPredNames = [],
|
|
io.format("%% Starting unneededed code pass %d\n",
|
|
[i(Pass)], !IO)
|
|
;
|
|
DebugPredNames = [_ | _],
|
|
( list.member(PredName, DebugPredNames) ->
|
|
io.format("%% Starting unneededed code pass %d\n",
|
|
[i(Pass)], !IO),
|
|
OutInfo = init_hlds_out_info(Globals, output_debug),
|
|
write_goal(OutInfo, !.ModuleInfo, VarSet0,
|
|
print_name_and_num, 0, ".\n", Goal0, !IO)
|
|
;
|
|
true
|
|
)
|
|
)
|
|
)
|
|
),
|
|
UnneededInfo = unneeded_code_info(!.ModuleInfo, VarTypes0, Options,
|
|
ContainingGoalMap),
|
|
unneeded_process_goal(UnneededInfo, Goal0, Goal1,
|
|
InitInstMap, FinalInstMap, WhereNeededMap1, _,
|
|
map.init, RefinedGoals1, no, Changed),
|
|
unneeded_refine_goal(Goal1, Goal2, RefinedGoals1, RefinedGoals),
|
|
expect(map.is_empty(RefinedGoals),
|
|
$module, $pred, "goal reattachment unsuccessful"),
|
|
(
|
|
Changed = yes,
|
|
% We need to fix up the goal_info by recalculating the nonlocal vars
|
|
% and the non-atomic instmap deltas.
|
|
proc_info_get_headvars(!.ProcInfo, HeadVars),
|
|
proc_info_get_inst_varset(!.ProcInfo, InstVarSet),
|
|
proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0),
|
|
implicitly_quantify_clause_body_general(ordinary_nonlocals_no_lambda,
|
|
HeadVars, _Warnings,
|
|
Goal2, Goal3, VarSet0, VarSet, VarTypes0, VarTypes,
|
|
RttiVarMaps0, RttiVarMaps),
|
|
recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas,
|
|
Goal3, Goal, VarTypes, InstVarSet, InitInstMap, !ModuleInfo),
|
|
proc_info_set_goal(Goal, !ProcInfo),
|
|
proc_info_set_varset(VarSet, !ProcInfo),
|
|
proc_info_set_vartypes(VarTypes, !ProcInfo),
|
|
proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo),
|
|
( Pass > 3 ->
|
|
true
|
|
;
|
|
unneeded_process_proc(!ProcInfo, !ModuleInfo, PredId, Pass + 1, _)
|
|
),
|
|
Successful = yes
|
|
;
|
|
Changed = no,
|
|
Successful = no
|
|
).
|
|
|
|
:- pred unneeded_process_goal(unneeded_code_info::in,
|
|
hlds_goal::in, hlds_goal::out, instmap::in, instmap::in,
|
|
where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out, bool::in, bool::out) is det.
|
|
|
|
unneeded_process_goal(UnneededInfo, Goal0, Goal, InitInstMap, FinalInstMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
can_eliminate_or_move(UnneededInfo, Goal0, InitInstMap, FinalInstMap,
|
|
!.WhereNeededMap, WhereInfo),
|
|
(
|
|
WhereInfo = everywhere,
|
|
unneeded_process_goal_internal(UnneededInfo, Goal0, Goal,
|
|
InitInstMap, FinalInstMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed)
|
|
;
|
|
WhereInfo = branches(Branches),
|
|
demand_inputs(UnneededInfo, Goal0, InitInstMap, WhereInfo,
|
|
!WhereNeededMap),
|
|
map.to_assoc_list(Branches, BranchList),
|
|
list.foldl(insert_branch_into_refined_goals(Goal0), BranchList,
|
|
!RefinedGoals),
|
|
Goal = true_goal,
|
|
!:Changed = yes,
|
|
|
|
Options = UnneededInfo ^ uci_options,
|
|
Debug = Options ^ uc_debug,
|
|
(
|
|
Debug = no
|
|
;
|
|
Debug = yes,
|
|
Goal0 = hlds_goal(_GoalExpr0, GoalInfo0),
|
|
goal_info_get_goal_id(GoalInfo0) = goal_id(GoalIdNum0),
|
|
trace [io(!IO)] (
|
|
io.format("unneeded code at goal id %d\n", [i(GoalIdNum0)],
|
|
!IO)
|
|
)
|
|
)
|
|
),
|
|
ModuleInfo = UnneededInfo ^ uci_module_info,
|
|
undemand_virgin_outputs(Goal0, ModuleInfo, InitInstMap, !WhereNeededMap),
|
|
( goal_get_purity(Goal) = purity_impure ->
|
|
% By saying that all vars that are live before the impure goal are
|
|
% needed everywhere, we prevent the movement of the goals producing
|
|
% those vars across the impure goal.
|
|
%
|
|
% This code requires compound goals containing impure code
|
|
% to also be marked impure.
|
|
map.map_values_only(demand_var_everywhere, !WhereNeededMap)
|
|
;
|
|
true
|
|
).
|
|
|
|
:- pred insert_branch_into_refined_goals(hlds_goal::in,
|
|
pair(branch_point, set(int))::in,
|
|
refined_goal_map::in, refined_goal_map::out) is det.
|
|
|
|
insert_branch_into_refined_goals(Goal, BranchPoint - BranchNumSet,
|
|
!RefinedGoals) :-
|
|
BranchPoint = branch_point(GoalPath, _),
|
|
set.to_sorted_list(BranchNumSet, BranchNums),
|
|
list.foldl(insert_branch_arm_into_refined_goals(Goal, GoalPath),
|
|
BranchNums, !RefinedGoals).
|
|
|
|
:- pred insert_branch_arm_into_refined_goals(hlds_goal::in, goal_id::in,
|
|
int::in, refined_goal_map::in, refined_goal_map::out) is det.
|
|
|
|
insert_branch_arm_into_refined_goals(Goal, GoalPath, BranchNum,
|
|
!RefinedGoals) :-
|
|
Key = GoalPath - BranchNum,
|
|
( map.search(!.RefinedGoals, Key, Goals0) ->
|
|
Goals = [Goal | Goals0],
|
|
map.det_update(Key, Goals, !RefinedGoals)
|
|
;
|
|
map.det_insert(Key, [Goal], !RefinedGoals)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred can_eliminate_or_move(unneeded_code_info::in, hlds_goal::in,
|
|
instmap::in, instmap::in,
|
|
where_needed_map::in, where_needed::out) is det.
|
|
|
|
can_eliminate_or_move(UnneededInfo, Goal, InitInstMap, FinalInstMap,
|
|
WhereNeededMap, !:WhereInfo) :-
|
|
ModuleInfo = UnneededInfo ^ uci_module_info,
|
|
VarTypes = UnneededInfo ^ uci_vartypes,
|
|
instmap_changed_vars(InitInstMap, FinalInstMap, VarTypes, ModuleInfo,
|
|
ChangedVarSet),
|
|
set_of_var.to_sorted_list(ChangedVarSet, ChangedVars),
|
|
map.init(Empty),
|
|
!:WhereInfo = branches(Empty),
|
|
Goal = hlds_goal(_, GoalInfo),
|
|
CurrentId = goal_info_get_goal_id(GoalInfo),
|
|
ContainingGoalMap = UnneededInfo ^ uci_containing_goal_map,
|
|
list.foldl(
|
|
collect_where_needed(ContainingGoalMap, CurrentId, WhereNeededMap),
|
|
ChangedVars, !WhereInfo),
|
|
Options = UnneededInfo ^ uci_options,
|
|
adjust_where_needed(Goal, Options, !WhereInfo).
|
|
|
|
:- pred collect_where_needed(containing_goal_map::in, goal_id::in,
|
|
where_needed_map::in, prog_var::in, where_needed::in, where_needed::out)
|
|
is det.
|
|
|
|
collect_where_needed(ContainingGoalMap, CurrentId, WhereNeededMap, ChangedVar,
|
|
!WhereInfo) :-
|
|
( map.search(WhereNeededMap, ChangedVar, Where) ->
|
|
where_needed_upper_bound(ContainingGoalMap, CurrentId, Where,
|
|
!WhereInfo)
|
|
;
|
|
true
|
|
).
|
|
|
|
% This is the predicate responsible for ensuring that the act of optimizing
|
|
% away the execution of a goal on some or all computation paths changes the
|
|
% operational semantics only in ways that are explicitly permitted by the
|
|
% programmer.
|
|
%
|
|
:- pred adjust_where_needed(hlds_goal::in, uc_option_values::in,
|
|
where_needed::in, where_needed::out) is det.
|
|
|
|
adjust_where_needed(Goal, Options, !WhereInfo) :-
|
|
(
|
|
Goal = hlds_goal(GoalExpr, GoalInfo),
|
|
(
|
|
% Do not move goals that can fail, since doing so can cause
|
|
% execution to reach goals it shouldn't, and those goals may have
|
|
% undesirable behavior (e.g. infinite loops).
|
|
Detism = goal_info_get_determinism(GoalInfo),
|
|
detism_is_moveable(Detism, no)
|
|
;
|
|
% Do not move impure or semipure goals, since their ordering
|
|
% wrt other such goals must be preserved.
|
|
goal_info_get_purity(GoalInfo) \= purity_pure
|
|
;
|
|
% With --fully-strict, we cannot optimize away infinite loops
|
|
% or exceptions.
|
|
Options ^ uc_fully_strict = yes,
|
|
goal_can_loop_or_throw(Goal)
|
|
;
|
|
% With --no-reorder-conj, we cannot move infinite loops or
|
|
% exceptions, but we can delete them.
|
|
Options ^ uc_reorder_conj = no,
|
|
goal_can_loop_or_throw(Goal),
|
|
!.WhereInfo = branches(BranchMap),
|
|
\+ map.is_empty(BranchMap)
|
|
;
|
|
% Do not delete the `true' goal, since deleting it is a no-op,
|
|
% and thus does *not* strictly reduce the number of computation
|
|
% paths on which a subgoal of the procedure body is executed.
|
|
GoalExpr = true_goal_expr
|
|
;
|
|
!.WhereInfo = branches(BranchMap),
|
|
map.values(BranchMap, BranchArms),
|
|
list.map(set.count, BranchArms, BranchArmCounts),
|
|
BranchArmCount = list.foldl(int.plus, BranchArmCounts, 0),
|
|
BranchArmCount > Options ^ uc_copy_limit
|
|
|
|
% We may also want to add other space time tradeoffs. E.g. if
|
|
% profiling shows that Goal is required in 10 branches that
|
|
% account for 99% of all executions and is not required in 5
|
|
% branches that account for the remaining 1%, and Goal itself
|
|
% is sufficiently cheap to execute, then not moving Goal may cost
|
|
% a small slowdown in 1% of cases but avoid 9 extra copies of Goal.
|
|
% Due to better instruction cache behavior, not moving Goal
|
|
% may in fact yield faster code after all.
|
|
)
|
|
->
|
|
!:WhereInfo = everywhere
|
|
;
|
|
true
|
|
).
|
|
|
|
:- pred detism_is_moveable(determinism::in, bool::out) is det.
|
|
|
|
detism_is_moveable(detism_det, yes).
|
|
detism_is_moveable(detism_semi, no).
|
|
detism_is_moveable(detism_non, no).
|
|
detism_is_moveable(detism_multi, yes).
|
|
detism_is_moveable(detism_erroneous, no).
|
|
detism_is_moveable(detism_failure, no).
|
|
detism_is_moveable(detism_cc_non, no).
|
|
detism_is_moveable(detism_cc_multi, yes).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred demand_inputs(unneeded_code_info::in, hlds_goal::in, instmap::in,
|
|
where_needed::in, where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
demand_inputs(UnneededInfo, Goal, InitInstMap, WhereNeeded, !WhereNeededMap) :-
|
|
Goal = hlds_goal(_, GoalInfo),
|
|
NonLocalSet = goal_info_get_nonlocals(GoalInfo),
|
|
GoalId = goal_info_get_goal_id(GoalInfo),
|
|
set_of_var.to_sorted_list(NonLocalSet, NonLocals),
|
|
ModuleInfo = UnneededInfo ^ uci_module_info,
|
|
list.filter(nonlocal_may_be_input(ModuleInfo, InitInstMap), NonLocals,
|
|
Inputs),
|
|
ContainingGoalMap = UnneededInfo ^ uci_containing_goal_map,
|
|
list.foldl(demand_var(ContainingGoalMap, GoalId, WhereNeeded), Inputs,
|
|
!WhereNeededMap).
|
|
|
|
:- pred nonlocal_may_be_input(module_info::in, instmap::in,
|
|
prog_var::in) is semidet.
|
|
|
|
nonlocal_may_be_input(ModuleInfo, InstMap, Var) :-
|
|
instmap_lookup_var(InstMap, Var, Inst),
|
|
inst_is_bound(ModuleInfo, Inst).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred undemand_virgin_outputs(hlds_goal::in, module_info::in,
|
|
instmap::in, where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
undemand_virgin_outputs(Goal, ModuleInfo, InstMap, !WhereNeededMap) :-
|
|
Goal = hlds_goal(_, GoalInfo),
|
|
NonLocalSet = goal_info_get_nonlocals(GoalInfo),
|
|
set_of_var.to_sorted_list(NonLocalSet, NonLocals),
|
|
list.filter(nonlocal_is_virgin_output(ModuleInfo, InstMap), NonLocals,
|
|
VirginOutputs),
|
|
list.foldl(undemand_var, VirginOutputs, !WhereNeededMap).
|
|
|
|
:- pred nonlocal_is_virgin_output(module_info::in, instmap::in,
|
|
prog_var::in) is semidet.
|
|
|
|
nonlocal_is_virgin_output(ModuleInfo, InstMap, Var) :-
|
|
instmap_lookup_var(InstMap, Var, Inst),
|
|
\+ inst_is_bound(ModuleInfo, Inst).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred demand_var(containing_goal_map::in, goal_id::in,
|
|
where_needed::in, prog_var::in,
|
|
where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
demand_var(ContainingGoalMap, CurrentId, WhereNeeded, Var, !WhereNeededMap) :-
|
|
( map.search(!.WhereNeededMap, Var, Where0) ->
|
|
where_needed_upper_bound(ContainingGoalMap, CurrentId,
|
|
WhereNeeded, Where0, Where),
|
|
map.det_update(Var, Where, !WhereNeededMap)
|
|
;
|
|
map.det_insert(Var, WhereNeeded, !WhereNeededMap)
|
|
).
|
|
|
|
:- pred undemand_var(prog_var::in,
|
|
where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
undemand_var(Var, !WhereNeededMap) :-
|
|
map.delete(Var, !WhereNeededMap).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred demand_var_everywhere(where_needed::in, where_needed::out) is det.
|
|
|
|
demand_var_everywhere(_WhereNeeded0, everywhere).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred unneeded_process_goal_internal(unneeded_code_info::in,
|
|
hlds_goal::in, hlds_goal::out, instmap::in, instmap::in,
|
|
where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out, bool::in, bool::out) is det.
|
|
|
|
unneeded_process_goal_internal(UnneededInfo, Goal0, Goal,
|
|
InitInstMap, FinalInstMap, !WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
|
|
(
|
|
( GoalExpr0 = unify(_, _, _, _, _)
|
|
; GoalExpr0 = plain_call(_, _, _, _, _, _)
|
|
; GoalExpr0 = generic_call(_, _, _, _, _)
|
|
; GoalExpr0 = call_foreign_proc(_, _, _, _, _, _, _)
|
|
),
|
|
Goal = Goal0,
|
|
demand_inputs(UnneededInfo, Goal, InitInstMap, everywhere,
|
|
!WhereNeededMap)
|
|
;
|
|
GoalExpr0 = conj(ConjType, Conjuncts0),
|
|
(
|
|
ConjType = plain_conj,
|
|
unneeded_process_conj(UnneededInfo, Conjuncts0, Conjuncts,
|
|
InitInstMap, FinalInstMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed),
|
|
GoalExpr = conj(plain_conj, Conjuncts),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
ConjType = parallel_conj,
|
|
Goal = Goal0,
|
|
demand_inputs(UnneededInfo, Goal, InitInstMap, everywhere,
|
|
!WhereNeededMap)
|
|
)
|
|
;
|
|
GoalExpr0 = switch(SwitchVar, CanFail, Cases0),
|
|
ContainingGoalMap = UnneededInfo ^ uci_containing_goal_map,
|
|
(
|
|
Cases0 = [FirstCase0 | _],
|
|
FirstCase0 = case(_, _, FirstCaseGoal0),
|
|
FirstCaseGoal0 = hlds_goal(_, FirstCaseGoalInfo0),
|
|
FirstCaseGoalId0 = goal_info_get_goal_id(FirstCaseGoalInfo0),
|
|
map.lookup(ContainingGoalMap, FirstCaseGoalId0, GoalContaining0),
|
|
GoalContaining0 = containing_goal(_ContainingGoalId,
|
|
FirstCaseLastStep),
|
|
FirstCaseLastStep = step_switch(_, MaybeNumAltPrime)
|
|
->
|
|
MaybeNumAlt = MaybeNumAltPrime
|
|
;
|
|
unexpected($module, $pred, "switch count")
|
|
),
|
|
GoalId = goal_info_get_goal_id(GoalInfo0),
|
|
BranchPoint = branch_point(GoalId, alt_switch(MaybeNumAlt)),
|
|
map.map_values_only(demand_var_everywhere, !WhereNeededMap),
|
|
map.init(BranchNeededMap0),
|
|
unneeded_process_cases(UnneededInfo, Cases0, Cases, BranchPoint, 1,
|
|
InitInstMap, FinalInstMap, GoalId,
|
|
!.WhereNeededMap, BranchNeededMap0, BranchNeededMap,
|
|
!RefinedGoals, !Changed),
|
|
merge_where_needed_maps(ContainingGoalMap, GoalId, !.WhereNeededMap,
|
|
BranchNeededMap, !:WhereNeededMap),
|
|
demand_var(ContainingGoalMap, GoalId, everywhere, SwitchVar,
|
|
!WhereNeededMap),
|
|
GoalExpr = switch(SwitchVar, CanFail, Cases),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = disj(Disjuncts0),
|
|
GoalId = goal_info_get_goal_id(GoalInfo0),
|
|
map.map_values_only(demand_var_everywhere, !WhereNeededMap),
|
|
unneeded_process_disj(UnneededInfo, Disjuncts0, Disjuncts,
|
|
InitInstMap, FinalInstMap, GoalId,
|
|
!.WhereNeededMap, !.WhereNeededMap, !:WhereNeededMap,
|
|
!RefinedGoals, !Changed),
|
|
GoalExpr = disj(Disjuncts),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = if_then_else(Quant, Cond0, Then0, Else0),
|
|
GoalId = goal_info_get_goal_id(GoalInfo0),
|
|
BranchPoint = branch_point(GoalId, alt_ite),
|
|
map.map_values_only(demand_var_everywhere, !WhereNeededMap),
|
|
unneeded_process_ite(UnneededInfo, Cond0, Cond,
|
|
Then0, Then, Else0, Else, BranchPoint, InitInstMap, FinalInstMap,
|
|
GoalId, !WhereNeededMap, !RefinedGoals, !Changed),
|
|
GoalExpr = if_then_else(Quant, Cond, Then, Else),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = negation(NegGoal0),
|
|
unneeded_process_goal(UnneededInfo, NegGoal0, NegGoal,
|
|
InitInstMap, FinalInstMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed),
|
|
GoalExpr = negation(NegGoal),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = scope(Reason, SomeGoal0),
|
|
( Reason = from_ground_term(_, from_ground_term_construct) ->
|
|
Goal = Goal0
|
|
;
|
|
unneeded_process_goal(UnneededInfo, SomeGoal0, SomeGoal,
|
|
InitInstMap, FinalInstMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed),
|
|
GoalExpr = scope(Reason, SomeGoal),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
)
|
|
;
|
|
GoalExpr0 = shorthand(_),
|
|
% These should have been expanded out by now.
|
|
unexpected($module, $pred, "shorthand")
|
|
).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type bracketed_goal
|
|
---> bracketed_goal(hlds_goal, instmap, instmap).
|
|
|
|
:- pred unneeded_process_conj(unneeded_code_info::in,
|
|
list(hlds_goal)::in, list(hlds_goal)::out, instmap::in, instmap::in,
|
|
where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out, bool::in, bool::out) is det.
|
|
|
|
unneeded_process_conj(UnneededInfo, Goals0, Goals, InitInstMap, _FinalInstMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
build_bracketed_conj(Goals0, InitInstMap, BracketedGoals),
|
|
list.reverse(BracketedGoals, RevBracketedGoals),
|
|
unneeded_process_rev_bracketed_conj(UnneededInfo,
|
|
RevBracketedGoals, RevGoals, !WhereNeededMap, !RefinedGoals, !Changed),
|
|
list.reverse(RevGoals, Goals).
|
|
|
|
:- pred build_bracketed_conj(list(hlds_goal)::in, instmap::in,
|
|
list(bracketed_goal)::out) is det.
|
|
|
|
build_bracketed_conj([], _, []).
|
|
build_bracketed_conj([Goal | Goals], InitInstMap, BracketedGoals) :-
|
|
( instmap_is_unreachable(InitInstMap) ->
|
|
BracketedGoals = []
|
|
;
|
|
Goal = hlds_goal(_, GoalInfo),
|
|
InstMapDelta = goal_info_get_instmap_delta(GoalInfo),
|
|
instmap.apply_instmap_delta(InitInstMap, InstMapDelta, FinalInstMap),
|
|
build_bracketed_conj(Goals, FinalInstMap, BracketedTail),
|
|
BracketedGoal = bracketed_goal(Goal, InitInstMap, FinalInstMap),
|
|
BracketedGoals = [BracketedGoal | BracketedTail]
|
|
).
|
|
|
|
:- pred unneeded_process_rev_bracketed_conj(unneeded_code_info::in,
|
|
list(bracketed_goal)::in, list(hlds_goal)::out,
|
|
where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out, bool::in, bool::out) is det.
|
|
|
|
unneeded_process_rev_bracketed_conj(_, [], [],
|
|
!WhereNeededMap, !RefinedGoals, !Changed).
|
|
unneeded_process_rev_bracketed_conj(UnneededInfo,
|
|
[BracketedGoal | BracketedGoals], Goals,
|
|
!WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
BracketedGoal = bracketed_goal(Goal0, InitInstMap, FinalInstMap),
|
|
unneeded_process_goal(UnneededInfo, Goal0, Goal1,
|
|
InitInstMap, FinalInstMap, !WhereNeededMap, !RefinedGoals, !Changed),
|
|
unneeded_process_rev_bracketed_conj(UnneededInfo, BracketedGoals, Goals1,
|
|
!WhereNeededMap, !RefinedGoals, !Changed),
|
|
( Goal1 = hlds_goal(true_goal_expr, _) ->
|
|
Goals = Goals1
|
|
;
|
|
Goals = [Goal1 | Goals1]
|
|
).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred unneeded_process_disj(unneeded_code_info::in,
|
|
list(hlds_goal)::in, list(hlds_goal)::out,
|
|
instmap::in, instmap::in, goal_id::in,
|
|
where_needed_map::in, where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out, bool::in, bool::out) is det.
|
|
|
|
unneeded_process_disj(_, [], [], _, _, _, _,
|
|
!WhereNeededMap, !RefinedGoals, !Changed).
|
|
unneeded_process_disj(UnneededInfo, [Goal0 | Goals0], [Goal | Goals],
|
|
InitInstMap, FinalInstMap, CurrentId,
|
|
StartWhereNeededMap, !WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
unneeded_process_goal(UnneededInfo, Goal0, Goal, InitInstMap, FinalInstMap,
|
|
StartWhereNeededMap, WhereNeededMapFirst, !RefinedGoals, !Changed),
|
|
map.to_assoc_list(WhereNeededMapFirst, WhereNeededList),
|
|
ContainingGoalMap = UnneededInfo ^ uci_containing_goal_map,
|
|
add_where_needed_list(ContainingGoalMap, WhereNeededList, CurrentId,
|
|
!WhereNeededMap),
|
|
unneeded_process_disj(UnneededInfo, Goals0, Goals,
|
|
InitInstMap, FinalInstMap, CurrentId, StartWhereNeededMap,
|
|
!WhereNeededMap, !RefinedGoals, !Changed).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred unneeded_process_cases(unneeded_code_info::in,
|
|
list(case)::in, list(case)::out, branch_point::in, int::in,
|
|
instmap::in, instmap::in, goal_id::in,
|
|
where_needed_map::in, where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out,
|
|
bool::in, bool::out) is det.
|
|
|
|
unneeded_process_cases(_, [], [], _, _, _, _, _, _,
|
|
!WhereNeededMap, !RefinedGoals, !Changed).
|
|
unneeded_process_cases(UnneededInfo, [Case0 | Cases0], [Case | Cases],
|
|
BranchPoint, BranchNum, InitInstMap, FinalInstMap, CurrentId,
|
|
StartWhereNeededMap, !WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
Case0 = case(MainConsId, OtherConsIds, Goal0),
|
|
unneeded_process_goal(UnneededInfo, Goal0, Goal, InitInstMap, FinalInstMap,
|
|
StartWhereNeededMap, WhereNeededMapFirst, !RefinedGoals, !Changed),
|
|
Case = case(MainConsId, OtherConsIds, Goal),
|
|
map.to_assoc_list(WhereNeededMapFirst, WhereNeededList),
|
|
ContainingGoalMap = UnneededInfo ^ uci_containing_goal_map,
|
|
add_alt_start(ContainingGoalMap, WhereNeededList, BranchPoint, BranchNum,
|
|
CurrentId, !WhereNeededMap),
|
|
unneeded_process_cases(UnneededInfo, Cases0, Cases,
|
|
BranchPoint, BranchNum + 1, InitInstMap, FinalInstMap, CurrentId,
|
|
StartWhereNeededMap, !WhereNeededMap, !RefinedGoals, !Changed).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred unneeded_process_ite(unneeded_code_info::in,
|
|
hlds_goal::in, hlds_goal::out,
|
|
hlds_goal::in, hlds_goal::out, hlds_goal::in, hlds_goal::out,
|
|
branch_point::in, instmap::in, instmap::in, goal_id::in,
|
|
where_needed_map::in, where_needed_map::out,
|
|
refined_goal_map::in, refined_goal_map::out, bool::in, bool::out) is det.
|
|
|
|
unneeded_process_ite(UnneededInfo, Cond0, Cond, Then0, Then, Else0, Else,
|
|
BranchPoint, InitInstMap, FinalInstMap, CurrentId,
|
|
!WhereNeededMap, !RefinedGoals, !Changed) :-
|
|
Cond0 = hlds_goal(_, CondInfo0),
|
|
InstMapDelta = goal_info_get_instmap_delta(CondInfo0),
|
|
instmap.apply_instmap_delta(InitInstMap, InstMapDelta, InstMapCond),
|
|
|
|
unneeded_process_goal(UnneededInfo, Else0, Else, InitInstMap, FinalInstMap,
|
|
!.WhereNeededMap, WhereNeededMapElse, !RefinedGoals, !Changed),
|
|
unneeded_process_goal(UnneededInfo, Then0, Then, InstMapCond, FinalInstMap,
|
|
!.WhereNeededMap, WhereNeededMapThen, !RefinedGoals, !Changed),
|
|
|
|
ContainingGoalMap = UnneededInfo ^ uci_containing_goal_map,
|
|
map.init(BranchNeededMap0),
|
|
map.to_assoc_list(WhereNeededMapElse, WhereNeededListElse),
|
|
add_alt_start(ContainingGoalMap, WhereNeededListElse, BranchPoint, 2,
|
|
CurrentId, BranchNeededMap0, BranchNeededMap1),
|
|
map.to_assoc_list(WhereNeededMapThen, WhereNeededListThen),
|
|
add_alt_start(ContainingGoalMap, WhereNeededListThen, BranchPoint, 1,
|
|
CurrentId, BranchNeededMap1, BranchNeededMap),
|
|
merge_where_needed_maps(ContainingGoalMap, CurrentId,
|
|
!.WhereNeededMap, BranchNeededMap, WhereNeededMapCond),
|
|
|
|
unneeded_process_goal(UnneededInfo, Cond0, Cond, InitInstMap, InstMapCond,
|
|
WhereNeededMapCond, !:WhereNeededMap, !RefinedGoals, !Changed).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% Merge two where_needed_maps, so that if var V is needed at branch B
|
|
% in the resulting where_needed_map iff it is needed there in one of
|
|
% the input maps.
|
|
%
|
|
:- pred merge_where_needed_maps(containing_goal_map::in, goal_id::in,
|
|
where_needed_map::in, where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
merge_where_needed_maps(ContainingGoalMap, CurrentId,
|
|
WhereNeededMap1, WhereNeededMap2, WhereNeededMap) :-
|
|
map.to_assoc_list(WhereNeededMap1, WhereNeededList1),
|
|
add_where_needed_list(ContainingGoalMap, WhereNeededList1, CurrentId,
|
|
WhereNeededMap2, WhereNeededMap).
|
|
|
|
:- pred add_where_needed_list(containing_goal_map::in,
|
|
assoc_list(prog_var, where_needed)::in, goal_id::in,
|
|
where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
add_where_needed_list(_, [], _, !WhereNeededMap).
|
|
add_where_needed_list(ContainingGoalMap, [Var - BranchWhere | WhereNeededList],
|
|
CurrentId, !WhereNeededMap) :-
|
|
( map.search(!.WhereNeededMap, Var, OldWhere) ->
|
|
where_needed_upper_bound(ContainingGoalMap, CurrentId,
|
|
BranchWhere, OldWhere, CombinedWhere),
|
|
map.det_update(Var, CombinedWhere, !WhereNeededMap)
|
|
;
|
|
map.det_insert(Var, BranchWhere, !WhereNeededMap)
|
|
),
|
|
add_where_needed_list(ContainingGoalMap, WhereNeededList, CurrentId,
|
|
!WhereNeededMap).
|
|
|
|
% Given a where_needed_map, add to it the where_needed information for the
|
|
% start of an alternative in a branched goal. This source is important,
|
|
% because if the analysis *at the start of an alternative* says that the
|
|
% variable is needed everywhere, the scope of this "everywhere" is only
|
|
% that alternative.
|
|
%
|
|
:- pred add_alt_start(containing_goal_map::in,
|
|
assoc_list(prog_var, where_needed)::in, branch_point::in,
|
|
int::in, goal_id::in, where_needed_map::in, where_needed_map::out) is det.
|
|
|
|
add_alt_start(_, [], _, _, _, !WhereNeededMap).
|
|
add_alt_start(ContainingGoalMap, [Var - BranchWhere0 | WhereNeededList],
|
|
BranchPoint, BranchNum, CurrentId, !WhereNeededMap) :-
|
|
(
|
|
BranchWhere0 = everywhere,
|
|
BranchNumSet = set.make_singleton_set(BranchNum),
|
|
BranchMap = map.singleton(BranchPoint, BranchNumSet),
|
|
BranchWhere = branches(BranchMap)
|
|
;
|
|
BranchWhere0 = branches(_),
|
|
BranchWhere = BranchWhere0
|
|
),
|
|
( map.search(!.WhereNeededMap, Var, OldWhere) ->
|
|
where_needed_upper_bound(ContainingGoalMap, CurrentId,
|
|
BranchWhere, OldWhere, CombinedWhere),
|
|
map.det_update(Var, CombinedWhere, !WhereNeededMap)
|
|
;
|
|
map.det_insert(Var, BranchWhere, !WhereNeededMap)
|
|
),
|
|
add_alt_start(ContainingGoalMap, WhereNeededList, BranchPoint, BranchNum,
|
|
CurrentId, !WhereNeededMap).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred unneeded_refine_goal(hlds_goal::in, hlds_goal::out,
|
|
refined_goal_map::in, refined_goal_map::out) is det.
|
|
|
|
unneeded_refine_goal(Goal0, Goal, !RefinedGoals) :-
|
|
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
|
|
(
|
|
( GoalExpr0 = unify(_, _, _, _, _)
|
|
; GoalExpr0 = plain_call(_, _, _, _, _, _)
|
|
; GoalExpr0 = generic_call(_, _, _, _, _)
|
|
; GoalExpr0 = call_foreign_proc(_, _, _, _, _, _, _)
|
|
),
|
|
Goal = Goal0
|
|
;
|
|
GoalExpr0 = conj(ConjType, Conjuncts0),
|
|
(
|
|
ConjType = plain_conj,
|
|
unneeded_refine_conj(Conjuncts0, Conjuncts, !RefinedGoals),
|
|
GoalExpr = conj(ConjType, Conjuncts),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
ConjType = parallel_conj,
|
|
Goal = Goal0
|
|
)
|
|
;
|
|
GoalExpr0 = switch(SwitchVar, CanFail, Cases0),
|
|
GoalId = goal_info_get_goal_id(GoalInfo0),
|
|
unneeded_refine_cases(Cases0, Cases, !RefinedGoals, GoalId, 1),
|
|
GoalExpr = switch(SwitchVar, CanFail, Cases),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = disj(Disjuncts0),
|
|
GoalId = goal_info_get_goal_id(GoalInfo0),
|
|
unneeded_refine_disj(Disjuncts0, Disjuncts, !RefinedGoals,
|
|
GoalId, 1),
|
|
GoalExpr = disj(Disjuncts),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = if_then_else(Quant, Cond0, Then0, Else0),
|
|
GoalId = goal_info_get_goal_id(GoalInfo0),
|
|
unneeded_refine_ite(Cond0, Cond, Then0, Then, Else0, Else,
|
|
!RefinedGoals, GoalId),
|
|
GoalExpr = if_then_else(Quant, Cond, Then, Else),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = negation(NegGoal0),
|
|
unneeded_refine_goal(NegGoal0, NegGoal, !RefinedGoals),
|
|
GoalExpr = negation(NegGoal),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
;
|
|
GoalExpr0 = scope(Reason, SomeGoal0),
|
|
( Reason = from_ground_term(_, from_ground_term_construct) ->
|
|
Goal = Goal0
|
|
;
|
|
unneeded_refine_goal(SomeGoal0, SomeGoal, !RefinedGoals),
|
|
GoalExpr = scope(Reason, SomeGoal),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo0)
|
|
)
|
|
;
|
|
GoalExpr0 = shorthand(_),
|
|
unexpected($module, $pred, "shorthand")
|
|
).
|
|
|
|
:- pred unneeded_refine_conj(list(hlds_goal)::in, list(hlds_goal)::out,
|
|
refined_goal_map::in, refined_goal_map::out) is det.
|
|
|
|
unneeded_refine_conj([], [], !RefinedGoals).
|
|
unneeded_refine_conj([Goal0 | Goals0], Goals, !RefinedGoals) :-
|
|
unneeded_refine_goal(Goal0, HeadGoal, !RefinedGoals),
|
|
unneeded_refine_conj(Goals0, TailGoals, !RefinedGoals),
|
|
( HeadGoal = hlds_goal(conj(plain_conj, HeadGoals), _) ->
|
|
Goals = HeadGoals ++ TailGoals
|
|
;
|
|
Goals = [HeadGoal | TailGoals]
|
|
).
|
|
|
|
:- pred unneeded_refine_cases(list(case)::in, list(case)::out,
|
|
refined_goal_map::in, refined_goal_map::out,
|
|
goal_id::in, int::in) is det.
|
|
|
|
unneeded_refine_cases([], [], !RefinedGoals, _, _).
|
|
unneeded_refine_cases([Case0 | Cases0], [Case | Cases], !RefinedGoals,
|
|
GoalId, BranchNum) :-
|
|
Case0 = case(MainConsId, OtherConsIds, Goal0),
|
|
unneeded_refine_goal(Goal0, Goal1, !RefinedGoals),
|
|
( map.search(!.RefinedGoals, GoalId - BranchNum, ToInsertGoals) ->
|
|
insert_refine_goals(ToInsertGoals, Goal1, Goal),
|
|
map.delete(GoalId - BranchNum, !RefinedGoals)
|
|
;
|
|
Goal = Goal1
|
|
),
|
|
Case = case(MainConsId, OtherConsIds, Goal),
|
|
unneeded_refine_cases(Cases0, Cases, !RefinedGoals,
|
|
GoalId, BranchNum + 1).
|
|
|
|
:- pred unneeded_refine_disj(list(hlds_goal)::in, list(hlds_goal)::out,
|
|
refined_goal_map::in, refined_goal_map::out,
|
|
goal_id::in, int::in) is det.
|
|
|
|
unneeded_refine_disj([], [], !RefinedGoals, _, _).
|
|
unneeded_refine_disj([Goal0 | Goals0], [Goal | Goals], !RefinedGoals,
|
|
GoalId, BranchNum) :-
|
|
unneeded_refine_goal(Goal0, Goal1, !RefinedGoals),
|
|
( map.search(!.RefinedGoals, GoalId - BranchNum, ToInsertGoals) ->
|
|
insert_refine_goals(ToInsertGoals, Goal1, Goal),
|
|
map.delete(GoalId - BranchNum, !RefinedGoals)
|
|
;
|
|
Goal = Goal1
|
|
),
|
|
unneeded_refine_disj(Goals0, Goals, !RefinedGoals,
|
|
GoalId, BranchNum + 1).
|
|
|
|
:- pred unneeded_refine_ite(hlds_goal::in, hlds_goal::out,
|
|
hlds_goal::in, hlds_goal::out, hlds_goal::in, hlds_goal::out,
|
|
refined_goal_map::in, refined_goal_map::out, goal_id::in) is det.
|
|
|
|
unneeded_refine_ite(Cond0, Cond, Then0, Then, Else0, Else,
|
|
!RefinedGoals, GoalId) :-
|
|
unneeded_refine_goal(Cond0, Cond, !RefinedGoals),
|
|
unneeded_refine_goal(Then0, Then1, !RefinedGoals),
|
|
unneeded_refine_goal(Else0, Else1, !RefinedGoals),
|
|
|
|
( map.search(!.RefinedGoals, GoalId - 1, ToInsertGoalsThen) ->
|
|
insert_refine_goals(ToInsertGoalsThen, Then1, Then),
|
|
map.delete(GoalId - 1, !RefinedGoals)
|
|
;
|
|
Then = Then1
|
|
),
|
|
( map.search(!.RefinedGoals, GoalId - 2, ToInsertGoalsElse) ->
|
|
insert_refine_goals(ToInsertGoalsElse, Else1, Else),
|
|
map.delete(GoalId - 2, !RefinedGoals)
|
|
;
|
|
Else = Else1
|
|
).
|
|
|
|
:- pred insert_refine_goals(list(hlds_goal)::in, hlds_goal::in,
|
|
hlds_goal::out) is det.
|
|
|
|
insert_refine_goals(ToInsertGoals, Goal0, Goal) :-
|
|
list.append(ToInsertGoals, [Goal0], Conj),
|
|
% XXX GoalInfo0
|
|
Goal0 = hlds_goal(_, GoalInfo0),
|
|
conj_list_to_goal(Conj, GoalInfo0, Goal).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Given two sets of requirements about where a goal is needed, return
|
|
% a single requirement that contains all the demands. The main purpose
|
|
% of this predicate is to discover when the union of two sets of
|
|
% requirements (e.g. branch sets {b1,b2} and {b3} covers all
|
|
% computation paths.
|
|
%
|
|
:- pred where_needed_upper_bound(containing_goal_map::in, goal_id::in,
|
|
where_needed::in, where_needed::in, where_needed::out) is det.
|
|
|
|
where_needed_upper_bound(ContainingGoalMap, CurrentId,
|
|
WhereNeededA, WhereNeededB, WhereNeeded) :-
|
|
(
|
|
WhereNeededA = everywhere,
|
|
WhereNeeded = everywhere
|
|
;
|
|
WhereNeededA = branches(BranchesA),
|
|
(
|
|
WhereNeededB = everywhere,
|
|
WhereNeeded = everywhere
|
|
;
|
|
WhereNeededB = branches(BranchesB),
|
|
where_needed_branches_upper_bound(ContainingGoalMap, CurrentId,
|
|
BranchesA, BranchesB, WhereNeeded)
|
|
)
|
|
).
|
|
|
|
:- pred where_needed_branches_upper_bound(containing_goal_map::in, goal_id::in,
|
|
where_needed_branches::in, where_needed_branches::in, where_needed::out)
|
|
is det.
|
|
|
|
where_needed_branches_upper_bound(ContainingGoalMap, CurrentId,
|
|
BranchesA, BranchesB, WhereNeeded) :-
|
|
% We should select the smaller map to convert to list.
|
|
map.to_assoc_list(BranchesA, BranchesList),
|
|
where_needed_branches_upper_bound_2(ContainingGoalMap, CurrentId,
|
|
BranchesList, BranchesB, WhereNeeded).
|
|
|
|
:- pred where_needed_branches_upper_bound_2(containing_goal_map::in,
|
|
goal_id::in, assoc_list(branch_point, set(int))::in,
|
|
where_needed_branches::in, where_needed::out) is det.
|
|
|
|
where_needed_branches_upper_bound_2(_, _, [],
|
|
Branches, branches(Branches)).
|
|
where_needed_branches_upper_bound_2(ContainingGoalMap, CurrentId,
|
|
[First | Rest], Branches0, WhereNeeded) :-
|
|
First = BranchPoint - NewAlts,
|
|
( map.search(Branches0, BranchPoint, OldAlts) ->
|
|
set.union(OldAlts, NewAlts, Alts),
|
|
BranchPoint = branch_point(BranchGoalId, BranchAlts),
|
|
( branch_point_is_complete(BranchAlts, Alts) ->
|
|
(
|
|
get_parent_branch_point(ContainingGoalMap, BranchGoalId,
|
|
ParentBranchGoalId, ParentBranchArmGoalId,
|
|
ParentBranchAlt, ParentBranchNum),
|
|
\+ goal_id_inside(ContainingGoalMap, ParentBranchArmGoalId,
|
|
CurrentId)
|
|
->
|
|
map.delete(BranchPoint, Branches0, Branches1),
|
|
ParentBranchPoint = branch_point(ParentBranchGoalId,
|
|
ParentBranchAlt),
|
|
ParentAlts = set.make_singleton_set(ParentBranchNum),
|
|
where_needed_branches_upper_bound_2(ContainingGoalMap,
|
|
CurrentId, [ParentBranchPoint - ParentAlts | Rest],
|
|
Branches1, WhereNeeded)
|
|
;
|
|
WhereNeeded = everywhere
|
|
)
|
|
;
|
|
map.det_update(BranchPoint, Alts, Branches0, Branches1),
|
|
where_needed_branches_upper_bound_2(ContainingGoalMap, CurrentId,
|
|
Rest, Branches1, WhereNeeded)
|
|
)
|
|
;
|
|
map.det_insert(BranchPoint, NewAlts, Branches0, Branches1),
|
|
where_needed_branches_upper_bound_2(ContainingGoalMap, CurrentId,
|
|
Rest, Branches1, WhereNeeded)
|
|
).
|
|
|
|
:- pred get_parent_branch_point(containing_goal_map::in, goal_id::in,
|
|
goal_id::out, goal_id::out, branch_alts::out, int::out) is semidet.
|
|
|
|
get_parent_branch_point(ContainingGoalMap, GoalId, BranchGoalId,
|
|
BranchArmGoalId, BranchAlt, BranchNum) :-
|
|
map.lookup(ContainingGoalMap, GoalId, GoalContaining),
|
|
GoalContaining = containing_goal(ContainingGoalId, LastStep),
|
|
(
|
|
LastStep = step_switch(Arm, MaybeNumAlts),
|
|
BranchGoalId = ContainingGoalId,
|
|
BranchArmGoalId = GoalId,
|
|
BranchAlt = alt_switch(MaybeNumAlts),
|
|
BranchNum = Arm
|
|
;
|
|
LastStep = step_ite_then,
|
|
BranchGoalId = ContainingGoalId,
|
|
BranchArmGoalId = GoalId,
|
|
BranchAlt = alt_ite,
|
|
BranchNum = 1
|
|
;
|
|
LastStep = step_ite_else,
|
|
BranchGoalId = ContainingGoalId,
|
|
BranchArmGoalId = GoalId,
|
|
BranchAlt = alt_ite,
|
|
BranchNum = 2
|
|
;
|
|
( LastStep = step_ite_cond
|
|
; LastStep = step_neg
|
|
; LastStep = step_scope(_)
|
|
; LastStep = step_conj(_)
|
|
; LastStep = step_disj(_)
|
|
),
|
|
get_parent_branch_point(ContainingGoalMap, ContainingGoalId,
|
|
BranchGoalId, BranchArmGoalId, BranchAlt, BranchNum)
|
|
).
|
|
|
|
:- pred branch_point_is_complete(branch_alts::in, set(int)::in) is semidet.
|
|
|
|
branch_point_is_complete(alt_ite, Alts) :-
|
|
set.count(Alts, NumAlts),
|
|
NumAlts = 2.
|
|
branch_point_is_complete(alt_switch(known_num_functors_in_type(NumFunctors)),
|
|
Alts) :-
|
|
set.count(Alts, NumAlts),
|
|
NumAlts = NumFunctors.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
:- end_module transform_hlds.unneeded_code.
|
|
%---------------------------------------------------------------------------%
|