mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-16 01:43:35 +00:00
2d0bfc0674
Estimated hours taken: 120 Branches: main The algorithm that decides whether the order independent state update transformation is applicable in a given module needs access to the list of oisu pragmas in that module, and to information about the types of variables in the procedures named in those pragmas. This diff puts this information in Deep.procrep files, to make them available to the autoparallelization feedback program, to which that algorithm will later be added. Compilers that have this diff will generate Deep.procrep files in a new, slightly different format, but the deep profiler will be able to read Deep.procrep files not just in the new format, but in the old format as well. runtime/mercury_stack_layout.h: Add to module layout structures the fields holding the new information we want to put into Deep.procrep files. This means three things: - a bytecode array in module layout structures encoding the list of oisu pragmas in the module; - additions to the bytecode arrays in procedure layout structures mapping the procedure's variables to their types; and - a bytecode array containing the encoded versions of those types themselves in the module layout structure. This allows us to represent each type used in the module just once. Since there is now information in module layout structures that is needed only for deep profiling, as well as information that is needed only for debugging, the old arrangement that split a module's information between two structures, MR_ModuleLayout (debug specific info) and MR_ModuleCommonLayout (info used by both debugging and profiling), is no longer approriate. We could add a third structure containing profiling-specific info, but it is simpler to move all the info into just one structure, some of whose fields may not be used. This wastes only a few words of memory per module, but allows the runtime system to avoid unnecessary indirections. runtime/mercury_types.h: Remove the type synonym for the deleted type. runtime/mercury_grade.h: The change in mercury_stack_layout.h destroys binary compatibility with previous versions of Mercury for debug and deep profiling grades, so bump their grade-component-specific version numbers. runtime/mercury_deep_profiling.c: Write out the information in the new fields in module layout structures, if they are filled in. Since this changes the format of the Deep.procrep file, bump its version number. runtime/mercury_deep_profiling.h: runtime/mercury_stack_layout.c: Conform to the change to mercury_stack_layout.h. mdbcomp/program_representation.m: Add to module representations information about the oisu pragmas defined in that module, and the type table of the module. Optionally add to procedure representations a map mapping the variables of the procedure to their types. Rename the old var_table type to be the var_name_table type, since it contains just names. Make the var to type map separate, since it will be there only for selected procedures. Modify the predicates reading in module and procedure representations to allow them to read in the new representation, while still accepting the old one. Use the version number in the Deep.procrep file to decide which format to expect. mdbcomp/rtti_access.m: Add functions to encode the data representations that this module also decodes. Conform to the changes above. mdbcomp/feedback.automatic_parallelism.m: Conform the changes above. mdbcomp/prim_data.m: Fix layout. compiler/layout.m: Update the compiler's representation of layout structures to conform to the change to runtime/mercury_stack_layout.h. compiler/layout_out.m: Output the new parts of module layout structures. compiler/opt_debug.m: Allow the debugging of code referring to the new parts of module layout structures. compiler/llds_out_file.m: Conform to the move to a single module layout structure. compiler/prog_rep_tables.m: This new module provided mechanisms for building the string table and the type table components of module layouts. The string table part is old (it is moved here from stack_layout.m); the type table part is new. Putting this code in a module of its own allows us to remove a circular dependency between prog_rep.m and stack_layout.m; instead, both now just depend on prog_rep_tables.m. compiler/ll_backend.m: Add the new module. compiler/notes/compiler_design.html: Describe the new module. compiler/prog_rep.m: When generating the representation of a module for deep profiling, include the information needed by the order independent state update analysis: the list of oisu pragmas in the module, if any, and information about the types of variables in selected procedures. To avoid having these additions increasing the size of the bytecode representation too much, convert some fixed 32 bit numbers in the bytecode to use variable sized numbers, which will usually be 8 or 16 bits. Do not use predicates from bytecode_gen.m to encode numbers, since there is nothing keeping these in sync with the code that reads them in mdbcomp/program_representation.m. Instead, use new predicates in program_representation.m itself. compiler/stack_layout.m: Generate the new parts of module layouts. Remove the code moved to prog_rep_tables.m. compiler/continuation_info.m: compiler/proc_gen.m: Make some more information available to stack_layout.m. compiler/prog_data.m: Fix some formatting. compiler/introduce_parallelism.m: Conform to the renaming of the var_table type. compiler/follow_code.m: Fix the bug that used to cause the failure of the hard_coded/mode_check_clauses test case in deep profiling grades. deep_profiler/program_representation_utils.m: Output the new parts of module and procedure representations, to allow the correctness of this change to be tested. deep_profiler/mdprof_create_feedback.m: If we cannot read the Deep.procrep file, print a single error message and exit, instead of continuing with an analysis that will generate a whole bunch of error messages, one for each attempt to access a procedure's representation. deep_profiler/mdprof_procrep.m: Give this program an option that specifies what file it is to look at; do not hardwire in "Deep.procrep" in the current directory. deep_profiler/report.m: Add a report type that just prints the representation of a module. It returns the same information as mdprof_procrep, but from within the deep profiler, which can be more convenient. deep_profiler/create_report.m: deep_profiler/display_report.m: Respectively create and display the new report type. deep_profiler/query.m: Recognize a query asking for the new report type. deep_profiler/autopar_calc_overlap.m: deep_profiler/autopar_find_best_par.m: deep_profiler/autopar_reports.m: deep_profiler/autopar_search_callgraph.m: deep_profiler/autopar_search_goals.m: deep_profiler/autopar_types.m: deep_profiler/branch_and_bound.m: deep_profiler/coverage.m: deep_profiler/display.m: deep_profiler/html_format.m: deep_profiler/mdprof_test.m: deep_profiler/measurements.m: deep_profiler/query.m: deep_profiler/read_profile.m: deep_profiler/recursion_patterns.m: deep_profiler/top_procs.m: deep_profiler/top_procs.m: Conform to the changes above. Fix layout. tests/debugger/declarative/dependency.exp2: Add this file as a possible expected output. It contains the new field added to module representations.
423 lines
17 KiB
Mathematica
423 lines
17 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1994-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: follow_code.m.
|
|
% Main author: conway.
|
|
% Extensive modifications by zs.
|
|
%
|
|
% The problem attacked by this module is that sometimes the code generator
|
|
% doesn't know where it should put the values of live variables at the end
|
|
% of a branched control structure. All branches must put each live variable
|
|
% into the same lval, so having each branch leave each live variable where it
|
|
% just happens to be is not an option. We currently just put all live variables
|
|
% into its own rN register or stack slot, but often is not where the variable
|
|
% happens to be at the end of any branch, nor is it where the variable is next
|
|
% needed.
|
|
%
|
|
% The idea used by this module to attack this problem is to try to ensure
|
|
% that the branched control structure is followed immediately either by a call
|
|
% or by the end of the procedure body, because both have clear rules about
|
|
% where every live variable must be. If a branched control structure is
|
|
% followed by builtin goals such as unifications, we push those goals into
|
|
% each branch.
|
|
%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module ll_backend.follow_code.
|
|
:- interface.
|
|
|
|
:- import_module hlds.hlds_module.
|
|
:- import_module hlds.hlds_pred.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_proc(pred_proc_id::in,
|
|
proc_info::in, proc_info::out, module_info::in, module_info::out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module check_hlds.mode_util.
|
|
:- import_module hlds.code_model.
|
|
:- import_module hlds.goal_util.
|
|
:- import_module hlds.hlds_goal.
|
|
:- import_module hlds.hlds_rtti.
|
|
:- import_module hlds.instmap.
|
|
:- import_module hlds.quantification.
|
|
:- import_module parse_tree.prog_data.
|
|
:- import_module parse_tree.set_of_var.
|
|
|
|
:- import_module bool.
|
|
:- import_module list.
|
|
:- import_module require.
|
|
:- import_module set.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
move_follow_code_in_proc(_PredProcId, !ProcInfo, !ModuleInfo) :-
|
|
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),
|
|
move_follow_code_in_goal(Goal0, Goal1, RttiVarMaps0, no, Changed),
|
|
(
|
|
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),
|
|
implicitly_quantify_clause_body_general(
|
|
ordinary_nonlocals_no_lambda,
|
|
HeadVars, _Warnings, Goal1, Goal2,
|
|
Varset0, Varset, VarTypes0, VarTypes,
|
|
RttiVarMaps0, RttiVarMaps),
|
|
proc_info_get_initial_instmap(!.ProcInfo, !.ModuleInfo, InstMap0),
|
|
proc_info_get_inst_varset(!.ProcInfo, InstVarSet),
|
|
recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas,
|
|
Goal2, Goal, VarTypes, InstVarSet, InstMap0, !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)
|
|
;
|
|
Changed = no
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_goal(hlds_goal::in, hlds_goal::out,
|
|
rtti_varmaps::in, bool::in, bool::out) is det.
|
|
|
|
move_follow_code_in_goal(Goal0, Goal, RttiVarMaps, !Changed) :-
|
|
Goal0 = hlds_goal(GoalExpr0, GoalInfo),
|
|
(
|
|
GoalExpr0 = conj(ConjType, Goals0),
|
|
(
|
|
ConjType = plain_conj,
|
|
ConjPurity = goal_info_get_purity(GoalInfo),
|
|
move_follow_code_in_conj(Goals0, ConjPurity, RttiVarMaps, Goals,
|
|
!Changed)
|
|
;
|
|
ConjType = parallel_conj,
|
|
move_follow_code_in_independent_goals(Goals0, Goals, RttiVarMaps,
|
|
!Changed)
|
|
),
|
|
GoalExpr = conj(ConjType, Goals),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
;
|
|
GoalExpr0 = disj(Goals0),
|
|
move_follow_code_in_independent_goals(Goals0, Goals, RttiVarMaps,
|
|
!Changed),
|
|
GoalExpr = disj(Goals),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
;
|
|
GoalExpr0 = negation(SubGoal0),
|
|
move_follow_code_in_goal(SubGoal0, SubGoal, RttiVarMaps, !Changed),
|
|
GoalExpr = negation(SubGoal),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
;
|
|
GoalExpr0 = switch(Var, Det, Cases0),
|
|
move_follow_code_in_cases(Cases0, Cases, RttiVarMaps, !Changed),
|
|
GoalExpr = switch(Var, Det, Cases),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
;
|
|
GoalExpr0 = if_then_else(Vars, Cond0, Then0, Else0),
|
|
move_follow_code_in_goal(Cond0, Cond, RttiVarMaps, !Changed),
|
|
move_follow_code_in_goal(Then0, Then, RttiVarMaps, !Changed),
|
|
move_follow_code_in_goal(Else0, Else, RttiVarMaps, !Changed),
|
|
GoalExpr = if_then_else(Vars, Cond, Then, Else),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
;
|
|
GoalExpr0 = scope(Reason, SubGoal0),
|
|
(
|
|
Reason = from_ground_term(_, FGT),
|
|
( FGT = from_ground_term_construct
|
|
; FGT = from_ground_term_deconstruct
|
|
)
|
|
->
|
|
SubGoal = SubGoal0
|
|
;
|
|
move_follow_code_in_goal(SubGoal0, SubGoal, RttiVarMaps, !Changed)
|
|
),
|
|
GoalExpr = scope(Reason, SubGoal),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
;
|
|
( GoalExpr0 = generic_call(_, _, _, _, _)
|
|
; GoalExpr0 = plain_call(_, _, _, _, _, _)
|
|
; GoalExpr0 = unify(_, _, _, _, _)
|
|
; GoalExpr0 = call_foreign_proc(_, _, _, _, _, _, _)
|
|
),
|
|
Goal = Goal0
|
|
;
|
|
GoalExpr0 = shorthand(_),
|
|
% These should have been expanded out by now.
|
|
unexpected($module, $pred, "shorthand")
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% move_follow_code_in_independent_goals is used both for disjunction and
|
|
% parallel conjunction.
|
|
%
|
|
:- pred move_follow_code_in_independent_goals(list(hlds_goal)::in,
|
|
list(hlds_goal)::out, rtti_varmaps::in, bool::in, bool::out) is det.
|
|
|
|
move_follow_code_in_independent_goals([], [], _, !Changed).
|
|
move_follow_code_in_independent_goals([Goal0 | Goals0], [Goal | Goals],
|
|
RttiVarMaps, !Changed) :-
|
|
move_follow_code_in_goal(Goal0, Goal, RttiVarMaps, !Changed),
|
|
move_follow_code_in_independent_goals(Goals0, Goals, RttiVarMaps,
|
|
!Changed).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_in_cases(list(case)::in, list(case)::out,
|
|
rtti_varmaps::in, bool::in, bool::out) is det.
|
|
|
|
move_follow_code_in_cases([], [], _, !Changed).
|
|
move_follow_code_in_cases([Case0 | Cases0], [Case | Cases], RttiVarMaps,
|
|
!Changed) :-
|
|
Case0 = case(MainConsId, OtherConsIds, Goal0),
|
|
move_follow_code_in_goal(Goal0, Goal, RttiVarMaps, !Changed),
|
|
Case = case(MainConsId, OtherConsIds, Goal),
|
|
move_follow_code_in_cases(Cases0, Cases, RttiVarMaps, !Changed).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Find the first branched structure, and split the conj into those goals
|
|
% before and after it.
|
|
%
|
|
:- pred move_follow_code_in_conj(list(hlds_goal)::in, purity::in,
|
|
rtti_varmaps::in, list(hlds_goal)::out, bool::in, bool::out) is det.
|
|
|
|
move_follow_code_in_conj(Goals0, ConjPurity, RttiVarMaps, Goals, !Changed) :-
|
|
move_follow_code_in_conj_2(Goals0, ConjPurity, RttiVarMaps, [], RevGoals,
|
|
!Changed),
|
|
list.reverse(RevGoals, Goals).
|
|
|
|
:- pred move_follow_code_in_conj_2(list(hlds_goal)::in, purity::in,
|
|
rtti_varmaps::in, list(hlds_goal)::in, list(hlds_goal)::out,
|
|
bool::in, bool::out) is det.
|
|
|
|
move_follow_code_in_conj_2([], _ConjPurity, _RttiVarMaps, !RevPrevGoals,
|
|
!Changed).
|
|
move_follow_code_in_conj_2([Goal0 | Goals0], ConjPurity, RttiVarMaps,
|
|
!RevPrevGoals, !Changed) :-
|
|
(
|
|
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
|
|
goal_util.goal_is_branched(GoalExpr0),
|
|
% A goal that has the mode_check_clauses marker on it will not
|
|
% have its set of output variables updated by recompute_instmap_delta.
|
|
% If we move new code into it, this lack of recomputation will
|
|
% be a bug if that code binds any variables, which it almost certainly
|
|
% will.
|
|
not goal_info_has_feature(GoalInfo0, feature_mode_check_clauses_goal),
|
|
|
|
move_follow_code_select(Goals0, RttiVarMaps, FollowGoals,
|
|
RestGoalsPrime, ConjPurity, WorstPurity),
|
|
FollowGoals = [_ | _],
|
|
% Moving any goals that bind variables into a model_semi (or model_det)
|
|
% disjunction gives that disjunction some outputs, which means that it
|
|
% will become nondet.
|
|
(
|
|
(
|
|
GoalExpr0 = disj(_),
|
|
goal_info_get_code_model(GoalInfo0) \= model_non
|
|
)
|
|
=>
|
|
no_bind_vars(FollowGoals)
|
|
),
|
|
move_follow_code_move_goals(Goal0, FollowGoals, WorstPurity,
|
|
Goal1Prime)
|
|
->
|
|
!:Changed = yes,
|
|
Goal1 = Goal1Prime,
|
|
RestGoals = RestGoalsPrime
|
|
;
|
|
Goal1 = Goal0,
|
|
RestGoals = Goals0
|
|
),
|
|
move_follow_code_in_goal(Goal1, Goal, RttiVarMaps, !Changed),
|
|
!:RevPrevGoals = [Goal | !.RevPrevGoals],
|
|
move_follow_code_in_conj_2(RestGoals, ConjPurity, RttiVarMaps,
|
|
!RevPrevGoals, !Changed).
|
|
|
|
:- pred no_bind_vars(list(hlds_goal)::in) is semidet.
|
|
|
|
no_bind_vars([]).
|
|
no_bind_vars([Goal | Goals]) :-
|
|
Goal = hlds_goal(_, GoalInfo),
|
|
InstMapDelta = goal_info_get_instmap_delta(GoalInfo),
|
|
instmap_delta_changed_vars(InstMapDelta, ChangedVars),
|
|
set_of_var.is_empty(ChangedVars),
|
|
no_bind_vars(Goals).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Split a list of goals into the prefix of builtins and the rest.
|
|
%
|
|
:- pred move_follow_code_select(list(hlds_goal)::in, rtti_varmaps::in,
|
|
list(hlds_goal)::out, list(hlds_goal)::out, purity::in, purity::out)
|
|
is det.
|
|
|
|
move_follow_code_select([], _, [], [], !Purity).
|
|
move_follow_code_select([Goal | Goals], RttiVarMaps, FollowGoals, RestGoals,
|
|
!Purity) :-
|
|
Goal = hlds_goal(GoalExpr, GoalInfo),
|
|
(
|
|
move_follow_code_is_builtin(GoalExpr),
|
|
|
|
% Don't attempt to move existentially typed deconstructions
|
|
% into branched structures. Doing so would confuse the
|
|
% rtti_varmaps structure, which expects type(class)_infos
|
|
% for a given type variable (constraint) to be retrieved from
|
|
% a single location.
|
|
%
|
|
% XXX A better solution might be to introduce exists_cast goals,
|
|
% which would allow separate type variables for each branch and
|
|
% avoid the above confusion.
|
|
%
|
|
\+ (
|
|
GoalExpr = unify(_, _, _, Unification, _),
|
|
Unification = deconstruct(_, _, Args, _, _, _),
|
|
list.member(Arg, Args),
|
|
rtti_varmaps_var_info(RttiVarMaps, Arg, RttiVarInfo),
|
|
RttiVarInfo \= non_rtti_var
|
|
)
|
|
->
|
|
GoalPurity = goal_info_get_purity(GoalInfo),
|
|
!:Purity = worst_purity(!.Purity, GoalPurity),
|
|
move_follow_code_select(Goals, RttiVarMaps, FollowGoals0, RestGoals,
|
|
!Purity),
|
|
FollowGoals = [Goal | FollowGoals0]
|
|
;
|
|
FollowGoals = [],
|
|
RestGoals = [Goal | Goals]
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_move_goals(hlds_goal::in, list(hlds_goal)::in,
|
|
purity::in, hlds_goal::out) is semidet.
|
|
|
|
move_follow_code_move_goals(Goal0, FollowGoals, FollowPurity, Goal) :-
|
|
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
|
|
(
|
|
GoalExpr0 = switch(Var, Det, Cases0),
|
|
move_follow_code_move_goals_cases(Cases0, FollowGoals, FollowPurity,
|
|
Cases),
|
|
GoalExpr = switch(Var, Det, Cases)
|
|
;
|
|
GoalExpr0 = disj(Goals0),
|
|
move_follow_code_move_goals_disj(Goals0, FollowGoals, FollowPurity,
|
|
Goals),
|
|
GoalExpr = disj(Goals)
|
|
;
|
|
GoalExpr0 = if_then_else(Vars, Cond, Then0, Else0),
|
|
follow_code_conjoin_goal_and_goal_list(Then0, FollowGoals,
|
|
FollowPurity, Then),
|
|
follow_code_conjoin_goal_and_goal_list(Else0, FollowGoals,
|
|
FollowPurity, Else),
|
|
GoalExpr = if_then_else(Vars, Cond, Then, Else)
|
|
),
|
|
OldPurity = goal_info_get_purity(GoalInfo0),
|
|
NewPurity = worst_purity(OldPurity, FollowPurity),
|
|
goal_info_set_purity(NewPurity, GoalInfo0, GoalInfo),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_move_goals_cases(list(case)::in, list(hlds_goal)::in,
|
|
purity::in, list(case)::out) is semidet.
|
|
|
|
move_follow_code_move_goals_cases([], _FollowGoals, _FollowPurity, []).
|
|
move_follow_code_move_goals_cases([Case0 | Cases0], FollowGoals, FollowPurity,
|
|
[Case | Cases]) :-
|
|
Case0 = case(MainConsId, OtherConsIds, Goal0),
|
|
follow_code_conjoin_goal_and_goal_list(Goal0, FollowGoals, FollowPurity,
|
|
Goal),
|
|
Case = case(MainConsId, OtherConsIds, Goal),
|
|
move_follow_code_move_goals_cases(Cases0, FollowGoals, FollowPurity,
|
|
Cases).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_move_goals_disj(list(hlds_goal)::in,
|
|
list(hlds_goal)::in, purity::in, list(hlds_goal)::out) is semidet.
|
|
|
|
move_follow_code_move_goals_disj([], _FollowGoals, _FollowPurity, []).
|
|
move_follow_code_move_goals_disj([Goal0 | Goals0], FollowGoals, FollowPurity,
|
|
[Goal | Goals]) :-
|
|
follow_code_conjoin_goal_and_goal_list(Goal0, FollowGoals, FollowPurity,
|
|
Goal),
|
|
move_follow_code_move_goals_disj(Goals0, FollowGoals, FollowPurity, Goals).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Takes a goal and a list of goals, and conjoins them (with a potentially
|
|
% blank goal_info), checking that the determinism of the goal is not
|
|
% changed.
|
|
%
|
|
:- pred follow_code_conjoin_goal_and_goal_list(hlds_goal::in,
|
|
list(hlds_goal)::in, purity::in, hlds_goal::out) is semidet.
|
|
|
|
follow_code_conjoin_goal_and_goal_list(Goal0, FollowGoals, FollowPurity,
|
|
Goal) :-
|
|
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
|
|
Detism0 = goal_info_get_determinism(GoalInfo0),
|
|
determinism_components(Detism0, _CanFail0, MaxSolns0),
|
|
(
|
|
MaxSolns0 = at_most_zero,
|
|
Goal = Goal0
|
|
;
|
|
( MaxSolns0 = at_most_one
|
|
; MaxSolns0 = at_most_many
|
|
; MaxSolns0 = at_most_many_cc
|
|
),
|
|
check_follow_code_detism(FollowGoals, Detism0),
|
|
( GoalExpr0 = conj(plain_conj, Conjuncts0) ->
|
|
GoalExpr = conj(plain_conj, Conjuncts0 ++ FollowGoals)
|
|
;
|
|
GoalExpr = conj(plain_conj, [Goal0 | FollowGoals])
|
|
),
|
|
OldPurity = goal_info_get_purity(GoalInfo0),
|
|
NewPurity = worst_purity(OldPurity, FollowPurity),
|
|
goal_info_set_purity(NewPurity, GoalInfo0, GoalInfo),
|
|
Goal = hlds_goal(GoalExpr, GoalInfo)
|
|
).
|
|
|
|
% This check is necessary to make sure that follow_code doesn't change
|
|
% the determinism of the goal.
|
|
%
|
|
:- pred check_follow_code_detism(list(hlds_goal)::in, determinism::in)
|
|
is semidet.
|
|
|
|
check_follow_code_detism([], _).
|
|
check_follow_code_detism([hlds_goal(_, GoalInfo) | Goals], Detism0) :-
|
|
Detism1 = goal_info_get_determinism(GoalInfo),
|
|
det_conjunction_detism(Detism0, Detism1, Detism0),
|
|
check_follow_code_detism(Goals, Detism0).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred move_follow_code_is_builtin(hlds_goal_expr::in) is semidet.
|
|
|
|
move_follow_code_is_builtin(GoalExpr) :-
|
|
(
|
|
GoalExpr = unify(_, _, _, Unification, _),
|
|
Unification \= complicated_unify(_, _, _)
|
|
;
|
|
GoalExpr = plain_call(_, _, _, inline_builtin, _, _)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
:- end_module ll_backend.follow_code.
|
|
%-----------------------------------------------------------------------------%
|