mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-19 07:45:09 +00:00
21685c9e226249ef2dcad4c3a2d1c8bbb6c85129
108 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Zoltan Somogyi
|
21685c9e22 |
Improve the error messages generated for determinism errors involving committed
Estimated hours taken: 6
Branches: main
Improve the error messages generated for determinism errors involving committed
choice contexts. Previously, we printed a message to the effect that e.g.
a cc pred is called in context that requires all solutions, but we didn't say
*why* the context requires all solutions. We now keep track of all the goals
to the right that could fail, since it is these goals that may reject the first
solution of a committed choice goal.
The motivation for this diff was the fact that I found that locating the
failing goal can be very difficult if the conjunction to the right is
a couple of hundred lines long. This would have been a nontrivial problem,
since (a) unifications involving values of user-defined types are committed
choice goals, and (b) we can expect uses of user-defined types to increase.
compiler/det_analysis.m:
Keep track of goals to the right of the current goal that could fail,
and include them in the error representation if required.
compiler/det_report.m:
Include the list of failing goals to the right in the representations
of determinism errors involving committed committed choice goals.
Convert the last part of this module that wasn't using error_util
to use error_util. Make most parts of this module just construct
error message specifications; print those specifications (using
error_util) in only a few places.
compiler/hlds_out.m:
Add a function for use by the new code in det_report.m.
compiler/error_util.m:
Add a function for use by the new code in det_report.m.
compiler/error_util.m:
compiler/compiler_util.m:
Error_util is still changing reasonably often, and yet it is
included in lots of modules, most of which need only a few simple
non-parse-tree-related predicates from it (e.g. unexpected).
Move those predicates to a new module, compiler_util.m. This also
eliminates some undesirable dependencies from libs to parse_tree.
compiler/libs.m:
Include compiler_util.m.
compiler/notes/compiler_design.html:
Document compiler_util.m, and fix the documentation of some other
modules.
compiler/*.m:
Import compiler_util instead of or in addition to error_util.
To make this easier, consistently use . instead of __ for module
qualifying module names.
tests/invalid/det_errors_cc.{m,err_exp}:
Add this new test case to test the error messages for cc contexts.
tests/invalid/det_errors_deet.{m,err_exp}:
Add this new test case to test the error messages for unifications
inside function symbols.
tests/invalid/Mmakefile:
Add the new test cases.
tests/invalid/det_errors.err_exp:
tests/invalid/magicbox.err_exp:
Change the expected output to conform to the change in det_report.m,
which is now more consistent.
|
||
|
Zoltan Somogyi
|
f9fe8dcf61 |
Improve the error messages generated for determinism errors involving committed
Estimated hours taken: 8
Branches: main
Improve the error messages generated for determinism errors involving committed
choice contexts. Previously, we printed a message to the effect that e.g.
a cc pred is called in context that requires all solutions, but we didn't say
*why* the context requires all solutions. We now keep track of all the goals
to the right that could fail, since it is these goals that may reject the first
solution of a committed choice goal.
The motivation for this diff was the fact that I found that locating the
failing goal can be very difficult if the conjunction to the right is
a couple of hundred lines long. This would have been a nontrivial problem,
since (a) unifications involving values of user-defined types are committed
choice goals, and (b) we can expect uses of user-defined types to increase.
compiler/det_analysis.m:
Keep track of goals to the right of the current goal that could fail,
and include them in the error representation if required.
compiler/det_report.m:
Include the list of failing goals to the right in the representations
of determinism errors involving committed committed choice goals.
Convert the last part of this module that wasn't using error_util
to use error_util. Make most parts of this module just construct
error message specifications; print those specifications (using
error_util) in only a few places.
compiler/hlds_out.m:
Add a function for use by the new code in det_report.m.
compiler/error_util.m:
Add a function for use by the new code in det_report.m.
compiler/error_util.m:
compiler/compiler_util.m:
Error_util is still changing reasonably often, and yet it is
included in lots of modules, most of which need only a few simple
non-parse-tree-related predicates from it (e.g. unexpected).
Move those predicates to a new module, compiler_util.m. This also
eliminates some undesirable dependencies from libs to parse_tree.
compiler/libs.m:
Include compiler_util.m.
compiler/notes/compiler_design.html:
Document compiler_util.m, and fix the documentation of some other
modules.
compiler/*.m:
Import compiler_util instead of or in addition to error_util.
To make this easier, consistently use . instead of __ for module
qualifying module names.
tests/invalid/det_errors_cc.{m,err_exp}:
Add this new test case to test the error messages for cc contexts.
tests/invalid/det_errors_deet.{m,err_exp}:
Add this new test case to test the error messages for unifications
inside function symbols.
tests/invalid/Mmakefile:
Add the new test cases.
tests/invalid/det_errors.err_exp:
tests/invalid/magicbox.err_exp:
Change the expected output to conform to the change in det_report.m,
which is now more consistent.
|
||
|
Julien Fischer
|
9ec3ae8d08 |
Fix the problems with mutable declarations and sub-modules by making
Estimated hours taken: 11 Branches: main Fix the problems with mutable declarations and sub-modules by making sure that the relevant information is written out in the private interface files. Fix a bug where mutable variables were not being initialised with their declared intial value. The problem was that the compiler was optimizing away the body of the automatically generated predicate that was setting the initial value. We now make such predicates impure to prevent this. In order to support the above, accept `:- intialise' declarations that specify impure predicates, provided that the declaration in question was generated by the compiler. It is still an error for the user to specify such declarations. Fix some other problems with mutable declarations. compiler/modules.m: Do not write `:- mutable' declarations out to private interface files, instead write out the predicate and mode declarations for the access predicates. Remove some old XXX comments about mutables that are no longer relevant. compiler/make_hlds_passes.m: Don't add the export pragmas for initialise declarations during pass 2. For some reason we were doing this during pass 2 and again during pass 3. Make the intialise predicates for mutable variables impure in order to prevent the compiler from optimizing them away Fix origin fields that were being set incorrectly during the mutable transformation. compiler/prog_mutable.m: New module. Shift some code from make_hlds_passes to here, since modules.m also needs access to it. compiler/parse_tree.m: Include the new module. compiler/notes/compiler_design.html: Mention the new module. tests/hard_coded/sub-modules/Mmakefile: tests/hard_coded/sub-modules/mutable_parent.m: tests/hard_coded/sub-modules/mutable_child.m: tests/hard_coded/sub-modules/mutable_grandchild.m: tests/hard_coded/sub-modules/mutable_parent.exp: Test case for mutables and sub-modules. tests/hard_coded/not_in_interface.m: tests/hard_coded/not_in_interface.err_exp: Test for ordering problems between mutable and initialise declarations when emitting errors about items that should not occur in module interfaces. This can happen if the item's origin field is incorrectly set. |
||
|
Zoltan Somogyi
|
df0d9036cf |
Optimize calls that would be tail calls in Prolog but are followed by
Estimated hours taken: 40 Branches: main Optimize calls that would be tail calls in Prolog but are followed by construction unifications in Mercury: last call modulo construction. For now, the optimization is available only for the LLDS backend. compiler/lco.m: Turn this module from a placeholder to a real implementation of the optimization. compiler/hlds_goal.m: Allow lco.m to attach to construction unifications a note that says that certain arguments, instead of being filled in by the unification, should have their addresses taken and stored in the corresponding variables. Group this note together with the note that asks for term size profiling to avoid an increase in the sizes of goals in the compiler in most cases. compiler/hlds_pred.m: Provide a predicate for setting the name of a predicate after its creation. This functionality is used by lco.m. Extend the pred_transformation part of the pred_origin type to allow it to express that a procedure was created by lco.m. List the new primitive store_at_ref as a no-typeinfo builtin. Fix some problems with indentation. compiler/layout_out.m: Handle the new pred_transformation. compiler/unify_gen.m: When processing construction unifications that have the new feaure turned on, perform the requested action. Fix some departures from coding style. Shorten lines by deleting unnecessary module qualifications. Add some auxiliary predicates to make the code easier to read. compiler/var_locn.m: Fix an earlier oversight: when materializing variables inside rvals and lvals, look inside memory references too. Previously, the omission didn't matter, since we didn't generate such references, but now we do. Fix some departures from coding style. compiler/llds_out.m: Fix some old XXXs in code handling memory references. We didn't use to generate such references, but now we do. Move some functionality here from code_aux.m. compiler/code_info.m: Provide some primitive operations needed by the new code in var_locn.m. Delete an unneeded predicate. compiler/options.m: Rename the existing option optimize_constructor_last_call as optimize_constructor_last_call_accumulator, since that optimization is done by accumulator.m. Make optimize_constructor_last_call be the option that calls for the new optimization. compiler/handle_options.m: Handle the implications of the new option. compiler/mercury_compile.m: Invoke the lco module by its new interface. librrary/private_builtin.m: Add a new primitive operation, store_at_ref, for use by the new optimization. Switch the module to four-space indentation. compiler/add_clause.m: Comment out the warning for clauses for builtin, since this is needed to bootstrap the addition of the new builtin. compiler/term_constr_initial.m: Handle the new builtin. compiler/accumulator.m: Conform to the change in options. compiler/builtin_ops.m: Provide a third template for builtins, for use by store_at_ref. Convert the file to four-space indentation. compiler/call_gen.m: Generate code following the new builtin template. compiler/rl_exprn.m: Minor changes to conform to the changes in builtin templates. compiler/quantification.m: Minor changes to conform to the changes in construct unifications. Don't make the "get" predicates operating on quantification_infos to return the "new" quantification_info: it is always the same as the old one. compiler/aditi_builtin_ops.m: compiler/common.m: compiler/deep_profiling.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/lambda.m: compiler/magic_util.m: compiler/ml_unify_gen.m: compiler/modecheck_unify.m: compiler/polymorphism.m: compiler/size_prof.m: Minor changes to conform to the changes in construct unifications. compiler/dependency_graph.m: Add a new predicate to recompute the dependency information, even if a previous (and possibly now inaccurate) version is present. Change the interface to make it clearer, by changing bools into types specific to the situation. Convert the file to four-space indentation. compiler/mode_constraints.m: Minor changes to conform to the changes in dependency_graph.m. compiler/code_aux.m: Delete this module. Half its functionality has been moved into llds_out.m, half to middle_rec.m (its only user). compiler/goal_form.m: Move the predicates in this module that are used only by middle_rec.m to middle_rec.m. Convert the file to four-space indentation. compiler/goal_util.m: compiler/det_util.m: Move update_instmap from det_util to goal_util, since it is usefulness extends beyond determinism analysis. Convert det_util.m to four-space indentation. compiler/middle_rec.m: Move here the code required only here from code_aux and goal_form. Update the moved code for the changes in construct unifications. The updates are specific to middle_rec.m: they wouldn't be of use to other modules. They basically say that any code that takes the addresses of fields cannot be handled by middle_rec.m. compiler/code_gen.m: compiler/det_analysis.m: compiler/live_vars.m: compiler/ll_backend.m: compiler/loop_inv.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/notes/compiler_design.html: Minor changes to conform to the deletion of code_aux.m and/or the movement of code from det_util to goal_util.m. compiler/opt_debug.m: Print info for vars in rvals. compiler/hlds_module.m: Convert a lambda to an explicit predicate to make some code easier to read. Switch the module to four-space indentation. |
||
|
Zoltan Somogyi
|
10536c5ee0 |
Divide make_hlds.m into submodules of manageable size.
Estimated hours taken: 12 Branches: main Divide make_hlds.m into submodules of manageable size. compiler/make_hlds.m: Distribute all the code that was previously here to new submodules. Include those submodules. Keep the existing interface of this module by defining predicates that do nothing except call the actual implementation in one of those submodules. The only changes visible from outside are the renaming of a predicate and the creation of a second name, make_hlds_qual_info, for qual_info. Both changes are designed to avoid ambiguity in the presence of intermodule optimization. compiler/add_aditi.m: Submodule for dealing with aditi-specific issues. compiler/add_class.m: Submodule for handling typeclasses. compiler/add_clause.m: Submodule for handling the general processing of clauses. compiler/add_pred.m: Submodule for handling new predicates. compiler/add_special_pred.m: Submodule for handling special (unify/compare/index/init) predicates. compiler/add_type.m: Submodule for handling new types. compiler/add_mode.m: Submodule for handling new insts and modes. compiler/add_solver.m: Submodule for handling new solver types. compiler/add_pragma.m: Submodule for handling new pragmas. compiler/state_var.m: Submodule for handling the state variable transformation. compiler/superhomogeneous.m: Submodule for converting clauses to superhomogeneous form. compiler/field_access.m: Submodule for field access syntax. compiler/make_hlds_passes.m: Submodule containing the code that performs passes on the item list, adding things to the HLDS, calling the other submodules as necessary. compiler/make_hlds_warn.m: Submodule that looks for constructs that merit warnings. compiler/make_hlds_error.m: Submodule containing error messages used by more than one submodule. compiler/hlds_pred.m: Since this module defines the clauses_info and proc_id types, move the predicates that initialize values of that type here as well from make_hlds.m (deleting an unnecessary parameter from one). compiler/hlds_pred.m: compiler/prog_data.m: Move the type tvar_name_map from from hlds_pred.m to prog_data.m, since that is where similar maps are. compiler/check_typeclass.m: compiler/mercury_compile.m: Conform to the change to make_hlds_qual_info. compiler/hlds_out.m: compiler/prog_out.m: Replace two identical predicates for printing out lists of strings in hlds_out.m and make_hlds.m with just one in prog_out.m, since that is where it belongs in the compiler. compiler/prog_util.m: Move some utility predicates for substitutions and term recognition here from make_hlds.m, since they are needed by more than one submodule. Make this module conform to our coding guidelines, and convert it to four-space indentation to eliminate bad line breaks. compiler/clause_to_proc.m: compiler/hlds_code_util.m: compiler/make_tags.m: compiler/prog_mode.m: compiler/quantification.m: compiler/type_util.m: Trivial formatting changes. compiler/notes/compiler_design.html: Describe the new modules. |
||
|
Zoltan Somogyi
|
68b1a6c0ea |
Add a new LLDS optimization we discussed on thursday: elimination of procedures
Estimated hours taken: 4 Branches: main Add a new LLDS optimization we discussed on thursday: elimination of procedures whose code is an exact copy of the code of another mode of the same predicate. This happens with in,out vs di,uo and also possibly with in,out vs any,any. The new optimization reduces the compiler's code size by 0.6%. compiler/dupproc.m: A new module implementing the new optimization. compiler/ll_backend.m: Add dupproc.m as a new submodule. compiler/notes/compiler_design.html: Mention the new module. compiler/options.m: Add an option, --optimize-proc-dups, enabling the new optimization. Make --opt-space imply the new option. doc/user_guide.texi: Document the new option. compiler/mercury_compile.m: Invoke the new optimization when compiling by predicates. Move the imports of library modules to their own section. compiler/handle_options.m: Make --optimize-proc-dups imply compiling by predicates. The rest of these changes are cosmetic only. compiler/llds.m: Delete an obsolete form of constant we haven't used in a long time. compiler/exprn_aux.m: compiler/jumpopt.m: compiler/llds_out.m: compiler/opt_debug.m: compiler/opt_util.m: Conform to the change in llds.m. compiler/dependency_graph.m: Clean up some comments. compiler/dupelim.m: Fix some variable names. compiler/hlds_module.m: compiler/hlds_pred.m: Minor cleanups. |
||
|
Mark Brown
|
a5eb58d00b |
Update the design document after the recent changes to add functional
Estimated hours taken: 0.2 Branches: main compiler/notes/compiler_design.html: Update the design document after the recent changes to add functional dependencies and split up typecheck.m. compiler/check_typeclass.m: Fix a typo. |
||
|
Julien Fischer
|
4c39d891fc |
Clean up lp.m and bring it more into sync with the corresponding
Estimated hours taken: 1.5 Branches: main Clean up lp.m and bring it more into sync with the corresponding parts of lp_rational.m. The one algorithmic change is to replace two closures that where called by an all solutions predicate with a single iterative predicate that does the same thing. Shift lp.m from the transform_hlds package into the libs package. compiler/lp.m: Shift to 4-space indentation throughout. Use state variables throughout and rearrange argument orders where necessary. Use predmode syntax throughout. Add field names to several of the major data structures in this module. Standardize variable names. s/__/./ throughout. Other minor formatting changes. compiler/transform_hlds.m: compiler/libs.m: Move the lp module from the transform_hlds package to the libs package. It doesn't really have anything to do with the HLDS. compiler/term_pass1.m: compiler/notes/compiler_design.html: Minor changes to conform to the above. |
||
|
Zoltan Somogyi
|
309910d736 |
Change the mechanism we use to transmit a representation of procedure bodies
Estimated hours taken: 16 Branches: main Change the mechanism we use to transmit a representation of procedure bodies from the compiler to the declarative debugger from Mercury terms to a bytecode. This achieves two objectives. First, the code for Mercury terms worked only as long as the compiler used the same data representation as the program being compiled; it generated incorrect term representations when e.g. the compiler generating code in reserve tag grades. Second, the new representation is significantly smaller. The total size of the .c files in the compiler directory in grade asm_fast.gc.decldebug.tr is now only 213 Mb compared with 313 Mb previously (a reduction of almost one third). The executable file size of a compiler compiled in asm_fast.gc.decldebug.tr is now only 59 Mb, compare with 64 Mb previously (a reduction of almost 8%, and there is room for further reductions). The overhead of the decldebug grade when compared with a plain debug grade now only about 25%, compared to about 36% before. The downside is that the procedure body representation must now be constructed by the declarative debugger from the bytecode instead of being available directly. We minimize this effect by using a cache to ensure that each procedure's body representation is constructed at most once. browser/declarative_execution.m: Do not include the procedure representation in call nodes. This should make the annotated trace somewhat smaller and quicker to construct. Since this code will be executed many more times than the number of procedures whose bodies are needed by subterm dependency tracking, the overall effect of this change on speed should be positive. Instead, add code to construct procedure body representations on demand from bytecode, which is reachable indirectly through the call's node label label structure. browser/declarative_tree.m: Conform to the new structure of call nodes. compiler/prog_rep.m: Replace the code that generated the term representation of procedure bodies with code that generates a bytecode representation of procedure bodies. compiler/static_term.m: Delete this file, since it is no longer needed. compiler/notes/compiler_design.html: Document the deletion of static_term.m. mdbcomp/program_representation.m: Add the definitions related to the structure of the bytecode that are shared by the compiler and the declarative debugger. This includes the representations of determinisms. compiler/code_model.m: To prevent requiring double maintenance, use the facilities now in mdbcomp/program_representation.m to encode determinisms. runtime/mercury_stack_layout.h: compiler/layout.m: compiler/layout_out.m: compiler/opt_debug.m: compiler/stack_layout.m: Replace the proc layout field holding the procedure representation term with the field holding the procedure representation bytecode. runtime/mercury_grade.h: Record the breaking of backward compatibility in debug grades. compiler/options.m: Add an option for use by compiler implementors while implementing changes like this. runtime/mercury_trace_base.[ch]: Add the hash table that caches the results of bytecode translations. trace/mercury_trace_declarative.c: Do not include procedure representations when constructing call nodes, since it is no longer necessary. trace/mercury_trace_internal.c: Update the code that deals with procedure bodies to use the bytecode representation. |
||
|
Julien Fischer
|
601fe20aba |
Simplify the structure of the compiler by removing the cycle
Estimated hours taken: 3.5 Branches: main Simplify the structure of the compiler by removing the cycle parse_tree -> backend_libs -> check_hlds -> parse_tree from the package dependency graph. I've done this by factoring out the code in backend_libs.foreign and backend_libs.name_mangle that is needed by the frontend of the compiler and putting it in a new module, parse_tree.prog_foreign. This removes the dependency between the parse_tree and backend_libs packages. The obvious downside to this is that the name mangler is now split in two, although such a division was always in implicit in the predicates of the name_mangle module anyway, ie. between those bits that operate on the HLDS/MLDS/LLDS level data structures and those that don't. compiler/name_mangle.m: compiler/foreign.m: compiler/prog_foreign.m: Move code for dealing with foreign language procedures that is required by the parse_tree package into a new module, prog_foreign. Update the formatting in some of these modules so that they match our current coding standard. compiler/*.m: Update to reflect the above change. compiler/notes/compiler_design.html: Include the new module. Fix some spelling errors. |
||
|
Richard James Fothergill
|
388bd7025a |
These changes provide the framework for a new approach to constraints
Estimated hours taken: 100 Branches: main These changes provide the framework for a new approach to constraints based mode analysis. They build constraints for simple mercury programs (sorry, no higher order unifications), and can later be extended to handle all applicable hlds goals. They have been designed with the intention that they would be solved, for example, by a propagation based constraint solver, and the information used for producing a partial order on conjuncts and for mode analysis of a mercury program. compiler/notes/compiler_design.html Added a description of various parts of the new constraints based mode analysis work. |
||
|
Zoltan Somogyi
|
86ac840326 |
Implement a mechanism to generate the information required to determine the
Estimated hours taken: weeks Branches: main Implement a mechanism to generate the information required to determine the algorithmic complexity of selected procedures. The basis of the mechanism is a program transformation that wraps up the body of each selected procedure in code that detects top-level (non-recursive) calls, and for each top-level call, records the sizes of the input arguments and information about the cost of the call. For now, the cost information consists only of the number of cells and words allocated during the call, but there is provision for later adding information from a real-time clock. compiler/complexity.m: A new module containing the new transformation. compiler/transform_hlds.m: Add complexity.m to the list of submodules. compiler/mercury_compile.m: Invoke the new module. compiler/notes/compiler_design.html: Mention the new module. compiler/options.m: Add an option, --experimental-complexity. Its argument is a filename that specifies the list of procedures to transform. Add an option, --no-allow-inlining, to disallow all inlining. This is simpler to use than specifying several options to turn off each potential reason to inline procedures. doc/user_guide.texi: Document the new options. The documentation present now is only a shell; it will be expanded later. compiler/table_gen.m: compiler/goal_util.m: Move the predicate for creating renamings from table_gen.m to goal_util.m, since complexity.m also needs it now. In the process, make it more general by allowing outputs to have more complex modes than simply `out'. compiler/goal_util.m: Fix a bug exposed by the new transformation: when renaming goals (e.g. for quantification), rename the variables holding information about term sizes. compiler/handle_options.m: Disable inlining if experimental complexity analysis is enabled. compiler/compile_target_code.m: Pass the --experimental-complexity option on to the linker. library/term_size_prof_builtin.m: Add the Mercury predicates that serve as interfaces to the primitives needed by the experimental complexity transformation. runtime/mercury_term_size.[ch]: Add the implementations of the primitives needed by the experimental complexity transformation. runtime/mercury_wrapper.[ch]: Add global variables holding counters of the numbers of words and cells allocated so far. runtime/mercury_heap.h: Update these global variables when allocating memory. runtime/mercury_complexity.h: New file that contains the definition of the data structures holding the data collected by the experimental complexity transformation. This is separate from mercury_term_size.h, because it needs to be #included in mercury_init.h, the header file of the mkinit-generated <program>_init.c files. runtime/mercury_init.h: runtime/mercury_imp.h: #include mercury_complexity.h. util/mkinit.c: Define and initialize the data structures holding complexity information when given the -X option (mkinit doesn't have long options). Fix some deviations from our coding style. scripts/parse_ml_options.sh-subr.in: Accept the --experiment-complexity option. scripts/c2init.in: Pass the --experiment-complexity option on to mkinit.c. tools/bootcheck: Preserve the files containing the results of complexity analysis, if they exist. tools/makebatch: Allow the specification of EXTRA_MLFLAGS in the generated Mmake.stage.params files. |
||
|
Julien Fischer
|
3e19c2fad6 |
Improve the termination analyser's handling of user-defined
Estimated hours taken: 20 Branches: main Improve the termination analyser's handling of user-defined special predicates. Currently termination analysis assumes that all calls to special predicates terminate. For those that are user-defined this is not necessarily true. This diff adds a new pass to the compiler that is run after the main termination analysis pass. It checks any user-defined special predicates and emits a warning if their termination can not be proved. Add a new option, `--no-warn-non-term-special-preds' that disables this warning. The warning is only emitted when termination analysis is enabled. The new option has no effect if termination analysis is not enabled. compiler/post_term_analysis.m: New file. Add an additional pass that runs after the main termination analysis and makes use of the information obtained then to perform further semantic checks and optimizations. compiler/termination.m: Run the new pass after the main analysis. Update the comment about the termination analyser doing the wrong thing for user-defined special predicates. compiler/options.m: Parse the new option. Update the special handler for the inhibit_warning option so that it handles `--warn-table-with-inline' and the new option correctly. Fix some typos. compiler/transform_hlds.m: Include the new module. compiler/notes/compiler_design.html: Mention the new module. doc/user_guide.texi: Document the new option. Fix some typos: s/occured/occurred/, s/interative/interactive/, s/exlained/explained/ and /currect/current/ library/array.m: library/version_array.m: Add pragma terminates declarations to the user-defined equality and comparison predicates for the array/1 and version_array/1 types. The termination analyser cannot (yet) prove termination in these cases because it cannot reason about iteration over arrays. tests/warnings/Mercury.options: tests/warnings/Mmakefile: tests/warnings/warn_non_term_user_special.m: tests/warnings/warn_non_term_user_special.exp: Test the new option. |
||
|
Julien Fischer
|
a3352a6e5d |
Do not include :- import_module' and :- use_module' declarations
Estimated hours taken: 22 Branches: main Do not include `:- import_module' and `:- use_module' declarations in the implementation section of .int and .int2 files unless the types that they export are required by the definition of an equivalence type. This should help prevent unnecessary recompilations when new imports are made in the implementation of modules. Break up check_hlds.type_util so that predicates that do not require access to the HLDS are placed in a new module, parse_tree.prog_type. The above change requires some of these predicates. This also removes one of the dependencies between the parse_tree package on modules of the check_hlds package. Remove the remaining such dependency by moving inst_constrains_unconstrained_var/1 from check_hlds.inst_util to parse_tree.prog_mode. None of the modules in parse_tree now depend upon modules in check_hlds. Modify the parser so that import_module declarations that specify more than one module are replaced by multiple import_module declarations, with one module per declaration. This makes the above change easier to implement and is in any case required by the upcoming diff for canonicalizing module interfaces. We also do the same for use_module and include_module declarations. compiler/modules.m: Don't import modules in the implementation section of interface files unless they are required by the definition of equivalence types. compiler/prog_type.m: New module. Move procedures from type_util that do not depend on the HLDS to here so that we can use them when generating interface files. XXX There are probably others that could be moved as well - I only moved those that were immediately useful. compiler/type_util.m: Delete the procedures that have been moved to the new prog_type module. compiler/prog_io.m: Remove the dependency on check_hlds.inst_util. compiler/prog_io_typeclass.m: compiler/equiv_type.m: Remove dependencies on check_hlds.type_util. compiler/prog_util.m: Add a predicate sym_name_get_module_name/2 that is similar to sym_name_get_module_name/3 except that it fails if the input is an unqualified sym_name. compiler/inst_util.m: Delete inst_contains_unconstrained_var/1 from this module and copy it to prog_mode.m. compiler/parse_tree.m: Include the new module. Do not import the check_hlds package as all dependencies on this package have been removed. compiler/*.m: Minor changes to conform to the above. compiler/notes/compiler_design.html: Mention the new module. |
||
|
Zoltan Somogyi
|
02b9dceb8f |
Move changes in the compiler on the mode-constraints branch onto the trunk.
Estimated hours taken: unknown, but months (almost all by dmo) Branches: main Move changes in the compiler on the mode-constraints branch onto the trunk. compiler/top_level.m: Add the new package mode_robdd. compiler/check_hlds.m: Add the new modules within the check_hlds.m package: mode_constraints, mode_constraint_robdd and mode_ordering. compiler/hlds.m: Add the new modules within the hlds.m package, hhf and inst_graph. compiler/hhf.m: This new module implements the transformation from our usual superhomogeneous form to the hyperhomogeneous form required by constraint based mode analysis. compiler/inst_graph.m: This new module computes the instantiation graphs required by constraint based mode analysis. compiler/hlds_goal.m: Add an extra slot into goal_infos for use by constraint based mode analysis, and the predicates required to manipulate it. compiler/hlds_pred.m: Add two extra slots into pred_infos and one extra slot into proc_infos for use by constraint based mode analysis, and the predicates required to manipulate them. compiler/mercury_compile.m: Invoke the constraint based mode analysis pass if the options call for it. compiler/mode_constraints.m: This new module implements the top level of the constraint based mode analysis algorithm: it finds the constraints and adds them to the constraint store, and invokes other modules to find solutions and process them. compiler/mode_ordering.m: This new module processes solutions of constraint systems by trying to find execution orders for conjunctions that are consistent with the assignment of producers represented by a such a solution. compiler/mode_constraint_robdd.m: This new module provides a useful interface to operations on robdds used for constraint based mode analysis. The actual implementation uses one or two of the mode_robdd.X.m modules. compiler/mode_robdd.m: New top-level package to hold the modules listed below, which deal with robdd based solvers for the constraint systems generated by mode analysis. compiler/mode_robdd.check.m: This new module invokes two of the modules below and compares their results. If one of the modules is known to be good, this is useful for debugging the other. compiler/mode_robdd.r.m: compiler/mode_robdd.tfeir.m: compiler/mode_robdd.tfeirn.m: compiler/mode_robdd.tfer.m: compiler/mode_robdd.tfern.m: compiler/mode_robdd.tfr.m: These new modules each implement robdd based constraint solvers. They differ in the amount of information they keep in the robdd versus how much information they keep in Mercury data structures. The naming scheme assigns a letter to each kind of information we are concerned about, and includes that letter in the name the Mercury data structure has a separate field for that kind of information. The mapping is: r: robdd (present in all variants) tf: variables known to be true or false e: variable equivalences i: variable implications. n: normalization Normally only one of these would be linked in, or two if mode_robdd.check.m is being used to compare two of these modules. compiler/mode_robdd.equiv_vars.m: This module implements utility operations involving sets of equivalent variables. compiler/mode_robdd.implications.m: This module implements utility operations involving implications among variables. compiler/mode_robdd.prop.m: Experimental module; currently unused. Committed only to preserve its history. compiler/goal_path.m: Add a variant of an existing predicate needed by constraint based mode analysis. compiler/hlds_out.m: Print out the components added to the HLDS by this change if the appropriate signal character is present in the revelant option. compiler/handle_options.m: Add the signal for printing mode constraints to the names of the usual dumping aliases. They have no effect unless constraint based mode analysis is enabled. compiler/options.m: Add the options controlling the experimental mode constraints pass. doc/user_guide.texi: Document the options controlling the experimental mode constraints pass for implementors. compiler/notes/compiler_design.html: Document the new modules, and fix some old errors. |
||
|
Julien Fischer
|
980afa90c5 |
Add an analysis that tries to identify those procedures
Estimated hours taken: 70 Branches: main Add an analysis that tries to identify those procedures in a module that will not throw an exception. (I guess it may be more accurate to call it a non-exception analysis). For those procedures that might throw exceptions the analysis further tries to distinguish between those that throw an exception as a result of a call to throw and those that throw an exception as a result of a call to a unification/comparison predicate that may involve calls to user-defined equality/comparison predicates that throw exceptions. This sort of thing used to be done by the termination analysis, where being able to prove termination was equated with not throwing an exception. This no longer works now that the termination analyser considers exception.throw/1 to be terminating - and in fact it never quite worked anyway because the termination analyser was not handling things like foreign code and user-defined equality and comparison predicates correctly. There are currently a few limitations, the main ones being: * we currently use transitive-intermodule optimization rather than the intermodule-analysis framework. This may causes problems when their are cycles in the module dependency graph. * we currently assume that all calls to higher-order predicates may result in an exception being thrown. * we currently assume that all foreign procs that make calls back to Mercury may throw exceptions. * we currently assume that all solver types and existentially quantified types might result in an exception being thrown. It should be possible to remove these limitations in later versions. This diff also modifies the cannot_loop_or_throw family of predicates in goal_form.m. There are now two versions of each predicate; one that can make use of information from the termination and exception analyses and one that cannot. compiler/exception_analysis.m: The new analysis. compiler/prog_data.m: compiler/prog_io_pragma.m: Handle `:- pragma exceptions(...' in .opt and .trans_opt files. compiler/hlds_module.m: Attach information to each module about whether each procedure in the module may throw an exception. compiler/goal_form.m: Rewrite the predicates in this module so that they can optionally use information from the exception analysis. compiler/constraint.m: compiler/goal_util.m: compiler/rl.m: compiler/simplify.m: Use information from exception and termination analyses when performing various optimizations. compiler/type_util.m: Add a new predicate type_util.type_is_existq/2 that tests whether a type is existentially quantified or not. compiler/mercury_compile.m: compiler/mercury_to_mercury.m: compiler/modules.m: compiler/options.m: compiler/module_qual.m: compiler/make_hlds.m: compiler/recompilation.version.m: compiler/trans_opt.m: compiler/transform_hlds.m: Minor changes needed by the above. NEWS: compiler/notes/compiler_design.html: doc/user_guide.texi: Mention the new analysis. tests/README: Include a description of the term directory. tests/term/Mercury.options: tests/term/Mmakefile: tests/term/exception_analysis_test.m: tests/term/exception_analysis_test.trans_opt_exp: Add a test for the new analysis. |
||
|
Zoltan Somogyi
|
885fd4a387 |
Remove almost all dependencies by the modules of parse_tree.m on the modules
Estimated hours taken: 12 Branches: main Remove almost all dependencies by the modules of parse_tree.m on the modules of hlds.m. The only such dependencies remaining now are on type_util.m. compiler/hlds_data.m: compiler/prog_data.m: Move the cons_id type from hlds_data to prog_data, since several parts of the parse tree data structure depend on it (particularly insts). Remove the need to import HLDS modules in prog_data.m by making the cons_ids that refer to procedure ids refer to them via a new type that contains shrouded pred_ids and proc_ids. Since pred_ids and proc_ids are abstract types in hlds_data, add predicates to hlds_data to shroud and unshroud them. Also move some other types, e.g. mode_id and class_id, from hlds_data to prog_data. compiler/hlds_data.m: compiler/prog_util.m: Move predicates for manipulating cons_ids from hlds_data to prog_util. compiler/inst.m: compiler/prog_data.m: Move the contents of inst.m to prog_data.m, since that is where it belongs, and since doing so eliminates a circular dependency. The separation doesn't serve any purpose any more, since we don't need to import hlds_data.m anymore to get access to the cons_id type. compiler/mode_util.m: compiler/prog_mode.m: compiler/parse_tree.m: Move the predicates in mode_util that don't depend on the HLDS to a new module prog_mode, which is part of parse_tree.m. compiler/notes/compiler_design.m: Mention prog_mode.m, and delete the mention of inst.m. compiler/mercury_to_mercury.m: compiler/hlds_out.m: Move the predicates that depend on HLDS out of mercury_to_mercury.m to hlds_out.m. Export from mercury_to_mercury.m the predicates needed by the moved predicates. compiler/hlds_out.m: compiler/prog_out.m: Move predicates for printing parts of the parse tree out of hlds_out.m to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/purity.m: compiler/prog_out.m: Move predicates for printing purities from purity.m, which is part of check_hlds.m, to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/passes_aux.m: compiler/prog_out.m: Move some utility predicates (e.g. for printing progress messages) from passes_aux.m to prog_out.m, since some predicates in submodules of parse_tree.m need to use them. compiler/foreign.m: compiler/prog_data.m: Move some types from foreign.m to prog_data.m to allow the elimination of some dependencies on foreign.m from submodules of parse_tree.m. compiler/*.m: Conform to the changes above, mostly by updating lists of imported modules and module qualifications. In some cases, also do some local cleanups such as converting predicate declarations to predmode syntax and fixing white space. |
||
|
Zoltan Somogyi
|
5f32f6a836 |
Update the documentation of the module structure after the movement
Estimated hours taken: 0.2 Branches: main compiler/notes/compiler_design.html: Update the documentation of the module structure after the movement of two submodule between toplevel modules. |
||
|
Zoltan Somogyi
|
c91313b32f |
Bring these modules up to date with our current coding style.
Estimated hours taken: 8
Branches: main
compiler/modules.m:
compiler/compile_target_code.m:
compiler/handle_options.m:
compiler/bytecode_data.m:
compiler/prog_io_util.m:
Bring these modules up to date with our current coding style. Use
predmode declarations and state variable syntax where appropriate.
Fix inconsistent indentation. Print more error messages using
error_util.m for printing error messages.
compiler/trace_param.m:
Add a new predicate for use by the updated code in handle_options.m.
compiler/error_util.m:
compiler/hlds_error_util.m:
Make error_util.m to be a submodule of parse_tree.m, not hlds.m.
Most of its predicates are not dependent on HLDS data structures.
Move the ones that are into a new module, hlds_error_util, that
is a submodule of hlds.m. Overall, this reduces the dependence
of submodules of parse_tree.m, including modules.m, on submodules
of hlds.m.
compiler/notes/compiler_design.html:
Update the documentation of compiler modes to account for
hlds_error_util.m.
compiler/hlds.m:
compiler/parse_tree.m:
Update the list of included submodules.
compiler/*.m:
Update module imports and module qualifications as needed for the
change above.
tests/invalid/*.{exp,exp2}:
Update the expected outputs of a bunch of test cases to reflect the new
format of some warning messages due to the user error_util; they now
observe line length limits, and print contexts in some cases where they
were previously missing.
|
||
|
Simon Taylor
|
82c6cdb55e |
Make definitions of abstract types available when generating
Estimated hours taken: 100
Branches: main
Make definitions of abstract types available when generating
code for importing modules. This is necessary for the .NET
back-end, and for `:- pragma export' on the C back-end.
compiler/prog_data.m:
compiler/modules.m:
compiler/make.dependencies.m:
compiler/recompilation.version.m:
Handle implementation sections in interface files.
There is a new pseudo-declaration `abstract_imported'
which is applied to items from the implementation
section of an interface file. `abstract_imported'
items may not be used in the error checking passes
for the curent module.
compiler/equiv_type_hlds.m:
compiler/notes/compiler_design.html:
New file.
Go over the HLDS expanding all types fully after
semantic checking has been run.
compiler/mercury_compile.m:
Add the new pass.
Don't write the `.opt' file if there are any errors.
compiler/instmap.m:
Add a predicate instmap_delta_map_foldl to apply
a procedure to all insts in an instmap.
compiler/equiv_type.m:
Export predicates for use by equiv_type_hlds.m
Reorder arguments so state variables and higher-order
programming can be used.
compiler/prog_data.m:
compiler/prog_io_pragma.m:
compiler/make_hlds.m:
compiler/mercury_to_mercury.m:
Handle `:- pragma foreign_type' as a form of type
declaration rather than a pragma.
compiler/hlds_data.m:
compiler/*.m:
Add a field to the type_info_cell_constructor cons_id
to identify the type_ctor, which is needed by
equiv_type_hlds.m.
compiler/module_qual.m:
Donn't allow items from the implementation section of
interface files to match items in the current module.
compiler/*.m:
tests/*/*.m:
Add missing imports which only became apparent with
the bug fixes above.
Remove unnecessary imports which only became apparent with
the bug fixes above.
tests/hard_coded/Mmakefile:
tests/hard_coded/export_test2.{m,exp}:
Test case.
tests/invalid/Mmakefile:
tests/invalid/missing_interface_import2.{m,err_exp}:
Test case.
|
||
|
Zoltan Somogyi
|
f007b45df8 |
Implement the infrastructure for term size profiling.
Estimated hours taken: 400
Branches: main
Implement the infrastructure for term size profiling. This means adding two
new grade components, tsw and tsc, and implementing them in the LLDS code
generator. In grades including tsw (term size words), each term is augmented
with an extra word giving the number of heap words it contains; in grades
including tsc (term size cells), each term is augmented with an extra word
giving the number of heap cells it contains. The extra word is at the start,
at offset -1, to leave almost all of the machinery for accessing the heap
unchanged.
For now, the only way to access term sizes is with a new mdb command,
"term_size <varspec>". Later, we will use term sizes in conjunction with
deep profiling to do experimental complexity analysis, but that requires
a lot more research. This diff is a necessary first step.
The implementation of term size profiling consists of three main parts:
- a source-to-source transform that computes the size of each heap cell
when it is constructed (and increments it in the rare cases when a free
argument of an existing heap cell is bound),
- a relatively small change to the code generator that reserves the extra
slot in new heap cells, and
- extensions to the facilities for creating cells from C code to record
the extra information we now need.
The diff overhauls polymorphism.m to make the source-to-source transform
possible. This overhaul includes separating type_ctor_infos and type_infos
as strictly as possible from each other, converting type_ctor_infos into
type_infos only as necessary. It also includes separating type_ctor_infos,
type_infos, base_typeclass_infos and typeclass_infos (as well as voids,
for clarity) from plain user-defined type constructors in type categorizations.
This change needs this separation because values of those four types do not
have size slots, but they ought to be treated specially in other situations
as well (e.g. by tabling).
The diff adds a new mdb command, term_size. It also replaces the proc_body
mdb command with new ways of using the existing print and browse commands
("print proc_body" and "browse proc_body") in order to make looking at
procedure bodies more controllable. This was useful in debugging the effect
of term size profiling on some test case outputs. It is not strictly tied
to term size profiling, but turns out to be difficult to disentangle.
compiler/size_prof.m:
A new module implementing the source-to-source transform.
compiler/notes/compiler_design.html:
Mention the new module.
compiler/transform_hlds.m:
Include size_prof as a submodule of transform_hlds.
compiler/mercury_compile.m:
If term size profiling is enabled, invoke its source-to-source
transform.
compiler/hlds_goal.m:
Extend construction unifications with an optional slot for recording
the size of the term if the size is a constant, or the identity of the
variable holding the size, if the size is not constant. This is
needed by the source-to-source transform.
compiler/quantification.m:
Treat the variable reference that may be in this slot as a nonlocal
variable of construction unifications, since the code generator needs
this.
compiler/compile_target_code.m:
Handle the new grade components.
compiler/options.m:
Implement the options that control term size profiling.
doc/user_guide.texi:
Document the options and grade components that control term size
profiling, and the term_size mdb command. The documentation is
commented out for now.
Modify the wording of the 'u' HLDS dump flag to include other details
of unifications (e.g. term size info) rather than just unification
categories.
Document the new alternatives of the print and browse commands. Since
they are for developers only, the documentation is commented out.
compiler/handle_options.m:
Handle the implications of term size profiling grades.
Add a -D flag value to print HLDS components relevant to HLDS
transformations.
compiler/modules.m:
Import the new builtin library module that implements the operations
needed by term size profiling automatically in term size profiling
grades.
Switch the predicate involved to use state var syntax.
compiler/prog_util.m:
Add predicates and functions that return the sym_names of the modules
needed by term size profiling.
compiler/code_info.m:
compiler/unify_gen.m:
compiler/var_locn.m:
Reserve an extra slot in heap cells and fill them in in unifications
marked by size_prof.
compiler/builtin_ops.m:
Add term_size_prof_builtin.term_size_plus as a builtin, with the same
implementation as int.+.
compiler/make_hlds.m:
Disable warnings about clauses for builtins while the change to
builtin_ops is bootstrapped.
compiler/polymorphism.m:
Export predicates that generate goals to create type_infos and
type_ctor_infos to add_to_construct.m. Rewrite their documentation
to make it more detailed.
Make orders of arguments amenable to the use of state variable syntax.
Consolidate knowledge of which type categories have builtin unify and
compare predicates in one place.
Add code to leave the types of type_ctor_infos alone: instead of
changing their types to type_info when used as arguments of other
type_infos, create a new variable of type type_info instead, and
use an unsafe_cast. This would make the HLDS closer to being type
correct, but this new code is currently commented out, for two
reasons. First, common.m is currently not smart enough to figure out
that if X and Y are equal, then similar unsafe_casts of X and Y
are also equal, and this causes the compiler do not detect some
duplicate calls it used to detect. Second, the code generators
are also not smart enough to know that if Z is an unsafe_cast of X,
then X and Z do not need separate stack slots, but can use the same
slot.
compiler/type_util.m:
Add utility predicates for returning the types of type_infos and
type_ctor_infos, for use by new code in polymorphism.m.
Move some utility predicates here from other modules, since they
are now used by more than one module.
Rename the type `builtin_type' as `type_category', to better reflect
what it does. Extend it to put the type_info, type_ctor_info,
typeclass_info, base_typeclass_info and void types into categories
of their own: treating these types as if they were a user-defined
type (which is how they used to be classified) is not always correct.
Rename the functor polymorphic_type to variable_type, since types
such as list(T) are polymorphic, but they fall into the user-defined
category. Rename user_type as user_ctor_type, since list(int) is not
wholly user-defined but falls into this category. Rename pred_type
as higher_order_type, since it also encompasses functions.
Replace code that used to check for a few of the alternatives
of this type with code that does a full switch on the type,
to ensure that they are updated if the type definition ever
changes again.
compiler/pseudo_type_info.m:
Delete a predicate whose updated implementation is now in type_util.m.
compiler/mlds_to_c.m:
compiler/mlds_to_gcc.m:
compiler/mlds_to_il.m:
compiler/mlds_to_java.m:
Still treat type_infos, type_ctor_infos, typeclass_infos and
base_typeclass_infos as user-defined types, but prepare for when
they won't be.
compiler/hlds_pred.m:
Require interface typeinfo liveness when term size profiling is
enabled.
Add term_size_profiling_builtin.increase_size as a
no_type_info_builtin.
compiler/hlds_out.m:
Print the size annotations on unifications if HLDS dump flags call
for unification details. (The flag test is in the caller of the
modified predicate.)
compiler/llds.m:
Extend incr_hp instructions and data_addr_consts with optional fields
that allow the code generator to refer to N words past the start of
a static or dynamic cell. Term size profiling uses this with N=1.
compiler/llds_out.m:
When allocating memory on the heap, use the macro variants that
specify an optional offset, and specify the offset when required.
compiler/bytecode_gen.m:
compiler/dense_switch.m:
compiler/dupelim.m:
compiler/exprn_aux.m:
compiler/goal_form.m:
compiler/goal_util.m:
compiler/higher_order.m:
compiler/inst_match.m:
compiler/intermod.m:
compiler/jumpopt.m:
compiler/lambda.m:
compiler/livemap.m:
compiler/ll_pseudo_type_info.m:
compiler/lookup_switch.m:
compiler/magic_util.m:
compiler/middle_rec.m:
compiler/ml_code_util.m:
compiler/ml_switch_gen.m:
compiler/ml_unify_gen.m:
compiler/mlds.m:
compiler/mlds_to_c.m:
compiler/mlds_to_gcc.m:
compiler/mlds_to_il.m:
compiler/mlds_to_java.m:
compiler/modecheck_unify.m:
compiler/opt_debug.m:
compiler/opt_util.m:
compiler/par_conj_gen.m:
compiler/post_typecheck.m:
compiler/reassign.m:
compiler/rl.m:
compiler/rl_key.m:
compiler/special_pred.m:
compiler/stack_layout.m:
compiler/static_term.m:
compiler/string_switch.m:
compiler/switch_gen.m:
compiler/switch_util.m:
compiler/table_gen.m:
compiler/term_util.m:
compiler/type_ctor_info.m:
compiler/unused_args.m:
compiler/use_local_vars.m:
Minor updates to conform to the changes above.
library/term_size_prof_builtin.m:
New module containing helper predicates for term size profiling.
size_prof.m generates call to these predicates.
library/library.m:
Include the new module in the library.
doc/Mmakefile:
Do not include the term_size_prof_builtin module in the library
documentation.
library/array.m:
library/benchmarking.m:
library/construct.m:
library/deconstruct.m:
library/io.m:
library/sparse_bitset.m:
library/store.m:
library/string.m:
Replace all uses of MR_incr_hp with MR_offset_incr_hp, to ensure
that we haven't overlooked any places where offsets may need to be
specified.
Fix formatting of foreign_procs.
Use new macros defined by the runtime system when constructing
terms (which all happen to be lists) in C code. These new macros
specify the types of the cell arguments, allowing the implementation
to figure out the size of the new cell based on the sizes of its
fields.
library/private_builtin.m:
Define some constant type_info structures for use by these macros.
They cannot be defined in the runtime, since they refer to types
defined in the library (list.list and std_util.univ).
util/mkinit.c:
Make the addresses of these type_info structures available to the
runtime.
runtime/mercury_init.h:
Declare these type_info structures, for use in mkinit-generated
*_init.c files.
runtime/mercury_wrapper.[ch]:
Declare and define the variables that hold these addresses, for use
in the new macros for constructing typed lists.
Since term size profiling can refer to a memory cell by a pointer
that is offset by one word, register the extra offsets with the Boehm
collector if is being used.
Document the incompatibility of MR_HIGHTAGS and the Boehm collector.
runtime/mercury_tags.h:
Define new macros for constructing typed lists.
Provide macros for preserving the old interface presented by this file
to the extent possible. Uses of the old MR_list_cons macro will
continue to work in grades without term size profiling. In term
size profiling grades, their use will get a C compiler error.
Fix a bug caused by a missing backslash.
runtime/mercury_heap.h:
Change the basic macros for allocating new heap cells to take
an optional offset argument. If this is nonzero, the macros
increment the returned address by the given number of words.
Term size profiling specifies offset=1, reserving the extra
word at the start (which is ignored by all components of the
system except term size profiling) for holding the size of the term.
Provide macros for preserving the old interface presented by this file
to the extent possible. Since the old MR_create[123] and MR_list_cons
macros did not specify type information, they had to be changed
to take additional arguments. This affects only hand-written C code.
Call new diagnostic macros that can help debug heap allocations.
Document why the macros in this files must expand to expressions
instead of statements, evn though the latter would be preferable
(e.g. by allowing them to declare and use local variables without
depending on gcc extensions).
runtime/mercury_debug.[ch]:
Add diagnostic macros to debug heap allocations, and the functions
behind them if MR_DEBUG_HEAP_ALLOC is defined.
Update the debugging routines for hand-allocated cells to print the
values of the term size slot as well as the other slots in the relevant
grades.
runtime/mercury_string.h:
Provide some needed variants of the macro for copying strings.
runtime/mercury_deconstruct_macros.h:
runtime/mercury_type_info.c:
Supply type information when constructing terms.
runtime/mercury_deep_copy_body.h:
Preserve the term size slot when copying terms.
runtime/mercury_deep_copy_body.h:
runtime/mercury_ho_call.c:
runtime/mercury_ml_expand_body.h:
Use MR_offset_incr_hp instead of MR_incr_hp to ensure that all places
that allocate cells also allocate space for the term size slot if
necessary.
Reduce code duplication by using a now standard macro for copying
strings.
runtime/mercury_grade.h:
Handle the two new grade components.
runtime/mercury_conf_param.h:
Document the C macros used to control the two new grade components,
as well as MR_DEBUG_HEAP_ALLOC.
Detect incompatibilities between high level code and profiling.
runtime/mercury_term_size.[ch]:
A new module to house a function to find and return term sizes
stored in heap cells.
runtime/mercury_proc_id.h:
runtime/mercury_univ.h:
New header files. mercury_proc_id.h contains the (unchanged)
definition of MR_Proc_Id, while mercury_univ.h contains the
definitions of the macros for manipulating univs that used to be
in mercury_type_info.h, updated to use the new macros for allocating
memory.
In the absence of these header files, the following circularity
would ensue:
mercury_deep_profiling.h includes mercury_stack_layout.h
- needs definition of MR_Proc_Id
mercury_stack_layout.h needs mercury_type_info.h
- needs definition of MR_PseudoTypeInfo
mercury_type_info.h needs mercury_heap.h
- needs heap allocation macros for MR_new_univ_on_hp
mercury_heap.h includes mercury_deep_profiling.h
- needs MR_current_call_site_dynamic for recording allocations
Breaking the circular dependency in two places, not just one, is to
minimize similar problems in the future.
runtime/mercury_stack_layout.h:
Delete the definition of MR_Proc_Id, which is now in mercury_proc_id.h.
runtime/mercury_type_info.h:
Delete the macros for manipulating univs, which are now in
mercury_univ.h.
runtime/Mmakefile:
Mention the new files.
runtime/mercury_imp.h:
runtime/mercury.h:
runtime/mercury_construct.c:
runtime/mercury_deep_profiling.h:
Include the new files at appropriate points.
runtime/mercury.c:
Change the names of the functions that create heap cells for
hand-written code, since the interface to hand-written code has
changed to include type information.
runtime/mercury_tabling.h:
Delete some unused macros.
runtime/mercury_trace_base.c:
runtime/mercury_type_info.c:
Use the new macros supplying type information when constructing lists.
scripts/canonical_grade_options.sh-subr:
Fix an undefined sh variable bug that could cause error messages
to come out without identifying the program they were from.
scripts/init_grade_options.sh-subr:
scripts/parse_grade_options.sh-subr:
scripts/canonical_grade_options.sh-subr:
scripts/mgnuc.in:
Handle the new grade components and the options controlling them.
trace/mercury_trace_internal.c:
Implement the mdb command "term_size <varspec>", which is like
"print <varspec>", but prints the size of a term instead of its value.
In non-term-size-profiling grades, it prints an error message.
Replace the "proc_body" command with optional arguments to the "print"
and "browse" commands.
doc/user_guide.tex:
Add documentation of the term_size mdb command. Since the command is
for implementors only, and works only in grades that are not yet ready
for public consumption, the documentation is commented out.
Add documentation of the new arguments of the print and browse mdb
commands. Since they are for implementors only, the documentation
is commented out.
trace/mercury_trace_vars.[ch]:
Add the functions needed to implement the term_size command, and
factor out the code common to the "size" and "print"/"browse" commands.
Decide whether to print the name of a variable before invoking the
supplied print or browse predicate on it based on a flag design for
this purpose, instead of overloading the meaning of the output FILE *
variable. This arrangement is much clearer.
trace/mercury_trace_browse.c:
trace/mercury_trace_external.c:
trace/mercury_trace_help.c:
Supply type information when constructing terms.
browser/program_representation.m:
Since the new library module term_size_prof_builtin never generates
any events, mark it as such, so that the declarative debugger doesn't
expect it to generate any.
Do the same for the deep profiling builtin module.
tests/debugger/term_size_words.{m,inp,exp}:
tests/debugger/term_size_cells.{m,inp,exp}:
Two new test cases, each testing one of the new grades.
tests/debugger/Mmakefile:
Enable the two new test cases in their grades.
Disable the tests sensitive to stack frame sizes in term size profiling
grades.
tests/debugger/completion.exp:
Add the new "term_size" mdb command to the list of command completions,
and delete "proc_body".
tests/debugger/declarative/dependency.{inp,exp}:
Use "print proc_body" instead of "proc_body".
tests/hard_coded/nondet_c.m:
tests/hard_coded/pragma_inline.m:
Use MR_offset_incr_hp instead of MR_incr_hp to ensure that all places
that allocate cells also allocate space for the term size slot if
necessary.
tests/valid/Mmakefile:
Disable the IL tests in term size profiling grades, since the term size
profiling primitives haven't been (and probably won't be) implemented
for the MLDS backends, and handle_options causes a compiler abort
for grades that combine term size profiling and any one of IL, Java
and high level C.
|
||
|
Zoltan Somogyi
|
32c03c9b41 |
Fix repeated words.
Estimated hours taken: 0.1 Branches: main compiler/notes/compiler_design.html: Fix repeated words. |
||
|
Fergus Henderson
|
cf55e41289 |
Update to reflect the fact that we are now using sub-modules.
Estimated hours taken: 3.5 Branches: main compiler/notes/compiler_design.html: Update to reflect the fact that we are now using sub-modules. this required a bit of reorganization in some places. Also, document some modules that were previously not mentioned. |
||
|
Zoltan Somogyi
|
20d0a371e4 |
Document a module.
Estimated hours taken: 0.2 Branches: main compiler/notes/compiler_design.html: Document a module. |
||
|
Zoltan Somogyi
|
cbd6a7c56a |
Delete the old, lazy LLDS code generator, since we won't be maintaining it
Estimated hours taken: 3 Branches: main Delete the old, lazy LLDS code generator, since we won't be maintaining it anymore. Its deletion speeds up the compiler by 0.2% when using the LLDS back end. compiler/code_exprn.m: Delete the module. compiler/ll_backend.m: Delete code_exprn from the list of submodules of this module. compiler/notes/compiler_design.html: Delete the documentation of code_exprn.m, and update the documentation of var_locn.m. compiler/options.m: Delete the --lazy-code option that used to select code_exprn over var_locn. Delete the follow_vars option, since the LLDS backend now always executes the follow_vars pass. compiler/handle_options.m: Delete the code setting the follow_vars option. Make the setting of static_ground_terms conditional on the use of the LLDS backend (which now implies the eager code generator). compiler/code_info.m: Delete lots of code that switches between code_exprn.m and var_locn.m. Simplify the data structures accordingly. compiler/store_alloc.m: Delete the code and data structures required to cater for the case where the follow_vars pass isn't run. compiler/pragma_c_gen.m: compiler/var_locn.m: compiler/hlds_goal.m: compiler/lookup_switch.m: Update a comment. doc/user_guide.texi: Delete the documentation of --follow-vars. --lazy-code was already undocumented. tests/valid/Mercury.options: Delete a setting of --no-follow-vars. |
||
|
Simon Taylor
|
82a950c0d9 |
Make Aditi work with `--highlevel-code'.
Estimated hours taken: 80 Branches: main Make Aditi work with `--highlevel-code'. (Note that this doesn't work with the current CVS version of Aditi. The Aditi developers have rewritten the Aditi client API, and haven't maintained the old version of the API, so Mercury queries don't work at the moment. extras/aditi will be updated to use the new interface as a separate change.) extras/aditi/aditi_private_builtin.m: extras/aditi/aditi.m: Move code to implement Aditi calls and updates into a aditi_private_builtin.m. These operations are now implemented using ordinary Mercury foreign procedures, rather than hand-coded C modules. compiler/magic.m: Use calls to ordinary calls to predicates defined in extras/aditi/aditi_private_builtin.m to implement the procedures which interface between top-down Mercury code and Aditi procedures. compiler/aditi_backend.pp: compiler/aditi_builtin_ops.m: compiler/mercury_compile.m: compiler/notes/compiler_design.html: Add a pass to convert Aditi builtins (calls and updates) into ordinary calls to predicates defined in extras/aditi/aditi_private_builtin.m. compiler/hlds_goal.m: compiler/hlds_pred.m: Add a new generic_call type -- `unsafe_cast'. aditi_builtin_ops.m needs to be able to cast closures from one type and inst to another. Delete the `aditi_call' alternative for `aditi_builtin', which is not needed after the change to magic.m described above. Add predicates `construct_tuple' and `deconstruct_tuple'. compiler/*hlds.*.m: compiler/call_gen.m: compiler/ml_call_gen.m: Handle unsafe cast goals. compiler/common.m: compiler/higher_order.m: compiler/unify_proc.m: Generate unsafe_cast goals instead of calls to private_builtin.unsafe_type_cast. compiler/purity.m: compiler/notes/compiler_design.html: Convert calls to private_builtin.unsafe_type_cast into unsafe_cast goals. compiler/ml_code_gen.m: Don't attempt to generate code for Aditi procedures. Remove special case handling of calls to private_builtin.unsafe_type_cast -- such calls are now transformed away. compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/maybe_mlds_to_gcc.m: Add the RL code to the generated C file. compiler/llds_out.m: compiler/c_util.m: compiler/compile_target_code.m: Move code to generate a `.rlo' file and work out the name of the RL constant embeeded in the C file for a module into c_util.m, for use by the MLDS backend. compiler/modules.m: Automatically import aditi_private_builtin when compiling with `--aditi'. We generate a C constant for the RL code for each module, so modules compiled with `--aditi' need to be treated by the build system as if they contain foreign code. compiler/polymorphism.m: Tuple insertion and deletion no longer need special treatment. compiler/llds.m: compiler/ll_backend.*.m: Delete the Aditi alternatives of the `code_addr' type. compiler/mode_util.m: Add function versions of in_mode, out_mode, etc. compiler/prog_util.m: Add aditi_public_builtin_module (returns `aditi') and aditi_private_builtin_module (returns `aditi_private_builtin'). tests/valid/aditi_private_builtin.m: tests/invalid/aditi_private_builtin.m: tests/valid/Mercury.options: tests/invalid/Mercury.options: Add a cut down version of extras/aditi/aditi_private_builtin.m for use in running the tests. |
||
|
Fergus Henderson
|
5823c8a2e3 |
Perform loop invariant hoisting after inlining, since inlining
Estimated hours taken: 2 Branches: main compiler/mercury_compile.m: compiler/notes/compiler_design.html: Perform loop invariant hoisting after inlining, since inlining can create opportunities for loop invariant hoisting. library/string.m: Implement string__index in Mercury, in terms of string__length, string__unsafe_index, and a new procedure string__index_check, rather than implementing in C. string__index_check contains just the index checking code from the old string__index implementation. Implementing string__index in Mercury like this should allow the Mercury compiler to do loop invariant hoisting on the calls to string__length. Declare the output argument for string__unsafe_index and string__index_det with mode `uo', to match string__index. For unsafe__index, this change was needed now that string__index is implemented in terms of string__unsafe_index. |
||
|
Fergus Henderson
|
b39fcee35d |
Trivial comment changes.
Estimated hours taken: 0.25 Branches: main Trivial comment changes. compiler/inst_match.m: Update some obsolete comments to match the current interface. Add a comment about contravariance/covariance in pred_inst_argmodes_matches. compiler/java_util.m: compiler/notes/compiler_design.html: Fix typos. |
||
|
Fergus Henderson
|
5b8eef87b5 |
Fix a bug where the compiler was going into an infinite loop for
Estimated hours taken: 16 Branches: main, release Fix a bug where the compiler was going into an infinite loop for insts and modes that are infinitely recursive at the top level, e.g. `:- inst foo == foo.' or `:- mode foo == foo'. compiler/make_hlds.m: Check for circular insts and modes, and report an error if any occur. Also, pass back a boolean from pass 1 indicating whether or not any cyclic insts and modes. Rename the "UndefModes" argument for parse_tree_to_hlds as "InvalidModes", and set it to yes if there were any circular insts or modes, to ensure that mercury_compile.m will not run mode analysis. This is needed to avoid infinite loops in mode analysis when processing circular compiler/notes/compiler_design.html: Mention that make_hlds.m checks for circular insts and modes. Also mention that it expands state variable syntax. compiler/mercury_compile.m: Add a comment about circular insts and modes to the list of reasons why we might need to stop before running mode analysis. tests/invalid/circ_inst2.m: Fix a misleading comment. tests/invalid/Mmakefile: tests/invalid/circ_inst.err_exp: tests/invalid/circ_inst2.err_exp: tests/invalid/circ_inst3.err_exp: tests/invalid/circ_inst4.err_exp: tests/invalid/circ_mode.err_exp: tests/invalid/circ_mode2.err_exp: tests/invalid/circ_mode3.err_exp: tests/invalid/circ_mode4.err_exp: Enable these test cases, and add expected output files for them. tests/invalid/Mmakefile: tests/invalid/circ_type3.m: tests/invalid/circ_type3.err_exp: Add another test for circular equivalence types. |
||
|
Ralph Becket
|
b75b17bba3 |
Added loop-invariant hoisting optimization.
Estimated hours taken: 900 Branches: main Added loop-invariant hoisting optimization. liveness.m: Improved the debugging output to show HLDS before and after liveness analysis. loop_inv.m: New module containing the implementation of the loop invariant hoisting optimization. mercury_compile.m: Added loop_inv at step 34, moving inlining to step 35. options.m: Added bool option --loop-invariants (default `no'). This optimization is set at -O4. passes_aux.m: Minor changes to support introduction of the loop invariant hoisting optmimization. follow_code.m: Updated to reflect the new interface to passes_aux.m. transform_hlds.m: Added include_module declaration for loop_inv. |
||
|
Simon Taylor
|
fc8725fc3c |
Allow arbitrary mappings from source file name to module name.
Estimated hours taken: 8 Branches: main Allow arbitrary mappings from source file name to module name. The mapping is created using the command `mmc -f *.m', which must be run before `mmake depend'. compiler/parse_tree.m: compiler/source_file_map.m: compiler/notes/compiler_design.html: Add a new module to read, write and search the mapping. compiler/modules.m: Use the source file map when searching for source files. Export `make_directory' for use by source_file_map.m. Use the module name rather than the source file name to generate the executable name. This matches the documentation in the User's Guide, and it's needed to make the tests work. compiler/prog_io.m: Separate out the code to read the first item in a module to find the module name into a new predicate, `find_module_name'. compiler/handle_options.m: Don't complain about the module name not matching the file name when generating the Mercury.modules file -- the file only needs to be generated when the module name doesn't match the file name. compiler/llds_out.m: Remove a duplicate copy of `make_directory'. compiler/options.m: compiler/mercury_compile.m: doc/user_guide.texi: Add the `--generate-source-file-mapping' (-f) option to generate the mapping. NEWS: Document the change. tests/hard_coded/Mmakefile: tests/hard_coded/source_file_map.m: tests/hard_coded/mapped_module.exp: Test case. |
||
|
Simon Taylor
|
811c0af920 |
Make inter-module optimization work properly with sub-modules.
Estimated hours taken: 15 Branches: main Make inter-module optimization work properly with sub-modules. compiler/intermod.m: Write `exported_to_submodules' predicates to the `.opt' file. Read `.int0' files needed by the `.opt' files. compiler/make.dependencies.m: compiler/modules.m: Handle dependencies on the extra `.int0' files when compiling with `--intermodule-optimization'. compiler/modules.m: compiler/prog_io.m: compiler/*.m: Handle partially qualified file names when searching for the `.m' file for a module when checking whether there should be a dependency on the `.opt' file for the module. Separate out the code to find for the source file for a module from the code to read the source file for a module. Remove an unnecessary argument from prog_io__read_opt_file (`.opt' files are always searched for). compiler/modules.m: Export process_module_private_interfaces, for use by intermod.m. Remove process_module_indirect_imports, which isn't used anywhere. Change get_ancestors from a predicate to a function. compiler/make_hlds.m: Don't report duplicate declaration errors for items imported for inter-module optimization. Sometimes both the `.int' and `.int0' file for a module are read, and the `.int0' file contains everything in the `.int' file.. compiler/modes.m: compiler/post_typecheck.m: Don't report errors for duplicate mode declarations for imported predicates when performing inter-module optimization. If the `.int' and `.int0' files for a module are both read, the mode declarations for a predicate can be read twice. Where there are duplicate mode declarations, remove the duplicate procedures. Move the code to check for indistinguishable modes into post_typecheck.m. It only needs to be done once, not on every iteration of mode inference. compiler/hlds_pred.m: Add a predicate pred_info_remove_procid, for use by post_typecheck.m. compiler/mercury_to_mercury.m: Improve the comment generated for module_defn items which shouldn't appear in Mercury source. compiler/notes/compiler_design.html: Improve the documentation of post_typecheck.m. tests/invalid/qualified_cons_id2.err_exp: Update expected output. |
||
|
Zoltan Somogyi
|
189b9215ae |
This diff implements stack slot optimization for the LLDS back end based on
Estimated hours taken: 400
Branches: main
This diff implements stack slot optimization for the LLDS back end based on
the idea that after a unification such as A = f(B, C, D), saving the
variable A on the stack indirectly also saves the values of B, C and D.
Figuring out what subset of {B,C,D} to access via A and what subset to access
via their own stack slots is a tricky optimization problem. The algorithm we
use to solve it is described in the paper "Using the heap to eliminate stack
accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot.
That paper also describes (and has examples of) the source-to-source
transformation that implements the optimization.
The optimization needs to know what variables are flushed at call sites
and at program points that establish resume points (e.g. entries to
disjunctions and if-then-elses). We already had code to compute this
information in live_vars.m, but this code was being invoked too late.
This diff modifies live_vars.m to allow it to be invoked both by the stack
slot optimization transformation and by the code generator, and allows its
function to be tailored to the requirements of each invocation.
The information computed by live_vars.m is specific to the LLDS back end,
since the MLDS back ends do not (yet) have the same control over stack
frame layout. We therefore store this information in a new back end specific
field in goal_infos. For uniformity, we make all the other existing back end
specific fields in goal_infos, as well as the similarly back end specific
store map field of goal_exprs, subfields of this new field. This happens
to significantly reduce the sizes of goal_infos.
To allow a more meaningful comparison of the gains produced by the new
optimization, do not save any variables across erroneous calls even if
the new optimization is not enabled.
compiler/stack_opt.m:
New module containing the code that performs the transformation
to optimize stack slot usage.
compiler/matching.m:
New module containing an algorithm for maximal matching in bipartite
graphs, specialized for the graphs needed by stack_opt.m.
compiler/mercury_compile.m:
Invoke the new optimization if the options ask for it.
compiler/stack_alloc.m:
New module containing code that is shared between the old,
non-optimizing stack slot allocation system and the new, optimizing
stack slot allocation system, and the code for actually allocating
stack slots in the absence of optimization.
Live_vars.m used to have two tasks: find out what variables need to be
saved on the stack, and allocating those variables to stack slots.
Live_vars.m now does only the first task; stack_alloc.m now does
the second, using code that used to be in live_vars.m.
compiler/trace_params:
Add a new function to test the trace level, which returns yes if we
want to preserve the values of the input headvars.
compiler/notes/compiler_design.html:
Document the new modules (as well as trace_params.m, which wasn't
documented earlier).
compiler/live_vars.m:
Delete the code that is now in stack_alloc.m and graph_colour.m.
Separate out the kinds of stack uses due to nondeterminism: the stack
slots used by nondet calls, and the stack slots used by resumption
points, in order to allow the reuse of stack slots used by resumption
points after execution has left their scope. This should allow the
same stack slots to be used by different variables in the resumption
point at the start of an else branch and nondet calls in the then
branch, since the resumption point of the else branch is not in effect
when the then branch is executed.
If the new option --opt-no-return-calls is set, then say that we do not
need to save any values across erroneous calls.
Use type classes to allow the information generated by this module
to be recorded in the way required by its invoker.
Package up the data structures being passed around readonly into a
single tuple.
compiler/store_alloc.m:
Allow this module to be invoked by stack_opt.m without invoking the
follow_vars transformation, since applying follow_vars before the form
of the HLDS code is otherwise final can be a pessimization.
Make the module_info a part of the record containing the readonly data
passed around during the traversal.
compiler/common.m:
Do not delete or move around unifications created by stack_opt.m.
compiler/call_gen.m:
compiler/code_info.m:
compiler/continuation_info.m:
compiler/var_locn.m:
Allow the code generator to delete its last record of the location
of a value when generating code to make an erroneous call, if the new
--opt-no-return-calls option is set.
compiler/code_gen.m:
Use a more useful algorithm to create the messages/comments that
we put into incr_sp instructions, e.g. by distinguishing between
predicates and functions. This is to allow the new scripts in the
tool directory to gather statistics about the effect of the
optimization on stack frame sizes.
library/exception.m:
Make a hand-written incr_sp follow the new pattern.
compiler/arg_info.m:
Add predicates to figure out the set of input, output and unused
arguments of a procedure in several different circumstances.
Previously, variants of these predicates were repeated in several
places.
compiler/goal_util.m:
Export some previously private utility predicates.
compiler/handle_options.m:
Turn off stack slot optimizations when debugging, unless
--trace-optimized is set.
Add a new dump format useful for debugging --optimize-saved-vars.
compiler/hlds_llds.m:
New module for handling all the stuff specific to the LLDS back end
in HLDS goal_infos.
compiler/hlds_goal.m:
Move all the relevant stuff into the new back end specific field
in goal_infos.
compiler/notes/allocation.html:
Update the documentation of store maps to reflect their movement
into a subfield of goal_infos.
compiler/*.m:
Minor changes to accomodate the placement of all back end specific
information about goals from goal_exprs and individual fields of
goal_infos into a new field in goal_infos that gathers together
all back end specific information.
compiler/use_local_vars.m:
Look for sequences in which several instructions use a fake register
or stack slot as a base register pointing to a cell, and make those
instructions use a local variable instead.
Without this, a key assumption of the stack slot optimization,
that accessing a field in a cell costs only one load or store
instruction, would be much less likely to be true. (With this
optimization, the assumption will be false only if the C compiler's
code generator runs out of registers in a basic block, which for
the code we generate should be unlikely even on x86s.)
compiler/options.m:
Make the old option --optimize-saved-vars ask for both the old stack
slot optimization (implemented by saved_vars.m) that only eliminates
the storing of constants in stack slots, and the new optimization.
Add two new options --optimize-saved-vars-{const,cell} to turn on
the two optimizations separately.
Add a bunch of options to specify the parameters of the new
optimizations, both in stack_opt.m and use_local_vars.m. These are
for implementors only; they are deliberately not documented.
Add a new option, --opt-no-return-cells, that governs whether we avoid
saving variables on the stack at calls that cannot return, either by
succeeding or by failing. This is for implementors only, and thus
deliberately documented only in comments. It is enabled by default.
compiler/optimize.m:
Transmit the value of a new option to use_local_vars.m.
doc/user_guide.texi:
Update the documentation of --optimize-saved-vars.
library/tree234.m:
Undo a previous change of mine that effectively applied this
optimization by hand. That change complicated the code, and now
the compiler can do the optimization automatically.
tools/extract_incr_sp:
A new script for extracting stack frame sizes and messages from
stack increment operations in the C code for LLDS grades.
tools/frame_sizes:
A new script that uses extract_incr_sp to extract information about
stack frame sizes from the C files saved from a stage 2 directory
by makebatch and summarizes the resulting information.
tools/avg_frame_size:
A new script that computes average stack frame sizes from the files
created by frame_sizes.
tools/compare_frame_sizes:
A new script that compares the stack frame size information
extracted from two different stage 2 directories by frame_sizes,
reporting on both average stack frame sizes and on specific procedures
that have different stack frame sizes in the two versions.
|
||
|
Simon Taylor
|
a719e74ee9 |
Rearrange some code after the `--make' change.
Estimated hours taken: 1.5 Branches: main Rearrange some code after the `--make' change. This was not done as part of that change for ease of reviewing. compiler/mercury_compile.m: compiler/compile_target_code.m: compiler/make.m: compiler/make.module_target.m: compiler/make.program_target.m: Move code to compile the generated code into compile_target_code.m. compiler/make.util.m: compiler/passes_aux.m: compiler/process_util.m: Move process and signal handling functionality into process_util.m. compiler/Mmakefile: Compile process_util.c with `--no-ansi' so that the declarations of `struct sigaction' and `kill' are available on Linux. compiler/notes/compiler_design.html: Document compile_target_code.m and process_util.m. Move timestamp.m into the "Miscellaneous" section (it's used by make as well as smart recompilation). Fix the documentation of options_file.m. |
||
|
Simon Taylor
|
d96f7a9bd5 |
Allow declarations of the form
Estimated hours taken: 40 Branches: main Allow declarations of the form :- pred p `with_type` higher_order_type `with_inst` higher_order_inst. XXX We should allow `with_inst` annotations on higher-order terms. compiler/prog_data.m: Add fields to `pred_or_func' and `pred_or_func_mode' items to hold the `with_type` and `with_inst` annotations. compiler/prog_io.m: compiler/prog_io_typeclass.m: Parse the annotations. compiler/module_qual.m: Module qualify the annotations. compiler/equiv_type.m: Expand away `with_type` and `with_inst`. Report errors. Strip items containing errors from the item list. Record smart recompilation dependencies on the types and modes expanded. Also record a dependency on the arity of predicate and function declarations before expansion. Use error_util for error messages. compiler/mercury_to_mercury.m: Write `with_type` and `with_inst` annotations to interface files. compiler/make_hlds.m: Ignore `with_type` and `with_inst` fields in predicate and function declarations. compiler/recompilation.m: Changes to allow equiv_type.m to record dependencies on arbitrary items, not just types. compiler/recompilation_usage.m: compiler/recompilation_check.m: Allow searches in the sets of used predicates and functions using name, not name and arity, as the key. This is needed because the actual arity of a predicate defined using `with_type` is not known when writing the interface files. compiler/recompilation_version.m: Handle `with_inst` and `with_type`. Pragmas now need to be recorded in the version_numbers even if there is no matching `:- pred' or `:- func' declaration -- the pragma may apply to a predicate or function declared using `with_type`. compiler/mode_util.m: Export inst_subsitute_arg_list for use by equiv_type.m. compiler/error_util.m: Add predicate `pred_or_func_to_string'. library/std_util.m: Add std_util__map_foldl_maybe and std_util__map_foldl2_maybe, which are like list__map_foldl and list__map_foldl2, but apply to the item stored in a value of type std_util__maybe. NEWS: doc/reference_manual.texi: Document the new syntax and library predicates. tests/invalid/Mmakefile: tests/invalid/with_type.m: tests/invalid/with_type.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/recompilation/TESTS: tests/recompilation/unchanged_with_type_nr*: tests/recompilation/with_type_re*: Test cases. tests/invalid/errors1.err_exp: tests/invalid/type_loop.err_exp: tests/invalid/vars_in_wrong_places.err_exp: Update expected output. |
||
|
Zoltan Somogyi
|
2980737352 |
A new LLDS->LLDS transformation that optimizes instruction sequences such
Estimated hours taken: 24
Branches: main
A new LLDS->LLDS transformation that optimizes instruction sequences such
as the following extract from tree234__search:
MR_r1 = MR_stackvar(3);
MR_r2 = MR_stackvar(4);
MR_r3 = MR_const_field(MR_mktag(1), MR_stackvar(1), (MR_Integer) 2);
MR_r4 = MR_stackvar(2);
MR_succip = (MR_Code *) MR_stackvar(5);
if ((MR_tag(MR_r3) != MR_mktag((MR_Integer) 1))) {
MR_GOTO_LABEL(mercury__x3__search_3_0_i1);
}
MR_stackvar(1) = MR_r3;
MR_stackvar(2) = MR_r4;
MR_stackvar(3) = MR_r1;
MR_stackvar(4) = MR_r2;
MR_r2 = MR_r4;
MR_r3 = MR_const_field(MR_mktag(1), MR_r3, (MR_Integer) 0);
MR_call_localret(...)
The code before the if-then-else is part of the procedure epilogue; the code
after it is the code from the initial part of the procedure that fulljump
optimization replaces the self-tail-call with.
The transformation deletes the redundant assignments to stackvars 2, 3 and 4.
It reduces both the size and the runtime of the compiler by about 0.5%.
compiler/reassign.m:
The new module that does the work.
compiler/optimize.m:
Invoke the new module if the optimization is enabled. Invoke it after
most other optimizations have been run, since they may create more
opportunities for it.
compiler/option.m:
Add a new option to control whether the new optimization is enabled.
Turn on the new optimization at optimization level 3.
doc/user_guide.texi:
Document the new option.
compiler/notes/compiler_design.html:
Document the new module.
|
||
|
Simon Taylor
|
9c9601808d |
Add an alternative implementation of Mmake as part of the compiler.
Estimated hours taken: 500 Add an alternative implementation of Mmake as part of the compiler. The advantages of this are - more accurate dependencies - no `mmake depend' step - less process creation (no processes are created to build interface files). Still to do: - handle --split-c-files - handle the IL backend properly - library installation - allow the compiler to be built and the nightly tests to be run with `mmc --make' compiler/make.m: Control the build process. compiler/make.program_target.m: Build executables and libraries. compiler/make.module_target.m: Build C files, object files, interface files etc. compiler/make.dependencies.m: Work out the depenendencies between targets. compiler/make.module_dep_file.m: Record the inter-module dependencies between invocations of mmc. compiler/make.util.m: Utility predicates used by `mmc --make'. compiler/compile_target_code.m: This module will eventually contain the predicates used to compile the target code files generated by the compiler which are now in mercury_compile.m. (That will be done as a separate change for ease of reviewing). For now compile_target_code.m compiler/mercury_compile.m: Export the predicates used to compile target code. Call make.m. Pass the name of the top-level module in the source file to modules.m. It is needed when generating the `.module_dep' files. Lookup the option defaults (which will eventually be stored in DEFAULT_MCFLAGS by the mmc script) before compiling. Up until now the option defaults have been passed on the command line by the mmc script, but with `mmc --make' the default options need to be overridden by the value of the MCFLAGS make variable, but the MCFLAGS make variable is overridden by command line options. Pass the value of `--link-flags' to c2init. Remove some uninformative messages printed when a C, IL, etc. compilation fails. compiler/options_file.m: Read files containing Make style variable assignments. compiler/options.m: doc/user_guide.texi: Add a new options category: build system options. Add some extra options: --warn-undefined-options-variables - like mmake --warn-undefined-vars --verbose-commands - print commands that the user might be interested in, like C compilation, but not things like mercury_update_interface. --output-compile-error-lines - print the first n lines of the error file generated by a command. --generate-mmc-make-modules-dependencies - generate dependencies for use by `mmc --make' even when using Mmake. --il-assembler, --ilasm-flags, --mcpp-compiler, --mcpp-flags, --csharp-compiler, --csharp-flags, --install-prefix, --install-command, --libgrades, --options-files, --options-search-directories. compiler/modules.m: Add fields to the `module_imports' type for use by make.*m. Don't try to fill in fields of the module_imports structure lazily. It's error prone, and probably doesn't save much anyway. Clean up the code to compute what foreign languages are used by a list of item. Simplify the handling of fact tables by recording that a module containing fact tables has foreign code to implement them, rather than requiring separate checks everywhere. Generalise predicates like get_interface so that they work even after the imported items have been read. Fix the handling of header files with the LLDS backend. Install the `.module_dep' files created for use by `mmc --make'. compiler/*.m: Use record syntax rather than explicit deconstruction to refer to fields of the `module_imports' type. compiler/*.m: Be more careful about where output goes. mercury_compile.m sets the output stream to be io__stderr_stream at the start of compilation, so remove all explicit writes to io__stderr_stream (with `--make' the error output stream may be a `.err' file, not io__stderr_stream). Change all occurrences of io__tell/io__told to use io__open_output/io__close_output (io__told restores the current output stream to io__stdout_stream, not the previous value). compiler/passes_aux.m: Make the output from system commands go to the current output stream, not C stdout and stderr. Allow commands to be printed with `--verbose-commands'. Remove uninformative error messages when a command fails. compiler/timestamp.m: Add functions oldest_timestamp and newest_timestamp. compiler/llds_out.m: Record the number of C files written with `--split-c-files' in <module>.num_split. compiler/prog_io.m: compiler/*.m: `search_for_file' now returns the directory in which the file was found. compiler/foreign.m: Use sub-typing to make some calls to predicates in this module `det' rather than `semidet'. compiler/handle_options.m: Return the option arguments. compiler/Mmakefile: make.util.m refers to kill() and `struct sigaction' which are not exported from <signal.h> unless `--no-ansi' is passed to gcc. compiler/notes/compiler_design.html: Document the new modules. runtime/mercury_signal.h: runtime/mercury_signal.c: Add a function MR_signal_should_restart() which alters whether a signal restarts or interrupts system calls. In general restarting is the preferred behaviour, but the wait() for a child process needs to be interruptible. scripts/Mmake.vars.in: Add subdirs for `.module_dep', `.err_date' and `.num_split' files. library/io.m: Add a version of io_call_system which returns the signal that killed the command rather than converting it into an error message. Add a predicate to interpret the result of system() or wait(). library/list.m: Add list__map_foldl2 and a unique mode for list__foldl3. NEWS: Document the new library predicates. configure.in: runtime/mercury_conf.h.in: Check for siginterrupt(). doc/user_guide.texi: Document the new options. Add a description of `mmc --make' to the "Using Mmake" chapter. |
||
|
Fergus Henderson
|
fc8b0fe968 |
Move the code for constructing closures from ml_unify_gen.m
Estimated hours taken: 1 Branches: main Move the code for constructing closures from ml_unify_gen.m into a new module ml_closure_gen.m. compiler/ml_unify_gen.m: compiler/ml_code_util.m: Move ml_make_boxed_types and fixup_builtin_module from ml_unify_gen.m to ml_code_util.m, for use by ml_closure_gen.m. compiler/ml_unify_gen.m: Export ml_gen_new_object, for use by ml_closure_gen.m. compiler/rtti_to_mlds.m: Import ml_closure_gen.m, for ml_gen_closure_wrapper. compiler/ml_unify_gen.m: compiler/ml_closure_gen.m: Move the code for constructing closures from ml_unify_gen.m into a new module ml_closure_gen.m. compiler/notes/compiler_design.html: Mention the new module. |
||
|
Fergus Henderson
|
6d9448c654 |
Implement a new option `--warn-non-tail-recursion'.
Estimated hours taken: 1 Branches: main Implement a new option `--warn-non-tail-recursion'. compiler/ml_tailcall.m: Add a pass to warn about directly recursive calls that are not tail calls. compiler/options.m: doc/user_guide.texi: Add a new option to enable the new pass. compiler/mercury_compile.m: Add code to invoke the new pass. compiler/handle_options.m: If --warn-non-tail-recursion is set, then report an error if either --high-level-code or --optimize-tailcalls is not, or if --error-check-only is set. compiler/notes/compiler_design.html: Mention the new functionality in ml_tailcall.m. |
||
|
Fergus Henderson
|
f08b29edc9 |
Some more bug fixes for accurate GC with the MLDS->C back-end.
Estimated hours taken: 2 Branches: main Some more bug fixes for accurate GC with the MLDS->C back-end. With these changes, and a few hacks (see http://www.cs.mu.oz.au/research/ mercury/mailing-lists/mercury-reviews/mercury-reviews.0201/0188.html), I was able to build all of the programs in tests/benchmarks in grade hlc.agc, with `EXTRA_MCFLAGS = -O5 --no-deforestation --no-reclaim-heap-on-failure'. compiler/ml_elim_nested.m: - Use an assignment rather than an initializer when saving the stack chain; this is needed because the hoist_nested_funcs pass (which gets run next) assumes that the MLDS doesn't have any initializers for local variables. - Include a counter in the ml_elim_info, and use it to ensure that all the saved stack chain variables get named differently; this is needed because the hoist_nested_funcs pass doesn't handle variables with overlapping scopes. - Move the code for generating the code to save/restore the stack chain into a separate function. compiler/notes/compiler_design.html: Mention the accurate GC pass in ml_elim_nested.m. |
||
|
Zoltan Somogyi
|
d6fa030ee9 |
Fix an omission.
Estimated hours taken: 0.1 Branches: main compiler/notes/compiler_desigm.html: Fix an omission. |
||
|
Fergus Henderson
|
95acb0d8a2 |
Implement heap reclamation on failure for the MLDS back-end.
Branches: main Estimated hours taken: 8 Implement heap reclamation on failure for the MLDS back-end. library/private_builtin.m: Add impure procedures for saving and restoring the heap pointer. compiler/add_heap_ops.m: New file, similar to add_trail_ops.m. An HLDS->HLDS transformation to add heap reclamation operations. compiler/mercury_compile.m: Call the new pass. compiler/notes/compiler_design.html: Mention the new pass. compiler/add_trail_ops.m: compiler/table_gen.m: compiler/goal_util.m: Abstract out the common code from `generate_call' in table_gen.m, add_trail_ops.m, and add_heap_ops.m, and put it in a new procedure `generate_simple_goal' in goal_util.m. compiler/add_heap_ops.m: compiler/add_trail_ops.m: Apply a review suggestion from Peter Ross: when putting code in places that should not be reachable, insert code that calls private_builtin__unused (which calls error/1) rather than just inserting `true'. |
||
|
Simon Taylor
|
311d0af1e5 |
Constraint propagation.
Estimated hours taken: 90
Constraint propagation.
compiler/constraint.m:
Push constraints left and inwards as much as possible
within a goal. This module has been completely rewritten.
compiler/deforest.m:
Push constraints within a goal before processing it.
Make specialized versions for calls with constrained outputs.
Rerun determinism inference on specialized versions
when constraint propagation has been run, because the
determinism can change from nondet to semidet.
compiler/pd_util.m:
Add pd_util__propagate_constraints, which uses constraint.m
to push constraints within a goal.
Add some documentation for the exported predicates.
compiler/pd_term.m:
Add support for checking termination of the optimization process
for constraint propagation, which differs from deforestation
in that the conjunctions selected for optimization don't
necessarily have a call at both ends.
compiler/pd_debug.m:
Print some extra information when `--debug-pd' is enabled.
compiler/mercury_compile.m:
Check whether constraint propagation should be performed when
working out whether to run the deforestation pass.
compiler/make_hlds.m:
Add `no_inline' markers to the "recursive" procedures
introduced for builtins to stop constraint propagation
attempting to specialize such procedures.
compiler/hlds_pred.m:
Don't fill in the declared determinism field of the predicates
introduced by `hlds_pred__define_new_pred', so that rerunning
determinism inference will compute a more accurate determinism.
compiler/inlining.m:
Requantify before recomputing instmap_deltas, not after.
compiler/det_report.m:
Add predicates to disable warnings when rerunning
determinism analysis after constraint propagation.
compiler/options.m:
Add documentation for `--constraint-propagation'.
Add option `--local-constraint-propagation', which makes
deforestation call constraint.m to move constraints within
a goal, but does not create specialized versions of procedures
for which there are calls with constrained outputs.
compiler/handle_options.m:
`--constraint-propagation' implies `--local-constraint-propagation'.
compiler/notes/compiler_design.html:
Change the documentation to show that constraint.m is now part
of the deforestation pass.
NEWS:
Announce the new transformation.
doc/user_guide.texi:
Document the new options.
tests/hard_coded/Mmakefile:
tests/hard_coded/constraint.{m,exp}:
tests/hard_coded/constraint_order.{m,exp}:
Test cases.
|
||
|
Simon Taylor
|
9dd11b2fc6 |
Smart recompilation. Record version numbers for each item
Estimated hours taken: 400
Smart recompilation. Record version numbers for each item
in interface files. Record which items are used in each compilation.
Only recompile a module if the output file does not exist or
nothing has changed.
There is still some work to do on this:
- it doesn't work with inter-module optimization.
- it doesn't work when the module name doesn't match the file name.
(this problem will go away when mmake functionality is moved into
the compiler.
I'll hold off documenting this change in the NEWS file and
on the web page for a month or so, until I've had a bit more
experience using it.
compiler/options.m:
compiler/handle_options.m:
doc/user_guide.texi:
Add an option `--smart-recompilation', currently off by default.
Add an internal option `--generate-version-numbers' to control
whether version numbers are written to the interface files. If
`--smart-recompilation' is disabled because the module
is being compiled with `--intermodule-optimization' (e.g. in the
standard library), we still want to write the version numbers
to the interface files.
Add an option `--verbose-recompilation' (default off)
to write messages describing why recompilation is needed.
Add an option `--warn-smart-recompilation' (default on)
to control warnings relating to the smart recompilation
system. Warn if smart recompilation will not work with
the output and inter-module optimization options given.
compiler/recompilation.m:
Type declarations for smart recompilation.
Predicates to record program items used by compilation.
compiler/recompilation_version.m:
Compute version numbers for program items in interface files.
compiler/recompilation_usage.m:
Find all items used by a compilation.
compiler/recompilation_check.m:
Check whether recompilation is necessary.
compiler/timestamp.m:
Timestamp ADT for smart recompilation.
compiler/mercury_compile.m:
Invoke the smart recompilation passes.
compiler/modules.m:
compiler/prog_io.m:
Return timestamps for modules read.
When reading a module make sure the current input stream
is reset to its old value, not stdin.
Handle version number items in interface files.
compiler/module_qual.m:
compiler/unify_proc.m:
compiler/make_hlds.m:
Record all items used by local items.
compiler/make_hlds.m:
Process `:- pragma type_spec' declarations in
add_item_list_clauses. The qual_info is needed
when processing `:- pragma type_spec' declarations
so that any equivalence types used by the declaration
can be recorded as used by the predicate or function to
which the `:- pragma type_spec' applies.
compiler/equiv_type.m:
For each imported item, record which equivalence types
are used by that item.
compiler/hlds_module.m:
Add a field to the module_info to store information about
items used during compilation of a module.
compiler/check_typeclass.m:
Make sure any items used in clauses for typeclass method
implementations are recorded in the `.used' file.
compiler/prog_data.m:
compiler/*.m:
Factor out some duplicated code by combining the
pred and func, and pred_mode and func_mode items.
Make it easier to extract the name of a type, inst or mode
from its declaration.
Add an item type to hold the version numbers for an interface file.
Allow warnings to be reported for `nothing' items (used for
reporting when version numbers are written using an
obsolete format).
compiler/prog_io.m:
compiler/prog_io_util.m:
compiler/typecheck.m:
compiler/type_util.m:
compiler/*.m:
Strip contexts from all types, not just those in class constraints.
This makes it possible to use ordinary unification to check
whether items have changed (with the exception of clauses).
Remove code to create types with contexts in typechecking.
Remove code scattered through the compiler to remove contexts
from types in class constraints.
compiler/hlds_pred.m:
compiler/prog_util.m:
Move hlds_pred__adjust_func_arity to prog_util, so that it
can be used by the pre-hlds passes.
compiler/typecheck.m:
compiler/hlds_module.m:
Move typecheck__visible_modules to hlds_module.m, so it can
be used by recompilation_usage.m.
compiler/typecheck.m:
Add a comment telling where updates may be required if the
code to typecheck a var-functor unification changes.
compiler/error_util.m:
Allow writing messages without contexts (used for the verbose
recompilation messages).
Add functions to format sym_name and sym_name_and_arity,
and to add punctuation to the end of an error message
without unwanted line breaks before the punctuation.
scripts/Mmake.rules:
compiler/modules.m:
Don't remove the output file before running the compiler. We need
to leave the old output file intact if smart recompilation detects
that recompilation is not needed.
compiler/notes/compiler_design.html:
Document the new modules.
library/io.m:
NEWS:
Add predicates to find the modification time of files
and input_streams.
library/set.m:
NEWS:
Add a predicate version of set__fold
Don't sort the output of set__filter, it's already sorted.
library/std_util.m:
NEWS:
Add a predicate `std_util__map_maybe/3' and a function
`std_util__map_maybe/2' to apply a predicate or a function to
a value stored in a term of type `std_util__maybe'.
configure.in:
runtime/mercury_conf.h.in:
runtime/RESERVED_MACRO_NAMES:
When checking whether the compiler is recent enough, check for
the --warn-smart-recompilation option.
Check for stat().
library/Mmakefile:
Disable warnings about smart recompilation not working with
`--intermodule-optimization'.
browser/Mmakefile:
Disable warnings about smart recompilation not working when
the module name doesn't match the file name.
runtime/mercury_string.h:
Add a macro MR_make_string_const() which automates computation
of the length of string argument to MR_string_const().
tests/recompilation/Mmakefile:
tests/recompilation/runtests:
tests/recompilation/test_functions:
tests/recompilation/TESTS:
tests/recompilation/README:
A framework for testing smart recompilation.
The option currently only works for the recompilation directory.
tests/recompilation/TEST.m.{1,2}:
tests/recompilation/TEST_2.m.{1,2}:
tests/recompilation/TEST.exp.{1,2}:
tests/recompilation/TEST.err_exp.2:
Test cases, where TEST is one of add_constructor_r, add_instance_r,
add_instance_2_r, add_type_nr, change_class_r, change_instance_r,
change_mode_r, field_r, func_overloading_nr, func_overloading_r,
lambda_mode_r, nested_module_r, no_version_numbers_r,
pragma_type_spec_r, pred_ctor_ambiguity_r, pred_overloading_r,
add_type_re, remove_type_re, type_qual_re.
tests/handle_options:
Add an option `-e' to generate any missing expected output files.
|
||
|
Zoltan Somogyi
|
04e614485d |
Implement deep profiling; merge the changes on the deep2 branch back
Estimated hours taken: 500 Branches: main Implement deep profiling; merge the changes on the deep2 branch back onto the trunk. The main documentation on the general architecture of the deep profiler is the deep profiling paper. doc/user_guide.texi: Document how to use the deep profiler. deep_profiler: deep_profiler/Mmakefile: A new directory holding the deep profiler and its mmakefile. Mmakefile: Add targets for the new directory. Add support for removing inappropriate files from directories. deep_profiler/interface.m: The deep profiler consists of two programs: mdprof_cgi.m, which acts as a CGI "script", and mdprof_server.m, which implements the server process that the CGI script talks to. Interface.m defines the interface between them. script/mdprof.in: A shell script template. ../configure uses it to generate mdprof, which is a wrapper around mdprof_cgi that tells it how to find mdprof_server. deep_profiler/mdprof_cgi.m: The CGI "script" program. deep_profiler/mdprof_server.m: The top level predicates of the server. deep_profiler/profile.m: The main data structures of the server and their operations. deep_profiler/read_profile.m: Code for reading in profiling data files. deep_profiler/startup.m: Code for post-processing the information in profiling data files, propagating costs from procedures to their ancestors and performing various kinds of summaries. deep_profiler/server.m: Code for responding to requests from the CGI script. deep_profiler/cliques.m: Code to find cliques in graphs. deep_profiler/array_util.m: deep_profiler/util.m: Utility predicates. deep_profiler/dense_bitset.m: An implementation of (part of) the set ADT with dense bit vectors. deep_profiler/measurements.m: Operations on profiling measurements. deep_profiler/timeout.m: An implementation of a timeout facility. deep_profiler/conf.m: Functions that depend on autoconfigured settings. configure.in: Find out what command to use to find the name of the local host. Install deep profiling versions of the standard library along with the other profiling versions. runtime/mercury_conf.h.in: Add some macros for deep_profiler/conf.m to use. library/profiling_builtin.m: runtime/mercury_deep_call_port_body.h: runtime/mercury_deep_leave_port_body.h: runtime/mercury_deep_redo_port_body.h: A new library module that implements deep profiling primitives. Some of these primitives have many versions, whose common code is factor is factored out in three new include files in the runtime. compiler/deep_profiling.m: New module to perform the program transformations described in the paper. compiler/notes/compiler_design.html: Document the new compiler module. compiler/mercury_compiler.m: Invoke the new module in deep profiling grades. Allow global static data to be generated by deep_profiling.m. compiler/options.m: Add options to turn on deep profiling and (for benchmarking purposes) control its implementation. Add an optiooption disable tailcall optimization in the LLDS backend, to help benchmarking deep profiling. compiler/jumpopt.m: compiler/optimize.m: Obey the option to disable tailcalls. compiler/handle_options.m: Handle the implications of deep profiling. compiler/modules.m: In deep profiling grades, automatically import profiling_builtin.m. compiler/prog_util.m: doc/Makefile: library/library.m: Handle the new builtin module. compiler/export.m: In deep profiling grades, wrap deep profiling code around exported procedures to handle the "unscheduled call" aspects of callbacks to Mercury from the foreign language. compiler/higher_order.m: profiler/demangle.m: util/demangle.c: When creating a name for a higher-order-specialized predicate, include the mode number in the name. compiler/add_trail_ops.m: compiler/type_util.m: Move c_pointer_type from add_trail_ops to type_util, so it can also be used by deep_profiling.m. compiler/hlds_goal.m: Add a new goal feature that marks a tail call, for use by deep_profiling.m. compiler/hlds_pred.m: Add a new field to proc_info structures for use by deep_profiling.m. Add a mechanism for getting proc_ids for procedure clones. Remove next_proc_id, an obsolete and unused predicate. compiler/hlds_data.m: Add a new cons_id to refer to the proc_static structure of a procedure. compiler/bytecode_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/switch_util.m: compiler/unify_gen.m: Trivial changes to handle the new cons_id, goal feature and/or proc_info argument. compiler/rtti.m: Add a utility predicate for extracting pred_id and proc_id from an rtti_proc_label, for use by hlds_out.m compiler/layout.m: compiler/layout_out.m: compiler/llds.m: compiler/llds_common.m: Add support for proc_static and call_site_static structures. compiler/layout_out.m: compiler/llds_out.m: Add code for the output of proc_static structures. compiler/code_util.m: Make code_util__make_proc_label_from_rtti a function, and export it. util/mkinit.c: compiler/llds_out.m: compiler/layout.m: compiler/modules.m: Add support for a fourth per-module C function, for writing out proc_static structures (and the call_site_static structures they contains). Since proc_static structures can be referred to from LLDS code (and not just from other static structures and compiler-generated C code), reorganize the declarations of static structures slightly. Change the schema for the name of the first per-module C function slightly, to make it the addition of the fourth function easier. The scheme now is: mercury__<modulename>__init mercury__<modulename>__init_type_tables mercury__<modulename>__init_debugger mercury__<modulename>__write_out_proc_statics Improve formatting of the generated C code. library/*.m: runtime/mercury.c: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_tabling.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: trace/mercrury_trace.[ch]: trace/mercrury_trace_declarative.c: trace/mercrury_trace_external.c: trace/mercrury_trace_internal.c: Conform to the new scheme for initialization functions for hand-written modules. compiler/mercury_compile.m: library/benchmarking.m: runtime/mercury_conf_param.h: runtime/mercury.h: runtime/mercury_engine.c: runtime/mercury_goto.c: runtime/mercury_grade.h: runtime/mercury_ho_call.c: runtime/mercury_label.[ch]: runtime/mercury_prof.[ch]: Add an MR_MPROF_ prefix in front of the C macros used to control the old profiler. compiler/handle_options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make deep profiling completely separate from the old profiling system, by making the deep profiling grade independent of MR_MPROF_PROFILE_TIME and the compiler option --profile-time. library/array.m: library/builtin.m: library/std_util.m: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_compare_body.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of hand-written unification and comparison procedures. Make the reporting of array bounds violations switchable between making them fatal errors, as we currently, and reporting them by throwing an exception. Throwing an exception makes debugging code using arrays easier, but since exceptions aren't (yet) propagated across engine boundaries, we keep the old behaviour as the default; the new behaviour is for implementors. runtime/mercury_deep_profiling_hand.h: New file that defines macros for use in Mercury predicates whose definition is in hand-written C code. library/exception.m: runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of the various modes of builtin_catch. Provide a function that C code can use to throw exceptions. library/benchmarking.m: library/exception.m: library/gc.m: library/std_util.m: runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_overflow.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_thread.c: runtime/mercury_wrapper.c: Add prefixes to the names of the fields in the engine and context structures, to make code using them easier to understand and modify. runtime/mercury_deep_profiling.[ch]: New module containing support functions for deep profiling and functions for writing out a deep profiling data file at the end of execution. runtime/mercury_debug.[ch]: Add support for debugging deep profiling. Add support for watching the value at a given address. Make the buffered/unbuffered nature of debugging output controllable via the -du option. Print register contents only if -dr is specified. runtime/mercury_goto.h: runtime/mercury_std.h: Use the macros in mercury_std.h instead of defining local variants. runtime/mercury_goto.h: runtime/mercury_stack_layout.h: runtime/mercury_stack_trace.c: runtime/mercury_tabling.c: trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Standardize some of the macro names with those used in the debugger paper. runtime/mercury_heap.h: Add support for memory profiling with the deep profiler. runtime/mercury_prof.[ch]: runtime/mercury_prof_time.[ch]: Move the functionality that both the old profiler and the deep profiler need into the new module mercury_prof_time. Leave mercury_prof containing stuff that is only relevant to the old profiler. runtime/mercury_prof.[ch]: runtime/mercury_strerror.[ch]: Move the definition of strerror from mercury_prof to its own file. runtime/mercury_wrapper.[ch]: Add support for deep profiling. Add suppory for controlling whether debugging output is buffered or not. Add support for watching the value at a given address. runtime/Mmakefile: Mention all the added files. scripts/mgnuc.in: Add an option for turning on deep profiling. Add options for controlling the details of deep profiling. These are not documented because they are intended only for benchmarking the deep profiler itself, for the paper; they are not for general use. tools/bootcheck: Compile the deep_profiler directory as well as the other directories containing Mercury code. Turn off the creation of deep profiling data files during bootcheck, since all but one of these in each directory will be overwritten anyway. Add support for turning on --keep-objs by default in a workspace. tools/speedtest: Preserve any deep profiling data files created by the tests. trace/mercury_trace.c: Trap attempts to perform retries in deep profiling grades, since they would lead to core dumps otherwise. util/Mmakefile: Avoid compile-time warnings when compiling getopt. tests/*/Mmakefile: tests/*/*/Mmakefile: In deep profiling grades, switch off the tests that test features that don't work with deep profiling, either by design or because the combination hasn't been implemented yet. |
||
|
Simon Taylor
|
cddde72b73 |
Remove the `--convert-to-goedel' option. It doesn't really work
Estimated hours taken: 0.5 Remove the `--convert-to-goedel' option. It doesn't really work and it's a hassle to maintain. Remove the `--generate-prolog' and `--prolog-dialect' options. They aren't implemented, and now that we have a proper debugger they probably never will be. compiler/mercury_to_goedel.m: Removed. compiler/notes/compiler_design.html: Remove mercury_to_goedel.m. compiler/globals.m: compiler/handle_options.m: Remove code dealing with Prolog dialects. compiler/options.m: doc/user_guide.texi: Remove the options. compiler/prog_io.m: Delete a comment referring to Mercury-to-Goedel converters. compiler/mercury_compile.m: Don't call convert_to_goedel. NEWS: Document the removal of the `--convert-to-goedel' option. WORK_IN_PROGRESS: Remove a reference to the `--generate-prolog' option. |
||
|
Simon Taylor
|
028211a6b5 |
Remove compiler/excess.m. Its functionality has been included in
Estimated hours taken: 0.2 Remove compiler/excess.m. Its functionality has been included in simplify.m. The rationale for leaving it lying around was that it may have been necessary to provide a version which maintains superhomogeneous form. Experience has shown that when a compiler pass requires strict superhomogeneous form (e.g. magic.m) it's simpler to add back the extra assignments where needed. compiler/excess.m: Removed. compiler/dnf.m: Remove the last import of excess.m. compiler/notes/compiler_design.html Remove description of excess.m. |
||
|
Fergus Henderson
|
b973fb0b9d |
Add support for using different clauses for different modes of a
Estimated hours taken: 8 Branches: main Add support for using different clauses for different modes of a predicate or function, using mode annotations on the clauses. compiler/make_hlds.m: Add support for mode annotations on clauses. compiler/module_qual.m: Add new routine qualify_clause_mode_list, for use by make_hlds.m. compiler/mode_errors.m: Export output_mode_decl, for use by make_hlds.m compiler/purity.m: Treat procedures with different clauses for different modes as impure, unless promised pure. compiler/notes/compiler_design.html: Specify when module qualification of modes in clause mode annotations is done (in make_hlds.m). NEWS: doc/reference_manual.texi: Document the new feature. |
||
|
Zoltan Somogyi
|
7add5e0b0d |
Disable value numbering, now that it is no longer needed.
Estimated hours taken: 0.5 Branches: main Disable value numbering, now that it is no longer needed. The value numbering source files are not deleted from the CVS repository, since that would make their restoration (in the unlikely event that this is needed) inconvenient, but they will no longer be compiled or included in compiler executables. doc/user_guide.texi: compiler/options.m: Delete the options dealing with value numbering. compiler/optimize.m: Do not invoke value numbering. compiler/handle_options.m: Delete code that handles implications involving value numbering. compiler/opt_debug.m: Delete code for debugging value numbering, since leaving it in would require importing value numbering modules and would thus drag them into the compiler executable. compiler/value_number.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_debug.m: compiler/vn_filter.m: compiler/vn_flush.m: compiler/vn_order.m: compiler/vn_table.m: compiler/vn_temploc.m: compiler/vn_type.m: compiler/vn_util.m: compiler/vn_verify.m: Delete these now obsolete modules. compiler/notes/compiler_design.html: Delete mentions of value numbering and its modules. tests/general/accumulator/Mmakefile: tests/hard_coded/Mmakefile: Remove references to options removed by this change. |
||
|
Zoltan Somogyi
|
9c58f97e3b |
Add a new optimization, --use-local-vars, to the LLDS backend.
Estimated hours taken: 20 Branches: main Add a new optimization, --use-local-vars, to the LLDS backend. This optimization is intended to replace references to fake registers and stack slots with references to temporary variables in C code, since accessing these should be cheaper. With this optimization and one for delaying construction unifications, the eager code generator should generate code at least good as that produced by the old value numbering pass. This should make it possible to get rid of value numbering, which is much harder to maintain. compiler/use_local_vars.m: New module containing the optimization. compiler/notes/compiler_design.html: Mention the new module. compiler/exprn_aux.m: Add new utility predicates for use by use_local_vars. If --debug-opt is specified, do not dump instruction sequences to standard output. Instead, put them in separate files, where they can be compared more easily. compiler/options.m: Add the --use-local-vars option to control whether the use_local_vars pass gets run. compiler/llds.m: Add liveness information to the c_code and pragma_foreign_code LLDS instructions, in order to allow use_local_vars to work in the presence of automatically-generated C code (e.g. by debugging). compiler/livemap.m: Use the new liveness information to generate useful livemap information even in the presence of automatically generated C code. compiler/code_gen.m: compiler/code_info.m: compiler/dupelim.m: compiler/frameopt.m: compiler/llds_common.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pragma_c_gen.m: compiler/trace.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_filter.m: compiler/vn_verify.m: Provide and/or ignore this additional liveness information. compiler/wrap_block.m: The post_value_number pass wraps LLDS instruction sequences using temporaries in a block instruction which actually declares those temporaries. It used to be used only by value numbering; it is now also used by use_local_vars. It has therefore been renamed and put in its own file. compiler/optimize.m: Invoke use_local_vars if required, and call wrap_blocks instead of post_value_number. compiler/value_number.m: Since the value numbering pass still cannot handle automatically generated C code, check for it explicitly now that livemap carries out only a weaker check. compiler/basic_block.m: Add a module qualification. library/set.m: library/set_bbbtree.m: library/set_ordlist.m: library/set_unordlist.m: Add a new predicate, union_list, to each implementation of sets, for use by some of the new code above. tests/general/array_test.m: Print out the result of each operation as soon as it is done, so that if you get a seg fault, you know which operations have completed and which haven't. |