102 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	ac05623367	Associate a type with an inst. ... Many predicates working on the inst of a variable (or part of the value of a variable) need to know the type of (that part of) the variable, but in some contexts, the type is not available at compile time. (One instance is the type of an existentially typed argument.) Because of this, the compiler used to pass a maybe(mer_type) with each mer_inst. Act on an old XXX to change this to pass a mer_type with each mer_inst, with the mer_type being a type variable if the type is not known statically. This is conceptually cleaner, and should also be faster, due to avoiding yes() wrappers in the usual case where the type *is* available. compiler/inst_match.m: compiler/inst_merge.m: compiler/inst_test.m: As above. compiler/inst_util.m: Update the names as well as the types of two utility predicates. Add a function for returning the canonical representation of no type information being available. compiler/instmap.m: Conform to the changes above. compiler/type_util.m: Add a new utility predicate for use by inst_match.m. The old code in inst_match.m called a nondet predicate as a semidet test by throwing away all its output arguments. The new utility predicate avoids the wasted work of constructing those arguments.	2021-12-17 11:40:56 +11: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	a818e42cb9	Put bigger/slower-varying inputs before others. ... compiler/inst_match.m: compiler/inst_test.m: As above. compiler/common.m: compiler/constraint.m: compiler/goal_mode.m: compiler/hlds_pred.m: compiler/inst_util.m: compiler/instmap.m: compiler/mode_comparison.m: compiler/mode_errors.m: compiler/mode_util.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/pd_info.m: compiler/simplify_goal_disj.m: compiler/unique_modes.m: compiler/unused_args.m: Conform to the changes above.	2021-06-14 16:48:19 +10:00
Zoltan Somogyi	3a21e5e374	Move two predicates to better homes. ... compiler/type_util.m: compiler/inst_util.m: Move two predicates that operate on types but are used only by code that manipulates insts from type_util.m to inst_util.m. The reason is that both predicates lose higher order inst information, and fixing that will require them to operate on insts as well. Moving them now should make the diff with the fix easier to review. compiler/inst_match.m: compiler/inst_test.m: Conform to the moves above.	2021-02-25 19:49:27 +11:00
Zoltan Somogyi	63dabcfcf8	Fix filling in partial terms that use direct_arg tags. ... This fix uses the approach discussed on m-dev 2020 nov 16/17 for fixing github issue #72, whose core problem is a need for information flow back to a the caller from a callee when the callee fills in the argument of a function symbol whose representation is a direct_arg tag. In most cases when the callee fills in the value of an argument, the caller can see it because the argument is in a word on the heap, but when the function symbol uses a direct_arg tag, that is not the case. compiler/direct_arg_in_out.m: A new module that implements the transformation proposed on m-dev. It creates a fresh clone variable every time an argument of a direct_arg tag function symbol is (or may be) updated. This can happen several times if a type has more than one function symbol with a direct_arg tag. Since the affected variable can be bound to only one function symbol at the start, its argument can be filled in only once, but the compiler cannot know in advance what function symbol the variable contains, and therefore which of the possibly several fill-in sites (which fill in the arguments of different function symbols) executed in sequence will actually update the variable. The transformation ensures that once a variable is cloned, it is never referred to again. It also ensures that in a branched control structure (if-then-else, disjunction or switch), all branches will use the *same* variable to represent the latest version of each cloned variable at the end, so that following code has a consistent view regardless of through which branch execution has reached it. There are three situations that the transformation cannot and does not handle. 1. Situations in which the mode of an argument is either an inst variable, or an abstract inst. In either case, the pass cannot know whether it should apply its transformation to the argument. 2. Situations where a procedure that has such an argument is exported to C code as a function. In that case, the C signature of the function we would generate would be different from what the user would normally expect. We could modify the documentation of the export pragma, but I don't think there much point due to lack of demand. (The problem cannot arise when targeting any language other than C, because we use direct_arg tags only with the low level data representation, which we only use for C.) 3. Situations where a procedure that has such an argument is defined by foreign_proc. Again, dealing with the problem would require nontrivial changes to the documented interface between code in foreign_procs and the surrounding Mercury code, and I see no demand for code that could benefit from that. In these cases, this module generates error messages. compiler/transform_hlds.m: Include the new module in the transform_hlds package. Delete unnecessary module qualification on some existing inclusions. Put some existing inclusions into a more meaningful order. compiler/notes/compiler_design.html: Document the new pass. Fix some nearby prose. compiler/lambda.m: compiler/simplify_proc.m: Use a predicate exported by direct_arg_in_out.m to test, for each procedure, whether the procedure has any argument positions that are subject to the problem that direct_arg_in_out.m addresses. simplify_proc.m does this for all procedures it processes; lambda.m does this for all the procedures it creates from lambda expressions. Give a predicate in simplify_proc.m a better name. Sort a list of predicate names. compiler/hlds_module.m: Add a field to the module_info that simplify_proc.m and lambda.m can use to tell direct_arg_in_out.m what work (if any) it needs to do. compiler/mercury_compile_middle_passes.m: Invoke direct_arg_in_out.m if the new field in the HLDS indicates that it has some work to do. (In the vast majority of compiler invocations, it won't have any.) compiler/hlds_pred.m: The new code in direct_arg_in_out.m creates a clone of each procedure affected by the problem, before deleting the originals (to make sure that no references to the unfixed versions of now-fixed procedures remain.) Make it possible to create exact clones of both predicates and procedures by adding two pairs of predicates, {pred,proc}_prepare_to_clone and {pred,proc}_create. Add the direct_arg_in_out transformation as a possible source of transformed predicates. library/private_builtin.m: Add a new builtin operation, partial_inst_copy, that the new module generates calls to. configure.ac: Require the installed compiler to recognize partial_inst_copy as a no_type_info builtin. compiler/builtin_ops.m: Recognize the new builtin. (This was committed before the rest; the diff to private_builtin.m can be done only once the change to builtin_ops.m is part of the installed compiler.) compiler/options.m: Add a way to test whether the builtin_ops.m in the installed compiler recognizes the new builtin. compiler/dead_proc_elim.m: Do not delete the new primitive before direct_arg_in_out.m has had a chance to generate calls to it. Add an XXX. compiler/error_util.m: Recognize the new module as a source of error messages. compiler/pred_table.m: Add a pair of utility predicates to be used when looking up builtin predicates, for which the compiler writer knows that there should be exactly one match. These are used in direct_arg_in_out.m. compiler/simplify_goal_call.m: Replace some existing code with calls to the new predicates in pred_table.m. compiler/hlds_goal.m: Add modes to rename_vars_in_goal_expr that express the fact that when an atomic goal_expr has some variables renamed inside it, it does not suddenly become some *other* kind of goal_expr. New code in direct_arg_in_out.m relies on this. compiler/hlds_out_goal.m: When the HLDS we are dumping out is malformed because it contains calls to predicates that have been deleted, the compiler used to abort at such calls. (I ran into this while debugging direct_arg_in_out.m.) Fix this. When such calls are encountered, we now print out as much information we can about the call, and prefix the call with an unmistakable prefix to draw attention to the problem. compiler/inst_util.m: Fix a bug that prevented direct_arg_in_out.m from even being invoked on some test code for it. The bug was in code that we use to unify a headvar's initial inst with its final inst. When the initial inst was a non-ground bound_inst such as the ones used in tests/hard_coded/gh72.m, and the final inst was simply "ground", this code quite properly returned a bound_inst (which, unlike ground, can show the exact set of function symbols that the headvar could be bound to). The problem was that it reused the original bound_inst's test results, including the one that said the final inst is NOT ground, which of course is wrong for any inst unified with ground. Fix two instances of this bug. compiler/modes.m: Make some of the code I had to traverse to find the bug in inst_util.m easier to read and understand. Replace some uses of booleans with bespoke enum types. Change the argument lists of some predicates to put related arguments next to each other. Give some variables more descriptive names. compiler/layout_out.m: Conform to the change in hlds_pred.m. compiler/var_locn.m: Fix a code generation bug. When filling-in the value of the argument of a function symbol represented by a direct_arg tag, the code we generated for it worked only if the direct_arg tag used 0 as its ptag value. In the test cases we initially used for github issue 72, that was the case, but the new tests/hard_coded/gh72.m has direct_tag args that use other ptag values as well. Document the reason why the updated code works. compiler/term_constr_initial.m: Add the new primitive predicate added to private_builtin.m, partial_inst_copy, to a table of builtins that do not take type_infos, even though their signatures contain type variables. Fix a bunch of old bugs: most other such primitives were not listed either. mdbcomp/program_representation.m: Add partial_inst_copy to the master list of builtins that do not take type_infos even though their signatures contain type variables. (Done by an earlier commit.) Document the fact that any updates here require updates to term_constr_initial.m. library/multi_map.m: We have long had multi_map.add and multi_map.set as synonyms, but we only had multi_map.reverse_set. Add multi_map.reverse_add as a synonym for it. Define the "set" versions in terms of the "add" versions, instead of vice versa. NEWS: Document the new predicates in multi_map.m. tests/hard_coded/gh72a.m: Fix typo. tests/hard_coded/gh72.{m,exp}: A new, much more comprehensive test case than gh72a.m. This one tries to tickle github issue 72 in as many forms of code as I can think of. tests/invalid/gh72_errors.{m,err_exp}: A test case for testing the generation of error messages for two out of the three kinds of situations that direct_arg_in_out.m cannot handle. (Proposals for how to test the third category welcome.) tests/hard_coded/Mmakefile: tests/invalid/Mmakefile: Enable the two new test cases, as well as two old ones, gh72[ab].m, that previously we didn't pass. tests/invalid/Mercury.option: Do not compile gh72_error.m with --errorcheck-only, since its errors are reported by a pass that --errorcheck-only does not invoke.	2021-01-13 05:35:40 +11:00
Julien Fischer	2e2abc39e2	Fix a typo. ... compiler/inst_util.m: s/tern/term/	2020-07-01 22:28:11 +10:00
Zoltan Somogyi	ed47bfc058	Add some documentation.	2020-07-01 18:51:53 +10:00
Zoltan Somogyi	3a1ed2efcb	Replace simple_call_id with pf_sym_name_arity. ... compiler/prog_data.m: Delete the simple_call_id data type, since it is isomorphic to the pf_sym_name_arity type, which more clearly specifies what is stored inside it. compiler/prog_out.m: Rename (all three versions of) simple_call_id_to_string to pf_sym_name_orig_arity_to_string, both to conform to the change in the input data type, and to emphasize that the resulting string will contain the *original* arity of functions (which does not include the return value), which is one less than the arity in the pf_sym_name_arity structure (which, in accordance with the convention inside the compiler that the arity is the length of the argument list, *does* include the return value). Delete the provision inside simple_call_id_to_string, now pf_sym_name_orig_arity_to_string, for special handling of the names of the predicates we use to implement promises, because it seems that *none* of the call sites to any of the three versions of this function can actually pass to it the identity of such a predicate. These calls refer to a predicate or mode declaration item (which promise predicates do not have), to clause or foreign_proc items (which again, promise predicates cannot have) or calls to the predicate (promise predicates cannot be called). Delete the exported predicate simple_call_id_to_sym_name_arity. It was called from exactly one place, inside prog_out.m itself, and this diff inlines that call. Avoid unnecessary forwarding of work from prog_out.m to error_util.m. Delete (all three versions of) write_simple_call_id. The changes below replace all their (few) uses with calls to pf_sym_name_orig_arity_to_string. compiler/error_util.m: Replace the simple_call() error piece with qual_pf_sym_name_orig_arity, and add a new version unqual_pf_sym_name_orig_arity. Their names explicitly say that they print the original arities of functions, also say whether they strip away any module qualification on the sym_name inside the pf_sym_name_arity. We prefer the unqual version in situations where the module qualifier is implicit, which usually means that it must be the same as the name of the module being compiled, because it reduces visual clutter for readers of error messages. Put {qual,unqual}_pf_sym_name_orig_arity next to their most closely related function symbols, {qual,unqual}_sym_name_arity, in the format_component type. (This yields a few inconsequential changes in the order of error_specs when sorted.) compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_pragma.m: compiler/add_pragma_tabling.m: compiler/add_pragma_type_spec.m: compiler/add_pred.m: compiler/check_libgrades.m: compiler/check_parse_tree_type_defns.m: compiler/check_promise.m: compiler/check_typeclass.m: compiler/convert_parse_tree.m: compiler/equiv_type.m: compiler/goal_expr_to_goal.m: compiler/hlds_data.m: compiler/hlds_desc.m: compiler/hlds_goal.m: compiler/hlds_out_pred.m: compiler/hlds_out_util.m: compiler/hlds_pred.m: compiler/inst_util.m: compiler/llds_out_instr.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make_hlds_error.m: compiler/make_hlds_warn.m: compiler/mark_tail_calls.m: compiler/ml_unify_gen_construct.m: compiler/mlds_to_c_stmt.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/modecheck_util.m: compiler/module_qual.collect_mq_info.m: compiler/module_qual.qualify_items.m: compiler/parse_item.m: compiler/parse_module.m: compiler/parse_type_repn.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/pre_quantification.m: compiler/pred_table.m: compiler/prog_item.m: compiler/recompilation.version.m: compiler/term_constr_build.m: compiler/termination.m: compiler/type_ctor_info.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/typecheck_info.m: compiler/unify_gen_construct.m: compiler/unused_imports.m: Conform to the changes above. Where I am pretty sure that in an error message, the module qualifier of a name must be the current module, use unqual_pf_sym_name_orig_arity instead of qual_pf_sym_name_orig_arity. Add some sanity checks where they seem appropriate. Replace sequences of io.write_strings with uses of io.format where this yields clearer code. (This is why there were no remaining calls to write_simple_call_id.) Shorten some too-long lines. In add_pred.m, make the order of some predicate definitions match the order of the calls to them. tests/invalid/ambiguous_method.err_exp: tests/invalid/ambiguous_method_2.err_exp: tests/invalid/bad_pred_arity.err_exp: tests/invalid/bad_sv_unify_msg.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/bug113.err_exp: tests/invalid/bug197.err_exp: tests/invalid/bug278.err_exp: tests/invalid/bug410.err_exp: tests/invalid/bug476.err_exp: tests/invalid/bug487.err_exp: tests/invalid/complex_constraint_err.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/errors2.err_exp: tests/invalid/exported_mode.err_exp: tests/invalid/field_syntax_error.err_exp: tests/invalid/foreign_singleton.err_exp: tests/invalid/funcs_as_preds.err_exp: tests/invalid/imported_mode.err_exp: tests/invalid/invalid_binary_literal.err_exp: tests/invalid/invalid_float_literal.err_exp: tests/invalid/invalid_hex_literal.err_exp: tests/invalid/invalid_octal_literal.err_exp: tests/invalid/make_opt_error.err_exp: tests/invalid/missing_det_decls.err_exp: tests/invalid/multimode_syntax.err_exp: tests/invalid/null_char.err_exp: tests/invalid/occurs.err_exp: tests/invalid/record_syntax_errors.err_exp: tests/invalid/ref_to_implicit_pred.err_exp: tests/invalid/require_tailrec_1.err_exp: tests/invalid/require_tailrec_1.err_exp2: tests/invalid/require_tailrec_2.err_exp: tests/invalid/require_tailrec_2.err_exp2: tests/invalid/require_tailrec_3.err_exp: tests/invalid/require_tailrec_3.err_exp2: tests/invalid/state_vars_test2.err_exp: tests/invalid/state_vars_test3.err_exp: tests/invalid/state_vars_test5.err_exp: tests/invalid/type_inf_loop.err_exp: tests/invalid/typeclass_constraint_extra_var.err_exp: tests/invalid/typeclass_mode_2.err_exp: tests/invalid/typeclass_test_12.err_exp: tests/invalid/typeclass_test_2.err_exp: tests/invalid/typeclass_test_9.err_exp: tests/invalid/types.err_exp: tests/invalid/types2.err_exp: tests/invalid/unbound_type_vars.err_exp: tests/invalid/with_type.err_exp: tests/invalid_purity/purity_nonsense.err_exp: tests/invalid_purity/purity_nonsense2.err_exp: tests/warnings/double_underscore.exp: tests/warnings/pragma_source_file.exp: tests/warnings/singleton_test.exp: tests/warnings/singleton_test.exp2: tests/warnings/singleton_test.exp3: tests/warnings/singleton_test.exp4: tests/warnings/singleton_test_state_var.exp: tests/warnings/warn_return.exp: tests/warnings/warn_return.exp2: tests/warnings/warn_return.exp3: tests/warnings/warn_succ_ind.exp: tests/warnings/warn_succ_ind.exp2: tests/warnings/warn_succ_ind.exp3: tests/warnings/warn_succ_ind.exp4: Update all these expected output files. Most changes are due to predicate and function names no longer being module qualified when the module qualification is obvious. A few changes are due to the change in the relative ordering of the function symbols of the format_component type. For singleton_test, warn_return and warn_succ_ind in warnings, the changes to the non-C .exp files were done by hand, so they may have the wrong white space.	2020-03-16 12:10:28 +11:00
Zoltan Somogyi	e9ad852183	Improve mode error messages a bit more. ... compiler/mode_errors.m: Simplify the wording of the new error message component added yesterday. Mention a possible reason for inst mismatches when the inst contains a higher order component. Put this in the parentheses, because it is *not* guaranteed to be the actual reason. compiler/inst_util.m: Add a utility predicate for the new code in mode_errors.m. tests/invalid/any_passed_as_ground.err_exp: tests/invalid/constrained_poly_insts2.err_exp: tests/invalid/ho_type_mode_bug.err_exp: tests/invalid/try_detism.err_exp: Expect the updated error messages.	2020-01-24 16:26:24 +11:00
Zoltan Somogyi	ae4b736fdd	Implement warnings for suspicious recursion. ... compiler/simplify_goal_call.m: If the --warn-suspicious-recursion option is set, and if the warning isn't disabled, generate warnings for two different kinds of suspicious recursion. They are both related to, but separate from, the warning we have long generated for infinite recursion, which occurs when the input args of a recursive call are the same as the corresponding args in the clause head. Both kinds suspicious recursion look at the input args of a recursive call that are NOT the same as the corresponding args in the clause head. Both require these args to have non-unique modes. (If they have unique modes, then the depth of the recursion may be controlled by state outside the view of the Mercury compiler, which means that a warning would be likely to be misleading.) The first kind is when all these args use state variable notation. Most of the time, we use state var notation to denote the data structures updated by the recursive code; having variables using such notation *controlling* the recursion is much less common, and much more likely to be unintended. The motivation for the new option was this infinitely looping code, which resulted from neglecting to s/[X | Xs]/Xs/ after cutting-and-pasting the clause head to the recursive call. p([X | Xs], !S) :- ..., p([X | Xs], !S). The other kind of suspicious recursive call we warn about involve input arguments where the base names of the input arguments (the part before any numeric suffixes) seem be switched between the clause head and the recursive call, as here: q(As0, Bs0, ...) :- ..., q(Bs1, As, ...). compiler/mercury_compile_main.m: Disable style warnings when invoked with --make-optimization-interface or its transitive variant. Without this, warnings about suspicious recursion would get reported in such invocations. Move a test from a callee to a caller to allow the callee to be less indented. compiler/options.m: Export functionality to mercury_compile_main.m to make the above possible. library/string.m: Add a predicate to convert a string to *reverse* char list directly. Note a discrepancy between the documentation and the implementation of the old predicate the new one is based on (which converts a string to a forward char list). NEWS: Note the new predicate in string.m. compiler/cse_detection.m: compiler/ctgc.selector.m: compiler/dead_proc_elim.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/distance_granularity.m: compiler/frameopt.m: compiler/inst_util.m: compiler/lp_rational.m: compiler/matching.m: compiler/modes.m: compiler/old_type_constraints.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_arguments.m: compiler/recompilation.usage.m: compiler/stratify.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/typeclasses.m: compiler/use_local_vars.m: deep_profiler/callgraph.m: deep_profiler/canonical.m: library/bit_buffer.read.m: library/bit_buffer.write.m: library/calendar.m: library/diet.m: library/lexer.m: library/parser.m: library/parsing_utils.m: library/ranges.m: library/set_ctree234.m: library/set_tree234.m: library/string.parse_util.m: library/tree234.m: library/varset.m: mdbcomp/program_representation.m: mdbcomp/rtti_access.m: profiler/demangle.m: Avoid warnings for suspicious recursion. In most cases, do this by wrapping disable_warning scopes around the affected recursive calls; in a few cases, do this by changing the code. tests/warnings/suspicious_recursion.{m,exp}: A test case for the new warnings. tests/warnings/Mercury.options: tests/warnings/Mmakefile: Enable the new test case.	2019-05-01 21:29:05 +10:00
Zoltan Somogyi	5eae909f78	Split hlds_cons.m from hlds_data.m. ... compiler/hlds_cons.m: compiler/hlds_data.m: Move the parts of hlds_data.m dealing with the cons table (representing the function symbols visible in the current module) and with the fields within those function symbols to the new module hlds_cons.m. This code was a large fraction of hlds_data.m, yet it is needed by relatively few modules. compiler/hlds.m: compiler/notes/compiler_design.html: Add and document the new module. compiler/*.m: Import the new module as well as, or instead of, hlds_data.m.	2018-10-26 00:30:12 +11:00
Zoltan Somogyi	15aa457e12	Delete $module arg from calls to unexpected.	2018-04-07 18:25:43 +10:00
Peter Wang	c23771d3e8	Prevent float_regs abort on constrained polymorphic inst. ... The float_regs pass made a call to inst_expand (which does not touch an inst with constrained_inst_vars at the top level) followed by get_arg_insts (which expects the inst to be expanded), leading to a compiler abort. This fixes compilation of tests/valid/constrained_poly_insts.m when floating point registers are used. compiler/float_regs.m: Replace a call to inst_expand with inst_expand_and_remove_constrained_inst_vars. Add require_complete_switch scope to a switch. compiler/inst_util.m: compiler/prog_mode.m: Add comments for would-be callers of inst_expand and get_arg_insts.	2018-03-09 14:22:13 +11:00
Zoltan Somogyi	28e9a29fc2	Carve hlds_inst_mode.m out of hlds_data.m. ... compiler/hlds_class.m: New module containing the parts of hlds_data.m that deal with insts and modes. compiler/hlds_data.m: Delete the moved code. compiler/hlds.m: Include the new module. compiler/notes/compiler_design.html: Document the new module. compiler/*.m: Conform to the changes above.	2018-02-06 06:20:52 +11:00
Zoltan Somogyi	fb97df69ed	Make "compute type representations" a separate pass. ... The ultimate purpose of this diff is to prepare for future improvements in type representations, allowing values of some data types to be represented more compactly than up to now. The main way this diff does that is by creating a separate pass for deciding how values of each type should be represented. We have traditionally decided data representations for each type as its type definition was processed during the make_hlds pass, but these decisions were always tentative, and could be overridden later, e.g. when we processed foreign_type or foreign_enum pragmas for the type. This dispersed decision making algorithm is hard to understand, and therefore to change. This diff centralizes decisions about type representations in a separate pass that does nothing else. It leaves the algorithm distributed among several files (du_type_layout.m, make_tags.m, and add_foreign_enum.m) for now, to make reviewing this diff easier, but soon after it is committed I intend to move all the relevant code to du_type_layout.m, to centralize the decision code in "space" as well as in time. For the reason why this pass runs before any of the semantic analysis passes, instead of after all of them as I originally intended and as we discussed on m-dev in late october 2017, see the big comment at the start of du_type_layout.m. As per another part of that same discussion on m-dev, this diff makes a start on implementing a new type of item, the type_repn item, which is intended *only* to be used in compiler-generated interface files, *not* in source files. It is only a start because we can use these items only *after* the creation of a separate type representation decision pass, and this diff is already very big. The code for making the compiler understand these items will be added later. The code for generating them will be added later still, once the code for understanding them has been installed on all our systems. Since I was going to be working on the affected code anyway, this diff also carries out two other decisions that came out of that discussion: - the deletion of the ability to reserve a tag in a type for HAL, either via a compiler option or via a pragma, and - the deletion of the ability to represent a functor using the address of a statically allocated object (which we haven't used and won't use, because it slows down accesses to *all the other functors* of the type). compiler/mercury_compile_front_end.m: Invoke the new pass for making decisions about type representations after the make_hlds pass. (We used to do only the final part of it then.) Fix a bad dump stage name. Add an extra check for what it means for a module to be error free. Make a sub-switch explicit. compiler/hlds.m: compiler/make_hlds.m: Move the modules that implement the new pass from the make_hlds package to the hlds package, to give the compiler's top level access to them. Make the same move for the modules that the new pass's modules need. Since they are now part of hlds, they cannot reach into make_hlds, and I think this is a cleaner solution than forwarding predicates. Delete some forwarding predicates that are no longer needed. compiler/notes/compiler_design.html: Document the updated location of the moved modules. Add an XXX to note a place where the documentation has not been updated in the past. compiler/du_type_layout.m: Add code to implement the new pass. Keep the algorithm for deciding type representations as close to the previously used algorithm as possible, since this diff is already big enough. (The previous algorithm was scattered across add_type.m, add_foreign_enum.m, and make_hlds_passes.m.) Simplifications and optimizations will come later, after this module is merged with make_tags.m and with (at least) the foreign_enum half of add_foreign_enum.m. compiler/make_tags.m: Keep the functionality of this module, which does both the first part of deciding type representations (tentatively assigning tags to functors, an assignment that may be overridden later), and the last part (packing multiple adjacent less-than-word-sized enum args into a single word, if possible.), but simplify it where possible, and note possibilities for further improvements. compiler/add_foreign_enum.m: This module has two halves, one dealing with foreign_enum pragmas and one dealing with foreign_export_enum pragmas. Change the half that deals with foreign_enum pragmas to just build a data structure that du_type_layout.m will need to make its decisions, this structure being a map from type_ctors to the foreign enum specification applicable to the current target language. Include in this structure a component that add_foreign_enum.m itself can use to report better error messages for duplicate foreign_enum pragmas; this component records, for each type_ctor and language, the context of the previous foreign_enum pragma for that combo. Change the input for the half that deals with foreign_export_enum pragmas to reflect the fact that it is invoked by du_type_layout.m after all decisions about type representations have already been made. compiler/add_special_pred.m: Move this module from the make_hlds package to the hlds package, since the code that adds special preds for type is now called from du_type_layout.m. Change the names of predicates to make clear whether they add only the declaration of a predicate, only its definition, or both. Don't try to pre-guess whether the implementation of a type's compare predicate will need an index predicate. Let the code that generates calls to the index predicate both declare and define the index predicate. This change removes the potential for inconsistencies between the two pieces of code. compiler/add_pred.m: Move this module from the make_hlds package to the hlds package, since add_special_pred.m needs access to it. compiler/add_type.m: When adding a type definition to the HLDS, don't try to decide its representation. Any such decision was tentative anyway, due to the possibility of e.g. the later processing of foreign_type or foreign_enum pragmas for the type. Likewise, don't try to create the special (unify, compare) predicates for the type. Leave both tasks to the du_type_layout pass. Likewise, don't try to pack the representation of types, or record no_tag types in the table of no_tag types, during the post-processing pass either; leave both of these to du_type_layout as well. Rename the predicate that post_processes type definitions to reflect the two tasks left for it to do. compiler/prog_data.m: Do not store width information about the arguments of those data constructors in the parse tree. That information is not computed until later; until then, it was always filled in with dummy values. (But see hlds_data.m below.) Use bespoke types to represent the presence or absence of user-specified unify and compare predicates. Change the representation of data constructors to use a single "maybe" type, not two lists, to denote the presence or absence of existentially typed arguments. Give the HLDS the ability to hold representation information about abstract types that in the future we will get from type_repn items in the defining modules' interface files. Delete the uses_reserved_tag type, since we never use reserved tags anymore. compiler/prog_item.m: Add the new type_repn item type, which is not used yet. Delete the reserve_tag pragma. Fix an earlier mistake in the wording of a context message. compiler/hlds_data.m: Put all the fields of hlds_du_type (the type definition variant dealing with discriminated union types) that deal with type representation issues in a single "maybe" field that is set to "no" before the type representation decision pass has been run. Add new type, constructor_repn, that stores the same information as the old constructor type (defined in prog_data.m), PLUS the information describing how terms with that data constructor are stored. Likewise, add a new type ctor_arg_rep, which likewise stores the widths of each constructor argument. When we implement argument reordering, we would store the offset of the arg as well. Since the parse tree representations of constructors and their arguments don't store representation information anymore, the cons_table they are stored in doesn't either. Make the lookup of representation information for a given constructor possible by adding a map to the new "maybe" field of hlds_du_type. Provide some utility predicates. Optimize some existing predicates. Rename some types to better reflect their meaning. compiler/hlds_module.m: Provide a slot in the module_info for storing the information gathered by make_hlds.m that is needed by the new pass. compiler/make_hlds_separate_items.m: When we see either a foreign_enum or a foreign_export_enum pragma, return values of a bespoke type for them (a type defined in hlds_module.m), instead of an item_pragma. This makes handling them considerably easier. compiler/make_hlds_passes.m: With the changes in this diff, adding a type to the HLDS won't decide its representation. Therefore delete the code that used to loop over foreign_export_enum pragmas; in the absence of the final type representation information, it won't work right. Record the information that the du_type_layout pass will need in the module_info. compiler/add_pragma.m: Delete the code for passing on foreign_enum and foreign_export_enum pragmas to add_foreign_enum.m; they are now passed to add_foreign_enum.m by du_type_layout.m. Move a utility predicate to make_hlds_error.m, to allow add_foreign_enum.m to call it. compiler/make_hlds_error.m: Add the utility predicate moved from add_pragma.m. Move the module from the make_hlds to the hlds package. compiler/module_qual.m: Provide a mechanism for recording error messages about e.g. undefined types without recording that we found an undefined type. This sounds strange, but there is a valid use case. When a type definition declares a functor's argument to be of an undefined type, that error is usually fatal; we stop the compiler from proceeding even to typechecking, since the typechecker will probably abort with a map lookup failure. Most other references to undefined types are similarly fatal for the same reason. However, if e.g. a foreign_export_enum pragma refers to an undefined type, that error *won't* be visible to the typechecker, and therefore won't crash it. The error will still cause the compiler to exit without generating any target language code, but at least it will be able to run the typechecker and other semantic analysis passes. Without this change, the compiler will report only one error in the ee_invalid.m test case; with it, it reports *every* error in the test case expected output. compiler/module_qual.qualify_items.m: Use the capability describe above for undefined types in foreign_export_enum pragmas. compiler/module_qual.qual_errors.m: Delete a (somewhat incorrect) copy of a predicate in prog_item.m, to reduce code duplication. compiler/prog_type.m: Add ways to represent abstract types whose representations are nevertheless known (from type_repn items in the defining modules' interface files) to be notag or dummy types. This will be needed to fix Mantis bug #441, a fix that will probably be one of the first later changes to build on this diff. Delete a type moved to type_util.m. compiler/type_util.m: Provide extra versions of some predicates, with the difference between the old and the new versions being that one requires type representations to have been decided already, and the other one does not. Move the definition of the ctor_defn type here from prog_type.m, since prog_type.m itself does not use it, but type_util.m does. Give some predicates more meaningful names. compiler/parse_type_defn.m: Simplify the code for parsing type definitions, to make it easier to reuse to parse type_repn items. Add a sanity check that requires existential constraints to have *some* existential variables to apply to. Allow "type_is_representable_in_n_bits" as a synonym for "type_is_abstract_enum", since in the future we want to be able to pack e.g. multiple int8s, not just multiple enums, into a single word. Generate more specific error messages for some classes of malformed input. compiler/parse_type_repn.m: New module to parse type_repn items. compiler/polymorphism.m: Make some predicates that operate on type constructors take the type constructors themselves as input arguments, not a whole type *using* that type constructor. Put the arguments of those predicates in a more standard order. Note that some predicates don't belong in this module. compiler/special_pred.m: Make the code that decides whether a special predicate for a type constructor can be defined lazily avoid using type representation information. (Actually, we now make decisions about lazy vs eager definitions after type representation is available, but that was not so in an earlier version of this change, and the new code is more robust.) compiler/unify_proc.m: When we decide to generate code for a compare predicate that needs the type to have an index predicate, don't presume that the index predicate has already been declared and defined; instead, declare and define it then and there. (Index predicates are *never* called from anywhere else.) Pack the information needed to define a special predicate into a single structure, to simplify the above. Since the creation of a clause for a compare predicate may now require the declaration and definition of an index predicate, the module_info field of the unify_proc_info is now a writeable field. Give some predicates and function symbols more meaningful names. Note some problems with the existing code. compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_mode.m: compiler/add_mutable_aux_preds.m: compiler/add_pragma_tabling.m: compiler/add_pragma_type_spec.m: compiler/add_solver.m: compiler/check_typeclass.m: compiler/code_info.m: compiler/comp_unit_interface.m: compiler/ctgc.selector.m: compiler/ctgc.util.m: compiler/default_func_mode.m: compiler/det_report.m: compiler/equiv_type.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/export.m: compiler/foreign.m: compiler/get_dependencies.m: compiler/goal_expr_to_goal.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_out_module.m: compiler/inst_check.m: compiler/inst_test.m: compiler/inst_util.m: compiler/intermod.m: compiler/item_util.m: compiler/make_hlds_warn.m: compiler/ml_accurate_gc.m: compiler/ml_simplify_switch.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_cs.m: compiler/mlds_to_java.m: compiler/mode_util.m: compiler/modecheck_goal.m: compiler/module_qual.collect_mq_info.m: compiler/modules.m: compiler/parse_item.m: compiler/parse_pragma.m: compiler/parse_tree.m: compiler/parse_tree_out.m: compiler/parse_tree_out_pragma.m: compiler/post_term_analysis.m: compiler/proc_requests.m: compiler/prog_item_stats.m: compiler/qual_info.m: compiler/recompilation.check.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/resolve_unify_functor.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/simplify_goal_ite.m: compiler/stack_opt.m: compiler/state_var.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/superhomogeneous.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/trailing_analysis.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/typecheck.m: compiler/unify_gen.m: compiler/untupling.m: compiler/unused_imports.m: compiler/write_module_interface_files.m: compiler/xml_documentation.m: Conform to the changes above. tests/invalid/Mmakefile: Disable the reserve_tag test case, as it is not applicable anymore. tests/invalid/exported_foreign_enum.{m,err_exp}: tests/invalid/pragma_qual_error.{m,err_exp}: Delete reserve_tag pragmas from these test cases, and its effects from the expected outputs. tests/invalid/bad_foreign_type.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/foreign_enum_invalid.err_exp: tests/invalid/type_lhs_var.err_exp: tests/invalid/uu_type.err_exp: tests/invalid/where_abstract_enum.err_exp: tests/invalid/where_direct_arg.err_exp: Expect the updated messages for some errors. tests/valid/Mmake.valid.common: tests/valid/Mmakefile: Disable any reserve_tag test cases, as they are not applicable anymore.	2018-01-31 17:54:40 +11:00
Zoltan Somogyi	8547e1634b	Fix some things reported by --warn-inconsistent-pred-order-clauses. ... compiler/arg_info.m: compiler/bytecode_data.m: compiler/common.m: compiler/compile_target_code.m: compiler/delay_info.m: compiler/det_util.m: compiler/erl_call_gen.m: compiler/erl_code_util.m: compiler/from_ground_term_util.m: compiler/hlds_out_goal.m: compiler/inst_match.m: compiler/inst_util.m: compiler/mode_constraint_robdd.m: compiler/ordering_mode_constraints.m: compiler/simplify_info.m: compiler/switch_detection.m: compiler/type_util.m: compiler/unique_modes.m: As above. compiler/Mercury.options: Note a module that is not worth fixing this way.	2017-10-14 19:07:02 +11: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
Zoltan Somogyi	c6ab550db8	Remove the code for automatic initialization of solver vars. ... We haven't supported it in years, and keeping it in the compiler is just a maintenance burden and a performance problem. mdbcomp/prim_data.m: Delete the spec_pred_init functor, since we don't support special "init" predicates anymore. compiler/prog_data.m: Delete the slot in solver type details that record the name of the auto-initialization predicate. compiler/prog_io_type_defn.m: Don't allow a type definition to specify an auto-initialization predicate. compiler/options.m: compiler/globals.m: Delete the option that allowed support for auto-initialization to be turned back on. compiler/inst_match.m: compiler/inst_util.m: Delete comments about auto-initialization. compiler/mode_info.m: Delete the record of whether we have variables that can be auto-initialized (we never do anymore) and the flag that controls whether auto-initialization is permitted or not. compiler/modecheck_conj.m: Simplify the code that modechecks conjunctions, since it no longer has to figure out where to insert auto-initializations of solver vars. compiler/modecheck_goal.m: Delete the code that ensured that if one branch of a branched control structure auto-initialized a solver variable, then they all did. compiler/modecheck_unify.m: Don't auto-initializate variables before unifications. compiler/modecheck_util.m: Delete the code that auto-initialized solver variables at the ends of procedure bodies if this needed to be done and wasn't done before. compiler/add_special_pred.m: compiler/equiv_type.m: compiler/equiv_type_hlds.m: compiler/get_dependencies.m: compiler/hlds_module.m: compiler/hlds_pred.m: compiler/modecheck_call.m: compiler/modes.m: compiler/module_qual.qualify_items.m: compiler/parse_tree_out.m: compiler/post_term_analysis.m: compiler/smm_common.m: compiler/special_pred.m: compiler/term_constr_errors.m: compiler/term_constr_initial.m: compiler/term_util.m: compiler/termination.m: compiler/trace_params.m: compiler/type_util.m: compiler/unify_proc.m: Delete code that handled stuff related to auto-initialization, and now always take the path that would normally be taken in the absence of auto-initialization. deep_profiler/read_profile.m: runtime/mercury_layout_util.c: runtime/mercury_stack_trace.c: util/mdemangle.c: Remove code that recognized the compiler-generated name of initialization predicates. tests/debugger/solver_test.m: tests/hard_coded/solver_construction_init_test.m: tests/hard_coded/solver_disj_inits.m: tests/hard_coded/solver_ite_inits.m: tests/invalid/missing_init_pred.m: tests/invalid/zinc2mer_lib.m: tests/valid/fz_conf.m: tests/valid/solver_type_bug_2.m: tests/valid/solver_type_mutable_bug.m: These tests tested the handling of auto-initialization, which we no longer support. Keep them around (and a bit more visible than inside the git repo) in case we need them again, but add a comment to each saying that the test is disabled. tests/debugger/Mercury.options: tests/debugger/Mmakefile: tests/hard_coded/Mercury.options: tests/hard_coded/Mmakefile: tests/invalid/Mercury.options: tests/invalid/Mmakefile: tests/valid/Mercury.options: tests/valid/Mmakefile: Disable those tests. tests/warnings/non_term_user_special.{m,exp}: Part of this test tested the handling of auto-initialization; delete that part. tests/warnings/Mercury.options: Delete the flag required by the deleted part, since we don't support it anymore.	2015-12-03 05:06:28 +11:00
Mark Brown	4b640dd74d	Fix default func modes in the inst merge operation ... compiler/inst_util.m: When merging bound with ground, ensure that all functions in the bound match the default function mode. tests/invalid/Mmakefile: tests/invalid/default_ho_inst_2.{m,err_exp}: Test case for this bug. This test currently passes due to the workaround for bug 264; the above fix means that the workaround is not needed in this case.	2015-11-22 16:51:22 +11:00
Mark Brown	0be00e30f8	Refactor parts of compiler/inst_{util,match}.m ... compiler/inst_util.m: Move the predicates for testing whether an inst contains or matches a nondefault function mode from here to compiler/inst_match.m, as they primarily make use of, and are used by, code from that module. compiler/inst_match.m: Rename {pred_inst,ho_inst_info}_is_nondefault_func_mode to {pred_inst,ho_inst_info}_matches_ground, and negate the meaning. Most uses of the old version were themselves negated. Provide a version that takes an inst_match_info and passes it through to pred_inst_matches_2. This makes it suitable for use in inst_matches_*, where it might otherwise cause an infinite loop due to not recording the expansions it has seen so far. It will be needed in inst_matches_* to properly disallow nondefault functions from matching ground, but that is left for a separate change.	2015-11-21 05:09:50 +11:00
Mark Brown	db464ca661	Consistently refer to "default" function modes instead of "standard".	2015-11-16 21:14:17 +11:00
Mark Brown	b2ae55c29c	Change 'none' to 'none_or_default_func' in ho_inst_info. ... This value of ho_inst_info is used for first-order values as well as for functions that have the default inst, and the new name better reflects that. Places using this value have been checked for correctness. Issues that need to be looked at have been marked with XXX, although have not been addressed in this change. compiler/prog_data.m: Update the type. compiler/inst_match.m: Add XXX comments. This module needs to check for non-default function insts in a bunch of places. compiler/inst_util.m: Add XXX comments. We lose information about non-default function insts when merging bound and any. The information needs to be either preserved or disallowed entirely. compiler/float_regs.m: Add XXX comments. This module may miss cases involving default function insts. compiler/modecheck_unify.m: Add XXX comment. We should exclude pred and non-default func lambda non-locals from becoming locked, an addition to default functions. compiler/*.m: No special handling is required for other modules.	2015-11-16 21:13:04 +11:00
Mark Brown	7f5a08eb37	Split parts of inst_match.m into a new module, inst_test.m ... Most modules that imported inst_match did so in order to use predicates such as inst_is_ground to test properties of insts. These predicates are split into a new module, leaving the more complex parts of inst_match to be imported in fewer places. This makes it easier to change inst_match (for example, to address mantis bug 264) without unintentional changes to the rest of the compiler. compiler/inst_test.m: New module containing code from inst_match.m. compiler/check_hlds.m: Include the new module. compiler/inst_match.m: Move code to the new module. compiler/inst_util.m: Move inst_expand and inst_expand_and_remove_constrained_inst_vars here rather than the new module, since they make more sense here. compiler/build_mode_constraints.m: compiler/cse_detection.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_report.m: compiler/fact_table.m: compiler/float_regs.m: compiler/goal_util.m: compiler/interval.m: compiler/loop_inv.m: compiler/modecheck_goal.m: compiler/pd_util.m: compiler/prog_rep.m: compiler/simplify_goal_call.m: compiler/size_prof.m: compiler/stm_expand.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/term_util.m: compiler/trace_gen.m: compiler/unify_proc.m: compiler/unneeded_code.m: Only import inst_test. compiler/common.m: compiler/instmap.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/simplify_goal_disj.m: Import inst_test in addition to inst_match. compiler/lco.m: compiler/simplify_goal_switch.m: Import inst_test and inst_util, but not inst_match.	2015-11-06 20:52:25 +11:00
Zoltan Somogyi	c5b64d36ea	Convert (C->T;E) to (if C then T else E).	2015-10-18 08:21:53 +11:00
Zoltan Somogyi	62ec97d443	Report imports shadowed by other imports. ... If a module has two or more import_module or use_module declarations for the same module, (typically, but not always, one being in its interface and one in its implementation), generate an informational message about each redundant declaration if --warn-unused-imports is enabled. compiler/hlds_module.m: We used to record the set of imported/used modules, and the set of modules imported/used in the interface of the current module. However, these sets - did not record the distinction between imports and uses; - did not allow distinction between single and multiple imports/uses; - did not record the locations of the imports/uses. The first distinction was needed only by module_qual.m, which *did* pay attention to it; the other two were not needed at all. To generate messages for imports/uses shadowing other imports/uses, we need all three, so change the data structure storing such information for *direct* imports to one that records all three of the above kinds of information. (For imports made by read-in interface and optimization files, the old set of modules approach is fine, and this diff leaves the set of thus *indirectly* imported module names alone.) compiler/unused_imports.m: Use the extra information now available to generate a severity_informational message about any import or use that is made redundant by an earlier, more general import or use. Fix two bugs in the code that generated warnings for just plain unused modules. (1) It did not consider that a use of the builtin type char justified an import of char.m, but without that import, the type is not visible. (2) It scanned cons_ids in goals in procedure bodies, but did not scan cons_ids that have been put into the const_struct_db. (I did not update the code here when I added the const_struct_db.) Also, add a (hopefully temporary) workaround for a bug in make_hlds_passes.m, which is noted below. However, there are at least three problems that prevent us from enabling --warn-unused-imports by default. (1) In some places, the import of a module is used only by clauses for a predicate that also has foreign procs. When compiled in a grade that selects one of those foreign_procs as the implementation of the predicate, the clauses are discarded *without* being added to the HLDS at all. This leads unused_imports.m to generate an uncalled-for warning in such cases. To fix this, we would need to preserve the Mercury clauses for *all* predicates, even those with foreign procs, and do all the semantic checks on them before throwing them away. (I tried to do this once, and failed, but the task should be easier after the item list change.) (2) We have two pieces of code to generate import warnings. The one in unused_imports.m operates on the HLDS after type and mode checking, while module_qual.m operates on the parse tree before the creation of the HLDS. The former is more powerful, since it knows e.g. what types and modes are used in the bodies of predicates, and hence can generate warnings about an import being unused *anywhere* in a module, as opposed to just unused in its interface. If --warn-unused-imports is enabled, we will get two separate set of reports about an interface import being unused in the interface, *unless* we get a type or mode error, in which case unused_imports.m won't be invoked. But in case we do get such errors, we don't want to throw away the warnings from module_qual.m. We could store them and throw them away only after we know we won't need them, or just get the two modules to generate identical error_specs for each warning, so that the sort_and_remove_dups of the error specs will do the throwing away for us for free, if we get that far. (3) The valid/bug100.m test case was added as a regression test for a bug that was fixed in module_qual.m. However the bug is still present in unused_imports.m. compiler/make_hlds_passes.m: Give hlds_module.m the extra information it now needs for each item_avail. Add an XXX for a bug that cannot be fixed right now: the setting of the status of abstract instances to abstract_imported. (The "abstract" part is correct; the "imported" part may not be.) compiler/intermod.m: compiler/try_expand.m: compiler/xml_documentation.m: Conform to the change in hlds_module.m. compiler/module_qual.m: Update the documentation of the relationship of this module with unused_imports.m. compiler/hlds_data.m: Document a problem with the status of instance definitions. compiler/hlds_out_module.m: Update the code that prints out the module_info to conform to the change to hlds_module.m. Print status information about instances, which was needed to diagnose one of the bugs in unused_imports.m. Format the output for instances nicer. compiler/prog_item.m: Add a convenience predicate. compiler/prog_data.m: Remove a type synonym that makes things harder to understand, not easier. compiler/modules.m: Delete an XXX that asks for the feature this diff implements. Add another XXX about how that feature could be improved. compiler/Mercury.options.m: Add some more modules to the list of modules on which the compiler should be invoked with --no-warn-unused-imports. compiler/*.m: library/*.m: mdbcomp/*.m: browser/*.m: deep_profiler/*.m: mfilterjavac/*.m: Delete unneeded imports. Many of these shadow other imports, and some are just plain unneeded, as shown by --warn-unused-imports. In a few modules, there were a *lot* of unneeded imports, but most had just one or two. In a few cases, removing an import from a module, because it *itself* does not need it, required adding that same import to those of its submodules which *do* need it. In a few cases, conform to other changes above. tests/invalid/Mercury.options: Test the generation of messages about import shadowing on the existing import_in_parent.m test case (although it was also tested very thoroughly when giving me the information needed for the deletion of all the unneeded imports above). tests/*/*.{m,*exp}: Delete unneeded imports, and update any expected error messages to expect the now-smaller line numbers.	2015-08-25 00:38:49 +10: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	89628ae791	More speedups of inst handling code. ... On tools/speedtest -l -m, my tests show a speedup of about 2%, but on Dirk's stress test module, for which the compiler (used to) spend almost all its time handling insts, the speedup is about 40%. This diff also contains some small incidental changes I stumbled upon the "need" for while working on the main change. compiler/prog_data.m: The existing inst_test_results type used to be able to hold the results of four tests about a bound inst. Add two more: the set of inst vars that may occur in the inst, and whether a type constructor has already been propagated into the cons_ids of the bound insts. Put the fields of the the unify_inst and merge_inst inst_names into a more sensible order. Define types that hold the information stored in specific kinds of inst_names, for use by hlds_data.m (see below). compiler/inst_user.m: For each user defined bound inst that matches exactly one parameterless type, propagate its type constructor into it, and record the fact that it has been done. This avoids having to do it many times later. Also record the set of inst vars in each inst, again to avoid having to repeat the test many times later. compiler/mercury_compile_front_end.m: Invoke the inst_user module as soon after inst_check.m as we can. compiler/hlds_data.m: Make the structure of six subtables of the inst table private, to allow them to be experimented with (and possibly changed) without code changes being required in other modules. The unify_inst_table, the ground_inst_table and the any_inst_table used to be maps whose keys were inst_names, but they were each only ever used with one kind of inst_name. Change their keys to the new types unify_inst_info, ground_inst_info and any_inst_info, which each contain the information in the unify_inst, ground_inst and any_inst inst_names respectively. That way, the searches in the maps will perform comparisons that don't need to switch on what kind of inst_name they are dealing with, and instead go directly to comparing the arguments. With the unify_inst_table, also go a step further. The unify_inst_info has two fields that are equivalent to booleans. Comparing these at every level of the map is wasteful, so switch the representation of the unify_inst_table from one map to four maps, one map for each possible combination of those booleans. This way, the two booleans in the unify_inst_info key are tested just once, when the applicable map is selected. The merge_inst_table used to have a pair of insts as keys. Replace that with the merge_inst_info type, which also holds a pair of insts, but on which comparisons should be a bit faster, since it is not polymorphic, and thus does not need an implicit typeinfo passed along. Provide a combined search_insert operation on each of the inst_tables, since their pattern of use is exactly that: search the table, and if the key is not found, insert a marker that says the entry is being worked on. This avoid one traversal of a possibly-large tree, with its associated (possibly very expensive) comparisons. For each inst table, provide conversion predicates to and from sorted association lists, for use by equiv_type_hlds.m compiler/equiv_type_hlds.m: Expand equivalence types in the new structure of the inst tables. compiler/inst_util.m: Use the new search_insert predicates for the various inst_tables. If one of the two insts being unified is free, then avoid using the unify_inst_table, since just doing the abstract unification is faster, and does not pollute the unify_inst_table. If both insts being merged are bound insts, then avoid using the merge_inst_table, since (a) the lookup is slower than just doing the merge, and (b) it can pollute the merge_inst_table to the extent that *all other lookups* in it become very slow. compiler/inst_match.m: Use test result information in bound insts to speed up the corresponding tests. compiler/set_of_var.m: Change the representation of sets of vars back to sparse_bitsets. I changed them to tree_bitsets several years ago to avoid some bad worst-case behavior with sparse_bitsets (which occurred when repeatedly appending to the "ends" of sets), but other algorithmic changes have since avoiding using set_of_vars in ways that induce that behavior, and now my benchmarking tells me that the bottleneck operation is conversion of set_of_vars to lists of vars. This is faster with sparse_bitsets, since unlike tree_bitsets, they don't have to unravel a tree structure. compiler/mode_util.m: Export a predicate now needed by inst_user.m, and clean up the code a bit, factoring out repeated code. compiler/modecheck_util.m: Modify an equality comparison of two insts to compare the instantiation states themselves, but NOT the test results about those instantiation states, since these can differ if the two insts have different histories. compiler/hlds_code_util.m: compiler/hlds_out_mode.m: compiler/hlds_out_module.m: compiler/mercury_to_mercury.m: compiler/module_qual.m: compiler/polymorphism.m: compiler/prog_mode.m: compiler/recompilation.usage.m: compiler/unused_imports.m: compiler/xml_documentation.m: Conform to the changes above. The following changes are mostly incidental. compiler/hlds_args.m: Speed up a predicate by avoiding the materialization of a list that is needed only for a test. compiler/instmap.m: Clarify some code. compiler/liveness.m: Avoid computing some value when it is not needed. compiler/mode_errors.m: Avoid referring to "arguments" (plural) for errors involving *one* argument. compiler/mode_info.m: Move the documentation of some predicates to their declarations. compiler/modecheck_unify.m: Compute some data closer to where it is needed, to reduce the number of stack slots needed. tests/invalid/constrained_poly_insts2.err_exp: Expect the updated error message from mode_errors.m (with "argument" in singular), as well as module qualified insts, since having inst_user.m push type_ctors into the definitions of named inst module qualifies the bound_insts inside those definitions.	2015-03-05 20:01:00 +11:00
Zoltan Somogyi	85da715041	Generate a specific warning for X = f(X). ... This warning is for when X is ground. When X is free (or otherwise nonground), such unifications have always gotten an error. compiler/mode_errors.m: Add a warning type for occur check violations with ground vars. Fix the grammar in the other two warnings generated by mode analysis. compiler/modecheck_unify.m: Generate the new warning when appropriate. To make this possible, rewrite a previously 280-line predicate that was hard to understand because of its structure as well as its length into a smaller, better structured predicate less than half the size (a) by moving coherent pieces of it out into other predicates, some of which are now called more than once, thus reducing code duplication, and (b) by avoiding redundant work, to wit, optimizing the form of a unification when we have already decided that it has a mode error, and thus cannot be scheduled now. compiler/prog_mode.m: Add a det version of an existing predicate. compiler/inst_util.m: Remove a comment on a predicate implementation that duplicates the comment on the predicate's declaration. compiler/modecheck_util.m: Minor fixes of comments. compiler/superhomogeneous.m: Fix some bit rot: update the name of a predicate to match the name of the data it works on, which was changed a few years ago. tests/invalid/occurs.err_exp: tests/invalid/qualified_cons_id2.err_exp: tests/warning/simple_code.exp: tests/warning/unify_f_g.exp: Conform to the error message format we generate after the change to mode_errors.m. tests/warning/unify_x_f_x.{m,exp}: A new test case to test the new functionality. tests/warning/Mmakefile: Enable the new test case.	2014-11-10 17:00:08 +11:00
Zoltan Somogyi	fe785c668b	Consistently use set.is_empty and set.is_non_empty. ... compiler/*.m: deep_profiler/*.m: As above. library/set.m: library/set_bbbtree.m: library/set_ctree234.m: library/set_ordlist.m: library/set_tree234.m: library/set_unordlist.m: Add is_non_empty to the set modules that did not already have it. (Some did, some didn't.) Make the documentation of empty, is_empty, non_empty and is_non_empty consistent.	2014-11-04 23:18:43 +11:00
Peter Wang	338b5cb98e	Fix some bugs with constrained polymorphic modes. ... 1. An inst variable from the head of the clause could be bound in the body. The mode error in the call `P(X)' was not detected because the inst variable I could be bound to ground. :- pred p(pred(T), T). :- mode p(pred(in(I =< ground)) is det, in) is det. p(P, X) :- P(X). 2. In David Overton's thesis, a get_subst function produces an inst substitution from the callee's initial insts to the arguments' initial insts, and the substitution is applied to all insts from the callee. In the implementation we actually build the substitution while matching the arguments' insts with the callee's insts, but we lost some precision by not applying the incremental substitutions built as we match a list of insts. 3. We rename apart the callee's inst variables from our own, but did not keep the merged inst varset. When a renamed inst variable appears in a mode error it would be printed without its original name. (could this avert more serious problems?) 4. inst_merge_3 was missing a case. Some of these bugs may not be apparent due to the hack in inst_matches_final_3 which allows a ground inst to match any bound inst. A similar hack exists in inst_matches_binding_3. compiler/inst_util.m: Handle in inst_merge_3 the case InstA \= constrained_inst_var(_, _), InstB = constrained_inst_var(_, _). Move InstA = not_reached case to inst_merge_2 to maintain inst_merge(not_reached, InstB @ constrained_inst_var(_, _)) = InstB compiler/inst_match.m: Improve precision of inst var substitution computed in handle_inst_var_subs_2, following dmo's thesis. compiler/mode_util.m: compiler/modecheck_call.m: Keep the merged inst varsets after renaming. compiler/mode_info.m: Add "head inst vars" in mode_info structure. compiler/modecheck_util.m: Add get_constrained_inst_vars to extract constrained inst vars from a list of mode. Make modecheck_var_has_inst_list_* fail if the computed substitution would change the constraints of any head inst variables. compiler/modes.m: Initialise mode_info with head inst variables. compiler/pd_info.m: compiler/pd_util.m: Conform to change in mode_info_init (not specifically tested). compiler/prog_mode.m: Export inst_apply_substitution. Make rename_apart_inst_vars return the merged inst varset. Fix comments. tests/invalid/Mmakefile: tests/invalid/constrained_poly_insts2.err_exp: tests/invalid/constrained_poly_insts2.m: tests/valid/Mmakefile: tests/valid/constrained_poly_multi.m: Add test cases. NEWS: Announce fix.	2014-09-12 16:11:28 +10:00
Zoltan Somogyi	13b6f03f46	Module qualify end_module declarations. ... compiler/*.m: Module qualify the end_module declarations. In some cases, add them. compiler/table_gen.m: Remove an unused predicate, and inline another in the only place where it is used. compiler/add_pragma.m: Give some predicates more meaningful names.	2014-09-04 00:24:52 +02:00
Zoltan Somogyi	ee63cb8d84	Heavily polymorphic code, such as that generated by g12, often builds the same ... Estimated hours taken: 80 Branches: main Heavily polymorphic code, such as that generated by g12, often builds the same typeinfos and typeclass infos over and over again. We have long had caches that avoid building a new typeinfo or typeclass info if some variable in the current scope already contains the right value, but a program that has many scopes may still build the same typeinfo or typeclass info many times. If that typeinfo or typeclass info is a ground term, the code generators will recognize that fact, and will turn all the constructions of that ground term in different scopes into referencess to the same constant structure. However, in the meantime, the program can be much bigger than necessary. In the motivating test case for this change, a single call to fdic_post is preceded by 133 goals that build the four typeclass infos it needs. The main idea of this diff is to construct constant typeinfos and typeclass infos out of line, in a separate data structure. Polymorphism then binds variables representing typeinfo and typeclass infos to reference to these constant structures. In the motivating example, this allows polymorphism.m to insert just four goals before the call to fdic_post, the minimal possible number: one for each typeclass info that predicate needs. On Leslie's bug344 program, this change speeds up the compiler by a factor of five to eight (reducing compile time from about 80 or 85 seconds to 10 or 15). There is a drawback to this scheme, but it is minor. That drawback is that once a constant structure is entered into our database of constant structures, it cannot (yet) be removed. Even if all the references to a constant structure are eliminated by optimizations, the structure will remain. ------------------------------------------ CHANGES IN THE FRONT END compiler/const_struct.m: A new module to look after our new database of constant structures. Currently, its use is enable only on the LLDS and MLDS C backends. compiler/hlds.m: compiler/notes/compiler_design.html: Add the new module to the HLDS package. compiler/hlds_module.m: Include the constant structure database in the module_info. compiler/hlds_data.m: Add two new cons_ids, which refer to typeinfos and typeclass infos implemented as constant structures. Move the code for calculating the number of extra instance args in base_typeclass_infos here from base_typeclass_info.m, since polymorphism.m now needs it too. We can now also eliminate the duplicate copy of that code in higher_order.m. Make an independent optimization: make the restrict_list_elements function more efficient by avoiding redundant tests. compiler/polymorphism.m: When building typeinfo and typeclass infos, keep track of whether the structure being built is constant. If it is, then put it in the database of constant structures, and replace the code building it with a simple reference to that new entry. Since I now expect most goal sequences inserted before goals to be short, consistent use lists of goals to represent these, since the costs of conversions to and from cord form are unlikely to be paid back by the higher efficiency of cord operations on longer sequences. When we want to get the typeclass info of a superclass out of the typeclass info of a subclass, if the typeclass info of the subclass is known, do the extraction here. We used to do this optimization only in higher_order.m, but doing so here reduces the size of the HLDS between polymorphism.m and higher_order.m, and thus improves compilation time. Reorganize some of the structure of this module to make the above changes possible. In particular, our new approach requires making snapshots of the varsets and vartypes, and later restoring those snapshots if the variables allocated turn out to be unnecessary, due to all of them describing the components of a constant structure. The correctness of such code is much easier to check if the taking and restoring of each snapshot takes places in a single predicate. Remove the code moved to higher_order.m. Add some debugging code for now. If no issues arise in the next few weeks, it can be deleted. compiler/modecheck_unify.m: Treat unifications whose right hand side has a cons_id referring to a constant structure specially. compiler/base_typeclass_info.m: Replace the code that is now in num_extra_instance_args with a call to that predicate. Put the arguments of some predicates in a more logical order. compiler/higher_order.m: When looking up the components of existing typeclass infos, handle cases where those typeclass infos are constant structures. Give some types, fields and variables better names. Avoid a redundant map search. Avoid some redundant tests by providing separate predicates to handle higher order calls and method calls. Move the predicate is_typeclass_info_manipulator here from polymorphism.m, since this is the only module that uses that predicate. ------------------------------------------ CHANGES IN THE LLDS BACKEND: compiler/llds.m: Add a type to map constant structure numbers to rvals together with their LLDS types. Introduce a type to represent rvals together with their LLDS types. compiler/mercury_compile_llds_back_end.m: Before we generate code for the predicates of the module, convert the constant structures to typed LLDS rvals. Create a map mapping each constant structure number to the corresponding typed rvals. compiler/proc_gen.m: Take that map, and put it into the code_info, to allow references to those structures to be translated. Put the arguments of some predicates into a more logical order. compiler/code_info.m: Include a map giving the representation of each constant structure in the code_info. compiler/unify_gen.m: Add the predicates needed to convert the constant structures of a module to LLDS rvals. For now, this code works only on the kinds of constant structures generated by polymorphism.m. Handle unifications whose right hand side is a reference to a constant structure. compiler/global_data.m: compiler/stack_layout.m: Use the new typed_rval type where relevant. ------------------------------------------ CHANGES IN THE MLDS BACKEND: compiler/ml_proc_gen.m: Before we generate code for the predicates of the module, convert the constant structures to typed MLDS rvals. Create a map mapping each constant structure number to the corresponding typed rvals. Factor out some code into a predicate of its own. compiler/ml_gen_info.m: Include a map giving the representation of each constant structure in the ml_gen_info. Also add to the ml_gen_info an indication of what GC system we are generating code for, since the code generator needs to know this often. compiler/ml_unify_gen.m: Add the predicates needed to convert the constant structures of a module to MLDS rvals. For now, this code works only on the kinds of constant structures generated by polymorphism.m. Handle unifications whose right hand side is a reference to a constant structure. Simplify some existing code. ------------------------------------------ MINOR CHANGES: mdbcomp/prim_data.m: Add a predicate that gets both the module name and the base name from a sym_name at the same time. This is used for minor speedups in other code updated in this diff. compiler/dead_proc_elim.m: Scan constant structures for references to entities that need to be kept alive. compiler/term_constr_build.m: compiler/term_traversal.m: Do not build size constraints from references to constant structures. The sizes of constant terms don't change, so they are irrelevant when building constraints for finding argument size changes. ------------------------------------------ TRIVIAL CHANGES TO CONFORM TO OTHER CHANGES: compiler/hlds_out_module.m: Print out the constant structure database if asked. doc/user_guide.tex: Document how to ask for it. compiler/hlds_out_util.m: Print out the new cons_ids. compiler/hlds_out_mode.m: Print out the new cons_ids in insts. Remove a compiler abort, to help debug a problem. Improve the structure of a predicate. compiler/hlds_out_goal.m: Fix some missing newlines. compiler/hlds_code_util.m: Add some utility predicates needed by the modules above. Conform to the changes above. compiler/mlds_to_il.m: Reorder some predicates. Conform to the changes above. compiler/bytecode_gen.m: compiler/ctgc.selector.m: compiler/dependency_graph.m: compiler/erl_unify_gen.m: compiler/export.m: compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/llds_out_globals.m: compiler/mercury_to_mercury.m: compiler/ml_global_data.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/module_qual.m: compiler/prog_rep.m: compiler/prog_type.m: compiler/prog_util.m: compiler/rbmm.execution_path.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/type_ctor_info.m: compiler/unused_imports.m: compiler/var_locn.m: compiler/xml_documentation.m: Conform to the changes above. ------------------------------------------ OTHER INDEPENDENT CHANGES: compiler/handle_options.m: Add a dump option that is useful for debugging when working on polymorphism.m and constant structures. compiler/equiv_type_hlds.m: Fix an old performance bug: make the code handling try goals keep the old memory cells representing such goals, instead of rebuilding them, if no changes took place inside them. compiler/ml_accurate_gc.m: Move a test earlier, to allow us to avoid more work in the common case. compiler/erl_code_gen.m: compiler/error_util.m: compiler/hhf.m: compiler/inst_util.m: compiler/ml_code_util.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/modecheck_call.m: compiler/modecheck_util.m: compiler/post_typecheck.m: compiler/size_prof.m: compiler/stack_opt.m: compiler/stratify.m: compiler/unused_args.m: compiler/post_type_analysis.m: library/erland_rtti_implementation.m: Minor cleanups. ------------------------------------------ CHANGES TO THE TEST SUITE: tests/invalid/any_passed_as_ground.err_exp2: tests/invalid/invalid_default_func_1.err_exp2: tests/invalid/invalid_default_func_3.err_exp2: tests/invalid/try_detism.err_exp2: Add second expected output files for these tests. We need alternate expected outputs because the numbers of some of the typeinfo variables mentioned in error message are different depending on whether or not const structures are enabled.	2012-06-08 15:37:07 +00:00
Zoltan Somogyi	932f7256ba	A large part of the cost of a large ground term is incurred not when the ... Estimated hours taken: 40 Branches: main A large part of the cost of a large ground term is incurred not when the term is constructed, but when it is used. The inst of the term will be huge, and will typically have to be traversed many times. Some of those traversals would be linear if not for the fact that, in order to avoid infinite loops on recursive insts, the predicate doing the traversal has to keep a set of the insts visited so far. When the traversal is in the middle of the ground term's inst, it is looking up that inst in a set of the insts of its containing terms all the way up to the root. When the ground term contains a list with many repeated elements near the start, the cost of the traversal is cubic in the length of the list: a linear number of set membership tests, each of which tests the current inst against a linear number of large insts, the test itself being linear. This diff aims to totally sidestep all that. It extends the mer_inst type to allow (but not require) the creator of an inst to record what the outcome of some tests on the inst would be. Is it ground? Does it contain "any"? What inst names and types may it contain? If the creator records this answer, which the code that creates ground terms does, then many tests will now run in CONSTANT time, not linear, quadratic or cubic. We do this only for bound insts. While the concept can apply to all insts, for small insts it can cost more to interpret the results term than to do the test directly. Insts cannot be large without being composed mostly of bound insts, so by recording this info only for bound insts, we can speed up the handling of all large insts. This also has the side benefit that in many cases, a traversal that operates on an inst will often do so in order to compute an updated version of that inst. In many cases, the updated version is the same as the original version, but since the traversal has to be prepared for updates, it makes a copy of the inst anyway. The result of the traversal is thus an inst that has the same value as the original inst but not the same address. This makes it useless to try to do equality checks of related insts in constant time by looking at the pointers. With this diff, many such traversals can be avoided, allowing the updated inst to keep the address as well as the value of the corresponding original inst. Without this diff, the compiler takes more than 10 seconds to compile zm_rcpsp_cpx.m, with most of that time being spent in mode checking. With this diff, it takes less than 5 seconds. Basically, mode checking went from 6+ seconds to 1. The profile of the compiler is now flat on this input; no single pass takes much more time than the others. The speed of the compiler is unaffected on tools/speedtest. (Actually, it gets a very slight speedup, but it is in the noise.) compiler/prog_data.m: Change the bound/2 functor of the mer_inst type to bound/3, adding a field that gives the outcome of some common tests performed on insts. When we attach insts to the variables representing parts of ground terms, we mark the insts accordingly. This allows us to perform many tests on insts in constant time, not in a time that is linear, quadratic or worse in the size of the inst. compiler/add_pragma.m: compiler/const_prop.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/float_regs.m: compiler/hlds_code_util.m: compiler/hlds_goal.m: compiler/inst_check.m: compiler/inst_match.m: compiler/inst_util.m: compiler/lco.m: compiler/mercury_to_mercury.m: compiler/mode_constraints.m: compiler/mode_debug.m: compiler/mode_util.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/module_qual.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/prog_io.m: compiler/prog_io_util.m: compiler/prog_mode.m: compiler/prog_util.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/simplify.m: compiler/try_expand.m: compiler/unique_modes.m: compiler/unused_imports.m: compiler/xml_documentation.m: Conform to the above change. Obviously, this required the modification of most predicates dealing with insts. Where the original predicates used multiple clauses, inconsistent variable names and/or bad grouping or ordering of code, this diff fixes that. More to the point, while in many places, the new code ignores the new field in input insts as either not relevant or not useful, in several places, the new code - pays attention to this field in input insts and executes less or faster code if the result of some test it needs is already available in it, or - fills in the field in insts it generates as output. Most, but not all, of changes in the first of those two categories were in inst_util.m and inst_match.m. compiler/hlds_out_mode.m: When writing out insts, or converting them to term form as the first step in printing them out, print the new field if we are generating debug output (such as a HLDS dump), but do not do so if we are generating actual Mercury code (such as a .opt file). Reorder the arguments of many predicates to move the context argument BEFORE the argument representing the object to be printed or converted to a term, since this allows us to use list.map on lists of such objects. compiler/hlds_out_util.m: Define a type that allows us to distinguish between the two. compiler/hlds_out_goal.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: Thread values of this flag type through a bunch of predicates as needed. compiler/intermod.m: Specify output_mercury when writing clauses for optimization files. This is needed because mode-specific clauses can have insts in their heads. (The mode declarations in .int* files are written out by a separate set of predicates, in mercury_to_mercury.m, which ALWAYS ignore the new field.) compiler/prog_util.m: There were two predicates named construct_qualified_term, with different arities: one took a context, the other didn't. Rename the former to avoid the ambiguity. compiler/goal_expr_to_goal.m: Conform to the change to prog_util.m. compiler/prog_io.m: There were two predicates named constrain_inst_vars_in_mode; rename one. Add an XXX about why they are here in the first place. compiler/format_call.m: Give some type and field names prefixes to avoid some ambiguities.	2012-04-23 03:34:49 +00:00
Zoltan Somogyi	55bc393ded	Replace the misleading names of several predicates. ... Estimated hours taken: 2 Branches: main compiler/type_util.m: Replace the misleading names of several predicates. The old names talked about testing a type, type definition or variable to see whether it is a solver type, when the test they actually implemented also succeeded if they were NOT a solver type, but contained a component that was a solver type. Add versions of some of these predicates that take only a type table, and not a whole module_info, as input. (The type table is the only part of the module_info that the old predicates actually use.) I have plans to use these predicates in a later diff. Give some other predicates better names as well. compiler/modecheck_conj.m: Rename a predicate along similar lines. compiler/cse_detection.m: compiler/exception_analysis.m: compiler/inst_match.m: compiler/inst_util.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/simplify.m: compiler/trailing_analysis.m: Conform to the above changes.	2012-04-11 04:52:35 +00:00
Zoltan Somogyi	56ea88e183	Require the main switches I recently introduced in this module to be ... Estimated hours taken: 2 Branches: main compiler/inst_util.m: Require the main switches I recently introduced in this module to be complete, adding alternatives as needed. Add XXX comments where I think that the old actions in those cases (which was of course always "fail") is wrong. Make the variable names used for some things consistent across predicates. Comment out an unused predicate.	2012-04-05 01:45:21 +00:00
Zoltan Somogyi	fe3b8bf7d3	Clean up this module in several respects. ... Estimated hours taken: 8 Branches: main compiler/inst_util.m: Clean up this module in several respects. First, replace predicate definitions consisting of long lists of clauses with a single clause with an explicit disjunction, and in the process, impose consistent names on things. The old code used to do things like call the same argument different names in different clauses, and use the same name for different things in different clauses. Different clauses also followed different naming conventions, for example some referred to two insts being merged as InstA and InstB, while others referred to them as X and Y. Second, put the disjuncts in a more logical order. Third, reorganize the disjuncts so that two old pieces of code that handled the abstract unification of e.g. bound/2 and ground/2 insts for live and dead unifications respectively are next to each other, with the commonalities factored out. In some cases, ALL of the code was common. Fourth, mark with XXXs some places where the behavior of the code seems suspect.	2012-04-04 06:08:31 +00:00
Zoltan Somogyi	376a1cef36	In two places, we were using (pairs of) nondet calls to list.member ... Estimated hours taken: 2 Branches: main compiler/inst_util.m: In two places, we were using (pairs of) nondet calls to list.member to iterate over all the insts included in a list of bound insts. For programs that build large terms, there could be many such insts, so many that they exhaust the nondet stack in low level C grades. This diff replaces that code with code to explicit traverse the lists of bound insts with det code. The new code is tail recursive to avoid simply transferring the problem to the det stack. I have also changed the code to use switches in det functions (which are checked for completeness) instead of switches in semidet predicates (which are not). I have also changed the code to use sets of inst_names instead of full insts to test for infinite recursion. The set of insts only ever contained insts that were wrappers around inst_names anyway.	2012-04-04 02:07:59 +00:00
Peter Wang	b86f973fa9	Allow the use of Mercury abstract machine float registers for passing ... Branches: main Allow the use of Mercury abstract machine float registers for passing double-precision float arguments in higher order calls. In of itself this is not so useful for typical Mercury code. However, as all non-local procedures are potentially the targets of higher order calls, without this change first order calls to non-local procedures could not use float registers either. That is the actual motivation for this change. The basic mechanism is straightforward. As before, do_call_closure_* is invoked to place the closure's hidden arguments into r1, ..., rN, and extra input arguments shifted into rN+1, etc. With float registers, extra input arguments may also be in f1, f2, etc. and the closure may also have hidden float arguments. Optimising for calls, we order the closure's hidden arguments so that all float register arguments come after all regular register arguments in the vector. Having the arguments out of order does complicate code which needs to deconstruct closures, but that is not so important. Polymorphism complicates things. A closure with type pred(float) may be passed to a procedure expecting pred(T). Due to the `float' argument type, the closure expects its argument in a float register. But when passed to the procedure, the polymorphic argument type means it would be called with the argument in a regular register. Higher-order insts already contain information about the calling convention, without which a higher-order term cannot be called. We extend higher-order insts to include information about the register class required for each argument. For example, we can distinguish between: pred(in) is semidet /* arg regs: [reg_f] */ and pred(in) is semidet /* arg regs: [reg_r] */ Using this information, we can create a wrapper around a higher-order variable if it appears in a context requiring a different calling convention. We do this in a new HLDS pass, called float_regs.m. Note: Mercury code has a tendency to lose insts for higher-order terms, then "recover" them by hacky means. The float_regs pass depends on higher-order insts; it is impossible to create a wrapper for a procedure without knowing how to call it. The float_regs pass will report errors which we otherwise accepted, due to higher-order insts being unavailable. It should be possible for the user to adjust the code to satisfy the pass, though the user may not understand why it should be necessary. In most cases, it probably really *is* unnecessary. We may be able to make the float_regs pass more tolerant of missing higher-order insts in the future. Class method calls do not use float registers because I didn't want to deal with them yet. compiler/options.m: compiler/handle_options.m: Always enable float registers in low-level C grades when floats are wider than a word. compiler/make_hlds_passes.m: Always allow double word floats to be stored unboxed in cells on C grades. compiler/hlds_goal.m: Add an extra field to `generic_call' which gives the register class to use for each argument. This is set by the float_regs pass. compiler/prog_data.m: Add an extra field to `pred_inst_info' which records the register class to use for each argument. This is set by the float_regs pass. compiler/hlds_pred.m: Add a field to `proc_sub_info' which lists the headvars which must be passed via regular registers despite their types. Add a field to `pred_sub_info' to record the original unsubstituted argument types for instance method predicates. compiler/check_typeclass.m: In the pred_info of an instance method predicate, record the original argument types before substituting the type variables for the instance. compiler/float_regs.m: compiler/transform_hlds.m: Add the new HLDS pass. compiler/mercury_compile_middle_passes.m: Run the new pass if float registers are enabled. compiler/lambda.m: Export the predicate to produce a predicate from a lambda. This is reused by float_regs.m to create wrapper closures. Add an argument to `expand_lambda' to set the reg_r_headvars field on the newly created procedure. Delete some unused fields from `lambda_info'. compiler/arg_info.m: Make `generate_proc_arg_info' no longer always use regular registers for calls to exported procedures. Do always use regular registers for class methods calls. Add a version of `make_arg_infos' which takes an explicit list of argument registers. Rename the previous version. Add `generic_call_arg_reg_types' to return the argument registers for a generic call. Add a version of `compute_in_and_out_vars' which additionally separates arguments for float and regular registers. compiler/call_gen.m: Use float registers for argument passing in higher-order calls, as directed by the new field in `generic_call'. compiler/code_util.m: Add a function to encode the number of regular and float register arguments when making a higher-order call. compiler/llds.m: Say that the `do_call_closure_N' functions only work for zero float register arguments. compiler/follow_vars.m: compiler/interval.m: Account for the use of float registers by generic call goals in these passes. compiler/unify_gen.m: Move float register arguments to the end of a closure's hidden arguments vector, after regular register arguments. Count hidden regular and float register arguments separately, but encode them in the same word in the closure. This is preferable to using two words because it reduces the differences between grades with and without float registers present. Disable generating code which creates a closure from an existing closure, if float registers exist. That code does not understand the reordered hidden arguments vector yet. compiler/continuation_info.m: Replace an argument's type_info in the closure layout if the argument is a float *and* is passed via a regular register, when floats are normally passed via float registers. Instead, give it the type_info for `private_builtin.float_box'. compiler/builtin_lib_types.m: Add function to return the type of `private_builtin.float_box/0'. compiler/hlds_out_goal.m: compiler/hlds_out_pred.m: compiler/mercury_to_mercury.m: Dump the new fields added to `generic_call', `pred_inst_info' and `proc_sub_info'. compiler/prog_type.m: Add helper predicate. compiler/*.m: Conform to changes. library/private_builtin.m: Add a type `float_box'. runtime/mercury_ho_call.h: Describe the modified closure representation. Rename the field which counts the number of hidden arguments to prevent it being used incorrectly, as it now encodes two numbers (potentially). Add macros to unpack the encoded field. runtime/mercury_ho_call.c: Update the description of how higher-order calls work. Update code which extracts closure arguments to take account the arguments being reordered in the hidden arguments vector. runtime/mercury_deep_copy.c: runtime/mercury_deep_copy_body.h: runtime/mercury_layout_util.c: runtime/mercury_ml_expand_body.h: Update code which extracts closure arguments to take account the arguments being reordered in the hidden arguments vector. runtime/mercury_type_info.c: runtime/mercury_type_info.h: Add helper function. tools/make_spec_ho_call: Update the generated do_call_closure_* functions to place float register arguments. tests/hard_coded/Mercury.options: tests/hard_coded/Mmakefile: tests/hard_coded/ho_float_reg.exp: tests/hard_coded/ho_float_reg.m: Add new test case. tests/hard_coded/copy_pred.exp: tests/hard_coded/copy_pred.m: tests/hard_coded/deconstruct_arg.exp: tests/hard_coded/deconstruct_arg.exp2: tests/hard_coded/deconstruct_arg.m: Extend test cases with float arguments in closures. tests/debugger/higher_order.exp2: Add alternative output, changed due to closure wrapping. tests/hard_coded/ho_univ_to_type.m: Adjust test case so that the float_regs pass does not report errors about missing higher-order insts. compiler/notes/compiler_design.html: Describe the new module. Delete a duplicated paragraph. compiler/notes/todo.html: TODO: Delete one hundred billion year old todos.	2012-02-13 00:11:57 +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	9ae7fe6b70	Change the argument ordering of predicates in the set module. ... Branches: main Change the argument ordering of predicates in the set module. library/set.m: Change predicate argument orders to match the versions in the svset module. Group function definitions with the corresponding predicates rather than at the end of the file. Delete Ralph's comments regarding the argument order in the module interface: readers of the library reference guide are unlikely to be interested in his opinion of the argument ordering ten or so years ago. Add extra modes for set.map/3 and set.map_fold/5. library/svset.m: library/eqvclass.m: library/tree234.m: library/varset.m: browser/*.m: compiler/*.m: deep_profiler/*.m: mdbcomp/trace_counts.m: extras/moose/grammar.m: extras/moose/lalr.m: extras/moose/moose.m: tests/hard_coded/bitset_tester.m: Conform to the above change. NEWS: Announce the above changes.	2011-05-06 05:03:29 +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	d96a8d33d4	Add a comment about a performance problem. ... Estimated hours taken: 2 Branches: main compiler/inst_util.m: Add a comment about a performance problem.	2009-07-16 08:34:32 +00:00
Zoltan Somogyi	d69ba1a1f0	Include the type_ctor in cons_ids for user-defined types. ... Estimated hours taken: 32 Branches: main Include the type_ctor in cons_ids for user-defined types. The intention is two-fold: - It prepares for a future in which we allow more than one function symbol to with the same name to be defined in a module. - It makes the HLDS code more self-contained. In many places, processing construction and deconstruction unifications required knowing which type the cons_id belongs to, but until now, code couldn't know that unless it kept track of the type of the variable unified with the cons_id. With this diff, user-defined cons_ids are represented as cons(SymName, Arity, TypeCtor) The last field is filled in during post-typecheck. After that time, any module qualification in the SymName (which may initially be partial) is redundant, since it is also available in the TypeCtor. In the future, we could make all those SymNames be just unqualified(_) at that time. We could also replace the current maps in HLDS type definitions with full cons_id keys with just name/arity keys (since the module qualifier is a given for any given type definition), we could also support partially qualified cons_ids in source code using a map from name/arity pairs to a list of all the type_ctors that have function symbols with that name/arity, instead of our current practice of inserting all possible partially module qualified version of every cons_id into a single giant table, and we could do the same thing with the field names table. This diff also separates tuples out from user-defined types, since in many respects they are different (they don't have a single type_ctor, for starters). It also separates out character constants, since they were alreay treated specially in most places, though not in some places where they *ought* to have been treated specially. Take the opportunity to give some other cons_ids better names. compiler/prog_data.m: Make the change described above, and document it. Put the implementations of the predicates declared in each part of this module next to the declarations, instead of keeping all the code until the very end (where it was usually far from their declarations). Remove three predicates with identical definitions from inst_match.m, inst_util.m and mode_constraints.m, and put the common definition in prog_data.m. library/term_io.m: Add a new predicate that is basically a reversible version of the existing function espaced_char, since the definition of char_consts needs reversibilty. compiler/post_typecheck.m: For functors of user-defined types, record their type_ctor. For tuples and char constants, record them as such. compiler/builtin_lib_types.m: compiler/parse_tree.m: compiler/notes/compiler_design.html: New module to centralize knowledge about builtin types, specially handled library types, and their function symbols. Previously, the stuff now in this module used to be in several different places, including prog_type.m and stm_expand.m, and some of it was duplicated. mdbcomp/prim_data.m: Add some predicates now needed by builtin_lib_types.m. compiler/builtin_ops.m: Factor out some duplicated code. compiler/add_type.m: Include the relevant type_ctors in the cons_ids generated in type definitions. compiler/hlds_data.m: Document an existing type better. Rename a cons_tag in sync with its corresponding cons_id. Put some declarations into logical order. compiler/hlds_out.m: Rename a misleadingly-named predicate. compiler/prog_ctgc.m: compiler/term_constr_build.m: Add XXXs for questionable existing code. compiler/add_clause.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/bytecode_gen.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/complexity.m: compiler/ctgc_selector.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/delay_partial_inst.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/erl_rtti.m: compiler/erl_unify_gen.m: compiler/export.m: compiler/field_access.m: compiler/foreign.m: compiler/format_call.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_desc.m: compiler/hlds_goal.m: compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/inst_graph.m: compiler/inst_match.m: compiler/inst_util.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/make_tags.m: compiler/mercury_compile.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/mlds_to_java.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_ordering.m: compiler/mode_util.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/polymorphism.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/prog_io_util.m: compiler/prog_mode.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/prog_type.m: compiler/prog_util.m: compiler/purity.m: compiler/qual_info.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/simplify.m: compiler/simplify.m: compiler/special_pred.m: compiler/ssdebug.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbagem: compiler/superhomoegenous.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/try_expand.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unify_modes.m: compiler/untupling.m: compiler/unused_imports.m: compiler/xml_documentation.m: Minor changes, mostly to ignore the type_ctor in cons_ids in places where it is not needed, take the type_ctor from the cons_id in places where it is more convenient, conform to the new names of some cons_ids, conform to the changes in hlds_out.m, and/or add now-needed imports of builtin_lib_types.m. In some places, the handling previously applied to cons/2 (which included tuples and character constants as well as user-defined function symbols) is now applied only to user-defined function symbols or to user-defined function symbols and tuples, as appropriate, with character constants being handled more like the other kinds of constants. In inst_match.m, rename a whole bunch of predicates to avoid ambiguities. In prog_util.m, remove two predicates that did almost nothing yet were far too easy to misuse.	2009-06-11 07:00:38 +00:00
Zoltan Somogyi	ea84652184	"Fix" a problem whose workaround by Julien was committed recently. ... Estimated hours taken: 6 Branches: main "Fix" a problem whose workaround by Julien was committed recently. The immediate symptom was a code generator abort caused by a model_non goal in a model_det context: a det procedure whose body was multi. The reason why the body was multi was that a disjunction with no outputs was not recognized as having no outputs, because instmap_delta_no_output_vars_2 does not succeed if the old and new insts of a variable specify non-overlapping sets of function symbols. This diff does not fix the actual problem (though it does document it), but it does make it much less likely to occur by making the mishandled situation much less likely to occur. compiler/instmap.m: Document the problem with instmap_delta_no_output_vars_2. Simplify the code of instmap_delta_no_output_vars_2. compiler/mode_util.m: When recomputing instmap_deltas of deconstruction unifications, abstractly unify the inst of the LHS variable before and after the deconstruction. If the cons_id does not appear among the possible cons_ids in the old inst, this will make the final inst not_reached, and avoid the problem situation for later. compiler/Mercury.options: Remove Julien's workaround, since it is not needed anymore. doc/user_guide.texi: Document the --dump-hlds-options a bit better. This helped in tracking down the problem. tests/hard_coded/Mmakefile: Reenable an old test that this change now enables us to pass. The following are style fixes only. compiler/compile_target_code.m: Fix formatting in the code affected by the workaround. compiler/handle_options.m: Add a dump alias to help diagnose determinism problems. compiler/inlining.m: compiler/inst_util.m: Minor style fixes. compiler/inst_match.m: Put the predicates into more logical groups. Move documentation of exported predicates from the implementation section to the interface section. Add a prefix to field names, to avoid ambiguity. Avoid the use of with_type and with_inst. Avoid the use of faux field accesses when it makes the actual steps harder to understand. Make the initial values of inst_match_info explicit. Abort when the lists of a cons_id's argument variables and argument modes are of different lengths.	2009-01-28 06:57:51 +00:00
Zoltan Somogyi	5ad9a27793	Speed up the compiler's handling of code that constructs large ground terms ... Estimated hours taken: 80 Branches: main Speed up the compiler's handling of code that constructs large ground terms by specializing the treatment of such code. This diff reduces the compilation time for training_cars_full.m from 106.9 seconds to 30.3 seconds on alys, my laptop. The time on tools/speedtest stays pretty much the same. compiler/hlds_goal.m: Record the classification of from_ground_term scopes as purely constructing terms, purely deconstructing them or something other. Fix an old potential bug: variables inside the construct_how fields of unifications weren't being renamed along with other variables. This is a bug if any part of the compiler later looks at those variables. (I am not sure whether or not this happens.) compiler/superhomogenous.m: Provisionally mark newly constructed static terms as being from_ground_term_construct. Mode checking will either confirm this or change the scope kind. compiler/options.m: compiler/handle_options.m: Add a new option, from_ground_term_threshold, that allows the user to set the boundary between ground terms that get scopes and ground terms do not. I plan to experiment with different settings later. compiler/modes.m: Make this classification. For scopes that construct ground terms, use a specialized algorithm that avoids quadratic behavior. (It does not access the unify_inst_table, which is where the factor of N other than the length of the goal list came from.) The total size of the instmap_deltas, if printed out, still looks like O(N^2) in size, but due to structure sharing it needs only O(N) memory. For scopes that construct ground terms, set the determinism information so that det_analysis.m doesn't have to traverse such scopes. When handling disjunctions, check whether some nonlocals of the disjunctions are constructed by from_ground_term_construct scopes. For any such nonlocals, set their insts to just ground, throwing away the precise information we have about exactly what function symbols they and ALL their subterms are bound to. This is HUGE win, since it allows us avoid spending a lot of time building a huge merge_inst table, which later passes of the compiler (e.g. equiv_type_hlds) would then have to spend similarly huge times traversing. This approach does have a down side. If lots of arms of a disjunction bind a nonlocal to a large ground term, but a few bind it to a SMALL ground term, a term below the from_ground_term_threshold, this optimization won't kick in. That could be one purpose of the new option. It isn't documented yet; I will seek feedback about its usefulness first. compiler/modecheck_unify.m: Handle the three different kinds of right hand sides separately. This yields a small speedup, because now we don't test rhs_vars and rhs_functors (the common right hand sides) for a special case (goals containing "any" insts) that is applicable only to rhs_lambda_goals. compiler/unique_modes.m: Don't traverse scopes that construct ground terms, since modes.m has already done everything that needs to be done. compiler/det_analysis.m: Don't traverse scopes that construct ground terms, since modes.m has already done the needed work. compiler/instmap.m: Add a new predicate for use by modes.m. Many predicate names in this module were quite uninformative; give them informative names. compiler/polymorphism.m: If this pass invalidates the from_ground_term_construct invariants, then mark the relevant scope as from_ground_term_other. Delete two unused access predicates. compiler/equiv_type_hlds.m: Don't traverse scopes that construct ground terms, since modes.m ensures that their instmap deltas do not contain typed insts, and thus the scope cannot contain types that need to be expanded. Convert some predicates to single clauses. compiler/goal_form.m: compiler/goal_util.m: In predicates that test goals for various properties, don't traverse scopes that construct ground terms when the outcome of the test is the same for all such scopes. Convert some predicates to single clauses. compiler/simplify.m: Do not look for common structs in from_ground_term_construct scopes, both because this speeds up the compiler, and because retaining references to ground terms is in fact a pessimization, not an optimization. This is because (a) those references need to be stored in stack slots across calls, and (b) the C code generators ensure that the cells representing ground terms will be shared as needed. If all arms of a switch are from_ground_term_construct scopes, do not merge the instmap_deltas from those arms, since this is both time-consuming (even after the other changes in this diff) and extremely unlikely to improve the instmap_delta. Disable common_struct in from_ground_term_construct scopes, since for these scopes, it is actually a pessimization. Do not delete from_ground_term_construct scopes, since many compiler passes can now use them. Do some manual deforestation, break up some large predicates, and give better names to some. compiler/liveness.m Special-case the handling from_ground_term_construct scopes. This allows us to traverse them just once instead of three times, and this traversal is simpler and faster than any of the three. In some traversals, we were switching on the goal type twice; once in e.g. detect_liveness_in_goal_2, and once by calling goal_expr_has_subgoals. Eliminate the double switching by merging the relevant predicates. (The double-switching structure was easier to work with before we had multi-cons-id switches.) compiler/typecheck.m: Move a lookup after a test, so we don't have to do it if the test fails. Provide a specialized mode for a predicate. This should allow the compiler to eliminate an argument and a test in the common case. Note a possible chance for a speedup. compiler/typecheck_info.m: Don't apply empty substitutions to the types of a possibly very large set of variables. compiler/quantification.m: Don't quantify from_ground_term_construct scopes. They are created correctly quantified, and any compiler pass that invalidates that quantification also removes the from_ground_term_construct mark. Don't apply empty renamings to a possibly very large set of variables. Move the code for handling scopes to its own predicate, to avoid overwhelming the code that handles other kinds of goals. Even from this, factor out the renaming code, since it is needed only for some kinds of scopes. Make some predicate names better reflect what the predicate does. compiler/pd_cost.m: For from_ground_term_construct scopes, instead of computing their cost by adding up the costs of the goals inside, make their cost a constant, since binding a variable to a static term takes constant time. compiler/pd_info.m: Add prefixes on field names to avoid ambiguities. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/closure_analysis.m: compiler/constraint.m: compiler/cse_detection.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/distance_granularity.m: compiler/exception_analysis.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/format_call.m: compiler/granularity.m: compiler/higher_order.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/loop_inv.m: compiler/middle_rec.m: compiler/mode_util.m: compiler/parallel_to_plain_conj.m: compiler/saved_vars.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.lbu.m: compiler/structure_sharing.analysis.m: compiler/switch_detection.analysis.m: compiler/trail_analysis.m: compiler/term_pass1.m: compiler/tupling.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: These passes have nothing to do in from_ground_term_construct scopes, so don't traverse them. In some modules (e.g. dead_proc_elim), some traversals had to be kept. In loop_inv.m, replace a code structure that updated accumulators with functions (which prevented the natural use of state variables), that in lots of places reconstructed the term it had just deconstructed, and obscured the identical handling of different kinds of goals, with a structure based on predicates, state variables and shared code for different goal types where possible. In store_alloc.m, avoid some double switching on the same value. In stratify.m, unneeded_code.m and unused_args.m, rename predicates to avoid ambiguities. compiler/goal_path.m: compiler/goal_util.m: compiler/implementation_defined_literals.m: compiler/intermode.m: compiler/mark_static_terms.m: compiler/ml_code_gen.m: compiler/mode_ordering.m: compiler/ordering_mode_constraints.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_path.m: compiler/rbmm.region_transformation.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/term_const_build.m: compiler/term_traversal.m: compiler/unused_imports.m: Mark places where we cannot (yet) special case from_ground_term_construct scopes. In structure_reuse.lfu.m, turn nested if-then-elses into a switch in. compiler/size_prof.m: Turn from_ground_term_construct scopes into from_ground_term_other scopes, since in term size profiling grades, we need to attach sizes to terms. Give predicates better names. compiler/*.m: Minor changes to conform to the changes above. compiler/make_hlds_passes.m: With -S, print statistics after the third pass over items, since this is the time-consuming one. compiler/mercury_compile.m: Conform to the new names of some predicates. When declining to output a HLDS dump because it would be identical to the previous dump, don't confuse the user either by being silent about the decision, or by leaving an old dump laying around that could be mistaken for a new one. tools/binary: tools/binary_step: Bring these tools up to date. compiler/Mmakefile: Add an int3s target for use by the new code in the tools. The Mmakefiles in the other directories with Mercury code already have such a target. compiler/notes/allocation.html: Fix an out-of-date reference. tests/debugger/polymorphic_ground_term.{m,inp,exp}: New test case to check whether liveness.m handles typeinfo liveness of ground terms correctly. tests/debugger/Mmakefile: Enable the new test case. tests/debugger/polymorphic_output.{m,exp}: Fix tab/space mixup.	2008-12-23 01:38:03 +00:00
Mark Brown	7460aadbf8	Implement higher-order any' insts. Pred or func expressions with an any' ... Estimated hours taken: 100 Branches: main Implement higher-order `any' insts. Pred or func expressions with an `any' inst may bind non-local solver variables, but themselves must not be called in a negated context. (The existing ground pred and func expressions may not bind non-local solver variables, but may be called in a negated context.) Higher-order `any' insts are specified by using `any_pred' and `any_func' in place of `pred' and `func', respectively. We implement these insts by adding a new field to the any/1 constructor of mer_inst, which is identical to the ground_inst_info field of the ground/2 constructor. Both are given the new type `ho_inst_info'. We then relax the locking of non-local variables in these pred and func expressions, and extend call/N and apply/N to also accept the new insts (provided the variables are not locked). We also store the groundness (ho_ground or ho_any) of each lambda expression in a unification, in a new field in the rhs_lambda_goal constructor. NEWS: Mention the new feature. compiler/prog_data.m: Rename the ground_inst_info type ho_inst_info, and update its documentation. Add the ho_inst_info field to the any constructor in mer_inst. compiler/hlds_goal.m: Add the rhs_groundness field to rhs_lambda_goal in unify_rhs. compiler/inst_match.m: Propagate inst matching into the pred_inst_infos of any insts, if they exist. compiler/inst_util.m: Propagate abstract unification and inst merging into the pred_inst_infos of any insts, if they exist. May use of this information when building ground, any, shared and mostly_unique versions of insts. compiler/modecheck_call.m: Allow an `any' inst as the pred (func) argument to call/N (apply/N), but check that the variable is not locked. If the variable is locked, report a mode error which suggests using the ground inst. (We could also suggest that the goal be made impure, but it is best to point users towards the pure approach.) compiler/modecheck_unify.m: Relax the locking of non-locals when processing non-ground lambda goals. Update documentation. compiler/mode_util.m: Propagate type information into the pred_inst_infos of any insts. compiler/mode_errors.m: Change the purity error "lambda should be impure" to "lambda should be any", since this is better advice. Also provide an example of correct syntax if the verbose errors option is given. compiler/prog_io_goal.m: Parse the new kinds of expressions, returning the groundness along with the existing information about lambda expressions. compiler/superhomogeneous.m: Use the above groundness when building the lambda unification. compiler/prog_io_util.m: Parse the new kind of insts, filling in the new ho_inst_info field where appropriate. compiler/polymorphism.m: Handle the new fields. Assume that the shorthand form of lambda expressions always defines a ground inst -- if users want non-ground higher-order expressions they will need to use an explicit any_pred or any_func expression. compiler/equiv_type_hlds.m: Replace equivalent types in the pred_inst_infos of `any' insts. compiler/module_qual.m: Module qualify the pred_inst_infos of `any' insts. compiler/recompilation.usage.m: compiler/unused_imports.m: Look for items or imports used by insts in the pred_inst_infos of `any' insts. compiler/hlds_out.m: compiler/mercury_to_mercury.m: Output the new lambda expressions and insts in the correct format. compiler/type_util.m: Treat all pred and func types as solver types. (Effectively they are, since all such types can now have non-ground values, with call/N and apply/N acting as constraints.) compiler/lambda.m: Pass the groundness value when building procedures for lambda expressions. This is not currently required for anything. doc/reference_manual.texi: Document the new feature, and update existing documentation on solver types and negated contexts. tests/valid/Mmakefile: tests/valid/ho_any_inst.m: New test case for some valid code using higher-order any insts. tests/invalid/Mmakefile: tests/invalid/ho_any_inst.err_exp: tests/invalid/ho_any_inst.m: New test case for some illegal code. tests/invalid/anys_in_negated_contexts.err_exp: Update expected error message for this test case. We now report that the expression should be `any', rather than impure. compiler/*.m: Handle the new fields.	2008-01-22 15:08:36 +00:00
Zoltan Somogyi	cc88711d63	Implement true multi-cons_id arm switches, i.e. switches in which we associate ... Estimated hours taken: 40 Branches: main Implement true multi-cons_id arm switches, i.e. switches in which we associate more than one cons_id with a switch arm. Previously, for switches like this: ( X = a, goal1 ; ( X = b ; X = c ), goal2 ) we duplicated goal2. With this diff, goal2 won't be duplicated. We still duplicate goals when that is necessary, i.e. in cases which the inner disjunction contains code other than a functor test on the switched-on var, like this: ( X = a, goal1 ; ( X = b, goalb ; X = c goalc ), goal2 ) For now, true multi-cons_id arm switches are supported only by the LLDS backend. Supporting them on the MLDS backend is trickier, because some MLDS target languages (e.g. Java) don't support the concept at all. So when compiling to MLDS, we still duplicate the goal in switch detection (although we could delay the duplication to just before code generation, if we wanted.) compiler/options.m: Add an internal option that tells switch detection whether to look for multi-cons_id switch arms. compiler/handle_options.m: Set this option based on the back end. Add a version of the "trans" dump level that doesn't print unification details. compiler/hlds_goal.m: Extend the representation of switch cases to allow more than one cons_id for a switch arm. Add a type for representing switches that also includes tag information (for use by the backends). compiler/hlds_data.m: For du types, record whether it is possible to speed up tests for one cons_id (e.g. cons) by testing for the other (nil) and negating the result. Recording this information once is faster than having unify_gen.m trying to compute it from scratch for every single tag test. Add a type for representing a cons_id together with its tag. compiler/hlds_out.m: Print out the cheaper_tag_test information for types, and possibly several cons_ids for each switch arm. Add some utility predicates for describing switch arms in terms of which cons_ids they are for. Replace some booleans with purpose-specific types. Make hlds_out honor is documentation, and not print out detailed information about unifications (e.g. uniqueness and static allocation) unless the right character ('u') is present in the control string. compiler/add_type.m: Fill in the information about cheaper tag tests when adding a du type. compiler/switch_detection.m: Extend the switch detection algorithm to detect multi-cons_id switch arms. When entering a switch arm, update the instmap to reflect that the switched-on variable can now be bound only to the cons_ids that this switch arm is for. We now need to do this, because if the arm contains another switch on the same variable, computing the can_fail field of that switch correctly requires us to know this information. (Obviously, an arm for a single cons_id is unlikely to have switch on the same variable, and for arms for several cons_ids, we previously duplicated the arm and left the unification with the cons_id in each copy, and this unification allowed the correct handling of any later switches. However, the code of a multi-cons_id switch arm obviously cannot have a unification with each cons_id in it, which is why we now need to get the binding information from the switch itself.) Replace some booleans with purpose-specific types, and give some predicates better names. compiler/instmap.m: Provide predicates for recording that a switched-on variable has one of several given cons_ids, for use at the starts of switch arms. Give some predicates better names. compiler/modes.m: Provide predicates for updating the mode_info at the start of a multi-cons_id switch arm. compiler/det_report.m: Handle multi-cons_id switch arms. Update the instmap when entering each switch arm, since this is needed to provide good (i.e. non-misleading) error messages when one switch on a variable exists inside another switch on the same variable. Since updating the instmap requires updating the module_info (since the new inst may require a new entry in an inst table), thread the det_info through as updateable state. Replace some multi-clause predicate definitions with single clauses, to make it easier to print the arguments in mdb. Fix some misleading variable names. compiler/det_analysis.m: Update the instmap when entering each switch arm and thread the det_info through as updateable state, since the predicates we call in det_report.m require this. compiler/det_util.m: Handle multi-cons_id switch arms. Rationalize the argument order of some access predicates. compiler/switch_util.m: Change the parts of this module that deal with string and tag switches to optionally convert each arm to an arbitrary representation of the arm. In the LLDS backend, the conversion process generated code for the arm, and the arm's representation is the label at the start of this code. This way, we can duplicate the label without duplicating the code. Add a new part of this module that associates each cons_id with its tag, and (during the same pass) checks whether all the cons_ids are integers, and if so what are min and max of these integers (needed for dense switches). This scan is needed because the old way of making this test had single-cons_id switch arms as one of its basic assumptions, and doing it while adding tags to each case reduces the number of traversals required. Give better names to some predicates. compiler/switch_case.m: New module to handle the tasks associated with managing multi-cons_id switch arms, including representing them for switch_util.m. compiler/ll_backend.m: Include the new module. compiler/notes/compiler_design.html: Note the new module. compiler/llds.m: Change the computed goto instruction to take a list of maybe labels instead of a list of labels, with any missing labels meaning "not reached". compiler/string_switch.m: compiler/tag_switch.m: Reorganize the way these modules work. We can't generate the code of each arm in place anymore, since it is now possible for more than one cons_id to call for the execution of the same code. Instead, in string_switch.m, we generate the codes of all the arms all at once, and construct the hash index afterwards. (This approach simplifies the code significantly.) In tag switches (unlike string switches), we can get locality benefits if the code testing for a cons_id is close to the code for that cons_id, so we still try to put them next to each other when such a locality benefit is available. In both modules, the new approach uses a utility predicate in switch_case.m to actually generate the code of each switch arm, eliminating several copies the same code in the old versions of these modules. In tag_switch.m, don't create a local label that simply jumps to the code address do_not_reached. Previously, we had to do this for positions in jump tables that corresponded to cons_ids that the switch variable could not be bound to. With the change to llds.m, we now simply generate a "no" instead. compiler/lookup_switch.m: Get the info about int switch limits from our caller; don't compute it here. Give some variables better names. compiler/dense_switch.m: Generate the codes of the cases all at once, then assemble the table, duplicate the labels as needed. This separation of concerns allows significant simplifications. Pack up all the information shared between the predicate that detects whether a dense switch is appropriate and the predicate that actually generates the dense switch. Move some utility predicates to switch_util. compiler/switch_gen.m: Delete the code for tagging cons_ids, since that functionality is now in switch_util.m. The old version of this module could call the code generator to produce (i.e. materialize) the switched-on variable repeatedly. We now produce the variable once, and do the switch on the resulting rval. compiler/unify_gen.m: Use the information about cheaper tag tests in the type constructor's entry in the HLDS type table, instead of trying to recompute it every time. Provide the predicates switch_gen.m now needs to perform tag tests on rvals, as opposed to variables, and against possible more than one cons_id. Allow the caller to provide the tag corresponding to the cons_id(s) in tag tests, since when we are generating code for switches, the required computations have already been done. Factor out some code to make all this possible. Give better names to some predicates. compiler/code_info.m: Provide some utility predicates for the new code in other modules. Give better names to some existing predicates. compiler/hlds_code_util.m: Rationalize the argument order of some predicates. Replace some multi-clause predicate definitions with single clauses, to make it easier to print the arguments in mdb. compiler/accumulator.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/build_mode_constraints.m: compiler/check_typeclass.m: compiler/closure_analysis.m: compiler/code_util.m: compiler/constraint.m: compiler/cse_detection.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/distance_granularity.m: compiler/dupproc.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/exception_analysis.m: compiler/export.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/foreign.m: compiler/format_call.m: compiler/frameopt.m: compiler/goal_form.m: compiler/goal_path.m: compiler/goal_util.m: compiler/granularity.m: compiler/hhf.m: compiler/higher_order.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/inst_check.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lambda.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/livemap.m: compiler/liveness.m: compiler/llds_out.m: compiler/llds_to_x86_64.m: compiler/loop_inv.m: compiler/make_hlds_warn.m: compiler/mark_static_terms.m: compiler/middle_rec.m: compiler/ml_tag_switch.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_util.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pd_cost.m: compiler/pd_into.m: compiler/pd_util.m: compiler/peephole.m: compiler/polymorphism.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/purity.m: compiler/quantification.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_paths.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/store_alloc.m: compiler/stratify.m: compiler/structure_reuse.direct.choose_reuse.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/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/trailing_analysis.m: compiler/transform_llds.m: compiler/tupling.m: compiler/type_ctor_info.m: compiler/type_util.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/xml_documentation.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. compiler/ml_string_switch.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. Give some predicates better names. compiler/dependency_graph.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. Change the order of arguments of some predicates to make this easier. compiler/bytecode.m: compiler/bytecode_data.m: compiler/bytecode_gen.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. (The bytecode interpreter has not been updated.) compiler/prog_rep.m: mdbcomp/program_representation.m: Change the byte sequence representation of goals to allow switch arms with more than one cons_id. compiler/prog_rep.m now writes out the updated representation, while mdbcomp/program_representation.m reads in the updated representation. deep_profiler/mdbprof_procrep.m: Conform to the updated program representation. tools/binary: Fix a bug: if the -D option was given, the stage 2 directory wasn't being initialized. Abort if users try to give that option more than once. compiler/Mercury.options: Work around bug #32 in Mantis.	2007-12-30 08:24:23 +00:00
Zoltan Somogyi	b56885be93	Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. ... Estimated hours taken: 12 Branches: main Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. The problem was not in lco.m, but in follow_code.m. In some cases, (specifically, the LCMC version of insert_2 in sparse_bitset.m), follow_code.m moved an impure goal (store_at_ref) into the arms of an if-then-else without marking those arms, or the if-then-else, as impure. The next pass, simplify, then deleted the entire if-then-else, since it had no outputs. (The store_at_ref that originally appeared after the if-then-else was the only consumer of its only output.) The fix is to get follow_code.m to make branched control structures such as if-then-elses, as well as their arms, semipure or impure if a goal being moved into them is semipure or impure, or if they came from an semipure or impure conjunction. Improve the optimization of the LCMC version of sparse_bitset.insert_2, which had a foreign_proc invocation of bits_per_int in it: replace such invocations with a unification of the bits_per_int constant if not cross compiling. Add a new option, --optimize-constructor-last-call-null. When set, LCMC will assign NULLs to the fields not yet filled in, to avoid any junk happens to be there from being followed by the garbage collector's mark phase. This diff also makes several other changes that helped me to track down the bug above. compiler/follow_code.m: Make the fix described above. Delete all the provisions for --prev-code; it won't be implemented. Don't export a predicate that is not now used anywhere else. compiler/simplify.m: Make the optimization described above. compiler/lco.m: Make sure that the LCMC specialized procedure is a predicate, not a function: having a function with the mode LCMC_insert_2(in, in) = in looks wrong. To avoid name collisions when a function and a predicate with the same name and arity have LCMC applied to them, include the predicate vs function status of the original procedure included in the name of the new procedure. Update the sym_name of calls to LCMC variants, not just the pred_id, because without that, the HLDS dump looks misleading. compiler/pred_table.m: Don't have optimizations like LCMC insert new predicates at the front of the list of predicates. Maintain the list of predicates in the module as a two part list, to allow efficient addition of new pred_ids at the (logical) end without using O(N^2) algorithms. Having predicates in chronological order makes it easier to look at HLDS dumps and .c files. compiler/hlds_module.m: Make module_info_predids return a module_info that is physically updated though logically unchanged. compiler/options.m: Add --optimize-constructor-last-call-null. Make the options --dump-hlds-pred-id, --debug-opt-pred-id and --debug-opt-pred-name into accumulating options, to allow the user to specify more than one predicate to be dumped (e.g. insert_2 and its LCMC variant). Delete --prev-code. doc/user_guide.texi: Document the changes in options.m. compiler/code_info.m: Record the value of --optimize-constructor-last-call-null in the code_info, to avoid lookup at every cell construction. compiler/unify_gen.m: compiler/var_locn.m: When deciding whether a cell can be static or not, make sure that we never make static a cell that has some fields initialized with dummy zeros, to be filled in for real later. compiler/hlds_out.m: For goals that are semipure or impure, note this fact. This info was lost when I changed the representation of impurity from markers to a field. mdbcomp/prim_data.m: Rename some ambiguous function symbols. compiler/intermod.m: compiler/trans_opt.m: Rename the main predicates (and some function symbols) of these modules to avoid ambiguity and to make them more expressive. compiler/llds.m: Don't print line numbers for foreign_code fragments if the user has specified --no-line-numbers. compiler/make.dependencies.m: compiler/mercury_to_mercury.m: compiler/recompilation.usage.m: Don't use io.write to write out information to files we may need to parse again, because this is vulnerable to changes to the names of function symbols (e.g. the one to mdbcomp/prim_data.m). The compiler still contains some uses of io.write, but they are for debugging. I added an item to the todo list of the one exception, ilasm.m. compiler/recompilation.m: Rename a misleading function symbol name. compiler/parse_tree.m: Don't import recompilation.m here. It is not needed (all the components of parse_tree that need recompilation.m already import it themselves), and deleting the import avoids recompiling almost everything when recompilation.m changes. compiler/*.m: Conform to the changes above. compiler/*.m: browser/*.m: slice/*.m: Conform to the change to mdbcomp. library/sparse_bitset.m: Use some better variable names.	2007-01-19 07:05:06 +00:00
Julien Fischer	f5345e7b46	Add some higher-order operations that work on proc_arg_vectors. ... Estimated hour taken: 1.5 Branches: main Add some higher-order operations that work on proc_arg_vectors. These are required by upcoming changes. Remove ambiguities on the function symbol `dead' by renaming type constructors (and in one case by deleting an unused type.) Julien. compiler/hlds_args.m: Add some higher-order operations for proc_arg_vectors. compiler/hlds_pred.m: Delete the type `liveness' since it is unused and its function symbols clash with the function symbols of other types. compiler/prog_data.m: Add prefixes to the function symbols of the type is_live in order to make them unambiguous. compiler/var_locn.m: Do the same for the function symbols for the dead_or_alive type. compiler/inst_match.m: compiler/inst_util.m: compiler/instmap.m: compiler/mercury_to_mercury.m: compiler/mode_info.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/unique_modes.m: Conform to the above changes. compiler_unify_gen.m Switch on the arg_mode type in a few spots. Conform to the above changes. compiler/structure_sharing.domain.m Fix some comments.	2007-01-15 10:30:36 +00:00