diff --git a/compiler/accumulator.m b/compiler/accumulator.m index 38eebe07b..f7aaa2573 100644 --- a/compiler/accumulator.m +++ b/compiler/accumulator.m @@ -281,7 +281,7 @@ accu_transform_proc(proc(PredId, ProcId), PredInfo, !ProcInfo, !ModuleInfo, [option_is_set(warn_accumulator_swaps, yes, [always(InPieces)])]), - proc_info_get_varset(!.ProcInfo, VarSet), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, _VarTypes), generate_warnings(!.ModuleInfo, VarSet, Warnings, WarnMsgs), ( Warnings = [_], @@ -405,7 +405,7 @@ should_attempt_accu_transform(!ModuleInfo, PredId, ProcId, PredInfo, should_attempt_accu_transform_2(!ModuleInfo, PredId, PredInfo, !ProcInfo, HeadVars, InitialInstMap, TopLevel, FullyStrict, DoLCMC, [Id | Ids], C, M, Rec, Warnings) :- - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes0), identify_out_and_out_prime(!.ModuleInfo, VarTypes0, InitialInstMap, Id, Rec, HeadVars, Out, OutPrime, HeadToCallSubst, CallToHeadSubst), ( if @@ -1153,8 +1153,7 @@ accu_stage2(ModuleInfo, ProcInfo0, GoalId, GoalStore, Sets, OutPrime, Out, set_of_var.init, AfterNonLocals), InitAccs = set_of_var.intersect(BeforeNonLocals, AfterNonLocals), - proc_info_get_varset(ProcInfo0, !:VarSet), - proc_info_get_vartypes(ProcInfo0, !:VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, !:VarSet, !:VarTypes), accu_substs_init(set_of_var.to_sorted_list(InitAccs), !VarSet, !VarTypes, !:Substs), @@ -1495,8 +1494,7 @@ accu_stage3(RecCallId, Accs, VarSet, VarTypes, C, CS, Substs, AccBaseGoal, AccRecGoal, OrigGoal, AccGoal), proc_info_set_goal(OrigGoal, !OrigProcInfo), - proc_info_set_varset(VarSet, !OrigProcInfo), - proc_info_set_vartypes(VarTypes, !OrigProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !OrigProcInfo), requantify_proc_general(ordinary_nonlocals_no_lambda, !OrigProcInfo), update_accumulator_pred(AccPredId, AccProcId, AccGoal, !ModuleInfo). diff --git a/compiler/add_heap_ops.m b/compiler/add_heap_ops.m index 3c14d20c4..fbe3c19bc 100644 --- a/compiler/add_heap_ops.m +++ b/compiler/add_heap_ops.m @@ -82,21 +82,19 @@ heap_module_info :: module_info ). -add_heap_ops(ModuleInfo0, !Proc) :- - proc_info_get_goal(!.Proc, Goal0), - proc_info_get_varset(!.Proc, VarSet0), - proc_info_get_vartypes(!.Proc, VarTypes0), +add_heap_ops(ModuleInfo0, !ProcInfo) :- + proc_info_get_goal(!.ProcInfo, Goal0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), TrailOpsInfo0 = heap_ops_info(VarSet0, VarTypes0, ModuleInfo0), goal_add_heap_ops(Goal0, Goal, TrailOpsInfo0, TrailOpsInfo), TrailOpsInfo = heap_ops_info(VarSet, VarTypes, _), - proc_info_set_goal(Goal, !Proc), - proc_info_set_varset(VarSet, !Proc), - proc_info_set_vartypes(VarTypes, !Proc), + proc_info_set_goal(Goal, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), % The code below does not maintain the non-local variables, % so we need to requantify. % XXX it would be more efficient to maintain them rather than recomputing % them every time. - requantify_proc_general(ordinary_nonlocals_no_lambda, !Proc). + requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo). :- pred goal_add_heap_ops(hlds_goal::in, hlds_goal::out, heap_ops_info::in, heap_ops_info::out) is det. diff --git a/compiler/add_trail_ops.m b/compiler/add_trail_ops.m index e70e1eef5..3c1fff701 100644 --- a/compiler/add_trail_ops.m +++ b/compiler/add_trail_ops.m @@ -117,22 +117,20 @@ inline_ops :: maybe_gen_trail_ops_inline ). -add_trail_ops(OptTrailUsage, GenerateInline, ModuleInfo0, !Proc) :- - proc_info_get_goal(!.Proc, Goal0), - proc_info_get_varset(!.Proc, VarSet0), - proc_info_get_vartypes(!.Proc, VarTypes0), +add_trail_ops(OptTrailUsage, GenerateInline, ModuleInfo0, !ProcInfo) :- + proc_info_get_goal(!.ProcInfo, Goal0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), TrailOpsInfo0 = trail_ops_info(VarSet0, VarTypes0, ModuleInfo0, OptTrailUsage, GenerateInline), goal_add_trail_ops(Goal0, Goal, TrailOpsInfo0, TrailOpsInfo), TrailOpsInfo = trail_ops_info(VarSet, VarTypes, _, _, _), - proc_info_set_goal(Goal, !Proc), - proc_info_set_varset(VarSet, !Proc), - proc_info_set_vartypes(VarTypes, !Proc), + proc_info_set_goal(Goal, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), % The code below does not maintain the non-local variables, % so we need to requantify. % XXX it would be more efficient to maintain them rather than % recomputing them every time. - requantify_proc_general(ordinary_nonlocals_no_lambda, !Proc). + requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo). :- pred goal_add_trail_ops(hlds_goal::in, hlds_goal::out, trail_ops_info::in, trail_ops_info::out) is det. diff --git a/compiler/arg_info.m b/compiler/arg_info.m index 311f481e6..f11f2ea08 100644 --- a/compiler/arg_info.m +++ b/compiler/arg_info.m @@ -687,7 +687,7 @@ partition_args([Var - ArgInfo | VarsArgInfos], !:Ins, !:Outs, !:Unuseds) :- partition_proc_args(ProcInfo, ModuleInfo, Inputs, Outputs, Unuseds) :- proc_info_get_headvars(ProcInfo, Vars), proc_info_get_argmodes(ProcInfo, Modes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, Vars, Types), do_partition_proc_args(ModuleInfo, Vars, Types, Modes, Inputs, Outputs, Unuseds). diff --git a/compiler/build_mode_constraints.m b/compiler/build_mode_constraints.m index c39d26fa7..c006f76d0 100644 --- a/compiler/build_mode_constraints.m +++ b/compiler/build_mode_constraints.m @@ -716,7 +716,7 @@ mode_decls_constraints(ModuleInfo, VarMap, PredId, Decls, HeadVarsList, add_mode_decl_constraints(ModuleInfo, PredId, ProcId, Decl, Args, !VarInfo, !Constraints) :- module_info_proc_info(ModuleInfo, PredId, ProcId, ProcInfo), - proc_info_get_varset(ProcInfo, ProgVarset), + proc_info_get_varset_vartypes(ProcInfo, ProgVarset, _VarTypes), proc_info_get_context(ProcInfo, Context), prog_vars_at_path(ProgVarset, PredId, Args, goal_id(0), ArgsAtHead, diff --git a/compiler/bytecode_gen.m b/compiler/bytecode_gen.m index 86ec55ea7..b58204363 100644 --- a/compiler/bytecode_gen.m +++ b/compiler/bytecode_gen.m @@ -135,8 +135,7 @@ gen_proc(ProcId, PredInfo, ModuleInfo, Code) :- map.lookup(ProcTable, ProcId, ProcInfo), proc_info_get_goal(ProcInfo, Goal), - proc_info_get_vartypes(ProcInfo, VarTypes), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_interface_determinism(ProcInfo, Detism), determinism_to_code_model(Detism, CodeModel), diff --git a/compiler/call_gen.m b/compiler/call_gen.m index c0b358dec..88306eb80 100644 --- a/compiler/call_gen.m +++ b/compiler/call_gen.m @@ -76,6 +76,7 @@ :- import_module hlds.hlds_llds. :- import_module hlds.hlds_module. :- import_module hlds.instmap. +:- import_module hlds.var_table. :- import_module libs.options. :- import_module ll_backend.code_util. :- import_module ll_backend.continuation_info. @@ -84,6 +85,7 @@ :- import_module mdbcomp.goal_path. :- import_module parse_tree.prog_data_event. :- import_module parse_tree.prog_event. +:- import_module parse_tree.prog_type. :- import_module parse_tree.set_of_var. :- import_module bool. @@ -171,7 +173,7 @@ generate_call(CodeModel, PredId, ProcId, ArgVars, GoalInfo, Code, !CI, !CLD) :- %---------------------------------------------------------------------------% -generate_generic_call(OuterCodeModel, GenericCall, Args, Modes, +generate_generic_call(OuterCodeModel, GenericCall, ArgVars, Modes, MaybeRegTypes, Det, GoalInfo, Code, !CI, !CLD) :- % For a generic_call, we split the arguments into inputs and outputs, % put the inputs in the locations expected by mercury.do_call_closure in @@ -186,28 +188,30 @@ generate_generic_call(OuterCodeModel, GenericCall, Args, Modes, ( GenericCall = higher_order(_, _, _, _) ; GenericCall = class_method(_, _, _, _) ), - generate_main_generic_call(OuterCodeModel, GenericCall, Args, Modes, + generate_main_generic_call(OuterCodeModel, GenericCall, ArgVars, Modes, MaybeRegTypes, Det, GoalInfo, Code, !CI, !CLD) ; GenericCall = event_call(EventName), - generate_event_call(EventName, Args, GoalInfo, Code, !CI, !CLD) + generate_event_call(EventName, ArgVars, GoalInfo, Code, !CI, !CLD) ; GenericCall = cast(_), - ( if Args = [InputArg, OutputArg] then - get_module_info(!.CI, ModuleInfo), - get_proc_info(!.CI, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), - ( if var_is_of_dummy_type(ModuleInfo, VarTypes, InputArg) then + ( if ArgVars = [InputArgVar, OutputArgVar] then + get_var_table(!.CI, VarTable), + lookup_var_entry(VarTable, InputArgVar, InputArgEntry), + InputArgVarIsDummy = InputArgEntry ^ vte_is_dummy, + ( + InputArgVarIsDummy = is_dummy_type, % Dummy types don't actually have values, which is - % normally harmless. However using the constant zero means + % normally harmless. However, using the constant zero means % that we don't need to allocate space for an existentially % typed version of a dummy type. Using the constant zero % also avoids keeping pointers to memory that could be freed. - Rval = int_const(0) - else - Rval = leaf(InputArg) + InputArgRval = int_const(0) + ; + InputArgVarIsDummy = is_not_dummy_type, + InputArgRval = leaf(InputArgVar) ), - generate_assign_builtin(OutputArg, Rval, Code, !CLD) + generate_assign_builtin(OutputArgVar, InputArgRval, Code, !CLD) else unexpected($pred, "invalid type/inst cast call") ) diff --git a/compiler/clause_to_proc.m b/compiler/clause_to_proc.m index 815b957b7..fe3a551b8 100644 --- a/compiler/clause_to_proc.m +++ b/compiler/clause_to_proc.m @@ -126,8 +126,7 @@ copy_clauses_to_maybe_imported_proc_in_proc_info(PredInfo, ClausesInfo, clauses_info_get_vartypes(ClausesInfo, VarTypes), clauses_info_get_rtti_varmaps(ClausesInfo, RttiVarMaps), proc_info_set_headvars(HeadVarList, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo) else copy_clauses_to_proc_in_proc_info(PredInfo, ProcId, !ProcInfo) diff --git a/compiler/closure_analysis.m b/compiler/closure_analysis.m index 46e45adc8..27f85fb1c 100644 --- a/compiler/closure_analysis.m +++ b/compiler/closure_analysis.m @@ -152,7 +152,7 @@ insert_unknown(Var, !ClosureInfo) :- closure_analyse_proc(Debug, PPId, !ModuleInfo) :- module_info_pred_proc_info(!.ModuleInfo, PPId, PredInfo, ProcInfo0), proc_info_get_headvars(ProcInfo0, HeadVars), - proc_info_get_vartypes(ProcInfo0, VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, VarSet, VarTypes), proc_info_get_argmodes(ProcInfo0, ArgModes), ClosureInfo0 = closure_info_init(!.ModuleInfo, VarTypes, HeadVars, ArgModes), @@ -165,10 +165,9 @@ closure_analyse_proc(Debug, PPId, !ModuleInfo) :- ClosureInfo0, _ClosureInfo), ( Debug = yes, - proc_info_get_varset(ProcInfo, Varset), trace [io(!IO)] ( get_debug_output_stream(!.ModuleInfo, DebugStream, !IO), - dump_closure_info(DebugStream, Varset, BodyGoal, !IO), + dump_closure_info(DebugStream, VarSet, BodyGoal, !IO), io.flush_output(DebugStream, !IO) ) ; @@ -466,7 +465,7 @@ merge_closure_values(exclusive(A), exclusive(B), exclusive(A `set.union` B)). :- pred dump_closure_info(io.text_output_stream::in, prog_varset::in, hlds_goal::in, io::di, io::uo) is det. -dump_closure_info(DebugStream, Varset, Goal, !IO) :- +dump_closure_info(DebugStream, VarSet, Goal, !IO) :- % XXX zs: It seems to me that the output from this predicate % would be much easier to understand if each piece of the output % was preceded by the identity of the goal that it came from. @@ -475,33 +474,33 @@ dump_closure_info(DebugStream, Varset, Goal, !IO) :- GoalExpr = unify(_, _, _, _, _) ; GoalExpr = plain_call(_, _, _, _, _, _), - dump_ho_values(DebugStream, Varset, GoalInfo, !IO) + dump_ho_values(DebugStream, VarSet, GoalInfo, !IO) ; GoalExpr = generic_call(_, _, _, _, _), - dump_ho_values(DebugStream, Varset, GoalInfo, !IO) + dump_ho_values(DebugStream, VarSet, GoalInfo, !IO) ; GoalExpr = call_foreign_proc(_, _, _, _, _, _, _) ; GoalExpr = conj(_ConjType, SubGoals), - list.foldl(dump_closure_info(DebugStream, Varset), SubGoals, !IO) + list.foldl(dump_closure_info(DebugStream, VarSet), SubGoals, !IO) ; GoalExpr = disj(SubGoals), - list.foldl(dump_closure_info(DebugStream, Varset), SubGoals, !IO) + list.foldl(dump_closure_info(DebugStream, VarSet), SubGoals, !IO) ; GoalExpr = switch(_, _, Cases), SubGoals = list.map((func(case(_, _, CaseGoal)) = CaseGoal), Cases), - list.foldl(dump_closure_info(DebugStream, Varset), SubGoals, !IO) + list.foldl(dump_closure_info(DebugStream, VarSet), SubGoals, !IO) ; GoalExpr = if_then_else(_, CondGoal, ThenGoal, ElseGoal), - dump_closure_info(DebugStream, Varset, CondGoal, !IO), - dump_closure_info(DebugStream, Varset, ThenGoal, !IO), - dump_closure_info(DebugStream, Varset, ElseGoal, !IO) + dump_closure_info(DebugStream, VarSet, CondGoal, !IO), + dump_closure_info(DebugStream, VarSet, ThenGoal, !IO), + dump_closure_info(DebugStream, VarSet, ElseGoal, !IO) ; GoalExpr = negation(SubGoal), - dump_closure_info(DebugStream, Varset, SubGoal, !IO) + dump_closure_info(DebugStream, VarSet, SubGoal, !IO) ; GoalExpr = scope(_, SubGoal), - dump_closure_info(DebugStream, Varset, SubGoal, !IO) + dump_closure_info(DebugStream, VarSet, SubGoal, !IO) ; GoalExpr = shorthand(_), unexpected($pred, "shorthand") @@ -510,7 +509,7 @@ dump_closure_info(DebugStream, Varset, Goal, !IO) :- :- pred dump_ho_values(io.text_output_stream::in, prog_varset::in, hlds_goal_info::in, io::di, io::uo) is det. -dump_ho_values(DebugStream, Varset, GoalInfo, !IO) :- +dump_ho_values(DebugStream, VarSet, GoalInfo, !IO) :- HoValueMap = goal_info_get_higher_order_value_map(GoalInfo), ( if map.is_empty(HoValueMap) then true @@ -518,15 +517,15 @@ dump_ho_values(DebugStream, Varset, GoalInfo, !IO) :- Context = goal_info_get_context(GoalInfo), prog_out.write_context(DebugStream, Context, !IO), io.nl(DebugStream, !IO), - map.foldl(dump_ho_value_map_entry(DebugStream, Varset), + map.foldl(dump_ho_value_map_entry(DebugStream, VarSet), HoValueMap, !IO) ). :- pred dump_ho_value_map_entry(io.text_output_stream::in, prog_varset::in, prog_var::in, set(pred_proc_id)::in, io::di, io::uo) is det. -dump_ho_value_map_entry(DebugStream, Varset, ProgVar, Values, !IO) :- - VarName = varset.lookup_name(Varset, ProgVar), +dump_ho_value_map_entry(DebugStream, VarSet, ProgVar, Values, !IO) :- + VarName = varset.lookup_name(VarSet, ProgVar), io.format(DebugStream, "%s =\n", [s(VarName)], !IO), WritePPIds = ( pred(PPId::in, !.IO::di, !:IO::uo) is det :- diff --git a/compiler/code_gen.m b/compiler/code_gen.m index 094f55db2..1db910328 100644 --- a/compiler/code_gen.m +++ b/compiler/code_gen.m @@ -87,7 +87,7 @@ generate_goal(ContextModel, Goal, Code, !CI, !CLD) :- trace [compiletime(flag("codegen_goal")), io(!IO)] ( some [ModuleInfo, VarSet, GoalDesc] ( code_info.get_module_info(!.CI, ModuleInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), GoalDesc = describe_goal(ModuleInfo, VarSet, Goal), ( if should_trace_code_gen(!.CI) then @@ -192,7 +192,7 @@ generate_goal(ContextModel, Goal, Code, !CI, !CLD) :- trace [compiletime(flag("codegen_goal")), io(!IO)] ( some [ModuleInfo, VarSet, GoalDesc] ( code_info.get_module_info(!.CI, ModuleInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), GoalDesc = describe_goal(ModuleInfo, VarSet, Goal), ( if should_trace_code_gen(!.CI) then diff --git a/compiler/code_info.m b/compiler/code_info.m index 5f639336f..bd488ba16 100644 --- a/compiler/code_info.m +++ b/compiler/code_info.m @@ -380,8 +380,7 @@ code_info_init(ModuleInfo, PredId, ProcId, PredInfo, ProcInfo, % argument PredInfo % argument ProcInfo ProcLabel = make_proc_label(ModuleInfo, PredId, ProcId), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), make_var_table(ModuleInfo, VarSet, VarTypes, VarTable), proc_info_get_stack_slots(ProcInfo, StackSlots), max_var_slot(StackSlots, VarSlotMax), @@ -770,7 +769,6 @@ max_var_slot_loop([Slot | Slots], !Max) :- % Find out the type of the given variable. % :- func variable_type(code_info, prog_var) = mer_type. -:- func var_table_type(var_table, prog_var) = mer_type. % Compute the principal type constructor of the given type, and return % the definition of this type constructor, if it has one (some type @@ -899,11 +897,6 @@ variable_type(CI, Var) = Type :- lookup_var_entry(VarTable, Var, Entry), Type = Entry ^ vte_type. -% XXX should be in var_table.m -var_table_type(VarTable, Var) = Type :- - lookup_var_entry(VarTable, Var, Entry), - Type = Entry ^ vte_type. - search_type_defn(CI, Type, TypeDefn) :- get_module_info(CI, ModuleInfo), type_to_ctor_det(Type, TypeCtor), diff --git a/compiler/code_loc_dep.m b/compiler/code_loc_dep.m index c2bf134ba..c56d056c8 100644 --- a/compiler/code_loc_dep.m +++ b/compiler/code_loc_dep.m @@ -191,8 +191,7 @@ code_loc_dep_init(FollowVars, ResumePoint, !CI, !:CLD) :- proc_info_get_liveness_info(ProcInfo, Liveness), CodeModel = proc_info_interface_code_model(ProcInfo), build_input_arg_list(ProcInfo, ArgList), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_stack_slots(ProcInfo, StackSlots), globals.lookup_bool_option(Globals, use_float_registers, UseFloatRegs), ( @@ -3442,7 +3441,7 @@ compute_forward_live_var_saves(CI, CLD, OutArgs, VarLocs) :- Vars0 = set_of_var.list_to_set(Variables0), TypeInfoLiveness = body_typeinfo_liveness(CI), get_proc_info(CI, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), maybe_complete_with_typeinfo_vars(Vars0, TypeInfoLiveness, VarTypes, RttiVarMaps, Vars1), diff --git a/compiler/complexity.m b/compiler/complexity.m index 8a10b0021..04645d372 100644 --- a/compiler/complexity.m +++ b/compiler/complexity.m @@ -267,8 +267,7 @@ complexity_process_proc(NumProcs, ProcNum, FullName, PredId, determinism_to_code_model(Detism, CodeModel), proc_info_get_headvars(!.ProcInfo, HeadVars), proc_info_get_argmodes(!.ProcInfo, ArgModes), - proc_info_get_varset(!.ProcInfo, VarSet), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, VarTypes), proc_info_get_goal(!.ProcInfo, OrigGoal), Context = goal_info_get_context(OrigGoalInfo), % Even if the original goal doesn't use all of the headvars, the code @@ -462,13 +461,13 @@ generate_size_goals([Var - VarSeqNum | NumberedVars], Context, NumProfiledVars, generate_size_goal(ArgVar, VarSeqNum, Context, NumProfiledVars, ProcVarName, SlotVarName, PredId, !ProcInfo, !ModuleInfo, Goals, ForeignArgs, CodeStr) :- - proc_info_get_vartypes(!.ProcInfo, VarTypes1), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet1, VarTypes1), lookup_var_type(VarTypes1, ArgVar, VarType), MacroName = "MR_complexity_fill_size_slot", make_type_info_var(VarType, Context, PredId, !ProcInfo, !ModuleInfo, TypeInfoVar, Goals), % Since we just created TypeInfoVar, it isn't in VarTypes1. - proc_info_get_vartypes(!.ProcInfo, VarTypes2), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet2, VarTypes2), lookup_var_type(VarTypes2, TypeInfoVar, TypeInfoType), ArgName = "arg" ++ int_to_string(VarSeqNum), TypeInfoArgName = "input_typeinfo" ++ int_to_string(VarSeqNum), @@ -493,12 +492,10 @@ generate_size_goal(ArgVar, VarSeqNum, Context, NumProfiledVars, ProcVarName, proc_info::in, proc_info::out, prog_var::out) is det. generate_new_var(Name, Type, !ProcInfo, Var) :- - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), varset.new_named_var(Name, Var, VarSet0, VarSet), add_var_type(Var, Type, VarTypes0, VarTypes), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo). + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo). :- pred complexity_generate_call_foreign_proc(string::in, determinism::in, list(foreign_arg)::in, list(foreign_arg)::in, string::in, diff --git a/compiler/continuation_info.m b/compiler/continuation_info.m index 6902ecb26..0fca69868 100644 --- a/compiler/continuation_info.m +++ b/compiler/continuation_info.m @@ -678,7 +678,7 @@ generate_resume_layout(ModuleInfo, ProcInfo, InstMap, ResumeMap, Temps, Layout) :- map.to_assoc_list(ResumeMap, ResumeList), set.init(TVars0), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), generate_resume_layout_for_vars(ResumeList, InstMap, VarTypes, ProcInfo, ModuleInfo, [], VarInfos, TVars0, TVars), set.list_to_set(VarInfos, VarInfoSet), @@ -755,8 +755,7 @@ generate_temp_var_infos([Temp | Temps], [Live | Lives]) :- generate_layout_for_var(_ModuleInfo, ProcInfo, _InstMap, Var, LiveValueType, TypeVars) :- - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), ( if varset.search_name(VarSet, Var, GivenName) then Name = GivenName else @@ -849,7 +848,7 @@ build_closure_info([Var | Vars], [Type0 | Types], %---------------------------------------------------------------------------% find_typeinfos_for_tvars(ProcInfo, TypeVars, VarLocs, TypeInfoDataMap) :- - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), list.foldl( gather_type_info_layout_locns_for_tvar(VarSet, RttiVarMaps, VarLocs), @@ -888,8 +887,7 @@ gather_type_info_layout_locn(TypeInfoLocn, Lval, !Locns) :- %---------------------------------------------------------------------------% generate_table_arg_type_info(ProcInfo, NumberedVars, TableArgInfos) :- - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), set.init(TypeVars0), build_table_arg_info(VarSet, VarTypes, NumberedVars, ArgLayouts, TypeVars0, TypeVars), @@ -921,7 +919,7 @@ build_table_arg_info(VarSet, VarTypes, [Var - SlotNum | NumberedVars], find_typeinfos_for_tvars_table(ProcInfo, TypeVars, NumberedVars, TypeInfoDataMap) :- - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), list.map(rtti_lookup_type_info_locn(RttiVarMaps), TypeVars, TypeInfoLocns), diff --git a/compiler/cse_detection.m b/compiler/cse_detection.m index 1d2119c26..aa1aa2fc6 100644 --- a/compiler/cse_detection.m +++ b/compiler/cse_detection.m @@ -285,8 +285,7 @@ detect_cse_in_proc_pass(ModuleInfo, Redo, !ProcInfo) :- proc_info_get_goal(!.ProcInfo, Goal0), proc_info_get_initial_instmap(ModuleInfo, !.ProcInfo, InstMap0), - proc_info_get_varset(!.ProcInfo, Varset0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, Varset0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), Redo0 = no, CseInfo0 = @@ -310,8 +309,7 @@ detect_cse_in_proc_pass(ModuleInfo, Redo, !ProcInfo) :- VarSet1, VarSet, VarTypes1, VarTypes, RttiVarMaps1, RttiVarMaps), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo) ). diff --git a/compiler/ctgc.datastruct.m b/compiler/ctgc.datastruct.m index b071b9a0e..fae20dd0f 100644 --- a/compiler/ctgc.datastruct.m +++ b/compiler/ctgc.datastruct.m @@ -125,7 +125,7 @@ datastruct_termshift(ModuleInfo, ProcInfo, Sel, Data0) = Data :- selector_termshift(DSel, Sel, NewSel0), % Keep datastruct seletors normalized. - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), normalize_selector_with_type_information(ModuleInfo, Type, NewSel0, NewSel), @@ -135,7 +135,7 @@ datastruct_termshift(ModuleInfo, ProcInfo, Sel, Data0) = Data :- normalize_datastruct(ModuleInfo, ProcInfo, Data0) = Data :- Data0 = selected_cel(Var, DSel0), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), normalize_selector_with_type_information(ModuleInfo, Type, DSel0, DSel), Data = selected_cel(Var, DSel). @@ -144,7 +144,7 @@ datastruct_subsumed_by_return_selector(ModuleInfo, ProcInfo, Data1, Data2, Extension) :- Data1 = selected_cel(Var, Sel1), Data2 = selected_cel(Var, Sel2), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), selector_subsumed_by(ModuleInfo, already_normalized, Sel1, Sel2, Type, Extension). @@ -189,7 +189,7 @@ datastruct_lists_least_upper_bound(ModuleInfo, ProcInfo, Data1, Data2) datastruct_apply_widening(ModuleInfo, ProcInfo, Data0, Data) :- Data0 = selected_cel(Var, Sel0), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), selector_apply_widening(ModuleInfo, Type, Sel0, Sel), Data = selected_cel(Var, Sel). diff --git a/compiler/ctgc.util.m b/compiler/ctgc.util.m index c1982158d..6e01d004d 100644 --- a/compiler/ctgc.util.m +++ b/compiler/ctgc.util.m @@ -148,7 +148,7 @@ reverse_renaming(RevSubst, K0, V0, !Acc) :- %---------------------------------------------------------------------------% var_needs_sharing_analysis(ModuleInfo, ProcInfo, Var) :- - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), type_needs_sharing_analysis(ModuleInfo, Type). diff --git a/compiler/deep_profiling.m b/compiler/deep_profiling.m index ba7cc4444..e01b7e6df 100644 --- a/compiler/deep_profiling.m +++ b/compiler/deep_profiling.m @@ -661,7 +661,7 @@ make_deep_original_body(ModuleInfo, ProcInfo, DeepOriginalBody) :- proc_info_get_goal(ProcInfo, Body), proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_initial_instmap(ModuleInfo, ProcInfo, Instmap), - proc_info_get_vartypes(ProcInfo, Vartypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_declared_determinism(ProcInfo, MaybeDetism), ( MaybeDetism = yes(Detism) @@ -669,9 +669,8 @@ make_deep_original_body(ModuleInfo, ProcInfo, DeepOriginalBody) :- MaybeDetism = no, proc_info_get_inferred_determinism(ProcInfo, Detism) ), - proc_info_get_varset(ProcInfo, Varset), - DeepOriginalBody = deep_original_body(Body, HeadVars, Instmap, Vartypes, - Detism, Varset). + DeepOriginalBody = deep_original_body(Body, HeadVars, Instmap, + VarSet, VarTypes, Detism). %-----------------------------------------------------------------------------% @@ -701,8 +700,7 @@ deep_prof_transform_normal_proc(ModuleInfo, PredProcId, !ProcInfo, fill_goal_id_slots_in_proc(ModuleInfo, ContainingGoalMap, !ProcInfo), module_info_get_globals(ModuleInfo, Globals), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), some [!VarInfo, !DeepInfo, !Goal] ( proc_info_get_goal(!.ProcInfo, !:Goal), !.Goal = hlds_goal(_, GoalInfo0), @@ -787,9 +785,8 @@ deep_prof_transform_normal_proc(ModuleInfo, PredProcId, !ProcInfo, GoalInfo0, BindProcStaticVarGoal, !Goal) ), - !.VarInfo = prog_var_set_types(Vars, VarTypes), - proc_info_set_varset(Vars, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + !.VarInfo = prog_var_set_types(VarSet, VarTypes), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_goal(!.Goal, !ProcInfo), DeepLayoutInfo = hlds_deep_layout(ProcStatic, ExcpVars) ). @@ -808,8 +805,7 @@ deep_prof_transform_inner_proc(ModuleInfo, PredProcId, !ProcInfo) :- proc_info_get_goal(!.ProcInfo, Goal0), Goal0 = hlds_goal(_, GoalInfo0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), VarInfo0 = prog_var_set_types(VarSet0, VarTypes0), generate_var("MiddleCSD", c_pointer_type, MiddleCSD, VarInfo0, VarInfo1), @@ -825,9 +821,7 @@ deep_prof_transform_inner_proc(ModuleInfo, PredProcId, !ProcInfo) :- VarInfo = DeepInfo ^ deep_varinfo, VarInfo = prog_var_set_types(VarSet, VarTypes), - - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo). :- func is_proc_in_interface(module_info, pred_id, proc_id) = bool. diff --git a/compiler/deforest.m b/compiler/deforest.m index 1c0a8101c..0fdfeadd9 100644 --- a/compiler/deforest.m +++ b/compiler/deforest.m @@ -234,7 +234,7 @@ deforest_proc_deltas(proc(PredId, ProcId), CostDelta, SizeDelta, !PDInfo) :- requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), proc_info_get_goal(!.ProcInfo, !:Goal), proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InstMap0), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_inst_varset(!.ProcInfo, InstVarSet), recompute_instmap_delta(recompute_atomic_instmap_deltas, !Goal, VarTypes, InstVarSet, InstMap0, !ModuleInfo), @@ -1290,7 +1290,7 @@ create_deforest_goal(EarlierGoal, BetweenGoals, MaybeLaterGoal, pd_info_get_parent_versions(!.PDInfo, Parents0), pd_info_get_proc_info(!.PDInfo, ProcInfo1), - proc_info_get_vartypes(ProcInfo1, VarTypes), + proc_info_get_varset_vartypes(ProcInfo1, _VarSet, VarTypes), lookup_var_types(VarTypes, NonLocalsList, ArgTypes), VersionInfo = version_info(FoldGoal, CalledPreds, NonLocalsList, ArgTypes, InstMap0, 0, 0, Parents0, MaybeGeneralised), @@ -1356,8 +1356,7 @@ create_call_goal(proc(PredId, ProcId), VersionInfo, Renaming, TypeSubn, Goal, pd_info_get_proc_info(!.PDInfo, ProcInfo0), pd_info_get_pred_info(!.PDInfo, PredInfo0), - proc_info_get_vartypes(ProcInfo0, VarTypes0), - proc_info_get_varset(ProcInfo0, VarSet0), + proc_info_get_varset_vartypes(ProcInfo0, VarSet0, VarTypes0), pred_info_get_typevarset(PredInfo0, TVarSet0), % Rename the argument types using the current pred's tvarset. @@ -1368,8 +1367,7 @@ create_call_goal(proc(PredId, ProcId), VersionInfo, Renaming, TypeSubn, Goal, create_deforest_call_args(OldArgs, ArgTypes1, Renaming, TypeSubn, Args, VarSet0, VarSet, VarTypes0, VarTypes), - proc_info_set_vartypes(VarTypes, ProcInfo0, ProcInfo1), - proc_info_set_varset(VarSet, ProcInfo1, ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, ProcInfo0, ProcInfo), pd_info_set_proc_info(ProcInfo, !PDInfo), % Compute a goal_info. @@ -1464,7 +1462,7 @@ try_generalisation(EarlierGoal, BetweenGoals, MaybeLaterGoal, VersionArgTypes, VersionInstMap, _, _, _, _), pd_info_get_versions(!.PDInfo, Versions), pd_info_get_proc_info(!.PDInfo, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), ( if pd_util.goals_match(ModuleInfo, VersionGoal, VersionArgs, VersionArgTypes, FoldGoal, VarTypes, Renaming, _) @@ -1477,7 +1475,6 @@ try_generalisation(EarlierGoal, BetweenGoals, MaybeLaterGoal, % matching against that. This happens when attempting two % deforestations in a row and the first deforestation required % generalisation. - proc_info_get_varset(ProcInfo, VarSet), match_generalised_version(ModuleInfo, VersionGoal, VersionArgs, VersionArgTypes, EarlierGoal, BetweenGoals, MaybeLaterGoal, ConjNonLocals, VarSet, VarTypes, Versions, @@ -1597,8 +1594,8 @@ match_generalised_version(ModuleInfo, VersionGoal, VersionArgs, module_info_pred_proc_info(ModuleInfo, FirstPredId, FirstProcId, _, FirstProcInfo), - proc_info_get_varset(FirstProcInfo, FirstVersionVarSet), - proc_info_get_vartypes(FirstProcInfo, FirstVersionVarTypes), + proc_info_get_varset_vartypes(FirstProcInfo, + FirstVersionVarSet, FirstVersionVarTypes), clone_variables(FirstVersionVars, FirstVersionVarSet, FirstVersionVarTypes, @@ -2016,7 +2013,7 @@ unfold_call(CheckImprovement, CheckVars, PredId, ProcId, Args, globals.get_opt_tuple(Globals, OptTuple), VarsThreshold = OptTuple ^ ot_deforestation_vars_threshold, pd_info_get_proc_info(!.PDInfo, ProcInfo0), - proc_info_get_varset(ProcInfo0, VarSet0), + proc_info_get_varset_vartypes(ProcInfo0, VarSet0, VarTypes0), varset.vars(VarSet0, Vars), list.length(Vars, NumVars), globals.lookup_bool_option(Globals, debug_pd, DebugPD), @@ -2037,7 +2034,6 @@ unfold_call(CheckImprovement, CheckVars, PredId, ProcId, Args, CalledPredInfo, CalledProcInfo), pred_info_get_typevarset(PredInfo0, TypeVarSet0), pred_info_get_univ_quant_tvars(PredInfo0, UnivQVars), - proc_info_get_vartypes(ProcInfo0, VarTypes0), proc_info_get_rtti_varmaps(ProcInfo0, RttiVarMaps0), inlining.do_inline_call(UnivQVars, Args, CalledPredInfo, CalledProcInfo, VarSet0, VarSet, VarTypes0, VarTypes, @@ -2045,17 +2041,16 @@ unfold_call(CheckImprovement, CheckVars, PredId, ProcId, Args, pred_info_set_typevarset(TypeVarSet, PredInfo0, PredInfo), proc_info_get_has_parallel_conj(CalledProcInfo, CalledHasParallelConj), - proc_info_set_varset(VarSet, ProcInfo0, ProcInfo1), - proc_info_set_vartypes(VarTypes, ProcInfo1, ProcInfo2), - proc_info_set_rtti_varmaps(RttiVarMaps, ProcInfo2, ProcInfo3), + proc_info_set_varset_vartypes(VarSet, VarTypes, ProcInfo0, ProcInfo1), + proc_info_set_rtti_varmaps(RttiVarMaps, ProcInfo1, ProcInfo2), ( CalledHasParallelConj = has_parallel_conj, proc_info_set_has_parallel_conj(has_parallel_conj, - ProcInfo3, ProcInfo) + ProcInfo2, ProcInfo) ; CalledHasParallelConj = has_no_parallel_conj, % Leave the has_parallel_conj field of the proc_info as it is. - ProcInfo = ProcInfo3 + ProcInfo = ProcInfo2 ), pd_info_set_pred_info(PredInfo, !PDInfo), diff --git a/compiler/delay_construct.m b/compiler/delay_construct.m index 7147e765d..ffb54f7a0 100644 --- a/compiler/delay_construct.m +++ b/compiler/delay_construct.m @@ -68,7 +68,7 @@ delay_construct_proc(ModuleInfo, proc(PredId, ProcId), !ProcInfo) :- module_info_get_globals(ModuleInfo, Globals), module_info_pred_info(ModuleInfo, PredId, PredInfo), body_should_use_typeinfo_liveness(PredInfo, Globals, BodyTypeinfoLiveness), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps), proc_info_get_initial_instmap(ModuleInfo, !.ProcInfo, InstMap0), DelayInfo = delay_construct_info(ModuleInfo, BodyTypeinfoLiveness, diff --git a/compiler/delay_partial_inst.m b/compiler/delay_partial_inst.m index b7bf66164..8f96dd154 100644 --- a/compiler/delay_partial_inst.m +++ b/compiler/delay_partial_inst.m @@ -229,8 +229,7 @@ delay_partial_inst_proc(ModuleInfo, PredId, ProcTable, ProcId, ), some [!ProcInfo] ( map.lookup(ProcTable, ProcId, !:ProcInfo), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_initial_instmap(ModuleInfo, !.ProcInfo, InstMap0), proc_info_get_goal(!.ProcInfo, Goal0), @@ -245,8 +244,7 @@ delay_partial_inst_proc(ModuleInfo, PredId, ProcTable, ProcId, ( Changed = yes, proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), requantify_proc_general(ordinary_nonlocals_maybe_lambda, !ProcInfo), !:ChangedProcs = [ProcId - !.ProcInfo | !.ChangedProcs], diff --git a/compiler/dep_par_conj.m b/compiler/dep_par_conj.m index c45809358..10a76e758 100644 --- a/compiler/dep_par_conj.m +++ b/compiler/dep_par_conj.m @@ -287,8 +287,7 @@ sync_dep_par_conjs_in_proc(PredId, ProcId, IgnoreVars, !ModuleInfo, module_info_pred_proc_info(!.ModuleInfo, PredId, ProcId, !:PredInfo, !:ProcInfo), proc_info_get_goal(!.ProcInfo, !:Goal), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InstMap0), module_info_get_globals(!.ModuleInfo, Globals), globals.get_opt_tuple(Globals, OptTuple), @@ -337,8 +336,7 @@ sync_dep_par_conjs_in_proc(PredId, ProcId, IgnoreVars, !ModuleInfo, % We really only need to run this part if something changed, but we % only run this predicate on procedures which are likely to have % parallel conjunctions. - proc_info_set_varset(!.VarSet, !ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo), proc_info_set_goal(!.Goal, !ProcInfo), fixup_and_reinsert_proc(PredId, ProcId, !.PredInfo, !.ProcInfo, !ModuleInfo), @@ -1558,7 +1556,7 @@ find_specialization_requests_in_proc(DoneProcs, InitialModuleInfo, PredProcId, some [!PredInfo, !ProcInfo, !Goal, !SpecInfo] ( module_info_pred_proc_info(!.ModuleInfo, PredId, ProcId, !:PredInfo, !:ProcInfo), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, VarTypes), proc_info_get_goal(!.ProcInfo, !:Goal), !:SpecInfo = spec_info(DoneProcs, !.RevProcMap, InitialModuleInfo, PredProcId, VarTypes, !.ModuleInfo, !.PendingParProcs, @@ -1578,7 +1576,6 @@ find_specialization_requests_in_proc(DoneProcs, InitialModuleInfo, PredProcId, then io.output_stream(Stream, !IO), OutInfo = init_hlds_out_info(Globals, output_debug), - proc_info_get_varset(!.ProcInfo, VarSet), io.format(Stream, "About to search %d/%d for dependant par conjs:\n", [i(PredIdInt), i(proc_id_to_int(ProcId))], !IO), @@ -1647,8 +1644,7 @@ add_requested_specialized_par_proc(CallPattern, NewProc, !PendingParProcs, % parallel conjunctions. module_info_proc_info(InitialModuleInfo, OldPredId, OldProcId, !:NewProcInfo), - proc_info_get_varset(!.NewProcInfo, !:VarSet), - proc_info_get_vartypes(!.NewProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.NewProcInfo, !:VarSet, !:VarTypes), proc_info_get_headvars(!.NewProcInfo, HeadVars0), proc_info_get_argmodes(!.NewProcInfo, ArgModes0), proc_info_get_goal(!.NewProcInfo, Goal0), @@ -1672,8 +1668,7 @@ add_requested_specialized_par_proc(CallPattern, NewProc, !PendingParProcs, sync_dep_par_proc_body(!.ModuleInfo, AllowSomePathsOnly, SharedVars, FutureMap, InstMap0, Goal0, Goal, !VarSet, !VarTypes), - proc_info_set_varset(!.VarSet, !NewProcInfo), - proc_info_set_vartypes(!.VarTypes, !NewProcInfo), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !NewProcInfo), proc_info_set_headvars(HeadVars, !NewProcInfo), proc_info_set_argmodes(ArgModes, !NewProcInfo), proc_info_set_goal(Goal, !NewProcInfo), diff --git a/compiler/det_analysis.m b/compiler/det_analysis.m index 6d93445e2..4d5415d7a 100644 --- a/compiler/det_analysis.m +++ b/compiler/det_analysis.m @@ -351,8 +351,7 @@ det_infer_proc(PredId, ProcId, !ModuleInfo, OldDetism, NewDetism, !Specs) :- % Infer the determinism of the goal. proc_info_get_goal(ProcInfo0, Goal0), proc_info_get_initial_instmap(!.ModuleInfo, ProcInfo0, InstMap0), - proc_info_get_varset(ProcInfo0, VarSet), - proc_info_get_vartypes(ProcInfo0, VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, VarSet, VarTypes), det_info_init(!.ModuleInfo, proc(PredId, ProcId), VarSet, VarTypes, pess_extra_vars_report, !.Specs, DetInfo0), det_infer_goal(Goal0, Goal, InstMap0, SolnContext, [], no, @@ -1131,7 +1130,7 @@ det_infer_call(PredId, ProcId0, ProcId, Args, GoalInfo, SolnContext, else GoalContext = goal_info_get_context(GoalInfo), det_get_proc_info(!.DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), PredPieces = describe_one_pred_name(ModuleInfo, should_module_qualify, PredId), FirstPieces = [words("Error: call to")] ++ PredPieces ++ @@ -1182,7 +1181,7 @@ det_infer_generic_call(GenericCall, CallDetism, GoalInfo, % This error can only occur for higher-order calls. % Class method calls are only introduced by polymorphism. det_get_proc_info(!.DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), FirstPieces = [words("Error: higher-order call to predicate with"), words("determinism"), quote(mercury_det_to_string(CallDetism)), words("occurs in a context which requires all solutions."), nl], @@ -1254,7 +1253,7 @@ det_infer_foreign_proc(Attributes, PredId, ProcId, _PragmaCode, SolnContext = all_solns then GoalContext = goal_info_get_context(GoalInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), WrongContextPredPieces = describe_one_pred_name(ModuleInfo, should_module_qualify, PredId), WrongContextFirstPieces = [words("Error: call to")] ++ @@ -1633,7 +1632,7 @@ det_infer_scope(Reason, Goal0, Goal, GoalInfo, InstMap0, SolnContext, ( Reason = promise_solutions(Vars, Kind), det_get_proc_info(!.DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), Context = goal_info_get_context(GoalInfo), ( @@ -1732,7 +1731,7 @@ det_infer_scope(Reason, Goal0, Goal, GoalInfo, InstMap0, SolnContext, var_is_any_in_instmap(ModuleInfo, InstMap0), NonLocalVars), BoundVars0 = set_of_var.union(GroundBoundVars, AnyBoundVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), BoundVars = remove_typeinfo_vars_from_set_of_var(VarTypes, BoundVars0), % Which vars were bound inside the scope but not listed @@ -1954,14 +1953,13 @@ det_check_for_noncanonical_type(Var, ExaminesRepresentation, CanFail, ExaminesRepresentation = yes, det_get_proc_info(!.DetInfo, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), det_type_has_user_defined_equality_pred(!.DetInfo, Type) then ( CanFail = can_fail, Context = goal_info_get_context(GoalInfo), - proc_info_get_varset(ProcInfo, VarSet), ( GoalContext = ccuc_switch, VarStr = mercury_var_to_name_only(VarSet, Var), @@ -2004,7 +2002,6 @@ det_check_for_noncanonical_type(Var, ExaminesRepresentation, CanFail, ( SolnContext = all_solns, Context = goal_info_get_context(GoalInfo), - proc_info_get_varset(ProcInfo, VarSet), ( GoalContext = ccuc_switch, VarStr = mercury_var_to_name_only(VarSet, Var), diff --git a/compiler/det_report.m b/compiler/det_report.m index 97f0253ba..49a0901c0 100644 --- a/compiler/det_report.m +++ b/compiler/det_report.m @@ -254,8 +254,7 @@ check_determinism_of_pred(PredProcId, !ModuleInfo, !Specs) :- ; Cmp = first_detism_incomparable ), proc_info_get_goal(ProcInfo, Goal), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_initial_instmap(!.ModuleInfo, ProcInfo, InstMap0), det_info_init(!.ModuleInfo, PredProcId, VarSet, VarTypes, pess_extra_vars_report, [], DetInfo0), @@ -359,8 +358,7 @@ make_reqscope_checks_if_needed(ModuleInfo, PredProcId, PredInfo, ProcInfo, ) then proc_info_get_goal(ProcInfo, Goal), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_initial_instmap(ModuleInfo, ProcInfo, InstMap0), det_info_init(ModuleInfo, PredProcId, VarSet, VarTypes, pess_extra_vars_ignore, [], DetInfo0), @@ -1571,8 +1569,7 @@ reqscope_check_goal_detism_for_cases(RequiredDetism, Var, VarType, generate_error_not_switch_on_required_var(RequiredVar, ScopeWord, ScopeGoalInfo, !DetInfo) :- - det_get_proc_info(!.DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + det_info_get_varset(!.DetInfo, VarSet), RequiredVarStr = mercury_var_to_name_only(VarSet, RequiredVar), Pieces = [words("Error: the goal inside the"), words(ScopeWord), fixed("[" ++ RequiredVarStr ++ "]"), words("scope"), @@ -1679,8 +1676,7 @@ find_missing_cons_ids(DetInfo, MaybeLimit, InstMap0, SwitchContexts, Var, Cases, NestingPieces, VarStr, MaybeMissingInfo) :- det_diagnose_switch_context(DetInfo, SwitchContexts, NestingPieces), - det_get_proc_info(DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + det_info_get_varset(DetInfo, VarSet), VarStr = mercury_var_to_name_only(VarSet, Var), det_info_get_module_info(DetInfo, ModuleInfo), instmap_lookup_var(InstMap0, Var, VarInst), @@ -1688,6 +1684,7 @@ find_missing_cons_ids(DetInfo, MaybeLimit, InstMap0, SwitchContexts, det_info_get_vartypes(DetInfo, VarTypes), lookup_var_type(VarTypes, Var, VarType), type_to_ctor_det(VarType, VarTypeCtor), + module_info_get_type_table(ModuleInfo, TypeTable), ( if inst_is_bound_to_functors(ModuleInfo, VarInst, BoundInsts) then @@ -1703,7 +1700,7 @@ find_missing_cons_ids(DetInfo, MaybeLimit, InstMap0, SwitchContexts, % only for the switch variable's type is a du type, and not % a builtin type such as int or string. ( if - det_lookup_var_type(ModuleInfo, ProcInfo, Var, TypeDefn), + search_type_ctor_defn(TypeTable, VarTypeCtor, TypeDefn), hlds_data.get_type_defn_body(TypeDefn, TypeBody), TypeBody = hlds_du_type(TypeBodyDu), TypeBodyDu = type_body_du(TypeConstructors, _, _, _, _) @@ -1719,7 +1716,7 @@ find_missing_cons_ids(DetInfo, MaybeLimit, InstMap0, SwitchContexts, PossibleConsIdsSet = BoundConsIdsSet ) else - det_lookup_var_type(ModuleInfo, ProcInfo, Var, TypeDefn), + search_type_ctor_defn(TypeTable, VarTypeCtor, TypeDefn), hlds_data.get_type_defn_body(TypeDefn, TypeBody), TypeBody = hlds_du_type(TypeBodyDu), TypeBodyDu = type_body_du(TypeConstructors, _, _, _, _), @@ -1882,7 +1879,7 @@ det_diagnose_switch_context(_, [], []). det_diagnose_switch_context(DetInfo, [SwitchContext | SwitchContexts], Pieces) :- det_get_proc_info(DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), SwitchContext = switch_context(Var, MainMatch, OtherMatches), MainMatchStr = switch_match_to_string(VarSet, MainMatch), OtherMatchStrs = list.map(switch_match_to_string(VarSet), OtherMatches), @@ -1974,7 +1971,7 @@ det_report_unify_context(!.First, Last, _Context, UnifyContext, DetInfo, unify_context_first_to_pieces(!First, UnifyContext, [], UnifyContextPieces), det_get_proc_info(DetInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), det_info_get_module_info(DetInfo, ModuleInfo), ( !.First = is_first, diff --git a/compiler/det_util.m b/compiler/det_util.m index e995351ef..86851daf7 100644 --- a/compiler/det_util.m +++ b/compiler/det_util.m @@ -19,7 +19,6 @@ :- interface. :- import_module hlds. -:- import_module hlds.hlds_data. :- import_module hlds.hlds_goal. :- import_module hlds.hlds_module. :- import_module hlds.hlds_pred. @@ -106,9 +105,6 @@ :- pred det_get_proc_info(det_info::in, proc_info::out) is det. -:- pred det_lookup_var_type(module_info::in, proc_info::in, prog_var::in, - hlds_type_defn::out) is semidet. - :- pred det_no_output_vars(det_info::in, instmap::in, instmap_delta::in, set_of_progvar::in) is semidet. @@ -144,7 +140,6 @@ :- implementation. -:- import_module parse_tree.prog_type. :- import_module parse_tree.prog_util. :- import_module map. @@ -223,16 +218,9 @@ det_get_proc_info(DetInfo, ProcInfo) :- det_info_get_pred_proc_id(DetInfo, PredProcId), module_info_proc_info(ModuleInfo, PredProcId, ProcInfo). -det_lookup_var_type(ModuleInfo, ProcInfo, Var, TypeDefn) :- - proc_info_get_vartypes(ProcInfo, VarTypes), - lookup_var_type(VarTypes, Var, Type), - type_to_ctor_det(Type, TypeCtor), - module_info_get_type_table(ModuleInfo, TypeTable), - search_type_ctor_defn(TypeTable, TypeCtor, TypeDefn). - det_no_output_vars(DetInfo, InstMap, InstMapDelta, Vars) :- det_info_get_module_info(DetInfo, ModuleInfo), - VarTypes = DetInfo ^ di_vartypes, + det_info_get_vartypes(DetInfo, VarTypes), instmap_delta_no_output_vars(ModuleInfo, VarTypes, InstMap, InstMapDelta, Vars). diff --git a/compiler/direct_arg_in_out.m b/compiler/direct_arg_in_out.m index 7f44e3e2c..f280ff93d 100644 --- a/compiler/direct_arg_in_out.m +++ b/compiler/direct_arg_in_out.m @@ -995,8 +995,7 @@ transform_direct_arg_in_out_calls_in_proc(DirectArgProcMap, "Direct arg in out transforming", PredId, ProcId, !IO) ) ), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_goal(!.ProcInfo, Goal0), module_info_get_name(!.ModuleInfo, ModuleName), trace [compile_time(flag("daio-debug")), io(!IO)] ( @@ -1013,8 +1012,7 @@ transform_direct_arg_in_out_calls_in_proc(DirectArgProcMap, PredProcId = proc(PredId, ProcId), proc_info_get_headvars(!.ProcInfo, HeadVars0), Info = daio_info(_, _, VarSet, VarTypes, CloneForeignProcs), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo), ( if diff --git a/compiler/disj_gen.m b/compiler/disj_gen.m index 404634196..37b4d3956 100644 --- a/compiler/disj_gen.m +++ b/compiler/disj_gen.m @@ -44,6 +44,7 @@ :- import_module backend_libs.builtin_ops. :- import_module hlds.goal_form. :- import_module hlds.hlds_llds. +:- import_module hlds.var_table. :- import_module libs. :- import_module libs.globals. :- import_module libs.optimization_options. @@ -168,7 +169,7 @@ is_lookup_disj(AddTrailOps, AddRegionOps, ResumeVars, Disjuncts, DisjGoalInfo, figure_out_output_vars(!.CI, !.CLD, DisjGoalInfo, OutVars), get_var_table(!.CI, VarTable), - OutTypes = list.map(var_table_type(VarTable), OutVars), + OutTypes = list.map(lookup_var_type_func(VarTable), OutVars), produce_vars(set_of_var.to_sorted_list(ResumeVars), ResumeMap, FlushCode, !CLD), diff --git a/compiler/equiv_type_hlds.m b/compiler/equiv_type_hlds.m index 202a0f3f0..d9c2fa177 100644 --- a/compiler/equiv_type_hlds.m +++ b/compiler/equiv_type_hlds.m @@ -293,7 +293,7 @@ replace_in_inst_table(TypeEqvMap, !InstTable, !Cache) :- % % inst_table_get_user_insts(!.InstTable, UserInsts0), % map.map_values( -% (pred(_::in, Defn0::in, Defn::out) is det :- +% ( pred(_::in, Defn0::in, Defn::out) is det :- % Body0 = Defn0 ^ inst_body, % ( % Body0 = abstract_inst, @@ -655,15 +655,15 @@ replace_in_proc(TypeEqvMap, !ProcInfo, !ModuleInfo, !PredInfo, !Cache) :- MaybeDeclModes0 = no ), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, VarTypes0), transform_foldl_var_types(hlds_replace_in_type(TypeEqvMap), VarTypes0, VarTypes, !TVarSet), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), rtti_varmaps_types(RttiVarMaps0, AllTypes), list.foldl2( - (pred(OldType::in, !.TMap::in, !:TMap::out, + ( pred(OldType::in, !.TMap::in, !:TMap::out, !.TVarSet::in, !:TVarSet::out) is det :- hlds_replace_in_type(TypeEqvMap, OldType, NewType, !TVarSet), map.set(OldType, NewType, !TMap) @@ -1604,7 +1604,7 @@ replace_in_goal_expr(TypeEqvMap, GoalExpr0, GoalExpr, Changed, !Info) :- ; GoalExpr0 = unify(Var, _, _, _, _), module_info_get_type_table(!.Info ^ ethri_module_info, TypeTable), - proc_info_get_vartypes(!.Info ^ ethri_proc_info, VarTypes), + proc_info_get_varset_vartypes(!.Info ^ ethri_proc_info, _, VarTypes), proc_info_get_rtti_varmaps(!.Info ^ ethri_proc_info, RttiVarMaps), lookup_var_type(VarTypes, Var, VarType), TypeCtorCat = classify_type(!.Info ^ ethri_module_info, VarType), diff --git a/compiler/exception_analysis.m b/compiler/exception_analysis.m index 2d5db8bf9..8ecf91dd5 100644 --- a/compiler/exception_analysis.m +++ b/compiler/exception_analysis.m @@ -328,7 +328,7 @@ maybe_analysis_status(ProcResult, ProcResult ^ epr_maybe_analysis_status). check_proc_for_exceptions(SCC, PPId, !Results, !ModuleInfo) :- module_info_pred_proc_info(!.ModuleInfo, PPId, _, ProcInfo), proc_info_get_goal(ProcInfo, Body), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), module_info_get_globals(!.ModuleInfo, Globals), globals.lookup_bool_option(Globals, intermodule_analysis, IntermodAnalysis), diff --git a/compiler/float_regs.m b/compiler/float_regs.m index 53df775bd..f575fd6dc 100644 --- a/compiler/float_regs.m +++ b/compiler/float_regs.m @@ -517,8 +517,7 @@ insert_reg_wrappers_proc_2(!ProcInfo, !PredInfo, !ModuleInfo, !Specs) :- % Grab the appropriate fields from the pred_info and proc_info. pred_info_get_typevarset(!.PredInfo, TypeVarSet0), proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_argmodes(!.ProcInfo, ArgModes), proc_info_get_goal(!.ProcInfo, Goal0), proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InstMap0), @@ -562,8 +561,7 @@ insert_reg_wrappers_proc_2(!ProcInfo, !PredInfo, !ModuleInfo, !Specs) :- % Set the new values of the fields in proc_info and pred_info. proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), proc_info_set_headvars(HeadVars, !ProcInfo), ensure_all_headvars_are_named(!ProcInfo), diff --git a/compiler/follow_code.m b/compiler/follow_code.m index c015d7d28..bde90c013 100644 --- a/compiler/follow_code.m +++ b/compiler/follow_code.m @@ -66,8 +66,7 @@ move_follow_code_in_proc(_PredProcId, !ProcInfo, !ModuleInfo) :- proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, Varset0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, Varset0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), move_follow_code_in_goal(Goal0, Goal1, RttiVarMaps0, no, Changed), ( @@ -85,8 +84,7 @@ move_follow_code_in_proc(_PredProcId, !ProcInfo, !ModuleInfo) :- recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas, Goal2, Goal, VarTypes, InstVarSet, InstMap0, !ModuleInfo), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(Varset, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(Varset, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo) ; Changed = no diff --git a/compiler/goal_mode.m b/compiler/goal_mode.m index 94ccbcd11..a989ab72f 100644 --- a/compiler/goal_mode.m +++ b/compiler/goal_mode.m @@ -214,7 +214,7 @@ compute_goal_modes_in_pred(ModuleInfo, ValidPredIds, PredId, !PredInfo) :- compute_goal_modes_in_proc(ModuleInfo, !ProcInfo) :- ( if proc_info_is_valid_mode(!.ProcInfo) then - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_initial_instmap(ModuleInfo, !.ProcInfo, InstMap0), proc_info_get_goal(!.ProcInfo, Goal0), compute_goal_modes_in_goal(ModuleInfo, VarTypes, InstMap0, _InstMap, diff --git a/compiler/goal_path.m b/compiler/goal_path.m index 74cf63d4c..e5457638d 100644 --- a/compiler/goal_path.m +++ b/compiler/goal_path.m @@ -86,7 +86,7 @@ ). fill_goal_id_slots_in_proc(ModuleInfo, ContainingGoalMap, !ProcInfo) :- - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_goal(!.ProcInfo, Goal0), fill_goal_id_slots_in_proc_body(ModuleInfo, VarTypes, ContainingGoalMap, Goal0, Goal), @@ -328,7 +328,7 @@ fill_orelse_id_slots(SlotInfo, GoalId, LastOrElseNum, !GoalNumCounter, fill_goal_path_slots_in_proc(ModuleInfo, !Proc) :- proc_info_get_goal(!.Proc, Goal0), - proc_info_get_vartypes(!.Proc, VarTypes), + proc_info_get_varset_vartypes(!.Proc, _VarSet, VarTypes), SlotInfo = slot_info(ModuleInfo, VarTypes), fill_goal_path_slots(rgp_nil, SlotInfo, Goal0, Goal), proc_info_set_goal(Goal, !Proc). diff --git a/compiler/higher_order.m b/compiler/higher_order.m index 8fc821233..c53286a7f 100644 --- a/compiler/higher_order.m +++ b/compiler/higher_order.m @@ -527,7 +527,7 @@ ho_fixup_proc_info(MustRecompute, !.Goal, !Info) :- requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), proc_info_get_goal(!.ProcInfo, !:Goal), proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InstMap), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_inst_varset(!.ProcInfo, InstVarSet), recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas, !Goal, VarTypes, InstVarSet, InstMap, !ModuleInfo), @@ -1412,7 +1412,7 @@ maybe_specialize_pred_const(hlds_goal(GoalExpr0, GoalInfo), PredProcId = unshroud_pred_proc_id(ShroudedPredProcId), proc(PredId, ProcId) = PredProcId, map.contains(NewPredMap, PredProcId), - proc_info_get_vartypes(ProcInfo0, VarTypes0), + proc_info_get_varset_vartypes(ProcInfo0, _VarSet0, VarTypes0), lookup_var_type(VarTypes0, LVar, LVarType), type_is_higher_order_details(LVarType, _, _, _, ArgTypes) then @@ -1465,9 +1465,11 @@ maybe_specialize_pred_const(hlds_goal(GoalExpr0, GoalInfo), % The dummy arguments can't be used anywhere. ProcInfo2 = !.Info ^ hoi_proc_info, - proc_info_get_vartypes(ProcInfo2, VarTypes2), + proc_info_get_varset_vartypes(ProcInfo2, VarSet2, VarTypes2), + varset.delete_vars(UncurriedArgs, VarSet2, VarSet), delete_var_types(UncurriedArgs, VarTypes2, VarTypes), - proc_info_set_vartypes(VarTypes, ProcInfo2, ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, + ProcInfo2, ProcInfo), !Info ^ hoi_proc_info := ProcInfo, NewPredProcId = proc(NewPredId, NewProcId), @@ -1525,12 +1527,13 @@ maybe_specialize_ordinary_call(CanRequest, CalledPred, CalledProc, MaybeContext, GoalInfo, Result, !Info) :- ModuleInfo0 = !.Info ^ hoi_global_info ^ hogi_module_info, pred_info_get_status(CalleePredInfo, CalleeStatus), - proc_info_get_vartypes(CalleeProcInfo, CalleeVarTypes), + proc_info_get_varset_vartypes(CalleeProcInfo, + _CalleeVarSet, CalleeVarTypes), proc_info_get_headvars(CalleeProcInfo, CalleeHeadVars), lookup_var_types(CalleeVarTypes, CalleeHeadVars, CalleeArgTypes), CallerProcInfo0 = !.Info ^ hoi_proc_info, - proc_info_get_vartypes(CallerProcInfo0, VarTypes), + proc_info_get_varset_vartypes(CallerProcInfo0, _VarSet, VarTypes), proc_info_get_rtti_varmaps(CallerProcInfo0, RttiVarMaps), find_higher_order_args(ModuleInfo0, CalleeStatus, Args0, CalleeArgTypes, VarTypes, RttiVarMaps, !.Info ^ hoi_known_var_map, 1, @@ -1777,7 +1780,7 @@ find_matching_version(Info, CalledPred, CalledProc, Args0, Context, get_extra_arguments(HigherOrderArgs, Args0, Args), compute_extra_typeinfos(Info, Args, ExtraTypeInfoTVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, Args0, CallArgTypes), pred_info_get_typevarset(PredInfo, TVarSet), @@ -1849,7 +1852,7 @@ compute_extra_typeinfos(Info, Args, ExtraTypeInfoTVars) :- % because the type variables are returned sorted by variable number, % which will vary between calls). ProcInfo = Info ^ hoi_proc_info, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, Args, ArgTypes), type_vars_list(ArgTypes, AllTVars), ( @@ -2197,7 +2200,7 @@ interpret_typeclass_info_manipulator(Manipulator, Args, Goal0, Goal, !Info) :- !Info ^ hoi_proc_info := ProcInfo, % Sanity check. - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, OutputVar, OutputVarType), lookup_var_type(VarTypes, SelectedArg, SelectedArgType), ( if OutputVarType = SelectedArgType then @@ -2310,7 +2313,7 @@ specialize_special_pred(CalledPred, CalledProc, Args, MaybeContext, ModuleInfo = !.Info ^ hoi_global_info ^ hogi_module_info, ProcInfo0 = !.Info ^ hoi_proc_info, KnownVarMap = !.Info ^ hoi_known_var_map, - proc_info_get_vartypes(ProcInfo0, VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, _VarSet, VarTypes), module_info_pred_info(ModuleInfo, CalledPred, CalledPredInfo), mercury_public_builtin_module = pred_info_module(CalledPredInfo), pred_info_module(CalledPredInfo) = mercury_public_builtin_module, @@ -3097,7 +3100,7 @@ create_new_proc(NewPred, !.NewProcInfo, !NewPredInfo, !GlobalInfo) :- pred_info_get_univ_quant_tvars(CallerPredInfo, CallerHeadParams), % Specialize the types of the called procedure as for inlining. - proc_info_get_vartypes(!.NewProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.NewProcInfo, VarSet0, VarTypes0), tvarset_merge_renaming(CallerTypeVarSet, TypeVarSet0, TypeVarSet, TypeRenaming), apply_variable_renaming_to_tvar_kind_map(TypeRenaming, KindMap0, KindMap), @@ -3122,7 +3125,7 @@ create_new_proc(NewPred, !.NewProcInfo, !NewPredInfo, !GlobalInfo) :- apply_rec_subst_to_vartypes(TypeSubn, VarTypes1, VarTypes2), apply_rec_subst_to_type_list(TypeSubn, OriginalArgTypes1, OriginalArgTypes), - proc_info_set_vartypes(VarTypes2, !NewProcInfo), + proc_info_set_varset_vartypes(VarSet0, VarTypes2, !NewProcInfo), % XXX kind inference: we assume vars have kind `star'. prog_type.var_list_to_type_list(map.init, ExtraTypeInfoTVars0, @@ -3249,7 +3252,7 @@ create_new_proc(NewPred, !.NewProcInfo, !NewPredInfo, !GlobalInfo) :- proc_info_reset_imported_structure_sharing(!NewProcInfo), proc_info_reset_imported_structure_reuse(!NewProcInfo), - proc_info_get_vartypes(!.NewProcInfo, VarTypes7), + proc_info_get_varset_vartypes(!.NewProcInfo, VarSet7, VarTypes7), lookup_var_types(VarTypes7, ExtraHeadVars, ExtraHeadVarTypes0), remove_const_higher_order_args(1, OriginalArgTypes, HOArgs, ModifiedOriginalArgTypes), @@ -3283,7 +3286,7 @@ create_new_proc(NewPred, !.NewProcInfo, !NewPredInfo, !GlobalInfo) :- ExtraHeadVarTypes, ExtraHeadVarsAndTypes), list.foldl(update_var_types, ExtraHeadVarsAndTypes, VarTypes7, VarTypes8), - proc_info_set_vartypes(VarTypes8, !NewProcInfo) + proc_info_set_varset_vartypes(VarSet7, VarTypes8, !NewProcInfo) ), % Find the new class context. diff --git a/compiler/hlds_out_pred.m b/compiler/hlds_out_pred.m index 1f28f9454..b775231ac 100644 --- a/compiler/hlds_out_pred.m +++ b/compiler/hlds_out_pred.m @@ -761,8 +761,7 @@ write_proc(Info, Stream, VarNamePrint, ModuleInfo, PredId, PredInfo, ProcId, ProcInfo, !IO) :- pred_info_get_typevarset(PredInfo, TVarSet), proc_info_get_can_process(ProcInfo, CanProcess), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_declared_determinism(ProcInfo, DeclaredDeterminism), proc_info_get_inferred_determinism(ProcInfo, InferredDeterminism), proc_info_get_headvars(ProcInfo, HeadVars), diff --git a/compiler/hlds_pred.m b/compiler/hlds_pred.m index 5ddcc4366..959886309 100644 --- a/compiler/hlds_pred.m +++ b/compiler/hlds_pred.m @@ -1357,8 +1357,7 @@ pred_info_create(PredOrFunc, PredModuleName, PredName, Context, Origin, Status, UnprovenBodyConstraints, InstGraphInfo, ArgModesMaps, VarNameRemap, Assertions, ObsoleteInFavourOf, InstanceMethodArgTypes), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), map.init(TVarNameMap), proc_info_get_headvars(ProcInfo, HeadVars), HeadVarVec = proc_arg_vector_init(PredOrFunc, HeadVars), @@ -2157,9 +2156,9 @@ marker_list_to_markers(Markers, MarkerSet) :- dob_body :: hlds_goal, dob_head_vars :: list(prog_var), dob_instmap :: instmap, + dob_varset :: prog_varset, dob_vartypes :: vartypes, - dob_detism :: determinism, - dob_varset :: prog_varset + dob_detism :: determinism ). :- type table_arg_infos @@ -2476,8 +2475,8 @@ marker_list_to_markers(Markers, MarkerSet) :- :- pred proc_info_get_headvars(proc_info::in, list(prog_var)::out) is det. :- pred proc_info_get_goal(proc_info::in, hlds_goal::out) is det. -:- pred proc_info_get_varset(proc_info::in, prog_varset::out) is det. -:- pred proc_info_get_vartypes(proc_info::in, vartypes::out) is det. +:- pred proc_info_get_varset_vartypes(proc_info::in, + prog_varset::out, vartypes::out) is det. :- pred proc_info_get_rtti_varmaps(proc_info::in, rtti_varmaps::out) is det. :- pred proc_info_get_inst_varset(proc_info::in, inst_varset::out) is det. :- pred proc_info_get_maybe_declared_argmodes(proc_info::in, @@ -2560,9 +2559,7 @@ marker_list_to_markers(Markers, MarkerSet) :- proc_info::in, proc_info::out) is det. :- pred proc_info_set_goal(hlds_goal::in, proc_info::in, proc_info::out) is det. -:- pred proc_info_set_varset(prog_varset::in, - proc_info::in, proc_info::out) is det. -:- pred proc_info_set_vartypes(vartypes::in, +:- pred proc_info_set_varset_vartypes(prog_varset::in, vartypes::in, proc_info::in, proc_info::out) is det. :- pred proc_info_set_rtti_varmaps(rtti_varmaps::in, proc_info::in, proc_info::out) is det. @@ -3593,10 +3590,9 @@ proc_info_get_headvars(PI, X) :- X = PI ^ proc_head_vars. proc_info_get_goal(PI, X) :- X = PI ^ proc_body. -proc_info_get_varset(PI, X) :- - X = PI ^ proc_prog_varset. -proc_info_get_vartypes(PI, X) :- - X = PI ^ proc_var_types. +proc_info_get_varset_vartypes(PI, X, Y) :- + X = PI ^ proc_prog_varset, + Y = PI ^ proc_var_types. proc_info_get_rtti_varmaps(PI, X) :- X = PI ^ proc_rtti_varmaps. proc_info_get_inst_varset(PI, X) :- @@ -3687,10 +3683,9 @@ proc_info_set_headvars(X, !PI) :- !PI ^ proc_head_vars := X. proc_info_set_goal(X, !PI) :- !PI ^ proc_body := X. -proc_info_set_varset(X, !PI) :- - !PI ^ proc_prog_varset := X. -proc_info_set_vartypes(X, !PI) :- - !PI ^ proc_var_types := X. +proc_info_set_varset_vartypes(X, Y, !PI) :- + !PI ^ proc_prog_varset := X, + !PI ^ proc_var_types := Y. proc_info_set_rtti_varmaps(X, !PI) :- !PI ^ proc_rtti_varmaps := X. proc_info_set_inst_varset(X, !PI) :- @@ -3900,54 +3895,51 @@ proc_info_get_initial_instmap(ModuleInfo, ProcInfo, InstMap) :- InstMap = instmap_from_assoc_list(InstAL). proc_info_ensure_unique_names(!ProcInfo) :- - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes), vartypes_vars(VarTypes, AllVars), - proc_info_get_varset(!.ProcInfo, VarSet0), varset.ensure_unique_names(AllVars, "p", VarSet0, VarSet), - proc_info_set_varset(VarSet, !ProcInfo). + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo). proc_info_create_var_from_type(Type, MaybeName, NewVar, !ProcInfo) :- - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), varset.new_maybe_named_var(MaybeName, NewVar, VarSet0, VarSet), add_var_type(NewVar, Type, VarTypes0, VarTypes), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo). + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo). proc_info_create_vars_from_types(Types, NewVars, !ProcInfo) :- list.length(Types, NumVars), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), varset.new_vars(NumVars, NewVars, VarSet0, VarSet), vartypes_add_corresponding_lists(NewVars, Types, VarTypes0, VarTypes), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo). + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo). proc_info_instantiated_head_vars(ModuleInfo, ProcInfo, ChangedInstHeadVars) :- proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_argmodes(ProcInfo, ArgModes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), assoc_list.from_corresponding_lists(HeadVars, ArgModes, HeadVarModes), - IsInstChanged = (pred(VarMode::in, Var::out) is semidet :- - VarMode = Var - Mode, - lookup_var_type(VarTypes, Var, Type), - mode_get_insts(ModuleInfo, Mode, Inst1, Inst2), - not inst_matches_binding(ModuleInfo, Type, Inst1, Inst2) - ), + IsInstChanged = + ( pred(VarMode::in, Var::out) is semidet :- + VarMode = Var - Mode, + lookup_var_type(VarTypes, Var, Type), + mode_get_insts(ModuleInfo, Mode, Inst1, Inst2), + not inst_matches_binding(ModuleInfo, Type, Inst1, Inst2) + ), list.filter_map(IsInstChanged, HeadVarModes, ChangedInstHeadVars). proc_info_uninstantiated_head_vars(ModuleInfo, ProcInfo, UnchangedInstHeadVars) :- proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_argmodes(ProcInfo, ArgModes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), assoc_list.from_corresponding_lists(HeadVars, ArgModes, HeadVarModes), - IsInstUnchanged = (pred(VarMode::in, Var::out) is semidet :- - VarMode = Var - Mode, - lookup_var_type(VarTypes, Var, Type), - mode_get_insts(ModuleInfo, Mode, Inst1, Inst2), - inst_matches_binding(ModuleInfo, Type, Inst1, Inst2) - ), + IsInstUnchanged = + ( pred(VarMode::in, Var::out) is semidet :- + VarMode = Var - Mode, + lookup_var_type(VarTypes, Var, Type), + mode_get_insts(ModuleInfo, Mode, Inst1, Inst2), + inst_matches_binding(ModuleInfo, Type, Inst1, Inst2) + ), list.filter_map(IsInstUnchanged, HeadVarModes, UnchangedInstHeadVars). proc_interface_should_use_typeinfo_liveness(PredInfo, ProcId, Globals, @@ -4032,7 +4024,7 @@ non_special_body_should_use_typeinfo_liveness(Globals, BodyTypeInfoLiveness) :- proc_info_has_io_state_pair(ModuleInfo, ProcInfo, InArgNum, OutArgNum) :- proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_argmodes(ProcInfo, ArgModes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_has_io_state_pair_from_details(ModuleInfo, HeadVars, ArgModes, VarTypes, InArgNum, OutArgNum). @@ -4129,22 +4121,22 @@ proc_info_is_valid_mode(ProcInfo) :- ensure_all_headvars_are_named(!ProcInfo) :- proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_varset(!.ProcInfo, VarSet0), - ensure_all_headvars_are_named_2(HeadVars, 1, VarSet0, VarSet), - proc_info_set_varset(VarSet, !ProcInfo). + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), + ensure_all_headvars_are_named_loop(HeadVars, 1, VarSet0, VarSet), + proc_info_set_varset_vartypes(VarSet, VarTypes0, !ProcInfo). -:- pred ensure_all_headvars_are_named_2(list(prog_var)::in, int::in, +:- pred ensure_all_headvars_are_named_loop(list(prog_var)::in, int::in, prog_varset::in, prog_varset::out) is det. -ensure_all_headvars_are_named_2([], _, !VarSet). -ensure_all_headvars_are_named_2([Var | Vars], SeqNum, !VarSet) :- +ensure_all_headvars_are_named_loop([], _, !VarSet). +ensure_all_headvars_are_named_loop([Var | Vars], SeqNum, !VarSet) :- ( if varset.search_name(!.VarSet, Var, _Name) then true else Name = "HeadVar__" ++ int_to_string(SeqNum), varset.name_var(Var, Name, !VarSet) ), - ensure_all_headvars_are_named_2(Vars, SeqNum + 1, !VarSet). + ensure_all_headvars_are_named_loop(Vars, SeqNum + 1, !VarSet). var_is_of_dummy_type(ModuleInfo, VarTypes, Var) :- lookup_var_type(VarTypes, Var, Type), diff --git a/compiler/hlds_rtti.m b/compiler/hlds_rtti.m index 14d1e6001..71d4ea816 100644 --- a/compiler/hlds_rtti.m +++ b/compiler/hlds_rtti.m @@ -358,7 +358,7 @@ make_rtti_proc_label(ModuleInfo, PredId, ProcId) = ProcLabel :- PredName = pred_info_name(PredInfo), Arity = pred_info_orig_arity(PredInfo), pred_info_get_arg_types(PredInfo, ArgTypes), - proc_info_get_varset(ProcInfo, ProcVarSet), + proc_info_get_varset_vartypes(ProcInfo, ProcVarSet, _ProcVarTypes), proc_info_get_headvars(ProcInfo, ProcHeadVars), proc_info_get_argmodes(ProcInfo, ProcModes), proc_info_interface_determinism(ProcInfo, ProcDetism), @@ -372,7 +372,7 @@ make_rtti_proc_label(ModuleInfo, PredId, ProcId) = ProcLabel :- then yes else no), pred_info_get_origin(PredInfo, Origin), ProcHeadVarsWithNames = list.map( - (func(Var) = Var - Name :- + ( func(Var) = Var - Name :- Name = varset.lookup_name(ProcVarSet, Var) ), ProcHeadVars), ( if diff --git a/compiler/hlds_statistics.m b/compiler/hlds_statistics.m index dfd379fd4..635438020 100644 --- a/compiler/hlds_statistics.m +++ b/compiler/hlds_statistics.m @@ -98,7 +98,7 @@ write_proc_stats_for_proc(OutStream, Msg, ModuleInfo, Stats0 = init_proc_stats, accumulate_proc_stats_in_goal(Goal, UsedVars0, UsedVars, Stats0, Stats), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), do_write_proc_stats(OutStream, Msg, Name, PredId, ProcId, Stats, UsedVars, VarSet, !IO). diff --git a/compiler/inlining.m b/compiler/inlining.m index 7fb9479f2..4f95bf625 100644 --- a/compiler/inlining.m +++ b/compiler/inlining.m @@ -701,8 +701,7 @@ inline_in_proc(Params, ShouldInlineProcs, ShouldInlineTailProcs, PredProcId, pred_info_get_typevarset(!.PredInfo, TypeVarSet0), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), InlineInfo0 = inline_info(!.ModuleInfo, VarThresh, HighLevelCode, @@ -719,8 +718,7 @@ inline_in_proc(Params, ShouldInlineProcs, ShouldInlineTailProcs, PredProcId, pred_info_set_typevarset(TypeVarSet, !PredInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo), @@ -910,14 +908,15 @@ inlining_in_call(GoalExpr0, GoalInfo0, Goal, !Info) :- UserReq = not_user_req, % Okay, but will we exceed the number-of-variables threshold? varset.vars(VarSet0, ListOfVars), - list.length(ListOfVars, ThisMany), + list.length(ListOfVars, NumVarsInVarSet), % We need to find out how many variables the Callee has. - proc_info_get_varset(ProcInfo, CalleeVarSet), + proc_info_get_varset_vartypes(ProcInfo, + CalleeVarSet, _CalleeVarTypes), varset.vars(CalleeVarSet, CalleeListOfVars), - list.length(CalleeListOfVars, CalleeThisMany), - TotalVars = ThisMany + CalleeThisMany, - TotalVars =< VarThresh + list.length(CalleeListOfVars, NumVarsInCallee), + TotalNumVars = NumVarsInVarSet + NumVarsInCallee, + TotalNumVars =< VarThresh ), % XXX Work around bug #142. not may_encounter_bug_142(ProcInfo, ArgVars) @@ -1011,8 +1010,7 @@ do_inline_call(ExternalTypeParams, ArgVars, PredInfo, ProcInfo, pred_info_get_typevarset(PredInfo, CalleeTypeVarSet), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, CalleeVarTypes0), - proc_info_get_varset(ProcInfo, CalleeVarSet), + proc_info_get_varset_vartypes(ProcInfo, CalleeVarSet, CalleeVarTypes0), proc_info_get_rtti_varmaps(ProcInfo, CalleeRttiVarMaps0), % Substitute the appropriate types into the type mapping of the called diff --git a/compiler/intermod.m b/compiler/intermod.m index 169c1f0ae..a2957c39c 100644 --- a/compiler/intermod.m +++ b/compiler/intermod.m @@ -433,7 +433,7 @@ pred_has_a_higher_order_input_arg(ModuleInfo, PredInfo) :- proc_has_a_higher_order_input_arg(ModuleInfo, ProcInfo) :- proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_argmodes(ProcInfo, ArgModes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), some_input_arg_is_higher_order(ModuleInfo, VarTypes, HeadVars, ArgModes). :- pred some_input_arg_is_higher_order(module_info::in, vartypes::in, diff --git a/compiler/intermod_analysis.m b/compiler/intermod_analysis.m index cef113778..cf09e3da0 100644 --- a/compiler/intermod_analysis.m +++ b/compiler/intermod_analysis.m @@ -781,7 +781,7 @@ gather_pragma_structure_sharing_for_proc(ModuleInfo, OrderPredInfo, proc_info_get_structure_sharing(ProcInfo, MaybeSharingStatus), MaybeSharingStatus = yes(SharingStatus) then - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), pred_info_get_typevarset(PredInfo, TypeVarSet), ModuleName = pred_info_module(PredInfo), PredSymName = qualified(ModuleName, PredName), @@ -789,7 +789,6 @@ gather_pragma_structure_sharing_for_proc(ModuleInfo, OrderPredInfo, PredNameModesPF = proc_pf_name_modes(PredOrFunc, PredSymName, ArgModes), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), SharingStatus = structure_sharing_domain_and_status(Sharing, _Status), SharingInfo = pragma_info_structure_sharing(PredNameModesPF, @@ -832,7 +831,7 @@ gather_pragma_structure_reuse_for_proc(ModuleInfo, OrderPredInfo, proc_info_get_structure_reuse(ProcInfo, MaybeStructureReuseDomain), MaybeStructureReuseDomain = yes(StructureReuseDomain) then - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), pred_info_get_typevarset(PredInfo, TypeVarSet), ModuleName = pred_info_module(PredInfo), PredSymName = qualified(ModuleName, PredName), @@ -840,7 +839,6 @@ gather_pragma_structure_reuse_for_proc(ModuleInfo, OrderPredInfo, PredNameModesPF = proc_pf_name_modes(PredOrFunc, PredSymName, ArgModes), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), StructureReuseDomain = structure_reuse_domain_and_status(Reuse, _Status), diff --git a/compiler/introduce_exists_casts.m b/compiler/introduce_exists_casts.m index 272106a15..3883d6374 100644 --- a/compiler/introduce_exists_casts.m +++ b/compiler/introduce_exists_casts.m @@ -124,8 +124,7 @@ introduce_exists_casts_proc(ModuleInfo, PredInfo, !ProcInfo) :- OrigArity = pred_info_orig_arity(PredInfo), NumExtraHeadVars = list.length(ArgTypes) - OrigArity, - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_headvars(!.ProcInfo, HeadVars0), proc_info_get_goal(!.ProcInfo, Body0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), diff --git a/compiler/introduce_parallelism.m b/compiler/introduce_parallelism.m index f6e444c4a..a64838c91 100644 --- a/compiler/introduce_parallelism.m +++ b/compiler/introduce_parallelism.m @@ -267,12 +267,11 @@ parallelise_proc(CPCProc, PredInfo, !ProcInfo, proc_info_get_goal(!.ProcInfo, Goal0), Context = goal_info_get_context(Goal0 ^ hg_info), term.context_file(Context, FileName), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, VarTypes), % VarNumRep is not used by goal_to_goal_rep, var_num_1_byte % is an arbitrary value. XXX zs: I don't think this is true. VarNumRep = var_num_1_byte, proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_varset(!.ProcInfo, VarSet), compute_var_number_map(HeadVars, VarSet, [], Goal0, VarNumMap), ProgRepInfo = prog_rep_info(!.ModuleInfo, FileName, VarTypes, VarNumMap, VarNumRep, flatten_par_conjs), diff --git a/compiler/lambda.m b/compiler/lambda.m index 325f078f1..456ade6eb 100644 --- a/compiler/lambda.m +++ b/compiler/lambda.m @@ -209,8 +209,7 @@ do_expand_lambdas_in_proc(!ProcInfo, !PredInfo, !ModuleInfo) :- % Grab the appropriate fields from the pred_info and proc_info. pred_info_get_typevarset(!.PredInfo, TypeVarSet0), proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_goal(!.ProcInfo, Goal0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), proc_info_get_inst_varset(!.ProcInfo, InstVarSet0), @@ -255,8 +254,7 @@ do_expand_lambdas_in_proc(!ProcInfo, !PredInfo, !ModuleInfo) :- % Set the new values of the fields in proc_info and pred_info. proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), pred_info_set_typevarset(TypeVarSet, !PredInfo). diff --git a/compiler/lco.m b/compiler/lco.m index c057a27e0..13a679988 100644 --- a/compiler/lco.m +++ b/compiler/lco.m @@ -404,8 +404,7 @@ lco_proc(LowerSCCVariants, SCC, CurProc, PredInfo, ProcInfo0, io.write_line(DebugStream, CurProc, !IO), io.flush_output(DebugStream, !IO) ), - proc_info_get_varset(ProcInfo0, VarSet0), - proc_info_get_vartypes(ProcInfo0, VarTypes0), + proc_info_get_varset_vartypes(ProcInfo0, VarSet0, VarTypes0), proc_info_get_headvars(ProcInfo0, HeadVars), proc_info_get_argmodes(ProcInfo0, ArgModes), arg_info.compute_in_and_out_vars(!.ModuleInfo, VarTypes0, @@ -448,8 +447,7 @@ lco_proc(LowerSCCVariants, SCC, CurProc, PredInfo, ProcInfo0, ), some [!ProcInfo] ( !:ProcInfo = ProcInfo0, - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo), % See the comment in transform_call_and_unifies for why these % are needed. @@ -671,7 +669,7 @@ potentially_transformable_recursive_call(Info, ConstInfo, Goal, OutArgs) :- ModuleInfo = Info ^ lco_module_info, ProcInfo = ConstInfo ^ lci_cur_proc_proc, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), module_info_proc_info(ModuleInfo, PredId, ProcId, CalleeProcInfo), proc_info_get_argmodes(CalleeProcInfo, CalleeArgModes), @@ -798,7 +796,7 @@ acceptable_construct_unification(ConstInfo, DelayForVars, Goal, bag.insert_list(ConstructArgVars, !UnifyInputVars), trace [compiletime(flag("lco")), io(!IO)] ( ProcInfo = ConstInfo ^ lci_cur_proc_proc, - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), ConstructedVarStr = mercury_var_to_string(VarSet, print_name_and_num, ConstructedVar), @@ -869,7 +867,7 @@ transform_call_and_unifies(CallGoal, CallOutArgVars, UnifyGoals, CallGoal = hlds_goal(CallGoalExpr, CallGoalInfo), ModuleInfo = !.Info ^ lco_module_info, ProcInfo = ConstInfo ^ lci_cur_proc_proc, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), ( if CallGoalExpr = plain_call(PredId, ProcId, ArgVars, Builtin, UnifyContext, _SymName), @@ -1401,7 +1399,7 @@ update_variant_pred_info(VariantMap, PredProcId - VariantId, !ModuleInfo) :- VariantProcInfo, !ModuleInfo), proc_info_get_headvars(VariantProcInfo, HeadVars), - proc_info_get_vartypes(VariantProcInfo, VarTypes), + proc_info_get_varset_vartypes(VariantProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, ArgTypes), some [!VariantPredInfo] ( @@ -1427,16 +1425,14 @@ update_variant_pred_info(VariantMap, PredProcId - VariantId, !ModuleInfo) :- lco_transform_variant_proc(VariantMap, AddrOutArgs, ProcInfo, !:VariantProcInfo, !ModuleInfo) :- !:VariantProcInfo = ProcInfo, - proc_info_get_varset(ProcInfo, VarSet0), - proc_info_get_vartypes(ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(ProcInfo, VarSet0, VarTypes0), proc_info_get_headvars(ProcInfo, HeadVars0), proc_info_get_argmodes(ProcInfo, ArgModes0), make_addr_vars(!.ModuleInfo, 1, HeadVars0, HeadVars, ArgModes0, ArgModes, AddrOutArgs, VarToAddr, VarSet0, VarSet, VarTypes0, VarTypes), proc_info_set_headvars(HeadVars, !VariantProcInfo), proc_info_set_argmodes(ArgModes, !VariantProcInfo), - proc_info_set_varset(VarSet, !VariantProcInfo), - proc_info_set_vartypes(VarTypes, !VariantProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !VariantProcInfo), proc_info_get_initial_instmap(!.ModuleInfo, ProcInfo, InstMap0), proc_info_get_goal(ProcInfo, Goal0), @@ -1821,7 +1817,7 @@ lco_transform_variant_plain_call(ModuleInfo, Transforms, VariantMap, VarToAddr, CallPredProcId = proc(CallPredId, CallProcId), module_info_proc_info(ModuleInfo, CallPredId, CallProcId, CalleeProcInfo), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_argmodes(CalleeProcInfo, CalleeArgModes), ( if multi_map.search(VariantMap, CallPredProcId, ExistingVariantIds), diff --git a/compiler/live_vars.m b/compiler/live_vars.m index 3808871ea..2ec447ce9 100644 --- a/compiler/live_vars.m +++ b/compiler/live_vars.m @@ -476,7 +476,7 @@ build_live_sets_in_goal_expr(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, ; GenericCall = event_call(_) ), ProcInfo = AllocData ^ ad_proc_info, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, ArgVars, Types), ModuleInfo = AllocData ^ ad_module_info, arg_info.partition_generic_call_args(ModuleInfo, ArgVars, @@ -490,7 +490,7 @@ build_live_sets_in_goal_expr(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, GoalExpr = GoalExpr0, ModuleInfo = AllocData ^ ad_module_info, CallerProcInfo = AllocData ^ ad_proc_info, - proc_info_get_vartypes(CallerProcInfo, VarTypes), + proc_info_get_varset_vartypes(CallerProcInfo, _VarSet, VarTypes), module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _, ProcInfo), arg_info.partition_proc_call_args(ProcInfo, VarTypes, ModuleInfo, ArgVars, _InVars, OutVars, _UnusedVars), @@ -542,7 +542,7 @@ build_live_sets_in_goal_expr(GoalExpr0, GoalExpr, GoalInfo0, GoalInfo, GoalExpr = GoalExpr0, ModuleInfo = AllocData ^ ad_module_info, CallerProcInfo = AllocData ^ ad_proc_info, - proc_info_get_vartypes(CallerProcInfo, VarTypes), + proc_info_get_varset_vartypes(CallerProcInfo, _VarSet, VarTypes), module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _, ProcInfo), ArgVars = list.map(foreign_arg_var, Args), arg_info.partition_proc_call_args(ProcInfo, VarTypes, ModuleInfo, @@ -774,7 +774,7 @@ build_live_sets_in_cases([Case0 | Cases0], [Case | Cases], maybe_add_typeinfo_liveness(ProcInfo, TypeInfoLiveness, OutVars, !LiveVars) :- ( TypeInfoLiveness = yes, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), get_typeinfo_vars(!.LiveVars, VarTypes, RttiVarMaps, TypeInfoVarsLive), get_typeinfo_vars(OutVars, VarTypes, RttiVarMaps, TypeInfoVarsOut), diff --git a/compiler/liveness.m b/compiler/liveness.m index de35f4a1d..1e69c6178 100644 --- a/compiler/liveness.m +++ b/compiler/liveness.m @@ -236,7 +236,7 @@ detect_liveness_proc_2(ModuleInfo, PredId, !ProcInfo) :- pred_id_to_int(PredId, PredIdInt), proc_info_get_goal(!.ProcInfo, GoalBeforeQuant), - proc_info_get_varset(!.ProcInfo, VarSetBeforeQuant), + proc_info_get_varset_vartypes(!.ProcInfo, VarSetBeforeQuant, _), trace [io(!IO)] ( maybe_debug_liveness(ModuleInfo, "\nbefore requantify", @@ -245,8 +245,7 @@ detect_liveness_proc_2(ModuleInfo, PredId, !ProcInfo) :- requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), proc_info_get_goal(!.ProcInfo, GoalAfterQuant), - proc_info_get_varset(!.ProcInfo, VarSet), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, VarTypes), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps), module_info_pred_info(ModuleInfo, PredId, PredInfo), body_should_use_typeinfo_liveness(PredInfo, Globals, TypeInfoLiveness), @@ -1787,14 +1786,9 @@ require_equal(LivenessFirst, LivenessRest, GoalType, LiveInfo) :- initial_liveness(ModuleInfo, PredInfo, ProcInfo, !:Liveness) :- proc_info_get_headvars(ProcInfo, Vars), proc_info_get_argmodes(ProcInfo, Modes), - proc_info_get_vartypes(ProcInfo, VarTypes), - lookup_var_types(VarTypes, Vars, Types), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), !:Liveness = set_of_var.init, - ( if initial_liveness_2(ModuleInfo, Vars, Types, Modes, !Liveness) then - true - else - unexpected($pred, "length mismatch") - ), + initial_liveness_2(ModuleInfo, VarTypes, Vars, Modes, !Liveness), % If a variable is unused in the goal, it shouldn't be in the initial % liveness. (If we allowed it to start live, it wouldn't ever become dead, @@ -1811,19 +1805,24 @@ initial_liveness(ModuleInfo, PredInfo, ProcInfo, !:Liveness) :- RttiVarMaps, NonLocals), set_of_var.intersect(!.Liveness, NonLocals, !:Liveness). -:- pred initial_liveness_2(module_info::in, - list(prog_var)::in, list(mer_type)::in, list(mer_mode)::in, - set_of_progvar::in, set_of_progvar::out) is semidet. +:- pred initial_liveness_2(module_info::in, vartypes::in, + list(prog_var)::in, list(mer_mode)::in, + set_of_progvar::in, set_of_progvar::out) is det. -initial_liveness_2(_ModuleInfo, [], [], [], !Liveness). -initial_liveness_2(ModuleInfo, [Var | Vars], [Type | Types], [Mode | Modes], +initial_liveness_2(_, _, [], [], !Liveness). +initial_liveness_2(_, _, [], [_ | _], !Liveness) :- + unexpected($pred, "length mismatch"). +initial_liveness_2(_, _, [_ | _], [], !Liveness) :- + unexpected($pred, "length mismatch"). +initial_liveness_2(ModuleInfo, VarTypes, [Var | Vars], [Mode | Modes], !Liveness) :- + lookup_var_type(VarTypes, Var, Type), ( if mode_to_top_functor_mode(ModuleInfo, Mode, Type, top_in) then set_of_var.insert(Var, !Liveness) else true ), - initial_liveness_2(ModuleInfo, Vars, Types, Modes, !Liveness). + initial_liveness_2(ModuleInfo, VarTypes, Vars, Modes, !Liveness). %-----------------------------------------------------------------------------% @@ -1839,7 +1838,7 @@ initial_deadness(ModuleInfo, ProcInfo, LiveInfo, Deadness) :- % If doing typeinfo liveness, the corresponding typeinfos need to be added % to these. - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), maybe_complete_with_typeinfo_vars(set_to_bitset(Deadness0), LiveInfo ^ li_typeinfo_liveness, VarTypes, RttiVarMaps, Deadness). diff --git a/compiler/loop_inv.m b/compiler/loop_inv.m index 44f7da6a6..8168039f0 100644 --- a/compiler/loop_inv.m +++ b/compiler/loop_inv.m @@ -749,10 +749,9 @@ create_aux_pred(PredProcId, HeadVars, ComputedInvArgs, proc_info_get_goal(ProcInfo, Goal @ hlds_goal(_GoalExpr, GoalInfo)), pred_info_get_typevarset(PredInfo, TVarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), pred_info_get_class_context(PredInfo, ClassContext), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), - proc_info_get_varset(ProcInfo, VarSet), proc_info_get_inst_varset(ProcInfo, InstVarSet), pred_info_get_markers(PredInfo, Markers), pred_info_get_origin(PredInfo, OrigOrigin), @@ -942,8 +941,7 @@ gen_out_proc(PredProcId, PredInfo0, ProcInfo0, ProcInfo, Replacement, Body0, % Put the new procedure body into the module_info. PredProcId = proc(PredId, ProcId), - proc_info_get_varset(ProcInfo0, VarSet), - proc_info_get_vartypes(ProcInfo0, VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, VarSet, VarTypes), proc_info_get_headvars(ProcInfo0, HeadVars), proc_info_get_rtti_varmaps(ProcInfo0, RttiVarMaps), diff --git a/compiler/mark_tail_calls.m b/compiler/mark_tail_calls.m index 41fa742ae..c5fe75c12 100644 --- a/compiler/mark_tail_calls.m +++ b/compiler/mark_tail_calls.m @@ -537,7 +537,7 @@ do_mark_tail_rec_calls_in_proc(Params, ModuleInfo, SCC, PredId, ProcId, proc_info_get_goal(!.ProcInfo, Goal0), proc_info_get_argmodes(!.ProcInfo, Modes), proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), find_output_args(ModuleInfo, Types, Modes, HeadVars, Outputs), Info0 = mark_tail_rec_calls_info(ModuleInfo, PredInfo, diff --git a/compiler/ml_accurate_gc.m b/compiler/ml_accurate_gc.m index 5b575a577..12f82276f 100644 --- a/compiler/ml_accurate_gc.m +++ b/compiler/ml_accurate_gc.m @@ -408,8 +408,7 @@ ml_gen_make_type_info_var(Type, Context, TypeInfoVar, TypeInfoGoals, !Info) :- module_info_set_pred_proc_info(PredProcId, PredInfo, ProcInfo, ModuleInfo1, ModuleInfo), % Save the new information back in the ml_gen_info. - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), % XXX It would be nice to have polymorphism update the var table directly. make_var_table(ModuleInfo, VarSet, VarTypes, VarTable), ml_gen_info_set_module_info(ModuleInfo, !Info), diff --git a/compiler/ml_args_util.m b/compiler/ml_args_util.m index c544b8419..9d371ee61 100644 --- a/compiler/ml_args_util.m +++ b/compiler/ml_args_util.m @@ -429,7 +429,7 @@ get_raw_data_for_proc_params(ModuleInfo, PredProcId, PredInfo, module_info_pred_proc_info(ModuleInfo, PredProcId, PredInfo, ProcInfo), PredOrFunc = pred_info_is_pred_or_func(PredInfo), CodeModel = proc_info_interface_code_model(ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), proc_info_get_headvars(ProcInfo, HeadVars), pred_info_get_arg_types(PredInfo, HeadTypes), proc_info_get_argmodes(ProcInfo, HeadModes), diff --git a/compiler/ml_closure_gen.m b/compiler/ml_closure_gen.m index 5869acf87..39367edcf 100644 --- a/compiler/ml_closure_gen.m +++ b/compiler/ml_closure_gen.m @@ -699,7 +699,7 @@ ml_gen_closure_wrapper(PredId, ProcId, ClosureKind, NumClosureArgs, proc_info_get_headvars(ProcInfo, ProcHeadVars), proc_info_get_argmodes(ProcInfo, ProcArgModes), CodeModel = proc_info_interface_code_model(ProcInfo), - proc_info_get_varset(ProcInfo, ProcVarSet), + proc_info_get_varset_vartypes(ProcInfo, ProcVarSet, _ProcVarTypes), ProcArity = list.length(ProcHeadVars), ProcHeadVarNames = ml_gen_local_var_names_from_varset(ProcVarSet, ProcHeadVars), diff --git a/compiler/ml_gen_info.m b/compiler/ml_gen_info.m index f94688afc..f239f4cee 100644 --- a/compiler/ml_gen_info.m +++ b/compiler/ml_gen_info.m @@ -966,8 +966,7 @@ ml_gen_info_init(ModuleInfo, Target, ConstStructMap, PredProcId, ProcInfo, AuxVarCounter, CondVarCounter, PackedWordCounter, ConvVarCounter, TailRecInfo), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), make_var_table(ModuleInfo, VarSet, VarTypes, VarTable), HighLevelData = mlds_target_high_level_data(Target), module_info_get_globals(ModuleInfo, Globals), diff --git a/compiler/ml_proc_gen.m b/compiler/ml_proc_gen.m index 7deee6f1f..b6222fd82 100644 --- a/compiler/ml_proc_gen.m +++ b/compiler/ml_proc_gen.m @@ -1184,7 +1184,7 @@ compute_initial_tail_rec_map_for_mutual(ModuleInfo, module_info_pred_proc_info(ModuleInfo, PredProcId, PredInfo, ProcInfo), pred_info_get_is_pred_or_func(PredInfo, PredOrFunc), CodeModel = proc_info_interface_code_model(ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), proc_info_get_headvars(ProcInfo, HeadVars), pred_info_get_arg_types(PredInfo, HeadTypes), proc_info_get_argmodes(ProcInfo, HeadModes), diff --git a/compiler/mode_info.m b/compiler/mode_info.m index 0474fd050..026b1425e 100644 --- a/compiler/mode_info.m +++ b/compiler/mode_info.m @@ -611,8 +611,7 @@ mode_info_init(ModuleInfo, PredId, ProcId, Context, LiveVars, HeadInstVars, ), module_info_proc_info(ModuleInfo, PredId, ProcId, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_inst_varset(ProcInfo, InstVarSet), bag.from_sorted_list(set_of_var.to_sorted_list(LiveVars), LiveVarsBag), diff --git a/compiler/modecheck_goal.m b/compiler/modecheck_goal.m index d49df603b..5eb9ec321 100644 --- a/compiler/modecheck_goal.m +++ b/compiler/modecheck_goal.m @@ -1188,18 +1188,16 @@ modecheck_make_type_info_var_for_type(Type, Context, TypeInfoVar, % unifications to handle implied modes. mode_info_get_var_types(!.ModeInfo, VarTypes0), mode_info_get_varset(!.ModeInfo, VarSet0), - proc_info_set_varset(VarSet0, ProcInfo0, ProcInfo1), - proc_info_set_vartypes(VarTypes0, ProcInfo1, ProcInfo2), + proc_info_set_varset_vartypes(VarSet0, VarTypes0, ProcInfo0, ProcInfo1), polymorphism_make_type_info_var_raw(Type, Context, TypeInfoVar, TypeInfoGoals, ModuleInfo0, ModuleInfo1, - PredInfo0, PredInfo, ProcInfo2, ProcInfo), + PredInfo0, PredInfo, ProcInfo1, ProcInfo), module_info_set_pred_proc_info(PredId, ProcId, PredInfo, ProcInfo, ModuleInfo1, ModuleInfo), % Update the information in the mode_info. - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), mode_info_set_varset(VarSet, !ModeInfo), mode_info_set_var_types(VarTypes, !ModeInfo), mode_info_set_module_info(ModuleInfo, !ModeInfo). diff --git a/compiler/modes.m b/compiler/modes.m index 4531d6135..2d8573ea1 100644 --- a/compiler/modes.m +++ b/compiler/modes.m @@ -942,8 +942,7 @@ do_modecheck_proc(WhatToCheck, MayChangeCalledProc, mode_info_get_var_types(!.ModeInfo, VarTypes), mode_info_get_need_to_requantify(!.ModeInfo, NeedToRequantify), proc_info_set_goal(Body, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_argmodes(ArgModes, !ProcInfo), ( NeedToRequantify = do_not_need_to_requantify diff --git a/compiler/par_loop_control.m b/compiler/par_loop_control.m index 5ed05ba5d..2527bcb22 100644 --- a/compiler/par_loop_control.m +++ b/compiler/par_loop_control.m @@ -151,7 +151,7 @@ maybe_par_loop_control_proc(DepInfo, PredProcId, !ProcInfo, !ModuleInfo) :- proc_info_get_goal(!.ProcInfo, Body0), % Re-calculate goal ids. - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), fill_goal_id_slots_in_proc_body(!.ModuleInfo, VarTypes, ContainingGoalMap, Body0, Body), proc_info_set_goal(Body, !ProcInfo), @@ -625,8 +625,7 @@ create_inner_proc(RecParConjIds, OldPredProcId, OldProcInfo, % in the body. proc_info_get_argmodes(OldProcInfo, ArgModes0), proc_info_get_headvars(OldProcInfo, HeadVars0), - proc_info_get_varset(OldProcInfo, !:VarSet), - proc_info_get_vartypes(OldProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(OldProcInfo, !:VarSet, !:VarTypes), proc_info_get_goal(OldProcInfo, !:Body), varset.new_named_var("LC", LCVar, !VarSet), @@ -1357,7 +1356,7 @@ update_outer_proc(PredProcId, InnerPredProcId, InnerPredName, ModuleInfo, % Re-build the variables in the procedure with smaller sets. varset.init(!:VarSet), init_vartypes(!:VarTypes), - proc_info_get_varset(!.ProcInfo, OldVarSet), + proc_info_get_varset_vartypes(!.ProcInfo, OldVarSet, _OldVarTypes), list.foldl3_corresponding(add_old_var_to_sets(OldVarSet), HeadVars0, HeadVarTypes, !VarSet, !VarTypes, map.init, Remap), list.map(map.lookup(Remap), HeadVars0, HeadVars), @@ -1428,8 +1427,7 @@ update_outer_proc(PredProcId, InnerPredProcId, InnerPredName, ModuleInfo, ), proc_info_set_goal(Body, !ProcInfo), - proc_info_set_varset(!.VarSet, !ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo) + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo) ). :- pred add_old_var_to_sets(prog_varset::in, prog_var::in, mer_type::in, diff --git a/compiler/pd_debug.m b/compiler/pd_debug.m index 8feed8bef..920d8bd42 100644 --- a/compiler/pd_debug.m +++ b/compiler/pd_debug.m @@ -169,7 +169,7 @@ pd_debug_output_version(Stream, ModuleInfo, PredProcId, Version, io.format(Stream, " cost delta: %d\n", [i(CostDelta)], !IO), NonLocals = goal_info_get_nonlocals(GoalInfo), module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), instmap_restrict(NonLocals, InstMap, InstMap1), io.format(Stream, " args: %s\n", [s(mercury_vars_to_string(VarSet, print_name_and_num, Args))], !IO), @@ -202,7 +202,7 @@ pd_debug_write_instmap(PDInfo, !IO) :- io.output_stream(Stream, !IO), pd_info_get_instmap(PDInfo, InstMap), pd_info_get_proc_info(PDInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), pd_info_get_module_info(PDInfo, ModuleInfo), module_info_get_globals(ModuleInfo, Globals), globals.lookup_bool_option(Globals, debug_pd, DebugPD), @@ -241,7 +241,7 @@ pd_debug_output_goal(PDInfo, Msg, Goal, !IO) :- Goal = hlds_goal(GoalExpr, GoalInfo), pd_info_get_proc_info(PDInfo, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), pd_info_get_instmap(PDInfo, InstMap), goal_util.goal_vars(hlds_goal(GoalExpr, GoalInfo), Vars), instmap_restrict(Vars, InstMap, VarsInstMap), diff --git a/compiler/pd_info.m b/compiler/pd_info.m index 466301df8..cf866ca10 100644 --- a/compiler/pd_info.m +++ b/compiler/pd_info.m @@ -212,7 +212,7 @@ pd_info_bind_var_to_functors(Var, MainConsId, OtherConsIds, !PDInfo) :- pd_info_get_instmap(!.PDInfo, InstMap0), pd_info_get_module_info(!.PDInfo, ModuleInfo0), pd_info_get_proc_info(!.PDInfo, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), bind_var_to_functors(Var, Type, MainConsId, OtherConsIds, InstMap0, InstMap, ModuleInfo0, ModuleInfo), @@ -492,7 +492,7 @@ pd_info_search_version(PDInfo, Goal, MaybeVersion) :- pd_info_get_module_info(PDInfo, ModuleInfo), pd_info_get_proc_info(PDInfo, ProcInfo), pd_info_get_instmap(PDInfo, InstMap), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), ( if map.search(GoalVersionIndex, CalledPreds, VersionIds), pd_info_get_matching_version(ModuleInfo, Goal, InstMap, @@ -667,8 +667,7 @@ pd_info_define_new_pred(Origin, Goal, PredProcId, CallGoal, !PDInfo) :- pred_info_get_typevarset(PredInfo, TVarSet), pred_info_get_markers(PredInfo, Markers), pred_info_get_class_context(PredInfo, ClassContext), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), proc_info_get_inst_varset(ProcInfo, InstVarSet), proc_info_get_has_parallel_conj(ProcInfo, HasParallelConj), diff --git a/compiler/pd_util.m b/compiler/pd_util.m index 2f4e6f63d..297564efb 100644 --- a/compiler/pd_util.m +++ b/compiler/pd_util.m @@ -216,8 +216,7 @@ propagate_constraints(!Goal, !PDInfo) :- ), pd_info_get_proc_info(!.PDInfo, ProcInfo0), pd_info_get_instmap(!.PDInfo, InstMap), - proc_info_get_vartypes(ProcInfo0, VarTypes0), - proc_info_get_varset(ProcInfo0, VarSet0), + proc_info_get_varset_vartypes(ProcInfo0, VarSet0, VarTypes0), constraint_info_init(ModuleInfo0, VarTypes0, VarSet0, InstMap, CInfo0), Goal0 = hlds_goal(_, GoalInfo0), NonLocals = goal_info_get_nonlocals(GoalInfo0), @@ -225,8 +224,7 @@ propagate_constraints(!Goal, !PDInfo) :- constraint_info_deconstruct(CInfo, ModuleInfo, VarTypes, VarSet, Changed), pd_info_set_module_info(ModuleInfo, !PDInfo), - proc_info_set_vartypes(VarTypes, ProcInfo0, ProcInfo1), - proc_info_set_varset(VarSet, ProcInfo1, ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, ProcInfo0, ProcInfo), pd_info_set_proc_info(ProcInfo, !PDInfo), ( Changed = yes, @@ -315,8 +313,7 @@ unique_modecheck_goal_live_vars(LiveVars, Goal0, Goal, Errors, !PDInfo) :- module_info_pred_proc_info(ModuleInfo, PredId, ProcId, PredInfo, ProcInfo1), pd_info_set_pred_info(PredInfo, !PDInfo), - proc_info_set_varset(VarSet, ProcInfo1, ProcInfo2), - proc_info_set_vartypes(VarTypes, ProcInfo2, ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, ProcInfo1, ProcInfo), pd_info_set_proc_info(ProcInfo, !PDInfo). % Work out which vars are live later in the computation based on @@ -374,8 +371,7 @@ rerun_det_analysis(Goal0, Goal, !PDInfo) :- module_info_set_pred_proc_info(PredProcId, PredInfo, ProcInfo, ModuleInfo0, ModuleInfo1), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), det_info_init(ModuleInfo1, PredProcId, VarSet, VarTypes, pess_extra_vars_ignore, [], DetInfo0), pd_info_get_instmap(!.PDInfo, InstMap), @@ -397,7 +393,7 @@ rerun_det_analysis(Goal0, Goal, !PDInfo) :- get_branch_vars_proc(PredProcId, ProcInfo, !ModuleInfo, !ArgInfo) :- proc_info_get_goal(ProcInfo, Goal), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), instmap.init_reachable(InstMap0), map.init(Vars0), set_of_var.init(LeftVars0), @@ -491,7 +487,7 @@ get_branch_vars_goal(Goal, MaybeBranchInfo, !PDInfo) :- pd_info_get_instmap(!.PDInfo, InstMap0), pd_info_get_proc_arg_info(!.PDInfo, ProcArgInfo), pd_info_get_proc_info(!.PDInfo, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), set_of_var.init(LeftVars0), map.init(Vars0), ( if @@ -767,14 +763,12 @@ combine_vars(BranchNo, [ExtraVar | ExtraVars], !Vars) :- pd_requantify_goal(NonLocals, Goal0, Goal, !PDInfo) :- some [!ProcInfo] ( pd_info_get_proc_info(!.PDInfo, !:ProcInfo), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), implicitly_quantify_goal_general(ordinary_nonlocals_no_lambda, NonLocals, _, Goal0, Goal, VarSet0, VarSet, VarTypes0, VarTypes, RttiVarMaps0, RttiVarMaps), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), pd_info_set_proc_info(!.ProcInfo, !PDInfo) ). @@ -783,7 +777,7 @@ pd_recompute_instmap_delta(Goal0, Goal, !PDInfo) :- pd_info_get_module_info(!.PDInfo, ModuleInfo0), pd_info_get_instmap(!.PDInfo, InstMap), pd_info_get_proc_info(!.PDInfo, ProcInfo), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_inst_varset(ProcInfo, InstVarSet), recompute_instmap_delta(recompute_atomic_instmap_deltas, Goal0, Goal, VarTypes, InstVarSet, InstMap, ModuleInfo0, ModuleInfo), diff --git a/compiler/polymorphism_info.m b/compiler/polymorphism_info.m index a5274e649..1867d4c30 100644 --- a/compiler/polymorphism_info.m +++ b/compiler/polymorphism_info.m @@ -335,8 +335,7 @@ create_poly_info(ModuleInfo, PredInfo, ProcInfo, PolyInfo) :- pred_info_get_tvar_kind_map(PredInfo, TypeVarKinds), pred_info_get_constraint_proof_map(PredInfo, ProofMap), pred_info_get_constraint_map(PredInfo, ConstraintMap), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), map.init(TypeInfoVarMap), map.init(TypeClassInfoMap), @@ -367,8 +366,7 @@ poly_info_extract(Info, Specs, !PredInfo, !ProcInfo, !:ModuleInfo) :- module_info_set_const_struct_db(ConstStructDb, !ModuleInfo), % Set the new values of the fields in proc_info and pred_info. - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), pred_info_set_typevarset(TypeVarSet, !PredInfo), pred_info_set_tvar_kind_map(TypeVarKinds, !PredInfo). diff --git a/compiler/proc_gen.m b/compiler/proc_gen.m index 24405a073..7833063c5 100644 --- a/compiler/proc_gen.m +++ b/compiler/proc_gen.m @@ -491,9 +491,8 @@ generate_proc_code(ModuleInfo0, ConstStructMap, PredId, PredInfo, proc_info_get_eval_method(ProcInfo, EvalMethod), proc_info_get_initial_instmap(ModuleInfo, ProcInfo, InstMap0), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_argmodes(ProcInfo, ArgModes), - proc_info_get_vartypes(ProcInfo, VarTypes), globals.get_trace_suppress(Globals, TraceSuppress), NeedBodyReps = eff_trace_needs_proc_body_reps(ModuleInfo, PredInfo, ProcInfo, TraceLevel, TraceSuppress), diff --git a/compiler/purity.m b/compiler/purity.m index cfdc5724f..d8cec841c 100644 --- a/compiler/purity.m +++ b/compiler/purity.m @@ -401,8 +401,7 @@ repuritycheck_proc(ModuleInfo, proc(_PredId, ProcId), !PredInfo) :- pred_info_get_proc_table(!.PredInfo, Procs0), map.lookup(Procs0, ProcId, ProcInfo0), proc_info_get_goal(ProcInfo0, Goal0), - proc_info_get_vartypes(ProcInfo0, VarTypes0), - proc_info_get_varset(ProcInfo0, VarSet0), + proc_info_get_varset_vartypes(ProcInfo0, VarSet0, VarTypes0), PurityInfo0 = purity_info(ModuleInfo, do_not_run_post_typecheck_tasks, do_not_need_to_requantify, have_not_converted_unify, !.PredInfo, VarTypes0, VarSet0, []), @@ -410,15 +409,14 @@ repuritycheck_proc(ModuleInfo, proc(_PredId, ProcId), !PredInfo) :- PurityInfo = purity_info(_, _, NeedToRequantify, _, !:PredInfo, VarTypes, VarSet, _), proc_info_set_goal(Goal, ProcInfo0, ProcInfo1), - proc_info_set_vartypes(VarTypes, ProcInfo1, ProcInfo2), - proc_info_set_varset(VarSet, ProcInfo2, ProcInfo3), + proc_info_set_varset_vartypes(VarSet, VarTypes, ProcInfo1, ProcInfo2), ( NeedToRequantify = need_to_requantify, requantify_proc_general(ordinary_nonlocals_maybe_lambda, - ProcInfo3, ProcInfo) + ProcInfo2, ProcInfo) ; NeedToRequantify = do_not_need_to_requantify, - ProcInfo = ProcInfo3 + ProcInfo = ProcInfo2 ), map.det_update(ProcId, ProcInfo, Procs0, Procs), pred_info_set_proc_table(Procs, !PredInfo), diff --git a/compiler/push_goals_together.m b/compiler/push_goals_together.m index 011b1209c..3e3e62e6c 100644 --- a/compiler/push_goals_together.m +++ b/compiler/push_goals_together.m @@ -90,8 +90,7 @@ push_goals_in_proc(PushGoals, OverallResult, !ProcInfo, !ModuleInfo) :- module_info_get_globals(!.ModuleInfo, Globals), module_info_get_name(!.ModuleInfo, ModuleName), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), PushInfo = push_info(Globals, ModuleName, RttiVarMaps0), OutInfo = init_hlds_out_info(Globals, output_debug), @@ -138,8 +137,7 @@ push_goals_in_proc(PushGoals, OverallResult, !ProcInfo, !ModuleInfo) :- recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas, Goal2, Goal, VarTypes, InstVarSet, InstMap0, !ModuleInfo), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), trace [compiletime(flag("debug_push_goals")), io(!IO)] ( get_debug_output_stream(Globals, ModuleName, DebugStream, !IO), diff --git a/compiler/quantification.m b/compiler/quantification.m index 2cc08e9b1..442768e42 100644 --- a/compiler/quantification.m +++ b/compiler/quantification.m @@ -133,15 +133,13 @@ requantify_proc_general(NonLocalsToRecompute, !ProcInfo) :- proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_goal(!.ProcInfo, Goal0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarmaps0), implicitly_quantify_clause_body_general(NonLocalsToRecompute, HeadVars, _, Goal0, Goal, VarSet0, VarSet, VarTypes0, VarTypes, RttiVarmaps0, RttiVarmaps), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarmaps, !ProcInfo). diff --git a/compiler/rbmm.add_rbmm_goal_infos.m b/compiler/rbmm.add_rbmm_goal_infos.m index 9f032eeda..218c04f9e 100644 --- a/compiler/rbmm.add_rbmm_goal_infos.m +++ b/compiler/rbmm.add_rbmm_goal_infos.m @@ -189,7 +189,7 @@ collect_rbmm_goal_info_goal_expr(ModuleInfo, ProcInfo, Graph, goal_info_set_maybe_rbmm(yes(rbmm_info_init), !Info) else CallSite = program_point_init(!.Info), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), RegionArgs = list.filter(is_region_var(VarTypes), Args), map.lookup(ActualRegionsArgsProc, CallSite, ActualRegionArgs), ActualRegionArgs = region_args(Constants, Inputs, _Outputs), @@ -245,7 +245,7 @@ collect_rbmm_goal_info_goal_expr(ModuleInfo, ProcInfo, Graph, % by all the conjuncts. RbmmInfo0 = rbmm_goal_info(Created, Removed, _, AllocatedInto, Used), NonLocals = goal_info_get_nonlocals(!.Info), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), NonLocalRegionsSet = set_of_var.filter(is_region_var(VarTypes), NonLocals), NonLocalRegions = set_of_var.bitset_to_set(NonLocalRegionsSet), diff --git a/compiler/rbmm.live_variable_analysis.m b/compiler/rbmm.live_variable_analysis.m index 91104d7b3..bce7790ac 100644 --- a/compiler/rbmm.live_variable_analysis.m +++ b/compiler/rbmm.live_variable_analysis.m @@ -372,7 +372,7 @@ collect_void_vars(ProgPoint, ProducedSet, ProcInfo, !ProcVoidVar) :- ( if map.search(!.ProcVoidVar, ProgPoint, _DeadVars) then true else - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), set.fold(void_var(VarSet), ProducedSet, set.init, VoidVars), map.set(ProgPoint, VoidVars, !ProcVoidVar) ). diff --git a/compiler/rbmm.points_to_graph.m b/compiler/rbmm.points_to_graph.m index 9d61d1543..e6c45c6ce 100644 --- a/compiler/rbmm.points_to_graph.m +++ b/compiler/rbmm.points_to_graph.m @@ -667,7 +667,7 @@ rptg_reach_from_a_variable(Graph, HLDS, ProcInfo, X, !Reach_X) :- rptg_get_node_by_variable(Graph, X, N_X), Node_Selector = pair(N_X, []), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, X, TypeX), % Find regions reached from X. diff --git a/compiler/rbmm.points_to_info.m b/compiler/rbmm.points_to_info.m index c95e614d8..21f595b9a 100644 --- a/compiler/rbmm.points_to_info.m +++ b/compiler/rbmm.points_to_info.m @@ -87,7 +87,7 @@ rpta_info_table_set_rpta_info(PredProcId, RptaInfo, !Table) :- !Table ^ elem(PredProcId) := RptaInfo. rpta_info_init(ProcInfo) = RptaInfo :- - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), vartypes_vars(VarTypes, Vars), list.foldl2(add_node_from_var(VarTypes), Vars, 1, _Reg, rpt_graph_init, Graph), diff --git a/compiler/rbmm.region_liveness_info.m b/compiler/rbmm.region_liveness_info.m index 8bb113326..f1b0cffca 100644 --- a/compiler/rbmm.region_liveness_info.m +++ b/compiler/rbmm.region_liveness_info.m @@ -98,7 +98,7 @@ find_input_output_args(ModuleInfo, CalleeProcInfo, Inputs, Outputs) :- proc_info_get_headvars(CalleeProcInfo, ArgVars), - proc_info_get_vartypes(CalleeProcInfo, VarTypes), + proc_info_get_varset_vartypes(CalleeProcInfo, _VarSet, VarTypes), proc_info_get_argmodes(CalleeProcInfo, ArgModes), arg_info.compute_in_and_out_vars(ModuleInfo, VarTypes, ArgVars, ArgModes, Inputs, Outputs). diff --git a/compiler/rbmm.region_transformation.m b/compiler/rbmm.region_transformation.m index 8fb704352..bf34a5a90 100644 --- a/compiler/rbmm.region_transformation.m +++ b/compiler/rbmm.region_transformation.m @@ -217,8 +217,7 @@ region_transform_proc(RptaInfoTable, FormalRegionArgTable, PPId = proc(PredId, ProcId), module_info_pred_proc_info(!.ModuleInfo, PPId, PredInfo0, ProcInfo0), fill_goal_path_slots_in_proc(!.ModuleInfo, ProcInfo0, ProcInfo1), - proc_info_get_varset(ProcInfo1, VarSet0), - proc_info_get_vartypes(ProcInfo1, VarTypes0), + proc_info_get_varset_vartypes(ProcInfo1, VarSet0, VarTypes0), proc_info_get_headvars(ProcInfo1, HeadVars0), proc_info_get_argmodes(ProcInfo1, ActualArgModes0), proc_info_get_goal(ProcInfo1, Goal0), @@ -322,9 +321,8 @@ annotate_proc(ModuleInfo, PredInfo, Graph, FormalRegionArgProc, ++ OutModes ++ [LastHeadMode] ), - proc_info_set_varset(!.VarSet, !ProcInfo), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo), proc_info_set_goal(!.Goal, !ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo), proc_info_set_headvars(!.HeadVars, !ProcInfo), proc_info_set_argmodes(!.ActualArgModes, !ProcInfo). diff --git a/compiler/recompute_instmap_deltas.m b/compiler/recompute_instmap_deltas.m index ac018b8fe..4ce5a0786 100644 --- a/compiler/recompute_instmap_deltas.m +++ b/compiler/recompute_instmap_deltas.m @@ -83,7 +83,7 @@ recompute_instmap_delta_proc(RecomputeAtomic, !ProcInfo, !ModuleInfo) :- proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InstMap0), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_goal(!.ProcInfo, Goal0), proc_info_get_inst_varset(!.ProcInfo, InstVarSet), recompute_instmap_delta(RecomputeAtomic, Goal0, Goal, diff --git a/compiler/saved_vars.m b/compiler/saved_vars.m index 6f00ed80b..a2065d2ce 100644 --- a/compiler/saved_vars.m +++ b/compiler/saved_vars.m @@ -80,8 +80,7 @@ saved_vars_proc(proc(PredId, ProcId), !ProcInfo, !ModuleInfo) :- body_should_use_typeinfo_liveness(PredInfo, Globals, TypeInfoLiveness), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, Varset0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, Varset0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), init_slot_info(Varset0, VarTypes0, RttiVarMaps0, TypeInfoLiveness, SlotInfo0), @@ -115,8 +114,7 @@ saved_vars_proc(proc(PredId, ProcId), !ProcInfo, !ModuleInfo) :- ), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(Varset, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(Varset, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo). %-----------------------------------------------------------------------------% diff --git a/compiler/simplify_goal_unify.m b/compiler/simplify_goal_unify.m index b2984eb73..d3e094524 100644 --- a/compiler/simplify_goal_unify.m +++ b/compiler/simplify_goal_unify.m @@ -287,8 +287,7 @@ make_type_info_vars(Types, TypeInfoVars, TypeInfoGoals, !Info) :- % this information from the pred_info and proc_info. module_info_pred_proc_info(ModuleInfo0, PredProcId, !:PredInfo, !:ProcInfo), - proc_info_set_vartypes(VarTypes0, !ProcInfo), - proc_info_set_varset(VarSet0, !ProcInfo), + proc_info_set_varset_vartypes(VarSet0, VarTypes0, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps0, !ProcInfo), % Generate the code that creates the type_infos. @@ -297,8 +296,7 @@ make_type_info_vars(Types, TypeInfoVars, TypeInfoGoals, !Info) :- TypeInfoVars, TypeInfoGoals, ModuleInfo0, ModuleInfo1, !PredInfo, !ProcInfo), - proc_info_get_vartypes(!.ProcInfo, VarTypes), - proc_info_get_varset(!.ProcInfo, VarSet), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, VarTypes), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps), simplify_info_set_var_types(VarTypes, !Info), simplify_info_set_varset(VarSet, !Info), diff --git a/compiler/simplify_info.m b/compiler/simplify_info.m index ba10e0dfc..3de854bd3 100644 --- a/compiler/simplify_info.m +++ b/compiler/simplify_info.m @@ -410,8 +410,7 @@ simplify_info_init(ModuleInfo, PredId, ProcId, ProcInfo, SimplifyTasks, % SimplifyTasks % ModuleInfo - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), RerunQuant = do_not_rerun_quant_instmap_deltas, RerunDet = do_not_rerun_det, diff --git a/compiler/simplify_proc.m b/compiler/simplify_proc.m index ad4e7b5ab..baf31662c 100644 --- a/compiler/simplify_proc.m +++ b/compiler/simplify_proc.m @@ -182,8 +182,7 @@ simplify_goal_update_vars_in_proc(SimplifyTasks, !ModuleInfo, simplify_info_get_varset(SimplifyInfo, VarSet), simplify_info_get_var_types(SimplifyInfo, VarTypes), simplify_info_get_rtti_varmaps(SimplifyInfo, RttiVarMaps), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), simplify_info_get_cost_delta(SimplifyInfo, CostDelta). @@ -290,8 +289,7 @@ simplify_proc_return_msgs(SimplifyTasks0, PredId, ProcId, !ModuleInfo, else VarSet = VarSet0 ), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), simplify_info_get_has_parallel_conj(Info, HasParallelConj), @@ -348,7 +346,7 @@ simplify_proc_maybe_vary_parameters(ModuleInfo, PredId, ProcInfo, TurnOffCommonStructByRequest = no ) ), - proc_info_get_vartypes(ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(ProcInfo, _VarSet0, VarTypes0), vartypes_count(VarTypes0, NumVars), ( if ( TurnOffCommonStructByRequest = yes @@ -410,15 +408,13 @@ simplify_proc_maybe_mark_modecheck_clauses(!ProcInfo) :- simplify_proc_analyze_and_format_calls(!ModuleInfo, ImplicitStreamWarnings, PredId, ProcId, FormatSpecs, !ProcInfo) :- proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), analyze_and_optimize_format_calls(!.ModuleInfo, ImplicitStreamWarnings, Goal0, MaybeGoal, FormatSpecs, VarSet0, VarSet, VarTypes0, VarTypes), ( MaybeGoal = yes(Goal), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), % The goals we replace format calls with are created with the % correct nonlocals, but analyze_and_optimize_format_calls can @@ -688,8 +684,7 @@ maybe_recompute_fields_after_top_level_goal(GoalInfo0, InstMap0, simplify_info_get_pred_proc_id(!.Info, PredProcId), module_info_pred_proc_info(!.ModuleInfo, PredProcId, PredInfo, !:ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo), - proc_info_set_varset(!.VarSet, !ProcInfo), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(!.RttiVarMaps, !ProcInfo), module_info_set_pred_proc_info(PredProcId, PredInfo, !.ProcInfo, !ModuleInfo), diff --git a/compiler/size_prof.m b/compiler/size_prof.m index e0a4c821d..1708066f0 100644 --- a/compiler/size_prof.m +++ b/compiler/size_prof.m @@ -238,8 +238,7 @@ size_prof_process_proc(Transform, proc(PredId, ProcId), !ProcInfo, simplify_proc(SimplifyTasks, PredId, ProcId, !ModuleInfo, !ProcInfo), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InstMap0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), % The with_types are needed to avoid a combinatorial explosion @@ -270,8 +269,7 @@ size_prof_process_proc(Transform, proc(PredId, ProcId), !ProcInfo, recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas, Goal2, Goal, VarTypes, InstVarSet, InstMap0, !ModuleInfo), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo). :- pred size_prof_process_goal(hlds_goal::in, hlds_goal::out, diff --git a/compiler/ssdebug.m b/compiler/ssdebug.m index f7ed63666..370e04e33 100644 --- a/compiler/ssdebug.m +++ b/compiler/ssdebug.m @@ -493,14 +493,12 @@ insert_context_update_call(ModuleInfo, Goal0, Goal, !ProcInfo) :- Context = term.context(FileName, LineNumber), some [!VarSet, !VarTypes] ( - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), make_string_const_construction_alloc(FileName, yes("FileName"), MakeFileName, FileNameVar, !VarSet, !VarTypes), make_int_const_construction_alloc(LineNumber, yes("LineNumber"), MakeLineNumber, LineNumberVar, !VarSet, !VarTypes), - proc_info_set_varset(!.VarSet, !ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo) + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo) ), ArgVars = [FileNameVar, LineNumberVar], @@ -605,8 +603,7 @@ ssdebug_process_proc_det(SSTraceLevel, PredId, ProcId, some [!PredInfo, !VarSet, !VarTypes] ( module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo), proc_info_get_goal(!.ProcInfo, OrigBodyGoal), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), get_stripped_headvars(!.PredInfo, !.ProcInfo, FullHeadVars, HeadVars, ArgModes), @@ -699,8 +696,7 @@ ssdebug_process_proc_semi(SSTraceLevel, PredId, ProcId, some [!PredInfo, !VarSet, !VarTypes] ( module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo), proc_info_get_goal(!.ProcInfo, OrigBodyGoal), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), get_stripped_headvars(!.PredInfo, !.ProcInfo, FullHeadVars, HeadVars, ArgModes), @@ -829,8 +825,7 @@ ssdebug_process_proc_nondet(SSTraceLevel, PredId, ProcId, some [!PredInfo, !VarSet, !VarTypes] ( module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo), proc_info_get_goal(!.ProcInfo, OrigBodyGoal), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), get_stripped_headvars(!.PredInfo, !.ProcInfo, FullHeadVars, HeadVars, _ArgModes), @@ -929,8 +924,7 @@ ssdebug_process_proc_failure(SSTraceLevel, PredId, ProcId, some [!PredInfo, !VarSet, !VarTypes] ( module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo), proc_info_get_goal(!.ProcInfo, OrigBodyGoal), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), get_stripped_headvars(!.PredInfo, !.ProcInfo, FullHeadVars, HeadVars, _ArgModes), @@ -997,8 +991,7 @@ ssdebug_process_proc_erroneous(SSTraceLevel, PredId, ProcId, some [!PredInfo, !VarSet, !VarTypes] ( module_info_pred_info(!.ModuleInfo, PredId, !:PredInfo), proc_info_get_goal(!.ProcInfo, OrigBodyGoal), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), get_stripped_headvars(!.PredInfo, !.ProcInfo, _FullHeadVars, HeadVars, _ArgModes), @@ -1179,8 +1172,7 @@ commit_goal_changes(ConjGoals, PredId, ProcId, !.PredInfo, !ProcInfo, Purity = goal_info_get_purity(OrigGoalInfo), Goal = hlds_goal(scope(promise_purity(Purity), Conj), ScopeGoalInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo), requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), recompute_instmap_delta_proc(recompute_atomic_instmap_deltas, @@ -1422,8 +1414,7 @@ make_var_value(InstMap, VarToInspect, Renaming, VarDesc, VarPos, Goals, % polymorphism_make_type_info_var uses a prog_var which is % already bound. - proc_info_set_varset(!.VarSet, !ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo), % Create dynamic constructor for the value of the argument. % @@ -1438,9 +1429,7 @@ make_var_value(InstMap, VarToInspect, Renaming, VarDesc, VarPos, Goals, polymorphism_make_type_info_var_raw(MerType, Context, TypeInfoVar, TypeInfoGoals0, !ModuleInfo, !PredInfo, !ProcInfo), - proc_info_get_varset(!.ProcInfo, !:VarSet), - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), - + proc_info_get_varset_vartypes(!.ProcInfo, !:VarSet, !:VarTypes), % Constructor of the variable's description. ConsId = cons(qualified(SSDBModule, "bound_head_var"), 3, VarValueTypeCtor), diff --git a/compiler/stack_alloc.m b/compiler/stack_alloc.m index 1a1474b8b..c14591097 100644 --- a/compiler/stack_alloc.m +++ b/compiler/stack_alloc.m @@ -86,7 +86,7 @@ allocate_stack_slots_in_proc(ModuleInfo, proc(PredId, ProcId), !ProcInfo) :- body_should_use_typeinfo_liveness(PredInfo, Globals, TypeInfoLiveness), globals.lookup_bool_option(Globals, opt_no_return_calls, OptNoReturnCalls), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), build_dummy_type_array(ModuleInfo, VarTypes, DummyTypeArray, DummyVars), AllocData = alloc_data(ModuleInfo, !.ProcInfo, proc(PredId, ProcId), TypeInfoLiveness, OptNoReturnCalls, DummyTypeArray), diff --git a/compiler/stack_layout.m b/compiler/stack_layout.m index 9166d8e81..eb7a93c83 100644 --- a/compiler/stack_layout.m +++ b/compiler/stack_layout.m @@ -678,8 +678,8 @@ construct_proc_layout(Params, PLI, ProcLayoutName, Kind, InternalLabelInfos, DeepOriginalBody = DeepProfInfo ^ pdpi_orig_body, DeepOriginalBody = deep_original_body(BytecodeBody, - BytecodeHeadVars, BytecodeInstMap, BytecodeVarTypes, - BytecodeDetism, BytecodeVarSet), + BytecodeHeadVars, BytecodeInstMap, + BytecodeVarSet, BytecodeVarTypes, BytecodeDetism), compute_var_number_map(BytecodeHeadVars, BytecodeVarSet, [], BytecodeBody, BytecodeVarNumMap) ; diff --git a/compiler/stack_opt.m b/compiler/stack_opt.m index a15e25e61..bb74b53c6 100644 --- a/compiler/stack_opt.m +++ b/compiler/stack_opt.m @@ -259,8 +259,7 @@ init_opt_stack_alloc = opt_stack_alloc(set_of_var.init). optimize_live_sets(ModuleInfo, OptAlloc, !ProcInfo, Changed, DebugStackOpt, PredIdInt) :- proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), - proc_info_get_varset(!.ProcInfo, VarSet0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), OptAlloc = opt_stack_alloc(ParConjOwnSlot), arg_info.partition_proc_args(!.ProcInfo, ModuleInfo, InputArgs, OutputArgs, UnusedArgs), @@ -330,8 +329,7 @@ optimize_live_sets(ModuleInfo, OptAlloc, !ProcInfo, Changed, DebugStackOpt, apply_headvar_correction(set_to_bitset(HeadVars), RenameMap, Goal1, Goal), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), Changed = yes ). @@ -1053,7 +1051,7 @@ maybe_write_progress_message(Message, DebugStackOpt, PredIdInt, ProcInfo, ModuleInfo, !IO) :- ( if DebugStackOpt = PredIdInt then proc_info_get_goal(ProcInfo, Goal), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), module_info_get_globals(ModuleInfo, Globals), io.output_stream(Stream, !IO), io.write_string(Stream, Message, !IO), diff --git a/compiler/stm_expand.m b/compiler/stm_expand.m index d6678fd40..8089ffa74 100644 --- a/compiler/stm_expand.m +++ b/compiler/stm_expand.m @@ -1325,10 +1325,10 @@ move_variables_to_new_pred(AtomicGoal0, AtomicGoal, AtomicGoalVars, InnerDI, InnerUO, !NewPredInfo, !StmInfo) :- NewProcInfo0 = !.NewPredInfo ^ new_pred_proc_info, OldProcInfo0 = !.StmInfo ^ stm_info_proc_info, - proc_info_get_varset(NewProcInfo0, NewPredVarSet0), - proc_info_get_vartypes(NewProcInfo0, NewPredVarTypes0), - proc_info_get_varset(OldProcInfo0, OldPredVarSet0), - proc_info_get_vartypes(OldProcInfo0, OldPredVarTypes0), + proc_info_get_varset_vartypes(NewProcInfo0, + NewPredVarSet0, NewPredVarTypes0), + proc_info_get_varset_vartypes(OldProcInfo0, + OldPredVarSet0, OldPredVarTypes0), AtomicGoalVars = stm_goal_vars(_, LocalVars, _, OrigInnerDI, OrigInnerUO), LocalVarList = set_of_var.to_sorted_list(LocalVars), @@ -1346,10 +1346,10 @@ move_variables_to_new_pred(AtomicGoal0, AtomicGoal, AtomicGoalVars, ), rename_some_vars_in_goal(VarMapping, AtomicGoal0, AtomicGoal), - proc_info_set_varset(NewPredVarSet, NewProcInfo0, NewProcInfo1), - proc_info_set_vartypes(NewPredVarTypes, NewProcInfo1, NewProcInfo), - proc_info_set_varset(OldPredVarSet, OldProcInfo0, OldProcInfo1), - proc_info_set_vartypes(OldPredVarTypes, OldProcInfo1, OldProcInfo), + proc_info_set_varset_vartypes(NewPredVarSet, NewPredVarTypes, + NewProcInfo0, NewProcInfo), + proc_info_set_varset_vartypes(OldPredVarSet, OldPredVarTypes, + OldProcInfo0, OldProcInfo), !NewPredInfo ^ new_pred_proc_info := NewProcInfo, !StmInfo ^ stm_info_proc_info := OldProcInfo. @@ -2129,8 +2129,8 @@ construct_output(Context, AtomicGoalVars, ResultType, ResultVar, StmInfo, rename_var_in_wrapper_pred(Name, ResultVar0, ResultType, ResultVar, !NewPredInfo, !Goal) :- NewProcInfo0 = !.NewPredInfo ^ new_pred_proc_info, - proc_info_get_varset(NewProcInfo0, NewPredVarSet0), - proc_info_get_vartypes(NewProcInfo0, NewPredVarTypes0), + proc_info_get_varset_vartypes(NewProcInfo0, + NewPredVarSet0, NewPredVarTypes0), proc_info_get_headvars(NewProcInfo0, NewHeadVars0), varset.delete_var(ResultVar0, NewPredVarSet0, NewPredVarSet1), delete_var_type(ResultVar0, NewPredVarTypes0, NewPredVarTypes1), @@ -2150,9 +2150,9 @@ rename_var_in_wrapper_pred(Name, ResultVar0, ResultType, ResultVar, list.map(MapLambda, NewHeadVars0, NewHeadVars), rename_some_vars_in_goal(VarMapping, !Goal), - proc_info_set_varset(NewPredVarSet, NewProcInfo0, NewProcInfo1), - proc_info_set_vartypes(NewPredVarTypes, NewProcInfo1, NewProcInfo2), - proc_info_set_headvars(NewHeadVars, NewProcInfo2, NewProcInfo), + proc_info_set_varset_vartypes(NewPredVarSet, NewPredVarTypes, + NewProcInfo0, NewProcInfo1), + proc_info_set_headvars(NewHeadVars, NewProcInfo1, NewProcInfo), !NewPredInfo ^ new_pred_proc_info := NewProcInfo. %-----------------------------------------------------------------------------% @@ -2453,8 +2453,7 @@ create_cloned_pred(ProcHeadVars, PredArgTypes, ProcHeadModes, CloneKind, pred_info_proc_info(PredInfo, ProcId, ProcInfo), proc_info_get_context(ProcInfo, ProcContext), - proc_info_get_varset(ProcInfo, ProcVarSet), - proc_info_get_vartypes(ProcInfo, ProcVarTypes), + proc_info_get_varset_vartypes(ProcInfo, ProcVarSet, ProcVarTypes), proc_info_get_inst_varset(ProcInfo, ProcInstVarSet), ( MaybeDetism = yes(ProcDetism) @@ -2583,15 +2582,14 @@ new_pred_set_goal(Goal, !NewPredInfo) :- ProcInfo0 = !.NewPredInfo ^ new_pred_proc_info, goal_vars(Goal, GoalVars), GoalVarsSet = set_of_var.bitset_to_set(GoalVars), - proc_info_get_varset(ProcInfo0, ProcVarSet0), - proc_info_get_vartypes(ProcInfo0, ProcVarTypes0), + proc_info_get_varset_vartypes(ProcInfo0, ProcVarSet0, ProcVarTypes0), varset.select(GoalVarsSet, ProcVarSet0, ProgVarSet), vartypes_select(GoalVarsSet, ProcVarTypes0, ProcVarTypes), - proc_info_set_varset(ProgVarSet, ProcInfo0, ProcInfo1), - proc_info_set_goal(Goal, ProcInfo1, ProcInfo2), - proc_info_set_vartypes(ProcVarTypes, ProcInfo2, ProcInfo), + proc_info_set_varset_vartypes(ProgVarSet, ProcVarTypes, + ProcInfo0, ProcInfo1), + proc_info_set_goal(Goal, ProcInfo1, ProcInfo), !NewPredInfo ^ new_pred_proc_info := ProcInfo. % Returns the pred_proc_id of the new predicate. @@ -2628,7 +2626,7 @@ get_input_output_varlist(StmGoalVars, Input, Output) :- get_input_output_types(StmGoalVars, StmInfo, InputTypes, OutputTypes) :- ProcInfo0 = StmInfo ^ stm_info_proc_info, - proc_info_get_vartypes(ProcInfo0, VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, _VarSet, VarTypes), get_input_output_varlist(StmGoalVars, InputVars, OutputVars), lookup_var_types(VarTypes, InputVars, InputTypes), diff --git a/compiler/store_alloc.m b/compiler/store_alloc.m index b17e355c1..3ed17e3db 100644 --- a/compiler/store_alloc.m +++ b/compiler/store_alloc.m @@ -111,7 +111,7 @@ allocate_store_maps(RunType, ModuleInfo, proc(PredId, _), !ProcInfo) :- build_input_arg_list(!.ProcInfo, InputArgLvals), LastLocns0 = initial_last_locns(InputArgLvals), proc_info_get_stack_slots(!.ProcInfo, StackSlots), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), globals.lookup_bool_option(Globals, use_float_registers, FloatRegs), ( FloatRegs = yes, diff --git a/compiler/structure_reuse.analysis.m b/compiler/structure_reuse.analysis.m index faf1b1efa..ce55532c6 100644 --- a/compiler/structure_reuse.analysis.m +++ b/compiler/structure_reuse.analysis.m @@ -857,7 +857,7 @@ analysis_name = "structure_reuse". Answer2 = structure_reuse_answer_conditional(_, _, _), FuncInfo = structure_reuse_func_info(ModuleInfo, ProcInfo), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), structure_reuse_answer_to_domain(HeadVarTypes, ProcInfo, Answer1, Reuse1), @@ -878,7 +878,7 @@ analysis_name = "structure_reuse". Answer2 = structure_reuse_answer_conditional(_, _, _), FuncInfo = structure_reuse_func_info(ModuleInfo, ProcInfo), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), structure_reuse_answer_to_domain(HeadVarTypes, ProcInfo, Answer1, Reuse1), @@ -996,7 +996,7 @@ reuse_as_to_structure_reuse_answer(ModuleInfo, PPId, ReuseAs, Answer) :- Reuse = has_conditional_reuse(Conditions), module_info_proc_info(ModuleInfo, PPId, ProcInfo), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), Answer = structure_reuse_answer_conditional(HeadVars, HeadVarTypes, Conditions) diff --git a/compiler/structure_reuse.direct.choose_reuse.m b/compiler/structure_reuse.direct.choose_reuse.m index 800e5c9c8..499a8211a 100644 --- a/compiler/structure_reuse.direct.choose_reuse.m +++ b/compiler/structure_reuse.direct.choose_reuse.m @@ -167,7 +167,7 @@ determine_reuse(ModuleInfo, ProcInfo, DeadCellTable, !Goal, ReuseAs) :- background_info. background_info_init(Strategy, ModuleInfo, ProcInfo) = Background :- - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), Background = background(Strategy, ModuleInfo, ProcInfo, VarTypes). %---------------------------------------------------------------------------% diff --git a/compiler/structure_reuse.direct.detect_garbage.m b/compiler/structure_reuse.direct.detect_garbage.m index 2c8ae14a7..28519358a 100644 --- a/compiler/structure_reuse.direct.detect_garbage.m +++ b/compiler/structure_reuse.direct.detect_garbage.m @@ -224,7 +224,7 @@ determine_dead_deconstructions_generic_call(ModuleInfo, ProcInfo, ( GenDetails = higher_order(_, _, _, _) ; GenDetails = class_method(_, _, _, _) ), - proc_info_get_vartypes(ProcInfo, CallerVarTypes), + proc_info_get_varset_vartypes(ProcInfo, _CallerVarSet, CallerVarTypes), lookup_var_types(CallerVarTypes, CallArgs, ActualTypes), ( if bottom_sharing_is_safe_approximation_by_args(ModuleInfo, Modes, @@ -274,7 +274,7 @@ unification_verify_reuse(ModuleInfo, ProcInfo, GoalInfo, Unification, Arity \= 0, % No-tag values don't have a cell to reuse. - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), not type_is_no_tag_type(ModuleInfo, Type), diff --git a/compiler/structure_reuse.indirect.m b/compiler/structure_reuse.indirect.m index 25e86edc6..b773da653 100644 --- a/compiler/structure_reuse.indirect.m +++ b/compiler/structure_reuse.indirect.m @@ -372,7 +372,7 @@ ir_background_info_init(ModuleInfo, PPId, PredInfo, ProcInfo, SharingTable, % type-info arguments and alike, so we remove them from the list % of head variables: proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, Vartypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, Vartypes), HeadVarsOfInterest = remove_typeinfo_vars(Vartypes, HeadVars), module_info_get_globals(ModuleInfo, Globals), @@ -650,7 +650,7 @@ indirect_reuse_analyse_generic_call(BaseInfo, GenDetails, CallArgs, Modes, ( GenDetails = higher_order(_, _, _, _) ; GenDetails = class_method(_, _, _, _) ), - proc_info_get_vartypes(ProcInfo, CallerVarTypes), + proc_info_get_varset_vartypes(ProcInfo, _CallerVarSet, CallerVarTypes), lookup_var_types(CallerVarTypes, CallArgs, ActualTypes), ( if bottom_sharing_is_safe_approximation_by_args(ModuleInfo, Modes, @@ -926,7 +926,7 @@ verify_indirect_reuse_for_call(BaseInfo, IrInfo, GoalInfo, CalleePPId, PredInfo = BaseInfo ^ irb_pred_info, ProcInfo = BaseInfo ^ irb_proc_info, SharingAs = IrInfo ^ ira_sharing_as, - proc_info_get_vartypes(ProcInfo, ActualVarTypes), + proc_info_get_varset_vartypes(ProcInfo, _, ActualVarTypes), pred_info_get_typevarset(PredInfo, CallerTypeVarSet), pred_info_get_univ_quant_tvars(PredInfo, CallerHeadTypeParams), lookup_var_types(ActualVarTypes, CalleeArgs, CalleeTypes), @@ -1040,7 +1040,7 @@ maybe_write_verify_indirect_reuse_reason(Stream, BaseInfo, CalleePPId, ModuleInfo = BaseInfo ^ irb_module_info, GoalReuse = goal_info_get_reuse(GoalInfo), Context = goal_info_get_context(GoalInfo), - proc_info_get_varset(BaseInfo ^ irb_proc_info, VarSet), + proc_info_get_varset_vartypes(BaseInfo ^ irb_proc_info, VarSet, _), CalleeStr = pred_proc_id_to_string(ModuleInfo, CalleePPId), io.write_string(Stream, "\tcall to ", !IO), io.write_string(Stream, CalleeStr, !IO), diff --git a/compiler/structure_reuse.lbu.m b/compiler/structure_reuse.lbu.m index 37111df17..dfd3396e7 100644 --- a/compiler/structure_reuse.lbu.m +++ b/compiler/structure_reuse.lbu.m @@ -56,7 +56,7 @@ backward_use_information(_ModuleInfo, !ProcInfo):- proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), % Before the first goal, the set of variables in LBU is empty. LBU0 = set_of_var.init, diff --git a/compiler/structure_reuse.lfu.m b/compiler/structure_reuse.lfu.m index db1becbef..516b967ee 100644 --- a/compiler/structure_reuse.lfu.m +++ b/compiler/structure_reuse.lfu.m @@ -57,7 +57,7 @@ %-----------------------------------------------------------------------------% forward_use_information(!ProcInfo) :- - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), proc_info_get_goal(!.ProcInfo, Goal0), % Set of variables initially instantiated. diff --git a/compiler/structure_sharing.analysis.m b/compiler/structure_sharing.analysis.m index 99e234a27..54adf6871 100644 --- a/compiler/structure_sharing.analysis.m +++ b/compiler/structure_sharing.analysis.m @@ -585,7 +585,7 @@ analyse_goal(ModuleInfo, PredInfo, ProcInfo, SharingTable, Verbose, Goal, ), % Rename - proc_info_get_vartypes(ProcInfo, CallerVarTypes), + proc_info_get_varset_vartypes(ProcInfo, _CallerVarSet, CallerVarTypes), lookup_var_types(CallerVarTypes, CallArgs, ActualTypes), pred_info_get_typevarset(PredInfo, CallerTypeVarSet), pred_info_get_univ_quant_tvars(PredInfo, CallerHeadParams), @@ -754,7 +754,7 @@ analyse_generic_call(ModuleInfo, ProcInfo, GenDetails, CallArgs, Modes, ( GenDetails = higher_order(_, _, _, _) ; GenDetails = class_method(_, _, _, _) ), - proc_info_get_vartypes(ProcInfo, CallerVarTypes), + proc_info_get_varset_vartypes(ProcInfo, _CallerVarSet, CallerVarTypes), lookup_var_types(CallerVarTypes, CallArgs, ActualTypes), ( if bottom_sharing_is_safe_approximation_by_args(ModuleInfo, Modes, @@ -914,7 +914,9 @@ wrapped_init(_Id) = sharing_as_and_status(sharing_as_init, optimal). ---> structure_sharing_answer_bottom ; structure_sharing_answer_top ; structure_sharing_answer_real( - ssar_vars :: prog_vars, + % XXX The next two fields should be a list of pairs, + % not a pair of lists. + ssar_vars :: list(prog_var), ssar_types :: list(mer_type), ssar_sharing :: structure_sharing % We cannot keep this as a sharing_as. When the analysis @@ -981,7 +983,7 @@ analysis_name = "structure_sharing". FuncInfo = structure_sharing_func_info(ModuleInfo, ProcInfo), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), structure_sharing_answer_to_domain(no, HeadVarTypes, ProcInfo, Answer1, Sharing1), @@ -1002,7 +1004,7 @@ analysis_name = "structure_sharing". ; FuncInfo = structure_sharing_func_info(ModuleInfo, ProcInfo), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), structure_sharing_answer_to_domain(no, HeadVarTypes, ProcInfo, Answer1, Sharing1), @@ -1140,7 +1142,7 @@ maybe_record_sharing_analysis_result_2(ModuleInfo, SharingAsTable, PredId, ; Sharing = structure_sharing_real(SharingPairs), proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), Answer = structure_sharing_answer_real(HeadVars, HeadVarTypes, SharingPairs), diff --git a/compiler/structure_sharing.domain.m b/compiler/structure_sharing.domain.m index 6c23999f5..c2cf51700 100644 --- a/compiler/structure_sharing.domain.m +++ b/compiler/structure_sharing.domain.m @@ -544,7 +544,7 @@ sharing_from_unification(ModuleInfo, ProcInfo, Unification, GoalInfo) :- pred is_introduced_typeinfo_arg(proc_info::in, prog_var::in) is semidet. is_introduced_typeinfo_arg(ProcInfo, Var) :- - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, Type), is_introduced_type_info_type(Type). @@ -645,11 +645,12 @@ add_foreign_proc_sharing(ModuleInfo, PredInfo, ProcInfo, ForeignPPId, Attributes, ForeignPPId, GoalContext), ActualVars = list.map(foreign_arg_var, Args), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, ActualVars, ActualTypes), pred_info_get_typevarset(PredInfo, CallerTypeVarSet), pred_info_get_external_type_params(PredInfo, CallerExternalTypeParams), + % XXX We should pass VarTypes instead of ActualTypes. sharing_as_rename_using_module_info(ModuleInfo, ForeignPPId, ActualVars, ActualTypes, CallerTypeVarSet, CallerExternalTypeParams, ForeignSharing, ActualSharing), @@ -862,11 +863,12 @@ lookup_sharing_and_comb(ModuleInfo, PredInfo, ProcInfo, SharingTable, lookup_sharing_or_predict(ModuleInfo, SharingTable, PPId, FormalSharing, _Status, _IsPredicted), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, ActualVars, ActualTypes), pred_info_get_typevarset(PredInfo, CallerTypeVarSet), pred_info_get_univ_quant_tvars(PredInfo, CallerExternalTypeParams), + % XXX We should pass VarTypes instead of ActualTypes. sharing_as_rename_using_module_info(ModuleInfo, PPId, ActualVars, ActualTypes, CallerTypeVarSet, CallerExternalTypeParams, FormalSharing, ActualSharing), @@ -953,7 +955,7 @@ bottom_sharing_is_safe_approximation(ModuleInfo, PredInfo, ProcInfo) :- ; proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_argmodes(ProcInfo, Modes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, HeadVars, Types), bottom_sharing_is_safe_approximation_by_args(ModuleInfo, Modes, Types) ). @@ -1218,7 +1220,7 @@ sharing_set_extend_datastruct(ModuleInfo, ProcInfo, Datastruct, SharingSet) ( if map.search(SharingMap, Var, SelectorSet) then % The type of the variable is needed to be able to compare % datastructures. - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var, VarType), Datastructures = selector_sharing_set_extend_datastruct(ModuleInfo, ProcInfo, VarType, Selector, SelectorSet) @@ -1416,7 +1418,7 @@ sharing_set_altclos_2(ModuleInfo, ProcInfo, NewSharingSet, OldSharingSet) map.select(NewMap, CommonVarsSet, NewMap1), map.select(OldMap, CommonVarsSet, OldMap1), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), % % for each common var V, compute the sharing pairs A-B, such that % \exists X where var(X) = V, and X-A \in NewSharingSet, and X-B \in @@ -1515,7 +1517,7 @@ sharing_set_subsumes_sharing_pair(ModuleInfo, ProcInfo, SharingSet, check_normalized(ModuleInfo, Type2, Sel2) ), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var1, Type1), lookup_var_type(VarTypes, Var2, Type2), @@ -1576,7 +1578,7 @@ sharing_set_subsumed_subset(ModuleInfo, ProcInfo, SharingSet, SharingPair, check_normalized(ModuleInfo, Type2, Sel2) ), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), lookup_var_type(VarTypes, Var1, Type1), lookup_var_type(VarTypes, Var2, Type2), diff --git a/compiler/switch_detection.m b/compiler/switch_detection.m index dbe825728..93a74d236 100644 --- a/compiler/switch_detection.m +++ b/compiler/switch_detection.m @@ -209,7 +209,7 @@ detect_switches_in_proc(Info, !ProcInfo) :- % based on the modes of the head vars, and pass these to % `detect_switches_in_goal'. Info = switch_detect_info(ModuleInfo, AllowMulti), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), Requant0 = do_not_need_to_requantify, BodyDeletedCallCallees0 = set.init, LocalInfo0 = local_switch_detect_info(ModuleInfo, AllowMulti, Requant0, diff --git a/compiler/table_gen.m b/compiler/table_gen.m index 6a8db1943..012e4c104 100644 --- a/compiler/table_gen.m +++ b/compiler/table_gen.m @@ -603,8 +603,7 @@ table_gen_transform_proc(TabledMethod, PredId, ProcId, !ProcInfo, !PredInfo, proc_info_interface_determinism(!.ProcInfo, Detism), determinism_to_code_model(Detism, CodeModel), proc_info_get_headvars(!.ProcInfo, HeadVars), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_goal(!.ProcInfo, OrigGoal), proc_info_get_argmodes(!.ProcInfo, ArgModes), proc_info_get_table_attributes(!.ProcInfo, MaybeAttributes), @@ -749,8 +748,7 @@ table_gen_transform_proc(TabledMethod, PredId, ProcId, !ProcInfo, !PredInfo, % Set the new values of the fields in proc_info and pred_info % and save in the module info. proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_call_table_tip(MaybeCallTableTip, !ProcInfo), ( @@ -2081,8 +2079,7 @@ do_own_stack_create_generator(PredId, ProcId, !.PredInfo, !.ProcInfo, Goal = hlds_goal(GoalExpr, OrigGoalInfo), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_vartypes(!.VarTypes, !ProcInfo), - proc_info_set_varset(!.VarSet, !ProcInfo), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, !ProcInfo), GenTabledMethod = tabled_minimal(own_stacks_generator), InputVarModeMethods = list.map(project_out_pos, NumberedInputVars), @@ -2171,8 +2168,7 @@ clone_pred_info(OrigPredId, OrigProcId, PredInfo0, HeadVars, clone_proc_and_create_call(PredInfo, ProcId, CallExpr, !ModuleInfo) :- pred_info_proc_info(PredInfo, ProcId, ProcInfo), proc_info_get_context(ProcInfo, ProcContext), - proc_info_get_varset(ProcInfo, ProcVarSet), - proc_info_get_vartypes(ProcInfo, ProcVarTypes), + proc_info_get_varset_vartypes(ProcInfo, ProcVarSet, ProcVarTypes), proc_info_get_headvars(ProcInfo, ProcHeadVars), proc_info_get_inst_varset(ProcInfo, ProcInstVarSet), proc_info_get_argmodes(ProcInfo, ProcHeadModes), @@ -4023,17 +4019,15 @@ table_gen_make_type_info_vars(Types, Context, !VarSet, !VarTypes, % Put the varset and vartypes from the simplify_info % back in the proc_info. - proc_info_set_vartypes(!.VarTypes, ProcInfo0, ProcInfo1), - proc_info_set_varset(!.VarSet, ProcInfo1, ProcInfo2), + proc_info_set_varset_vartypes(!.VarSet, !.VarTypes, ProcInfo0, ProcInfo1), % Generate the code that creates the type_infos. polymorphism_make_type_info_vars_raw(Types, Context, TypeInfoVars, TypeInfoGoals, ModuleInfo0, ModuleInfo, - PredInfo0, PredInfo, ProcInfo2, ProcInfo), + PredInfo0, PredInfo, ProcInfo1, ProcInfo), % Get the new varset and vartypes from the proc_info. - proc_info_get_vartypes(ProcInfo, !:VarTypes), - proc_info_get_varset(ProcInfo, !:VarSet), + proc_info_get_varset_vartypes(ProcInfo, !:VarSet, !:VarTypes), % Put the new module_info, pred_info, and proc_info back in the table_info. table_info_init(ModuleInfo, PredInfo, ProcInfo, !:TableInfo). diff --git a/compiler/tabling_analysis.m b/compiler/tabling_analysis.m index b889a5660..4322e7d73 100644 --- a/compiler/tabling_analysis.m +++ b/compiler/tabling_analysis.m @@ -293,7 +293,7 @@ check_proc_for_mm_tabling(SCC, PPId, !Results, !ModuleInfo) :- ; EvalMethod = eval_tabled(tabled_io(_, _)) ), proc_info_get_goal(ProcInfo, Body), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), check_goal_for_mm_tabling(SCC, VarTypes, Body, Result, MaybeAnalysisStatus, !ModuleInfo) ), @@ -571,7 +571,7 @@ mm_tabling_annotate_proc(PPId, !ModuleInfo) :- some [!ProcInfo, !Body] ( module_info_pred_proc_info(!.ModuleInfo, PPId, PredInfo, !:ProcInfo), proc_info_get_goal(!.ProcInfo, !:Body), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), mm_tabling_annotate_goal(VarTypes, !Body, _Status, !ModuleInfo), proc_info_set_goal(!.Body, !ProcInfo), module_info_set_pred_proc_info(PPId, PredInfo, !.ProcInfo, !ModuleInfo) diff --git a/compiler/term_constr_build.m b/compiler/term_constr_build.m index fd92cadac..f06b02f04 100644 --- a/compiler/term_constr_build.m +++ b/compiler/term_constr_build.m @@ -214,7 +214,7 @@ term_constr_build_abstract_proc(ModuleInfo, Options, SCC, EntryProcs, PPId, module_info_pred_proc_info(ModuleInfo, PPId, PredInfo, ProcInfo), pred_info_get_context(PredInfo, Context), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_headvars(ProcInfo, HeadProgVars), proc_info_get_argmodes(ProcInfo, ArgModes0), proc_info_get_goal(ProcInfo, Goal0), diff --git a/compiler/term_constr_initial.m b/compiler/term_constr_initial.m index bcc26d755..0bbf7b163 100644 --- a/compiler/term_constr_initial.m +++ b/compiler/term_constr_initial.m @@ -393,7 +393,7 @@ set_generated_terminates([ProcId | ProcIds], SpecialPredId, ModuleInfo, !ProcTable) :- map.lookup(!.ProcTable, ProcId, ProcInfo0), proc_info_get_headvars(ProcInfo0, HeadVars), - proc_info_get_vartypes(ProcInfo0, VarTypes), + proc_info_get_varset_vartypes(ProcInfo0, _VarSet, VarTypes), special_pred_id_to_termination(SpecialPredId, HeadVars, ModuleInfo, VarTypes, ArgSize, Termination, VarMap, HeadSizeVars), some [!Term2Info] ( diff --git a/compiler/term_errors.m b/compiler/term_errors.m index 2bdbe433b..312d9367b 100644 --- a/compiler/term_errors.m +++ b/compiler/term_errors.m @@ -443,7 +443,7 @@ term_error_kind_description(ModuleInfo, Single, ErrorKind, Pieces, Reason) :- ), ProcPPId = proc(PredId, ProcId), module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _, ProcInfo), - proc_info_get_varset(ProcInfo, Varset), + proc_info_get_varset_vartypes(ProcInfo, Varset, _VarTypes), term_errors_var_bag_description(OutputSuppliers, Varset, OutputSuppliersNames), list.map((pred(OS::in, FOS::out) is det :- FOS = fixed(OS)), diff --git a/compiler/term_pass1.m b/compiler/term_pass1.m index 66cd0f608..711bf1e6e 100644 --- a/compiler/term_pass1.m +++ b/compiler/term_pass1.m @@ -220,7 +220,7 @@ find_arg_sizes_pred(ModuleInfo, PassInfo, PPId, OutputSupplierMap0, Result, pred_info_get_context(PredInfo, Context), proc_info_get_headvars(ProcInfo, Args), proc_info_get_argmodes(ProcInfo, ArgModes), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_goal(ProcInfo, Goal0), % The pretest code we add for compiler-generated unification and comparison % predicates uses type casts. It uses them in a way that is guaranteed @@ -299,7 +299,7 @@ update_output_suppliers([Arg | Args], ActiveVars, check_proc_non_term_calls(ModuleInfo, PPId, !Errors) :- module_info_pred_proc_info(ModuleInfo, PPId, _, ProcInfo), proc_info_get_goal(ProcInfo, Goal), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), check_goal_non_term_calls(ModuleInfo, PPId, VarTypes, Goal, !Errors). :- pred check_goal_non_term_calls(module_info::in, pred_proc_id::in, diff --git a/compiler/term_pass2.m b/compiler/term_pass2.m index 56e605e58..8ef5f2a64 100644 --- a/compiler/term_pass2.m +++ b/compiler/term_pass2.m @@ -378,7 +378,7 @@ prove_termination_in_scc_pass(ModuleInfo, PassInfo, FixDir, [PPId | PPIds], % to terminate, but our analysis is not (yet) able to find this out for % itself. We therefore analyse only the non-pretest parts of such goals. Goal = maybe_strip_equality_pretest(Goal0), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), map.init(EmptyMap), PassInfo = pass_info(FunctorInfo, MaxErrors, MaxPaths), init_term_traversal_params(FunctorInfo, PPId, Context, VarTypes, diff --git a/compiler/trace_gen.m b/compiler/trace_gen.m index ce1e9254f..a20a52c94 100644 --- a/compiler/trace_gen.m +++ b/compiler/trace_gen.m @@ -349,7 +349,7 @@ get_trace_maybe_tail_rec_info(TraceInfo, TraceInfo ^ ti_tail_rec_info). trace_fail_vars(ModuleInfo, ProcInfo, FailVars) :- proc_info_get_headvars(ProcInfo, HeadVars), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_argmodes(ProcInfo, Modes), mode_list_get_final_insts(ModuleInfo, Modes, FinalInsts), proc_info_arg_info(ProcInfo, ArgInfos), diff --git a/compiler/trailing_analysis.m b/compiler/trailing_analysis.m index a00b41cca..aada48c58 100644 --- a/compiler/trailing_analysis.m +++ b/compiler/trailing_analysis.m @@ -300,7 +300,7 @@ trail_maybe_analysis_status(ProcResult, AnalysisStatus) :- check_proc_for_trail_mods(SCC, PPId, !Results, !ModuleInfo) :- module_info_pred_proc_info(!.ModuleInfo, PPId, _, ProcInfo), proc_info_get_goal(ProcInfo, Body), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), check_goal_for_trail_mods(SCC, VarTypes, Body, Result, MaybeAnalysisStatus, !ModuleInfo), list.cons(trail_proc_result(PPId, Result, MaybeAnalysisStatus), !Results). @@ -834,7 +834,7 @@ trail_annotate_proc(PPId, !ModuleInfo) :- some [!ProcInfo, !Body] ( module_info_pred_proc_info(!.ModuleInfo, PPId, PredInfo, !:ProcInfo), proc_info_get_goal(!.ProcInfo, !:Body), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), trail_annotate_goal(VarTypes, !Body, _Status, !ModuleInfo), proc_info_set_goal(!.Body, !ProcInfo), module_info_set_pred_proc_info(PPId, PredInfo, !.ProcInfo, !ModuleInfo) diff --git a/compiler/try_expand.m b/compiler/try_expand.m index 9a89c5c83..1707b7ef7 100644 --- a/compiler/try_expand.m +++ b/compiler/try_expand.m @@ -531,7 +531,7 @@ expand_try_goal_2(MaybeIO, ResultVar, Goal1, Then1, MaybeElse1, ExcpHandling1, !PredInfo, !ProcInfo, !ModuleInfo) :- some [!VarTypes] ( % Get the type of the output tuple. - proc_info_get_vartypes(!.ProcInfo, !:VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet, !:VarTypes), GoalOutputVars = set_of_var.to_sorted_list(GoalOutputVarsSet), lookup_var_types(!.VarTypes, GoalOutputVars, GoalOutputVarTypes), OutputTupleType = tuple_type(GoalOutputVarTypes, kind_star), @@ -542,7 +542,7 @@ expand_try_goal_2(MaybeIO, ResultVar, Goal1, Then1, MaybeElse1, ExcpHandling1, qualified(mercury_exception_module, "exception_result"), [OutputTupleType], kind_star), update_var_type(ResultVar, RealResultVarType, !VarTypes), - proc_info_set_vartypes(!.VarTypes, !ProcInfo) + proc_info_set_varset_vartypes(VarSet, !.VarTypes, !ProcInfo) ), make_try_lambda(Goal1, GoalOutputVarsSet, OutputTupleType, MaybeIO, @@ -833,13 +833,11 @@ make_try_lambda(Body0, OutputVarsSet, OutputTupleType, MaybeIO, conjoin_goals(Body0, MakeOutputTuple, LambdaBody0), % Rename away output variables in the lambda body. - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), clone_variables(set_of_var.to_sorted_list(OutputVarsSet), VarSet0, VarTypes0, VarSet0, VarSet, VarTypes0, VarTypes, map.init, Renaming), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), rename_some_vars_in_goal(Renaming, LambdaBody0, LambdaBody), % Get the determinism of the lambda. diff --git a/compiler/tupling.m b/compiler/tupling.m index 02f9e9233..4badf856f 100644 --- a/compiler/tupling.m +++ b/compiler/tupling.m @@ -468,8 +468,7 @@ should_use_tupling_scheme(TuningParams, candidate_headvars_of_proc(ModuleInfo, PredProcId @ proc(PredId, ProcId), CandidateHeadVars) :- module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), proc_info_get_headvars(ProcInfo, HeadVars), proc_info_get_argmodes(ProcInfo, ArgModes), CandidateHeadVars = list.filter_map_corresponding( @@ -586,7 +585,7 @@ find_best_tupling_scheme_2(TraceCounts, TuningParams, ModuleInfo, add_tupling_proposal(ModuleInfo, CandidateHeadVars, MinArgsToTuple, PredProcId @ proc(PredId, ProcId), !TuplingScheme) :- module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), proc_info_get_headvars(ProcInfo, HeadVars), FieldVarArgPos = list.filter_map( ( func(_ - Annotation) = (Var - Pos) is semidet :- @@ -670,7 +669,7 @@ add_transformed_proc(PredProcId, tupling(_, FieldVars, _), % Create the cell variable. list.length(FieldVars, TupleArity), - proc_info_get_vartypes(!.ProcInfo, VarTypes), + proc_info_get_varset_vartypes(!.ProcInfo, _VarSet, VarTypes), lookup_var_types(VarTypes, FieldVars, TupleArgTypes), construct_type(type_ctor(unqualified("{}"), TupleArity), TupleArgTypes, TupleConsType), @@ -720,8 +719,7 @@ make_transformed_proc(CellVar, FieldVarsList, InsertMap, !ProcInfo) :- % Insert the necessary deconstruction unifications. proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), - proc_info_get_varset(!.ProcInfo, VarSet0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), % XXX: I haven't checked if adding this feature has any effect. MaybeGoalFeature = yes(feature_tuple_opt), record_decisions_in_goal(Goal0, Goal1, VarSet0, VarSet1, @@ -749,8 +747,7 @@ make_transformed_proc(CellVar, FieldVarsList, InsertMap, !ProcInfo) :- apply_headvar_correction(set_of_var.list_to_set(HeadVars), RenameMap, Goal3, Goal), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo). :- pred insert_proc_start_deconstruction(hlds_goal::in, hlds_goal::out, @@ -788,10 +785,9 @@ create_aux_pred(PredId, ProcId, PredInfo, ProcInfo, Counter, proc_info_get_goal(ProcInfo, Goal @ hlds_goal(_GoalExpr, GoalInfo)), proc_info_get_initial_instmap(!.ModuleInfo, ProcInfo, InitialAuxInstMap), pred_info_get_typevarset(PredInfo, TVarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), pred_info_get_class_context(PredInfo, ClassContext), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), - proc_info_get_varset(ProcInfo, VarSet), proc_info_get_inst_varset(ProcInfo, InstVarSet), pred_info_get_markers(PredInfo, Markers), pred_info_get_origin(PredInfo, OrigOrigin), @@ -1097,7 +1093,7 @@ count_load_stores_in_goal(Goal, CountInfo, !CountState) :- _Detism), ModuleInfo = CountInfo ^ ci_module, ProcInfo = CountInfo ^ ci_proc_info, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), arg_info.generic_call_arg_reg_types(ModuleInfo, GenericCall, ArgVars, MaybeArgRegs, ArgRegTypes), arg_info.compute_in_and_out_vars_sep_regs(ModuleInfo, VarTypes, @@ -1137,7 +1133,7 @@ count_load_stores_in_goal(Goal, CountInfo, !CountState) :- ArgVars = list.map(foreign_arg_var, Args), ExtraVars = list.map(foreign_arg_var, ExtraArgs), CallingProcInfo = CountInfo ^ ci_proc_info, - proc_info_get_vartypes(CallingProcInfo, VarTypes), + proc_info_get_varset_vartypes(CallingProcInfo, _VarSet, VarTypes), arg_info.partition_proc_call_args(ProcInfo, VarTypes, ModuleInfo, ArgVars, InputArgVarSet, OutputArgVarSet, _), set.to_sorted_list(InputArgVarSet, InputArgVars), @@ -1236,7 +1232,7 @@ count_load_stores_in_call_to_tupled(GoalExpr, GoalInfo, CountInfo, module_info_pred_proc_info(ModuleInfo, CalleePredId, CalleeProcId, _, CalleeProcInfo), CallingProcInfo = CountInfo ^ ci_proc_info, - proc_info_get_vartypes(CallingProcInfo, VarTypes), + proc_info_get_varset_vartypes(CallingProcInfo, _VarSet, VarTypes), arg_info.partition_proc_call_args(CalleeProcInfo, VarTypes, ModuleInfo, ArgVars, InputArgs0, Outputs, _), ( if @@ -1289,7 +1285,7 @@ count_load_stores_in_call_to_not_tupled(GoalExpr, GoalInfo, CountInfo, module_info_pred_proc_info(ModuleInfo, PredId, ProcId, _PredInfo, CalleeProcInfo), ProcInfo = CountInfo ^ ci_proc_info, - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), arg_info.partition_proc_call_args(CalleeProcInfo, VarTypes, ModuleInfo, ArgVars, InputArgs, OutputArgs, _), set.to_sorted_list(InputArgs, Inputs), @@ -1579,7 +1575,7 @@ add_branch_costs(BranchState, Weight, !CountState) :- build_interval_info(ModuleInfo, ProcInfo, IntervalInfo) :- proc_info_get_goal(ProcInfo, Goal), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), arg_info.partition_proc_args(ProcInfo, ModuleInfo, _InputArgs, OutputArgs, _UnusedArgs), Counter0 = counter.init(1), @@ -1734,15 +1730,13 @@ fix_calls_in_proc(TransformMap, proc(PredId, ProcId), !ModuleInfo) :- true else proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), - proc_info_get_varset(!.ProcInfo, VarSet0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), fix_calls_in_goal(Goal0, Goal, VarSet0, VarSet, VarTypes0, VarTypes, RttiVarMaps0, RttiVarMaps, TransformMap), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), recompute_instmap_delta_proc(recompute_atomic_instmap_deltas, diff --git a/compiler/unneeded_code.m b/compiler/unneeded_code.m index 19a2184c5..b8d5f1665 100644 --- a/compiler/unneeded_code.m +++ b/compiler/unneeded_code.m @@ -245,15 +245,13 @@ unneeded_process_proc_msg(PredProcId, !ProcInfo, !ModuleInfo) :- unneeded_pre_process_proc(!ProcInfo) :- proc_info_get_headvars(!.ProcInfo, HeadVars), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_rtti_varmaps(!.ProcInfo, RttiVarMaps0), implicitly_quantify_clause_body_general(ordinary_nonlocals_no_lambda, HeadVars, _Warnings, Goal0, Goal, VarSet0, VarSet, VarTypes0, VarTypes, RttiVarMaps0, RttiVarMaps), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo). % The source-to-source transform operates in two phases. @@ -304,8 +302,7 @@ unneeded_pre_process_proc(!ProcInfo) :- unneeded_process_proc(!ProcInfo, !ModuleInfo, PredId, Pass, Successful) :- fill_goal_id_slots_in_proc(!.ModuleInfo, ContainingGoalMap, !ProcInfo), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_varset(!.ProcInfo, VarSet0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), proc_info_get_initial_instmap(!.ModuleInfo, !.ProcInfo, InitInstMap), Goal0 = hlds_goal(_, GoalInfo0), InstMapDelta = goal_info_get_instmap_delta(GoalInfo0), @@ -375,8 +372,7 @@ unneeded_process_proc(!ProcInfo, !ModuleInfo, PredId, Pass, Successful) :- recompute_instmap_delta(do_not_recompute_atomic_instmap_deltas, Goal3, Goal, VarTypes, InstVarSet, InitInstMap, !ModuleInfo), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo), ( if Pass > 3 then true diff --git a/compiler/untupling.m b/compiler/untupling.m index 6e339efb0..62c999c33 100644 --- a/compiler/untupling.m +++ b/compiler/untupling.m @@ -245,8 +245,7 @@ expand_args_in_proc(PredId, ProcId, !ModuleInfo, !TransformMap, !Counter) :- proc_info_get_headvars(!.ProcInfo, HeadVars0), proc_info_get_argmodes(!.ProcInfo, ArgModes0), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), - proc_info_get_varset(!.ProcInfo, VarSet0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), expand_args_in_proc_2(HeadVars0, ArgModes0, HeadVars, ArgModes, Goal0, Goal, VarSet0, VarSet, VarTypes0, VarTypes, @@ -255,8 +254,7 @@ expand_args_in_proc(PredId, ProcId, !ModuleInfo, !TransformMap, !Counter) :- proc_info_set_headvars(HeadVars, !ProcInfo), proc_info_set_argmodes(ArgModes, !ProcInfo), proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), recompute_instmap_delta_proc(recompute_atomic_instmap_deltas, !ProcInfo, !ModuleInfo), @@ -429,10 +427,9 @@ create_aux_pred(PredId, ProcId, PredInfo, ProcInfo, Counter, proc_info_get_goal(ProcInfo, Goal @ hlds_goal(_GoalExpr, GoalInfo)), proc_info_get_initial_instmap(!.ModuleInfo, ProcInfo, InitialAuxInstMap), pred_info_get_typevarset(PredInfo, TVarSet), - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, VarSet, VarTypes), pred_info_get_class_context(PredInfo, ClassContext), proc_info_get_rtti_varmaps(ProcInfo, RttiVarMaps), - proc_info_get_varset(ProcInfo, VarSet), proc_info_get_inst_varset(ProcInfo, InstVarSet), pred_info_get_markers(PredInfo, Markers), pred_info_get_origin(PredInfo, OrigOrigin), @@ -494,16 +491,14 @@ fix_calls_in_proc(TransformMap, PredId, ProcId, !ModuleInfo) :- module_info_pred_proc_info(!.ModuleInfo, PredId, ProcId, PredInfo, !:ProcInfo), proc_info_get_goal(!.ProcInfo, Goal0), - proc_info_get_vartypes(!.ProcInfo, VarTypes0), - proc_info_get_varset(!.ProcInfo, VarSet0), + proc_info_get_varset_vartypes(!.ProcInfo, VarSet0, VarTypes0), fix_calls_in_goal(Goal0, Goal, VarSet0, VarSet, VarTypes0, VarTypes, TransformMap, !.ModuleInfo), ( if Goal0 = Goal then true else proc_info_set_goal(Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), requantify_proc_general(ordinary_nonlocals_no_lambda, !ProcInfo), recompute_instmap_delta_proc(recompute_atomic_instmap_deltas, !ProcInfo, !ModuleInfo), diff --git a/compiler/unused_args.m b/compiler/unused_args.m index ff2b67e9b..c81774cad 100644 --- a/compiler/unused_args.m +++ b/compiler/unused_args.m @@ -555,7 +555,7 @@ setup_proc_args(PredId, ProcId, !VarUsage, !PredProcIds, !OptProcs, then true else - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), vartypes_vars(VarTypes, Vars), initialise_vardep(Vars, !VarDep), setup_output_args(!.ModuleInfo, ProcInfo, !VarDep), @@ -1290,13 +1290,12 @@ create_call_goal(UnusedArgs, NewPredId, NewProcId, PredModule, PredName, proc_info_interface_determinism(!.OldProc, Determinism), goal_info_set_determinism(Determinism, GoalInfo0, GoalInfo1), - proc_info_get_vartypes(!.OldProc, VarTypes0), + proc_info_get_varset_vartypes(!.OldProc, VarSet0, VarTypes0), set.list_to_set(HeadVars, NonLocals), lookup_var_types(VarTypes0, HeadVars, VarTypeList), vartypes_from_corresponding_lists(HeadVars, VarTypeList, VarTypes1), % The varset should probably be fixed up, but it shouldn't make % too much difference. - proc_info_get_varset(!.OldProc, VarSet0), proc_info_get_rtti_varmaps(!.OldProc, RttiVarMaps0), remove_listof_elements(1, UnusedArgs, HeadVars, NewHeadVars), GoalExpr = plain_call(NewPredId, NewProcId, NewHeadVars, @@ -1306,8 +1305,7 @@ create_call_goal(UnusedArgs, NewPredId, NewProcId, PredModule, PredName, set_to_bitset(NonLocals), _, Goal1, Goal, VarSet0, VarSet, VarTypes1, VarTypes, RttiVarMaps0, RttiVarMaps), proc_info_set_goal(Goal, !OldProc), - proc_info_set_varset(VarSet, !OldProc), - proc_info_set_vartypes(VarTypes, !OldProc), + proc_info_set_varset_vartypes(VarSet, VarTypes, !OldProc), proc_info_set_rtti_varmaps(RttiVarMaps, !OldProc). % Create a pred_info for an imported pred with a pragma unused_args @@ -1429,10 +1427,9 @@ do_unused_args_fixup_proc(VarUsage, OldPredProcId, ProcCallInfo, map.keys(UsageInfos, UnusedVars), module_info_pred_proc_info(!.ModuleInfo, PredId, ProcId, PredInfo0, ProcInfo0), - proc_info_get_vartypes(ProcInfo0, VarTypes0), + proc_info_get_varset_vartypes(ProcInfo0, VarSet0, VarTypes0), proc_info_get_headvars(ProcInfo0, HeadVars0), proc_info_get_argmodes(ProcInfo0, ArgModes0), - proc_info_get_varset(ProcInfo0, VarSet0), proc_info_get_goal(ProcInfo0, Goal0), remove_listof_elements(1, UnusedArgs, HeadVars0, HeadVars), remove_listof_elements(1, UnusedArgs, ArgModes0, ArgModes), @@ -1459,8 +1456,7 @@ do_unused_args_fixup_proc(VarUsage, OldPredProcId, ProcCallInfo, NonLocals, _, !Goal, VarSet1, VarSet, VarTypes1, VarTypes, RttiVarMaps0, RttiVarMaps), proc_info_set_goal(!.Goal, !ProcInfo), - proc_info_set_varset(VarSet, !ProcInfo), - proc_info_set_vartypes(VarTypes, !ProcInfo), + proc_info_set_varset_vartypes(VarSet, VarTypes, !ProcInfo), proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo) ; Changed = no @@ -2100,7 +2096,7 @@ write_var_usage(Stream, ModuleInfo, PredProcId - VarDepMap, !IO) :- io.format(Stream, "\n%s:\n", [s(PredProcIdStr)], !IO), map.to_assoc_list(VarDepMap, VarDepList), module_info_proc_info(ModuleInfo, PredProcId, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), list.foldl2(write_usage_info(Stream, ModuleInfo, VarSet), VarDepList, [], RevNoDependVars, !IO), list.reverse(RevNoDependVars, NoDependVars), @@ -2151,7 +2147,7 @@ write_arg_var_in_proc(Stream, ModuleInfo, ArgVarInProc, !IO) :- ArgVarInProc = arg_var_in_proc(PredProcId, Var), PredProcIdStr = pred_proc_id_to_string(ModuleInfo, PredProcId), module_info_proc_info(ModuleInfo, PredProcId, ProcInfo), - proc_info_get_varset(ProcInfo, VarSet), + proc_info_get_varset_vartypes(ProcInfo, VarSet, _VarTypes), VarStr = mercury_var_to_string(VarSet, print_name_and_num, Var), io.format(Stream, "%s: %s\n", [s(PredProcIdStr), s(VarStr)], !IO). diff --git a/compiler/unused_imports.m b/compiler/unused_imports.m index 72e66b889..b00a5af4c 100644 --- a/compiler/unused_imports.m +++ b/compiler/unused_imports.m @@ -784,7 +784,7 @@ pred_info_used_modules(ModuleInfo, PredId, PredInfo, !UsedModules) :- used_modules::in, used_modules::out) is det. proc_info_used_modules(Visibility, _ProcId, ProcInfo, !UsedModules) :- - proc_info_get_vartypes(ProcInfo, VarTypes), + proc_info_get_varset_vartypes(ProcInfo, _VarSet, VarTypes), proc_info_get_headvars(ProcInfo, HeadVars), lookup_var_types(VarTypes, HeadVars, HeadVarTypes), list.foldl(mer_type_used_modules(Visibility), HeadVarTypes, !UsedModules),