diff --git a/compiler/accumulator.m b/compiler/accumulator.m index d40221fe2..c0e2e0f4e 100644 --- a/compiler/accumulator.m +++ b/compiler/accumulator.m @@ -1636,14 +1636,16 @@ create_orig_goal(Call, Substs, HeadToCallSubst, CallToHeadSubst, U = create_new_orig_recursive_goals(UpdateBase, Update, HeadToCallSubst, UpdateSubst, C), + Call = hlds_goal(_, CallGoalInfo), + Context = goal_info_get_context(CallGoalInfo), rename_some_vars_in_goal(CallToHeadSubst, Call, BaseCall), Cbefore = accu_goal_list(set.to_sorted_list(Before), C), Uupdate = accu_goal_list(set.to_sorted_list(UpdateBase) ++ set.to_sorted_list(Update), U), Cbase = accu_goal_list(base_case_ids(C), C), - calculate_goal_info(conj(plain_conj, Cbefore ++ Uupdate ++ [BaseCall]), - OrigRecGoal), - calculate_goal_info(conj(plain_conj, Cbase), OrigBaseGoal). + calculate_goal_info(Context, + conj(plain_conj, Cbefore ++ Uupdate ++ [BaseCall]), OrigRecGoal), + calculate_goal_info(Context, conj(plain_conj, Cbase), OrigBaseGoal). % Create the goals which are to go in the new accumulator version % of the predicate. @@ -1684,13 +1686,16 @@ create_acc_goal(Call, Substs, HeadToCallSubst, BaseIds, BasePairs, Sets, BaseCase = accu_goal_list(set.to_sorted_list(AssocBase `union` OtherBase) ++ Bafter, B), - list.map(acc_unification, BasePairs, UpdateBase), + Call = hlds_goal(_, CallGoalInfo), + Context = goal_info_get_context(CallGoalInfo), + list.map(acc_unification(Context), BasePairs, UpdateBase), - calculate_goal_info( + calculate_goal_info(Context, conj(plain_conj, Cbefore ++ Rassoc ++ Rupdate ++ [RecCall] ++ Rconstruct), AccRecGoal), - calculate_goal_info(conj(plain_conj, UpdateBase ++ BaseCase), AccBaseGoal). + calculate_goal_info(Context, + conj(plain_conj, UpdateBase ++ BaseCase), AccBaseGoal). % Create the U set of goals (those that will be used in the original % recursive case) by renaming all the goals which are used to initialize @@ -1737,16 +1742,18 @@ create_new_base_goals(Ids, C, AccVarSubst, HeadToCallSubst) % % is true if Goal represents the assignment unification Out = Acc. % -:- pred acc_unification(pair(prog_var)::in, hlds_goal::out) is det. +:- pred acc_unification(prog_context::in, pair(prog_var)::in, + hlds_goal::out) is det. -acc_unification(Out - Acc, Goal) :- +acc_unification(Context, Out - Acc, Goal) :- UnifyMode = unify_modes_li_lf_ri_rf(free, ground_inst, ground_inst, ground_inst), - Context = unify_context(umc_explicit, []), - Expr = unify(Out, rhs_var(Acc), UnifyMode, assign(Out,Acc), Context), + UnifyContext = unify_context(umc_explicit, []), + Expr = unify(Out, rhs_var(Acc), UnifyMode, assign(Out,Acc), UnifyContext), set_of_var.list_to_set([Out, Acc], NonLocalVars), InstMapDelta = instmap_delta_bind_var(Out), - goal_info_init(NonLocalVars, InstMapDelta, detism_det, purity_pure, Info), + goal_info_init(NonLocalVars, InstMapDelta, detism_det, purity_pure, + Context, Info), Goal = hlds_goal(Expr, Info). %---------------------------------------------------------------------------% @@ -1904,15 +1911,17 @@ accu_goal_list(Ids, GS) = Goals :- %---------------------------------------------------------------------------% %---------------------------------------------------------------------------% -:- pred calculate_goal_info(hlds_goal_expr::in, hlds_goal::out) is det. +:- pred calculate_goal_info(prog_context::in, hlds_goal_expr::in, + hlds_goal::out) is det. -calculate_goal_info(GoalExpr, hlds_goal(GoalExpr, GoalInfo)) :- +calculate_goal_info(Context, GoalExpr, hlds_goal(GoalExpr, GoalInfo)) :- ( if GoalExpr = conj(plain_conj, GoalList) then goal_list_nonlocals(GoalList, NonLocals), goal_list_instmap_delta(GoalList, InstMapDelta), goal_list_determinism(GoalList, Detism), - goal_info_init(NonLocals, InstMapDelta, Detism, purity_pure, GoalInfo) + goal_info_init(NonLocals, InstMapDelta, Detism, purity_pure, + Context, GoalInfo) else unexpected($pred, "not a conj") ). diff --git a/compiler/add_clause.m b/compiler/add_clause.m index 9b3f0a086..f02a4b6dd 100644 --- a/compiler/add_clause.m +++ b/compiler/add_clause.m @@ -839,12 +839,12 @@ add_clause_transform(KeepQuantVars, Renaming, PredOrFunc, PredSymName, InitialSVarState = !.SVarState, ( ClauseType = clause_for_promise(_), - HeadUnificationsGoal = true_goal + HeadUnificationsGoal = true_goal(Context) ; ClauseType = clause_not_for_promise, PredFormArity = arg_list_arity(ArgTerms0), ArgContext = ac_head(PredOrFunc, PredFormArity), - HeadUnificationsGoal0 = true_goal, + HeadUnificationsGoal0 = true_goal(Context), pair_vars_with_terms(HeadVars, ArgTerms, HeadVarsArgTerms), insert_arg_unifications(HeadVarsArgTerms, Context, ArgContext, HeadUnificationsGoal0, HeadUnificationsGoal1, diff --git a/compiler/add_heap_ops.m b/compiler/add_heap_ops.m index ffcf658d4..0d6e01c98 100644 --- a/compiler/add_heap_ops.m +++ b/compiler/add_heap_ops.m @@ -168,8 +168,8 @@ goal_expr_add_heap_ops(GoalExpr0, GoalInfo0, Goal, !Info) :- InnerGoal = hlds_goal(_, InnerGoalInfo), Determinism = goal_info_get_determinism(InnerGoalInfo), determinism_components(Determinism, _CanFail, NumSolns), - True = true_goal_with_context(Context), - Fail = fail_goal_with_context(Context), + True = true_goal(Context), + Fail = fail_goal(Context), ( NumSolns = at_most_zero, % The "then" part of the if-then-else will be unreachable, but to diff --git a/compiler/add_pragma_type_spec.m b/compiler/add_pragma_type_spec.m index 0b4e5436f..61c76b3ac 100644 --- a/compiler/add_pragma_type_spec.m +++ b/compiler/add_pragma_type_spec.m @@ -429,10 +429,9 @@ add_forcing_caller_of_pred(PredId, PredInfo0, PredFormArity, TypeSpecInfo0, ArgVarSet0, ArgVarSet), pred_info_get_context(PredInfo0, PredContext), - goal_info_init(GoalInfo0), + goal_info_init(PredContext, GoalInfo0), set_of_var.list_to_set(ArgVars, NonLocals), - goal_info_set_nonlocals(NonLocals, GoalInfo0, GoalInfo1), - goal_info_set_context(PredContext, GoalInfo1, GoalInfo), + goal_info_set_nonlocals(NonLocals, GoalInfo0, GoalInfo), % We don't record the called predicate as used -- it is only used % if there is some other call. This call is only used to make diff --git a/compiler/add_trail_ops.m b/compiler/add_trail_ops.m index 773ec6bf6..cf536e953 100644 --- a/compiler/add_trail_ops.m +++ b/compiler/add_trail_ops.m @@ -184,8 +184,8 @@ goal_expr_add_trail_ops(GoalExpr0, GoalInfo0, Goal, !Info) :- InnerGoal = hlds_goal(_, InnerGoalInfo), Determinism = goal_info_get_determinism(InnerGoalInfo), determinism_components(Determinism, _CanFail, NumSolns), - True = true_goal_with_context(Context), - Fail = fail_goal_with_context(Context), + True = true_goal(Context), + Fail = fail_goal(Context), ( NumSolns = at_most_zero, % The "then" part of the if-then-else will be unreachable, but @@ -244,7 +244,7 @@ goal_expr_add_trail_ops(GoalExpr0, GoalInfo0, Goal, !Info) :- gen_reset_ticket_undo(TicketVar, Context, ResetTicketUndoGoal, !.Info), gen_discard_ticket(Context, DiscardTicketGoal, !.Info), - FailGoal = fail_goal_with_context(Context), + FailGoal = fail_goal(Context), % Put it all together. Goal2 = hlds_goal(scope(Reason, InnerGoal), OuterGoalInfo), diff --git a/compiler/complexity.m b/compiler/complexity.m index cf9f376af..15057bb2f 100644 --- a/compiler/complexity.m +++ b/compiler/complexity.m @@ -599,7 +599,7 @@ is_active_type = Type :- make_type_info_var(Type, Context, PredId, !ProcInfo, !ModuleInfo, TypeInfoVar, TypeInfoGoals) :- module_info_pred_info(!.ModuleInfo, PredId, PredInfo0), - polymorphism_make_type_info_var_mi(Type, Context, + polymorphism_make_type_info_var_mi(Context, Type, TypeInfoVar, TypeInfoGoals, !ModuleInfo, PredInfo0, PredInfo, !ProcInfo), expect(unify(PredInfo0, PredInfo), $pred, "modified pred_info"). diff --git a/compiler/coverage_profiling.m b/compiler/coverage_profiling.m index c465ad27f..9d8818c42 100644 --- a/compiler/coverage_profiling.m +++ b/compiler/coverage_profiling.m @@ -359,7 +359,8 @@ coverage_prof_second_pass_goal(Goal0, Goal, RevGoalPath = goal_id_to_reverse_path(ContainingGoalMap, GoalId), CPInfo = coverage_point_info(RevGoalPath, CPType), - make_coverage_point(CPOptions, CPInfo, CPGoals, !Info), + Context = goal_info_get_context(GoalInfo1), + make_coverage_point(CPOptions, CPInfo, Context, CPGoals, !Info), create_conj_from_list([Goal1 | CPGoals], plain_conj, Goal), AddedImpurity = yes @@ -495,7 +496,8 @@ coverage_prof_second_pass_disj_2(DPInfo, % Insert the coverage point if we decided to above. ( InsertCP = yes, - DisjId = goal_info_get_goal_id(HeadDisjunct0 ^ hg_info), + HeadDisjunct0 = hlds_goal(_, HeadDisjunctGoalInfo0), + DisjId = goal_info_get_goal_id(HeadDisjunctGoalInfo0), ContainingGoalMap = !.Info ^ ci_containing_goal_map, DisjPath = goal_id_to_reverse_path(ContainingGoalMap, DisjId), HeadCoveragePoint = coverage_point_info(DisjPath, cp_type_branch_arm), @@ -1106,7 +1108,9 @@ coverage_prof_first_pass_switchcase(CPOptions, proc_coverage_info::in, proc_coverage_info::out) is det. insert_coverage_point_before(CPOptions, CPInfo, !Goal, !Info) :- - make_coverage_point(CPOptions, CPInfo, CPGoals, !Info), + !.Goal = hlds_goal(_, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), + make_coverage_point(CPOptions, CPInfo, Context, CPGoals, !Info), ( if !.Goal = hlds_goal(conj(plain_conj, InnerGoals), _) then Goals = CPGoals ++ InnerGoals else @@ -1118,10 +1122,11 @@ insert_coverage_point_before(CPOptions, CPInfo, !Goal, !Info) :- % for a coverage point. % :- pred make_coverage_point(coverage_profiling_options::in, - coverage_point_info::in, list(hlds_goal)::out, + coverage_point_info::in, prog_context::in, list(hlds_goal)::out, proc_coverage_info::in, proc_coverage_info::out) is det. -make_coverage_point(CPOptions, CoveragePointInfo, Goals, !CoverageInfo) :- +make_coverage_point(CPOptions, CoveragePointInfo, Context, + Goals, !CoverageInfo) :- CoveragePointInfos0 = !.CoverageInfo ^ ci_coverage_points, CPIndexCounter0 = !.CoverageInfo ^ ci_cp_index_counter, @@ -1137,13 +1142,13 @@ make_coverage_point(CPOptions, CoveragePointInfo, Goals, !CoverageInfo) :- !:VarTable = !.CoverageInfo ^ ci_var_table, generate_var_int("CPIndex", CPIndexVar, !VarTable), - generate_deep_const_unify(some_int_const(int_const(CPIndex)), + generate_deep_const_unify(Context, some_int_const(int_const(CPIndex)), CPIndexVar, GoalUnifyIndex), % When using dynamic coverage profiling we really on this variable % being optimised away later. generate_var_c_ptr("ProcLayout", ProcLayoutVar, !VarTable), proc_static_cons_id(!.CoverageInfo, ProcStaticConsId), - generate_deep_const_unify(ProcStaticConsId, ProcLayoutVar, + generate_deep_const_unify(Context, ProcStaticConsId, ProcLayoutVar, GoalUnifyProcLayout), !CoverageInfo ^ ci_var_table := !.VarTable @@ -1195,12 +1200,12 @@ make_coverage_point(CPOptions, CoveragePointInfo, Goals, !CoverageInfo) :- ForeignArgVars, [], no, ForeignProc), NonLocals = set_of_var.list_to_set(ArgVars), InstMapDelta = instmap_delta_from_assoc_list([]), - CallGoalInfo = impure_init_goal_info(NonLocals, InstMapDelta, - detism_det), + impure_init_goal_info(NonLocals, InstMapDelta, detism_det, Context, + CallGoalInfo), CallGoal = hlds_goal(CallGoalExpr, CallGoalInfo) ; UseCalls = yes, - generate_deep_call(ModuleInfo, PredName, PredArity, ArgVars, + generate_deep_call(ModuleInfo, Context, PredName, PredArity, ArgVars, yes([]), detism_det, CallGoal) ), diff --git a/compiler/dead_proc_elim.m b/compiler/dead_proc_elim.m index 43a03ae05..e5441ebee 100644 --- a/compiler/dead_proc_elim.m +++ b/compiler/dead_proc_elim.m @@ -1158,7 +1158,8 @@ dead_proc_eliminate_pred(ElimOptImported, PredId, !ProcElimInfo) :- DestroyGoal = ( pred(Id::in, PTable0::in, PTable::out) is det :- map.lookup(ProcTable0, Id, ProcInfo0), - proc_info_set_goal(true_goal, ProcInfo0, ProcInfo), + proc_info_get_context(ProcInfo0, Context), + proc_info_set_goal(true_goal(Context), ProcInfo0, ProcInfo), map.det_update(Id, ProcInfo, PTable0, PTable) ), ElimWhat = elim_whole_pred(elim_deleted_goal), diff --git a/compiler/deep_profiling.m b/compiler/deep_profiling.m index a6061812f..09b3f5524 100644 --- a/compiler/deep_profiling.m +++ b/compiler/deep_profiling.m @@ -37,12 +37,12 @@ :- pred apply_deep_profiling_transform(io.text_output_stream::in, module_info::in, module_info::out) is det. -:- pred generate_deep_call(module_info::in, string::in, int::in, - list(prog_var)::in, maybe(list(prog_var))::in, determinism::in, - hlds_goal::out) is det. +:- pred generate_deep_call(module_info::in, prog_context::in, + string::in, int::in, list(prog_var)::in, maybe(list(prog_var))::in, + determinism::in, hlds_goal::out) is det. -:- pred generate_deep_const_unify(cons_id::in, prog_var::in, hlds_goal::out) - is det. +:- pred generate_deep_const_unify(prog_context::in, cons_id::in, prog_var::in, + hlds_goal::out) is det. :- pred get_deep_profile_builtin_ppid(module_info::in, string::in, int::in, pred_id::out, proc_id::out) is det. @@ -772,7 +772,7 @@ deep_prof_transform_normal_proc(ModuleInfo, PredProcId, !ProcInfo, CallSites, CoveragePoints), ShroudedPredProcId = shroud_pred_proc_id(proc(PredId, ProcId)), ProcStaticConsId = deep_profiling_proc_layout(ShroudedPredProcId), - generate_deep_const_unify(ProcStaticConsId, ProcStaticVar, + generate_deep_const_unify(Context, ProcStaticConsId, ProcStaticVar, BindProcStaticVarGoal), % Wrap the procedure body inside more goals that invoke the port codes @@ -864,23 +864,24 @@ is_proc_in_interface(ModuleInfo, PredId, _ProcId) = IsInInterface :- build_det_proc_body(ModuleInfo, TopCSD, MiddleCSD, ProcStaticVar, MaybeActivationPtr, GoalInfo0, BindProcStaticVarGoal, Goal0, Goal) :- + Context = goal_info_get_context(GoalInfo0), ( MaybeActivationPtr = yes(ActivationPtr1), - generate_deep_det_call(ModuleInfo, "det_call_port_code_sr", 4, + generate_deep_det_call(ModuleInfo, Context, "det_call_port_code_sr", 4, [ProcStaticVar, TopCSD, MiddleCSD, ActivationPtr1], [TopCSD, MiddleCSD, ActivationPtr1], CallPortCode0), goal_add_feature(feature_save_deep_excp_vars, CallPortCode0, CallPortCode), - generate_deep_det_call(ModuleInfo, "det_exit_port_code_sr", 3, + generate_deep_det_call(ModuleInfo, Context, "det_exit_port_code_sr", 3, [TopCSD, MiddleCSD, ActivationPtr1], [], ExitPortCode) ; MaybeActivationPtr = no, - generate_deep_det_call(ModuleInfo, "det_call_port_code_ac", 3, + generate_deep_det_call(ModuleInfo, Context, "det_call_port_code_ac", 3, [ProcStaticVar, TopCSD, MiddleCSD], [TopCSD, MiddleCSD], CallPortCode0), goal_add_feature(feature_save_deep_excp_vars, CallPortCode0, CallPortCode), - generate_deep_det_call(ModuleInfo, "det_exit_port_code_ac", 2, + generate_deep_det_call(ModuleInfo, Context, "det_exit_port_code_ac", 2, [TopCSD, MiddleCSD], [], ExitPortCode) ), @@ -898,42 +899,49 @@ build_det_proc_body(ModuleInfo, TopCSD, MiddleCSD, ProcStaticVar, % If changing this transformation be sure to change original_root/3 in % deep_profiler/program_represenentation_utils.m. % -:- pred build_semi_proc_body(module_info::in, prog_var::in, prog_var::in, - prog_var::in, maybe(prog_var)::in, hlds_goal_info::in, hlds_goal::in, +:- pred build_semi_proc_body(module_info::in, + prog_var::in, prog_var::in, prog_var::in, + maybe(prog_var)::in, hlds_goal_info::in, hlds_goal::in, hlds_goal::in, hlds_goal::out) is det. build_semi_proc_body(ModuleInfo, TopCSD, MiddleCSD, ProcStaticVar, MaybeActivationPtr, GoalInfo0, BindProcStaticVarGoal, Goal0, Goal) :- + Context = goal_info_get_context(GoalInfo0), ( MaybeActivationPtr = yes(ActivationPtr1), - generate_deep_det_call(ModuleInfo, "semi_call_port_code_sr", 4, + generate_deep_det_call(ModuleInfo, Context, + "semi_call_port_code_sr", 4, [ProcStaticVar, TopCSD, MiddleCSD, ActivationPtr1], [TopCSD, MiddleCSD, ActivationPtr1], CallPortCode0), goal_add_feature(feature_save_deep_excp_vars, CallPortCode0, CallPortCode), - generate_deep_det_call(ModuleInfo, "semi_exit_port_code_sr", 3, + generate_deep_det_call(ModuleInfo, Context, + "semi_exit_port_code_sr", 3, [TopCSD, MiddleCSD, ActivationPtr1], [], ExitPortCode), - generate_deep_call(ModuleInfo, "semi_fail_port_code_sr", 3, + generate_deep_call(ModuleInfo, Context, + "semi_fail_port_code_sr", 3, [TopCSD, MiddleCSD, ActivationPtr1], maybe.no, detism_failure, FailPortCode), NewNonlocals = set_of_var.list_to_set([TopCSD, MiddleCSD, ActivationPtr1]) ; MaybeActivationPtr = no, - generate_deep_det_call(ModuleInfo, "semi_call_port_code_ac", 3, - [ProcStaticVar, TopCSD, MiddleCSD], + generate_deep_det_call(ModuleInfo, Context, + "semi_call_port_code_ac", 3, [ProcStaticVar, TopCSD, MiddleCSD], [TopCSD, MiddleCSD], CallPortCode0), goal_add_feature(feature_save_deep_excp_vars, CallPortCode0, CallPortCode), - generate_deep_det_call(ModuleInfo, "semi_exit_port_code_ac", 2, - [TopCSD, MiddleCSD], [], ExitPortCode), - generate_deep_call(ModuleInfo, "semi_fail_port_code_ac", 2, - [TopCSD, MiddleCSD], maybe.no, detism_failure, FailPortCode), + generate_deep_det_call(ModuleInfo, Context, + "semi_exit_port_code_ac", 2, [TopCSD, MiddleCSD], + [], ExitPortCode), + generate_deep_call(ModuleInfo, Context, + "semi_fail_port_code_ac", 2, [TopCSD, MiddleCSD], + maybe.no, detism_failure, FailPortCode), NewNonlocals = set_of_var.list_to_set([TopCSD, MiddleCSD]) ), - ExitConjGoalInfo = goal_info_add_nonlocals_make_impure(GoalInfo0, - NewNonlocals), + goal_info_add_nonlocals_make_impure(NewNonlocals, + GoalInfo0, ExitConjGoalInfo), make_impure(GoalInfo0, GoalInfo), GoalExpr = conj(plain_conj, [ @@ -949,46 +957,48 @@ build_semi_proc_body(ModuleInfo, TopCSD, MiddleCSD, ProcStaticVar, ]), Goal = hlds_goal(GoalExpr, GoalInfo). -:- pred build_non_proc_body(module_info::in, prog_var::in, prog_var::in, - prog_var::in, maybe(prog_var)::in, prog_var::in, hlds_goal_info::in, +:- pred build_non_proc_body(module_info::in, + prog_var::in, prog_var::in, prog_var::in, + maybe(prog_var)::in, prog_var::in, hlds_goal_info::in, hlds_goal::in, hlds_goal::in, hlds_goal::out) is det. build_non_proc_body(ModuleInfo, TopCSD, MiddleCSD, ProcStaticVar, MaybeOldActivationPtr, NewOutermostProcDyn, GoalInfo0, BindProcStaticVarGoal, Goal0, Goal) :- + Context = goal_info_get_context(GoalInfo0), ( MaybeOldActivationPtr = yes(OldOutermostProcDyn2), - generate_deep_det_call(ModuleInfo, "non_call_port_code_sr", 5, + generate_deep_det_call(ModuleInfo, Context, "non_call_port_code_sr", 5, [ProcStaticVar, TopCSD, MiddleCSD, OldOutermostProcDyn2, NewOutermostProcDyn], [TopCSD, MiddleCSD, OldOutermostProcDyn2, NewOutermostProcDyn], CallPortCode0), goal_add_feature(feature_save_deep_excp_vars, CallPortCode0, CallPortCode), - generate_deep_det_call(ModuleInfo, "non_exit_port_code_sr", 3, + generate_deep_det_call(ModuleInfo, Context, "non_exit_port_code_sr", 3, [TopCSD, MiddleCSD, OldOutermostProcDyn2], [], ExitPortCode), - generate_deep_call(ModuleInfo, "non_fail_port_code_sr", 3, + generate_deep_call(ModuleInfo, Context, "non_fail_port_code_sr", 3, [TopCSD, MiddleCSD, OldOutermostProcDyn2], maybe.no, detism_failure, FailPortCode), - generate_deep_call(ModuleInfo, "non_redo_port_code_sr", 2, + generate_deep_call(ModuleInfo, Context, "non_redo_port_code_sr", 2, [MiddleCSD, NewOutermostProcDyn], maybe.no, detism_failure, RedoPortCode0), NewNonlocals = set_of_var.list_to_set([TopCSD, MiddleCSD, OldOutermostProcDyn2]) ; MaybeOldActivationPtr = no, - generate_deep_det_call(ModuleInfo, "non_call_port_code_ac", 4, + generate_deep_det_call(ModuleInfo, Context, "non_call_port_code_ac", 4, [ProcStaticVar, TopCSD, MiddleCSD, NewOutermostProcDyn], [TopCSD, MiddleCSD, NewOutermostProcDyn], CallPortCode0), goal_add_feature(feature_save_deep_excp_vars, CallPortCode0, CallPortCode), - generate_deep_det_call(ModuleInfo, "non_exit_port_code_ac", 2, + generate_deep_det_call(ModuleInfo, Context, "non_exit_port_code_ac", 2, [TopCSD, MiddleCSD], [], ExitPortCode), - generate_deep_call(ModuleInfo, "non_fail_port_code_ac", 2, + generate_deep_call(ModuleInfo, Context, "non_fail_port_code_ac", 2, [TopCSD, MiddleCSD], maybe.no, detism_failure, FailPortCode), - generate_deep_call(ModuleInfo, "non_redo_port_code_ac", 2, + generate_deep_call(ModuleInfo, Context, "non_redo_port_code_ac", 2, [MiddleCSD, NewOutermostProcDyn], maybe.no, detism_failure, RedoPortCode0), NewNonlocals = set_of_var.list_to_set([TopCSD, MiddleCSD]) @@ -1011,11 +1021,11 @@ build_non_proc_body(ModuleInfo, TopCSD, MiddleCSD, ProcStaticVar, goal_info_set_determinism(Detism, GoalInfo0, GoalInfo1), set_of_var.insert(NewOutermostProcDyn, NewNonlocals, ExitRedoNonLocals), - ExitRedoGoalInfo = impure_reachable_init_goal_info(ExitRedoNonLocals, - detism_multi), + impure_reachable_init_goal_info(ExitRedoNonLocals, detism_multi, Context, + ExitRedoGoalInfo), - CallExitRedoGoalInfo = goal_info_add_nonlocals_make_impure(GoalInfo1, - ExitRedoNonLocals), + goal_info_add_nonlocals_make_impure(ExitRedoNonLocals, + GoalInfo1, CallExitRedoGoalInfo), make_impure(GoalInfo1, GoalInfo), GoalExpr = conj(plain_conj, [ @@ -1270,12 +1280,13 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- % NULL only temporarily, between the prepare_for_{...}_call and the % call port code). Goal1 = hlds_goal(GoalExpr0, GoalInfo2), + Context = goal_info_get_context(GoalInfo2), SiteNumCounter0 = !.DeepInfo ^ deep_site_num_counter, counter.allocate(SiteNum, SiteNumCounter0, SiteNumCounter), VarTable0 = !.DeepInfo ^ deep_var_table, generate_var_int("SiteNum", SiteNumVar, VarTable0, VarTable1), - generate_deep_const_unify(some_int_const(int_const(SiteNum)), + generate_deep_const_unify(Context, some_int_const(int_const(SiteNum)), SiteNumVar, SiteNumVarGoal), !DeepInfo ^ deep_var_table := VarTable1, !DeepInfo ^ deep_site_num_counter := SiteNumCounter, @@ -1286,11 +1297,11 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- ( CallKind = call_class_normal(PredProcId), ( if set.member(feature_deep_self_tail_rec_call, GoalFeatures) then - generate_deep_det_call(ModuleInfo, "prepare_for_tail_call", 1, - [SiteNumVar], [], PrepareGoal) + generate_deep_det_call(ModuleInfo, Context, + "prepare_for_tail_call", 1, [SiteNumVar], [], PrepareGoal) else - generate_deep_det_call(ModuleInfo, "prepare_for_normal_call", 1, - [SiteNumVar], [], PrepareGoal) + generate_deep_det_call(ModuleInfo, Context, + "prepare_for_normal_call", 1, [SiteNumVar], [], PrepareGoal) ), PredProcId = proc(PredId, ProcId), TypeSubst = compute_type_subst(GoalExpr0, !.DeepInfo), @@ -1320,16 +1331,18 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- Goal2 = Goal1 ; CallKind = call_class_special(_PredProcId, TypeInfoVar), - generate_deep_det_call(ModuleInfo, "prepare_for_special_call", 2, - [SiteNumVar, TypeInfoVar], [], PrepareGoal), + generate_deep_det_call(ModuleInfo, Context, + "prepare_for_special_call", 2, [SiteNumVar, TypeInfoVar], [], + PrepareGoal), CallSite = special_call(FileName, LineNumber, GoalPath), Goal2 = Goal1 ; CallKind = call_class_generic(Generic), ( Generic = higher_order(ClosureVar, _, _, _, _), - generate_deep_det_call(ModuleInfo, "prepare_for_ho_call", 2, - [SiteNumVar, ClosureVar], [], PrepareGoal), + generate_deep_det_call(ModuleInfo, Context, + "prepare_for_ho_call", 2, [SiteNumVar, ClosureVar], [], + PrepareGoal), CallSite = higher_order_call(FileName, LineNumber, GoalPath) ; Generic = class_method(TypeClassInfoVar, @@ -1337,9 +1350,11 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- VarTable2 = !.DeepInfo ^ deep_var_table, generate_var_int("MethodNum", MethodNumVar, VarTable2, VarTable3), !DeepInfo ^ deep_var_table := VarTable3, - generate_deep_const_unify(some_int_const(int_const(MethodNum)), - MethodNumVar, MethodNumVarGoal), - generate_deep_det_call(ModuleInfo, "prepare_for_method_call", 3, + generate_deep_const_unify(Context, + some_int_const(int_const(MethodNum)), MethodNumVar, + MethodNumVarGoal), + generate_deep_det_call(ModuleInfo, Context, + "prepare_for_method_call", 3, [SiteNumVar, TypeClassInfoVar, MethodNumVar], [], PrepareCallGoal), PrepareCallGoal = hlds_goal(_, PrepareCallGoalInfo), @@ -1385,8 +1400,8 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- SaveRestoreVars = [] ; VisSCC = [SCCmember], - generate_recursion_counter_saves_and_restores( - SCCmember ^ rec_call_sites, MiddleCSD, + generate_recursion_counter_saves_and_restores(Context, + MiddleCSD, SCCmember ^ rec_call_sites, CallGoals, ExitGoals, FailGoals, SaveRestoreVars, !DeepInfo) ; VisSCC = [_, _ | _], @@ -1404,18 +1419,17 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- ; CodeModel = model_non ), ExtraVars = set_of_var.list_to_set([MiddleCSD | SaveRestoreVars]), - WrappedGoalGoalInfo0 = - goal_info_add_nonlocals_make_impure(MdprofInstGoalInfo, - ExtraVars), + goal_info_add_nonlocals_make_impure(ExtraVars, + MdprofInstGoalInfo, WrappedGoalGoalInfo0), goal_info_set_mdprof_inst(goal_is_mdprof_inst, WrappedGoalGoalInfo0, WrappedGoalGoalInfo), - ReturnFailsGoalInfo0 = - impure_unreachable_init_goal_info(ExtraVars, detism_failure), + impure_unreachable_init_goal_info(ExtraVars, detism_failure, + Context, ReturnFailsGoalInfo0), goal_info_set_mdprof_inst(goal_is_mdprof_inst, ReturnFailsGoalInfo0, ReturnFailsGoalInfo), - FailGoalInfo0 = fail_goal_info, + FailGoalInfo0 = fail_goal_info(Context), goal_info_set_mdprof_inst(goal_is_mdprof_inst, FailGoalInfo0, FailGoalInfo), FailGoal = hlds_goal(disj([]), FailGoalInfo), @@ -1445,6 +1459,7 @@ deep_prof_wrap_call(Goal0, Goal, !DeepInfo) :- deep_prof_transform_higher_order_call(Globals, CodeModel, Goal0, Goal, !DeepInfo) :- + Goal0 = hlds_goal(_, GoalInfo0), some [!VarTable] ( !:VarTable = !.DeepInfo ^ deep_var_table, @@ -1452,6 +1467,7 @@ deep_prof_transform_higher_order_call(Globals, CodeModel, Goal0, Goal, globals.lookup_bool_option(Globals, use_activation_counts, UseActivationCounts), + ModuleInfo = !.DeepInfo ^ deep_module_info, ( UseActivationCounts = yes, @@ -1459,14 +1475,14 @@ deep_prof_transform_higher_order_call(Globals, CodeModel, Goal0, Goal, ExtraNonLocals = set_of_var.list_to_set([SavedCountVar, SavedPtrVar]), - generate_deep_det_call(!.DeepInfo ^ deep_module_info, + generate_deep_det_call(ModuleInfo, Context, "save_and_zero_activation_info_ac", 2, [SavedCountVar, SavedPtrVar], [SavedCountVar, SavedPtrVar], SaveStuff), - generate_deep_det_call(!.DeepInfo ^ deep_module_info, + generate_deep_det_call(ModuleInfo, Context, "reset_activation_info_ac", 2, [SavedCountVar, SavedPtrVar], [], RestoreStuff), - generate_deep_det_call(!.DeepInfo ^ deep_module_info, + generate_deep_det_call(ModuleInfo, Context, "rezero_activation_info_ac", 0, [], [], ReZeroStuff) ; @@ -1474,13 +1490,13 @@ deep_prof_transform_higher_order_call(Globals, CodeModel, Goal0, Goal, ExtraNonLocals = set_of_var.make_singleton(SavedPtrVar), - generate_deep_det_call(!.DeepInfo ^ deep_module_info, + generate_deep_det_call(ModuleInfo, Context, "save_and_zero_activation_info_sr", 1, [SavedPtrVar], [SavedPtrVar], SaveStuff), - generate_deep_det_call(!.DeepInfo ^ deep_module_info, + generate_deep_det_call(ModuleInfo, Context, "reset_activation_info_sr", 1, [SavedPtrVar], [], RestoreStuff), - generate_deep_det_call(!.DeepInfo ^ deep_module_info, + generate_deep_det_call(ModuleInfo, Context, "rezero_activation_info_sr", 0, [], [], ReZeroStuff) ), @@ -1488,27 +1504,27 @@ deep_prof_transform_higher_order_call(Globals, CodeModel, Goal0, Goal, !DeepInfo ^ deep_var_table := !.VarTable ), - Goal0 = hlds_goal(_, GoalInfo0), - ExtGoalInfo0 = goal_info_add_nonlocals_make_impure(GoalInfo0, - ExtraNonLocals), + goal_info_add_nonlocals_make_impure(ExtraNonLocals, + GoalInfo0, ExtGoalInfo0), goal_info_set_mdprof_inst(goal_is_mdprof_inst, ExtGoalInfo0, ExtGoalInfo), % XXX We should build up NoBindExtGoalInfo from scratch. instmap_delta_init_reachable(EmptyDelta), goal_info_set_instmap_delta(EmptyDelta, ExtGoalInfo, NoBindExtGoalInfo), - FailGoalInfo0 = fail_goal_info, + Context = goal_info_get_context(GoalInfo0), + FailGoalInfo0 = fail_goal_info(Context), goal_info_set_mdprof_inst(goal_is_mdprof_inst, FailGoalInfo0, FailGoalInfo), FailGoal = hlds_goal(disj([]), FailGoalInfo), - RestoreFailGoalInfo0 = impure_unreachable_init_goal_info(ExtraNonLocals, - detism_failure), + impure_unreachable_init_goal_info(ExtraNonLocals, + detism_failure, Context, RestoreFailGoalInfo0), goal_info_set_mdprof_inst(goal_is_mdprof_inst, RestoreFailGoalInfo0, RestoreFailGoalInfo), - RezeroFailGoalInfo0 = impure_unreachable_init_goal_info(set_of_var.init, - detism_failure), + impure_unreachable_init_goal_info(set_of_var.init, + detism_failure, Context, RezeroFailGoalInfo0), goal_info_set_mdprof_inst(goal_is_mdprof_inst, RezeroFailGoalInfo0, RezeroFailGoalInfo), @@ -1567,6 +1583,7 @@ deep_prof_transform_higher_order_call(Globals, CodeModel, Goal0, Goal, deep_prof_wrap_foreign_code(Goal0, Goal, !DeepInfo) :- Goal0 = hlds_goal(_GoalExpr0, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), GoalId = goal_info_get_goal_id(GoalInfo0), ContainingGoalMap = !.DeepInfo ^ deep_containing_goal_map, GoalPath = goal_id_to_forward_path(ContainingGoalMap, GoalId), @@ -1575,11 +1592,11 @@ deep_prof_wrap_foreign_code(Goal0, Goal, !DeepInfo) :- counter.allocate(SiteNum, SiteNumCounter0, SiteNumCounter), generate_var_int("SiteNum", SiteNumVar, !.DeepInfo ^ deep_var_table, VarTable), - generate_deep_const_unify(some_int_const(int_const(SiteNum)), + generate_deep_const_unify(Context, some_int_const(int_const(SiteNum)), SiteNumVar, SiteNumVarGoal), ModuleInfo = !.DeepInfo ^ deep_module_info, - generate_deep_det_call(ModuleInfo, "prepare_for_callback", 1, + generate_deep_det_call(ModuleInfo, Context, "prepare_for_callback", 1, [SiteNumVar], [], PrepareGoal), goal_info_get_context(GoalInfo0) = context(FileName0, LineNumber), @@ -1671,38 +1688,41 @@ compute_type_subst(_, _) = "". max_save_restore_vector_size = 9. -:- pred generate_recursion_counter_saves_and_restores(list(int)::in, - prog_var::in, list(hlds_goal)::out, list(hlds_goal)::out, +:- pred generate_recursion_counter_saves_and_restores(prog_context::in, + prog_var::in, list(int)::in, + list(hlds_goal)::out, list(hlds_goal)::out, list(hlds_goal)::out, list(prog_var)::out, deep_info::in, deep_info::out) is det. -generate_recursion_counter_saves_and_restores(CSNs, CSDVar, CallGoals, +generate_recursion_counter_saves_and_restores(Context, CSDVar, CSNs, CallGoals, ExitGoals, FailGoals, ExtraVars, !DeepInfo) :- list.chunk(CSNs, max_save_restore_vector_size, CSNChunks), - generate_recursion_counter_saves_and_restores_2(CSNChunks, CSDVar, + generate_recursion_counter_saves_and_restores_2(Context, CSDVar, CSNChunks, CallGoals, ExitGoals, FailGoals, ExtraVars, !DeepInfo). -:- pred generate_recursion_counter_saves_and_restores_2(list(list(int))::in, - prog_var::in, list(hlds_goal)::out, list(hlds_goal)::out, +:- pred generate_recursion_counter_saves_and_restores_2(prog_context::in, + prog_var::in, list(list(int))::in, + list(hlds_goal)::out, list(hlds_goal)::out, list(hlds_goal)::out, list(prog_var)::out, deep_info::in, deep_info::out) is det. -generate_recursion_counter_saves_and_restores_2([], _, [], [], [], [], +generate_recursion_counter_saves_and_restores_2(_, _, [], [], [], [], [], !DeepInfo). -generate_recursion_counter_saves_and_restores_2([Chunk | Chunks], CSDVar, - CallGoals, ExitGoals, FailGoals, ExtraVars, !DeepInfo) :- +generate_recursion_counter_saves_and_restores_2(Context, CSDVar, + [Chunk | Chunks], CallGoals, ExitGoals, FailGoals, ExtraVars, + !DeepInfo) :- list.map_foldl(generate_depth_var, Chunk, DepthVars, !DeepInfo), % We generate three separate variables to hold the constant CSN vector. % If we used only one, the code generator would have to save its value % on the stack when we enter the disjunction that wraps the goal. list.length(Chunk, Length), - generate_csn_vector(Length, Chunk, CSNCallVars, CSNCallGoals, CallCellVar, - !DeepInfo), - generate_csn_vector(Length, Chunk, CSNExitVars, CSNExitGoals, ExitCellVar, - !DeepInfo), - generate_csn_vector(Length, Chunk, CSNFailVars, CSNFailGoals, FailCellVar, - !DeepInfo), + generate_csn_vector(Context, Length, Chunk, + CSNCallVars, CSNCallGoals, CallCellVar, !DeepInfo), + generate_csn_vector(Context, Length, Chunk, + CSNExitVars, CSNExitGoals, ExitCellVar, !DeepInfo), + generate_csn_vector(Context, Length, Chunk, + CSNFailVars, CSNFailGoals, FailCellVar, !DeepInfo), list.condense([CSNCallVars, CSNExitVars, CSNFailVars], CSNExtraVars), CallPredName = string.format("save_recursion_depth_%d", [i(Length)]), @@ -1711,14 +1731,14 @@ generate_recursion_counter_saves_and_restores_2([Chunk | Chunks], CSDVar, FailPredName = string.format("restore_recursion_depth_fail_%d", [i(Length)]), ModuleInfo = !.DeepInfo ^ deep_module_info, - generate_deep_det_call(ModuleInfo, CallPredName, Length + 2, + generate_deep_det_call(ModuleInfo, Context, CallPredName, Length + 2, [CSDVar, CallCellVar | DepthVars], DepthVars, CallCellGoal), - generate_deep_det_call(ModuleInfo, ExitPredName, Length + 2, + generate_deep_det_call(ModuleInfo, Context, ExitPredName, Length + 2, [CSDVar, ExitCellVar | DepthVars], [], ExitCellGoal), - generate_deep_det_call(ModuleInfo, FailPredName, Length + 2, + generate_deep_det_call(ModuleInfo, Context, FailPredName, Length + 2, [CSDVar, FailCellVar | DepthVars], [], FailCellGoal), - generate_recursion_counter_saves_and_restores_2(Chunks, CSDVar, + generate_recursion_counter_saves_and_restores_2(Context, CSDVar, Chunks, TailCallGoals, TailExitGoals, TailFailGoals, TailExtraVars, !DeepInfo), CallGoals = CSNCallGoals ++ [CallCellGoal | TailCallGoals], @@ -1735,20 +1755,21 @@ generate_depth_var(CSN, DepthVar, !DeepInfo) :- generate_var_int(VarName, DepthVar, VarTable0, VarTable), !DeepInfo ^ deep_var_table := VarTable. -:- pred generate_csn_vector(int::in, list(int)::in, list(prog_var)::out, - list(hlds_goal)::out, prog_var::out, +:- pred generate_csn_vector(prog_context::in, int::in, list(int)::in, + list(prog_var)::out, list(hlds_goal)::out, prog_var::out, deep_info::in, deep_info::out) is det. -generate_csn_vector(Length, CSNs, CSNVars, UnifyGoals, CellVar, !DeepInfo) :- +generate_csn_vector(Context, Length, CSNs, + CSNVars, UnifyGoals, CellVar, !DeepInfo) :- ( if CSNs = [CSN] then - generate_single_csn_unify(CSN, CSNVar - UnifyGoal, !DeepInfo), + generate_single_csn_unify(Context, CSN, CSNVar - UnifyGoal, !DeepInfo), CSNVars = [CSNVar], UnifyGoals = [UnifyGoal], CellVar = CSNVar else expect(Length =< max_save_restore_vector_size, $pred, "too long"), - list.map_foldl(generate_single_csn_unify, CSNs, CSNVarsGoals, - !DeepInfo), + list.map_foldl(generate_single_csn_unify(Context), + CSNs, CSNVarsGoals, !DeepInfo), InnerVars = assoc_list.keys(CSNVarsGoals), InnerGoals = assoc_list.values(CSNVarsGoals), generate_csn_vector_cell(Length, InnerVars, CellVar, CellGoal, @@ -1774,26 +1795,28 @@ generate_csn_vector_cell(Length, CSNVars, CellVar, CellGoal, !DeepInfo) :- ConsId = du_data_ctor(DuCtor), generate_deep_cell_unify(Length, ConsId, CSNVars, CellVar, CellGoal). -:- pred generate_single_csn_unify(int::in, +:- pred generate_single_csn_unify(prog_context::in, int::in, pair(prog_var, hlds_goal)::out, deep_info::in, deep_info::out) is det. -generate_single_csn_unify(CSN, CSNVar - UnifyGoal, !DeepInfo) :- +generate_single_csn_unify(Context, CSN, CSNVar - UnifyGoal, !DeepInfo) :- VarTable0 = !.DeepInfo ^ deep_var_table, VarName = string.format("CSN%d", [i(CSN)]), generate_var_int(VarName, CSNVar, VarTable0, VarTable), !DeepInfo ^ deep_var_table := VarTable, - generate_deep_const_unify(some_int_const(int_const(CSN)), + generate_deep_const_unify(Context, some_int_const(int_const(CSN)), CSNVar, UnifyGoal). -:- pred generate_deep_det_call(module_info::in, string::in, int::in, - list(prog_var)::in, list(prog_var)::in, hlds_goal::out) is det. +:- pred generate_deep_det_call(module_info::in, prog_context::in, + string::in, int::in, list(prog_var)::in, list(prog_var)::in, + hlds_goal::out) is det. -generate_deep_det_call(ModuleInfo, Name, Arity, ArgVars, OutputVars, Goal) :- - generate_deep_call(ModuleInfo, Name, Arity, ArgVars, yes(OutputVars), - detism_det, Goal). +generate_deep_det_call(ModuleInfo, Context, Name, Arity, ArgVars, + OutputVars, Goal) :- + generate_deep_call(ModuleInfo, Context, Name, Arity, ArgVars, + yes(OutputVars), detism_det, Goal). -generate_deep_call(ModuleInfo, Name, Arity, ArgVars, MaybeOutputVars, Detism, - Goal) :- +generate_deep_call(ModuleInfo, Context, Name, Arity, ArgVars, + MaybeOutputVars, Detism, Goal) :- get_deep_profile_builtin_ppid(ModuleInfo, Name, Arity, PredId, ProcId), NonLocals = set_of_var.list_to_set(ArgVars), ( @@ -1805,11 +1828,12 @@ generate_deep_call(ModuleInfo, Name, Arity, ArgVars, MaybeOutputVars, Detism, ), SymName = unqualified(Name), GoalExpr = plain_call(PredId, ProcId, ArgVars, not_builtin, no, SymName), - GoalInfo1 = impure_init_goal_info(NonLocals, InstMapDelta, Detism), + impure_init_goal_info(NonLocals, InstMapDelta, Detism, Context, + GoalInfo1), goal_info_set_mdprof_inst(goal_is_mdprof_inst, GoalInfo1, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). -generate_deep_const_unify(ConsId, Var, Goal) :- +generate_deep_const_unify(Context, ConsId, Var, Goal) :- Ground = ground(shared, none_or_default_func), UnifyMode = unify_modes_li_lf_ri_rf(free, Ground, Ground, Ground), Unification = construct(Var, ConsId, [], [], @@ -1820,7 +1844,7 @@ generate_deep_const_unify(ConsId, Var, Goal) :- NonLocals = set_of_var.make_singleton(Var), InstMapDelta = instmap_delta_bind_var(Var), goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, - GoalInfo1), + Context, GoalInfo1), goal_info_set_mdprof_inst(goal_is_mdprof_inst, GoalInfo1, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). @@ -1840,7 +1864,7 @@ generate_deep_cell_unify(Length, ConsId, ArgVars, Var, Goal) :- InstMapDelta = instmap_delta_bind_var(Var), Determinism = detism_det, goal_info_init(NonLocals, InstMapDelta, Determinism, purity_pure, - GoalInfo), + dummy_context, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). :- pred maybe_generate_activation_ptr(bool::in, prog_var::in, prog_var::in, @@ -1932,10 +1956,10 @@ generate_var_c_ptr(Name, Var, !VarTable) :- %-----------------------------------------------------------------------------% -:- func goal_info_add_nonlocals_make_impure(hlds_goal_info, set_of_progvar) - = hlds_goal_info. +:- pred goal_info_add_nonlocals_make_impure(set_of_progvar::in, + hlds_goal_info::in, hlds_goal_info::out) is det. -goal_info_add_nonlocals_make_impure(!.GoalInfo, NewNonLocals) = !:GoalInfo :- +goal_info_add_nonlocals_make_impure(NewNonLocals, !GoalInfo) :- NonLocals0 = goal_info_get_nonlocals(!.GoalInfo), NonLocals = set_of_var.union(NonLocals0, NewNonLocals), goal_info_set_nonlocals(NonLocals, !GoalInfo), diff --git a/compiler/deforest.m b/compiler/deforest.m index 32c410425..014f4940d 100644 --- a/compiler/deforest.m +++ b/compiler/deforest.m @@ -106,6 +106,7 @@ :- import_module set. :- import_module string. :- import_module term. +:- import_module term_context. :- import_module univ. :- import_module varset. @@ -1167,7 +1168,9 @@ call_call_2(ConjNonLocals, EarlierGoal, BetweenGoals, MaybeLaterGoal, goals_size([EarlierGoal | BetweenGoals], NegSizeDelta), SizeDelta = - NegSizeDelta, pd_info_incr_size_delta(SizeDelta, !PDInfo), - create_call_goal(VersionPredProcId, VersionInfo, Renaming, + EarlierGoal = hlds_goal(_, EarlierGoalInfo), + Context = goal_info_get_context(EarlierGoalInfo), + create_call_goal(Context, VersionPredProcId, VersionInfo, Renaming, TypeRenaming, Goal, !PDInfo), MaybeGoal = yes(Goal) else @@ -1390,12 +1393,12 @@ create_deforest_goal(EarlierGoal, BetweenGoals, MaybeLaterGoal, % Create a goal to call a newly created version. % -:- pred create_call_goal(pred_proc_id::in, version_info::in, +:- pred create_call_goal(prog_context::in, pred_proc_id::in, version_info::in, map(prog_var, prog_var)::in, tsubst::in, hlds_goal::out, pd_info::in, pd_info::out) is det. -create_call_goal(proc(PredId, ProcId), VersionInfo, Renaming, TypeSubn, Goal, - !PDInfo) :- +create_call_goal(Context, proc(PredId, ProcId), VersionInfo, + Renaming, TypeSubn, Goal, !PDInfo) :- OldArgVars = VersionInfo ^ version_arg_vars, pd_info_get_module_info(!.PDInfo, ModuleInfo), module_info_pred_proc_info(ModuleInfo, PredId, ProcId, @@ -1427,7 +1430,8 @@ create_call_goal(proc(PredId, ProcId), VersionInfo, Renaming, TypeSubn, Goal, proc_info_interface_determinism(ProcInfo, Detism), set_of_var.list_to_set(ArgVars, NonLocals), pred_info_get_purity(CalledPredInfo, Purity), - goal_info_init(NonLocals, InstMapDelta, Detism, Purity, GoalInfo), + goal_info_init(NonLocals, InstMapDelta, Detism, Purity, Context, + GoalInfo), PredModule = pred_info_module(CalledPredInfo), PredName = pred_info_name(CalledPredInfo), @@ -1478,13 +1482,12 @@ create_conj(EarlierGoal, BetweenGoals, MaybeLaterGoal, NonLocals, FoldGoal) :- goal_list_instmap_delta(DeforestConj, InstMapDelta0), instmap_delta_restrict(NonLocals, InstMapDelta0, InstMapDelta), goal_list_purity(DeforestConj, Purity), - goal_info_init(NonLocals, InstMapDelta, Detism, Purity, ConjInfo0), - + EarlierGoal = hlds_goal(_, EarlierGoalInfo), % Give the conjunction a context so that the generated predicate % name points to the location of the first goal. - EarlierGoal = hlds_goal(_, EarlierGoalInfo), EarlierContext = goal_info_get_context(EarlierGoalInfo), - goal_info_set_context(EarlierContext, ConjInfo0, ConjInfo), + goal_info_init(NonLocals, InstMapDelta, Detism, Purity, EarlierContext, + ConjInfo), FoldGoal = hlds_goal(conj(plain_conj, DeforestConj), ConjInfo). %-----------------------------------------------------------------------------% @@ -1689,7 +1692,7 @@ match_generalised_version(ModuleInfo, VersionGoal, VersionArgVars, !.VarTable, _), % Only fill in as much as pd_util.goals_match actually looks at. - goal_info_init(GoalInfo), + goal_info_init(dummy_context, GoalInfo), NonGeneralFirstGoalExpr = plain_call(NonGeneralisedPredId, NonGeneralisedProcId, NewArgVars, not_builtin, no, unqualified("")), NonGeneralFirstGoal = hlds_goal(NonGeneralFirstGoalExpr, GoalInfo), @@ -1845,7 +1848,7 @@ can_move_goal_backward(ModuleInfo, FullyStrict, ThisGoal, Goals) :- push_goal_into_goal(NonLocals, DeforestInfo, EarlierGoal, BetweenGoals, LaterGoal, Goal, !PDInfo) :- pd_info_get_instmap(!.PDInfo, InstMap0), - EarlierGoal = hlds_goal(EarlierGoalExpr, _), + EarlierGoal = hlds_goal(EarlierGoalExpr, EarlierGoalInfo), ( EarlierGoalExpr = switch(Var1, CanFail1, Cases1), set_of_var.insert(Var1, NonLocals, CaseNonLocals), @@ -1870,6 +1873,7 @@ push_goal_into_goal(NonLocals, DeforestInfo, EarlierGoal, NonLocals, 1, DeforestInfo, Disjuncts0, Disjuncts, !PDInfo), GoalExpr = disj(Disjuncts) ; + % XXX SUBTYPE ( EarlierGoalExpr = unify(_, _, _, _, _) ; EarlierGoalExpr = plain_call(_, _, _, _, _, _) ; EarlierGoalExpr = generic_call(_, _, _, _, _) @@ -1893,7 +1897,8 @@ push_goal_into_goal(NonLocals, DeforestInfo, EarlierGoal, goal_list_purity([EarlierGoal | BetweenGoals], Purity0), Purity1 = goal_info_get_purity(LaterInfo), worst_purity(Purity0, Purity1) = Purity, - goal_info_init(NonLocals, Delta, Detism, Purity, GoalInfo), + Context = goal_info_get_context(EarlierGoalInfo), + goal_info_init(NonLocals, Delta, Detism, Purity, Context, GoalInfo), Goal2 = hlds_goal(GoalExpr, GoalInfo), pd_info_get_module_info(!.PDInfo, ModuleInfo), @@ -1965,13 +1970,15 @@ append_goal(Goal0, BetweenGoals, GoalToAppend0, NonLocals0, goal_to_conj_list(GoalToAppend, GoalListToAppend), list.condense([GoalList0, BetweenGoals, GoalListToAppend], Goals), + Goal0 = hlds_goal(_, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), goal_list_nonlocals(Goals, SubNonLocals), set_of_var.intersect(NonLocals0, SubNonLocals, NonLocals), goal_list_instmap_delta(Goals, Delta0), instmap_delta_restrict(NonLocals, Delta0, Delta), goal_list_determinism(Goals, Detism), goal_list_purity(Goals, Purity), - goal_info_init(NonLocals, Delta, Detism, Purity, GoalInfo), + goal_info_init(NonLocals, Delta, Detism, Purity, Context, GoalInfo), Goal = hlds_goal(conj(plain_conj, Goals), GoalInfo). %-----------------------------------------------------------------------------% diff --git a/compiler/delay_partial_inst.m b/compiler/delay_partial_inst.m index aa2c4f9bd..1a2e1c56b 100644 --- a/compiler/delay_partial_inst.m +++ b/compiler/delay_partial_inst.m @@ -579,7 +579,8 @@ delay_partial_inst_in_deconstruct(DelayInfo, Goal0, UnifyMode, Unify, Goal, lookup_var_type(VarTable, Var, Type), UnifyMode = unify_modes_li_lf_ri_rf(_, LHSFinalInst, _, _), ( if inst_is_ground(ModuleInfo, Type, LHSFinalInst) then - construct_functor(Var, ConsId, CanonArgs, ConstructGoal), + construct_functor(ProgContext, Var, ConsId, CanonArgs, + ConstructGoal), % Delete the variable on the LHS from the construct map % since it has been constructed. diff --git a/compiler/dep_par_conj.m b/compiler/dep_par_conj.m index 1776ef893..7fc21c678 100644 --- a/compiler/dep_par_conj.m +++ b/compiler/dep_par_conj.m @@ -551,8 +551,9 @@ maybe_sync_dep_par_conj(Conjuncts, GoalInfo, NewGoal, InstMap, !SyncInfo) :- sync_dep_par_conj(ModuleInfo, AllowSomePathsOnly, SharedVars, Goals, GoalInfo, NewGoal, InstMap, !VarTable, !TSStringTable) :- + Context = goal_info_get_context(GoalInfo), SharedVarsList = set_of_var.to_sorted_list(SharedVars), - list.map_foldl3(allocate_future(ModuleInfo), SharedVarsList, + list.map_foldl3(allocate_future(ModuleInfo, Context), SharedVarsList, AllocateFuturesGoals, !VarTable, map.init, FutureMap, !TSStringTable), list.condense(AllocateFuturesGoals, AllocateFutures), list.map_foldl2( @@ -3130,26 +3131,26 @@ seen_more_signal(FinalSignal0, FinalSignal) = SeenMoreSignal :- % to FutureVar to FutureMap, and generate the goal AllocGoal that calls % `par_builtin.new_future/1' to allocate FutureVar. % -:- pred allocate_future(module_info::in, prog_var::in, list(hlds_goal)::out, +:- pred allocate_future(module_info::in, prog_context::in, + prog_var::in, list(hlds_goal)::out, var_table::in, var_table::out, future_map::in, future_map::out, ts_string_table::in, ts_string_table::out) is det. -allocate_future(ModuleInfo, SharedVar, Goals, !VarTable, +allocate_future(ModuleInfo, Context, SharedVar, Goals, !VarTable, !FutureMap, !TSStringTable) :- lookup_var_entry(!.VarTable, SharedVar, SharedVarEntry), SharedVarType = SharedVarEntry ^ vte_type, SharedVarName = var_entry_name(SharedVar, SharedVarEntry), make_future_var(SharedVarName, SharedVarType, FutureVar, FutureVarType, !VarTable), - make_future_name_var_and_goal(SharedVarName, FutureNameVar, SetNameGoal, - !VarTable, !TSStringTable), + make_future_name_var_and_goal(Context, SharedVarName, FutureNameVar, + SetNameGoal, !VarTable, !TSStringTable), map.det_insert(SharedVar, FutureVar, !FutureMap), ModuleName = mercury_par_builtin_module, PredName = new_future_pred_name, Features = [], InstMapDelta = instmap_delta_bind_var(FutureVar), - Context = dummy_context, ShouldInline = should_inline_par_builtin_calls(ModuleInfo), ( ShouldInline = do_not_inline_par_builtins, @@ -3191,11 +3192,11 @@ make_future_var(SharedVarName, SharedVarType, FutureVar, FutureVarType, FutureVarEntry = vte(FutureVarName, FutureVarType, is_not_dummy_type), add_var_entry(FutureVarEntry, FutureVar, !VarTable). -:- pred make_future_name_var_and_goal(string::in, +:- pred make_future_name_var_and_goal(prog_context::in, string::in, prog_var::out, hlds_goal::out, var_table::in, var_table::out, ts_string_table::in, ts_string_table::out) is det. -make_future_name_var_and_goal(Name, FutureNameVar, Goal, +make_future_name_var_and_goal(Context, Name, FutureNameVar, Goal, !VarTable, !TSStringTable) :- FutureNameVarName = "FutureName" ++ Name, FutureNameVarEntry = vte(FutureNameVarName, int_type, is_not_dummy_type), @@ -3213,7 +3214,7 @@ make_future_name_var_and_goal(Name, FutureNameVar, Goal, GoalExpr = unify(FutureNameVar, RHS, UnifyMode, Unification, UnifyContext), InstmapDelta = instmap_delta_from_assoc_list([FutureNameVar - Ground]), goal_info_init(set_of_var.make_singleton(FutureNameVar), InstmapDelta, - detism_det, purity_pure, GoalInfo), + detism_det, purity_pure, Context, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). :- pred make_wait_goal(module_info::in, var_table::in, diff --git a/compiler/direct_arg_in_out.m b/compiler/direct_arg_in_out.m index 3028c0fc7..9c0d7e971 100644 --- a/compiler/direct_arg_in_out.m +++ b/compiler/direct_arg_in_out.m @@ -244,6 +244,7 @@ :- import_module set. :- import_module string. :- import_module term. +:- import_module term_context. :- import_module varset. %---------------------------------------------------------------------------% @@ -1794,7 +1795,7 @@ add_assign_of_merge_var(OrigVar, MergeVar, UnifyMainContext = umc_implicit("direct_arg_in_out_call"), UnifySubContexts = [], make_simple_assign(MergeVar, CurVar, - UnifyMainContext, UnifySubContexts, AssignGoal), + dummy_context, UnifyMainContext, UnifySubContexts, AssignGoal), append_goal(Goal0, AssignGoal, Goal) else % There is no point in adding dead code to the end of Goal0. diff --git a/compiler/distance_granularity.m b/compiler/distance_granularity.m index 68b90e21e..6dea0c33a 100644 --- a/compiler/distance_granularity.m +++ b/compiler/distance_granularity.m @@ -504,7 +504,7 @@ create_if_then_else_goal(GoalsInConj, ConjInfo, MaybeGranularityVar, MaybeGranularityVar = yes(GranularityVar), % Create the condition. make_simple_test(GranularityVar, Var, - umc_implicit("distance_granularity"), [], Test), + dummy_context, umc_implicit("distance_granularity"), [], Test), create_conj(UnifyGoal, Test, plain_conj, Cond), % Create the then. diff --git a/compiler/equiv_type_hlds.m b/compiler/equiv_type_hlds.m index 437aecd43..bc623e826 100644 --- a/compiler/equiv_type_hlds.m +++ b/compiler/equiv_type_hlds.m @@ -1475,7 +1475,8 @@ hash_cons_inst(Inst0, Inst, !Cache) :- replace_in_goal(TypeEqvMap, Goal0, Goal, Changed, !Info) :- Goal0 = hlds_goal(GoalExpr0, GoalInfo0), - replace_in_goal_expr(TypeEqvMap, GoalExpr0, GoalExpr, Changed0, !Info), + replace_in_goal_expr(TypeEqvMap, GoalInfo0, GoalExpr0, GoalExpr, + Changed0, !Info), InstMapDelta0 = goal_info_get_instmap_delta(GoalInfo0), TVarSet0 = !.Info ^ ethri_tvarset, @@ -1527,11 +1528,12 @@ replace_in_goals(TypeEqvMap, List0 @ [Goal0 | Goals0], List, Changed, !Acc) :- List = [Goal | Goals] ). -:- pred replace_in_goal_expr(type_eqv_map::in, +:- pred replace_in_goal_expr(type_eqv_map::in, hlds_goal_info::in, hlds_goal_expr::in, hlds_goal_expr::out, maybe_changed::out, replace_info::in, replace_info::out) is det. -replace_in_goal_expr(TypeEqvMap, GoalExpr0, GoalExpr, Changed, !Info) :- +replace_in_goal_expr(TypeEqvMap, GoalInfo0, GoalExpr0, GoalExpr, + Changed, !Info) :- ( GoalExpr0 = conj(ConjType, Goals0), replace_in_goals(TypeEqvMap, Goals0, Goals, Changed, !Info), @@ -1654,7 +1656,8 @@ replace_in_goal_expr(TypeEqvMap, GoalExpr0, GoalExpr, Changed, !Info) :- ), unexpected($pred, "info not found") ), - polymorphism_make_type_info_var_mi(TypeInfoType, dummy_context, + Context = goal_info_get_context(GoalInfo0), + polymorphism_make_type_info_var_mi(Context, TypeInfoType, TypeInfoVar, Goals0, ModuleInfo0, ModuleInfo, PredInfo1, PredInfo, ProcInfo0, ProcInfo), pred_info_get_typevarset(PredInfo, TVarSet), diff --git a/compiler/float_regs.m b/compiler/float_regs.m index 8979703d7..9829dc83e 100644 --- a/compiler/float_regs.m +++ b/compiler/float_regs.m @@ -1677,7 +1677,7 @@ create_reg_wrapper(OrigVar, OrigVarPredInstInfo, OuterArgRegs, InnerArgRegs, UnifyInstMapDelta = instmap_delta_from_assoc_list([ LHSVar - UnifyPredVarInst]), goal_info_init(UnifyNonLocals, UnifyInstMapDelta, detism_det, - purity_pure, UnifyGoalInfo), + purity_pure, Context, UnifyGoalInfo), UnifyGoal = hlds_goal(UnifyGoalExpr, UnifyGoalInfo), lambda_info_set_recompute_nonlocals(must_recompute_nonlocals, !Info). diff --git a/compiler/goal_expr_to_goal.m b/compiler/goal_expr_to_goal.m index fd13e2e27..c1fa466a2 100644 --- a/compiler/goal_expr_to_goal.m +++ b/compiler/goal_expr_to_goal.m @@ -248,11 +248,11 @@ transform_parse_tree_goal_to_hlds_unify(LocKind, Renaming, Goal, HLDSGoal, else true ), - HLDSGoal = true_goal_with_context(Context) + HLDSGoal = true_goal(Context) else if TermB = functor(atom("!"), [variable(StateVarB, _)], _) then report_svar_unify_error(Context, StateVarB, !UrInfo), make_svar_magically_known(StateVarB, !SVarState, !UrInfo), - HLDSGoal = true_goal_with_context(Context) + HLDSGoal = true_goal(Context) else unravel_unification(TermA, TermB, Context, umc_explicit, [], Purity, HLDSGoal, !SVarState, !UrInfo), @@ -870,7 +870,7 @@ transform_parse_tree_goal_to_hlds_try(LocKind, Renaming, Goal, HLDSGoal, [nl], Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces), add_unravel_err(Spec, !UrInfo), - HLDSGoal = true_goal_with_context(Context) + HLDSGoal = true_goal(Context) ) ). diff --git a/compiler/goal_transform.m b/compiler/goal_transform.m index 80d4a258b..46948165e 100644 --- a/compiler/goal_transform.m +++ b/compiler/goal_transform.m @@ -827,8 +827,10 @@ case_to_disjunct(Var, CaseGoal, InstMap, ConsId, Disjunct, instmap_delta_init_reachable(ExtraInstMapDelta0), instmap_delta_bind_var_to_functor(Var, VarType, ConsId, InstMap, ExtraInstMapDelta0, ExtraInstMapDelta, !ModuleInfo), + CaseGoal = hlds_goal(_, CaseGoalInfo), + CaseContext = goal_info_get_context(CaseGoalInfo), goal_info_init(NonLocals, ExtraInstMapDelta, - detism_semi, purity_pure, ExtraGoalInfo), + detism_semi, purity_pure, CaseContext, ExtraGoalInfo), % Conjoin the test and the rest of the case. goal_to_conj_list(CaseGoal, CaseGoalConj), @@ -836,7 +838,6 @@ case_to_disjunct(Var, CaseGoal, InstMap, ConsId, Disjunct, % Work out the nonlocals, instmap_delta and determinism % of the entire conjunction. - CaseGoal = hlds_goal(_, CaseGoalInfo), CaseNonLocals0 = goal_info_get_nonlocals(CaseGoalInfo), set_of_var.insert(Var, CaseNonLocals0, CaseNonLocals), CaseInstMapDelta = goal_info_get_instmap_delta(CaseGoalInfo), @@ -846,7 +847,7 @@ case_to_disjunct(Var, CaseGoal, InstMap, ConsId, Disjunct, det_conjunction_detism(detism_semi, CaseDetism0, Detism), CasePurity = goal_info_get_purity(CaseGoalInfo), goal_info_init(CaseNonLocals, InstMapDelta, Detism, CasePurity, - CombinedGoalInfo), + CaseContext, CombinedGoalInfo), Disjunct = hlds_goal(conj(plain_conj, GoalList), CombinedGoalInfo). %---------------------------------------------------------------------------% diff --git a/compiler/higher_order.make_specialized_preds.m b/compiler/higher_order.make_specialized_preds.m index 44356cb70..11611fa6d 100644 --- a/compiler/higher_order.make_specialized_preds.m +++ b/compiler/higher_order.make_specialized_preds.m @@ -831,8 +831,9 @@ construct_higher_order_terms(ModuleInfo, HeadVars0, NewHeadVars, ArgModes0, set_of_var.list_to_set(CurriedHeadVars1, ConstNonLocals), ConstInst = ground(shared, GroundInstInfo), ConstInstMapDelta = instmap_delta_from_assoc_list([LVar - ConstInst]), + proc_info_get_context(!.ProcInfo, Context), goal_info_init(ConstNonLocals, ConstInstMapDelta, detism_det, - purity_pure, ConstGoalInfo), + purity_pure, Context, ConstGoalInfo), RHS = rhs_functor(ConsId, is_not_exist_constr, CurriedHeadVars1), UnifyMode = unify_modes_li_lf_ri_rf(free, ConstInst, ConstInst, ConstInst), diff --git a/compiler/higher_order.specialize_calls.m b/compiler/higher_order.specialize_calls.m index 96d79c91d..1bfe03cd1 100644 --- a/compiler/higher_order.specialize_calls.m +++ b/compiler/higher_order.specialize_calls.m @@ -841,12 +841,13 @@ maybe_specialize_method_call(TypeClassInfoVar, MethodProcNum, Args, CallerProcInfo = CallerProcInfo0, AllArgs = Args else - get_unconstrained_instance_type_infos(ModuleInfo, + Context = goal_info_get_context(GoalInfo0), + get_unconstrained_instance_type_infos(ModuleInfo, Context, TypeClassInfoVar, UnconstrainedTVarTypes, 1, ArgTypeInfoGoals, ArgTypeInfoVars, CallerProcInfo0, CallerProcInfo1), FirstArgTypeclassInfo = list.length(UnconstrainedTVarTypes) + 1, - get_arg_typeclass_infos(ModuleInfo, TypeClassInfoVar, + get_arg_typeclass_infos(ModuleInfo, Context, TypeClassInfoVar, InstanceConstraints, FirstArgTypeclassInfo, ArgTypeClassInfoGoals, ArgTypeClassInfoVars, CallerProcInfo1, CallerProcInfo), @@ -914,14 +915,14 @@ instance_matches(ClassTypes, Instance, Constraints, UnconstrainedTVarTypes, % This simulates the action of `do_call_class_method' in % runtime/mercury_ho_call.c. % -:- pred get_arg_typeclass_infos(module_info::in, prog_var::in, - list(prog_constraint)::in, int::in, list(hlds_goal)::out, +:- pred get_arg_typeclass_infos(module_info::in, prog_context::in, + prog_var::in, list(prog_constraint)::in, int::in, list(hlds_goal)::out, list(prog_var)::out, proc_info::in, proc_info::out) is det. -get_arg_typeclass_infos(ModuleInfo, TypeClassInfoVar, InstanceConstraints, - Index, Goals, Vars, !ProcInfo) :- +get_arg_typeclass_infos(ModuleInfo, Context, TypeClassInfoVar, + InstanceConstraints, Index, Goals, Vars, !ProcInfo) :- MakeResultType = (func(_) = typeclass_info_type), - get_typeclass_info_args(ModuleInfo, TypeClassInfoVar, + get_typeclass_info_args(ModuleInfo, Context, TypeClassInfoVar, "instance_constraint_from_typeclass_info", MakeResultType, InstanceConstraints, Index, Goals, Vars, !ProcInfo). @@ -933,39 +934,42 @@ get_arg_typeclass_infos(ModuleInfo, TypeClassInfoVar, InstanceConstraints, % runtime/mercury_ho_call.c. % :- pred get_unconstrained_instance_type_infos(module_info::in, - prog_var::in, list(mer_type)::in, int::in, list(hlds_goal)::out, - list(prog_var)::out, proc_info::in, proc_info::out) is det. + prog_context::in, prog_var::in, list(mer_type)::in, int::in, + list(hlds_goal)::out, list(prog_var)::out, + proc_info::in, proc_info::out) is det. -get_unconstrained_instance_type_infos(ModuleInfo, TypeClassInfoVar, +get_unconstrained_instance_type_infos(ModuleInfo, Context, TypeClassInfoVar, UnconstrainedTVarTypes, Index, Goals, Vars, !ProcInfo) :- MakeResultType = build_type_info_type, - get_typeclass_info_args(ModuleInfo, TypeClassInfoVar, + get_typeclass_info_args(ModuleInfo, Context, TypeClassInfoVar, "unconstrained_type_info_from_typeclass_info", MakeResultType, UnconstrainedTVarTypes, Index, Goals, Vars, !ProcInfo). -:- pred get_typeclass_info_args(module_info::in, prog_var::in, string::in, - (func(T) = mer_type)::in, list(T)::in, int::in, list(hlds_goal)::out, - list(prog_var)::out, proc_info::in, proc_info::out) is det. +:- pred get_typeclass_info_args(module_info::in, prog_context::in, + prog_var::in, string::in, (func(T) = mer_type)::in, list(T)::in, int::in, + list(hlds_goal)::out, list(prog_var)::out, + proc_info::in, proc_info::out) is det. -get_typeclass_info_args(ModuleInfo, TypeClassInfoVar, PredName, MakeResultType, - Args, Index, Goals, Vars, !ProcInfo) :- +get_typeclass_info_args(ModuleInfo, Context, TypeClassInfoVar, + PredName, MakeResultType, Args, Index, Goals, Vars, !ProcInfo) :- lookup_builtin_pred_proc_id(ModuleInfo, mercury_private_builtin_module, PredName, pf_predicate, user_arity(3), only_mode, ExtractArgPredId, ExtractArgProcId), - get_typeclass_info_args_loop(ModuleInfo, TypeClassInfoVar, + get_typeclass_info_args_loop(ModuleInfo, Context, TypeClassInfoVar, ExtractArgPredId, ExtractArgProcId, qualified(mercury_private_builtin_module, PredName), MakeResultType, Args, Index, Goals, Vars, !ProcInfo). -:- pred get_typeclass_info_args_loop(module_info::in, prog_var::in, - pred_id::in, proc_id::in, sym_name::in, (func(T) = mer_type)::in, - list(T)::in, int::in, list(hlds_goal)::out, - list(prog_var)::out, proc_info::in, proc_info::out) is det. +:- pred get_typeclass_info_args_loop(module_info::in, prog_context::in, + prog_var::in, pred_id::in, proc_id::in, sym_name::in, + (func(T) = mer_type)::in, list(T)::in, int::in, + list(hlds_goal)::out, list(prog_var)::out, + proc_info::in, proc_info::out) is det. -get_typeclass_info_args_loop(_, _, _, _, _, _, [], _, [], [], !ProcInfo). -get_typeclass_info_args_loop(ModuleInfo, TypeClassInfoVar, PredId, ProcId, - SymName, MakeResultType, [Arg | Args], Index, +get_typeclass_info_args_loop(_, _, _, _, _, _, _, [], _, [], [], !ProcInfo). +get_typeclass_info_args_loop(ModuleInfo, Context, TypeClassInfoVar, + PredId, ProcId, SymName, MakeResultType, [Arg | Args], Index, [IndexGoal, CallGoal | Goals], [ResultVar | Vars], !ProcInfo) :- ResultType = MakeResultType(Arg), IsDummy = is_type_a_dummy(ModuleInfo, ResultType), @@ -980,12 +984,14 @@ get_typeclass_info_args_loop(ModuleInfo, TypeClassInfoVar, PredId, ProcId, instmap_delta_init_reachable(InstMapDelta0), instmap_delta_insert_var(ResultVar, ground(shared, none_or_default_func), InstMapDelta0, InstMapDelta), - goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, GoalInfo), + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, + Context, GoalInfo), CallGoalExpr = plain_call(PredId, ProcId, CallArgs, not_builtin, MaybeContext, SymName), CallGoal = hlds_goal(CallGoalExpr, GoalInfo), - get_typeclass_info_args_loop(ModuleInfo, TypeClassInfoVar, PredId, ProcId, - SymName, MakeResultType, Args, Index + 1, Goals, Vars, !ProcInfo). + get_typeclass_info_args_loop(ModuleInfo, Context, TypeClassInfoVar, + PredId, ProcId, SymName, MakeResultType, Args, Index + 1, + Goals, Vars, !ProcInfo). %---------------------------------------------------------------------------% @@ -1278,7 +1284,7 @@ maybe_specialize_ordinary_call(CanRequest, CalleePredProcId, MatchedNewPred = new_pred(NewPredProcId, _, _, NewName, _, _, _, _, _), - construct_extra_type_infos(ExtraTypeInfoTypes, + construct_extra_type_infos(Context, ExtraTypeInfoTypes, ExtraTypeInfoVars, ExtraTypeInfoGoals, !Info), NewPredProcId = proc(NewCalleePred, NewCalleeProc), @@ -1603,16 +1609,17 @@ arg_contains_type_info_for_tvar(RttiVarMaps, Var, !TVars) :- VarInfo = non_rtti_var ). -:- pred construct_extra_type_infos(list(mer_type)::in, +:- pred construct_extra_type_infos(prog_context::in, list(mer_type)::in, list(prog_var)::out, list(hlds_goal)::out, higher_order_info::in, higher_order_info::out) is det. -construct_extra_type_infos(Types, TypeInfoVars, TypeInfoGoals, !Info) :- +construct_extra_type_infos(Context, Types, TypeInfoVars, TypeInfoGoals, + !Info) :- GlobalInfo0 = hoi_get_global_info(!.Info), ModuleInfo0 = hogi_get_module_info(GlobalInfo0), PredInfo0 = hoi_get_pred_info(!.Info), ProcInfo0 = hoi_get_proc_info(!.Info), - polymorphism_make_type_info_vars_mi(Types, dummy_context, + polymorphism_make_type_info_vars_mi(Context, Types, TypeInfoVars, TypeInfoGoals, ModuleInfo0, ModuleInfo, PredInfo0, PredInfo, ProcInfo0, ProcInfo), hoi_set_pred_info(PredInfo, !Info), diff --git a/compiler/hlds_goal.m b/compiler/hlds_goal.m index d34716700..556e44084 100644 --- a/compiler/hlds_goal.m +++ b/compiler/hlds_goal.m @@ -1528,10 +1528,7 @@ % procedures access, see the definition of the hlds_goal_info type. % -:- pred goal_info_init(hlds_goal_info::out) is det. :- pred goal_info_init(prog_context::in, hlds_goal_info::out) is det. -:- pred goal_info_init(set_of_progvar::in, instmap_delta::in, determinism::in, - purity::in, hlds_goal_info::out) is det. :- pred goal_info_init(set_of_progvar::in, instmap_delta::in, determinism::in, purity::in, prog_context::in, hlds_goal_info::out) is det. @@ -1540,12 +1537,12 @@ :- func ctgc_goal_info_init = ctgc_goal_info. -:- func impure_init_goal_info(set_of_progvar, instmap_delta, determinism) - = hlds_goal_info. -:- func impure_reachable_init_goal_info(set_of_progvar, determinism) - = hlds_goal_info. -:- func impure_unreachable_init_goal_info(set_of_progvar, determinism) - = hlds_goal_info. +:- pred impure_init_goal_info(set_of_progvar::in, instmap_delta::in, + determinism::in, prog_context::in, hlds_goal_info::out) is det. +:- pred impure_reachable_init_goal_info(set_of_progvar::in, + determinism::in, prog_context::in, hlds_goal_info::out) is det. +:- pred impure_unreachable_init_goal_info(set_of_progvar::in, + determinism::in, prog_context::in, hlds_goal_info::out) is det. % Instead of recording the liveness of every variable at every part % of the goal, we just keep track of the initial liveness, and of the changes @@ -1886,18 +1883,6 @@ rbmm_info_init = %---------------------------------------------------------------------------% -:- pragma inline(pred(goal_info_init/1)). - -goal_info_init(GoalInfo) :- - Detism = detism_erroneous, - instmap_delta_init_unreachable(InstMapDelta), - NonLocals = set_of_var.init, - set.init(Features), - GoalId = invalid_goal_id, - GoalInfo = goal_info(Detism, purity_pure, InstMapDelta, NonLocals, - Features, GoalId, no_code_gen_info, - hlds_goal_extra_info_init(dummy_context)). - :- pragma inline(pred(goal_info_init/2)). goal_info_init(Context, GoalInfo) :- @@ -1910,13 +1895,6 @@ goal_info_init(Context, GoalInfo) :- Features, GoalId, no_code_gen_info, hlds_goal_extra_info_init(Context)). -goal_info_init(NonLocals, InstMapDelta, Detism, Purity, GoalInfo) :- - set.init(Features), - GoalId = invalid_goal_id, - GoalInfo = goal_info(Detism, Purity, InstMapDelta, NonLocals, - Features, GoalId, no_code_gen_info, - hlds_goal_extra_info_init(dummy_context)). - goal_info_init(NonLocals, InstMapDelta, Detism, Purity, Context, GoalInfo) :- set.init(Features), GoalId = invalid_goal_id, @@ -1944,21 +1922,22 @@ hlds_goal_extra_info_init(Context) = ExtraInfo :- ctgc_goal_info_init = ctgc_goal_info(set_of_var.init, set_of_var.init, no_reuse_info). -impure_init_goal_info(NonLocals, InstMapDelta, Determinism) = GoalInfo :- +impure_init_goal_info(NonLocals, InstMapDelta, Determinism, Context, + GoalInfo) :- goal_info_init(NonLocals, InstMapDelta, Determinism, purity_impure, - GoalInfo0), + Context, GoalInfo0), goal_info_add_feature(feature_not_impure_for_determinism, GoalInfo0, GoalInfo). -impure_reachable_init_goal_info(NonLocals, Determinism) = GoalInfo :- +impure_reachable_init_goal_info(NonLocals, Determinism, Context, GoalInfo) :- instmap_delta_init_reachable(InstMapDelta), goal_info_init(NonLocals, InstMapDelta, Determinism, purity_impure, - GoalInfo). + Context, GoalInfo). -impure_unreachable_init_goal_info(NonLocals, Determinism) = GoalInfo :- +impure_unreachable_init_goal_info(NonLocals, Determinism, Context, GoalInfo) :- instmap_delta_init_unreachable(InstMapDelta), goal_info_init(NonLocals, InstMapDelta, Determinism, purity_impure, - GoalInfo0), + Context, GoalInfo0), goal_info_add_feature(feature_not_impure_for_determinism, GoalInfo0, GoalInfo). diff --git a/compiler/hlds_proc.m b/compiler/hlds_proc.m index dada2ef53..d5eaa0b76 100644 --- a/compiler/hlds_proc.m +++ b/compiler/hlds_proc.m @@ -335,6 +335,7 @@ :- import_module int. :- import_module string. :- import_module term. +:- import_module term_context. :- import_module unit. :- import_module varset. @@ -565,7 +566,7 @@ proc_info_init(ModuleInfo, MainContext, ItemNumber, Types, InstVarSet, init_var_table(VarTable0), make_fresh_prefix_named_vars_from_types(ModuleInfo, "HeadVar__", 1, Types, HeadVars, VarTable0, VarTable), - goal_info_init(GoalInfo), + goal_info_init(dummy_context, GoalInfo), BodyGoal = hlds_goal(conj(plain_conj, []), GoalInfo), rtti_varmaps_init(RttiVarMaps), % argument InstVarSet diff --git a/compiler/lco.m b/compiler/lco.m index b740085de..807b6749e 100644 --- a/compiler/lco.m +++ b/compiler/lco.m @@ -1947,7 +1947,7 @@ lco_transform_variant_atomic_goal(ModuleInfo, VarToAddr, InstMap0, Changed = no ; GroundingVarToAddr = [_ | _], - list.map_foldl(make_store_goal(ModuleInfo, InstMap1), + list.map_foldl(make_store_goal(ModuleInfo, GoalInfo, InstMap1), GroundingVarToAddr, StoreGoals, !ProcInfo), GoalExpr = conj(plain_conj, [hlds_goal(GoalExpr0, GoalInfo) | StoreGoals]), @@ -1982,11 +1982,11 @@ grounding_to_variant_args(GroundingVarToAddr, OutArgNum, OutArgVars, Subst, ) ). -:- pred make_store_goal(module_info::in, instmap::in, +:- pred make_store_goal(module_info::in, hlds_goal_info::in, instmap::in, pair(prog_var, store_target)::in, hlds_goal::out, proc_info::in, proc_info::out) is det. -make_store_goal(ModuleInfo, InstMap, GroundVar - StoreTarget, Goal, +make_store_goal(ModuleInfo, GoalInfo0, InstMap, GroundVar - StoreTarget, Goal, !ProcInfo) :- StoreTarget = store_target(AddrVar, MaybeFieldId), ( @@ -2016,11 +2016,11 @@ make_store_goal(ModuleInfo, InstMap, GroundVar - StoreTarget, Goal, GoalExpr = unify(AddrVar, RHS, UnifyMode, Unification, UnifyContext), - goal_info_init(GoalInfo0), - goal_info_set_determinism(detism_det, GoalInfo0, GoalInfo1), - goal_info_set_instmap_delta(instmap_delta_bind_var(AddrVar), - GoalInfo1, GoalInfo), - + Context = goal_info_get_context(GoalInfo0), + set_of_var.list_to_set([AddrVar | ArgVars], NonLocals), + InstMapDelta = instmap_delta_bind_var(AddrVar), + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, + Context, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo) ). diff --git a/compiler/loop_inv.m b/compiler/loop_inv.m index ea15060c5..64f896e11 100644 --- a/compiler/loop_inv.m +++ b/compiler/loop_inv.m @@ -923,7 +923,9 @@ gen_aux_proc_case(Info, Case, AuxCase) :- gen_aux_proc_handle_non_recursive_call(Info, Goal, AuxGoal) :- ( if invariant_goal(Info ^ gapi_inv_goals, Goal) then - AuxGoal = true_goal + Goal = hlds_goal(_, GoalInfo), + Context = goal_info_get_context(GoalInfo), + AuxGoal = true_goal(Context) else AuxGoal = Goal ). diff --git a/compiler/make_goal.m b/compiler/make_goal.m index 2acd5611b..856452072 100644 --- a/compiler/make_goal.m +++ b/compiler/make_goal.m @@ -28,18 +28,14 @@ % Return the HLDS equivalent of `true'. % -:- func true_goal = hlds_goal. :- func true_goal_expr = hlds_goal_expr. - -:- func true_goal_with_context(prog_context) = hlds_goal. +:- func true_goal(prog_context) = hlds_goal. % Return the HLDS equivalent of `fail'. % -:- func fail_goal = hlds_goal. :- func fail_goal_expr = hlds_goal_expr. -:- func fail_goal_info = hlds_goal_info. - -:- func fail_goal_with_context(prog_context) = hlds_goal. +:- func fail_goal_info(prog_context) = hlds_goal_info. +:- func fail_goal(prog_context) = hlds_goal. % Create the hlds_goal for a unification, filling in all the as yet % unknown slots with dummy values. The unification is constructed as a @@ -58,25 +54,25 @@ prog_context::in, unify_main_context::in, list(unify_sub_context)::in, hlds_goal::out) is det. -:- pred make_complicated_unify_assigns(list(prog_var)::in, list(prog_var)::in, - list(hlds_goal)::out) is det. +:- pred make_complicated_unify_assigns(prog_context::in, + list(prog_var)::in, list(prog_var)::in, list(hlds_goal)::out) is det. -:- pred make_complicated_unify_assign(prog_var::in, prog_var::in, - hlds_goal::out) is det. +:- pred make_complicated_unify_assign(prog_context::in, + prog_var::in, prog_var::in, hlds_goal::out) is det. % Create the hlds_goal for a unification that assigns the second variable % to the first. The initial inst of the second variable should be % ground_inst. The resulting goal has all its fields filled in. % :- pred make_simple_assign(prog_var::in, prog_var::in, - unify_main_context::in, list(unify_sub_context)::in, + prog_context::in, unify_main_context::in, list(unify_sub_context)::in, hlds_goal::out) is det. % Create the hlds_goal for a unification that tests the equality of two % values of atomic types. The resulting goal has all its fields filled in. % :- pred make_simple_test(prog_var::in, prog_var::in, - unify_main_context::in, list(unify_sub_context)::in, + prog_context::in, unify_main_context::in, list(unify_sub_context)::in, hlds_goal::out) is det. % Produce a goal to construct a given constant. These predicates all @@ -130,19 +126,19 @@ % It fills in the non-locals, instmap_delta and determinism fields % of the goal_info. % -:- pred construct_functor(prog_var::in, cons_id::in, list(prog_var)::in, - hlds_goal::out) is det. -:- pred deconstruct_functor(prog_var::in, cons_id::in, list(prog_var)::in, - hlds_goal::out) is det. +:- pred construct_functor(prog_context::in, prog_var::in, cons_id::in, + list(prog_var)::in, hlds_goal::out) is det. +:- pred deconstruct_functor(prog_context::in, prog_var::in, cons_id::in, + list(prog_var)::in, hlds_goal::out) is det. % Produce a goal to construct or deconstruct a tuple containing % the given list of arguments, filling in the non-locals, % instmap_delta and determinism fields of the goal_info. % -:- pred construct_tuple(prog_var::in, list(prog_var)::in, hlds_goal::out) - is det. -:- pred deconstruct_tuple(prog_var::in, list(prog_var)::in, hlds_goal::out) - is det. +:- pred construct_tuple(prog_context::in, prog_var::in, list(prog_var)::in, + hlds_goal::out) is det. +:- pred deconstruct_tuple(prog_context::in, prog_var::in, list(prog_var)::in, + hlds_goal::out) is det. %---------------------------------------------------------------------------% %---------------------------------------------------------------------------% @@ -160,32 +156,27 @@ %---------------------------------------------------------------------------% -true_goal = hlds_goal(true_goal_expr, GoalInfo) :- - instmap_delta_init_reachable(InstMapDelta), - goal_info_init(set_of_var.init, InstMapDelta, detism_det, purity_pure, - GoalInfo). - true_goal_expr = conj(plain_conj, []). -true_goal_with_context(Context) = hlds_goal(GoalExpr, GoalInfo) :- - hlds_goal(GoalExpr, GoalInfo0) = true_goal, - goal_info_set_context(Context, GoalInfo0, GoalInfo). +:- func true_goal_info(prog_context) = hlds_goal_info. -fail_goal = hlds_goal(fail_goal_expr, GoalInfo) :- - instmap_delta_init_unreachable(InstMapDelta), - goal_info_init(set_of_var.init, InstMapDelta, detism_failure, purity_pure, - GoalInfo). +true_goal_info(Context) = GoalInfo :- + instmap_delta_init_reachable(InstMapDelta), + goal_info_init(set_of_var.init, InstMapDelta, detism_det, purity_pure, + Context, GoalInfo). + +true_goal(Context) = Goal :- + Goal = hlds_goal(true_goal_expr, true_goal_info(Context)). fail_goal_expr = disj([]). -fail_goal_info = GoalInfo :- +fail_goal_info(Context) = GoalInfo :- instmap_delta_init_unreachable(InstMapDelta), goal_info_init(set_of_var.init, InstMapDelta, detism_failure, purity_pure, - GoalInfo). + Context, GoalInfo). -fail_goal_with_context(Context) = hlds_goal(GoalExpr, GoalInfo) :- - hlds_goal(GoalExpr, GoalInfo0) = fail_goal, - goal_info_set_context(Context, GoalInfo0, GoalInfo). +fail_goal(Context) = Goal :- + Goal = hlds_goal(fail_goal_expr, fail_goal_info(Context)). %---------------------------------------------------------------------------% @@ -205,19 +196,19 @@ create_pure_atomic_complicated_unification(LHS, RHS, Context, %---------------------------------------------------------------------------% -make_complicated_unify_assigns([], [_ | _], _) :- +make_complicated_unify_assigns(_, [], [_ | _], _) :- unexpected($pred, "length mismatch"). -make_complicated_unify_assigns([_ | _], [], _) :- +make_complicated_unify_assigns(_, [_ | _], [], _) :- unexpected($pred, "length mismatch"). -make_complicated_unify_assigns([], [], []). -make_complicated_unify_assigns([Var1 | Vars1], [Var2 | Vars2], +make_complicated_unify_assigns(_, [], [], []). +make_complicated_unify_assigns(Context, [Var1 | Vars1], [Var2 | Vars2], [Goal | Goals]) :- - make_complicated_unify_assign(Var1, Var2, Goal), - make_complicated_unify_assigns(Vars1, Vars2, Goals). + make_complicated_unify_assign(Context, Var1, Var2, Goal), + make_complicated_unify_assigns(Context, Vars1, Vars2, Goals). -make_complicated_unify_assign(Var1, Var2, Goal) :- +make_complicated_unify_assign(Context, Var1, Var2, Goal) :- ( if Var1 = Var2 then - Goal = true_goal + Goal = true_goal(Context) else create_pure_atomic_complicated_unification(Var1, rhs_var(Var2), dummy_context, umc_explicit, [], Goal) @@ -225,23 +216,23 @@ make_complicated_unify_assign(Var1, Var2, Goal) :- %---------------------------------------------------------------------------% -make_simple_assign(X, Y, UnifyMainContext, UnifySubContext, Goal) :- +make_simple_assign(X, Y, Context, UnifyMainContext, UnifySubContext, Goal) :- Ground = ground(shared, none_or_default_func), UnifyMode = unify_modes_li_lf_ri_rf(free, Ground, Ground, Ground), Unification = assign(X, Y), UnifyContext = unify_context(UnifyMainContext, UnifySubContext), goal_info_init(set_of_var.list_to_set([X, Y]), instmap_delta_bind_var(X), - detism_det, purity_pure, GoalInfo), + detism_det, purity_pure, Context, GoalInfo), GoalExpr = unify(X, rhs_var(Y), UnifyMode, Unification, UnifyContext), Goal = hlds_goal(GoalExpr, GoalInfo). -make_simple_test(X, Y, UnifyMainContext, UnifySubContext, Goal) :- +make_simple_test(X, Y, Context, UnifyMainContext, UnifySubContext, Goal) :- Ground = ground(shared, none_or_default_func), UnifyMode = unify_modes_li_lf_ri_rf(Ground, Ground, Ground, Ground), Unification = simple_test(X, Y), UnifyContext = unify_context(UnifyMainContext, UnifySubContext), goal_info_init(set_of_var.list_to_set([X, Y]), instmap_delta_bind_no_var, - detism_semi, purity_pure, GoalInfo), + detism_semi, purity_pure, Context, GoalInfo), GoalExpr = unify(X, rhs_var(Y), UnifyMode, Unification, UnifyContext), Goal = hlds_goal(GoalExpr, GoalInfo). @@ -340,7 +331,7 @@ make_const_construction_alloc(ConsId, Type, IsDummyType, Name, Goal, Var, %---------------------------------------------------------------------------% -construct_functor(Var, ConsId, Args, Goal) :- +construct_functor(Context, Var, ConsId, Args, Goal) :- list.length(Args, Arity), RHS = rhs_functor(ConsId, is_not_exist_constr, Args), UnifyMode = unify_modes_li_lf_ri_rf(free_inst, ground_inst, @@ -352,10 +343,11 @@ construct_functor(Var, ConsId, Args, Goal) :- Unify = unify(Var, RHS, UnifyMode, Unification, UnifyContext), set_of_var.list_to_set([Var | Args], NonLocals), InstMapDelta = instmap_delta_bind_var(Var), - goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, GoalInfo), + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, + Context, GoalInfo), Goal = hlds_goal(Unify, GoalInfo). -deconstruct_functor(Var, ConsId, Args, Goal) :- +deconstruct_functor(Context, Var, ConsId, Args, Goal) :- list.length(Args, Arity), RHS = rhs_functor(ConsId, is_not_exist_constr, Args), UnifyMode = unify_modes_li_lf_ri_rf(ground_inst, ground_inst, @@ -367,18 +359,19 @@ deconstruct_functor(Var, ConsId, Args, Goal) :- Unify = unify(Var, RHS, UnifyMode, Unification, UnifyContext), set_of_var.list_to_set([Var | Args], NonLocals), InstMapDelta = instmap_delta_bind_vars(Args), - goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, GoalInfo), + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, + Context, GoalInfo), Goal = hlds_goal(Unify, GoalInfo). -construct_tuple(Tuple, Args, Goal) :- +construct_tuple(Context, Tuple, Args, Goal) :- list.length(Args, Arity), ConsId = tuple_cons(Arity), - construct_functor(Tuple, ConsId, Args, Goal). + construct_functor(Context, Tuple, ConsId, Args, Goal). -deconstruct_tuple(Tuple, Args, Goal) :- +deconstruct_tuple(Context, Tuple, Args, Goal) :- list.length(Args, Arity), ConsId = tuple_cons(Arity), - deconstruct_functor(Tuple, ConsId, Args, Goal). + deconstruct_functor(Context, Tuple, ConsId, Args, Goal). %---------------------------------------------------------------------------% :- end_module hlds.make_goal. diff --git a/compiler/ml_accurate_gc.m b/compiler/ml_accurate_gc.m index d83b8213a..eed2314c1 100644 --- a/compiler/ml_accurate_gc.m +++ b/compiler/ml_accurate_gc.m @@ -307,7 +307,7 @@ ml_gen_gc_trace_code(VarName, DeclType, ActualType, Context, GC_TraceCode, NonLocals = set_of_var.union_list(NonLocalsList), InstMapDelta = instmap_delta_bind_var(TypeInfoVar), goal_info_init(NonLocals, InstMapDelta, detism_det, purity_impure, - GoalInfo), + Context, GoalInfo), conj_list_to_goal(HLDS_TypeInfoGoals, GoalInfo, Conj), % Convert this HLDS code to MLDS. @@ -402,7 +402,7 @@ ml_gen_make_type_info_var(Type, Context, TypeInfoVar, TypeInfoGoals, !Info) :- ml_gen_info_get_pred_proc_id(!.Info, PredProcId), module_info_pred_proc_info(ModuleInfo0, PredProcId, PredInfo0, ProcInfo0), % Generate the HLDS code to create the type_infos. - polymorphism_make_type_info_var_mi(Type, Context, + polymorphism_make_type_info_var_mi(Context, Type, TypeInfoVar, TypeInfoGoals, ModuleInfo0, ModuleInfo1, PredInfo0, PredInfo, ProcInfo0, ProcInfo), module_info_set_pred_proc_info(PredProcId, PredInfo, ProcInfo, diff --git a/compiler/modecheck_goal.m b/compiler/modecheck_goal.m index a2bd2103d..a4ef403b2 100644 --- a/compiler/modecheck_goal.m +++ b/compiler/modecheck_goal.m @@ -614,7 +614,9 @@ modecheck_case_list(MultiModeErrorMap0, Var, [Case0 | Cases0], [Case | Cases], % 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 mode information. - Goal1 = true_goal, + Goal0 = hlds_goal(_, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), + Goal1 = true_goal(Context), InstMap = InstMap1 ), @@ -867,7 +869,9 @@ modecheck_goal_if_then_else(GoalExpr0, GoalInfo0, GoalExpr, !ModeInfo) :- % 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 mode information. - Then = true_goal, + Then0 = hlds_goal(_, ThenGoalInfo0), + ThenContext = goal_info_get_context(ThenGoalInfo0), + Then = true_goal(ThenContext), InstMapThen = InstMapCond ), mode_info_set_pred_var_multimode_error_map(MultiModeErrorMap0, !ModeInfo), @@ -1273,7 +1277,7 @@ modecheck_make_type_info_var_for_type(Type, Context, TypeInfoVar, mode_info_get_var_table(!.ModeInfo, VarTable0), proc_info_set_var_table(VarTable0, ProcInfo0, ProcInfo1), - polymorphism_make_type_info_var_mi(Type, Context, + polymorphism_make_type_info_var_mi(Context, Type, TypeInfoVar, TypeInfoGoals, ModuleInfo0, ModuleInfo1, PredInfo0, PredInfo, ProcInfo1, ProcInfo), module_info_set_pred_proc_info(PredId, ProcId, PredInfo, ProcInfo, diff --git a/compiler/modes.m b/compiler/modes.m index 7f876ac5a..8d48d9cbd 100644 --- a/compiler/modes.m +++ b/compiler/modes.m @@ -1434,7 +1434,8 @@ modecheck_clause_switch(CheckpointMsg, HeadVars, InstMap0, ArgFinalInsts0, % 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 mode information. - Goal1 = true_goal, + Context = goal_info_get_context(GoalInfo0), + Goal1 = true_goal(Context), InstMap = InstMap1, Goal1 = hlds_goal(_, ExitGoalInfo) ), @@ -1490,7 +1491,8 @@ unique_modecheck_clause_switch(CheckpointMsg, HeadVars, InstMap0, % 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 mode information. - Goal1 = true_goal, + Context = goal_info_get_context(GoalInfo0), + Goal1 = true_goal(Context), Goal1 = hlds_goal(_, ExitGoalInfo) ), diff --git a/compiler/opt_format_call.m b/compiler/opt_format_call.m index ca2d26820..995dcde00 100644 --- a/compiler/opt_format_call.m +++ b/compiler/opt_format_call.m @@ -1541,7 +1541,8 @@ opt_format_call_sites_in_goal(Goal0, Goal, !GoalIdMap, set_of_var.is_empty(NeededNonLocals) then !:ToDeleteGoals = NewToDeleteGoals, - Goal = true_goal + Context = goal_info_get_context(GoalInfo), + Goal = true_goal(Context) else Goal = Goal0, % Assume that all nonlocals are needed. @@ -1570,7 +1571,8 @@ opt_format_call_sites_in_goal(Goal0, Goal, !GoalIdMap, set_of_var.remove(LHSVar, !ToDeleteVars) then % This effectively deletes the unification. - Goal = true_goal + Context = goal_info_get_context(GoalInfo), + Goal = true_goal(Context) else % If _RHS = rhs_lambda_goal, we should optimize any occurrences % of format calls inside the lambda goal. Unfortunately, @@ -1815,7 +1817,7 @@ create_replacement_goal(ModuleInfo, GoalId, CallKind, Specs, _FmtStrValVars, StateInVar, StateOutVar), StateUpdate = io_state_stream(StreamVar) ), - create_state_update_replacement(ModuleInfo, Specs, Context, + create_state_update_replacement(ModuleInfo, Context, Specs, StateUpdate, StateInVar, StateOutVar, ReplacementGoal, !VarTable) ; CallKind = kind_stream_string_writer(Context, @@ -1868,7 +1870,7 @@ create_string_format_replacement(ModuleInfo, Specs, Context, ResultVar, % in the desired variable, this code point is never actually reached. % This code is here just in case that ever changes. make_simple_assign(ResultVar, ActualResultVar, - umc_implicit("replace_string_format"), [], AssignGoal), + Context, umc_implicit("replace_string_format"), [], AssignGoal), AllGoals = Goals ++ [AssignGoal] ), set_of_var.insert(ResultVar, ValueVars, NonLocals), @@ -1966,14 +1968,14 @@ replace_string_format_nonempty(ModuleInfo, HeadSpec, TailSpecs, % anyway, which is another reason why the --warn-implicit-stream-calls % option encourages programmers to do that. % -:- pred create_state_update_replacement(module_info::in, - list(compiler_format_spec)::in, prog_context::in, +:- pred create_state_update_replacement(module_info::in, prog_context::in, + list(compiler_format_spec)::in, state_format::in, prog_var::in, prog_var::in, hlds_goal::out, var_table::in, var_table::out) is det. -create_state_update_replacement(ModuleInfo, Specs, Context, StateFormat, +create_state_update_replacement(ModuleInfo, Context, Specs, StateFormat, StateInVar, StateOutVar, ReplacementGoal, !VarTable) :- - replace_state_format(ModuleInfo, Specs, StateFormat, + replace_state_format(ModuleInfo, Context, Specs, StateFormat, StateInVar, StateOutVar, Goals, ValueVars, !VarTable), make_di_uo_instmap_delta(StateInVar, StateOutVar, InstMapDelta), @@ -1982,12 +1984,13 @@ create_state_update_replacement(ModuleInfo, Specs, Context, StateFormat, Context, GoalInfo), conj_list_to_goal(Goals, GoalInfo, ReplacementGoal). -:- pred replace_state_format(module_info::in, list(compiler_format_spec)::in, - state_format::in, prog_var::in, prog_var::in, list(hlds_goal)::out, - set_of_progvar::out, var_table::in, var_table::out) is det. +:- pred replace_state_format(module_info::in, prog_context::in, + list(compiler_format_spec)::in, state_format::in, + prog_var::in, prog_var::in, list(hlds_goal)::out, set_of_progvar::out, + var_table::in, var_table::out) is det. -replace_state_format(ModuleInfo, Specs, StateFormat, StateInVar, StateOutVar, - Goals, !:ValueVars, !VarTable) :- +replace_state_format(ModuleInfo, Context, Specs, StateFormat, + StateInVar, StateOutVar, Goals, !:ValueVars, !VarTable) :- set_of_var.init(!:ValueVars), ( Specs = [], @@ -2001,7 +2004,7 @@ replace_state_format(ModuleInfo, Specs, StateFormat, StateInVar, StateOutVar, Unification, UnifyContext), make_di_uo_instmap_delta(StateInVar, StateOutVar, InstMapDelta), goal_info_init(set_of_var.list_to_set([StateInVar, StateOutVar]), - InstMapDelta, detism_det, purity_pure, GoalInfo), + InstMapDelta, detism_det, purity_pure, Context, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo), Goals = [Goal] ; @@ -2166,7 +2169,7 @@ represent_spec(ModuleInfo, Spec, MaybeResultVar, ResultVar, Goals, Context, ; MaybeResultVar = yes(ResultVar), make_simple_assign(ResultVar, ValueVar, - umc_implicit("represent_spec"), [], AssignGoal), + Context, umc_implicit("represent_spec"), [], AssignGoal), Goals = [AssignGoal] ) else @@ -2453,7 +2456,7 @@ build_flags_arg(Context, Flags, Var, Goals, !VarTable) :- du_ctor(ConsSymNameCombine, 5, TypeCtorCombine), ConsIdCombine = du_data_ctor(DuCtorCombine), SpecVars = [VarHash, VarSpace, VarZero, VarMinus, VarPlus], - construct_functor(Var, ConsIdCombine, SpecVars, GoalCombine), + construct_functor(Context, Var, ConsIdCombine, SpecVars, GoalCombine), Goals = [GoalHash, GoalSpace, GoalZero, GoalMinus, GoalPlus, GoalCombine]. diff --git a/compiler/par_loop_control.m b/compiler/par_loop_control.m index 1b0af09e4..8a2de2883 100644 --- a/compiler/par_loop_control.m +++ b/compiler/par_loop_control.m @@ -862,10 +862,14 @@ rewrite_nonrecursive_par_conjuncts(_, _, [], [], !VarTable). rewrite_nonrecursive_par_conjuncts(Info, UseParentStack, [Conjunct0 | Conjuncts0], Goals, !VarTable) :- % Create the "get free slot" call. - create_get_free_slot_goal(Info, LCSVar, GetFreeSlotGoal, !VarTable), + Conjunct0 = hlds_goal(_, ConjunctGoalInfo0), + ConjunctContext = goal_info_get_context(ConjunctGoalInfo0), + create_get_free_slot_goal(Info, ConjunctContext, + LCSVar, GetFreeSlotGoal, !VarTable), % Add a join_and_terminate goal to the end of Conjunct0 forming Conjunct. - create_join_and_terminate_goal(Info, LCVar, LCSVar, JoinAndTerminateGoal), + create_join_and_terminate_goal(Info, ConjunctContext, + LCVar, LCSVar, JoinAndTerminateGoal), Conjunct0GoalInfo = Conjunct0 ^ hg_info, goal_to_conj_list(Conjunct0, Conjunct0Goals), ConjunctGoals = Conjunct0Goals ++ [JoinAndTerminateGoal], @@ -1091,7 +1095,7 @@ combine_use_parent_stack(lc_create_frame_on_child_stack, goal_update_non_loop_control_paths(Info, RecParConjIds, FixupGoalInfo, !Goal) :- - GoalInfo0 = !.Goal ^ hg_info, + !.Goal = hlds_goal(_, GoalInfo0), GoalId = goal_info_get_goal_id(GoalInfo0), ( if % This goal is one of the transformed parallel conjunctions, @@ -1117,7 +1121,8 @@ goal_update_non_loop_control_paths(Info, RecParConjIds, FixupGoalInfo, ) then goal_to_conj_list(!.Goal, Conjs0), - create_finish_loop_control_goal(Info, FinishLCGoal), + Context = goal_info_get_context(GoalInfo0), + create_finish_loop_control_goal(Info, Context, FinishLCGoal), Conjs = Conjs0 ++ [FinishLCGoal], conj_list_to_goal(Conjs, GoalInfo0, !:Goal), fixup_goal_info(Info, !Goal), @@ -1253,10 +1258,10 @@ case_update_non_loop_control_paths(Info, RecParConjIds, !Case, %---------------------------------------------------------------------------% -:- pred create_get_free_slot_goal(loop_control_info::in, prog_var::out, - hlds_goal::out, var_table::in, var_table::out) is det. +:- pred create_get_free_slot_goal(loop_control_info::in, prog_context::in, + prog_var::out, hlds_goal::out, var_table::in, var_table::out) is det. -create_get_free_slot_goal(Info, LCSVar, Goal, !VarTable) :- +create_get_free_slot_goal(Info, Context, LCSVar, Goal, !VarTable) :- LCSVarEntry = vte("LCS", loop_control_slot_var_type, is_not_dummy_type), add_var_entry(LCSVarEntry, LCSVar, !VarTable), LCVar = Info ^ lci_lc_var, @@ -1267,31 +1272,34 @@ create_get_free_slot_goal(Info, LCSVar, Goal, !VarTable) :- maybe.no, SymName), NonLocals = set_of_var.list_to_set([LCVar, LCSVar]), InstmapDelta = instmap_delta_bind_var(LCSVar), - GoalInfo = impure_init_goal_info(NonLocals, InstmapDelta, detism_det), + impure_init_goal_info(NonLocals, InstmapDelta, detism_det, Context, + GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). %---------------------------------------------------------------------------% -:- pred create_create_loop_control_goal(module_info::in, prog_var::in, - prog_var::out, hlds_goal::out, var_table::in, var_table::out) is det. +:- pred create_create_loop_control_goal(module_info::in, prog_context::in, + prog_var::in, prog_var::out, hlds_goal::out, + var_table::in, var_table::out) is det. -create_create_loop_control_goal(ModuleInfo, NumContextsVar, LCVar, Goal, - !VarTable) :- +create_create_loop_control_goal(ModuleInfo, Context, NumContextsVar, + LCVar, Goal, !VarTable) :- LCVarEntry = vte("LC", loop_control_var_type, is_not_dummy_type), add_var_entry(LCVarEntry, LCVar, !VarTable), get_lc_create_proc(ModuleInfo, LCCreatePredId, LCCreateProcId), GoalExpr = plain_call(LCCreatePredId, LCCreateProcId, [NumContextsVar, LCVar], not_builtin, no, lc_create_sym_name), goal_info_init(set_of_var.list_to_set([NumContextsVar, LCVar]), - instmap_delta_bind_var(LCVar), detism_det, purity_pure, GoalInfo), + instmap_delta_bind_var(LCVar), detism_det, purity_pure, Context, + GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). %---------------------------------------------------------------------------% -:- pred create_join_and_terminate_goal(loop_control_info::in, prog_var::in, - prog_var::in, hlds_goal::out) is det. +:- pred create_join_and_terminate_goal(loop_control_info::in, prog_context::in, + prog_var::in, prog_var::in, hlds_goal::out) is det. -create_join_and_terminate_goal(Info, LCVar, LCSVar, Goal) :- +create_join_and_terminate_goal(Info, Context, LCVar, LCSVar, Goal) :- proc(PredId, ProcId) = Info ^ lci_join_and_terminate_proc, SymName = Info ^ lci_join_and_terminate_proc_name, @@ -1299,15 +1307,16 @@ create_join_and_terminate_goal(Info, LCVar, LCSVar, Goal) :- maybe.no, SymName), NonLocals = set_of_var.list_to_set([LCVar, LCSVar]), instmap_delta_init_reachable(InstmapDelta), - GoalInfo = impure_init_goal_info(NonLocals, InstmapDelta, detism_det), + impure_init_goal_info(NonLocals, InstmapDelta, detism_det, Context, + GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). %---------------------------------------------------------------------------% -:- pred create_finish_loop_control_goal(loop_control_info::in, hlds_goal::out) - is det. +:- pred create_finish_loop_control_goal(loop_control_info::in, + prog_context::in, hlds_goal::out) is det. -create_finish_loop_control_goal(Info, Goal) :- +create_finish_loop_control_goal(Info, Context, Goal) :- get_lc_finish_loop_control_proc(Info ^ lci_module_info, PredId, ProcId), LCVar = Info ^ lci_lc_var, @@ -1315,7 +1324,8 @@ create_finish_loop_control_goal(Info, Goal) :- lc_finish_loop_control_sym_name), NonLocals = set_of_var.list_to_set([LCVar]), instmap_delta_init_reachable(InstmapDelta), - GoalInfo = impure_init_goal_info(NonLocals, InstmapDelta, detism_det), + impure_init_goal_info(NonLocals, InstmapDelta, detism_det, Context, + GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). %---------------------------------------------------------------------------% @@ -1380,9 +1390,10 @@ update_outer_proc(PredProcId, InnerPredProcId, InnerPredName, ModuleInfo, add_var_entry(NumContextsEntry, NumContextsVar, !VarTable), get_lc_default_num_contexts_proc(ModuleInfo, LCDefaultNumContextsPredId, LCDefaultNumContextsProcId), + proc_info_get_context(!.ProcInfo, Context), goal_info_init(set_of_var.list_to_set([NumContextsVar]), instmap_delta_bind_var(NumContextsVar), - detism_det, purity_pure, GetNumContextsGoalInfo), + detism_det, purity_pure, Context, GetNumContextsGoalInfo), GetNumContextsGoalExpr = plain_call(LCDefaultNumContextsPredId, LCDefaultNumContextsProcId, [NumContextsVar], not_builtin, no, lc_default_num_contexts_sym_name), @@ -1390,8 +1401,8 @@ update_outer_proc(PredProcId, InnerPredProcId, InnerPredName, ModuleInfo, hlds_goal(GetNumContextsGoalExpr, GetNumContextsGoalInfo), % Create the call to lc_create - create_create_loop_control_goal(ModuleInfo, NumContextsVar, LCVar, - LCCreateGoal, !VarTable), + create_create_loop_control_goal(ModuleInfo, Context, NumContextsVar, + LCVar, LCCreateGoal, !VarTable), % Create the inner call. InnerCallArgs = [LCVar | HeadVars], @@ -1400,7 +1411,7 @@ update_outer_proc(PredProcId, InnerPredProcId, InnerPredName, ModuleInfo, % delta as the original body. remap_instmap(Remap, OrigInstmapDelta, InstmapDelta), goal_info_init(NonLocals, InstmapDelta, Detism, purity_impure, - InnerProcCallGoalInfo), + Context, InnerProcCallGoalInfo), proc(InnerPredId, InnerProcId) = InnerPredProcId, InnerProcCallGoal = hlds_goal(plain_call(InnerPredId, InnerProcId, InnerCallArgs, not_builtin, no, InnerPredName), @@ -1408,7 +1419,7 @@ update_outer_proc(PredProcId, InnerPredProcId, InnerPredName, ModuleInfo, % Build a conjunction of these goals. goal_info_init(set_of_var.list_to_set(HeadVars), InstmapDelta, Detism, - purity_impure, ConjGoalInfo), + purity_impure, Context, ConjGoalInfo), ConjGoal = hlds_goal(conj(plain_conj, [GetNumContextsGoal, LCCreateGoal, InnerProcCallGoal]), ConjGoalInfo), diff --git a/compiler/pd_debug.m b/compiler/pd_debug.m index ac59ae2e3..625b541f2 100644 --- a/compiler/pd_debug.m +++ b/compiler/pd_debug.m @@ -83,6 +83,7 @@ :- import_module bool. :- import_module maybe. :- import_module set. +:- import_module term_context. %---------------------------------------------------------------------------% @@ -241,7 +242,7 @@ pd_debug_output_goals(PDInfo, IdStr, Msg, Goals, !IO) :- ; MaybeDebugStream = yes(DebugStream), GoalExpr = conj(plain_conj, Goals), - goal_info_init(GoalInfo), + goal_info_init(dummy_context, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo), pd_debug_definitely_output_goal(PDInfo, DebugStream, IdStr, Msg, Goal, !IO) diff --git a/compiler/polymorphism_clause.m b/compiler/polymorphism_clause.m index a4b8b79fb..ae7c51f00 100644 --- a/compiler/polymorphism_clause.m +++ b/compiler/polymorphism_clause.m @@ -423,7 +423,7 @@ produce_clause_existq_tvars(PredInfo, HeadVars, UnconstrainedTVars, list.foldl(rtti_reuse_typeclass_info_var, ExistTypeClassVars, RttiVarMaps0, RttiVarMaps), poly_info_set_rtti_varmaps(RttiVarMaps, !Info), - make_complicated_unify_assigns(ExistTypeClassInfoHeadVars, + make_complicated_unify_assigns(Context, ExistTypeClassInfoHeadVars, ExistTypeClassVars, ExtraTypeClassUnifyGoals), % Figure out the bindings for any unconstrained existentially quantified @@ -450,10 +450,10 @@ produce_clause_existq_tvars(PredInfo, HeadVars, UnconstrainedTVars, % for those types. apply_subst_to_tvars(KindMap, PredToActualTypeSubst, UnconstrainedTVars, ActualTypes), - polymorphism_do_make_type_info_vars(ActualTypes, Context, + polymorphism_do_make_type_info_vars(Context, ActualTypes, TypeInfoVarsMCAs, ExtraTypeInfoGoals, !Info), assoc_list.keys(TypeInfoVarsMCAs, TypeInfoVars), - make_complicated_unify_assigns(TypeInfoHeadVars, TypeInfoVars, + make_complicated_unify_assigns(Context, TypeInfoHeadVars, TypeInfoVars, ExtraTypeInfoUnifyGoals), list.condense([[Goal0 | ExtraTypeClassGoals], ExtraTypeClassUnifyGoals, ExtraTypeInfoGoals, ExtraTypeInfoUnifyGoals], GoalList), diff --git a/compiler/polymorphism_goal.m b/compiler/polymorphism_goal.m index c9e4d8bd3..d351c0041 100644 --- a/compiler/polymorphism_goal.m +++ b/compiler/polymorphism_goal.m @@ -654,7 +654,7 @@ polymorphism_process_existq_unify_functor(CtorDefn, IsExistConstr, % Create type_info variables for the _unconstrained_ existentially % quantified type variables. - polymorphism_do_make_type_info_vars(ActualExistentialTypes, Context, + polymorphism_do_make_type_info_vars(Context, ActualExistentialTypes, ExtraTypeInfoVarsMCAs, ExtraTypeInfoGoals, !Info), assoc_list.keys(ExtraTypeInfoVarsMCAs, ExtraTypeInfoVars), @@ -1054,8 +1054,8 @@ polymorphism_process_plain_or_foreign_call(CalleePredId, CallArgVars0, % vars. apply_rec_subst_to_tvars(ParentKindMap, ParentToActualTypeSubst, ParentUnconstrainedUnivTVars, ActualUnconstrainedUnivTypes), - polymorphism_do_make_type_info_vars(ActualUnconstrainedUnivTypes, - CallContext, ExtraUnivTypeInfoVarsMCAs, + polymorphism_do_make_type_info_vars(CallContext, + ActualUnconstrainedUnivTypes, ExtraUnivTypeInfoVarsMCAs, ExtraUnivTypeInfoGoals, !Info), assoc_list.keys(ExtraUnivTypeInfoVarsMCAs, ExtraUnivTypeInfoVars), @@ -1063,8 +1063,8 @@ polymorphism_process_plain_or_foreign_call(CalleePredId, CallArgVars0, % vars. apply_rec_subst_to_tvars(ParentKindMap, ParentToActualTypeSubst, ParentUnconstrainedExistTVars, ActualUnconstrainedExistTypes), - polymorphism_do_make_type_info_vars(ActualUnconstrainedExistTypes, - CallContext, ExtraExistTypeInfoVarsMCAs, + polymorphism_do_make_type_info_vars(CallContext, + ActualUnconstrainedExistTypes, ExtraExistTypeInfoVarsMCAs, ExtraExistTypeInfoGoals, !Info), assoc_list.keys(ExtraExistTypeInfoVarsMCAs, ExtraExistTypeInfoVars), diff --git a/compiler/polymorphism_type_class_info.m b/compiler/polymorphism_type_class_info.m index 5edddef94..98737e7c4 100644 --- a/compiler/polymorphism_type_class_info.m +++ b/compiler/polymorphism_type_class_info.m @@ -516,7 +516,7 @@ make_typeclass_info_from_proof_instance(ExistQVars, Context, % Make the type_infos for the types that are constrained by this. % These are packaged in the typeclass_info. - polymorphism_do_make_type_info_vars(ConstrainedTypes, Context, + polymorphism_do_make_type_info_vars(Context, ConstrainedTypes, ArgTypeInfoVarsMCAs, TypeInfoGoals, !Info), % Make the typeclass_infos for the constraints from the context of the @@ -527,7 +527,7 @@ make_typeclass_info_from_proof_instance(ExistQVars, Context, % Make the type_infos for the unconstrained type variables % from the head of the instance declaration. - polymorphism_do_make_type_info_vars(ActualUnconstrainedTypes, Context, + polymorphism_do_make_type_info_vars(Context, ActualUnconstrainedTypes, ArgUnconstrainedTypeInfoVarsMCAs, UnconstrainedTypeInfoGoals, !Info), %---------------------% @@ -563,8 +563,8 @@ make_typeclass_info_from_proof_instance(ExistQVars, Context, else get_base_typeclass_info_cons_id(!.Info, InstanceTable, Constraint, instance_id(InstanceNum), InstanceTypes, BaseConsId), - materialize_base_typeclass_info_var(Constraint, BaseConsId, BaseVar, - BaseGoals, !Info), + materialize_base_typeclass_info_var(Context, Constraint, BaseConsId, + BaseVar, BaseGoals, !Info), construct_typeclass_info(Context, Constraint, BaseVar, BaseConsId, ArgVarsMCAs, InitialVarMapsSnapshot, TypeClassInfoVar, TypeClassInfoMCA, @@ -834,7 +834,8 @@ polymorphism_maybe_extract_type_info(OldRttiVarMaps, Context, TVar, then polymorphism_extract_type_info(TVar, TypeClassInfoVar, Index, Context, NewGoals, TypeInfoVar1, !Info), - make_complicated_unify_assign(TypeInfoVar0, TypeInfoVar1, AssignGoal), + make_complicated_unify_assign(Context, + TypeInfoVar0, TypeInfoVar1, AssignGoal), !:ExtraGoals = NewGoals ++ [AssignGoal | !.ExtraGoals] else true @@ -970,10 +971,12 @@ new_typeclass_info_var(Constraint, VarKind, Var, VarType, !Info) :- %---------------------------------------------------------------------------% -:- pred materialize_base_typeclass_info_var(prog_constraint::in, cons_id::in, +:- pred materialize_base_typeclass_info_var(prog_context::in, + prog_constraint::in, cons_id::in, prog_var::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. -materialize_base_typeclass_info_var(Constraint, ConsId, Var, Goals, !Info) :- +materialize_base_typeclass_info_var(Context, Constraint, ConsId, + Var, Goals, !Info) :- % NOTE We used to search for ConsId in the const_struct_var_map, but % this was useless, because we never PUT base_typeclass_infos into % the const_struct_var_map. @@ -1004,7 +1007,7 @@ materialize_base_typeclass_info_var(Constraint, ConsId, Var, Goals, !Info) :- % Create the rest of the unification goal. NonLocals = set_of_var.make_singleton(Var), InstMapDelta = instmap_delta_bind_var(Var), - goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, Context, GoalInfo), Goal = hlds_goal(Unify, GoalInfo), Goals = [Goal]. diff --git a/compiler/polymorphism_type_info.m b/compiler/polymorphism_type_info.m index 8154b04b4..0b25d3113 100644 --- a/compiler/polymorphism_type_info.m +++ b/compiler/polymorphism_type_info.m @@ -102,7 +102,6 @@ :- import_module assoc_list. :- import_module list. :- import_module maybe. -:- import_module term. %---------------------------------------------------------------------------% @@ -111,7 +110,7 @@ % to the appropriate type_info structure for the type. % Update the var_table accordingly. % -:- pred polymorphism_make_type_info_var(mer_type::in, term.context::in, +:- pred polymorphism_make_type_info_var(prog_context::in, mer_type::in, prog_var::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. % Given a list of types, create a list of variables to hold the type_infos @@ -119,7 +118,7 @@ % variables to the appropriate type_info structures for the types. % Update the var_table accordingly. % -:- pred polymorphism_make_type_info_vars(list(mer_type)::in, term.context::in, +:- pred polymorphism_make_type_info_vars(prog_context::in, list(mer_type)::in, list(prog_var)::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. @@ -127,8 +126,8 @@ % information for each var that can be useful when putting type_infos % into static data. % -:- pred polymorphism_do_make_type_info_vars(list(mer_type)::in, - term.context::in, +:- pred polymorphism_do_make_type_info_vars(prog_context::in, + list(mer_type)::in, assoc_list(prog_var, maybe(const_struct_arg))::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. @@ -139,18 +138,18 @@ % These do not store the updated pred_infos and proc_infos back into % the module_info. % -:- pred polymorphism_make_type_info_var_mi(mer_type::in, - term.context::in, prog_var::out, list(hlds_goal)::out, +:- pred polymorphism_make_type_info_var_mi(prog_context::in, + mer_type::in, prog_var::out, list(hlds_goal)::out, module_info::in, module_info::out, pred_info::in, pred_info::out, proc_info::in, proc_info::out) is det. -:- pred polymorphism_make_type_info_vars_mi(list(mer_type)::in, - term.context::in, list(prog_var)::out, list(hlds_goal)::out, +:- pred polymorphism_make_type_info_vars_mi(prog_context::in, + list(mer_type)::in, list(prog_var)::out, list(hlds_goal)::out, module_info::in, module_info::out, pred_info::in, pred_info::out, proc_info::in, proc_info::out) is det. %---------------------------------------------------------------------------% - % init_type_info_var(Type, ArgVars, TypeInfoVar, TypeInfoGoal, + % init_type_info_var(Context, Type, ArgVars, TypeInfoVar, TypeInfoGoal, % !RttiVarMaps): % % Create the unification that constructs the second cell of a type_info @@ -166,10 +165,10 @@ % The remaining variables in ArgVars should be bound to the type_infos % or type_ctor_infos giving Type's argument types. % -:- pred init_type_info_var(mer_type::in, list(prog_var)::in, prog_var::in, - hlds_goal::out, rtti_varmaps::in, rtti_varmaps::out) is det. +:- pred init_type_info_var(prog_context::in, mer_type::in, list(prog_var)::in, + prog_var::in, hlds_goal::out, rtti_varmaps::in, rtti_varmaps::out) is det. - % init_const_type_ctor_info_var(Type, TypeCtor, + % init_const_type_ctor_info_var(Context, Type, TypeCtor, % TypeCtorInfoVar, TypeCtorConsId, TypeCtorInfoGoal, % !VarTable, !RttiVarMaps): % @@ -187,8 +186,8 @@ % the type whose type constructor TypeCtor is, in the type of % TypeCtorInfoVar. % -:- pred init_const_type_ctor_info_var(mer_type::in, type_ctor::in, - prog_var::out, cons_id::out, hlds_goal::out, +:- pred init_const_type_ctor_info_var(prog_context::in, + mer_type::in, type_ctor::in, prog_var::out, cons_id::out, hlds_goal::out, var_table::in, var_table::out, rtti_varmaps::in, rtti_varmaps::out) is det. %---------------------% @@ -268,6 +267,7 @@ :- import_module pair. :- import_module require. :- import_module set. +:- import_module term. %---------------------------------------------------------------------------% @@ -281,11 +281,11 @@ polymorphism_make_type_info_vars(Types, Context, Vars, ExtraGoals, !Info) :- VarsMCAs, ExtraGoals, !Info), assoc_list.keys(VarsMCAs, Vars). -:- pred polymorphism_do_make_type_info_var(mer_type::in, term.context::in, +:- pred polymorphism_do_make_type_info_var(term.context::in, mer_type::in, pair(prog_var, maybe(const_struct_arg))::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. -polymorphism_do_make_type_info_var(Type, Context, VarMCA, ExtraGoals, !Info) :- +polymorphism_do_make_type_info_var(Context, Type, VarMCA, ExtraGoals, !Info) :- ( if type_has_variable_arity_ctor(Type, TypeCtor, TypeArgs) then % This occurs for code where a predicate calls a polymorphic predicate % with a type whose type constructor is of variable arity. The @@ -298,8 +298,8 @@ polymorphism_do_make_type_info_var(Type, Context, VarMCA, ExtraGoals, !Info) :- % XXX FIXME (RTTI for higher order impure code) % we should not ignore the purity of higher order procs; % it should get included in the RTTI. - polymorphism_make_type_info(Type, TypeCtor, TypeArgs, - tc_is_var_arity, Context, VarMCA, ExtraGoals, !Info) + polymorphism_make_type_info(Context, Type, TypeCtor, TypeArgs, + tc_is_var_arity, VarMCA, ExtraGoals, !Info) else ( ( Type = defined_type(_, _, _) @@ -313,8 +313,8 @@ polymorphism_do_make_type_info_var(Type, Context, VarMCA, ExtraGoals, !Info) :- % predicate with a known value of the type variable. The % transformation we perform is shown in the comment at the top % of the module. - polymorphism_make_type_info(Type, TypeCtor, TypeArgs, - tc_is_not_var_arity, Context, VarMCA, ExtraGoals, !Info) + polymorphism_make_type_info(Context, Type, TypeCtor, TypeArgs, + tc_is_not_var_arity, VarMCA, ExtraGoals, !Info) ; Type = type_variable(TypeVar, _), poly_get_type_info_locn(TypeVar, TypeInfoLocn, !Info), @@ -324,22 +324,22 @@ polymorphism_do_make_type_info_var(Type, Context, VarMCA, ExtraGoals, !Info) :- ) ). -polymorphism_do_make_type_info_vars([], _, [], [], !Info). -polymorphism_do_make_type_info_vars([Type | Types], Context, +polymorphism_do_make_type_info_vars(_, [], [], [], !Info). +polymorphism_do_make_type_info_vars(Context, [Type | Types], VarsMCAs, ExtraGoals, !Info) :- - polymorphism_do_make_type_info_var(Type, Context, HeadVarMCA, + polymorphism_do_make_type_info_var(Context, Type, HeadVarMCA, HeadGoals, !Info), - polymorphism_do_make_type_info_vars(Types, Context, TailVarsMCAs, + polymorphism_do_make_type_info_vars(Context, Types, TailVarsMCAs, TailGoals, !Info), VarsMCAs = [HeadVarMCA | TailVarsMCAs], ExtraGoals = HeadGoals ++ TailGoals. %---------------------% -polymorphism_make_type_info_var_mi(Type, Context, Var, ExtraGoals, +polymorphism_make_type_info_var_mi(Context, Type, Var, ExtraGoals, !ModuleInfo, !PredInfo, !ProcInfo) :- create_poly_info(!.ModuleInfo, !.PredInfo, !.ProcInfo, PolyInfo0), - polymorphism_make_type_info_var(Type, Context, Var, ExtraGoals, + polymorphism_make_type_info_var(Context, Type, Var, ExtraGoals, PolyInfo0, PolyInfo), poly_info_extract(PolyInfo, PolySpecs, !PredInfo, !ProcInfo, !:ModuleInfo), expect(unify(PolySpecs, []), $pred, "errors while making type_info var"). @@ -358,13 +358,13 @@ polymorphism_make_type_info_vars_mi(Types, Context, Vars, ExtraGoals, ---> tc_is_not_var_arity ; tc_is_var_arity. -:- pred polymorphism_make_type_info(mer_type::in, type_ctor::in, - list(mer_type)::in, type_ctor_is_var_arity::in, prog_context::in, - pair(prog_var, maybe(const_struct_arg))::out, +:- pred polymorphism_make_type_info(prog_context::in, + mer_type::in, type_ctor::in, list(mer_type)::in, + type_ctor_is_var_arity::in, pair(prog_var, maybe(const_struct_arg))::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. -polymorphism_make_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, - Context, TypeInfoVarMCA, ExtraGoals, !Info) :- +polymorphism_make_type_info(Context, Type, TypeCtor, TypeArgs, + TypeCtorIsVarArity, TypeInfoVarMCA, ExtraGoals, !Info) :- poly_info_get_type_info_var_map(!.Info, TypeInfoVarMap0), ( if map.search(TypeInfoVarMap0, TypeCtor, TypeCtorVarMap0), @@ -375,8 +375,8 @@ polymorphism_make_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, TypeInfoVarMCA = OldTypeInfoVarMCA, ExtraGoals = [] else - polymorphism_construct_type_info(Type, TypeCtor, TypeArgs, - TypeCtorIsVarArity, Context, TypeInfoVar, TypeInfoConstArg, + polymorphism_construct_type_info(Context, Type, TypeCtor, TypeArgs, + TypeCtorIsVarArity, TypeInfoVar, TypeInfoConstArg, ExtraGoals, !Info), TypeInfoVarMCA = TypeInfoVar - TypeInfoConstArg, % We have to get the type_info_var_map again since the call just above @@ -395,18 +395,18 @@ polymorphism_make_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, poly_info_set_type_info_var_map(TypeInfoVarMap, !Info) ). -:- pred polymorphism_construct_type_info(mer_type::in, type_ctor::in, - list(mer_type)::in, type_ctor_is_var_arity::in, prog_context::in, - prog_var::out, maybe(const_struct_arg)::out, +:- pred polymorphism_construct_type_info(prog_context::in, + mer_type::in, type_ctor::in, list(mer_type)::in, + type_ctor_is_var_arity::in, prog_var::out, maybe(const_struct_arg)::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. -polymorphism_construct_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, - Context, Var, MCA, ExtraGoals, !Info) :- +polymorphism_construct_type_info(Context, Type, TypeCtor, ArgTypes, + TypeCtorIsVarArity, Var, MCA, ExtraGoals, !Info) :- get_var_maps_snapshot("polymorphism_construct_type_info", InitialVarMapsSnapshot, !Info), % Create the typeinfo vars for the arguments. - polymorphism_do_make_type_info_vars(TypeArgs, Context, + polymorphism_do_make_type_info_vars(Context, ArgTypes, ArgTypeInfoVarsMCAs, ArgTypeInfoGoals, !Info), TypeCtorConsId = type_ctor_info_cons_id(TypeCtor), @@ -437,8 +437,8 @@ polymorphism_construct_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, poly_info_get_rtti_varmaps(!.Info, RttiVarMaps0), new_type_info_var_vt(Type, type_ctor_info, TypeCtorVar, VarTable0, VarTable1, RttiVarMaps0, RttiVarMaps1), - init_const_type_ctor_info_var_from_cons_id(TypeCtorConsId, TypeCtorVar, - TypeCtorGoal), + init_const_type_ctor_info_var_from_cons_id(Context, TypeCtorConsId, + TypeCtorVar, TypeCtorGoal), TypeCtorGoals = [TypeCtorGoal], map.det_insert(TypeCtorConsIdConstArg, TypeCtorVar, ConstStructVarMap0, ConstStructVarMap1), @@ -446,10 +446,10 @@ polymorphism_construct_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, poly_info_set_var_table_rtti(VarTable1, RttiVarMaps1, !Info) ), - polymorphism_maybe_construct_second_type_info_cell(Type, TypeCtor, - TypeCtorIsVarArity, TypeCtorVar, TypeCtorConsId, TypeCtorGoals, - ArgTypeInfoVarsMCAs, ArgTypeInfoGoals, InitialVarMapsSnapshot, - Var, MCA, ExtraGoals, !Info). + polymorphism_maybe_construct_second_type_info_cell(Context, + Type, TypeCtor, TypeCtorIsVarArity, TypeCtorVar, TypeCtorConsId, + TypeCtorGoals, ArgTypeInfoVarsMCAs, ArgTypeInfoGoals, + InitialVarMapsSnapshot, Var, MCA, ExtraGoals, !Info). :- type maybe_need_arity ---> do_not_need_arity @@ -482,15 +482,15 @@ polymorphism_construct_type_info(Type, TypeCtor, TypeArgs, TypeCtorIsVarArity, % rtti_to_mlds.gen_type_info_defn/6 % java/runtime/TypeInfo_Struct.java % -:- pred polymorphism_maybe_construct_second_type_info_cell(mer_type::in, - type_ctor::in, type_ctor_is_var_arity::in, +:- pred polymorphism_maybe_construct_second_type_info_cell(prog_context::in, + mer_type::in, type_ctor::in, type_ctor_is_var_arity::in, prog_var::in, cons_id::in, list(hlds_goal)::in, assoc_list(prog_var, maybe(const_struct_arg))::in, list(hlds_goal)::in, var_maps::in, prog_var::out, maybe(const_struct_arg)::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. -:- pragma inline(pred(polymorphism_maybe_construct_second_type_info_cell/14)). +:- pragma inline(pred(polymorphism_maybe_construct_second_type_info_cell/15)). -polymorphism_maybe_construct_second_type_info_cell(Type, TypeCtor, +polymorphism_maybe_construct_second_type_info_cell(Context, Type, TypeCtor, TypeCtorIsVarArity, TypeCtorVar, TypeCtorConsId, TypeCtorGoals, ArgTypeInfoVarsMCAs, ArgTypeInfoGoals, InitialVarMapsSnapshot, TypeInfoVar, MCA, ExtraGoals, !Info) :- @@ -561,22 +561,22 @@ polymorphism_maybe_construct_second_type_info_cell(Type, TypeCtor, TypeInfoVar = TypeCtorVar else % We do need a second cell for a separate typeinfo. - polymorphism_construct_second_type_info_cell(Type, TypeCtor, + polymorphism_construct_second_type_info_cell(Context, Type, TypeCtor, NeedTypeCtorArity, TypeCtorVar, TypeCtorConsId, TypeCtorGoals, ArgTypeInfoVarsMCAs, ArgTypeInfoGoals, InitialVarMapsSnapshot, TypeInfoVar, MCA, ExtraGoals, !Info) ). -:- pred polymorphism_construct_second_type_info_cell(mer_type::in, - type_ctor::in, maybe_need_arity::in, +:- pred polymorphism_construct_second_type_info_cell(prog_context::in + ,mer_type::in, type_ctor::in, maybe_need_arity::in, prog_var::in, cons_id::in, list(hlds_goal)::in, assoc_list(prog_var, maybe(const_struct_arg))::in, list(hlds_goal)::in, var_maps::in, prog_var::out, maybe(const_struct_arg)::out, list(hlds_goal)::out, poly_info::in, poly_info::out) is det. -:- pragma inline(pred(polymorphism_construct_second_type_info_cell/14)). +:- pragma inline(pred(polymorphism_construct_second_type_info_cell/15)). -polymorphism_construct_second_type_info_cell(Type, TypeCtor, NeedTypeCtorArity, - TypeCtorVar, TypeCtorConsId, TypeCtorGoals, +polymorphism_construct_second_type_info_cell(Context, Type, TypeCtor, + NeedTypeCtorArity, TypeCtorVar, TypeCtorConsId, TypeCtorGoals, ArgTypeInfoVarsMCAs, ArgTypeInfoGoals, InitialVarMapsSnapshot, TypeInfoVar, MCA, ExtraGoals, !Info) :- Cell = type_info_cell(TypeCtor), @@ -657,7 +657,7 @@ polymorphism_construct_second_type_info_cell(Type, TypeCtor, NeedTypeCtorArity, InstMapDelta = instmap_delta_from_assoc_list([TypeInfoVar - TypeInfoVarInst]), goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, - GoalInfo), + Context, GoalInfo), TypeInfoGoal = hlds_goal(Unify, GoalInfo), ExtraGoals = [TypeInfoGoal] else @@ -670,14 +670,15 @@ polymorphism_construct_second_type_info_cell(Type, TypeCtor, NeedTypeCtorArity, % The call get_poly_const may (and probably will) allocate % a variable, though it shouldn't affect the rtti_varmaps. poly_info_get_rtti_varmaps(!.Info, RttiVarMaps1), - init_type_info_var(Type, [TypeCtorVar, ArityVar | ArgTypeInfoVars], + init_type_info_var(Context, Type, + [TypeCtorVar, ArityVar | ArgTypeInfoVars], TypeInfoVar, TypeInfoGoal, RttiVarMaps1, RttiVarMaps), ExtraGoals = TypeCtorGoals ++ ArityGoals ++ ArgTypeInfoGoals ++ [TypeInfoGoal] ; NeedTypeCtorArity = do_not_need_arity, poly_info_get_rtti_varmaps(!.Info, RttiVarMaps0), - init_type_info_var(Type, [TypeCtorVar | ArgTypeInfoVars], + init_type_info_var(Context, Type, [TypeCtorVar | ArgTypeInfoVars], TypeInfoVar, TypeInfoGoal, RttiVarMaps0, RttiVarMaps), ExtraGoals = TypeCtorGoals ++ ArgTypeInfoGoals ++ [TypeInfoGoal] ), @@ -687,7 +688,7 @@ polymorphism_construct_second_type_info_cell(Type, TypeCtor, NeedTypeCtorArity, %---------------------% -init_type_info_var(Type, ArgVars, TypeInfoVar, TypeInfoGoal, +init_type_info_var(Context, Type, ArgVars, TypeInfoVar, TypeInfoGoal, RttiVarMaps0, RttiVarMaps) :- type_to_ctor_det(Type, TypeCtor), Cell = type_info_cell(TypeCtor), @@ -723,24 +724,25 @@ init_type_info_var(Type, ArgVars, TypeInfoVar, TypeInfoGoal, [bound_functor(InstConsId, ArgInsts)]), InstMapDelta = instmap_delta_from_assoc_list( [TypeInfoVar - TypeInfoVarInst]), - goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, GoalInfo), + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, Context, + GoalInfo), TypeInfoGoal = hlds_goal(Unify, GoalInfo), % XXX This may be a bug. RttiVarMaps = RttiVarMaps0. -init_const_type_ctor_info_var(Type, TypeCtor, TypeCtorInfoVar, +init_const_type_ctor_info_var(Context, Type, TypeCtor, TypeCtorInfoVar, ConsId, TypeCtorInfoGoal, !VarTable, !RttiVarMaps) :- ConsId = type_ctor_info_cons_id(TypeCtor), new_type_info_var_vt(Type, type_ctor_info, TypeCtorInfoVar, !VarTable, !RttiVarMaps), - init_const_type_ctor_info_var_from_cons_id(ConsId, TypeCtorInfoVar, - TypeCtorInfoGoal). + init_const_type_ctor_info_var_from_cons_id(Context, ConsId, + TypeCtorInfoVar, TypeCtorInfoGoal). -:- pred init_const_type_ctor_info_var_from_cons_id(cons_id::in, prog_var::in, - hlds_goal::out) is det. +:- pred init_const_type_ctor_info_var_from_cons_id(prog_context::in, + cons_id::in, prog_var::in, hlds_goal::out) is det. -init_const_type_ctor_info_var_from_cons_id(ConsId, TypeCtorInfoVar, +init_const_type_ctor_info_var_from_cons_id(Context, ConsId, TypeCtorInfoVar, TypeCtorInfoGoal) :- % Create the construction unification to initialize the variable. TypeInfoRHS = rhs_functor(ConsId, is_not_exist_constr, []), @@ -756,7 +758,8 @@ init_const_type_ctor_info_var_from_cons_id(ConsId, TypeCtorInfoVar, % Create a goal_info for the unification. NonLocals = set_of_var.make_singleton(TypeCtorInfoVar), InstmapDelta = instmap_delta_bind_var(TypeCtorInfoVar), - goal_info_init(NonLocals, InstmapDelta, detism_det, purity_pure, GoalInfo), + goal_info_init(NonLocals, InstmapDelta, detism_det, purity_pure, Context, + GoalInfo), TypeCtorInfoGoal = hlds_goal(Unify, GoalInfo). %---------------------% diff --git a/compiler/prop_mode_constraints.m b/compiler/prop_mode_constraints.m index e44564e60..997b0ec7d 100644 --- a/compiler/prop_mode_constraints.m +++ b/compiler/prop_mode_constraints.m @@ -494,8 +494,7 @@ replace_call_with_conjunction(CallGoalExpr, Unifications, NewArgs, GoalExpr, % Create the new conjunction GoalExpr = conj(plain_conj, Goals), - goal_info_init(!:GoalInfo), - goal_info_set_context(Context, !GoalInfo), + goal_info_init(Context, !:GoalInfo), goal_info_set_nonlocals(CallNonlocals0, !GoalInfo). %----------------------------------------------------------------------------% diff --git a/compiler/quantification.m b/compiler/quantification.m index 4b18d5353..5d5c48822 100644 --- a/compiler/quantification.m +++ b/compiler/quantification.m @@ -955,11 +955,10 @@ quantify_goal_bi_implication(LHS0, RHS0, GoalExpr, OldGoalInfo, !Info) :- % ===> % (not (LHS, not RHS)), (not (RHS, not LHS)) Context = goal_info_get_context(OldGoalInfo), - goal_info_init(GoalInfo0), - goal_info_set_context(Context, GoalInfo0, GoalInfo1), - goal_info_set_nonlocals(LHS_NonLocals, GoalInfo1, LHS_GI), - goal_info_set_nonlocals(RHS_NonLocals, GoalInfo1, RHS_GI), - goal_info_set_nonlocals(NonLocals, GoalInfo1, GI), + goal_info_init(Context, GoalInfo0), + goal_info_set_nonlocals(LHS_NonLocals, GoalInfo0, LHS_GI), + goal_info_set_nonlocals(RHS_NonLocals, GoalInfo0, RHS_GI), + goal_info_set_nonlocals(NonLocals, GoalInfo0, GI), NotLHS = hlds_goal(negation(LHS), LHS_GI), NotRHS = hlds_goal(negation(RHS), RHS_GI), ForwardsImplicationExpr = diff --git a/compiler/rbmm.region_transformation.m b/compiler/rbmm.region_transformation.m index 29f17536b..c49792b88 100644 --- a/compiler/rbmm.region_transformation.m +++ b/compiler/rbmm.region_transformation.m @@ -100,6 +100,7 @@ :- import_module list. :- import_module require. :- import_module term. +:- import_module term_context. :- import_module varset. %---------------------------------------------------------------------------% @@ -989,7 +990,7 @@ make_assignment_goal(LeftRegVar, RightRegVar, Context, AssignmentGoal) :- NonLocals = set_of_var.init, InstmapDelta = instmap_delta_bind_var(LeftRegVar), goal_info_init(NonLocals, InstmapDelta, detism_det, purity_pure, - AssignmentInfo), + dummy_context, AssignmentInfo), AssignmentGoal = hlds_goal(AssignmentExpr, AssignmentInfo). %---------------------------------------------------------------------------% diff --git a/compiler/resolve_unify_functor.m b/compiler/resolve_unify_functor.m index cf7e9885a..5ac001bfa 100644 --- a/compiler/resolve_unify_functor.m +++ b/compiler/resolve_unify_functor.m @@ -242,7 +242,7 @@ resolve_unify_functor(ModuleInfo, X0, ConsId0, ArgVars0, Mode0, IsPlainUnify = is_not_plain_unify ; MaybeProcId = no, - Goal = true_goal, + Goal = true_goal(Context), SNA = sym_name_arity(SymName0, Arity), Pieces = [words("Error: the predicate or function")] ++ color_as_subject([qual_sym_name_arity(SNA)]) ++ diff --git a/compiler/simplify_goal.m b/compiler/simplify_goal.m index 0a15d90c0..68b70dbe5 100644 --- a/compiler/simplify_goal.m +++ b/compiler/simplify_goal.m @@ -256,7 +256,7 @@ maybe_simplify_goal_to_true_or_fail(InstMap0, Goal0ContainsTrace, ), goal_cost(Goal0, CostDelta), simplify_info_incr_cost_delta(CostDelta, !Info), - Goal = fail_goal_with_context(Context) + Goal = fail_goal(Context) else if % If --no-fully-strict, replace goals which cannot fail and have % no output variables with `true'. However, we don't do this for @@ -328,7 +328,7 @@ maybe_simplify_goal_to_true_or_fail(InstMap0, Goal0ContainsTrace, goal_cost(Goal0, CostDelta), simplify_info_incr_cost_delta(CostDelta, !Info), Context = goal_info_get_context(GoalInfo0), - Goal = true_goal_with_context(Context) + Goal = true_goal(Context) else Goal = Goal0 ). diff --git a/compiler/simplify_goal_call.m b/compiler/simplify_goal_call.m index 0872065f7..bcc6bede8 100644 --- a/compiler/simplify_goal_call.m +++ b/compiler/simplify_goal_call.m @@ -1280,7 +1280,8 @@ simplify_build_compare_ite(CmpLtGoal, CmpGtGoal, R, X, Y, Context, simplify_make_int_ico_op(ModuleName, Op, X, IntConst, Y, GoalExpr, OrigGoalInfo, !Info) :- - simplify_make_int_const(IntConst, ConstVar, ConstGoal, !Info), + Context = goal_info_get_context(OrigGoalInfo), + simplify_make_int_const(Context, IntConst, ConstVar, ConstGoal, !Info), simplify_make_binary_op_goal_expr(!.Info, ModuleName, Op, inline_builtin, X, ConstVar, Y, OpGoalExpr), % set_of_var.list_to_set([X, Y, ConstVar], NonLocals), @@ -1326,27 +1327,30 @@ simplify_make_cmp_goal_expr(Info, ModuleSymName, Op, IsBuiltin, X, Y, detism_semi, purity_pure, Context, GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). -:- pred simplify_make_int_const(int::in, prog_var::out, hlds_goal::out, - simplify_info::in, simplify_info::out) is det. - -simplify_make_int_const(IntConst, ConstVar, Goal, !Info) :- - ConstConsId = some_int_const(int_const(IntConst)), - simplify_make_const(int_type, ConstConsId, ConstVar, Goal, !Info). - -:- pred simplify_make_string_const(string::in, prog_var::out, hlds_goal::out, - simplify_info::in, simplify_info::out) is det. - -simplify_make_string_const(StringConst, ConstVar, Goal, !Info) :- - ConstConsId = string_const(StringConst), - simplify_make_const(string_type, ConstConsId, ConstVar, Goal, !Info). - -%---------------------% - -:- pred simplify_make_const(mer_type::in, cons_id::in, +:- pred simplify_make_int_const(prog_context::in, int::in, prog_var::out, hlds_goal::out, simplify_info::in, simplify_info::out) is det. -simplify_make_const(Type, ConstConsId, ConstVar, Goal, !Info) :- +simplify_make_int_const(Context, IntConst, ConstVar, Goal, !Info) :- + ConstConsId = some_int_const(int_const(IntConst)), + simplify_make_const(Context, int_type, ConstConsId, ConstVar, Goal, !Info). + +:- pred simplify_make_string_const(prog_context::in, string::in, + prog_var::out, hlds_goal::out, + simplify_info::in, simplify_info::out) is det. + +simplify_make_string_const(Context, StringConst, ConstVar, Goal, !Info) :- + ConstConsId = string_const(StringConst), + simplify_make_const(Context, string_type, ConstConsId, ConstVar, Goal, + !Info). + +%---------------------% + +:- pred simplify_make_const(prog_context::in, mer_type::in, cons_id::in, + prog_var::out, hlds_goal::out, + simplify_info::in, simplify_info::out) is det. + +simplify_make_const(Context, Type, ConstConsId, ConstVar, Goal, !Info) :- simplify_make_var(Type, ConstVar, !Info), Unification = construct(ConstVar, ConstConsId, [], [], construct_dynamically, cell_is_shared, no_construct_sub_info), @@ -1358,7 +1362,8 @@ simplify_make_const(Type, ConstConsId, ConstVar, Goal, !Info) :- GoalExpr = unify(ConstVar, RHS, UnifyMode, Unification, UnifyContext), NonLocals = set_of_var.make_singleton(ConstVar), InstMapDelta = instmap_delta_bind_var(ConstVar), - goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, GoalInfo), + goal_info_init(NonLocals, InstMapDelta, detism_det, purity_pure, Context, + GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). :- pred simplify_make_var(mer_type::in, prog_var::out, @@ -1509,8 +1514,8 @@ simplify_improve_arith_shift_cmp_ops(IntType, InstMap0, ModuleName, PredName, % ) Context = goal_info_get_context(GoalInfo), - simplify_make_int_const(NumTargetBits, NumTargetBitsConstVar, - NumTargetBitsConstGoal, !Info), + simplify_make_int_const(Context, NumTargetBits, + NumTargetBitsConstVar, NumTargetBitsConstGoal, !Info), PrivateBuiltin = mercury_private_builtin_module, % XXX This assumes that unsigned_lt works when Y is uint, % as well as when it is int. If this assumption is wrong, @@ -1531,7 +1536,7 @@ simplify_improve_arith_shift_cmp_ops(IntType, InstMap0, ModuleName, PredName, string.format("%s.(%s): second operand is out of range", [s(ModuleName), s(PredName)], NotInRangeStr), - simplify_make_string_const(NotInRangeStr, ErrorMsgStrVar, + simplify_make_string_const(Context, NotInRangeStr, ErrorMsgStrVar, ErrorMsgStrGoal, !Info), % XXX ExceptionType should be the type of math_domain_error. ExceptionType = void_type, @@ -1543,8 +1548,9 @@ simplify_improve_arith_shift_cmp_ops(IntType, InstMap0, ModuleName, PredName, du_ctor(ExceptionWrapperCtorSymName, 1, ExceptionTypeCtor), ExceptionWrapperCtorConsId = du_data_ctor(ExceptionWrapperCtorUDC), - construct_functor(ExceptionVar, ExceptionWrapperCtorConsId, - [ErrorMsgStrVar], WrapErrorMsgGoal), + construct_functor(Context, ExceptionVar, + ExceptionWrapperCtorConsId, [ErrorMsgStrVar], + WrapErrorMsgGoal), generate_plain_call(ModuleInfo, pf_predicate, mercury_exception_module, "throw", [], [ExceptionVar], instmap_delta_bind_no_var, only_mode, diff --git a/compiler/simplify_goal_conj.m b/compiler/simplify_goal_conj.m index 45ccb5c4f..cfe89547f 100644 --- a/compiler/simplify_goal_conj.m +++ b/compiler/simplify_goal_conj.m @@ -88,7 +88,7 @@ simplify_goal_plain_conj(Goals0, GoalExpr, GoalInfo0, GoalInfo, ( Goals = [], Context = goal_info_get_context(GoalInfo0), - hlds_goal(GoalExpr, GoalInfo) = true_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = true_goal(Context) ; Goals = [SingleGoal], % A singleton conjunction is equivalent to the goal itself. @@ -370,7 +370,7 @@ delete_tail_unreachable_goals(!.PrevGoals, HeadGoalContext0, HeadGoal1, % result if mode analysis is rerun, since according to the language % specification, mode analysis does not use inferred determinism % information when deciding what can never succeed. - FailGoal = fail_goal_with_context(HeadGoalContext0), + FailGoal = fail_goal(HeadGoalContext0), cord.snoc(FailGoal, !PrevGoals) ), Goals = cord.list(!.PrevGoals). @@ -499,7 +499,7 @@ all_cases_construct_test_var([Case | Cases], TestVar, TestConsId, CaseArgs = [] then Context = goal_info_get_context(GoalInfo), - TrueGoal = true_goal_with_context(Context), + TrueGoal = true_goal(Context), TruncatedCase = case(MainConsId, OtherConsIds, TrueGoal), !:RevTruncatedSameCases = [TruncatedCase | !.RevTruncatedSameCases] else @@ -1073,7 +1073,7 @@ simplify_goal_parallel_conj(Goals0, GoalExpr, GoalInfo0, GoalInfo, ( Goals0 = [], Context = goal_info_get_context(GoalInfo0), - hlds_goal(GoalExpr, GoalInfo) = true_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = true_goal(Context) ; Goals0 = [SingleGoal0], simplify_goal(SingleGoal0, hlds_goal(SingleGoal, SingleGoalInfo), diff --git a/compiler/simplify_goal_disj.m b/compiler/simplify_goal_disj.m index 53c9a30ca..f798f4575 100644 --- a/compiler/simplify_goal_disj.m +++ b/compiler/simplify_goal_disj.m @@ -86,7 +86,7 @@ simplify_goal_disj(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, ( Disjuncts = [], Context = goal_info_get_context(GoalInfo0), - hlds_goal(GoalExpr, GoalInfo) = fail_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = fail_goal(Context) ; Disjuncts = [SingleGoal], % A singleton disjunction is equivalent to the goal itself. @@ -431,7 +431,8 @@ det_disj_to_ite([Disjunct | Disjuncts], GoalInfo, Goal) :- Cond = Disjunct, Cond = hlds_goal(_CondGoal, CondGoalInfo), - Then = true_goal, + ThenContext = goal_info_get_context(CondGoalInfo), + Then = true_goal(ThenContext), det_disj_to_ite(Disjuncts, GoalInfo, Rest), Rest = hlds_goal(_RestGoal, RestGoalInfo), diff --git a/compiler/simplify_goal_ite.m b/compiler/simplify_goal_ite.m index 838092770..1e95d8ea7 100644 --- a/compiler/simplify_goal_ite.m +++ b/compiler/simplify_goal_ite.m @@ -512,12 +512,12 @@ simplify_goal_neg(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, % Replace `not true' with `fail'. SubGoal1 = hlds_goal(conj(plain_conj, []), _) then - hlds_goal(GoalExpr, GoalInfo) = fail_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = fail_goal(Context) else if % Replace `not fail' with `true'. SubGoal1 = hlds_goal(disj([]), _) then - hlds_goal(GoalExpr, GoalInfo) = true_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = true_goal(Context) else if % Remove double negation. SubGoal1 = diff --git a/compiler/simplify_goal_scope.m b/compiler/simplify_goal_scope.m index 00f0b0a66..8698ec385 100644 --- a/compiler/simplify_goal_scope.m +++ b/compiler/simplify_goal_scope.m @@ -355,7 +355,7 @@ simplify_goal_trace_goal(MaybeCompiletimeExpr, MaybeRuntimeExpr, SubGoal, KeepGoal = no, Goal0 = hlds_goal(_GoalExpr0, GoalInfo0), Context = goal_info_get_context(GoalInfo0), - Goal = true_goal_with_context(Context), + Goal = true_goal(Context), simplify_info_get_deleted_call_callees(!.Info, DeletedCallCallees0), SubGoalCalledProcs = goal_proc_refs(SubGoal), @@ -425,7 +425,7 @@ simplify_goal_trace_goal(MaybeCompiletimeExpr, MaybeRuntimeExpr, SubGoal, [], [], [], instmap_delta_bind_no_var, only_mode, detism_semi, purity_semipure, EvalFeatures, EvalAttributes, yes(RuntimeExpr), EvalCode, Context, CondGoal), - GoalExpr = if_then_else([], CondGoal, SubGoal, true_goal), + GoalExpr = if_then_else([], CondGoal, SubGoal, true_goal(Context)), Goal = hlds_goal(GoalExpr, GoalInfo0) ) ). diff --git a/compiler/simplify_goal_switch.m b/compiler/simplify_goal_switch.m index 4f4a148ec..c82845379 100644 --- a/compiler/simplify_goal_switch.m +++ b/compiler/simplify_goal_switch.m @@ -96,7 +96,7 @@ simplify_goal_switch(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, % An empty switch always fails. simplify_info_incr_cost_delta(cost_of_eliminate_switch, !Info), Context = goal_info_get_context(GoalInfo0), - hlds_goal(GoalExpr, GoalInfo) = fail_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = fail_goal(Context) ; Cases = [Case], Case = case(MainConsId, OtherConsIds, SingleGoal), @@ -127,8 +127,10 @@ simplify_goal_switch(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, simplify_info_set_module_info(ModuleInfo2, !Info), goal_info_set_instmap_delta(NewDelta, GoalInfo0, GoalInfo) else - create_test_unification(Var, MainConsId, MainConsIdArity, - UnifyGoal, InstMap0, !Info), + Context = goal_info_get_context(GoalInfo0), + create_test_unification(Context, Var, + MainConsId, MainConsIdArity, UnifyGoal, + InstMap0, !Info), % Conjoin the test and the rest of the case. goal_to_conj_list(SingleGoal, SingleGoalConj), @@ -147,7 +149,7 @@ simplify_goal_switch(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, det_conjunction_detism(detism_semi, CaseDetism, Detism), goal_list_purity(GoalList, Purity), goal_info_init(NonLocals, InstMapDelta, Detism, Purity, - CombinedGoalInfo), + Context, CombinedGoalInfo), simplify_info_set_rerun_quant_instmap_delta(!Info), GoalExpr = conj(plain_conj, GoalList), @@ -326,10 +328,12 @@ simplify_switch_cases(Var, [Case0 | Cases0], NestedContext0, InstMap0, Common0, % in a can_fail switch. % This will abort if the cons_id is existentially typed. % -:- pred create_test_unification(prog_var::in, cons_id::in, int::in, - hlds_goal::out, instmap::in, simplify_info::in, simplify_info::out) is det. +:- pred create_test_unification(prog_context::in, prog_var::in, + cons_id::in, int::in, hlds_goal::out, instmap::in, + simplify_info::in, simplify_info::out) is det. -create_test_unification(Var, ConsId, ConsArity, ExtraGoal, InstMap0, !Info) :- +create_test_unification(Context, Var, ConsId, ConsArity, ExtraGoal, + InstMap0, !Info) :- simplify_info_get_var_table(!.Info, VarTable0), simplify_info_get_module_info(!.Info, ModuleInfo), lookup_var_type(VarTable0, Var, VarType), @@ -357,7 +361,7 @@ create_test_unification(Var, ConsId, ConsArity, ExtraGoal, InstMap0, !Info) :- % The test can't bind any variables, so the InstMapDelta should be empty. instmap_delta_init_reachable(InstMapDelta), goal_info_init(NonLocals, InstMapDelta, detism_semi, purity_pure, - ExtraGoalInfo), + Context, ExtraGoalInfo), ExtraGoal = hlds_goal(ExtraGoalExpr, ExtraGoalInfo). %---------------------------------------------------------------------------% diff --git a/compiler/simplify_goal_unify.m b/compiler/simplify_goal_unify.m index 35a72326f..0c1c7e6cb 100644 --- a/compiler/simplify_goal_unify.m +++ b/compiler/simplify_goal_unify.m @@ -125,7 +125,7 @@ simplify_goal_unify(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, RHSVar0 = LHSVar0 then Context = goal_info_get_context(GoalInfo0), - hlds_goal(GoalExpr, GoalInfo) = true_goal_with_context(Context) + hlds_goal(GoalExpr, GoalInfo) = true_goal(Context) else if Unification0 = complicated_unify(ComplMode, CanFail, TypeInfoVars) then @@ -220,10 +220,10 @@ simplify_goal_unify(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, Context = goal_info_get_context(GoalInfo0), ( ConsIdMatch = cons_id_must_match, - TrueOrFailGoal = true_goal_with_context(Context) + TrueOrFailGoal = true_goal(Context) ; ConsIdMatch = cons_id_cannot_match, - TrueOrFailGoal = fail_goal_with_context(Context) + TrueOrFailGoal = fail_goal(Context) ), TrueOrFailGoal = hlds_goal(GoalExpr, GoalInfo), simplify_info_set_rerun_quant_instmap_delta(!Info), @@ -273,7 +273,8 @@ process_complicated_unify(XVar, YVar, UnifyMode, CanFail, _OldTypeInfoVars, Call = hlds_goal(Call1, GoalInfo), ExtraGoals = [] else - type_to_ctor_and_args_det(Type, TypeCtor, TypeArgs), + Context = goal_info_get_context(GoalInfo0), + type_to_ctor_and_args_det(Type, TypeCtor, ArgTypes), determinism_components(Detism, CanFail, at_most_one), lookup_mode_num(ModuleInfo, TypeCtor, UnifyMode, Detism, ProcId), ( if @@ -284,7 +285,8 @@ process_complicated_unify(XVar, YVar, UnifyMode, CanFail, _OldTypeInfoVars, % specialize these cases if possible. special_pred_is_generated_lazily(ModuleInfo, TypeCtor) then - make_type_info_vars([Type], TypeInfoVars, ExtraGoals, !Info), + make_type_info_vars(Context, [Type], + TypeInfoVars, ExtraGoals, !Info), ( if TypeInfoVars = [TypeInfoVarPrime] then TypeInfoVar = TypeInfoVarPrime else @@ -296,7 +298,8 @@ process_complicated_unify(XVar, YVar, UnifyMode, CanFail, _OldTypeInfoVars, % Convert other complicated unifications into calls to % specific unification predicates, inserting extra typeinfo % arguments if necessary. - make_type_info_vars(TypeArgs, TypeInfoVars, ExtraGoals, !Info), + make_type_info_vars(Context, ArgTypes, + TypeInfoVars, ExtraGoals, !Info), call_specific_unify(TypeCtor, TypeInfoVars, XVar, YVar, ProcId, ModuleInfo, UnifyContext, GoalInfo0, Call0, CallGoalInfo0), simplify_goal_expr(Call0, Call1, CallGoalInfo0, CallGoalInfo1, @@ -364,10 +367,11 @@ no_cons_id_can_match(ConsId, ArgVars, [BoundFunctor | BoundFunctors]) :- %---------------------------------------------------------------------------% -:- pred make_type_info_vars(list(mer_type)::in, list(prog_var)::out, - list(hlds_goal)::out, simplify_info::in, simplify_info::out) is det. +:- pred make_type_info_vars(prog_context::in, list(mer_type)::in, + list(prog_var)::out, list(hlds_goal)::out, + simplify_info::in, simplify_info::out) is det. -make_type_info_vars(Types, TypeInfoVars, TypeInfoGoals, !Info) :- +make_type_info_vars(Context, Types, TypeInfoVars, TypeInfoGoals, !Info) :- % Extract the information from simplify_info. simplify_info_get_var_table(!.Info, VarTable0), simplify_info_get_rtti_varmaps(!.Info, RttiVarMaps0), @@ -384,7 +388,7 @@ make_type_info_vars(Types, TypeInfoVars, TypeInfoGoals, !Info) :- proc_info_set_rtti_varmaps(RttiVarMaps0, !ProcInfo), % Generate the code that creates the type_infos. - polymorphism_make_type_info_vars_mi(Types, dummy_context, + polymorphism_make_type_info_vars_mi(Context, Types, TypeInfoVars, TypeInfoGoals, ModuleInfo0, ModuleInfo1, !PredInfo, !ProcInfo), diff --git a/compiler/size_prof.m b/compiler/size_prof.m index 3367d8590..ac336e108 100644 --- a/compiler/size_prof.m +++ b/compiler/size_prof.m @@ -877,8 +877,8 @@ make_type_info(Context, Type, TypeInfoVar, TypeInfoGoals, !Info) :- else if type_to_ctor_and_args(Type, TypeCtor, ArgTypes) then ( ArgTypes = [], - make_type_ctor_info(TypeCtor, [], TypeCtorVar, TypeCtorGoals, - !Info), + make_type_ctor_info(Context, TypeCtor, [], + TypeCtorVar, TypeCtorGoals, !Info), TypeInfoVar = TypeCtorVar, TypeInfoGoals = TypeCtorGoals ; @@ -937,7 +937,8 @@ construct_type_info(Context, Type, TypeCtor, ArgTypes, CtorIsVarArity, list.map2_foldl(make_type_info(Context), ArgTypes, ArgTypeInfoVars, ArgTypeInfoGoalLists, !Info), ArgTypeInfoGoals = list.condense(ArgTypeInfoGoalLists), - make_type_ctor_info(TypeCtor, ArgTypes, TypeCtorVar, TypeCtorGoals, !Info), + make_type_ctor_info(Context, TypeCtor, ArgTypes, + TypeCtorVar, TypeCtorGoals, !Info), ( CtorIsVarArity = yes, list.length(ArgTypes, Arity), @@ -963,7 +964,7 @@ construct_type_info(Context, Type, TypeCtor, ArgTypes, CtorIsVarArity, new_type_info_var_vt(Type, type_info, TypeInfoVar, VarTable2, VarTable, RttiVarMaps2, RttiVarMaps3) ), - init_type_info_var(Type, ArgVars, TypeInfoVar, TypeInfoGoal, + init_type_info_var(Context, Type, ArgVars, TypeInfoVar, TypeInfoGoal, RttiVarMaps3, RttiVarMaps), !Info ^ spi_var_table := VarTable, @@ -975,10 +976,12 @@ construct_type_info(Context, Type, TypeCtor, ArgTypes, CtorIsVarArity, % type_ctor_info. Return the variable holding the type_ctor_info in % TypeCtorVar, and the goals needed to create it in TypeCtorGoals. % -:- pred make_type_ctor_info(type_ctor::in, list(mer_type)::in, prog_var::out, - list(hlds_goal)::out, size_prof_info::in, size_prof_info::out) is det. +:- pred make_type_ctor_info(prog_context::in, + type_ctor::in, list(mer_type)::in, prog_var::out, list(hlds_goal)::out, + size_prof_info::in, size_prof_info::out) is det. -make_type_ctor_info(TypeCtor, TypeArgs, TypeCtorVar, TypeCtorGoals, !Info) :- +make_type_ctor_info(Context, TypeCtor, TypeArgs, TypeCtorVar, TypeCtorGoals, + !Info) :- ( if map.search(!.Info ^ spi_type_ctor_map, TypeCtor, TypeCtorVarPrime) then @@ -992,8 +995,9 @@ make_type_ctor_info(TypeCtor, TypeArgs, TypeCtorVar, TypeCtorGoals, !Info) :- ), VarTable0 = !.Info ^ spi_var_table, RttiVarMaps0 = !.Info ^ spi_rtti_varmaps, - init_const_type_ctor_info_var(Type, TypeCtor, TypeCtorVar, _ConsId, - TypeCtorGoal, VarTable0, VarTable, RttiVarMaps0, RttiVarMaps), + init_const_type_ctor_info_var(Context, Type, TypeCtor, TypeCtorVar, + _ConsId, TypeCtorGoal, VarTable0, VarTable, + RttiVarMaps0, RttiVarMaps), TypeCtorGoals = [TypeCtorGoal], !Info ^ spi_var_table := VarTable, !Info ^ spi_rtti_varmaps := RttiVarMaps diff --git a/compiler/ssdebug.m b/compiler/ssdebug.m index 821c90bcc..b3f94dc3c 100644 --- a/compiler/ssdebug.m +++ b/compiler/ssdebug.m @@ -791,7 +791,8 @@ ssdebug_process_proc_semi(SSTraceLevel, PredId, ProcId, ThenGoal = hlds_goal(conj(plain_conj, GoalsThen), ImpureGoalInfo), % Create the `else' branch. - make_switch_goal(RetryBVar, RecursiveGoal, fail_goal, + proc_info_get_context(!.ProcInfo, Context), + make_switch_goal(RetryBVar, RecursiveGoal, fail_goal(Context), SwitchFailPortGoal), GoalsElse = list.condense([ FailArgListGoals, @@ -825,6 +826,7 @@ ssdebug_process_proc_semi(SSTraceLevel, PredId, ProcId, ssdebug_process_proc_nondet(SSTraceLevel, PredId, ProcId, !ProcInfo, !ModuleInfo) :- some [!PredInfo, !VarTable] ( + % XXX Our caller should give us the initial PredInfo. module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo), proc_info_get_goal(!.ProcInfo, OrigBodyGoal), proc_info_get_var_table(!.ProcInfo, !:VarTable), @@ -867,8 +869,9 @@ ssdebug_process_proc_nondet(SSTraceLevel, PredId, ProcId, make_handle_event(!.ModuleInfo, "handle_event_redo_nondet", [ProcIdVar, ExitArgListVar], HandleEventRedoGoal), + proc_info_get_context(!.ProcInfo, ProcContext), RedoDisjunct = hlds_goal(conj(plain_conj, - [HandleEventRedoGoal, fail_goal]), + [HandleEventRedoGoal, fail_goal(ProcContext)]), impure_backtrack_goal_info(detism_failure)), ExitOrRedoGoal = hlds_goal(disj([ExitDisjunct, RedoDisjunct]), @@ -893,7 +896,7 @@ ssdebug_process_proc_nondet(SSTraceLevel, PredId, ProcId, [ProcIdVar, FailArgListVar, RetryVar], HandleEventFailGoal), make_recursive_call(!.PredInfo, !.ModuleInfo, PredId, ProcId, FullHeadVars, RecursiveGoal), - make_switch_goal(RetryVar, RecursiveGoal, fail_goal, + make_switch_goal(RetryVar, RecursiveGoal, fail_goal(ProcContext), SwitchFailPortGoal), FailDisjunctGoals = list.condense([ FailArgListGoals, @@ -907,6 +910,8 @@ ssdebug_process_proc_nondet(SSTraceLevel, PredId, ProcId, BodyDisj = hlds_goal(disj([CallExitRedoDisjunct, FailDisjunct]), impure_goal_info(ProcDetism)), BodyGoals = ProcIdGoals ++ [BodyDisj], + % XXX Returning !.ProcInfo *both* in !:ModuleInfo and as an + % argument is dangerous. commit_goal_changes(BodyGoals, PredId, ProcId, !.PredInfo, !.VarTable, !ProcInfo, !ModuleInfo) ). @@ -956,7 +961,9 @@ ssdebug_process_proc_failure(SSTraceLevel, PredId, ProcId, FullHeadVars, RecursiveGoal), % Create the switch on Retry at fail port. - make_switch_goal(RetryVar, RecursiveGoal, fail_goal, SwitchGoal), + proc_info_get_context(!.ProcInfo, ProcContext), + make_switch_goal(RetryVar, RecursiveGoal, fail_goal(ProcContext), + SwitchGoal), % Put it all together. proc_info_interface_determinism(!.ProcInfo, ProcDetism), @@ -1051,11 +1058,12 @@ get_output_args(ModuleInfo, HeadVars, ArgModes, OutputVars) :- var_table::in, var_table::out) is det. rename_outputs(OutputVars, !Goal, UnifyGoal, Renaming, !VarTable) :- - GoalInfo0 = get_hlds_goal_info(!.Goal), + !.Goal = hlds_goal(_, GoalInfo0), InstMapDelta = goal_info_get_instmap_delta(GoalInfo0), create_renaming(OutputVars, InstMapDelta, !VarTable, UnifyGoals, _NewVars, Renaming), - goal_info_init(UnifyGoalInfo0), + Context = goal_info_get_context(GoalInfo0), + goal_info_init(Context, UnifyGoalInfo0), goal_info_set_determinism(detism_det, UnifyGoalInfo0, UnifyGoalInfo), conj_list_to_goal(UnifyGoals, UnifyGoalInfo, UnifyGoal), rename_some_vars_in_goal(Renaming, !Goal). @@ -1142,7 +1150,7 @@ make_switch_goal(SwitchVar, DoRetryGoal, DoNotRetryGoal, SwitchGoal) :- det_switch_detism(RetryDetism, NoRetryDetism, SwitchDetism), - goal_info_init(GoalInfo0), + goal_info_init(dummy_context, GoalInfo0), goal_info_set_determinism(SwitchDetism, GoalInfo0, GoalInfo1), goal_info_set_purity(purity_impure, GoalInfo1, GoalInfo), @@ -1180,7 +1188,7 @@ commit_goal_changes(ConjGoals, PredId, ProcId, !.PredInfo, VarTable, :- func impure_goal_info(determinism) = hlds_goal_info. impure_goal_info(Detism) = GoalInfo :- - goal_info_init(GoalInfo0), + goal_info_init(dummy_context, GoalInfo0), goal_info_set_purity(purity_impure, GoalInfo0, GoalInfo1), goal_info_set_determinism(Detism, GoalInfo1, GoalInfo). @@ -1246,8 +1254,8 @@ make_proc_id_construction(ModuleInfo, PredInfo, Goals, ProcIdVar, !VarTable) :- construct_type(TypeCtor, [], ProcIdType), ProcIdVarEntry = vte("ProcId", ProcIdType, is_not_dummy_type), add_var_entry(ProcIdVarEntry, ProcIdVar, !VarTable), - construct_functor(ProcIdVar, ConsId, [ModuleNameVar, PredNameVar], - ConstructProcIdGoal), + construct_functor(dummy_context, ProcIdVar, ConsId, + [ModuleNameVar, PredNameVar], ConstructProcIdGoal), Goals = [ConstructModuleName, ConstructPredName, ConstructProcIdGoal]. @@ -1323,7 +1331,7 @@ make_arg_list(_Pos, _InstMap, [], _Renaming, OutVar, [Goal], !ModuleInfo, ListTypeCtor = type_ctor(ListTypeSymName, 1), ConsId = du_data_ctor(du_ctor(qualified(mercury_list_module, "[]" ), 0, ListTypeCtor)), - construct_functor(OutVar, ConsId, [], Goal). + construct_functor(dummy_context, OutVar, ConsId, [], Goal). make_arg_list(Pos0, InstMap, [ProgVar | ProgVars], Renaming, OutVar, Goals, !ModuleInfo, !ProcInfo, !PredInfo, !VarTable, !BoundVarDescs) :- Pos = Pos0 + 1, @@ -1360,7 +1368,8 @@ make_arg_list(Pos0, InstMap, [ProgVar | ProgVars], Renaming, OutVar, Goals, ListTypeCtor = type_ctor(ListTypeSymName, 1), ConsId = du_data_ctor(du_ctor(qualified(unqualified("list"), "[|]" ), 2, ListTypeCtor)), - construct_functor(OutVar, ConsId, [VarDesc, OutVar0], Goal), + construct_functor(dummy_context, OutVar, ConsId, [VarDesc, OutVar0], + Goal), %XXX Optimize me: repeated appends are slow. Goals = Goals0 ++ ValueGoals ++ [Goal] @@ -1401,6 +1410,7 @@ make_var_value(InstMap, VarToInspect, Renaming, VarDesc, VarPos, Goals, VarValueTypeIsDummy = is_type_a_dummy(!.ModuleInfo, VarValueType), VarDescEntry = vte("VarDesc", VarValueType, VarValueTypeIsDummy), add_var_entry(VarDescEntry, VarDesc, !VarTable), + Context = dummy_context, ( if var_is_ground_in_instmap(!.ModuleInfo, !.VarTable, InstMap, VarToInspect) @@ -1419,9 +1429,8 @@ make_var_value(InstMap, VarToInspect, Renaming, VarDesc, VarPos, Goals, % some[T] bound_head_var(string, int, T) ----> % some[T] bound_head_var(type_of_T, string, int, T) - Context = dummy_context, lookup_var_type(!.VarTable, VarToInspect, MerType), - polymorphism_make_type_info_var_mi(MerType, Context, + polymorphism_make_type_info_var_mi(Context, MerType, TypeInfoVar, TypeInfoGoals0, !ModuleInfo, !PredInfo, !ProcInfo), proc_info_get_var_table(!.ProcInfo, !:VarTable), @@ -1433,12 +1442,12 @@ make_var_value(InstMap, VarToInspect, Renaming, VarDesc, VarPos, Goals, % Renaming contains the names of all instantiated arguments % during the execution of the procedure's body. ( if map.is_empty(Renaming) then - construct_functor(VarDesc, ConsId, + construct_functor(Context, VarDesc, ConsId, [TypeInfoVar, VarNameVar, VarPosVar, VarToInspect], ConstructVarGoal) else map.lookup(Renaming, VarToInspect, RenamedVar), - construct_functor(VarDesc, ConsId, + construct_functor(Context, VarDesc, ConsId, [TypeInfoVar, VarNameVar, VarPosVar, RenamedVar], ConstructVarGoal) ), @@ -1457,7 +1466,7 @@ make_var_value(InstMap, VarToInspect, Renaming, VarDesc, VarPos, Goals, ConsId = du_data_ctor(du_ctor( qualified(SSDBModule, "unbound_head_var"), 2, VarValueTypeCtor)), - construct_functor(VarDesc, ConsId, [VarNameVar, VarPosVar], + construct_functor(Context, VarDesc, ConsId, [VarNameVar, VarPosVar], ConstructVarGoal), Goals = [ConstructVarName, ConstructVarPos, ConstructVarGoal] diff --git a/compiler/stm_expand.m b/compiler/stm_expand.m index db56f18c6..10c63ee10 100644 --- a/compiler/stm_expand.m +++ b/compiler/stm_expand.m @@ -1150,7 +1150,7 @@ create_test_on_exception(Context, ExceptVar, StmVar, ReturnType, RecCall, Goal, !NewPredInfo) :- create_aux_variable(univ_type, yes("ExceptUnivVar"), ExceptUnivVar, !NewPredInfo), - deconstruct_functor(ExceptVar, exception_exception_functor, + deconstruct_functor(Context, ExceptVar, exception_exception_functor, [ExceptUnivVar], DeconstructException), make_type_info(stm_rollback_exception_type, TypeInfoRollbackVar, TypeInfoRollbackAssign, !NewPredInfo), @@ -1690,7 +1690,7 @@ create_or_else_pred(Context, AtomicGoalVars, BranchGoalVars, Closures, create_cloned_pred(InputVars ++ OutputVars ++ [StmDI, StmUO], InputTypes ++ OutputTypes ++ [stm_state_type, stm_state_type], InputModes ++ OutputModes ++ [di_mode, uo_mode], stmck_or_else, - true_goal, MaybeDetism, NewPredInfo0, CallGoal, !StmInfo), + true_goal(Context), MaybeDetism, NewPredInfo0, CallGoal, !StmInfo), create_aux_variable(stm_state_type, yes("STMDI"), NewStmDI, NewPredInfo0, NewPredInfo1), @@ -2000,7 +2000,7 @@ create_or_else_branch(Context, AtomicGoalVars, ReturnType, OuterStmDIVar, % Code to extract the exception result. create_aux_variable(univ_type, yes("ExceptUnivVar"), ExceptUnivVar, !NewPredInfo), - deconstruct_functor(ReturnExceptVar, exception_exception_functor, + deconstruct_functor(Context, ReturnExceptVar, exception_exception_functor, [ExceptUnivVar], DeconstructException), create_plain_conj([DiscardCall, RethrowCall], NotRetryBranch), @@ -2053,6 +2053,7 @@ deconstruct_output(AtomicGoalVars, ReturnType, ReturnExceptVar, Goal, StmInfo, !NewPredInfo) :- get_input_output_varlist(AtomicGoalVars, _, OutputVars), get_input_output_types(AtomicGoalVars, StmInfo, _, OutputTypes), + Context = dummy_context, ( OutputTypes = [], @@ -2061,24 +2062,25 @@ deconstruct_output(AtomicGoalVars, ReturnType, ReturnExceptVar, % causing an exception in a later stage. create_aux_variable(ReturnType, yes("BoringResult"), SuccessResultVar, !NewPredInfo), - deconstruct_functor(ReturnExceptVar, exception_succeeded_functor, - [SuccessResultVar], Goal) + deconstruct_functor(Context, ReturnExceptVar, + exception_succeeded_functor, [SuccessResultVar], Goal) ; OutputTypes = [_], % Wrapper returns a single value -- Simply get the value from the % exception result and return. OutVar = list.det_head(OutputVars), - deconstruct_functor(ReturnExceptVar, exception_succeeded_functor, - [OutVar], Goal) + deconstruct_functor(Context, ReturnExceptVar, + exception_succeeded_functor, [OutVar], Goal) ; OutputTypes = [_, _ | _], % Wrapper returns a tuple. Get the tuple result and return it. make_type_info(ReturnType, _, MakeType, !NewPredInfo), create_aux_variable(ReturnType, yes("SuccessResult"), SuccessResultVar, !NewPredInfo), - deconstruct_functor(ReturnExceptVar, exception_succeeded_functor, - [SuccessResultVar], DeconstructGoal), - deconstruct_tuple(SuccessResultVar, OutputVars, UnifyOutputGoal), + deconstruct_functor(Context, ReturnExceptVar, + exception_succeeded_functor, [SuccessResultVar], DeconstructGoal), + deconstruct_tuple(Context, SuccessResultVar, OutputVars, + UnifyOutputGoal), create_plain_conj([DeconstructGoal, UnifyOutputGoal | MakeType], Goal) @@ -2118,7 +2120,7 @@ construct_output(Context, AtomicGoalVars, ResultType, ResultVar, StmInfo, OutputTypes = [_, _ | _], % Wrapper returns a tuple. Creates a tuple from the output values. make_type_info(ResultType, _, MakeType, !NewPredInfo), - construct_tuple(ResultVar, OutputVars, Goal), + construct_tuple(Context, ResultVar, OutputVars, Goal), Goals = [Goal | MakeType] ). @@ -2335,7 +2337,8 @@ create_closure(PredProcID, Args, ArgTypes, ArgModes, ClosureVar, construct_higher_order_pred_type(purity_pure, ArgTypes, ClosureType), ClosureCons = closure_cons(ShroudPredProcID), create_aux_variable(ClosureType, yes("Closure"), ClosureVar, !NewPredInfo), - construct_functor(ClosureVar, ClosureCons, Args, ClosureAssignGoal0), + construct_functor(dummy_context, ClosureVar, ClosureCons, Args, + ClosureAssignGoal0), ClosureAssignInstmapDeltaList = assoc_list.from_corresponding_lists( [ClosureVar], [ground(shared, higher_order(pred_inst_info( @@ -2422,7 +2425,7 @@ create_plain_conj(GoalsInConj, ConjGoal) :- make_type_info(Type, TypeInfoVar, Goals, NewPredInfo0, NewPredInfo) :- NewPredInfo0 = stm_new_pred_info(ModuleInfo0, PredId, ProcId, PredInfo0, ProcInfo0, Context, VarCnt), - polymorphism_make_type_info_var_mi(Type, Context, TypeInfoVar, Goals, + polymorphism_make_type_info_var_mi(Context, Type, TypeInfoVar, Goals, ModuleInfo0, ModuleInfo, PredInfo0, PredInfo, ProcInfo0, ProcInfo), NewPredInfo = stm_new_pred_info(ModuleInfo, PredId, ProcId, PredInfo, ProcInfo, Context, VarCnt). diff --git a/compiler/superhomogeneous.m b/compiler/superhomogeneous.m index 6bfbe69cf..434561b6b 100644 --- a/compiler/superhomogeneous.m +++ b/compiler/superhomogeneous.m @@ -843,8 +843,7 @@ unravel_special_if_then_else(XVar, CondTerm0, ThenTerm0, ElseTerm0, MaybeVarsCond = error4({OoMVarsCondErrSpecs, VarsConsWarnSpecs}), add_unravel_oom_errs(OoMVarsCondErrSpecs, !UrInfo), add_unravel_warns(VarsConsWarnSpecs, !UrInfo), - Expansion = expansion(not_fgti, - cord.singleton(true_goal_with_context(Context))) + Expansion = expansion(not_fgti, cord.singleton(true_goal(Context))) ). :- pred unravel_special_field_get(prog_var::in, prog_term::in, prog_term::in, diff --git a/compiler/superhomogeneous_lambda.m b/compiler/superhomogeneous_lambda.m index 2d059e620..b5936544c 100644 --- a/compiler/superhomogeneous_lambda.m +++ b/compiler/superhomogeneous_lambda.m @@ -765,7 +765,7 @@ build_lambda_expression(LHSVar, UnificationPurity, ArgSpecs = [_ | _], add_unravel_errs(ArgSpecs, !UrInfo), record_unravel_found_syntax_error(!UrInfo), - Goal = true_goal_with_context(Context) + Goal = true_goal(Context) ; ArgSpecs = [], some [!SVarState] ( @@ -793,7 +793,7 @@ build_lambda_expression(LHSVar, UnificationPurity, % Create the unifications that need to come before the body of the % lambda expression; those corresponding to args whose mode is % input or unused. - HeadBefore0 = true_goal_with_context(Context), + HeadBefore0 = true_goal(Context), insert_arg_unifications(NonOutputLambdaVarsArgs, Context, ArgContext, HeadBefore0, HeadBefore, !SVarState, !UrInfo), @@ -805,7 +805,7 @@ build_lambda_expression(LHSVar, UnificationPurity, % Create the unifications that need to come after the body of the % lambda expression; those corresponding to args whose mode is % output. - HeadAfter0 = true_goal_with_context(Context), + HeadAfter0 = true_goal(Context), insert_arg_unifications(OutputLambdaVarsArgs, Context, ArgContext, HeadAfter0, HeadAfter, !SVarState, !UrInfo), diff --git a/compiler/table_gen.m b/compiler/table_gen.m index eb92e3a35..f215d54d3 100644 --- a/compiler/table_gen.m +++ b/compiler/table_gen.m @@ -1018,7 +1018,7 @@ create_new_memo_goal(Detism, OrigGoal, Statistics, _MaybeSizeLimit, goal_info_init_hide(InactiveNonLocals, InactiveInstmapDelta, Detism, purity_impure, Context, InactiveGoalInfo), InactiveGoal = hlds_goal(InactiveGoalExpr, InactiveGoalInfo), - FailedGoal = fail_goal, + FailedGoal = fail_goal(Context), SwitchArms = [ case(memo_semi_active_cons_id, [], ActiveGoal), @@ -1332,7 +1332,7 @@ create_new_io_goal(OrigGoal, TableIoEntryKind, Unitize, TableIoStates, MaybeProcTableIOInfo = yes(ProcTableIOInfo) ; TableIoEntryKind = entry_stores_outputs, - TableIoEntryDescGoal = true_goal, + TableIoEntryDescGoal = true_goal(Context), NumberedRestoreVars = list.map(project_out_arg_method, SavedOutputVars), NumberedSaveVars = NumberedRestoreVars, @@ -2987,7 +2987,7 @@ generate_memo_restore_goal(NumberedOutputVars, OrigInstMapDelta, TipVar, Goal = ShortcutGoal ; NumberedOutputVars = [], - Goal = true_goal + Goal = true_goal(Context) ). % Generate a goal for restoring the output arguments from @@ -3272,7 +3272,7 @@ append_fail(Goal, GoalAndThenFail) :- goal_info_init_hide(NonLocals, UnreachInstMapDelta, detism_failure, purity_impure, Context, ConjGoalInfo), GoalAndThenFail = - hlds_goal(conj(plain_conj, [Goal, fail_goal]), ConjGoalInfo). + hlds_goal(conj(plain_conj, [Goal, fail_goal(Context)]), ConjGoalInfo). %---------------------------------------------------------------------------% @@ -3791,7 +3791,7 @@ table_gen_make_type_info_vars(Types, Context, !VarTable, !TableInfo, proc_info_set_var_table(!.VarTable, ProcInfo0, ProcInfo1), % Generate the code that creates the type_infos. - polymorphism_make_type_info_vars_mi(Types, Context, + polymorphism_make_type_info_vars_mi(Context, Types, TypeInfoVars, TypeInfoGoals, ModuleInfo0, ModuleInfo, PredInfo0, PredInfo, ProcInfo1, ProcInfo), diff --git a/compiler/try_expand.m b/compiler/try_expand.m index 87bdc36c8..d9171d590 100644 --- a/compiler/try_expand.m +++ b/compiler/try_expand.m @@ -655,19 +655,20 @@ implement_try_goal(MaybeIO, ResultVar, Goal1, Then1, MaybeElse1, ExcpHandling1, ExcpHandling = ExcpHandling1 ), - goal_info_init(GoalInfo), + goal_info_init(GoalContext, GoalInfo), % The `succeeded' case. proc_info_create_var_from_type("TmpOutputTuple", OutputTupleType, is_not_dummy_type, TmpTupleVar, !ProcInfo), proc_info_create_var_from_type("OutputTuple", OutputTupleType, is_not_dummy_type, TupleVar, !ProcInfo), - deconstruct_functor(ResultVar, exception_succeeded_functor, [TmpTupleVar], - DeconstructSucceeded), + deconstruct_functor(GoalContext, ResultVar, exception_succeeded_functor, + [TmpTupleVar], DeconstructSucceeded), instmap_lookup_vars(InstMap0, GoalOutputVars, TupleArgInsts), make_output_tuple_inst_cast(TmpTupleVar, TupleVar, TupleArgInsts, CastOutputTuple), - deconstruct_tuple(TupleVar, GoalOutputVars, DeconstructOutputs), + deconstruct_tuple(GoalContext, TupleVar, GoalOutputVars, + DeconstructOutputs), conj_list_to_goal([DeconstructSucceeded, CastOutputTuple, DeconstructOutputs, Then], GoalInfo, DeconstructsThen), SucceededCase = case(exception_succeeded_functor, [], DeconstructsThen), @@ -886,8 +887,10 @@ make_try_lambda(Body0, OutputVarsSet, OutputTupleType, MaybeIO, is_not_dummy_type, LambdaVar, !ProcInfo), % Add the construction of OutputTuple to the body. - construct_tuple(OutputTupleVar, set_of_var.to_sorted_list(OutputVarsSet), - MakeOutputTuple), + Body0 = hlds_goal(_, BodyGoalInfo0), + Context = goal_info_get_context(BodyGoalInfo0), + construct_tuple(Context, OutputTupleVar, + set_of_var.to_sorted_list(OutputVarsSet), MakeOutputTuple), conjoin_goals(Body0, MakeOutputTuple, LambdaBody0), % Rename away output variables in the lambda body. @@ -936,7 +939,7 @@ detism_to_try_lambda_detism(detism_failure, detism_semi). make_try_call(PredName, LambdaVar, ResultVar, ExtraArgs, OutputTupleType, GoalPurity, Context, OverallGoal, !PredInfo, !ProcInfo, !ModuleInfo) :- - polymorphism_make_type_info_var_mi(OutputTupleType, Context, + polymorphism_make_type_info_var_mi(Context, OutputTupleType, TypeInfoVar, MakeTypeInfoGoals, !ModuleInfo, !PredInfo, !ProcInfo), % The mode will be fixed up by a later analysis. diff --git a/compiler/tupling.m b/compiler/tupling.m index 5073aa68c..b02c6d4ed 100644 --- a/compiler/tupling.m +++ b/compiler/tupling.m @@ -696,7 +696,8 @@ add_transformed_proc(PredProcId, tupling(_, FieldVars, _), % Build an insertion map of where the deconstruction % unifications are needed. - build_insert_map(CellVar, FieldVars, IntervalInfo, InsertMap), + proc_info_get_context(!.ProcInfo, Context), + build_insert_map(Context, CellVar, FieldVars, IntervalInfo, InsertMap), % Make a transformed version of the procedure and add it to % the module. @@ -747,8 +748,9 @@ make_transformed_proc(InsertMap, CellVar, FieldVarsList, !ProcInfo) :- % We could make build_insert_map add such required unifications to the % insert map, but record_decisions_in_goal would need to be modified % as well. - % - deconstruct_tuple(CellVar, FieldVarsList, ProcStartDeconstruct), + Goal0 = hlds_goal(_, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), + deconstruct_tuple(Context, CellVar, FieldVarsList, ProcStartDeconstruct), ProcStartInsert = insert_spec(ProcStartDeconstruct, set_of_var.list_to_set(FieldVarsList)), insert_proc_start_deconstruction(ProcStartInsert, Goal1, Goal2, @@ -1624,25 +1626,25 @@ use_cell(_CellVar, _FieldVarList, _ConsId, _Goal, % deconstruction unification that is to be inserted _after_ the % interval beginning with that left anchor. % -:- pred build_insert_map(prog_var::in, list(prog_var)::in, interval_info::in, - insert_map::out) is det. +:- pred build_insert_map(prog_context::in, prog_var::in, list(prog_var)::in, + interval_info::in, insert_map::out) is det. -build_insert_map(CellVar, FieldVars, IntervalInfo, InsertMap) :- +build_insert_map(Context, CellVar, FieldVars, IntervalInfo, InsertMap) :- FieldVarsSet = set_of_var.list_to_set(FieldVars), - map.foldl(build_insert_map_2(CellVar, FieldVars, FieldVarsSet), + map.foldl(build_insert_map_2(Context, CellVar, FieldVars, FieldVarsSet), IntervalInfo ^ ii_anchor_follow_map, map.init, InsertMap). -:- pred build_insert_map_2(prog_var::in, list(prog_var)::in, +:- pred build_insert_map_2(prog_context::in, prog_var::in, list(prog_var)::in, set_of_progvar::in, anchor::in, anchor_follow_info::in, insert_map::in, insert_map::out) is det. -build_insert_map_2(CellVar, FieldVars, FieldVarsSet, Anchor, +build_insert_map_2(Context, CellVar, FieldVars, FieldVarsSet, Anchor, anchor_follow_info(FollowVars, _), !InsertMap) :- NeededFieldVars = FieldVarsSet `set_of_var.intersect` FollowVars, ( if set_of_var.is_empty(NeededFieldVars) then true else - deconstruct_tuple(CellVar, FieldVars, Goal), + deconstruct_tuple(Context, CellVar, FieldVars, Goal), InsertSpec = insert_spec(Goal, NeededFieldVars), add_insert_spec(Anchor, InsertSpec, !InsertMap) ). @@ -1787,7 +1789,8 @@ fix_calls_in_goal(TransformMap, Goal0, Goal, !VarTable, !RttiVarMaps) :- add_var_entry(CellVarEntry, CellVar, !VarTable), extract_tupled_args_from_list(Args0, ArgsToTuple, TupledArgs, UntupledArgs), - construct_tuple(CellVar, TupledArgs, ConstructGoal), + Context = goal_info_get_context(GoalInfo0), + construct_tuple(Context, CellVar, TupledArgs, ConstructGoal), ( if NewArgs = UntupledArgs ++ [CellVar], CallAux = CallAux0 ^ call_args := NewArgs diff --git a/compiler/unify_proc.m b/compiler/unify_proc.m index c1c34e995..e3d31fac5 100644 --- a/compiler/unify_proc.m +++ b/compiler/unify_proc.m @@ -336,7 +336,7 @@ generate_unify_proc_body(SpecDefnInfo, X, Y, Clauses, !Info) :- unify_proc_info::in, unify_proc_info::out) is det. generate_unify_proc_body_dummy(Context, X, Y, Clause, !Info) :- - Goal = true_goal_with_context(Context), + Goal = true_goal(Context), quantify_clause_body(all_modes, [X, Y], Goal, Context, Clause, !Info). %---------------------------------------------------------------------------% @@ -484,8 +484,7 @@ generate_unify_proc_body_eqv(Context, EqvType, X, Y, Clause, !Info) :- create_pure_atomic_complicated_unification(CastX, rhs_var(CastY), Context, umc_explicit, [], UnifyGoal), - goal_info_init(GoalInfo0), - goal_info_set_context(Context, GoalInfo0, GoalInfo), + goal_info_init(Context, GoalInfo), conj_list_to_goal([CastXGoal, CastYGoal, UnifyGoal], GoalInfo, Goal), quantify_clause_body(all_modes, [X, Y], Goal, Context, Clause, !Info). @@ -509,7 +508,7 @@ generate_unify_proc_body_solver(Context, X, Y, Clause, !Info) :- unify_proc_info::in, unify_proc_info::out) is det. generate_unify_proc_body_enum(Context, X, Y, Clause, !Info) :- - make_simple_test(X, Y, umc_explicit, [], Goal), + make_simple_test(X, Y, Context, umc_explicit, [], Goal), quantify_clause_body(all_modes, [X, Y], Goal, Context, Clause, !Info). %---------------------------------------------------------------------------% @@ -1240,8 +1239,7 @@ generate_compare_proc_body_eqv(Context, EqvType, Res, X, Y, Clause, !Info) :- build_simple_call(ModuleInfo, mercury_public_builtin_module, "compare", [Res, CastX, CastY], Context, CompareGoal), - goal_info_init(GoalInfo0), - goal_info_set_context(Context, GoalInfo0, GoalInfo), + goal_info_init(Context, GoalInfo), conj_list_to_goal([CastXGoal, CastYGoal, CompareGoal], GoalInfo, Goal), quantify_clause_body(all_modes, [Res, X, Y], Goal, Context, Clause, !Info). @@ -1273,8 +1271,7 @@ generate_compare_proc_body_enum(Context, Res, X, Y, Clause, !Info) :- generate_cast(unsafe_type_cast, Y, CastY, Context, CastYGoal), build_simple_call(ModuleInfo, mercury_private_builtin_module, "builtin_compare_int", [Res, CastX, CastY], Context, CompareGoal), - goal_info_init(GoalInfo0), - goal_info_set_context(Context, GoalInfo0, GoalInfo), + goal_info_init(Context, GoalInfo), conj_list_to_goal([CastXGoal, CastYGoal, CompareGoal], GoalInfo, Goal), quantify_clause_body(all_modes, [Res, X, Y], Goal, Context, Clause, !Info). @@ -1945,8 +1942,7 @@ generate_compare_goal(SpecDefnInfo, UCOptions, ConsIdsMatch, CtorRepn, umc_explicit, [], GoalUnifyY), GoalList = [GoalUnifyX, GoalUnifyY, CompareArgsGoal] ), - goal_info_init(GoalInfo0), - goal_info_set_context(Context, GoalInfo0, GoalInfo), + goal_info_init(Context, GoalInfo), conj_list_to_goal(GoalList, GoalInfo, Goal). %---------------------% @@ -2833,8 +2829,8 @@ build_spec_pred_call(Info, TypeCtor, SpecialPredId, ArgVars, PredName, PredId, ProcId), GoalExpr = plain_call(PredId, ProcId, ArgVars, not_builtin, no, PredName), set_of_var.list_to_set(ArgVars, NonLocals), - goal_info_init(NonLocals, InstmapDelta, Detism, purity_pure, GoalInfo0), - goal_info_set_context(Context, GoalInfo0, GoalInfo), + goal_info_init(NonLocals, InstmapDelta, Detism, purity_pure, Context, + GoalInfo), Goal = hlds_goal(GoalExpr, GoalInfo). %---------------------------------------------------------------------------% @@ -2874,7 +2870,7 @@ maybe_wrap_with_pretest_equality(Context, X, Y, MaybeCompareRes, CondGoal = hlds_goal(CondGoalExpr, ContextGoalInfo), ( MaybeCompareRes = no, - EqualGoal = true_goal_with_context(Context), + EqualGoal = true_goal(Context), GoalInfo = ContextGoalInfo ; MaybeCompareRes = yes(Res), diff --git a/compiler/unique_modes.m b/compiler/unique_modes.m index 49ef129e5..ad2106eee 100644 --- a/compiler/unique_modes.m +++ b/compiler/unique_modes.m @@ -727,7 +727,9 @@ unique_modes_check_cases([Case0 | Cases0], Var, [Case | Cases], % 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. - Goal1 = true_goal + Goal0 = hlds_goal(_, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), + Goal1 = true_goal(Context) ), mode_info_get_instmap(!.ModeInfo, InstMap), @@ -800,7 +802,9 @@ unique_modes_check_goal_if_then_else(Vars, Cond0, Then0, Else0, GoalInfo0, % 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. - Then = true_goal, + Then0 = hlds_goal(_, ThenGoalInfo0), + ThenContext = goal_info_get_context(ThenGoalInfo0), + Then = true_goal(ThenContext), InstMapThen = InstMapCond ), mode_info_set_instmap(InstMap0, !ModeInfo), diff --git a/compiler/unneeded_code.m b/compiler/unneeded_code.m index 2dfa6829b..c669c996c 100644 --- a/compiler/unneeded_code.m +++ b/compiler/unneeded_code.m @@ -414,7 +414,9 @@ unneeded_process_goal(UnneededInfo, InitInstMap, FinalInstMap, Goal0, Goal, map.to_assoc_list(Branches, BranchList), list.foldl(insert_branch_into_refined_goals(Goal0), BranchList, !RefinedGoalMap), - Goal = true_goal, + Goal0 = hlds_goal(_GoalExpr0, GoalInfo0), + Context = goal_info_get_context(GoalInfo0), + Goal = true_goal(Context), !:Changed = changed, Options = UnneededInfo ^ uci_options, @@ -423,7 +425,6 @@ unneeded_process_goal(UnneededInfo, InitInstMap, FinalInstMap, Goal0, Goal, Debug = no ; Debug = yes(Stream), - Goal0 = hlds_goal(_GoalExpr0, GoalInfo0), goal_info_get_goal_id(GoalInfo0) = goal_id(GoalIdNum0), trace [io(!IO)] ( io.format(Stream, "unneeded code at goal id %u\n", diff --git a/compiler/untupling.m b/compiler/untupling.m index e2ec8085e..920c27544 100644 --- a/compiler/untupling.m +++ b/compiler/untupling.m @@ -355,12 +355,16 @@ expand_one_arg_in_proc_2(ModuleInfo, TypeTable, HeadVar0, ArgMode0, !VarTable), list.duplicate(list.length(NewHeadVars), ArgMode0, NewArgModes), MaybeHeadVarsAndArgModes = yes(NewHeadVars - NewArgModes), + !.Goal = hlds_goal(_, GoalInfo), + Context = goal_info_get_context(GoalInfo), ( if ArgMode0 = in_mode then - construct_functor(HeadVar0, ConsId, NewHeadVars, UnifGoal), - conjoin_goals_keep_detism(UnifGoal, !Goal) + construct_functor(Context, HeadVar0, ConsId, NewHeadVars, + UnifyGoal), + conjoin_goals_keep_detism(Context, UnifyGoal, !Goal) else if ArgMode0 = out_mode then - deconstruct_functor(HeadVar0, ConsId, NewHeadVars, UnifGoal), - conjoin_goals_keep_detism(!.Goal, UnifGoal, !:Goal) + deconstruct_functor(Context, HeadVar0, ConsId, NewHeadVars, + UnifyGoal), + conjoin_goals_keep_detism(Context, !.Goal, UnifyGoal, !:Goal) else unexpected($pred, "unsupported mode") ), @@ -385,15 +389,15 @@ create_untuple_vars(ModuleInfo, ParentName, Num, create_untuple_vars(ModuleInfo, ParentName, Num + 1, Types, NewVars, !VarTable). -:- pred conjoin_goals_keep_detism(hlds_goal::in, hlds_goal::in, - hlds_goal::out) is det. +:- pred conjoin_goals_keep_detism(prog_context::in, + hlds_goal::in, hlds_goal::in, hlds_goal::out) is det. -conjoin_goals_keep_detism(GoalA, GoalB, Goal) :- +conjoin_goals_keep_detism(Context, GoalA, GoalB, Goal) :- goal_to_conj_list(GoalA, GoalListA), goal_to_conj_list(GoalB, GoalListB), GoalList = GoalListA ++ GoalListB, goal_list_determinism(GoalList, Determinism), - goal_info_init(GoalInfo0), + goal_info_init(Context, GoalInfo0), goal_info_set_determinism(Determinism, GoalInfo0, GoalInfo), Goal = hlds_goal(conj(plain_conj, GoalList), GoalInfo). @@ -538,11 +542,13 @@ fix_calls_in_goal(ModuleInfo, TransformMap, Goal0, Goal, !VarTable) :- module_info_pred_proc_info(ModuleInfo, CalleePredId, CalleeProcId, _CalleePredInfo, CalleeProcInfo), proc_info_get_argmodes(CalleeProcInfo, OrigArgModes), - expand_call_args(ModuleInfo, TypeTable, OrigArgs, OrigArgModes, - Args, EnterUnifs, ExitUnifs, !VarTable), + Context = goal_info_get_context(GoalInfo0), + expand_call_args(ModuleInfo, TypeTable, Context, + OrigArgs, OrigArgModes, Args, + EnterUnifyGoals, ExitUnifyGoals, !VarTable), ( if CallAux = CallAux0 ^ call_args := Args then Call = hlds_goal(CallAux, CallAuxInfo), - ConjList = EnterUnifs ++ [Call] ++ ExitUnifs, + ConjList = EnterUnifyGoals ++ [Call] ++ ExitUnifyGoals, conj_list_to_goal(ConjList, GoalInfo0, Goal) else unexpected($pred, "not a call template") @@ -651,29 +657,30 @@ fix_calls_in_cases(ModuleInfo, TransformMap, %-----------------------------------------------------------------------------% -:- pred expand_call_args(module_info::in, type_table::in, +:- pred expand_call_args(module_info::in, type_table::in, prog_context::in, list(prog_var)::in, list(mer_mode)::in, list(prog_var)::out, list(hlds_goal)::out, list(hlds_goal)::out, var_table::in, var_table::out) is det. -expand_call_args(ModuleInfo, TypeTable, ArgVars0, ArgModes0, ArgVars, - EnterUnifs, ExitUnifs, !VarTable) :- - expand_call_args_2(ModuleInfo, TypeTable, [], ArgVars0, ArgModes0, ArgVars, - EnterUnifs, ExitUnifs, !VarTable). +expand_call_args(ModuleInfo, TypeTable, Context, ArgVars0, ArgModes0, ArgVars, + EnterUnifyGoals, ExitUnifyGoals, !VarTable) :- + expand_call_args_2(ModuleInfo, TypeTable, Context, + [], ArgVars0, ArgModes0, ArgVars, + EnterUnifyGoals, ExitUnifyGoals, !VarTable). -:- pred expand_call_args_2(module_info::in, type_table::in, list(mer_type)::in, - list(prog_var)::in, list(mer_mode)::in, +:- pred expand_call_args_2(module_info::in, type_table::in, prog_context::in, + list(mer_type)::in, list(prog_var)::in, list(mer_mode)::in, list(prog_var)::out, list(hlds_goal)::out, list(hlds_goal)::out, var_table::in, var_table::out) is det. -expand_call_args_2(_, _, _, [], [], [], [], [], !VarTable). -expand_call_args_2(_, _, _, [], [_ | _], _, _, _, !VarTable) :- +expand_call_args_2(_, _, _, _, [], [], [], [], [], !VarTable). +expand_call_args_2(_, _, _, _, [], [_ | _], _, _, _, !VarTable) :- unexpected($pred, "length mismatch"). -expand_call_args_2(_, _, _, [_ | _], [], _, _, _, !VarTable) :- +expand_call_args_2(_, _, _, _, [_ | _], [], _, _, _, !VarTable) :- unexpected($pred, "length mismatch"). -expand_call_args_2(ModuleInfo, TypeTable, ContainerTypes0, +expand_call_args_2(ModuleInfo, TypeTable, Context, ContainerTypes0, [ArgVar0 | ArgVars0], [ArgMode | ArgModes], ArgVars, - EnterUnifs, ExitUnifs, !VarTable) :- + EnterUnifyGoals, ExitUnifyGoals, !VarTable) :- lookup_var_type(!.VarTable, ArgVar0, Arg0Type), expand_argument(ArgMode, Arg0Type, ContainerTypes0, TypeTable, Expansion), ( @@ -683,24 +690,26 @@ expand_call_args_2(ModuleInfo, TypeTable, ContainerTypes0, list.duplicate(NumVars, ArgMode, ReplacementModes), ContainerTypes = [Arg0Type | ContainerTypes0], ( if ArgMode = in_mode then - deconstruct_functor(ArgVar0, ConsId, ReplacementArgVars, Unif), - EnterUnifs = [Unif | EnterUnifs1], - expand_call_args_2(ModuleInfo, TypeTable, ContainerTypes, + deconstruct_functor(Context, ArgVar0, ConsId, ReplacementArgVars, + UnifyGoal), + expand_call_args_2(ModuleInfo, TypeTable, Context, ContainerTypes, ReplacementArgVars ++ ArgVars0, ReplacementModes ++ ArgModes, - ArgVars, EnterUnifs1, ExitUnifs, !VarTable) + ArgVars, EnterUnifyGoals1, ExitUnifyGoals, !VarTable), + EnterUnifyGoals = [UnifyGoal | EnterUnifyGoals1] else if ArgMode = out_mode then - construct_functor(ArgVar0, ConsId, ReplacementArgVars, Unif), - ExitUnifs = ExitUnifs1 ++ [Unif], - expand_call_args_2(ModuleInfo, TypeTable, ContainerTypes, + construct_functor(Context, ArgVar0, ConsId, ReplacementArgVars, + UnifyGoal), + expand_call_args_2(ModuleInfo, TypeTable, Context, ContainerTypes, ReplacementArgVars ++ ArgVars0, ReplacementModes ++ ArgModes, - ArgVars, EnterUnifs, ExitUnifs1, !VarTable) + ArgVars, EnterUnifyGoals, ExitUnifyGoals1, !VarTable), + ExitUnifyGoals = ExitUnifyGoals1 ++ [UnifyGoal] else unexpected($pred, "unsupported mode") ) ; Expansion = no_expansion, - expand_call_args(ModuleInfo, TypeTable, ArgVars0, ArgModes, ArgVars1, - EnterUnifs, ExitUnifs, !VarTable), + expand_call_args(ModuleInfo, TypeTable, Context, ArgVars0, ArgModes, + ArgVars1, EnterUnifyGoals, ExitUnifyGoals, !VarTable), ArgVars = [ArgVar0 | ArgVars1] ). diff --git a/compiler/unused_args_optimize.m b/compiler/unused_args_optimize.m index 89132bcbb..05141d275 100644 --- a/compiler/unused_args_optimize.m +++ b/compiler/unused_args_optimize.m @@ -619,7 +619,8 @@ delete_unused_args_in_goal_expr(Goal0, Goal, !Info, Changed) :- then UnusedVars = !.Info ^ delete_unused_vars, ( if list.member(TermVar, UnusedVars) then - Goal = true_goal, + Context = goal_info_get_context(GoalInfo0), + Goal = true_goal(Context), % We don't change the set of unneeded variables. Changed = unchanged else