Fix a failing debugger test case.
compiler/simplify_goal_call.m:
Avoid the check for division by zero in (/) and (rem) when the second
operand is a non-zero constant for the fixed size integer types.
Replace (<<) and (>>) with their unchecked variants if the second operand
is within the valid range for the fixed size integer types.
Generalise some code to make it suitable for all of the integer types.
Do not hardcode the names of integer modules in so many places.
Fix a bug: the current instmap was being passed to
simplify_improve_library_call twice.
tests/debugger/save.exp:
Update this expected output; it corresponds to the case where no
XUL browser (i.e. firefox) is available.
browser/browse.m:
Add save_and_browse_browser_term_web to be called when
"browse --web" is entered at the mdb prompt.
Add browser_term_to_html_flat_string, a helper predicate for
term_to_html.
Make portray_flat_write_browser_term work take a stream parameter
instead of writing to the current output stream. It is called by
browser_term_to_html_flat_string, writing to a string builder
stream.
browser/browser_info.m:
Add web_browser_cmd field to browser_persistent_state.
browser/mdb.m:
browser/term_to_html.m:
Add new module to generate an HTML document. The document contains a
JavaScript represention of a Mercury term.
(The JavaScript string escaping code is adapted from Julien's
mercury-json project.)
browser/percent_encoding.m:
Add new module to perform percent-encoding.
scripts/mdb_term_browser.css:
scripts/mdb_term_browser.js:
Add JavaScript and CSS files referenced by the generated HTML file
to create a tree view of a Mercury term using jstree.
scripts/32px.png:
scripts/40px.png:
scripts/throbber.gif:
scripts/jstree.min.js:
scripts/jstree.style.min.css:
Add local copy of jstree files <https://www.jstree.com/>
scripts/jquery.slim.min.js:
Add local copy of jquery <https://jquery.com/>
scripts/Mmakefile:
Install the new files into the same directory as mdbrc and other
mdb-related files.
trace/mercury_trace_browse.c:
trace/mercury_trace_browse.h:
trace/mercury_trace_cmd_browsing.c:
trace/mercury_trace_cmd_parameter.c:
trace/mercury_trace_cmd_parameter.h:
trace/mercury_trace_internal.c:
Add "browse --web" and "web_browser_cmd" commands.
doc/user_guide.texi:
Document "browse --web" and "web_browser_cmd" commands.
configure.ac:
scripts/mdbrc.in:
Set a reasonable default command to launch a web browser from mdb.
(Only tested on Linux.)
NEWS:
Announce the new feature.
.README.in:
Mention jquery and jstree licensing.
tests/debugger/Mmakefile:
tests/debugger/completion.exp:
tests/debugger/mdb_command_test.inp:
tests/debugger/save.exp2:
Update debugger tests for new commands.
compiler/options.m:
doc/user_guide.texi:
NEWS:
Add the above option.
compiler/simplify_goal_call.m:
If the option is given, then generate severity_informational messages
for calls to I/O predicates such as io.write_string/3, which have twins
(in this case io.write_string/4) that take an extra initial argument
that explicit specifies the stream to do the I/O on.
Additionally, generate warnings for the predicates that update
the library's notion of the current input and outpuy streams,
since these are effectively the "enablers" for the calls that the
above paragraph describes.
Fix the conditions on some error specs.
Delete a duplicated comment.
compiler/simplify_tasks.m:
Add the new task to the list of tasks that simplification
may be asked to do.
compiler/simplify_info.m:
compiler/simplify_proc.m:
Fix an old minor bug: shut up *all* messages, whether their severity
is error, warning or informational, during the second pass of
simplification. (The need for the fix is described in the new comment
in simplify_proc.m.)
compiler/common.m:
compiler/simplify_goal.m:
compiler/simplify_goal_disj.m:
compiler/simplify_goal_ite.m:
Conform to the changes above.
tests/warnings/save.{m,exp}:
A new test case to test the new option.
tests/warnings/Mmakefile:
Enable the new test case.
Switch to a more consistent indentation style.
tests/warnings/Mercury.options:
Run the new test case with the new option.
tests/debugger/save.m:
The new test case, warnings/save.m, is a version of debugger/save.m
with up-to-date programming style. Update the original as well.
compiler/det_report.m:
When a goal has too many solutions, but it occurs in a context in which
the identity of those solutions does not matter, the compiler inserts
a commit scope to prune away the redundant (because they are externally
indistinguishable) solutions.
When this goal is a switch inside a require_switch_arms_<detism> scope,
this commit scope added by determinism analysis screwed up the expectation
of the require_switch_arms_<detism> scope that the switch is its IMMEDIATE
subgoal. Relax this sometimes-wrong assumption by allowing for a commit
scope wrapped around the switch.
When generating error messages for cons_ids missing from switches,
don't print the module qualifiers for the cons_ids, since users
will already know it (it is part of the identity of the type of switch-on
variable).
Print the missing cons_ids one per line, to make the list easier to read.
Fix capitalization in some error messages.
compiler/switch_detection.m:
When creating switch arms, give each arm a more meaningful context
that the context of the original disjunction, which is usually the context
of the first ";" operator in it.
tests/invalid/switch_arm_multi_not_det.{m,err_exp}:
New test case for the fix listed first for det_report.m.
tests/invalid/Mmakefile:
Enable the new test case.
tests/debugger/dice.exp*:
tests/invalid/det_errors.err_exp:
tests/invalid/require_scopes.err_exp:
Update these expected outputs for the changes above.
Estimated hours taken: 26
Implement the following improvements:
- Pass mdb variable bindings to the interactive query processor,
allowing queries to make use of live values.
- Catch exceptions thrown by queries, rather than crashing mdb.
- Write outputs using io.write_cc/3.
- Don't output underscore variables, avoiding spurious warnings.
- More protection of the user's namespace.
- Updated the cleanup code.
browser/interactive_query.m:
The interface now accepts corresponding lists of names and values,
which are matched up with variables occurring in the queries.
Replace the code generator with one that supports passing data
to and from the query, and catching exceptions from the query.
Pass the appropriate data at the time the query predicate is called.
Distinguish between failure of the query and failure of the dynamic
casts used to instantiate the query inputs.
Use module qualifiers to avoid clashing with user imports. (Should the
generated code use use_module, just in case?)
Perform I/O, failure handling and exception handling in the caller
instead of in the generated code. This is faster, more maintainable,
and means that errors are caught earlier.
Place source_file and line directives more carefully so as to ensure
more consistent error messages, and to help distinguish errors in the
template from errors in the query.
Factor out the query command parser to avoid double maintenance.
browser/debugger_interface.m:
Conform to above changes.
trace/mercury_trace_vars.[ch]:
Export MR_trace_return_bindings, which constructs Mercury lists
of the variable names and values in the current environment.
trace/mercury_trace_browse.c:
Pass bindings from trace/mercury_trace_vars through to the interactive
query processor.
tests/debugger/interactive.{m,inp,exp}:
Update for changes to existing functionality. Additionally test the
new functionality.
doc/user_guide.texi:
Document the new behaviour.
NEWS:
Announce the new behaviour.
tests/benchmarks/Mmakefile:
Delete variables only used with the IL or GCC back-ends.
tests/debugger/Mmakefile:
tests/declarative_debugger/Mmakefile:
tests/par_conj/Mmakefile:
Delete references to the IL backend.
tests/par_conj/dep_par_10.m:
Add missing C# and Java foreign procs.
tests/dppd/Mmakefile:
Run these tests in the Java grade.
tests/general/Mmakefile:
Delete a workaround for OSF/1 -- we no longer support it.
tests/hard_coded/Mmakefile:
Delete the unused list of tests that will pass in the Java grade.
Delete a reference to the IL backend.
Mdb supports the location of a breakpoint to be specified either
as a procedure name, or as a source location in the form of a
filename/linenumber pair. It has long had readline auto-complete
on procedure names; this diff adds auto-complete on source locations as well.
NEWS:
Announce the new capability.
trace/mercury_trace_completion.{h,c}:
Add a completer for break commands that is separate from the existing
one that completes only procedure specifications. The new one completes
on both those AND on the filename:linenumber of all the events in all
the debuggable modules of the program.
Move all the forward declarations of static functions to the top
of mercury_trace_completion.c, and put them in the same order as
the corresponding definitions.
trace/mercury_trace_internal.c:
Use the new completer for the "break" command.
trace/mercury_trace_spy.c:
trace/mercury_trace_tables.c:
Fix some documentation.
tests/debugger/completion.{inp,exp}:
Update this test. Update the input, because in some cases, this diff
causes the shortest unambiguous extension of the current line so far
to become shorter, due to the addition of source locations to the set
of strings being given to readline. And update the output to show
the now-expanded set of matching strings at the points at which
completion is taking place.
We haven't supported it in years, and keeping it in the compiler
is just a maintenance burden and a performance problem.
mdbcomp/prim_data.m:
Delete the spec_pred_init functor, since we don't support special
"init" predicates anymore.
compiler/prog_data.m:
Delete the slot in solver type details that record the name of the
auto-initialization predicate.
compiler/prog_io_type_defn.m:
Don't allow a type definition to specify an auto-initialization predicate.
compiler/options.m:
compiler/globals.m:
Delete the option that allowed support for auto-initialization to be
turned back on.
compiler/inst_match.m:
compiler/inst_util.m:
Delete comments about auto-initialization.
compiler/mode_info.m:
Delete the record of whether we have variables that can be
auto-initialized (we never do anymore) and the flag that controls whether
auto-initialization is permitted or not.
compiler/modecheck_conj.m:
Simplify the code that modechecks conjunctions, since it no longer
has to figure out where to insert auto-initializations of solver vars.
compiler/modecheck_goal.m:
Delete the code that ensured that if one branch of a branched
control structure auto-initialized a solver variable, then they
all did.
compiler/modecheck_unify.m:
Don't auto-initializate variables before unifications.
compiler/modecheck_util.m:
Delete the code that auto-initialized solver variables at the ends
of procedure bodies if this needed to be done and wasn't done before.
compiler/add_special_pred.m:
compiler/equiv_type.m:
compiler/equiv_type_hlds.m:
compiler/get_dependencies.m:
compiler/hlds_module.m:
compiler/hlds_pred.m:
compiler/modecheck_call.m:
compiler/modes.m:
compiler/module_qual.qualify_items.m:
compiler/parse_tree_out.m:
compiler/post_term_analysis.m:
compiler/smm_common.m:
compiler/special_pred.m:
compiler/term_constr_errors.m:
compiler/term_constr_initial.m:
compiler/term_util.m:
compiler/termination.m:
compiler/trace_params.m:
compiler/type_util.m:
compiler/unify_proc.m:
Delete code that handled stuff related to auto-initialization,
and now always take the path that would normally be taken in the
absence of auto-initialization.
deep_profiler/read_profile.m:
runtime/mercury_layout_util.c:
runtime/mercury_stack_trace.c:
util/mdemangle.c:
Remove code that recognized the compiler-generated name of initialization
predicates.
tests/debugger/solver_test.m:
tests/hard_coded/solver_construction_init_test.m:
tests/hard_coded/solver_disj_inits.m:
tests/hard_coded/solver_ite_inits.m:
tests/invalid/missing_init_pred.m:
tests/invalid/zinc2mer_lib.m:
tests/valid/fz_conf.m:
tests/valid/solver_type_bug_2.m:
tests/valid/solver_type_mutable_bug.m:
These tests tested the handling of auto-initialization, which we
no longer support. Keep them around (and a bit more visible than
inside the git repo) in case we need them again, but add a comment
to each saying that the test is disabled.
tests/debugger/Mercury.options:
tests/debugger/Mmakefile:
tests/hard_coded/Mercury.options:
tests/hard_coded/Mmakefile:
tests/invalid/Mercury.options:
tests/invalid/Mmakefile:
tests/valid/Mercury.options:
tests/valid/Mmakefile:
Disable those tests.
tests/warnings/non_term_user_special.{m,exp}:
Part of this test tested the handling of auto-initialization;
delete that part.
tests/warnings/Mercury.options:
Delete the flag required by the deleted part, since we don't support it
anymore.
There are several reasons for this change.
First, it is more flexible than the previous arrangement of adding items
to the HLDS in three passes. Since adding a fourth pass would have had
significant performance implications, we refrained from making changes
that would have required a fourth pass in a pass-based algorithm.
With the new structure, such changes do not lead to any detectable slowdown,
so there is no reason why we should avoid making them.
In fact, the immediate motivation for this diff is to make such a change.
This is a fix for Mantis bug 318, which requires adding abstract and/or
non-foreign definitions for types before foreign definitions for those types
*regardless* of their relative order in the source code.
This diff also has the side effect that e.g. the mode declarations for
a predicate don't have to follow the declaration of the (type of) the predicate
itself. Pred and mode declarations used to be processed in the same pass,
but now, all pred declaration are processed before all mode declarations.
Second, as identified earlier, the new structure is conceptually cleaner than
the old one, and the constraints on when different kinds of items have to be
added to the HLDS can documented next to the code that does the adding,
since that code is no longer mixed with code that adds other kinds of items
at the same time.
Third, the code we used to use to detect invalid type definitions
was only a crude approximation. With the new setup, it is trivial to use
an exact computation. We now proceed to later compiler passes in many cases
that previously led us to stop before type checking because we (erroneously)
believed that the program had an invalid type definition.
Fourth, my benchmarking shows a speedup on tools/speedtest -l -m of about
1.2% to 1.5%. The new approach does allocate a bit more memory (a pair
and a cons cell per item), but it traverses most items just once, not
three times. A few kinds of items (e.g. pred declarations) do have to be
processed more than once, e.g. both before and after some other kinds
of items are added to the HLDS, but four of the five most frequent items
in bootchecks (the pragmas recording the results of the termination and
exception analyses, mode declarations, and clauses) are processed just once.
Evidently, the speedup from traversing fewer items, and avoiding the
switches on item kinds that those traversals involve, is greater than
the extra cost of the additional memory allocations, including their effect
on garbage collection times.
compiler/make_hlds_passes.m:
Make the change described above.
Remove "shim" code, i.e. code that serves only to unpack the pairing
of an item with other info such as a status, and code that tests
that status, e.g. to see whether the item is defined in the module
being compiled. Move that shim code to the other submodules of
make_hlds.m. (We used to have add_xyz predicate in make_hlds_passes.m
and module_add_xyz predicates in those submodules, in which add_xyz
contained only shim code and a call to the corresponding module_add_xyz
predicate.)
compiler/add_class.m:
compiler/add_mutable_aux_preds.m:
compiler/add_pred.m:
compiler/add_solver.m:
Move shim code here from make_hlds_passes.m.
Give some predicates better names.
In a few cases, remove unneeded arguments from predicates. For example,
most predicates that do only checks don't need write access to the
module_info.
compiler/add_pragma.m:
Use subtypes to make the code a bit more efficient.
Add specialized fold predicates that can handle those subtypes.
compiler/add_type.m:
Add documentation for an old design decision.
compiler/make_hlds.m:
Add some utility types for use by make_hlds_passes.m and the various
add_xyz.m.
compiler/check_typeclass.m:
Improve an error message. We now get this error message even for modules
on which the compiler previously stopped before getting to typechecking.
compiler/modes.m:
Don't generate redundant error messages for mode errors in mutables' aux
preds. (Previously, the mode checker wouldn't have been invoked if
make_hlds_passes.m found the original problem.)
compiler/prog_item_stats.m:
Delete an unneeded import.
library/list.m:
Add an inst-preserving version of reverse, since make_hlds_passes.m
now needs one.
tests/debugger/solver_test.exp:
We add predicates to the HLDS in a different order now (auxiliary
predicates for solver types are added *after* used-defined predicates).
This test prints the raw order of those predicates, so expect the new
order.
tests/invalid/typeclass_test_9.err_exp:
tests/invalid_purity/purity_nonsense2.err_exp:
Expect error messages we didn't used to get, because the compiler
stopped before typechecking due to (incorrectly) believing that it found
an invalid type definition.
For typeclass_test_9, expect the updated error message from
check_typeclass.m. (This newly printed error message was the reason
*why* I improved the message from check_typeclass.m.)
tests/invalid/tc_err1.err_exp:
tests/invalid/tc_err2.err_exp:
tests/invalid/typeclass_bogus_method.err_exp:
tests/invalid/typeclass_missing_mode_2.err_exp:
tests/invalid/typeclass_test_10.err_exp:
tests/invalid/typeclass_test_3.err_exp:
tests/invalid/typeclass_test_4.err_exp:
Expect the updated error message from check_typeclass.m.
tests/valid/bug318.m:
A test case for Mantis bug 318.
tests/valid/Mmakefile:
Enable the new test case.
tests/Mmake.common:
Don't invoke any actions in the clean_local and realclean_local
targets, since if using mmc --make, the builtin mmake rules
have actions for those targets as well, and make can't handle
more than one action for a target having actions. Replace those
actions with dependencies on other, unique targets that have
the actions instead.
tests/*/Mmakefile:
Avoid actions in clean_local and realclean_local targets the same way.
Sort the test names in some directories that didn't already do so.
Delete some obsolete comments.
Fix style.
tests/valid/Mmake.valid.common:
As for the Mmakefiles above, and also move the definition of a make
variable before it is needed.
Without this, mmake -jN may try to create the slices in parallel. Since that
task involves moving trace counts files, whose names are unpredictable (they
include the process id), we do it by moving all files whose names fit the
associated a pattern. If more than one slice is being created at any one time,
this meant that one invocation of the mmake rule doing the moving can "steal"
the trace counts file from another.
The big diff that replaced the item list with proper parse trees included code
that the compiler couldn't handle in decldebug grades, aborting with a message
about liveness mismatch between different switch arms. The problem occurred
when compiling this code in generate_missing_start_section_warning_int,
which is one arm of a switch on !.MissingStartSectionWarning:
!.MissingStartSectionWarning =
have_not_given_missing_section_start_warning,
!:MissingStartSectionWarning =
have_given_missing_section_start_warning,
Pieces = [invis_order_default_start(1), ...],
_Spec = error_spec(severity_error, phase_term_to_parse_tree,
[simple_msg(Context, [always(Pieces)])])
The problem was liveness.m's handling of the from_ground_term_construct
scope that is generated for the assigmnet of the ground term to Pieces.
compiler/liveness.m:
During the first pass through the procedure body, the liveness pass,
replace with the empty conjunction any from_ground_term_construct scopes
that construct terms to assign to dead variables. This prevents the
second pass, the deadness pass, from including the dead variable
(Pieces in the above example, after the assignment to _Spec was
optimized away by earlier passes) in the set of variables that
have been seen, since obviously, they won't be seen in the other arms.
This inclusion was the cause of the assertion failure that led to
the compiler abort.
Improve the existing debugging infrastructure to help find bugs like this,
by printing out what the selected procedure's body looks like before
as well as after the initial requantification.
compiler/quantification.m:
Replace from_ground_term_construct scopes whose ground term is assigned
to a dead variable with empty conjunctions, so that the compiler passes
between the first quantification after mode checking and the liveness
pass also see a smaller HLDS.
Implement an unrelated improvement whose possibility I discovered when
investigating why a version of the test case *without* the from_ground_term
scope wasn't getting the abort. When processing unifications, build up the
set of variables in the unification directly, not by recording a bunch
of maybe(somethings)s and then processing the somethings, if they existed,
later. This yields code that is shorter, simpler *and* faster.
tests/valid/liveness_disagree.m:
A new test case for this bug. It is a cut-down version of
generate_missing_start_section_warning_int.
tests/valid/Mmakefile:
tests/valid/Mercury.options:
Enable the new test case, and try to compile it in a declarative debugging
grade.
compiler/assertion.m:
compiler/deep_profiling.m:
compiler/lookup_switch.m:
compiler/par_loop_control.m:
Add module qualifications in several places. I found the need for these
when I temporarily redefined the set_of_var type to use sets instead of
sparse_bitsets, to make debugging the bug in liveness.m easier; without
them, I got errors about excessive overloading.
Do some other cleanups as well.
tests/debugger/all_solutions.exp4:
tests/debugger/exception_cmd.exp3:
tests/debugger/loopcheck.exp3:
tests/debugger/uci_index.exp2:
tests/declarative_debugger/Mmakefile:
tests/declarative_debugger/builtin_call_rep.exp:
tests/declarative_debugger/catch_retry.exp:
tests/declarative_debugger/condition_bug.exp:
tests/declarative_debugger/find_origin.exp3:
tests/declarative_debugger/lpe_example.exp3:
tests/declarative_debugger/priv_builtin_bug.exp:
tests/declarative_debugger/solns.exp3:
tests/declarative_debugger/sort.exp:
tests/declarative_debugger/track_through_catch.exp:
tests/declarative_debugger/typed_unify.exp:
Update all these expected outputs for the changes in line numbers
caused by my cleanups of the test cases early in 2015.
For the declarative_debugger/{condition_bug,sort} test cases, also
update them for the change to print the types and values of foreign types.
tests/hard_coded/type_qual.{m,exp}:
This test case failed for an earlier version of this diff, so add some
context to its outputs, to make such failures easier to debug.
To make *that* easier, bring it to date in programming style.
browser/interactive_query.m:
Use '.dylib' as the extension for the shared library we generate for
interactive queries when on OS X. (While '.so' would work in principle,
its use is unusual on OS X and the Mercury compiler will always use
'.dylib' anyway.)
Replace some sequences of I/O operations with single calls to io.format
so that message components are not spread over multiple lines.
Add an XXX comment about object file extensions.
Update comments that refer to 'libquery' rather than 'libmdb_query'.
README.MacOS:
Delete interactive queries from the list of unsupported features.
tests/debugger/interactive.exp:
Update this expected output. The changes are due to earlier
changes to the formatting and presentation of error messages.
runtime/mercury_ml_expand_body.h:
When deconstructing values of foreign types, include the type name
and the hex version off the value in the function symbol we generate.
tests/debugger/Mmakefile:
Replace the hex values of foreign types, which depend on the precise
layout of an executable, with 0xXXXXs.
Remove an old redundant rule.
tests/debugger/foreign_type.exp:
Expect the type names and the (filtered) values, both when the foreign type
value is printed by the program, and when it is printed by the debugger.
runtime/mercury_deconstruct.h:
Bring this module up to our current standards of programming style,
by making type names only camelcase, not camelcase AND underscores.
runtime/mercury_deconstruct.c:
runtime/mercury_ml_expand_body.h:
runtime/mercury_ml_functor_body.h:
library/deconstruct.m:
Conform to the above.
In mercury_ml_expand_body.h, fix an old mistake in documentation.
library/rtti_implementation.m:
Bring this module up to our current standards of programming style.
Note some inconsistencies. Factor out some common code.
tests/hardcoded/foreign_type.m:
Bring this module up to our current standards of programming style.
tests/debugger/foreign_type.{m,inp,exp}:
A new test case, to test the printing of values of foreign types.
tests/debugger/Mmakefile:
Enable the new test case.
Mmakefile:
Run the realclean_tests target *before* the realclean_subdirs
target since the former requires scripts/mmake to exist and
the latter deletes it.
tests/debugger/save.exp:
Update this expected output to conform to recent changes.
(The .exp2 file was updated as part of those changes, but
this one wasn't.)
trace/mercury_trace_cmd_breakpoint.c:
trace/mercury_trace_source.c:
Avoid warnings from GCC.
tests/Mmake.common:
Replace the -j1 in the runtests_local target used by all the test
directories with $(MAYBE_J1).
tests/*/Mmakefile:
Define MAYBE_J1 it as the empty string in test directories in which
different tests don't share source files.
Define MAYBE_J1 as -j1 in test directories in which
different tests do share source files.
tests/submodules/sub2_a.m:
Add this copy of sub_a.m to allow tests in the submodules directory
to be done in parallel.
tests/submodules/accessibility2.m:
Import sub2_a.m instead of sub_a.m.
tests/warnings/ambig_types_high_level.m:
Add this copy of ambig_types.m to allow tests in the warnings directory
to be done in parallel.
tests/warnings/ambig_high_level.m:
Import ambig_types_high_level.m instead of ambig_types.m.
tests/accumulator/*.m:
tests/analysis_*/*.m:
tests/benchmarks*/*.m:
tests/debugger*/*.{m,exp,inp}:
tests/declarative_debugger*/*.{m,exp,inp}:
tests/dppd*/*.m:
tests/exceptions*/*.m:
tests/general*/*.m:
tests/grade_subdirs*/*.m:
tests/hard_coded*/*.m:
Make these tests use four-space indentation, and ensure that
each module is imported on its own line. (I intend to use the latter
to figure out which subdirectories' tests can be executed in parallel.)
These changes usually move code to different lines. For the debugger tests,
specify the new line numbers in .inp files and expect them in .exp files.
Specifically, rename the following subdirectories of the test directory:
old dir name new dir name
analysis/ext analysis_external
analysis/ctgc analysis_ctgc
analysis/excp analysis_excp
analysis/table analysis_table
analysis/trail analysis_trail
invalid/purity invalid_purity
analysis/sharing analysis_sharing
hard_coded/purity purity
general/accumulator accumulator
analysis/unused_args analysis_unused_args
debugger/declarative declarative_debugger
hard_coded/exceptions exceptions
general/string_format string_format
hard_coded/sub-modules submodules
hard_coded/typeclasses typeclasses
general/structure_reuse structure_reuse
Some subdirectories are still there, to wit, the subdirs of the inactive
test directory stm, each of which (if I remember correctly) holds only one
test case.
The general/structure_reuse directory previously wasn't enabled; I think
this was a bug.
tests/Mmakefile:
tools/bootcheck:
List the new test directories.
tests/Mmake.common:
The analysis_* directories each need to know whether the workspace
uses subdirs. This used to be controlled from one place,
analysis/Mmakefile, but since analysis_* are not subdirs of analysis,
we need a new central place to find this out.
tests/analysis/common.sh:
Update documentation for the move.
tests/OLDDIRS/Mmakefile:
Set the subdir list to empty.
tests/NEWDIRS/Mmakefile:
Update the "this" directory's name, as well as TESTS_DIR.
In analysis_*/Mmakefile, use the new mechanism for detecting the presence
of subdirs.
Specifically, rename the following subdirectories of the test directory:
old dir name new dir name
analysis/ext analysis_external
analysis/ctgc analysis_ctgc
analysis/excp analysis_excp
analysis/table analysis_table
analysis/trail analysis_trail
invalid/purity invalid_purity
analysis/sharing analysis_sharing
hard_coded/purity purity
general/accumulator accumulator
analysis/unused_args analysis_unused_args
debugger/declarative declarative_debugger
hard_coded/exceptions exceptions
general/string_format string_format
hard_coded/sub-modules submodules
hard_coded/typeclasses typeclasses
general/structure_reuse structure_reuse
Some subdirectories are still there, to wit, the subdirs of the inactive
test directory stm, each of which (if I remember correctly) holds only one
test case.
The general/structure_reuse directory previously wasn't enabled; I think
this was a bug.
tests/Mmakefile:
tools/bootcheck:
List the new test directories.
tests/Mmake.common:
The analysis_* directories each need to know whether the workspace
uses subdirs. This used to be controlled from one place,
analysis/Mmakefile, but since analysis_* are not subdirs of analysis,
we need a new central place to find this out.
tests/analysis/common.sh:
Update documentation for the move.
tests/OLDDIRS/Mmakefile:
Set the subdir list to empty.
tests/NEWDIRS/Mmakefile:
Update the "this" directory's name, as well as TESTS_DIR.
In analysis_*/Mmakefile, use the new mechanism for detecting the presence
of subdirs.
This file-specific setting will override a default setting of expandtabs
in $HOME/.vimrc.
*/Makefile:
*/Mmakefile:
As above.
tests/hard_coded/.gitignore:
Don't ignore the purity subdir. This ignore must have been left over
from when purity.m was a test in hard_coded, not hard_coded/purity,
and it ignored an executable, not a directory.
tests/debugger/declarative/Mmakefile:
On my Mac with its old 32 bit C compiler, the hex strings generated
as part of the output when printing c_pointers includes an initial
minus sign. Don't let this prevent the replacement of all such
addresses with a standard 0xXXXX.
trace/mercury_trace_spy.c:
When giving a command such as
mdb> break badfilename.m:42
and the debugger has no information about any file named "badfilename.m",
print an error message that says just that. If the file exists but the
line number doesn't, say that. Previously, the error message didn't tell
the user whether it was the filename or the line number that was in error.
trace/mercury_trace_tables.[ch]:
Collect the information that mercury_trace_spy.c needs for its new task.
tests/debugger/breakpoints.{inp,exp,exp2}:
Add a test of both kinds of bad breakpoint specification to this test case.
library/solutions.m:
Fix mode error in `solutions' predicate in the `multi' mode.
Convince the compiler with a run-time check that the solution
list will be non-empty.
Similarly for `builtin_solutions'.
tests/debugger/declarative/solns.exp3:
tests/debugger/loopcheck.exp3:
Update expected outputs.
library/exception.m:
Fix errors that prevent the module from compiling following an
upcoming change to the mode checker.
Simplify code by creating higher-order terms from multi-moded
predicates. There is no need to switch on the determinism now.
tests/debugger/declarative/catch_retry.exp:
tests/debugger/declarative/catch_retry.inp:
Update test case.
I/O tabling has two main purposes. The first and more important is to allow the
debugger to replay parts of the program execution for the programmer, which
requires making I/O operations idempotent (so that we get the same results on
the second, third etc "execution" as on the first). The second purpose is to
let the person using the debugger actually see a list of the I/O actions, and
their results.
The root of the problem here is that the compiler can do the second part
only if it has access to the type_infos describing the types of the arguments
of the I/O action. With the current infrastructure for representing typeclass
information, this is not always possible in the presence of typeclass
constraints on I/O action predicates. The reason is that polymorphism.m can
put the typeinfo for a type variable that is subject to a typeclass constraint
arbitrarily deep inside the typeclass_info for that constraint, but the RTTI
can encode such locations only up to a fixed depth (currently only the
shallowest embedded is encodable).
Before this fix, the test case for this bug got a compiler abort when the
I/O tabling transformation tried to figure out how to table the typeclass
info representing the typeclass constraint on a I/O action predicate.
We still cannot table typeclass infos. We could store them (I/O tabling
does not require anything more complicated), but the problem of deeply buried
typeinfos inside them would still remain. So this fix consists of two parts:
- for typeclass constrained I/O primitives, recording only enough information
to allow them to replayed (the first purpose above), and not to print them
out (the second purpose), and
- getting the runtime system to understand this, and not crash with a core dump
in the absence of the information required for the second purpose.
This second part requires changes to the RTTI used by I/O tabling. These
changes BREAK BINARY COMPATIBILITY in debug grades.
runtime/mercury_stack_layout.h:
Rename the MR_TableIoDecl structure as the MR_TableIoEntry structure,
since the I/O table entries that it describes are used not just for
declarative debugging, but also for printing out I/O actions.
Add a field to it that specifies whether the fields describing
the types of the I/O action's arguments are meaningful.
runtime/mercury_grade.h:
Bump the debug-only binary compatibility version number, since
the change to mercury_stack_layout.h requires it.
runtime/mercury_trace_base.[ch]:
When returning information about a tabled I/O action, return a boolean
that says whether the information abouts its arguments is actually
present or not. Do not return information about the arguments if
we cannot convert them into univs due to missing type information.
browser/io_action.m:
Pay attention to the new info returned by MR_trace_get_action,
and avoid a potential core dump by generating a description of the
requested I/O action only if the argument type information needed
to generate that description is actually available.
trace/mercury_trace_vars.c:
Pay attention to the new info returned by MR_trace_get_action.
When the argument type information needed to generate an accurate
description of the I/O action is not available, generate a
"description" that mentions this fact.
trace/mercury_trace_cmd_browsing.c:
Make the fix to mercury_trace_vars.c easier to test by adding a mechanism
to print out all existing I/O actions, as long as there aren't too many
of them.
compiler/hlds_pred.m:
compiler/layout.m:
compiler/prog_data.m:
Prepare for the possibility that we have cannot record the information
needed to reconstruct the runtime types of the arguments of a I/O tabled
predicate.
compiler/table_gen.m:
If an I/O tabled predicate has one or more typeclass constraints,
do not attempt to record the RTTI needed to reconstruct the types
of its arguments at runtime.
compiler/continuation_info.m:
compiler/hlds_data.m:
Rename some data structures that referred to the old MR_TableIoDecl
structure to refer to its replacement, the MR_TableIoEntry structure.
compiler/bytecode_gen.m:
compiler/ctgc.selector.m:
compiler/dead_proc_elim.m:
compiler/dependency_graph.m:
compiler/erl_unify_gen.m:
compiler/export.m:
compiler/higher_order.m:
compiler/hlds_code_util.m:
compiler/hlds_out_mode.m:
compiler/hlds_out_pred.m:
compiler/hlds_out_util.m:
compiler/hlds_pred.m:
compiler/implementation_defined_literals.m:
compiler/inst_check.m:
compiler/layout.m:
compiler/layout_out.m:
compiler/llds.m:
compiler/llds_out_data.m:
compiler/llds_out_file.m:
compiler/llds_out_util.m:
compiler/mercury_compile_llds_back_end.m:
compiler/mercury_to_mercury.m:
compiler/ml_global_data.m:
compiler/ml_switch_gen.m:
compiler/ml_type_gen.m:
compiler/ml_unify_gen.m:
compiler/mode_util.m:
compiler/module_qual.m:
compiler/opt_debug.m:
compiler/proc_gen.m:
compiler/prog_data.m:
compiler/prog_out.m:
compiler/prog_rep.m:
compiler/prog_type.m:
compiler/prog_util.m:
compiler/rbmm.execution_path.m:
compiler/stack_layout.m:
compiler/structure_reuse.direct.choose_reuse.m:
compiler/switch_gen.m:
compiler/switch_util.m:
compiler/type_ctor_info.m:
compiler/unify_gen.m:
compiler/unused_imports.m:
compiler/xml_documentation.m:
runtime/mercury_misc.h:
runtime/mercury_tabling.h:
Conform to the above changes.
tests/debugger/tabled_typeclass.{m,inp,exp,exp2}:
New test case to test that I/O actions that have typeclass constraints
on them can be printed in mdb.
tests/debugger/Mmakefile:
tests/debugger/Mercury.options:
Enable the new case.
Also fix some bugs in related code, and improve the related debugging
infrastructure.
-------------------
runtime/mercury_stacks.[ch]:
Fix bug 314 for temp frames created by nondet procedures. The fix will
probably also work for *det* procedures that create temp frames on the
nondet stack, but I can't think of a way to test that, because det
procedures create such frames only in very specific circumstances,
and I cannot think of a way to nest a recursive call inside those
circumstances.
The problem was that when we were creating new temp frames on
the nondet stack, we did not check whether the current nondet stack segment
had room for them. We now do.
The stack trace tracing code needs to know the size of each nondet stack
frame, since it uses the size to classify frames as temp or ordinary.
The size is given by the difference in address between the address of the
frame and the address of the previous frame. This difference would yield
an incorrect size and hence an incorrect frame classification if a temp
frame were allowed to have a frame on a different segment as its
immediate predecessor.
We prevent this by putting an ordinary (i.e. non-temp) frame at the bottom
of every new nondet stack segment as a sentinel. We hand-build this frame,
since it is not an "ordinary" ordinary frame. It is not created by a call,
so it has no meaningful success continuation, and since it does not make
any calls, no other frame's success continuation can point to it either.
If backtracking reaches this sentinel frame, we use this fact to free
all the segments beyond the one the sentinel frame is in, but keep the
frame the sentinel frame is in, since we are likely to need it again.
Document the reason why MR_incr_sp_leaf() does not have to check
whether a new stack segment is needed. (See the fix to llds_out_instr.m
below.)
runtime/mercury_stack_trace.[ch]:
When traversing the nondet stack, treat the sentinel frame specially.
We have to, since it is an ordinary frame (i.e. it is not a temp frame),
but it is not an "ordinary" ordinary frame: it does not make calls,
and hence calls cannot return to it, and it does not return to any
other frame either. It therefore does not have the layout structures
(label and proc) that the nondet stack traversal expects to find.
Fix an old bug: the nondet stack traversal used a simple directional
pointer comparison to check whether it has reached the bottom of the nondet
stack. This is NOT guaranteed to work in the presence of stack segments:
depending on exactly what addresses new stack segments get, a stack frame
can have an address BELOW the address of the initial stack frame
even if it is logically ABOVE that stack frame.
Another old bug was that a difference between two pointers, which could
be 64 bit, was stored in an int, which could be 32 bit.
The nondet stack traversal code used a similar directional comparison
to implement optionally stopping at an arbitrary point on the nondet stack.
Fixing this facility (the limit_addr parameter of MR_dump_nondet_stack)
while preserving reasonable efficiency would not be trivial, but it would
also be pointless, since the facility is not actually used. This diff
deletes the parameter instead.
Move some loop invariant code out of its loop.
trace/mercury_trace_cmd_developer.c:
trace/mercury_trace_external.c:
Don't pass the now-deleted parameter to mercury_stack_trace.c.
runtime/mercury_wrapper.c:
Record the zone of the initial nondet stack frame, since the fix
of mercury_stack_trace.c needs that info, and it is much more efficient
to set it up just once.
tests/hard_coded/bug314.{m,exp}:
The regression test for this bug.
tests/hard_coded/Mercury.options:
Compile the new test case with the options it needs.
tests/hard_coded/Mmakefile:
Enable the new test case.
-------------------
runtime/mercury_wrapper.c:
The compiler knows the number of words in a stack frame it is creating,
not necessarily the number of bytes (though it could put bounds on that
from the number of tag bits). Since this size must sync with the runtime,
change the runtime's variable holding this size to also be in words.
Note that similar changes would also be beneficial for other sizes.
compiler/llds_out_instr.m:
Conform to the change in mercury_wrapper.c, fixing an old bug
(mercury_wrapper.c reserved 128 BYTES for leaf procedures, but
llds_out_instr.m was using that space for procedures whose frames
were up to 128 WORDS in size.)
compiler/mercury_memory.c:
Conform to the change in mercury_wrapper.c.
-------------------
runtime/mercury_memory_zones.h:
Instead of starting to use EVERY zone at a different offset, do this
only for the INITIAL zones in each memory area, since only on these
is it useful. When the program first starts up, it WILL be using
the initial parts of the det stack, nondet stack and heap, so it is
useful to make sure that these do not collide in the cache. However,
when we allocate e.g. the second zone in e.g. the nondet stack, we are
no more likely to be beating on the initial part of any segment
of the det stack than on any other part of such segments.
If a new debug macro, MR_DEBUG_STACK_SEGMENTS_SET_SIZE is set (to an int),
use only that many words in each segment. This allows the segment switchover
code to be exercised and debugged with smaller test cases.
runtime/mercury_conf_param.h:
Document the MR_DEBUG_STACK_SEGMENTS_SET_SIZE macro.
Convert this file to four-space indentation with tabs expanded.
-------------------
runtime/mercury_overflow.h:
Make abort messages from overflows and underflows more useful by including
more information.
runtime/mercury_overflow.c:
Add a new function to help with the better abort messages.
Since this file did not exist before, create it.
runtime/Mmakefile:
Add the new source file to the list of source files.
-------------------
runtime/mercury_debug.[ch]:
Fix problems with the formatting of the debugging output from existing
functions.
Add new functions for dumping info about memory zones.
Factor out some common code.
Convert the header file to four-space indentation.
-------------------
runtime/mercury_grade.c:
Generate an error if stack segments are specified together with stack
extension
-------------------
trace/.gitignore:
util/.gitignore:
tests/debugger/.gitignore:
List some more files.
-------------------
runtime/mercury_context.c:
runtime/mercury_engine.[ch]:
runtime/mercury_misc.h:
compiler/notes/failure.html:
Fix white space.
On some 32-bit architectures, we were violating memory alignment
requirements for double-precision floats, in cell fields and on det and
nondet stacks. Bug #299.
We now only take the address of a double field when it occurs on an
aligned memory address, i.e. when it starts at an even word offset from
the start of a cell (this assumption is incompatible with term-size
profiling which adds a hidden word before the start of the cell).
For the det stack, we can round up allocations to keep the stack pointer
double-aligned, then allocate slots for doubles at even word offsets
from the stack pointer.
It would be trickier for the nondet stack. Multiple frame types exist
on the nondet stack, and the different frame types are identified by
their sizes: 3-word and 4-word temporary frames, and 5/6+ word ordinary
frames. Rather than rounding up frame sizes to even numbers of words,
we would probably want to dynamically pad ordinary frame allocations,
such that any doubles in the frame will be at aligned addresses.
However, in this change, we simply store box floats on the nondet stack.
compiler/globals.m:
Add predicate which returns whether double-width floats
should be stored on the det stack.
compiler/handle_options.m:
Disable double-word fields in term-size profiling grades.
compiler/code_info.m:
Add a predicate to round up det stack frame sizes.
Remember the width of floats stored on the det stack in
exprn_opts.
compiler/hlds_llds.m:
compiler/llds.m:
compiler/stack_layout.m:
Delete the possibility of double-width slots on the nondet
stack.
Remember det_stack_float_width in exprn_opts.
compiler/llds_out_data.m:
Add wrapper macro `MR_dword_ptr' when taking the address of a
double.
Only take the address of doubles on the det stack.
compiler/llds_out_instr.m:
compiler/llds_out_util.m:
Only assign a double field in a single C statement when it is
aligned.
Assert that the stack pointer is incremented by an even number,
if necessary.
compiler/mlds_to_c.m:
Only take the address of doubles when aligned.
compiler/middle_rec.m:
compiler/proc_gen.m:
Round up det stack frame allocations to even numbers of words
when necessary.
compiler/stack_alloc.m:
Add padding as required so that double-word variables will
be allocated at even-word offsets from the stack pointer.
compiler/opt_debug.m:
compiler/par_conj_gen.m:
Conform to changes.
runtime/mercury_conf_param.h:
runtime/mercury_float.h:
Add macro `MR_dword_ptr' to be wrapped around instances where
the address of a double is taken. When `MR_DEBUG_DWORD_ALIGNMENT'
is defined (and using gcc or clang) the address is checked to be
properly aligned. Almost all our development is done on x86 or
x86-64 architecture which do not have strict memory alignment
requirements, making violations hard to check otherwise.
runtime/mercury_deconstruct.c:
runtime/mercury_layout_util.c:
Use `MR_float_from_dword' over `MR_float_from_dword_ptr' as the
former does not require dword alignment.
Related fix: looking up `double' variables on the nondet stack
used the stack pointer for the det stack instead. Fix it,
though the code now won't be executed after this change.
tests/debugger/nondet_stack.exp5:
Add new expected output. This is the same as nondet_stack.exp
except that det stack frames have been rounded up.
A number of patterns and filenames where missing from .gitignore files,
especially in the tests/ directory.
.gitignore:
boehm_gc/.gitignore:
boehm_gc/libatomic_ops/pkgconfig/.gitignore:
runtime/.gitignore:
scripts/.gitignore:
tests/.gitignore:
tests/analysis/table/.gitignore:
tests/analysis/trail/.gitignore:
tests/benchmarks/.gitignore:
tests/debugger/.gitignore:
tests/invalid/.gitignore:
tests/mmc_make/.gitignore:
tests/mmc_make/lib/.gitignore:
Add new patterns to .gitignore files.
Remove some patterns that are implicit because they're in a parent
directory's file.
tests/analysis/.gitignore:
After removing superfluous patterns this file was empty. I've deleted
it.
tests/debugger/declarative/builtin_call_rep.exp:
The current definition of the proc_defn_rep structure has
an additional field.
tests/debugger/declarative/condition_bug.m:
Replace the use of the now-deleted svmap module.
tests/debugger/declarative/condition_bug.exp:
Update this to conform to the current definition of the
I/O state in C grades.
tests/Makefile.tests:
Delete an old Makefile that was resurrected during the
conversion from SVN.
tests/debugger/interactive.exp2:
Delete a file that is not being used.
Estimated hours taken: 120
Branches: main
The algorithm that decides whether the order independent state update
transformation is applicable in a given module needs access to the list
of oisu pragmas in that module, and to information about the types
of variables in the procedures named in those pragmas. This diff
puts this information in Deep.procrep files, to make them available
to the autoparallelization feedback program, to which that algorithm
will later be added.
Compilers that have this diff will generate Deep.procrep files in a new,
slightly different format, but the deep profiler will be able to read
Deep.procrep files not just in the new format, but in the old format as well.
runtime/mercury_stack_layout.h:
Add to module layout structures the fields holding the new information
we want to put into Deep.procrep files. This means three things:
- a bytecode array in module layout structures encoding the list
of oisu pragmas in the module;
- additions to the bytecode arrays in procedure layout structures
mapping the procedure's variables to their types; and
- a bytecode array containing the encoded versions of those types
themselves in the module layout structure. This allows us to
represent each type used in the module just once.
Since there is now information in module layout structures that
is needed only for deep profiling, as well as information that is
needed only for debugging, the old arrangement that split a module's
information between two structures, MR_ModuleLayout (debug specific
info) and MR_ModuleCommonLayout (info used by both debugging and
profiling), is no longer approriate. We could add a third structure
containing profiling-specific info, but it is simpler to move
all the info into just one structure, some of whose fields
may not be used. This wastes only a few words of memory per module,
but allows the runtime system to avoid unnecessary indirections.
runtime/mercury_types.h:
Remove the type synonym for the deleted type.
runtime/mercury_grade.h:
The change in mercury_stack_layout.h destroys binary compatibility
with previous versions of Mercury for debug and deep profiling grades,
so bump their grade-component-specific version numbers.
runtime/mercury_deep_profiling.c:
Write out the information in the new fields in module layout
structures, if they are filled in.
Since this changes the format of the Deep.procrep file, bump
its version number.
runtime/mercury_deep_profiling.h:
runtime/mercury_stack_layout.c:
Conform to the change to mercury_stack_layout.h.
mdbcomp/program_representation.m:
Add to module representations information about the oisu pragmas
defined in that module, and the type table of the module.
Optionally add to procedure representations a map mapping
the variables of the procedure to their types.
Rename the old var_table type to be the var_name_table type,
since it contains just names. Make the var to type map separate,
since it will be there only for selected procedures.
Modify the predicates reading in module and procedure representations
to allow them to read in the new representation, while still accepting
the old one. Use the version number in the Deep.procrep file to decide
which format to expect.
mdbcomp/rtti_access.m:
Add functions to encode the data representations that this module
also decodes.
Conform to the changes above.
mdbcomp/feedback.automatic_parallelism.m:
Conform the changes above.
mdbcomp/prim_data.m:
Fix layout.
compiler/layout.m:
Update the compiler's representation of layout structures
to conform to the change to runtime/mercury_stack_layout.h.
compiler/layout_out.m:
Output the new parts of module layout structures.
compiler/opt_debug.m:
Allow the debugging of code referring to the new parts of
module layout structures.
compiler/llds_out_file.m:
Conform to the move to a single module layout structure.
compiler/prog_rep_tables.m:
This new module provided mechanisms for building the string table
and the type table components of module layouts. The string table
part is old (it is moved here from stack_layout.m); the type table
part is new.
Putting this code in a module of its own allows us to remove
a circular dependency between prog_rep.m and stack_layout.m;
instead, both now just depend on prog_rep_tables.m.
compiler/ll_backend.m:
Add the new module.
compiler/notes/compiler_design.html:
Describe the new module.
compiler/prog_rep.m:
When generating the representation of a module for deep profiling,
include the information needed by the order independent state update
analysis: the list of oisu pragmas in the module, if any, and
information about the types of variables in selected procedures.
To avoid having these additions increasing the size of the bytecode
representation too much, convert some fixed 32 bit numbers in the
bytecode to use variable sized numbers, which will usually be 8 or 16
bits.
Do not use predicates from bytecode_gen.m to encode numbers,
since there is nothing keeping these in sync with the code that
reads them in mdbcomp/program_representation.m. Instead, use
new predicates in program_representation.m itself.
compiler/stack_layout.m:
Generate the new parts of module layouts.
Remove the code moved to prog_rep_tables.m.
compiler/continuation_info.m:
compiler/proc_gen.m:
Make some more information available to stack_layout.m.
compiler/prog_data.m:
Fix some formatting.
compiler/introduce_parallelism.m:
Conform to the renaming of the var_table type.
compiler/follow_code.m:
Fix the bug that used to cause the failure of the
hard_coded/mode_check_clauses test case in deep profiling grades.
deep_profiler/program_representation_utils.m:
Output the new parts of module and procedure representations,
to allow the correctness of this change to be tested.
deep_profiler/mdprof_create_feedback.m:
If we cannot read the Deep.procrep file, print a single error message
and exit, instead of continuing with an analysis that will generate
a whole bunch of error messages, one for each attempt to access
a procedure's representation.
deep_profiler/mdprof_procrep.m:
Give this program an option that specifies what file it is to
look at; do not hardwire in "Deep.procrep" in the current directory.
deep_profiler/report.m:
Add a report type that just prints the representation of a module.
It returns the same information as mdprof_procrep, but from within
the deep profiler, which can be more convenient.
deep_profiler/create_report.m:
deep_profiler/display_report.m:
Respectively create and display the new report type.
deep_profiler/query.m:
Recognize a query asking for the new report type.
deep_profiler/autopar_calc_overlap.m:
deep_profiler/autopar_find_best_par.m:
deep_profiler/autopar_reports.m:
deep_profiler/autopar_search_callgraph.m:
deep_profiler/autopar_search_goals.m:
deep_profiler/autopar_types.m:
deep_profiler/branch_and_bound.m:
deep_profiler/coverage.m:
deep_profiler/display.m:
deep_profiler/html_format.m:
deep_profiler/mdprof_test.m:
deep_profiler/measurements.m:
deep_profiler/query.m:
deep_profiler/read_profile.m:
deep_profiler/recursion_patterns.m:
deep_profiler/top_procs.m:
deep_profiler/top_procs.m:
Conform to the changes above.
Fix layout.
tests/debugger/declarative/dependency.exp2:
Add this file as a possible expected output. It contains the new
field added to module representations.
Estimated hours taken: 30
Branches: main
Give the Mercury debugger the ability to detect cliques of mutually recursive
predicates on the stack. Exploit this ability to enhance the debugger's
level, retry, finish and stack commands.
runtime/mercury_stack_trace.[ch]:
Add a function, MR_find_clique_entry, that detects the clique
that contains the top stack frame. This is used to implement the new
arguments "clentry" and "clparent" (short for clique entry and parent)
options of the level, retry and finish commands. "clique" is a synonym
for "clentry" in these commands.
Add a function, MR_dump_stack_layout_clique, that implements the
new capabilities of the stack command. It can detect more than one
clique, anywhere on the stack.
To make this possible, modify the existing functions for printing
the lines of stack traces. These used to keep some information around
between calls in global variables. Now that information is stored in
two structures that the caller passes them. One contains the parameters
that govern what is to be printed, the other contains information about
what has been buffered up to be printed, but has not been flushed yet.
(The old code was confused in its handling of parameters. Some parts
of it looked up the global variables storing them, while other parts
were given the parameter values by their callers, values that could
have been -but weren't- inconsistent.)
Change the buffer flushing code to be idempotent, since in the new
code, sometimes it is hard to avoid flushing the buffer more than once,
and we want only the first to print its contents.
Make some type names conform to our standard style.
runtime/mercury_stack_layout.h:
Add a new flag in MR_ProcLayouts: a flag that indicates that the
procedure has one or more higher order arguments. The new code in
mercury_stack_trace.c handles procedures with this flag specially:
it does not consider two non-consecutive occurrences of such procedures
on the stack to be necessarily part of the same clique. This is to
avoid having two calls to e.g. list.map in different part of the
program pulling all the procedures between those parts on the stack
into a single clique. (The deep profiler has a very similar tweak.)
Add a pointer to the corresponding part of the compiler.
compiler/hlds_pred.m:
Add a predicate to test whether a predicate has any higher order args.
compiler/stack_layout.m:
When computing the flag in proc layouts, call the new procedure in
hlds_pred.m to help figure it out.
trace/mercury_trace_cmd_backward.c:
Implement the new options of the "retry" command.
trace/mercury_trace_cmd_forward.c:
Implement the new options of the "finish" command.
trace/mercury_trace_cmd_browsing.c:
Implement the "new options of the "level" command.
Implement the new functionality of the "stack" command.
trace/mercury_trace_util.[ch]:
Add some code common to the implementations of the level, retry and
finish commands.
trace/mercury_trace_external.c:
Conform to the changes to the runtime.
doc/user_guide.texi:
Document the debugger's new capabilities.
NEWS:
Announce the debugger's new capabilities.
tests/debugger/mutrec.{m,inp,exp}:
A new test case to test the handling of the stack command
in the presence of cliques.
tests/debugger/mutrec_higher_order.{m,inp,exp}:
A new test case to test the handling of the stack command
in the presence of cliques and higher order predicates.
tests/debugger/Mmakefile:
Enable both new test cases.
Branches: main
Allow the use of Mercury abstract machine float registers for passing
double-precision float arguments in higher order calls.
In of itself this is not so useful for typical Mercury code. However, as
all non-local procedures are potentially the targets of higher order calls,
without this change first order calls to non-local procedures could not use
float registers either. That is the actual motivation for this change.
The basic mechanism is straightforward. As before, do_call_closure_* is
invoked to place the closure's hidden arguments into r1, ..., rN, and extra
input arguments shifted into rN+1, etc. With float registers, extra input
arguments may also be in f1, f2, etc. and the closure may also have hidden
float arguments. Optimising for calls, we order the closure's hidden
arguments so that all float register arguments come after all regular
register arguments in the vector. Having the arguments out of order does
complicate code which needs to deconstruct closures, but that is not so
important.
Polymorphism complicates things. A closure with type pred(float) may be
passed to a procedure expecting pred(T). Due to the `float' argument type,
the closure expects its argument in a float register. But when passed to the
procedure, the polymorphic argument type means it would be called with the
argument in a regular register.
Higher-order insts already contain information about the calling convention,
without which a higher-order term cannot be called. We extend higher-order
insts to include information about the register class required for each
argument. For example, we can distinguish between:
pred(in) is semidet /* arg regs: [reg_f] */
and
pred(in) is semidet /* arg regs: [reg_r] */
Using this information, we can create a wrapper around a higher-order
variable if it appears in a context requiring a different calling convention.
We do this in a new HLDS pass, called float_regs.m.
Note: Mercury code has a tendency to lose insts for higher-order terms, then
"recover" them by hacky means. The float_regs pass depends on higher-order
insts; it is impossible to create a wrapper for a procedure without knowing
how to call it. The float_regs pass will report errors which we otherwise
accepted, due to higher-order insts being unavailable. It should be possible
for the user to adjust the code to satisfy the pass, though the user may not
understand why it should be necessary. In most cases, it probably really
*is* unnecessary. We may be able to make the float_regs pass more tolerant
of missing higher-order insts in the future.
Class method calls do not use float registers because I didn't want to deal
with them yet.
compiler/options.m:
compiler/handle_options.m:
Always enable float registers in low-level C grades when floats are
wider than a word.
compiler/make_hlds_passes.m:
Always allow double word floats to be stored unboxed in cells on C
grades.
compiler/hlds_goal.m:
Add an extra field to `generic_call' which gives the register class
to use for each argument. This is set by the float_regs pass.
compiler/prog_data.m:
Add an extra field to `pred_inst_info' which records the register class
to use for each argument. This is set by the float_regs pass.
compiler/hlds_pred.m:
Add a field to `proc_sub_info' which lists the headvars which must be
passed via regular registers despite their types.
Add a field to `pred_sub_info' to record the original unsubstituted
argument types for instance method predicates.
compiler/check_typeclass.m:
In the pred_info of an instance method predicate, record the original
argument types before substituting the type variables for the instance.
compiler/float_regs.m:
compiler/transform_hlds.m:
Add the new HLDS pass.
compiler/mercury_compile_middle_passes.m:
Run the new pass if float registers are enabled.
compiler/lambda.m:
Export the predicate to produce a predicate from a lambda.
This is reused by float_regs.m to create wrapper closures.
Add an argument to `expand_lambda' to set the reg_r_headvars field on
the newly created procedure.
Delete some unused fields from `lambda_info'.
compiler/arg_info.m:
Make `generate_proc_arg_info' no longer always use regular registers
for calls to exported procedures. Do always use regular registers for
class methods calls.
Add a version of `make_arg_infos' which takes an explicit list of
argument registers. Rename the previous version.
Add `generic_call_arg_reg_types' to return the argument registers
for a generic call.
Add a version of `compute_in_and_out_vars' which additionally separates
arguments for float and regular registers.
compiler/call_gen.m:
Use float registers for argument passing in higher-order calls, as
directed by the new field in `generic_call'.
compiler/code_util.m:
Add a function to encode the number of regular and float register
arguments when making a higher-order call.
compiler/llds.m:
Say that the `do_call_closure_N' functions only work for zero float
register arguments.
compiler/follow_vars.m:
compiler/interval.m:
Account for the use of float registers by generic call goals in these
passes.
compiler/unify_gen.m:
Move float register arguments to the end of a closure's hidden
arguments vector, after regular register arguments.
Count hidden regular and float register arguments separately, but
encode them in the same word in the closure. This is preferable to
using two words because it reduces the differences between grades
with and without float registers present.
Disable generating code which creates a closure from an existing
closure, if float registers exist. That code does not understand the
reordered hidden arguments vector yet.
compiler/continuation_info.m:
Replace an argument's type_info in the closure layout if the argument
is a float *and* is passed via a regular register, when floats are
normally passed via float registers. Instead, give it the type_info
for `private_builtin.float_box'.
compiler/builtin_lib_types.m:
Add function to return the type of `private_builtin.float_box/0'.
compiler/hlds_out_goal.m:
compiler/hlds_out_pred.m:
compiler/mercury_to_mercury.m:
Dump the new fields added to `generic_call', `pred_inst_info' and
`proc_sub_info'.
compiler/prog_type.m:
Add helper predicate.
compiler/*.m:
Conform to changes.
library/private_builtin.m:
Add a type `float_box'.
runtime/mercury_ho_call.h:
Describe the modified closure representation.
Rename the field which counts the number of hidden arguments to prevent
it being used incorrectly, as it now encodes two numbers (potentially).
Add macros to unpack the encoded field.
runtime/mercury_ho_call.c:
Update the description of how higher-order calls work.
Update code which extracts closure arguments to take account the
arguments being reordered in the hidden arguments vector.
runtime/mercury_deep_copy.c:
runtime/mercury_deep_copy_body.h:
runtime/mercury_layout_util.c:
runtime/mercury_ml_expand_body.h:
Update code which extracts closure arguments to take account the
arguments being reordered in the hidden arguments vector.
runtime/mercury_type_info.c:
runtime/mercury_type_info.h:
Add helper function.
tools/make_spec_ho_call:
Update the generated do_call_closure_* functions to place float
register arguments.
tests/hard_coded/Mercury.options:
tests/hard_coded/Mmakefile:
tests/hard_coded/ho_float_reg.exp:
tests/hard_coded/ho_float_reg.m:
Add new test case.
tests/hard_coded/copy_pred.exp:
tests/hard_coded/copy_pred.m:
tests/hard_coded/deconstruct_arg.exp:
tests/hard_coded/deconstruct_arg.exp2:
tests/hard_coded/deconstruct_arg.m:
Extend test cases with float arguments in closures.
tests/debugger/higher_order.exp2:
Add alternative output, changed due to closure wrapping.
tests/hard_coded/ho_univ_to_type.m:
Adjust test case so that the float_regs pass does not report errors
about missing higher-order insts.
compiler/notes/compiler_design.html:
Describe the new module.
Delete a duplicated paragraph.
compiler/notes/todo.html:
TODO:
Delete one hundred billion year old todos.
