Estimated hours taken: 5
Branches: main
Fix a bug reported by Greg Duck. The bug was that the compiler always generated
a global variable of type MR_Word for each mutable, but could then assign
variables of other types to and from this global. If this other type is
float, the assignments discard the fractional part. If this other type
is something else, the result can be even worse.
There are two ways to fix this discrepancy. One is to change the type of the
global, and the other is to change the type of the variables it is assigned
to and from. The former looks cleaner, but it would mean that every call
to the get predicate would require a boxing operation, and that can be
relatively slow, since (e.g. for floats) it may require allocating a heap cell.
This diff implements both solutions.
We use the second solution on the LLDS backend because of its better
performance. We have to use the first solution on the MLDS backend,
because on that backend the type of the mutable variable is reflected
in the signature of the getter and setter predicates (whereas on the
LLDS backend all arguments are always MR_Words).
compiler/options.m:
Add an internal-only option that controls whether we use the first
solution or the second.
compiler/handle_options.m:
Make the MLDS backend imply the first solution.
compiler/prog_data.m:
For each argument of a foreign_proc item, record whether we want to
keep it boxed in the foreign code.
Add a foreign_proc attribute that asks for every arg to be kept boxed.
We can attach this to the mutable implementation foreign_procs we write
out to .opt files. This attribute is deliberately undocumented since
users should never use it.
compiler/make_hlds_passes.m:
For each argument of the get and set foreign_procs we create for
mutables, record that we do want to keep it boxed.
Move the action of creating the foreign code for the mutable's
declaration and definition to the third pass, since during the second
pass we don't necessarily know yet what its foreign type is (we may not
have processed a foreign_type declaration affecting it). Move the code
for creating the foreign code here from prog_mutable, since it depends
on the HLDS (and prog_mutable.m is in the parse_tree package).
Hoist some error handling code to put it where it belongs,
and to avoid some errors being reported twice.
compiler/hlds_goal.m:
For each argument of a foreign_proc goal, record whether we want to
keep it boxed in the foreign code.
compiler/llds_out.m:
compiler/pragma_c_gen.m:
compiler/ml_code_gen.m:
compiler/ml_call_gen.m:
If a foreign_proc argument is noted as being kept boxed in the
foreign_proc code, then keep it that way.
compiler/prog_io_pragma.m:
Parse the new foreign_proc annotation.
compiler/simplify.m:
If a foreign_proc has the always_boxed annotation, attach this info
to each of its args. We do this here because simplify is guaranteed
to be executed before all the code that may inspect these arguments.
Since nothing ever deletes an always_boxed annotation of a foreign_proc
arg, the code that attaches the annotation is idempotent, so the fact
that the compiler executes simplify twice is not a problem.
compiler/*.m:
Minor changes to conform to the changes in data structures above.
compiler/prog_type.m:
Move a function definition from prog_mutable to prog_type, and
fix the lack of abstraction in its code.
compiler/prog_mutable.m:
Delete the code moved to make_hlds_passes.m and prog_type.m.
compiler/notes/compiler_design.html:
Make the documentation of prog_mutable.m easier to read in source.
tests/hard_coded/float_gv.{m,exp}:
An extended version of Greg's code as a new test case.
tests/hard_coded/Mmakefile:
Enable the new test case.
tests/hard_coded/sub-modules/non_word_mutable.{m,exp}:
tests/hard_coded/sub-modules/non_word_mutable.child.m:
A version of the float_gv test case in which the compiler-generated
get and set foreign_procs should end up in .opt files.
tests/hard_coded/sub-modules/Mmakefile:
tests/hard_coded/sub-modules/Mercury_options:
Enable the new test case, and make it execute with intermodule
optimization.
tests/invalid/bad_mutable.err_exp:
Expect the new output (in which an error is reported just once,
not twice).
Estimated hours taken: 2
Branches: main
Remove support for the Aditi backend. It is a pain to have to update it every
time a data structure changes when we don't see any benefit from it, and its
presence makes compilation of the compiler directory take about 10% longer
(since the Aditi backend modules are roughly 10% of the code in the compiler
directory). Deleting the Aditi-specific data structures from the HLDS should
also speed up compilation a little bit.
I have spoken to Rao and he is fine with this step.
Aditi users, if there are any, can continue to use the Aditi support in
release 0.12.*. I also tagged the last version on the trunk to support aditi
with the name "last_aditi". The need for modifications in this Aditi support
is likely to be very rare to nonexistent, if the recent past is any guide:
the Aditi backend hasn't seen a nontrivial modification in a year or more.
This diff removes a net 31492 lines.
compiler/add_aditi.m:
compiler/aditi_backend.pp:
compiler/aditi_builtin_ops.m:
compiler/context.m:
compiler/dnf.m:
compiler/magic.m:
compiler/magic_util.m:
compiler/rl.m:
compiler/rl_analyse.m:
compiler/rl_block.m:
compiler/rl_block_opt.m:
compiler/rl_code.m:
compiler/rl_dump.m:
compiler/rl_exprn.m:
compiler/rl_file.pp:
compiler/rl_gen.m:
compiler/rl_info.m:
compiler/rl_key.m:
compiler/rl_liveness.m:
compiler/rl_loop.m:
compiler/rl_opt.m:
compiler/rl_out.pp:
compiler/rl_relops.m:
compiler/rl_sort.m:
compiler/rl_stream.m:
Remove these compiler modules, since they existed only to support the
Aditi backend.
compiler/hlds_goal.m:
Delete the Aditi-specific components of goals (e.g. the aditi-builtin
kind of generic calls and Aditi-evaluated lambdas).
compiler/hlds_pred.m:
Delete the Aditi-specific components of pred_infos.
compiler/prog_data.m:
Delete the Aditi-specific items.
compiler/passes_aux.m:
Don't worry about processing all procedures or just all non-Aditi
procedures.
compiler/add_clause.m:
Add a predicate from a deleted module that is now used only here.
compiler/*.m:
Conform to the data structure changes above.
compiler/notes/*.html:
Remove references to the Aditi backend.
tests/invalid/aditi.m:
tests/invalid/aditi_errors.err_exp:
tests/invalid/aditi_errors.m:
tests/invalid/aditi_private_builtin.m:
tests/invalid/aditi_state_errors.err_exp:
tests/invalid/aditi_state_errors.m:
tests/invalid/aditi_update_derived_relation.err_exp:
tests/invalid/aditi_update_derived_relation.m:
tests/invalid/aditi_update_errors.err_exp:
tests/invalid/aditi_update_errors.m:
tests/invalid/aditi_update_mode_errors.err_exp:
tests/invalid/aditi_update_mode_errors.m:
tests/valid/aditi.m:
tests/valid/aditi_calls_mercury.m:
tests/valid/aditi_error_bug.m:
tests/valid/aditi_error_bug2.m:
tests/valid/aditi_error_bug3.m:
tests/valid/aditi_private_builtin.m:
tests/valid/aditi_query.m:
tests/valid/aditi_update.m:
tests/valid/base_relation.m:
tests/valid/base_relation2.m:
tests/valid/ite_to_disj.m:
Remove these Aditi-specific tests.
tests/*/Mmakefile:
Remove the references to these Aditi-specific tests.
Estimated hours taken: 120.
Branches: main.
Extend constraints based mode analysis.
Constraints on the producing and consuming goals for program
variables are now solved, and the solutions used for
conjunction reordering. The resulting HLDS is then thrown away,
after maybe being dumped (stage 33).
Extend dumping of mode analysis constraints.
Constraints are no longer dumped to file - they are displayed as
error messages when the --debug-mode-constraints is set. After
conjunction ordering, the original goal paths are printed in the
order they now appear.
compiler/options.m:
Added the option described above, and some comments describing
various mode constraint options.
compiler/check_hlds.m:
Grouped ":- include_module"s for propagation solver
constraints based mode analysis, and included
new modules in this area - mcsolver and
ordering_mode_constraints.
compiler/mode_constraints.m:
Changes to the nature of constraint dumping - introduction
of the use of --debug-mode-constraints.
Introduction of conjunction ordering (call to module
ordering_mode_constraints).
compiler/prop_mode_constraints.m:
Changes to way constraints are dumped as described above.
Changes to the way constraint variables are created -
constraint variables can now be constructed as needed
when the constraints are built.
Structural changes to make constraint generation more
natural (eg introduction of state variables, instead
of use of functions).
compiler/abstract_mode_constraints.m:
Changes to the way constraints are stored - the old
speculative code became redundant with the introduction
of rafe's solver (see mcsolver.m).
New, specialised constraint generation predicates.
Constraints are now created with a context attached,
and space was left for adding other information.
compiler/build_mode_constraints.m:
Changes to the way constraint variables are created -
constraint variables can now be constructed as needed
when the constraints are built.
Structural changes to make constraint generation more
natural (eg introduction of state variables, instead
of use of functions).
Constraints are now created with a context attached.
compiler/ordering_mode_constraints.m:
New file. Uses solutions to the producer/consumer
constraints to order conjunctions for mode analysis.
Does not yet do mode inference.
compiler/mcsolver.m:
New file. Written by rafe, modified by myself to
accomodate the rest of the mode constraints branch
(and a new constraint type). Solves mode constraints
to produce bindings for constraint variables from
producer/consumer analysis.
compiler/notes/compiler_design.html:
Updated notes about constraints based mode analysis.
Estimated hours taken: 0
Branches: main
compiler/notes/coding_standards.html:
Mention that module imports from the analysis directory should be
grouped with those from the compiler and mdbcomp directories.
Estimated hours taken: 16
Branches: main
Give the compiler the capability of detecting errors that manifest themselves
as mismatches between the format string and the list of values to be printed
in calls to string.format and io.format.
This capability is controlled through two new options:
--warn-known-bad-format-calls
--warn-unknown-format-calls
The first (which will default to "on" once this change has bootstrapped)
controls whether the compiler emits warnings for statically known mismatches.
The second (which will default to "off") controls whether the compiler emits
warnings in cases where either the format string or the structure of the list
of values to be printed is not available statically to be checked.
NEWS:
Mention the new capability.
compiler/options.m:
Add the two new options.
doc/user_guide.texi:
Document the new options.
compiler/format_call.m:
New module to implement the new capability.
compiler/notes/compiler_structure.html:
Document the new module.
compiler/check_hlds.m:
Include the new module.
compiler/simplify.m:
Invoke the new module if the procedure being processed contains calls
to string.format or io.format.
Fix an old bug: we could generate warnings or even errors when
simplifying predicate bodies imported from other modules via
intermodule optimization.
Don't export get/set predicates that do not need to be exported.
compiler/det_report.m:
Add new kinds of error specifications for the errors detected by the
new module.
Separate out the context of each error specification, in order
to allow the error messages to be sorted by context; this makes
the output much easier to read.
compiler/common.m:
compiler/det_analysis.m:
compiler/simplify.m:
Conform to the change to det_report.m.
mdbcomp/prim_data.m:
Add a utility function for forming the possibly qualified names of
library modules (such as "io" and "string").
library/Mercury.options:
compiler/Mercury.options:
Add the lines that disable the new checks in the modules that need them
disabled. The new lines are commented out until installed compilers all
understand them, at which point in time we will add the requirement to
understand the option to configure.in.
compiler/fact_table.m:
compiler/mlds_to_il.m:
Fix three bugs reported by the new check that have apparently escaped
detection all this time.
library/rtti_implementation.m:
Change some code to avoid a spurious warning from the new checks.
library/string.m:
Rename a predicate to avoid an unnecessary and confusing overloading of
its name.
Replace __ with . as module qualifier connective.
compiler/handle_options.m:
library/pprint.m:
Misc cleanups.
tests/invalid/string_format_bad.{m,err_exp}:
tests/invalid/string_format_unknown.{m,err_exp}:
New test cases to test the new warnings.
tests/invalid/Mmakefile:
tests/invalid/Mercury.options:
Enable the new test cases.
tests/general/string_format_test*.exp*:
Update any expected abort messages to expect . instead of __ as module
qualifier connective.
tests/invalid/det_errors_cc.err_exp:
tests/invalid/erroneous_throw_promise.err_exp:
tests/warnings/simple_code.exp:
Expect the same error messages in program context order.
Estimated hours taken: 3.5
Branches: main
Split the parse tree (currently defined in prog_data.m) into two
separate modules. The reason for doing this is that while over 80%
of the modules in the compiler import prog_data, very few of them actually
require access to the types that define the parse tree (principally
the item type). At the moment even small changes to these types can
result in recompiles that rebuild almost all of the compiler. This change
shifts the item type (and related types) into a new module, prog_item,
that is only imported where these types are required (mostly at the
frontend of the compiler). This should reduce the size of recompiles
required when the parse tree is modified.
This diff does not change any algorithms; it just shifts things around.
compiler/prog_data.m:
Move the item type and any related types that are not needed
after the HLDS has been built to the new prog_item module.
Fix bitrot in comments.
Fix formatting and layout of comments.
Use unexpected/2 in place of error/1 in a spot.
compiler/prog_item.m:
New file. This module contains any parts of the parse tree
that are not needed by the rest of the compiler after the
HLDS has been built.
compiler/check_typeclass.m:
s/list(instance_method)/instance_methods/
compiler/equiv_type.m:
compiler/hlds_module.m:
compiler/intermod.m:
compiler/make.module_dep_file.m:
compiler/make_hlds.m:
compiler/mercury_compile.m:
compiler/mercury_to_mercury.m:
compiler/module_qual.m:
compiler/modules.m:
compiler/parse_tree.m:
compiler/prog_io.m:
compiler/prog_io_dcg.m:
compiler/prog_io_goal.m:
compiler/prog_io_pragma.m:
compiler/prog_io_typeclass.m:
compiler/prog_io_util.m:
compiler/prog_out.m:
compiler/prog_util.m:
compiler/recompilation.check.m:
compiler/recompilation.usage.m:
compiler/recompilation.version.m:
compiler/trans_opt.m:
Conform to the above changes.
compiler/notes/compiler_design.html:
Mention the new module.
Estimated hours taken: 0.1
Branches: main
compiler/compiler_util.m:
Add expect/3 as a replacement for require/2 in the compiler.
compiler/notes/coding_standards.html:
Update some references: s/error_util/compiler_util/
Mention that in the compiler we should use expect/3 rather
than require/2.
Estimated hours taken: 5
Branches: main
Further work on trail usage analysis and optimization.
compiler/mercury_compile.m:
Move trail usage analysis from stage 123 to stage 167.
The advantage of having it later is that compiler
introduced predicates are also added to the trailing_info table.
compiler/trailing_analysis.m:
Do not run this analysis unless we are compiling in a trailing grade.
Add a table of (non-builtin) procedures from the standard library
whose trailing status can be assumed to be known. This works around
some limitations in our current intermodule analysis framework and
also improves trail usage optimization when we are compiling without
any intermodule optimization.
Fix some typos.
doc/user_guide.texi.m:
compiler/options.m:
Document `--analyse-trail-usage' and `--optimize-trail-usage'.
doc/reference_manual.texi:
Document the `will_not_modify_trail' and `may_modify_trail'
foreign code attributes.
compiler/notes/compiler_design.html:
Mention the trailing_analysis module.
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.
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.
Estimated hours taken: 0.2
Branches: main
.README.in:
Update the version of the boehm collector being used.
compiler/notes/upgrade_boehm_gc.html:
Add a step saying to update .README.in.
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.
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.
Estimated hours taken: 0.2
Branches: main
HISTORY:
NEWS:
RELEASE_NOTES:
compiler/notes/work_in_progress.html:
Update compiler documentation on the main branch to take account of
the 0.12 release.
scripts/mercury_config.in:
When reconfiguring don't abort because files need by the .NET and Java
runtime aren't present.
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.
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.
Estimated hours taken: 0.5
Branches: main
compiler/hlds_goal.m:
Clean up the formatting of comments in this module.
Add a comment about why there is duplicate information
in the representation of unifications.
Use unexpected/2 in preference to error1.
s/creater/creator/
compiler/notes/coding_standards.html:
Fix a misformed tag.
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.
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.
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.
Estimated hours taken: 3
Branches: main
compiler/*.m:
Import only one module per line in the modules of the compiler
where my previous diff did not already do so.
Misc other cleanups.
Where relevant, use the new mechanism in tree.m.
compiler/tree.m:
Fix a performance problem I noticed while update :- import_module
items. Instead of supplying a function to convert lists of trees
to a tree, make the tree data structure able to hold a list of
subtrees directly. This reduces the number of times where we have to
convert list of trees to trees that are sticks just to stay within
the old definition of what a tree is.
Estimated hours taken: 1
Branches: main
compiler/notes/coding_standards.html:
Update the coding standard to ask for each import_module to import
only one module even if the module is from the library.
Update the coding standard to reflect current accepted practice
with respect to indentation and the formatting of type definitions.
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.
Estimated hours taken: 0.1
Branches: main
compiler/notes/coding_standards.html:
Added a comment regarding the use of DCG notation and state
variables, particularly with respect to IO.
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.
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.
Estimated hours taken: 12
Branches: main
Move the mdbcomp library to its own directory. To make this change less painful
to test, improve the way we handle installs.
browser/mdbcomp.m:
browser/mer_mdbcomp.m:
browser/prim_data.m:
browser/program_representation.m:
browser/trace_counts.m:
Move these files to the mdbcomp directory.
browser/Mmakefile:
browser/Mercury.options:
mdbcomp/Mmakefile:
mdbcomp/Mercury.options:
Split the contents of the old Mmakefile and Mercury.options file
in the browser directory between these files as appropriate.
Simplify away the stuff not needed now that there is only one library
per directory. Make the browser directory see the relevant files
from the mdbcomp directory.
Mmake.common.in:
Separate out the prefixes allowed in the browser and the mdbcomp
directories.
Mmake.workspace:
Set up a make variable to refer to the mdbcomp directory.
Adjust references to the mdbcomp library to point to its new location.
Mmakefile:
Make invocations visit the mdbcomp library as necessary.
Improve the way we install grades. Making temporary backups of the
directories modified by the install process is unsatisfactory for two
reasons. First, if the install fails, the cleanup script, which is
necessary for user friendliness, destroys any evidence of the cause.
Second, the restore of the backup wasn't perfect, e.g. it left the
.d files modified to depend on .mih files, which don't exist in
LLDS grades, and also left altered timestamps.
This diff changes the install process to make a single tmp_dir
subdirectory of the workspace, with all the work of install_grade
being done inside tmp_dir. The original directories aren't touched
at all.
*/Mmakefile:
Adjust references to the browser directory to refer to the mdbcomp
directory instead or as well.
scripts/Mmake.rules:
*/Mmakefile:
Make it easier to debug Mmakefiles. Previously, creating a
Mmake.makefile with mmake -s and invoking "make -d" ignored the
most fundamental rules of mmake, because Mmake.rules was treating
an unset MMAKE_USE_MMC_MAKE as if it were set to "yes", simply because
it was different from "no". This diff changes it to treat an unset
MMAKE_USE_MMC_MAKE as if it were set to "no", which is a more
sensible default.
scripts/prepare_tmp_dir_fixed_part.in:
scripts/scripts/prepare_tmp_dir_grade_part:
Two new scripts that each do half the work of preparing tmp_dir for
the real work of the install_grade make target. The fixed_part script
prepares the parts of tmp_dir that are grade-independent, while the
grade_part scripts prepares the parts that are grade-dependent.
configure.in:
Test C files in the mdbcomp directory to see whether they need to
be recompiled after reconfiguration.
Create prepare_tmp_dir_fixed_part from prepare_tmp_dir_fixed_part.in.
compiler/*.m:
runtime/mercury_wrapper.c:
Update the references to the moved files.
compiler/notes/overall_design.html:
Mention the new directory.
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.
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.
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.
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.
Estimated hours taken: 0.1
Branches: main
compiler/notes/coding_standards.html:
If a grouping of predicate, mode and function declarations
occurs in the interface one of the standard library modules
specify that the function declaration should listed before the
others. The rationale for doing this is to make the library
reference manual more consistent (it also makes it easier
to see if there is a function version of a predicate.
Estimated hours taken: 3
Branches: main
Deprecate old-style lambda expressions properly.
compiler/make_hlds.m:
Emit a warning if an old-style lambda expression is
encountered.
compiler/notes/todo.html:
Remove this from the TODO list.
compiler/base_typeclass_info.m:
compiler/mercury_to_mercury.m:
extras/odbc/odbc.m:
tests/*/*.m:
Replace old-style lambda expressions as necessary.
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.
Estimated hours taken: 1
Branches: main
Update coding standards for interfaces in the
standard library. The intent is to improve the
library reference guide.
compiler/notes/coding_standards.html:
Modify the coding standards to specify how descriptive
comments for library procedures should be placed.
By fixing a style (hopefully) the library reference guide
should have a more consistent appearance.
Specify that predmode syntax should be used in preference
to a separate mode declaration if a predicates has only
one mode.
Specify that descriptive comments for procedures should
ideally state under which conditions the procedure can
fail (if it can) or throw an exception.
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.
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.
Estimated hours taken: 0.3
Branches: main
compiler/notes/type_class_transformation.html:
Undo Fergus's recent addition of a request for a pointer to the
documentation of the proposed replacement for base_typeclass_infos,
since that pointer already exists a few lines above.
Document the mechanisms we use or should use for detecting duplicate
instance declarations.
Estimated hours taken: 0.1
Branches: main
compiler/notes/Mmakefile:
w3/information/include/developer.inc:
Delete references to the recently deleted module_system.html.
Estimated hours taken: 0.25
Branches: main
compiler/notes/coding_standards.html:
Document that "++" should be used for string literals that don't
fit on a single line.
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.
