47 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	f7442dbb1a	Change some "arity"s to "pred_form_arity"s. ... compiler/hlds_rtti.m: compiler/mlds.m: As above. compiler/add_pragma_tabling.m: compiler/ml_accurate_gc.m: compiler/ml_code_util.m: compiler/ml_elim_nested.m: compiler/ml_util.m: compiler/mlds_dump.m: compiler/mlds_to_c_class.m: compiler/mlds_to_c_data.m: compiler/mlds_to_c_file.m: compiler/mlds_to_c_func.m: compiler/mlds_to_c_name.m: compiler/mlds_to_c_stmt.m: compiler/mlds_to_cs_name.m: compiler/mlds_to_java_name.m: compiler/proc_label.m: compiler/rtti_to_mlds.m: Conform to the changes above. Simplify some code that does output. Delete some no-longer-relevant comments.	2022-10-06 09:11:11 +11:00
Zoltan Somogyi	d787ee9355	Store var_tables in proc_infos. ... This fixes the performance problem reported in Mantis bug #562. compiler/hlds_pred.m: Instead of storing a varset and a vartypes in each proc_info, store just a var_table. Update the predicates that create or clone procedures accordingly. Where we had operations on proc_infos that had two versions, one operating on a varset/vartypes pair and one operating on var_table, keep only the latter, with the (shorter) name of the former. Delete the arity argument of proc_info_init, because the only valid value of that argument is the length of the list of the argument types. (In other words, this arg has been redundant all along.) Change the operations that create new variables in a procedure to get the caller to specify the (base) name of the new variable up front. Delete the unused predicate proc_info_ensure_unique_names. compiler/type_util.m: Due to the change above, we now construct var_tables during the construction of the HLDS. The code that does that needs to fill in the field that says whether the type of each variable in the table is a dummy type or not. However, at this time, the pass that decides type representations has not been run yet. The code of is_type_a_dummy used to throw an exception in such situations. Change this so that in such situations, is_type_a_dummy returns a placeholder, not-guaranteed-to-be-correct value. Document why this is ok. compiler/post_typecheck.m: Replace the placeholder values in vte_is_dummy fields in all the entries in the var_tables in all (valid) predicates with valid data. (If there are any invalid predicates, the compilation will fail anyway.) The clause_to_proc pass will copy these updated var_tables to be the initial var_tables in procedures. compiler/make_goal.m: Change the operations that create new variables in a procedure to get the caller to specify the (base) name of the new variable up front. This is simpler than the old method, which created new variables without a name, and had the caller give them a name as a separate operation. And since var_tables need this info, get the caller to also specify whether the type is a dummy, if the type is not a builtin type which is known not to be a dummy. compiler/var_table.m: Document the times when the types and is_dummy fields in var_table entries become meaningful. Fix a potential bug: when performing type substitutions in var_table entries, updating a variable's type may change whether that variable is a dummy or not, so recompute that info. It is quite possible that we *never* replace a nondummy type with a dummy type or vice versa, but in the absence of a convincing correctness argument for that proposition, better safe than sorry. Export the previously-private predicate transform_var_table to post_typecheck. Add code to implement the unused predicate deleted from hlds_pred.m: at the time I wrote it, I haven't yet realised that it was unused. The code I wrote here is therefore unused as well, so it is commented out. I did not delete it, because it may be useful later on. compiler/direct_arg_in_out.m: Don't make and split var_tables, since it is no longer needed. compiler/accumulator.m: compiler/add_class.m: compiler/add_clause.m: compiler/add_heap_ops.m: compiler/add_pred.m: compiler/add_special_pred.m: compiler/add_trail_ops.m: compiler/arg_info.m: compiler/build_mode_constraints.m: compiler/bytecode_gen.m: compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/closure_analysis.m: compiler/code_gen.m: compiler/code_loc_dep.m: compiler/complexity.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/ctgc.livedata.m: compiler/deep_profiling.m: compiler/default_func_mode.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/exception_analysis.m: compiler/float_regs.m: compiler/follow_code.m: compiler/goal_mode.m: compiler/goal_path.m: compiler/higher_order.m: compiler/hlds_out_pred.m: compiler/hlds_rtti.m: compiler/hlds_statistics.m: compiler/inlining.m: compiler/intermod.m: compiler/intermod_analysis.m: compiler/introduce_exists_casts.m: compiler/introduce_parallelism.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/liveness.m: compiler/loop_inv.m: compiler/mark_tail_calls.m: compiler/ml_accurate_gc.m: compiler/ml_args_util.m: compiler/ml_closure_gen.m: compiler/ml_gen_info.m: compiler/ml_proc_gen.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/modecheck_goal.m: compiler/par_loop_control.m: compiler/pd_debug.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism_info.m: compiler/post_typecheck.m: compiler/proc_gen.m: compiler/proc_requests.m: compiler/purity.m: compiler/push_goals_together.m: compiler/quantification.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.live_variable_analysis.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.points_to_graph.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_liveness_info.m: compiler/rbmm.region_transformation.m: compiler/recompute_instmap_deltas.m: compiler/saved_vars.m: compiler/simplify_goal_unify.m: compiler/simplify_info.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.domain.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_constr_initial.m: compiler/term_errors.m: compiler/term_pass1.m: compiler/term_pass2.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/try_expand.m: compiler/tupling.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/unused_imports.m: Conform to the changes above. Mostly this means - not passing a module_info to get a var_table out of a proc_info, but - having to pass a module_info to code that either constructs a var_table, or adds entries to a var_table (since we now need the type table to figure out whether variables' types are dummies).	2022-08-18 18:53:15 +10:00
Zoltan Somogyi	1eb1e239b3	Move the pred_origin type to pred_name.m. ... compiler/pred_name.m: Add the pred_origin type and its component types, moved here from hlds_pred.m and hlds_rtti.m. Also, add the functions and predicates that convert pred_origins to strings, moved here from hlds_pred.m, hlds_out_util.m and layout_out.m. compiler/hlds_pred.m: Delete the pred_origin type moved to pred_name.m. compiler/hlds_rtti.m: Delete the instance_method_constraints type moved to pred_name.m. It has nothing to do with RTTI, and was not used in hlds_rtti.m itself. The only data structure it is part of is pred_origin, though it is used as temporary data by a few other modules. compiler/hlds_out_util.m: compiler/hlds_pred.m: compiler/layout_out.m: Delete the functions and predicates moved to pred_name.m. compiler/*.m: Conform to the change above, mostly by adding imports of pred_name.m, in a few cases replacing hlds_pred.m or hlds_rtti.m.	2022-07-21 05:02:44 +10:00
Zoltan Somogyi	404fea1bd2	Start removing non-var_table versions of predicates. ... compiler/arg_info.m: compiler/goal_util.m: compiler/hlds_rtti.m: compiler/instmap.m: compiler/recompute_instmap_deltas.m: compiler/type_util.m: For predicates which had both varset/vartypes and var_table versions, but the former is not used anymore because all its callers have been switched to the latter, - delete the former, and - rename the latter to the name of the former. In goal_util.m, switch two currently-unused predicates to use var_tables instead of varsets/vartypes, in case they are needed again. compiler/hlds_pred.m: Likewise replace define_new_pred with define_new_pred_vt, but also change its implementation to use var_table for everything except the final construction of the proc_info. compiler/accumulator.m: compiler/call_gen.m: compiler/code_loc_dep.m: compiler/constraint.m: compiler/deforest.m: compiler/delay_construct.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_util.m: compiler/float_regs.m: compiler/follow_code.m: compiler/higher_order.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/liveness.m: compiler/loop_inv.m: compiler/ml_code_gen.m: compiler/modes.m: compiler/pd_info.m: compiler/pd_util.m: compiler/push_goals_together.m: compiler/rbmm.region_liveness_info.m: compiler/saved_vars.m: compiler/simplify_goal.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/table_gen.m: compiler/tupling.m: compiler/unneeded_code.m: compiler/untupling.m: Conform to the changes above.	2022-05-15 21:40:10 +10:00
Zoltan Somogyi	e10ecf5d69	Replace more varsets/vartypes with var_tables. ... compiler/hlds_rtti.m: compiler/hlds_statistics.m: compiler/intermod.m: compiler/loop_inv.m: compiler/recompute_instmap_deltas.m: As above. compiler/special_pred.m: Make some predicate names more meaningful. compiler/hlds_goal.m: Fix one of two instances of an ancient bug, which is not looking for variables inside the call_unify_context field of plain calls. In this instance, apply substitutions to the variables there. Make the names of the predicates involved more meaningful. compiler/lambda.m: Fix the other instance of that ancient bug, which was that the code was not looking for variables inside the call_unify_context fields of plain calls. Fix this by looking for used variables there as well. Without this, the code just added to hlds_goal.m may fail when invoked on the procedure we construct for a lambda, because a variable is included in the var_table of that procedure if lambda.m knows that variable is actually used in the original lambda goal. compiler/var_table.m: Allow searches (as opposed to lookups) for variable names in var_tables as part of transition arrangements to fail. Without this, finding the bug in lambda.m would have been much harder, by causing HLDS dumps to fail.	2022-05-15 14:47:06 +10:00
Zoltan Somogyi	33870445b8	Convert more modules to use var_tables. ... compiler/follow_vars.m: compiler/liveness.m: compiler/saved_vars.m: compiler/stack_alloc.m: compiler/store_alloc.m: compiler/try_expand.m: compiler/unused_imports.m: compiler/var_locn.m: Convert these modules to use var_tables. In many predicates, fix argument order. compiler/live_vars.m: Change the way that this support module keeps track of which variables to treat as dummy variables. Instead of an array with effectively a boolean slot for each variable, use a var_table, but with provision for a user of live_vars.m to specify that *no* variable is to be treated as a dummy, not even variables whose types are dummy types. (Some modules that import live_vars.m want this option.) compiler/hlds_rtti.m: Provide var_table-using versions of existing predicates, and fix their argument order. compiler/code_loc_dep.m: compiler/delay_construct.m: compiler/stack_opt.m: compiler/tupling.m: Conform to the changes above.	2022-04-30 13:27:02 +10:00
Zoltan Somogyi	ea4f95a7ed	Use var_tables in lco.m, and when dumping goals. ... Since this is the first converted module that dumps out goals when debugging trace flags are enabled, this required generalizing the code that does that, to take either varsets or var_tables as a means of specifying the names of variables. We do this via a new type, var_name_source, which contains either a varset or a var_table. Almost all of this diff is there to implement this generalization. A large part of it affects code in the parse_tree package that we use to write out the parts of HLDS goals that are defined by types defined in that package. Since we want to avoid making any part of the parse_tree package dependent on the hlds package, this required defining the var_name_source type in the parse_tree package, which in turn requires var_table.m to be in that same package. compiler/lco.m: Convert this module to use var_tables instead of varsets and vartypes. compiler/var_table.m: Move this module from the hlds package to the parse_tree package. To make this, possible, move the parts that required access to the HLDS to hlds_pred.m, from where it was usually invoked. Export some utility predicates to allow the moved code to work in hlds_pred.m without access to the actual definition of the var_table type. Define the var_name_source type. Add some utility functions for use by code writing out variable names. compiler/hlds_pred.m: Add the code moved from var_table.m. compiler/vartypes.m: Move this module from the hlds package to the parse_tree package, for symmetry with var_table.m. It did not depend on being in hlds in any way. compiler/hlds.m: compiler/parse_tree.m: Move vartypes.m and var_table.m from the hlds package to the parse_tree package. compiler/hlds_out_goal.m: Change all the predicates in this module to take a var_name_source instead of a prog_varset. Fix some comments. compiler/hlds_out_util.m: Change some of the predicates in this module (those called from hlds_out_goal.m) to take a var_name_source instead of a prog_varset. compiler/parse_tree_out_term.m: Provide variants of some existing predicates and functions that take var_name_sources instead of varsets. The code of the copies duplicates the logic of the originals, though I hope that this duplication can be done away with at the end of the transition. (The best solution would be to use a typeclass with methods that convert vars to their names, but we would want to ensure that the compiler can specialize all the affected predicates and functions to the two instances of this typeclass, which is something that we cannot do yet. In the meantime, the lack of any generalization in the old versions preserves their performance.) tools/sort_imports: tools/filter_sort_imports: A new tool that automatically sorts any occurrences of consecutive ":- import_module" declarations in the named files. The sorting is done in filter_sort_imports; sort_imports loops over the named files. After automatically replacing all occurrences of hlds.{vartypes,var_table} in import_module declarations with their parse_tree versions, the updated import_module declarations were usually out of order with respect to their neighbours. I used this script to fix that, and some earlier out-of-order imports. compiler/accumulator.m: compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_heap_ops.m: compiler/add_pragma_type_spec.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/analysis.m: compiler/arg_info.m: compiler/build_mode_constraints.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/check_promise.m: compiler/closure_analysis.m: compiler/closure_gen.m: compiler/code_info.m: compiler/code_loc_dep.m: compiler/common.m: compiler/compile_target_code.m: compiler/complexity.m: compiler/const_prop.m: compiler/constraint.m: compiler/continuation_info.m: compiler/convert_parse_tree.m: compiler/coverage_profiling.m: compiler/cse_detection.m: compiler/ctgc.datastruct.m: compiler/ctgc.util.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/direct_arg_in_out.m: compiler/disj_gen.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/exception_analysis.m: compiler/file_names.m: compiler/float_regs.m: compiler/follow_vars.m: compiler/format_call.m: compiler/generate_dep_d_files.m: compiler/get_dependencies.m: compiler/goal_expr_to_goal.m: compiler/goal_mode.m: compiler/goal_path.m: compiler/goal_store.m: compiler/goal_util.m: compiler/granularity.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_clauses.m: compiler/hlds_code_util.m: compiler/hlds_error_util.m: compiler/hlds_goal.m: compiler/hlds_llds.m: compiler/hlds_out_pred.m: compiler/hlds_rtti.m: compiler/hlds_statistics.m: compiler/inlining.m: compiler/inst_check.m: compiler/inst_test.m: compiler/inst_user.m: compiler/instance_method_clauses.m: compiler/instmap.m: compiler/intermod.m: compiler/intermod_analysis.m: compiler/interval.m: compiler/introduce_exists_casts.m: compiler/introduce_parallelism.m: compiler/item_util.m: compiler/lambda.m: compiler/live_vars.m: compiler/liveness.m: compiler/llds.m: compiler/llds_out_data.m: compiler/llds_out_file.m: compiler/llds_out_util.m: compiler/lookup_switch.m: compiler/loop_inv.m: compiler/make.module_target.m: compiler/make.util.m: compiler/make_goal.m: compiler/make_hlds_separate_items.m: compiler/make_hlds_types.m: compiler/mark_tail_calls.m: compiler/mercury_compile_mlds_back_end.m: compiler/middle_rec.m: compiler/ml_accurate_gc.m: compiler/ml_args_util.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_commit_gen.m: compiler/ml_disj_gen.m: compiler/ml_foreign_proc_gen.m: compiler/ml_gen_info.m: compiler/ml_lookup_switch.m: compiler/ml_proc_gen.m: compiler/ml_simplify_switch.m: compiler/ml_switch_gen.m: compiler/ml_tag_switch.m: compiler/ml_unify_gen.m: compiler/ml_unify_gen_construct.m: compiler/ml_unify_gen_deconstruct.m: compiler/ml_unify_gen_test.m: compiler/ml_unify_gen_util.m: compiler/mlds_to_c_data.m: compiler/mlds_to_c_func.m: compiler/mlds_to_c_global.m: compiler/mlds_to_cs_class.m: compiler/mlds_to_cs_file.m: compiler/mlds_to_java_data.m: compiler/mlds_to_java_file.m: compiler/mlds_to_java_stmt.m: compiler/mlds_to_java_type.m: compiler/mmc_analysis.m: compiler/mode_comparison.m: compiler/mode_constraints.m: compiler/mode_debug.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/mode_ordering.m: compiler/modecheck_call.m: compiler/modecheck_coerce.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/module_cmds.m: compiler/old_type_constraints.m: compiler/opt_debug.m: compiler/optimize.m: compiler/options_file.m: compiler/ordering_mode_constraints.m: compiler/par_loop_control.m: compiler/parse_item.m: compiler/parse_string_format.m: compiler/parse_tree_out_inst.m: compiler/parse_tree_to_term.m: compiler/parse_util.m: compiler/pd_debug.m: compiler/pd_info.m: compiler/pd_util.m: compiler/peephole.m: compiler/polymorphism.m: compiler/polymorphism_info.m: compiler/polymorphism_lambda.m: compiler/polymorphism_type_class_info.m: compiler/polymorphism_type_info.m: compiler/post_typecheck.m: compiler/pragma_c_gen.m: compiler/pred_name.m: compiler/pred_table.m: compiler/prog_item.m: compiler/prog_rep.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/push_goals_together.m: compiler/qual_info.m: compiler/quantification.m: compiler/rbmm.execution_path.m: compiler/rbmm.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.points_to_graph.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_resurrection_renaming.m: compiler/rbmm.region_transformation.m: compiler/recompilation.used_file.m: compiler/recompilation.version.m: compiler/recompute_instmap_deltas.m: compiler/resolve_unify_functor.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/saved_vars.m: compiler/set_of_var.m: compiler/simplify_goal_call.m: compiler/simplify_goal_conj.m: compiler/simplify_goal_disj.m: compiler/simplify_goal_ite.m: compiler/simplify_goal_scope.m: compiler/simplify_goal_switch.m: compiler/simplify_goal_unify.m: compiler/simplify_info.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/smm_common.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.domain.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/superhomogeneous.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_constr_data.m: compiler/term_constr_initial.m: compiler/term_constr_main.m: compiler/term_constr_main_types.m: compiler/term_constr_util.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/term_util.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/transform_llds.m: compiler/try_expand.m: compiler/tupling.m: compiler/type_assign.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_debug.m: compiler/typecheck_errors.m: compiler/typecheck_info.m: compiler/unify_gen_construct.m: compiler/unify_gen_deconstruct.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/var_locn.m: compiler/write_deps_file.m: compiler/write_module_interface_files.m: Conform to the changes above.	2022-04-18 02:00:38 +10:00
Zoltan Somogyi	02f0128c5a	Use var_tables in more of the later passes. ... compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/float_regs.m: compiler/lambda.m: compiler/mark_tail_calls.m: Convert these passes to use var_tables instead of varsets and vartypes. compiler/hlds_pred.m: Provide predicates to get and set "the var_table" of a procedure. The proc_info still stores varsets and vartypes, but these new predicates do the required conversions between representations. Likewise, provide a version of proc_info_create that takes a var_table argument instead of a varset and vartypes arguments. The new predicates should reduce the need for such conversions to be done elsewhere during the transition. compiler/var_table.m: Provide a predicate to turn a var_table back into a <varset, vartypes> pair. Provide two transitional types, var_db and var_type_source, that provide either - the functionality of both a varset and a vartypes, or - just the functionality of a vartypes, using either those structure(s), or a var_table. Make it possible to allocate new variables from a var_table, by including in it a counter that takes on the role played by the var_supply in varsets. Provide a predicate to look up the types of several variables at once. Provide a way to construct a var_table from a reverse sorted assoc list. compiler/vartypes.m: Provide a way to construct a var_table from a reverse sorted assoc list, to allow code to operate the same way on vartypes as on var_tables. library/varset.m: Provide predicates to make the changes in var_table.m possible. They have to be exported, but they are in the second interface section, so they are not publicly documented. compiler/quantification.m: compiler/recompute_instmap_deltas.m: compiler/goal_util.m: Provide versions of some exported predicates that take var_tables instead of varsets and vartypes, for use by the modules above. Rationalize the argument order of some predicates. compiler/instmap.m: Generalize some existing predicates to take type information from either vartypes or var_tables, using a transitional mechanism now provided by var_table.m. Rationalize the argument order of some predicates. compiler/inlining.m: Fix an unrelated bug that just happened to be tickled by the rest of this diff. When inlining a call, set the flag that calls for rerunning determinism analysis on the procedure in which the inlining takes place if the call has an argument variable that does not occur outside the call. We need to do this because ignoring the last output argument(s) of a call can reduce the max possible number of solutions of the call to one. compiler/set_of_var.m: Provide a predicate needed by the fix in inlining.m. compiler/prog_type.m: Give some predicates meaningful names, and create versions that return the same info in a different form (set instead of list). compiler/add_pragma_type_spec.m: compiler/check_typeclass.m: compiler/code_info.m: compiler/continuation_info.m: compiler/deforest.m: compiler/error_util.m: compiler/follow_code.m: compiler/higher_order.m: compiler/hlds_class.m: compiler/hlds_rtti.m: compiler/ml_gen_info.m: compiler/old_type_constraints.m: compiler/parse_class.m: compiler/parse_type_defn.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/polymorphism_type_class_info.m: compiler/post_typecheck.m: compiler/push_goals_together.m: compiler/qual_info.m: compiler/saved_vars.m: compiler/simplify_goal_disj.m: compiler/simplify_goal_ite.m: compiler/simplify_goal_switch.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/table_gen.m: compiler/trace_gen.m: compiler/type_assign.m: compiler/type_ctor_info.m: compiler/typecheck.m: compiler/typeclasses.m: compiler/unneeded_code.m: compiler/unused_args.m: Conform to the changes above.	2022-04-17 13:44:10 +10:00
Zoltan Somogyi	3f3045c9e2	Get and set varsets/vartypes in proc_infos together. ... compiler/hlds_pred.m: We eventually want to replace the varset and vartypes fields in each proc_info with a var_table, but it is not practical to do so at once; it will have to be done gradually, a few modules at most at a time. During this process, we will need a way either - to let already converted modules get a var_table out of the proc_info, and put an updated var_table back into a proc_info, even though proc_infos still contain varset and vartypes fields, or - to let not-yet-converted modules get varsets and vartypes out of the proc_info, and put updated varsets and vartypes back into a proc_info, even though proc_infos already store a var_table. The latter cannot be done in two halves (i.e. set the varset half of the var_table, and then set its vartypes half), and while the former *can* be done that way, it is more efficient to do them at the same time. Therefore as a first step, this diff replaces the indiviual getter and setter predicates of the varset and vartypes fields of proc_info with a getter that gets both and a setter that sets both. Put the varset and vartypes next to each other in a structure. compiler/code_info.m: Delete a function that duplicates a function in var_table.m. Conform to the change above. compiler/det_report.m: Factor out some common code. Conform to the change above. compiler/det_util.m: Delete a no-longer-needed predicate. Conform to the change above. compiler/higher_order.m: Fix an old oversight: when deleting variables from the vartypes, delete them from the varset as well. Conform to the change above. compiler/liveness.m: Avoid constructing and traversing a list unnecessarily. Conform to the change above. compiler/accumulator.m: compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/arg_info.m: compiler/build_mode_constraints.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/clause_to_proc.m: compiler/closure_analysis.m: compiler/code_gen.m: compiler/code_loc_dep.m: compiler/complexity.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/ctgc.datastruct.m: compiler/ctgc.util.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/direct_arg_in_out.m: compiler/disj_gen.m: compiler/equiv_type_hlds.m: compiler/exception_analysis.m: compiler/float_regs.m: compiler/follow_code.m: compiler/goal_mode.m: compiler/goal_path.m: compiler/hlds_out_pred.m: compiler/hlds_rtti.m: compiler/hlds_statistics.m: compiler/inlining.m: compiler/intermod.m: compiler/intermod_analysis.m: compiler/introduce_exists_casts.m: compiler/introduce_parallelism.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/loop_inv.m: compiler/mark_tail_calls.m: compiler/ml_accurate_gc.m: compiler/ml_args_util.m: compiler/ml_closure_gen.m: compiler/ml_gen_info.m: compiler/ml_proc_gen.m: compiler/mode_info.m: compiler/modecheck_goal.m: compiler/modes.m: compiler/par_loop_control.m: compiler/pd_debug.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism_info.m: compiler/proc_gen.m: compiler/purity.m: compiler/push_goals_together.m: compiler/quantification.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.live_variable_analysis.m: compiler/rbmm.points_to_graph.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_liveness_info.m: compiler/rbmm.region_transformation.m: compiler/recompute_instmap_deltas.m: compiler/saved_vars.m: compiler/simplify_goal_unify.m: compiler/simplify_info.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_constr_initial.m: compiler/term_errors.m: compiler/term_pass1.m: compiler/term_pass2.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/try_expand.m: compiler/tupling.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/unused_imports.m: Conform to the change above.	2022-04-07 21:22:21 +10:00
Zoltan Somogyi	d76c7bf617	Break up inst_util.m and mode_util.m. ... This step significantly improves module cohesion. compiler/inst_abstract_unify.m: New module carved out of inst_util.m, which does abstract unifications on insts. compiler/inst_merge.m: New module carved out of inst_util.m, which merges insts. compiler/inst_lookup.m: New module carved partly out of inst_util.m and partly out of mode_util.m, which looks up insts in the module_info, and then possibly expands out the result. compiler/mode_test.m: New module carved out of mode_util.m, whose predicates perform tests on modes. compiler/mode_top_functor.m: New module carved out of mode_util.m, which computes top_functor_modes from modes. compiler/inst_mode_type_prop.m: New module carved out of mode_util.m, which propagates type information into both insts and modes. compiler/recompute_instmap_deltas.m: New module carved out of mode_util.m, which recomputes goals' instmap_deltas. compiler/inst_test.m: Move here the predicates in inst_util.m that perform tests on insts. compiler/inst_util.m: compiler/mode_util.m: Delete the code that this diff moves to other modules. compiler/check_hlds.m: Add the new modules to the check_hlds package, the package that also contains inst_util.m and mode_util.m. (Some of these modules could be argued to fit better in the hlds package, but moving them there would not be desirable while they depend on code that is still in the check_hlds package.) compiler/notes/compiler_design.html: Document the new modules. compiler/add_pragma_tabling.m: compiler/arg_info.m: compiler/bytecode_gen.m: compiler/closure_analysis.m: compiler/complexity.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/det_report.m: compiler/direct_arg_in_out.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/error_msg_inst.m: compiler/fact_table.m: compiler/float_regs.m: compiler/follow_code.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/inlining.m: compiler/inst_match.m: compiler/inst_user.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/introduce_exists_casts.m: compiler/lambda.m: compiler/lco.m: compiler/liveness.m: compiler/lookup_util.m: compiler/loop_inv.m: compiler/mark_tail_calls.m: compiler/ml_args_util.m: compiler/ml_code_util.m: compiler/ml_foreign_proc_gen.m: compiler/ml_unify_gen_construct.m: compiler/ml_unify_gen_util.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/modecheck_call.m: compiler/modecheck_coerce.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/oisu_check.m: compiler/par_conj_gen.m: compiler/pd_util.m: compiler/post_typecheck.m: compiler/pragma_c_gen.m: compiler/proc_requests.m: compiler/prog_rep.m: compiler/push_goals_together.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/simplify_goal_switch.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/stratify.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.domain.m: compiler/superhomogeneous.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_pass2.m: compiler/term_util.m: compiler/tupling.m: compiler/unify_gen_construct.m: compiler/unify_gen_util.m: compiler/unique_modes.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: Conform to the changes above by importing the required new modules, sometimes in addition to inst_util.m or mode_util.m, but more usually instead of them.	2021-12-16 01:31:35 +11:00
Zoltan Somogyi	15aa457e12	Delete $module arg from calls to unexpected.	2018-04-07 18:25:43 +10:00
Zoltan Somogyi	cfcfde1db7	Simplify the representation of modes of unifications. ... Unifications (x = y) have long had two descriptions of their modes. One is the unify_mode, which used to look like this: (initx -> finalx) - (inity -> finaly) and other is the uni_mode, which used to look like this: (initx - inity) -> (finalx - finaly) Each unification had one unify_mode, and each unification that includes a function symbol had one uni_mode per argument of that function symbol. The two forms of mode information looked similar enough to be easily confusable, but were subtly different. As it turns out, there was no particular reason for the difference, so this diff eliminates the uni_mode type, and the difference along with it. What rationale there was for the uni_mode type was that the two modes it represented (one for each side of the unification) both had their initial and final insts directly available. This is not true for modes in general: a value of the mer_mode type could have the form "InitInst -> FinalInst" (which this diff renames "from_to_mode(InitInst, FinalInst)", but could also be a "user_defined_inst(...)", which required a table lookup to turn it into an initial/final pair of insts. This matters, because almost all code that processes the modes of unifications works with the initial and final insts. This diff therefore creates a new type, from_to_insts, which represents mode information only in the form of terms such as "from_to_insts(InitInst, FinalInst)", and makes a unify_mode take two values of this type, not mer_mode, as arguments. As discussed on m-rev, this diff also renames the old, deceptively named "arg_mode" type: its new name is "top_functor_mode". compiler/prog_data.m: compiler/hlds_goal.m: As mentioned above, avoid using "->" as a function symbol, and replace both -> and - with bespoke function symbols. compiler/mode_util.m: Add some utility predicates and functions on the new types, and delete the old utility routines that operated on uni_modes. Code that uses the new functions and predicates should have a higher level of abstraction than the code that used to do the same job "manually". compiler/*.m: Conform to the changes above, using the new utility predicates and functions where relevant. In several cases, this required fixing confusion of the kind described at the top. In all but one case, the confusion affected only variable names, but in one case, deconstruct_functor in make_goal.m, it caused a bug. The bug has had no effect up till now because deconstruct_functor is called only from three places: try_expand.m, stm_expand.m, and untupling.m. The incorrect mode (which was the nonsensical ground -> free) generated by the code of try_expand.m itself was discarded and overwritten when try_expand.m invoked the modechecker. (I don't know whether this bugfix makes that invocation redundant or not.) The other two modules, stm_expand.m and untupling.m, may do something similar, but in any case, they don't yet work for other reasons. (A bootcheck with --untupling causes a compiler abort when compiling deep_profiler/query.m in stage 2 both without and with this fix.) Delete no-longer-needed imports of the pair module (and of some other modules). Put the arguments of some predicates into a more logical order. In bytecode_gen.m, replace clauses with disjunctions, and delete the arguments that this step has revealed to be unused.	2016-05-19 10:43:24 +10:00
Mark Brown	3acbf03059	Implement combined higher-order types and insts. ... These allow types to be defined in the following manner: :- type job ---> job(pred(int::out, io::di, io::uo) is det). For any construction unification using this functor the argument must have the required higher-order inst; it is a mode error if it does not. When terms of type job with inst ground are deconstructed, the argument is inferred to have the given inst, allowing a higher-order call in that mode. The new type syntax is currently only permitted as the direct argument of a functor in a du type definition. In future it would be meaningful to support this syntax in other locations, but that is left for a separate change. In order to correctly implement the construct/3 library predicate, we need to be able to dynamically check that arguments do not violate any constraints on the argument insts. At the moment, we conservatively abort if any such constraints are present irrespective of whether they are satisfied or not. Since these constraints are a new feature, no existing code will abort in this way. The implementation refers to the inst information associated with types as "subtype information". This is because, generally, we think of the combination of a type with a fully bound inst (i.e., one that describes terms that contain no unbound variables) describes a subtype of that type. compiler/inst_util.m: Ensure that arguments have the necessary insts in construction unifications. Where available, propagate the insts into arguments rather than using ground(shared, none). compiler/prog_io_type_name.m: Parse the new form of types. compiler/unparse.m: Unparse the new form of types. compiler/prog_io_type_defn.m: Allow the new form of types in functor arguments. compiler/prog_ctgc.m: compiler/prog_io_item.m: compiler/prog_io_mutable.m: compiler/prog_io_pragma.m: compiler/prog_io_typeclass.m: compiler/superhomogeneous.m: Disallow the new form of types in places other than functor arguments. compiler/prog_data.m: Go back to representing function types with result type appended to the arguments. In most case this now results in simpler code. compiler/prog_type.m: Abstract away the representation of predicate vs function arguments by using a predicate to construct these types. compiler/rtti.m: compiler/type_ctor_info.m: Include subtype information about the arguments of a du functor and about the argument of a notag functor. Generate this information from the argument types. Currently, the information is one bit which says whether or not any subtypes exist in the arguments. Bump the RTTI version number from the compiler side. compiler/rtti_out.m: Output functor subtype information for the low-level C backend. compiler/rtti_to_mlds.m: Include functor subtype information in the MLDS. compiler/mlds_to_cs.m: Add the new runtime type to the special cases. compiler/erl_rtti.m: compiler/erlang_rtti.m: library/erlang_rtti_implementation.m: Include functor subtype info in the erlang RTTI. java/runtime/DuFunctorDesc.java: java/runtime/FunctorSubtypeInfo.java: Include functor subtype information in the Java runtime. runtime/mercury_dotnet.cs.in: Include functor subtype information in the C# runtime. runtime/mercury_type_info.h: Include functor subtype information in the C runtime. Bump the RTTI version number in the runtime. Define macros to access the new field. These macros can correctly handle the previous RTTI version, therefore we do not need to change the minimum version at this time. library/private_builtin.m: Define constants for use by the Java backend. library/construct.m: library/rtti_implementation.m: Use the new RTTI to ensure we don't attempt to construct terms that violate the new insts. compiler/prog_rep_tables.m: Ignore the new inst info for now. compiler/*.m: Changes to conform to above. doc/reference_manual.texi: Document the new feature. tests/hard_coded/functor_ho_inst.{m,exp}: tests/hard_coded/functor_ho_inst_2.{m,exp}: tests/hard_coded/functor_ho_inst_excp.{m,exp}: tests/hard_coded/functor_ho_inst_excp_2.{m,exp}: Test the new functionality. tests/invalid/combined_ho_type_inst.{m,err_exp}: tests/invalid/combined_ho_type_inst_2.{m,err_exp}: Test that we don't allow the new types where they are not permitted, or are incomplete. tests/invalid/functor_ho_inst_bad.{m,err_exp}: tests/invalid/functor_ho_inst_bad_2.{m,err_exp}: tests/invalid/functor_ho_inst_bad_3.{m,err_exp}: Test that the argument inst information is enforced as required. tests/hard_coded/Mmakefile: tests/invalid/Mmakefile: Run the new test cases.	2016-02-08 16:09:01 +11:00
Julien Fischer	3382f49a1c	Fix spelling. ... compiler/*.m: As above.	2015-12-17 09:43:24 +11:00
Zoltan Somogyi	d7ee1af27d	Make a predicate more direct.	2015-12-06 11:03:46 +11:00
Zoltan Somogyi	cc9912faa8	Don't import anything in packages. ... Packages are modules whose only job is to serve as a container for submodules. Modules like top_level.m, hlds.m, parse_tree.m and ll_backend.m are packages in this (informal) sense. Besides the include_module declarations for their submodules, most of the packages in the compiler used to import some modules, mostly other packages whose component modules their submodules may need. For example, ll_backend.m used to import parse_tree.m. This meant that modules in the ll_backend package did not have to import parse_tree.m before importing modules in the parse_tree package. However, this had a price. When we add a new module to the parse_tree package, parse_tree.int would change, and this would require the recompilation of ALL the modules in the ll_backend package, even the ones that did NOT import ANY of the modules in the parse_tree package. This happened even at one remove. Pretty much all modules in every one of the backend have to import one or more modules in the hlds package, and they therefore have import hlds.m. Since hlds.m imported transform_hlds.m, any addition of a new middle pass to the transform_hlds package required the recompilation of all backend modules, even in the usual case of the two having nothing to do with each other. This diff removes all import_module declarations from the packages, and replaces them with import_module declarations in the modules that need them. This includes only a SUBSET of their child modules and of the non-child modules that import them.	2015-11-13 15:03:20 +11:00
Zoltan Somogyi	1db28e27d8	Convert (C->T;E) to (if C then T else E).	2015-10-18 08:59:10 +11:00
Zoltan Somogyi	04dec8c205	Carve vartypes.m, prog_detism.m and prog_rename.m out of prog_data.m. ... Besides defining most of the types representing the smaller parts of parse trees (parts smaller than items), prog_data.m also has many utility predicates that operate on values of these types. Carve the three substantial clusters of predicates out of prog_data.m, and move them into their own modules, which are each imported by fewer modules than prog_data.m itself. compiler/vartypes.m: New module containing the vartypes type and the predicates that operate on it. The new module has *much* better cohesion than the old prog_data.m. The vartypes type does not appear in any parse tree; it is used only in the HLDS. So make vartypes.m part of the hlds.m package, not parse_tree.m. Move three predicates that perform renamings and substitutions on vartypes here from prog_type_subst.m, since the latter is part of the parse_tree.m package, and thus doesn't have access to hlds.vartypes. Make private the service predicate that these three moved predicates used to rely on, since it has no other callers. compiler/prog_detism.m: New module containing utility predicates that operate on determinisms and determinism components. compiler/prog_rename.m: New module containing utility predicates that rename variables in various data structures. compiler/prog_data.m: Remove the stuff now in the three new modules. compiler/prog_type_subst.m: Remove the three predicates now in vartypes.m. compiler/mercury_to_mercury.m: Delete an unneded predicate, which was the only part of this module that referred to vartypes. compiler/prog_type.m: compiler/builtin_lib_types.m: compiler/type_util.m: Move some utility predicates that refer to vartypes from prog_type.m and builtin_lib_types.m (both part of parse_tree.m) to type_util.m (part of check_hlds.m). compiler/parse_tree.m: compiler/hlds.m: compiler/notes/compiler_design.html: Mention the new modules. compiler/accumulator.m: compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_heap_ops.m: compiler/add_pragma_type_spec.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/arg_info.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/clause_to_proc.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/code_loc_dep.m: compiler/common.m: compiler/complexity.m: compiler/const_prop.m: compiler/constraint.m: compiler/continuation_info.m: compiler/coverage_profiling.m: compiler/cse_detection.m: compiler/ctgc.datastruct.m: compiler/ctgc.util.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/disj_gen.m: compiler/equiv_type_hlds.m: compiler/erl_call_gen.m: compiler/erl_code_gen.m: compiler/erl_code_util.m: compiler/exception_analysis.m: compiler/float_regs.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/format_call.m: compiler/goal_expr_to_goal.m: compiler/goal_path.m: compiler/goal_store.m: compiler/goal_util.m: compiler/headvar_names.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_clauses.m: compiler/hlds_goal.m: compiler/hlds_llds.m: compiler/hlds_out_goal.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/inlining.m: compiler/inst_util.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/liveness.m: compiler/lookup_switch.m: compiler/make_goal.m: compiler/mark_tail_calls.m: compiler/ml_accurate_gc.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_disj_gen.m: compiler/ml_gen_info.m: compiler/ml_lookup_switch.m: compiler/ml_proc_gen.m: compiler/ml_unify_gen.m: compiler/mode_constraints.m: compiler/mode_info.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_conj.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/par_loop_control.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_rep.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/qual_info.m: compiler/quantification.m: compiler/rbmm.points_to_graph.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_liveness_info.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/set_of_var.m: compiler/simplify_goal_call.m: compiler/simplify_goal_conj.m: compiler/simplify_goal_disj.m: compiler/simplify_goal_ite.m: compiler/simplify_goal_scope.m: compiler/simplify_goal_switch.m: compiler/simplify_goal_unify.m: compiler/simplify_info.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_constr_initial.m: compiler/term_constr_util.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/term_util.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/try_expand.m: compiler/tupling.m: compiler/type_assign.m: compiler/type_constraints.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/var_locn.m: Conform to the above changes, mostly by importing some of the three new modules as well as, or instead of, prog_data.m.	2015-08-09 19:02:12 +10:00
Zoltan Somogyi	471213371d	Move the context into goals in the parse tree. ... compiler/prog_item.m: The parse tree's goal type used to be defined as a pair of a goal_expr and a context. This diff moves the context into each function symbol of the goal_expr type, which it also renames the goal type, since it now contains all the information that the old goal type did. This reduces both the number of memory cells allocated (from two to one for each goal) and the total amount of memory allocated (since we don't need a pointer from the goal to the goal_expr), though the effect on performance is in the noise on tools/speedtest. The effect on performance when the compiler is just generating interface files should be bigger (since in such cases parsing takes a bigger proportion of the overall runtime), but (a) we don't have tools to measure that, and (b) each such invocation is plenty fast already, and they take nontrivial amounts of time only when invoked en masse. Add a utility predicate to get a goal's context, since we need it in a few cases. compiler/goal_expr_to_goal.m: Conform to the change in the goal type. Generate HLDS goals with the right contexts from the start, instead of creating them with dummy contexts and then setting the right context later. In a few pathological cases (such as conjunction containing explicit "true" goals), this leads to goals with different contexts than before, but in the cases I found, the new contexts are more appropriate. Make the code handling conjunctions easier to understand by using cords (which were not available when that code was written). The old code mixed reversed and double-reversed lists. When processing unifications like !X = f, don't just generate an error message; also pretend that !:X has been defined, to avoid later misleading error messages. Avoid situations in which Goal0 represents a parse tree goal and Goal a HLDS goal. Make the switch of representations obvious by switching to a different name (e.g. Goal to HLDSGoal), not just to a different numeric suffix. compiler/state_var.m: Conform to the change in the goal type. Provide a utility predicate to do the "pretending" part just above. compiler/*.m: Conform to the change in the goal type. In some cases, create new HLDS goals with the right context. library/term.m: Add a function to apply a singleton renaming (a renaming of just one variable) to a term, since some of the above changes can use this. Clean up the code in this module a bit: use meaningful variable names, and put the function versions of predicates next to those predicates. The order of predicates is still haphazard. tests/invalid/bad_sv_unify_msg.err_exp: Expect an error message at the correct context, and don't expect the redundant message we now don't generate.	2015-01-24 22:42:10 +11:00
Zoltan Somogyi	500948d549	Break up mdbcomp/prim_data.m. The new modules have much better cohesion. ... mdbcomp/sym_name.m: New module, containing the part of the old prim_data.m that dealt with sym_names. mdbcomp/builtin_modules.m: New module, containing the part of the old prim_data.m that dealt with builtin modules. mdbcomp/prim_data.m: Remove the things that are now in the two new modules. mdbcomp/mdbcomp.m: deep_proiler/Mmakefile: slice/Mmakefile: Add the two new modules. browser/*.m: compiler/*.m: deep_proiler/*.m: mdbcomp/*.m: slice/*.m: Conform to the above changes.	2014-09-02 05:20:23 +02:00
Zoltan Somogyi	6d1bc24d0b	Make vartypes an abstract data type, in preparation for exploring ... Estimated hours taken: 4 Branches: main compiler/prog_data.m: Make vartypes an abstract data type, in preparation for exploring better representations for it. compiler/mode_util.m: Provide two different versions of a predicate. The generic version continues to use map lookups. The other version knows it works on prog_vars, so it can use the abstract operations on them provided by prog_data.m. compiler/accumulator.m: compiler/add_class.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/arg_info.m: compiler/builtin_lib_types.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/clause_to_proc.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/common.m: compiler/complexity.m: compiler/const_prop.m: compiler/constraint.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/ctgc.datastruct.m: compiler/ctgc.util.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/disj_gen.m: compiler/equiv_type_hlds.m: compiler/erl_call_gen.m: compiler/erl_code_gen.m: compiler/erl_code_util.m: compiler/exception_analysis.m: compiler/float_regs.m: compiler/follow_vars.m: compiler/format_call.m: compiler/goal_path.m: compiler/goal_util.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_clauses.m: compiler/hlds_goal.m: compiler/hlds_out_goal.m: compiler/hlds_out_pred.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/inlining.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/liveness.m: compiler/lookup_switch.m: compiler/mercury_to_mercury.m: compiler/ml_accurate_gc.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_disj_gen.m: compiler/ml_lookup_switch.m: compiler/ml_proc_gen.m: compiler/ml_unify_gen.m: compiler/mode_info.m: compiler/modecheck_call.m: compiler/modecheck_conj.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/par_loop_control.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_type_subst.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/qual_info.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_liveness_info.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_opt.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_constr_util.m: compiler/term_traversal.m: compiler/term_util.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/try_expand.m: compiler/tupling.m: compiler/type_constraints.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/typecheck_info.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/untupling.m: compiler/unused_args.m: compiler/var_locn.m: Conform to the above. compiler/prog_type.m: compiler/rbmm.points_to_graph.m: Conform to the above. Move some comments where they belong. compiler/stm_expand.m: Conform to the above. Do not export a predicate that is not used outside this module. Disable some debugging output unless it is asked for. Remove unnecessary prefixes on variable names. library/version_array.m: Instead writing code for field access lookalike functions and defining lookup, set etc in terms of them, write code for lookup, set etc, and define the field access lookalike functions in terms of them. Change argument orders of some internal predicates to be more state variable friendly. Fix typos in comments. tests/hard_coded/version_array_test.exp: Conform to the change to version_array.m.	2012-07-02 01:16:39 +00:00
Zoltan Somogyi	7487590f2d	Predicates with many variables, such as some of those in zm_enums.m, ... Estimated hours taken: 24 Branches: main Predicates with many variables, such as some of those in zm_enums.m, tickle pretty bad behavior in the liveness and stack_alloc passes. This is because those passes manipulate sets of variables, which in such cases are large sets of variables, and the quadratic behavior of repeated operations on sets represents as sorted lists hurts us. This diff changes the representation of the sets of variables involved in those two passes, which are the prebirth, postbirth, predeath and postdeath sets in goal_infos, to be values of an abstract type (set_of_progvar). By default, these are implemented using tree_bitsets, which have much better worst case behaviour that set_ordlists. When compiling zm_enums with debugging enabled, this diff speeds up the liveness pass by about half and the stack alloc pass by about a third, with the overall speedup being about 6% (due to some other expensive passes). On tools/speedtest -l, the result is a 3.4% slowdown. Since the slowdown worsens slightly if I make the abstract representation of sets of prog_vars be the existing representation (an ordinary set), I think this slowdown is due to the conversions that are now required in some places between the abstract representation and an explicit set(prog_var) representation. As such, as other uses of set(progvar) get converted to set_of_progvar, this slowdown should disappear. compiler/set_of_var.m: The new module that contains the set_of_progvar abstract data type. This module also contains a copy of the code of the graph_colour module. Since the set_of_progvar type is private, this is necessary if we want all the set operations done by graph colouring (which does the bulk of the work of the stack alloc pass) to use the preferred set representation. compiler/graph_colour.m: Note that this module is no longer used. compiler/stack_alloc.m: compiler/liveness.m: Switch over to using the new module. compiler/parse_tree.m: Include set_of_var among the modules of this package. (It is in this package because the prog_var type is defined in this package.) compiler/test_bitset.m: A module that allows new set implementations to be tested. It is an extended and specialized version of the bitset_tester module from tests/hard_coded. compiler/hlds_llds.m: Use the set_of_progvar type for the prebirth, postbirth, predeath and postdeath sets in goal_infos, and for other liveness-related sets of variables. compiler/code_info.m: Some of the fields of the code_info structure represent sets of variables, and some of the predicates defined by this module have arguments that are sets of variables. If these sets represent entities that are computed from prebirth, postbirth, predeath and postdeath sets or from other goal_info fields that have been changed to the set_of_progvar representation, change them to use the set_of_progvar representation as well, or, in a few cases, to plain sorted lists. Conform to the above change. compiler/proc_type.m: Add a utility predicate to operate of set_of_progvar. Replace a lambda expression with a named predicate. compiler/quantification.m: Until now, quantification.m used its own private abstract type (defined as tree_bitset) to represent sets. Make it use set_of_progvar instead, since it has the same purpose. This eliminates a potential maintenance problem. compiler/call_gen.m: compiler/code_gen.m: compiler/commit_gen.m: compiler/delay_construct.m: compiler/disj_gen.m: compiler/hlds_out_goal.m: compiler/hlds_rtti.m: compiler/interval.m: compiler/ite_gen.m: compiler/live_vars.m: compiler/lookup_switch.m: compiler/lookup_util.m: compiler/matching.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/pragma_c_gen.m: compiler/proc_gen.m: compiler/simplify.m: compiler/stack_opt.m: compiler/store_alloc.m: compiler/string_switch.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_sharing.domain.m: compiler/switch_util.m: compiler/trace_gen.m: compiler/tupling.m: compiler/unify_gen.m: compiler/unused_args.m: Conform to the above change. library/map.m: Add a utility predicate, map.select_sorted_list, which functions the same way as map.select, but takes a sorted list as argument instead of a set. library/set_ordlist.m: Bring the interface of this module closer to set.m and tree_bitset.m to make them more easily interchangeable. This required adding the predicates is_non_empty and is_singleton, as well as adding predicate forms of union_list and intersect_list. I also added missing type_spec pragmas for some predicates frequently used by the compiler. library/tree_bitset.m: Bring the interface of this module closer to set.m and set_ordlist.m to make them more easily interchangeable. This required adding the predicates is_non_empty and is_singleton, and both function and predicate forms of union_list and intersect_list. Fix an old bug in the difference operation. Given SetA - SetB, if SetA was the empty set, then this operation would correctly return the empty set if SetB was small (represented by a leaf list), but would incorrectly return SetB if it was large (represented by an interior node list).	2011-07-21 06:58:34 +00:00
Zoltan Somogyi	295415090e	Convert almost all remaining modules in the compiler to use ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all remaining modules in the compiler to use "$module, $pred" instead of "this_file" in error messages. In a few cases, the old error message was misleading, since it contained an incorrect, out-of-date or cut-and-pasted predicate name. tests/invalid/unresolved_overloading.err_exp: Update an expected output containing an updated error message.	2011-05-23 05:08:24 +00:00
Julien Fischer	78b0bf3c7f	Use state variable field update syntax in more places. ... Branches: main Use state variable field update syntax in more places. browser/*.m: compiler/*.m: deep_profiler/*.m: As above.	2011-05-05 07:11:52 +00:00
Julien Fischer	9f68c330f0	Change the argument order of many of the predicates in the map, bimap, and ... Branches: main Change the argument order of many of the predicates in the map, bimap, and multi_map modules so they are more conducive to the use of state variable notation, i.e. make the order the same as in the sv* modules. Prepare for the deprecation of the sv{bimap,map,multi_map} modules by removing their use throughout the system. library/bimap.m: library/map.m: library/multi_map.m: As above. NEWS: Announce the change. Separate out the "highlights" from the "detailed listing" for the post-11.01 NEWS. Reorganise the announcement of the Unicode support. benchmarks/*/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: extras/*/*.m: mdbcomp/*.m: profiler/*.m: tests/*/*.m: ssdb/*.m: samples/*/*.m slice/*.m: Conform to the above change. Remove any dependencies on the sv{bimap,map,multi_map} modules.	2011-05-03 04:35:04 +00:00
Zoltan Somogyi	8a28e40c9b	Add the predicates sorry, unexpected and expect to library/error.m. ... Estimated hours taken: 2 Branches: main Add the predicates sorry, unexpected and expect to library/error.m. compiler/compiler_util.m: library/error.m: Move the predicates sorry, unexpected and expect from compiler_util to error. Put the predicates in error.m into the same order as their declarations. compiler/*.m: Change imports as needed. compiler/lp.m: compiler/lp_rational.m: Change imports as needed, and some minor cleanups. deep_profiler/*.m: Switch to using the new library predicates, instead of calling error directly. Some other minor cleanups. NEWS: Mention the new predicates in the standard library.	2010-12-15 06:30:36 +00:00
Zoltan Somogyi	ea2240197f	Note a problem with our current data structure design. ... Estimated hours taken: 1 Branches: main compiler/hlds_rtti.m: Note a problem with our current data structure design. compiler/hlds_rtti.m: compiler/quantification.m: Fix some issues of programming style.	2010-09-15 07:02:01 +00:00
Zoltan Somogyi	d4bbcda309	Move all the frequently occurring layout structures and components of layout ... Estimated hours taken: 40 Branches: main Move all the frequently occurring layout structures and components of layout structures into arrays where possible. By replacing N global variables holding individual layout structures or layout structure components with one global variable holding an array of them, we reduce the sizes of the symbol tables stored in object files, which should speed up both the C compiler and the linker. Measured on the modules of the library, mdbcomp and compiler directories compiled in grade asm_fast.gc.debug, this diff reduces the size of the generated C source files by 7.8%, the size of the generated object files by 10.4%, and the number of symbols in the symbol tables of those object files by a whopping 42.8%. (These improvements include, and are not on top of, the improvements in my previous similar diff.) runtime/mercury_stack_layout.h: Each label layout structure has information about the type and location of every variable that is live at that label. We store this information in three arrays: an array of pseudo-typeinfos giving the types of all these variables, and two arrays MR_ShortLvals and MR_LongLvals respectively giving their locations. (Most of the time, the location's encoded form fits into one byte (the MR_ShortLval) but sometimes it needs more bits (this is when we use MR_LongLval)). We used to store these three arrays, whose elements are different types, in a single occurrence-specific common structure, one after the other, with a cumbersome mechanism being required to access them. We now store them as segments of three separate arrays, of pseudo-typeinfos, MR_ShortLvals and MR_LongLvals respectively. This makes access simpler and faster (which will matter more to any accurate garbage collector than it does to the debugger). It also allows more scope for compression, since reusing an existing segment of one of the three arrays is easier than reusing an entire common structure, which would require the equivalent of exact matches on all three arrays. Since most label layout structures that have information about variables can encode the variables' locations using only MR_ShortLvals, create a version of the label layout structure type that omits the field used to record the whereabouts of the long location descriptors. Add macros now generated by the compiler to initialize layout structures. Simplify a one-field struct. runtime/mercury_grade.h: Increment the binary compatibility version number for debuggable executables, since .c and .o files from before and after the change to label layout structures are NOT compatible. runtime/mercury_type_info.h: Fix some binary-compatibility-related bit rot. runtime/mercury_misc.h: Move here the existing macros used by the compiler when generating references to layout arrays, and add new ones. runtime/mercury_goto.h: Delete the macros moved to mercury_misc.h. Conform to the changes in mercury_stack_layout.h. runtime/Mmakefile: Prevent the unnecessary rebuilding of mercury_conf.h. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_layout_util.c: runtime/mercury_stack_trace.c: runtime/mercury_types.h: trace/mercury_trace.c: trace/mercury_trace_vars.c: Conform to the changes in mercury_stack_layout.h. runtime/mercury_wrapper.c: Improve the debug support a bit. runtime/mercury_engine.h: Fix style. compiler/layout.m: Make the change described at the top. Almost all layout structures are now in arrays. The only exceptions are those that occur rarely, and proc layouts, whose names need to be derivable from the name of the procedure itself. Instead of having a single type "layout_data" that can represent different kinds of single global variables (not array slots), have different kinds for different purposes. This makes the code clearer and allows traversals that do not have to skip over inapplicable kinds of layout structures. compiler/layout_out.m: Output the new arrays. compiler/stack_layout.m: Generate the new arrays. Previously, an individual term generated by stack_layout.m could represent several components of a layout structure, with the components separated by layout_out.m. We now do the separation in stack_layout.m itself, adding each component to the array to which it belongs. Instead of passing around a single stack_layout_info structure, pass around several smaller one. This is preferable, since I found out the hard way that including everything in one structure would give the structure 51 fields. Most parts of the module work with only one or two of these structures, which makes their role clearer. Cluster related predicates together. compiler/options.m: doc/user_guide.texi: Add an option that control whether stack_layout.m will attempt to compress the layout arrays that can meaningfully be comressed. compiler/llds.m: Remove the old distinction between a data_addr and a data_name, replacing both types with a single new one: data_id. Since different kinds of data_names were treated differently in many places, the distinction in types (which was intended to allow us to process data_addrs that wrapped data_names differently from other kinds of data_addrs) wasn't buying us anything anymore. The new data_id type allows for the possibility that the code generator wants to generate a reference to an address it does not know yet, because it is a slot in a layout array, and the slot has not been allocated yet. Add the information from which the new layout array structures will be generated to the LLDS. compiler/llds_out.m: Call layout_out.m to output the new layout arrays. Adapt the decl_id type to the replacement of data_addrs by data_ids. Don't both keeping track of the have-vs-have-not-declared status of structures that are always declared at the start. When writing out a data_addr, for some kinds of data_addr, llds_out.m would write out the name of the relevant variable, while for some other kinds, it would write out its address. This diff separates out those those things into separate predicates, each of which behaves consistently. compiler/mercury_compile_llds_back_end.m: Convey the intended contents of the new layout arrays from stack_layout.m to llds_out.m. compiler/continuation_info.m: Add a type required by the way we now generate proc_static structures for deep profiling. compiler/hlds_rtti.m: Add distinguishing prefixes to the field names of the rtti_proc_label type. compiler/code_info.m: compiler/code_util.m: compiler/erl_rtti.m: compiler/exprn_aux.m: compiler/global_data.m: compiler/ll_pseudo_type_info.m: compiler/ml_code_util.m: compiler/opt_debug.m: compiler/proc_gen.m: compiler/prog_rep.m: compiler/rtti_out.m: compiler/unify_gen.m: Conform to the changes above. tests/debugger/declarative/track_through_catch.exp: Expect procedures to be listed in the proper order. tests/EXPECT_FAIL_TESTS.asm_fast.gc.debug: tests/EXPECT_FAIL_TESTS.asm_fast.gc.profdeep: Add these files to ignore expected failues in these grades.	2009-10-30 03:33:34 +00:00
Zoltan Somogyi	9bf2fb9330	Follow Mark's review suggestion. ... Estimated hours taken: 0.1 Branches: main compiler/hlds_rtti.m: Follow Mark's review suggestion.	2009-09-22 04:38:23 +00:00
Zoltan Somogyi	62d7496a7e	Significant further improvements in the worst-case behavior of the compiler ... Estimated hours taken: 16 Branches: main Significant further improvements in the worst-case behavior of the compiler when working on code such as zm_eq20.m and zm_coerce_tuples.m. On my laptop, zm_eq20.m and zm_coerce_tuples.m now compile in 2.5s and 12.9s respectively; the times before were 86.4s and 54.0s. The sizes of the stage 110 HLDS dumps (the stage just after lambda expansion) go from 8.5Mb and 760Mb (!) to just 0.4Mb and 7.4Mb respectively. compiler/polymorphism.m: Remember not just which typeinfos we have constructed, but also what type_ctor_infos, base_typeclass_infos and typeclass_infos we have constructed, so that we don't have to construct them again for code that is executed later. The maintenance of the additional maps adds some overhead that in typical code probably cannot be made back through the resulting reductions in the workload of later compiler passes. However, the avoidance of horrible worst-case behavior trumps small increases in normal-case runtime. For zm_coerce_tuples, polymorphism.m now generates as good HLDS code as can be expected within each lambda expression. There is still a lot of duplicated code, with each copy being in a different lambda expression, but factoring out these commonalities will require a fundamentally different approach. Avoid using the misleading prefix "TypeClassInfo_" on the names of variables holding base_typeclass_infos. compiler/ml_elim_nested.m: Don't look for static definitions where they cannot occur anymore. When deciding whether a definition needs to be hoisted out, don't look for it being used in later static definitions, since all the static definitions are now elsewhere. In order to avoid running the compiler out of nondet stack space on zm_coerce_tuples.m, avoid the use of enumerating all the definitions in a potentially huge piece of MLDS by backtracking. compiler/hlds_rtti.m: Avoid enumerating all the members of a potentially huge list by backtracking in order to avoid running the compiler out of nondet stack space on zm_coerce_tuples.m. I first tried to do this by constructing the list with det code, but this turned out not to fix the underlying problem, which was that almost all of the list's elements were copies of each other, and we then had to get rid of the copies. The actual fix is to gather the types we need directly as a set. Provide restrict_rtti_varmaps for use by lambda.m. Give the field names of the rtti_varmaps type a distinguishing prefix. compiler/lambda.m: The fundamental reason for the bad performance of the equiv_type_hlds pass on zm_coerce_tuples.m was that even with the recent improvements to polymorphism.m, a couple of big predicates had about ten thousand variables each, and when lambda.m created about 200 new procedures from the lambda expressions inside them, it duplicated those huge vartypes and rtti_varmaps for each one. The fix is to restrict the vartypes and the rtti_varmaps of both the newly created procedures and the old procedure they were taken from to the variables that actually occur in them. We could potentially avoid the need to restrict the rtti_varmap of the original procedure for the new procedures created for lambda goals by having polymorphism.m give each rhs_lambda_goal its own rtti_varmap in the first place, but that would be future work. Use the "no lambda" version of quantification after the lambda pass, since we have just removed all the lambdas from the goal being quantified. Give the predicates of this module more expressive names. compiler/mercury_compile.m: Conform to the change in lambda.m. compiler/equiv_type_hlds.m: Use specialized versions of the predicates in equiv_type.m, since the general versions do some things (finding circularities, recording used modules) that this pass does not need. Use some new predicates from the standard library to reduce overhead. compiler/ml_optimize.m: In order to avoid running the compiler out of nondet stack space on zm_coerce_tuples.m, avoid the use of enumerating all the members of a potentially huge list by backtracking. Move a cheap test before a more expensive one. compiler/modes.m: compiler/modecheck_unify.m: Avoid some unnecessary overheads when modechecking typeinfos and related variables. One overhead was iteration over a list of exactly one element, another is a redundant lookup of the variable's type, and the third is the redundant setting of the unify context. compiler/inst_match.m: Use set_tree234s instead sets to keep track of expansions in one group of predicates indicated by benchmarking. library/list.m: Add a new predicate, list.find_first_match, which is a version of filter that returns only the first matching item. This is for use in ml_elim_nested.m. Make list.sort_and_remove_dups remove duplicates as it goes, not all at the end, since this (a) allows us to avoid a separate duplicate-elimination pass at the end, and (b) any duplicate eliminated in one merge pass reduces the workload for any later merge passes. Put some code in its proper order, since preserving tail recursion in Prolog is no longer an issue. library/map.m: Add versions of map.foldl{,2,3} and map.map_foldl{,2,3} that do not pass the key to the higher order argument, for use by some of the compiler modules above. Group the declarations of all the foldr predicates together. library/tree.m: Make the same changes as in map.m, in order to implement map.m's new predicates. library/varset.m: Minor style improvements. library/set_tree234.m: Fix a wrong comment. NEWS: Mention the new additions to the library.	2009-09-16 02:32:56 +00:00
Zoltan Somogyi	5af57da91d	Further compiler speedups. ... Estimated hours taken: 4 Branches: main Further compiler speedups. library/varset.m: Speed up predicates by avoding making the same decisions over and over again. library/tree234.m: library/map.m: NEWS: Add tree234.map_values_only and map.map_values_only. compiler/add_pragma.m: compiler/analysis.m: compiler/code_info.m: compiler/cse_detection.m: compiler/cse_detection.m: compiler/equiv_type_hlds.m: compiler/global_data.m: compiler/hlds_out.m: compiler/hlds_rtti.m: compiler/inst_graph.m: compiler/lp_rational.m: compiler/hlds_out.m: compiler/mlds_to_il.m: compiler/modules.m: compiler/par_conj_gen.m: compiler/polymorphism.m: compiler/prog_data.m: compiler/prog_type_subst.m: compiler/recompilation.version.m: compiler/simplify.m: compiler/stack_layout.m: compiler/type_util.m: compiler/unneeded_code.m: Use the new predicates. compiler/mark_static_terms.m: Do not bother traversing from_ground_term_construct scopes. Remove a redundant test. compiler/ml_unify_gen.m: Speed up a predicate by avoding making the same decisions over and over again. compiler/mlds.m: Factor out some code. compiler/typecheck_info.m: Operate on vartypes directly as maps; don't transform them unnecessarily into association lists. Do not bother to apply empty substitutions.	2009-09-03 23:07:33 +00:00
Peter Wang	b0f7bc706f	Fix bug #90. The compiler would abort on the given program when performing ... Branches: main Fix bug #90. The compiler would abort on the given program when performing higher order/type specialisation due to "inconsistent type_infos". compiler/higher_order.m: In interpret_typeclass_info_manipulator, when assigning to a variable TypeInfoVar the extracted field of a type_info TypeInfoArg, duplicate the TypeInfoArg rtti_var_info for TypeInfoVar. On the test program the rtti_var_info for TypeInfoVar already existed but was for the procedure *before* specialisation, which is what lead to the inconsistent type_infos message. compiler/hlds_rtti.m: Add version of rtti_var_info_duplicate which doesn't abort if the rtti_varmap already has an entry for the target variable. tests/valid/Mercury.options: tests/valid/Mmakefile: tests/valid/tci_spec_varmap.m: Add test case.	2009-06-12 02:08:58 +00:00
Paul Bone	2d4554f0d2	In the case of an inconsistent rtti_type_infos error print the rtti_type_infos ... Estimated hours taken: 1.0 Branches: main In the case of an inconsistent rtti_type_infos error print the rtti_type_infos that cause this error. Add an option that forces the pre-profiling simplification pass at stage 215 to be run, even when profiling is not enabled. This is helpful when debugging generated code that may be removed by the dead procedure elimination stage. compiler/hlds_rtti.m: As above. compiler/options.m: Introduce the new --simplify-stage-215 option. compiler/handle_options.m: The logic that ensures that --profile_deep, --record-term-sizes-as-words and --record-term-sizes-as-cells imply --pre-prof-transforms-simplify has been added here, it was originally in the simplify predicate of mercury_compile.m compiler/mercury_compile.m: Rename simplify to maybe_simplify. Refactor maybe_simplify, it now uses --pre-prof-transforms-simplify to decide if simplification should be done before the deep profiling transformation.	2009-03-01 23:26:03 +00:00
Mark Brown	feab1f5e66	Fix a failure to compile analysis.m in grade asm_fast.gc.decldebug. ... Estimated hours taken: 20 Branches: main Fix a failure to compile analysis.m in grade asm_fast.gc.decldebug. The problem was that common.m would leave references to type-info variables that are assigned (i.e., introduced by common.m) rather than the type-infos that come from constructions, deconstructions or procedure calls. Later on, excess-assignment removal may leave these as dangling references. The fix is to always ensure that we refer to the original type-info, not the assigned one. compiler/common.m: When generating an assignment, first apply substitutions to the RttiVarMaps which eliminate the "To" variable in favor of the "From" variable. Then duplicate the information for the "To" variable. compiler/simplify.m: Export a procedure to perform the above steps on a simplify_info. compiler/hlds_rtti.m: Make use of the prog_var_renaming type. compiler/Mercury.options: Add a note that the workaround can be removed once the compiler is installed.	2008-03-26 01:38:47 +00:00
Zoltan Somogyi	672f77c4ec	Add a new compiler option. --inform-ite-instead-of-switch. ... Estimated hours taken: 20 Branches: main Add a new compiler option. --inform-ite-instead-of-switch. If this is enabled, the compiler will generate informational messages about if-then-elses that it thinks should be converted to switches for the sake of program reliability. Act on the output generated by this option. compiler/simplify.m: Implement the new option. Fix an old bug that could cause us to generate warnings about code that was OK in one duplicated copy but not in another (where a switch arm's code is duplicated due to the case being selected for more than one cons_id). compiler/options.m: Add the new option. Add a way to test for the bug fix in simplify. doc/user_guide.texi: Document the new option. NEWS: Mention the new option. library/*.m: mdbcomp/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: Convert if-then-elses to switches at most of the sites suggested by the new option. At the remaining sites, switching to switches would have nontrivial downsides. This typically happens with the switched-on type has many functors, and we treat one or two specially (e.g. cons/2 in the cons_id type). Perform misc cleanups in the vicinity of the if-then-else to switch conversions. In a few cases, improve the error messages generated. compiler/accumulator.m: compiler/hlds_goal.m: (Rename and) move insts for particular kinds of goal from accumulator.m to hlds_goal.m, to allow them to be used in other modules. Using these insts allowed us to eliminate some if-then-elses entirely. compiler/exprn_aux.m: Instead of fixing some if-then-elses, delete the predicates containing them, since they aren't used, and (as pointed out by the new option) would need considerable other fixing if they were ever needed again. compiler/lp_rational.m: Add prefixes to the names of the function symbols on some types, since without those prefixes, it was hard to figure out what type the switch corresponding to an old if-then-else was switching on. tests/invalid/reserve_tag.err_exp: Expect a new, improved error message.	2007-11-23 07:36:01 +00:00
Zoltan Somogyi	fcf0847a91	My previous fix to dead proc elimination helped fixed some compiler aborts, ... Estimated hours taken: 8 Branches: main My previous fix to dead proc elimination helped fixed some compiler aborts, but a related problem remained. The problem involved an unused procedure that was kept around so that the code generator would create the table associated with it. Since the procedure was unused, its body was thought to be unused too. If it contained a reference to a procedure that wasn't referred to from anywhere else, that procedure would be removed, leaving a dangling reference. This would cause a code generator abort. We can't fix the abort by replacing the kept-around procedure's body with "true", since that would cause a different code generator abort when moving the (now unbound) output variables to their argument registers. We could avoid generating any code for the procedure at all by e.g. marking it as opt_imported, but this would (a) be inconsistent and (b) require special case coding to still generate the table structure. The fix is to generate the global variable used for tabling *independently* of the procedure that enters things in the table. compiler/hlds_module.m: Add a field to the module_info (actually module_sub_info) that records the information the backends need to create the global variables representing call tables. Name all the fields of the module_info and module_sub_info during initialization, to make it easier to know where to add a new field. Put the initializations of the fields in the same order as the fields themselves. compiler/hlds_pred.m: Keep only the info for I/O tabling in procedures, since such tabling does not require defining a per-procedure global variable. Since the info for the forms of tabling that *do* require a per-procedure global variable are now divorced from the procedure, change their definition to avoid storing prog_vars in them, since those prog_vars would be separated from their varset. Instead, we record their numbers and their names (both are used only for debug support). On the other hand, some info from the pred_info and proc_info are to create the global variable; copy them into the data structure stored in hlds_module. Rename some fields to avoid ambiguities. compiler/table_gen.m: Continue to record information about I/O tabling in the proc_info, but record information about other forms of tabling in the new field in the module_info. compiler/rtti.m: compiler/hlds_rtti.m: Move the functions for constructing and deconstructing rtti_proc_labels from rtti.m (which is in backend_libs) to hlds_rtti.m (which is in hlds); the definition of rtti_proc_label was already in hlds_rtti.m. The move is needed to allow table_gen to put an rtti_proc_label in the data structures it puts in the module_info. compiler/hlds_out.m: Print out the new module_info field, and conform to the change to hlds_pred and table_arg_info. Always print variable numbers for type variables in table_arg_infos. compiler/continuation_info.m: Make room for either kind of tabling info for a procedure. (While the LLDS code generator doesn't need to know about the global variable representing the call table in order to create it, it does need to know about it in order to describe it to the debugger.) Conform to the change in table_arg_info. Rename some fields to avoid ambiguities. compiler/proc_gen.m: When generating code for procedures, do not try to create a per-procedure tabling struct, but do fill in the slot describing it in the continuation_info. Add a predicate to define all the tabling structs in a module. compiler/mercury_compile.m: Call proc_gen separately to define all the tabling structs. compiler/ml_code_gen.m: As with proc_gen, define tabling structs directly from the module_info and not when generating code from each proc_info. (The code for handling each proc is now logically not contiguous; I will address that in a separate change, to make the diff for this one easier to read.) compiler/dead_proc_elim.m: Don't keep unused tabled procedures alive, since that leads to the problem described up top. Keep track of which tabling structs are live, but don't yet act on that information, since some uses are hidden (for now). Add conditionally compiled tracing code that helped me trace down the problem. Fix an oversight in the severity level of an error spec. compiler/base_typeclass_info.m: compiler/code_util.m: compiler/deep_profiling.m: compiler/ml_code_util.m: compiler/proc_label.m: compiler/type_ctor_info.m: Conform to the move of make_rtti_proc_label. compiler/optimize.m: Conform to the change to continuation_info. compiler/stack_layout.m: Conform to the data structure changes above. doc/user_guide.texi: Document 'Z' as the character in -D arguments that tells hlds_out to dump the global structures needed for tabling. Fix an old oversight: document 'S' as the character in -D arguments that tells hlds_out to dump info about structure sharing. compiler/handle_options.m: Include 'Z' in -DALL -and -Dall. tests/tabling/mercury_java_parser_dead_proc_elim_bug.{m,exp}: Move this test case here from valid, since compiling all the way to executable doesn't work in valid (in yields link errors unrelated to the bug we are testing for). tests/tabling/mercury_java_parser_dead_proc_elim_bug2.{m,exp}: Add this new test case that in unfixed compilers gives the problem described up top. tests/tabling/Mmakefile: Enable the new tests. tests/valid/Mmakefile: tests/valid/Mercury.options: tests/valid/mercury_java_parser_dead_proc_elim_bug.m: Remove references to the moved test and the test itself.	2007-08-13 03:02:02 +00:00
Julien Fischer	b4c3bb1387	Clean up in unused module imports in the Mercury system detected ... Estimated hours taken: 3 Branches: main Clean up in unused module imports in the Mercury system detected by --warn-unused-imports. analysis/*.m: browser/*.m: deep_profiler/*.m: compiler/*.m: library/*.m: mdbcomp/*.m: profiler/*.m: slice/*.m: Remove unused module imports. Fix some minor departures from our coding standards. analysis/Mercury.options: browser/Mercury.options: deep_profiler/Mercury.options: compiler/Mercury.options: library/Mercury.options: mdbcomp/Mercury.options: profiler/Mercury.options: slice/Mercury.options: Set --no-warn-unused-imports for those modules that are used as packages or otherwise break --warn-unused-imports, e.g. because they contain predicates with both foreign and Mercury clauses and some of the imports only depend on the latter.	2006-12-01 15:04:40 +00:00
Zoltan Somogyi	f9cac21e3e	Get rid of a bunch more ambiguities by renaming predicates, mostly ... Estimated hours taken: 8 Branches: main Get rid of a bunch more ambiguities by renaming predicates, mostly in polymorphism.m, {abstract,build,ordering}_mode_constraints.m, prog_type.m, and opt_debug.m in the compiler directory and term_io.m, term.m, parser.m, and string.m in the library. In some cases, when the library and the compiler defined the same predicate with the same code, delete the compiler's copy and give it access to the library's definition by exporting the relevant predicate (in the undocumented part of the library module's interface). NEWS: Mention that the names of some library functions have changed. library/*.m: compiler/*.m: mdbcomp/*.m: browser/*.m: Make the changes mentioned above, and conform to them. test/general/string_test.m: test/hard_coded/string_strip.m: test/hard_coded/string_strip.exp: Conform to the above changes.	2006-09-20 09:42:28 +00:00
Julien Fischer	586cbb16ac	Change the implementation of map.merge/3 so that it throws an exception if the ... Estimated hours taken: 1.5 Branches: main, release Change the implementation of map.merge/3 so that it throws an exception if the sets of keys of the input maps are not disjoint. This is more in keeping with the documentation for that predicate which says they should be disjoint. The existing implementation handled duplicate keys by inserting the key and the smallest of the corresponding values into the output map. Some of the code in the compiler seems to rely on this behaviour - this is (probably) a bug but in at least in one instance, to do with merging RTTI varmaps during higher-order specialisation, it's going to be a bit tricky to fix. Rather than modify the compiler at the moment the old version of map.merge/3 is available as map.old_merge/3 and the compiler still uses this. (This predicate is not included in the library reference manual.) library/map.m: Make map.merge/3 throw an exception if the sets of keys of the input maps are not disjoint. Add the implementor-only predicate map.old_merge/3 for use by the compiler. compiler/hlds_rtti.m: compiler/interval.m: compiler/prog_io.m: compiler/tupling.m: Conform to the above changes. tests/hard_coded/map_merge_test.{m,exp}: Test for the new behaviour. tests/hard_coded/Makefile: Don't run the above test in deep profiling grades since it catches exceptions which the deep profiler cannot currently handle.	2006-09-16 10:46:41 +00:00
Zoltan Somogyi	00741b0162	This diff contains no algorithmic changes. ... Estimated hours taken: 6 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch more function symbols to reduce ambiguity. After this diff, the summary line from the mdb command "ambiguity -f" is Total: 351 names used 975 times, maximum 31, average: 2.78 browser/*.m: compiler/*.m: Rename function symbols to eliminate ambiguities. tests/debugger/declarative/dependency.exp: tests/debugger/declarative/dependency2.exp: Update the expected out where some internal function symbol names appear in the output of the debugger. (This output is meant for implementors only.)	2006-08-22 05:04:29 +00:00
Julien Fischer	e12ca34b2a	Fix a bug reported by Peter Hawkins. The problem occurred with switches with ... Estimated hours taken: 6 Branches: main, release Fix a bug reported by Peter Hawkins. The problem occurred with switches with multiple arms that shared code. Switch detection expands such arms by making copies of the shared code. Requantification then renames the variables in these copies apart, but the new variables are not being entered into the RTTI varmaps. This leads to an assertion failure. compiler/quantification.m: Update the RTTI varmaps after renaming apart. Failing to add any freshly introduced variables into the RTTI varmaps makes them inconsistent. compiler/add_clause.m: compiler/add_pragma.m: compiler/cse_detection.m: compiler/equiv_type_hlds.m: compiler/follow_code.m: compiler/hlds_clauses.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/lambda.m: compiler/mode_constraints.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/tupling.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Conform to the above change. Minor formatting fixes. tests/valid/Mmakefile: tests/valid/hawkins_switch_bug.m: Test case for the above.	2006-08-04 10:51:22 +00:00
Julien Fischer	aeeedd2c13	Standardize formatting of comments at the beginning of modules. ... compiler/*.m: Standardize formatting of comments at the beginning of modules.	2006-07-31 08:32:11 +00:00
Mark Brown	ee10ed0138	Make the header comments match the module content. ... Estimated hours taken: 0.1 Branches: main compiler/hlds_rtti.m: Make the header comments match the module content.	2006-07-31 07:21:46 +00:00
Julien Fischer	f5de906db6	Minor style cleanups for the CTGC system. There are no changes to any ... Estimated hours taken: 1 Branches: main Minor style cleanups for the CTGC system. There are no changes to any algorithms. compiler/ctgc.*.m: compiler/prog_ctgc.m: compiler/structure_reuse.*.m: compiler/structure_sharing.*.m: Minor style cleanups. compiler/builtin_ops.m: compiler/check_hlds.m: compiler/exception_analysis.m: compiler/hlds_rtti.m: compiler/process_util.m: s/__/./ in a couple of spots and fix a few other formatting problems.	2006-06-05 05:23:27 +00:00
Julien Fischer	459847a064	Move the univ, maybe, pair and unit types from std_util into their own ... Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.	2006-03-29 08:09:58 +00:00
Julien Fischer	a4519ed079	Move the all-solutions predicates from the library module std_util into their ... Estimated hours taken: 4 Branches: main Move the all-solutions predicates from the library module std_util into their own module, solutions. Move semidet_fail, semidet_succeed, cc_multi_equal and dynamic cast from std_util.m into builtin.m. Add some more utility functions for performing determinism or purity casts. (The later are primarily intended for use by solver implementors.) library/std_util.m: Move the all-solutions predicates into their own module, solutions.m. For now there are (obsolete) forwarding predicates from this module to the new one. The forwarding predicates will be included in the upcoming 0.13 release and then removed in later versions. Move semidet_succeed, semidet_fail, cc_multi_equal and dynamic_cast to builtin.m library/solutions.m: New file. This is the new home for the all-solutions predicates. This is pretty much cut and pasted from std_util (with module qualifiers updated accordingly). I've rearranged the code in a more top-down fashion as per our current coding standard. library/builtin.m: Move semidet_fail/0, semidet_succeed/0, cc_multi_equal/2 and dynamic_cast/2 to this module. Add semidet_true/0 and semidet_false/0 as synonyms for semidet_fail/0 and semidet_succeed/0. Add impure_true/0 and semipure_true/0. These are useful for performing purity casts, e.g. in solver implementations. library/library.m: Add the new module. NEWS: Announce the changes. library/*.m: Update to conform to the above. compiler/const_prop.m: Update evaluate_semidet_call/5 with the new module name for dynamic_cast. compiler/*.m: Module qualify calls to solutions to either disambiguate them from the versions in std_util (where they weren't module qualified) or change the module qualifier where they were (to avoid warnings about calls to the now deprecated versions). tests/debugger/declarative/solutions.*: Rename this module as the name conflicts with the new library module. tests/debugger/declarative/solns.*: Renamed version of above (with updated expected output). tests/debugger/declarative/Mmakefile: Handle the renamed version of the solutions test. tests/debugger/all_solutions.m: tests/debugger/declarative/args.m: tests/debugger/declarative/library_forwarding.m: tests/hard_coded/constant_prop_2.m: tests/invalid/multisoln_func.m: tests/invalid/one_member.m: tests/invalid/promise_equivalent_claueses.m: tests/valid/simplify_bug2.m: tests/valid/solv.m: Update to conform to the above changes. sample/solutions/*.m: Update to conform to the above changes.	2006-03-24 04:40:59 +00:00
Zoltan Somogyi	3ebda6545f	Move the stuff currently in hlds_pred.m that deals with clauses into a new ... Estimated hours taken: 1.5 Branches: main Move the stuff currently in hlds_pred.m that deals with clauses into a new module, hlds_clauses.m. Move the stuff currently in hlds_pred.m that deals with RTTI into a new module, hlds_rtti.m. Move the stuff currently in hlds_module.m that deals with predicate tables into a new module, pred_table.m. These changes make hlds_pred.m and hlds_module.m much more cohesive, but there are no changes in algorithms. compiler/hlds_clauses.m: compiler/hlds_rtti.m: compiler/pred_table.m: New modules as described above. In some cases, fix mixleading or ambiguous predicate names in the process, and convert a few predicates to functions. compiler/hlds_pred.m: compiler/hlds_module.m: Delete the stuff moved to other modules. compiler/*.m: In modules that need the functionality moved a new module, import the new module. It is rare for all the new modules to be needed, and many modules don't need any of the new modules at all. (For example, of the 200+ modules that import hlds_module.m, only about 40 need pred_table.m.) Conform to the few minor changes to e.g. predicate names. compiler/notes/compiler_design.html: Document the new modules.	2006-03-24 03:04:20 +00:00