mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-20 11:54:02 +00:00
083d376e6598628362ee91c2da170febd83590f4
53 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Zoltan Somogyi
|
a47de48c4d |
s/input_stream/text_input_stream/ ...
... and the same for output streams. |
||
|
Zoltan Somogyi
|
9047bdbf05 |
Improve programming style in the browser directory.
browser/declarative_analyser.m:
browser/declarative_debugger.m:
browser/declarative_oracle.m:
browser/declarative_tree.m:
browser/declarative_user.m:
browser/interactive_query.m:
browser/listing.m:
browser/parse.m:
browser/util.m:
Rename some predicates to avoid ambiguity.
Factor out common code.
If some versions of a field of a structure have names in a predicate
(by being stored in a named variable), then give all *other* versions
of that field in that structure names in that predicate as well.
If a field of a structure is used more than once in a predicate,
then again, store it in a named variable.
Reorder predicate arguments to put state variables last.
Use io.format instead of sequences of calls to io.write_string.
In declarative_user.m, note a probable bug (in a position where
it is probably rarely stumbled upon).
In listing.m, use a consistent naming scheme to differentiate
between Mercury streams and their C counterparts.
Replace if-then-else chains with switches where possible.
browser/name_mangle.m:
Note bit rot.
browser/browse.m:
Conform to the changes above.
library/io.m:
Improve predicate and variable names.
browser/mdb.m:
browser/mer_browser.m:
browser/percent_encoding.m:
browser/term_rep.m:
browser/tree234_cc.m:
library/library.m:
Improve comments.
|
||
|
Zoltan Somogyi
|
06f81f1cf0 |
Add end_module declarations ...
.. to modules which did not yet have them. |
||
|
Zoltan Somogyi
|
fdef49a9c6 | Improve the wording of comments. | ||
|
Zoltan Somogyi
|
eeb69f14ba |
Use explicit streams in browser/*.m.
browser/browse.m:
browser/browser_info.m:
browser/collect_lib.m:
browser/declarative_debugger.m:
browser/declarative_oracle.m:
browser/declarative_user.m:
browser/diff.m:
browser/help.m:
browser/interactive_query.m:
browser/parse.m:
browser/util.m:
Replace implicit streams with explicit streams.
Shorten lines longer than 79 chars.
In some places, simplify some code, often using constructs such as
string.format that either did not exist or were too expensive to use
when the original code was written.
In some places, change predicate names that were not meaningful
without module qualification by *including* the module qualification
in the name (e.g. init -> browser_info_init).
In some places, add XXXs.
In browser_info.m, make the output stream *part* of the debugger type,
because without this, having the debugger type belong to the stream
typeclass does NOT make sense. (The typeclass instance for debugger
used to always write to the current output stream, which this diff
is replacing with the use of explicitly specified streams.)
In browse.m, consistently put stream arguments before other arguments.
In browse.m, when exporting Mercury predicates to C, export them
under names with the standard ML_BROWSE_ prefix, NOT under the name
of a *different* predicate with that prefix.
In diff.m, eliminate an unnecessary difference between what we print
when the difference between two terms is at the root, vs what we print
when the difference between two terms is lower down.
In interactive_query.m, when trying to write a program out to a file,
do NOT write the program to the current output stream if we cannot open
the file, since that would accomplish nothing useful.
Also in interactive_query.m, cleanup .dylib instead of .so on MacOS.
In util.m, delete some unused predicates.
In collect_lib.m, document why some code is not worth updating.
In declarative_oracle.m, rename predicates with previously-ambiguous
names.
browser/MDBFLAGS.in:
Specify --warn-implicit-stream-calls for all Mercury modules
in the browser directory from now.
trace/mercury_trace_browse.c:
trace/mercury_trace_cmd_browsing.c:
ssdb/ssdb.m:
Conform to the changes in browser/*.m.
tests/debugger/queens.{exp,exp2}:
Expect the extra output from browser/diff.m.
|
||
|
Zoltan Somogyi
|
e08b8505e9 | Import the parents of *all* imported modules. | ||
|
Zoltan Somogyi
|
4d37389b7a | Reorder structure args to enable better packing. | ||
|
Mark Brown
|
d465fa53cb |
Update the COPYING.LIB file and references to it.
Discussion of these changes can be found on the Mercury developers
mailing list archives from June 2018.
COPYING.LIB:
Add a special linking exception to the LGPL.
*:
Update references to COPYING.LIB.
Clean up some minor errors that have accumulated in copyright
messages.
|
||
|
Zoltan Somogyi
|
6ea8406ac8 |
Fix more warnings from --warn-inconsistent-pred-order-clauses.
browser/browse.m:
browser/browser_info.m:
browser/collect_lib.m:
browser/debugger_interface.m:
browser/declarative_analyser.m:
browser/declarative_debugger.m:
browser/declarative_edt.m:
browser/declarative_execution.m:
browser/declarative_oracle.m:
browser/declarative_test.m:
browser/declarative_tree.m:
browser/declarative_user.m:
browser/diff.m:
browser/dl.m:
browser/frame.m:
browser/help.m:
browser/interactive_query.m:
browser/io_action.m:
browser/listing.m:
browser/mdb.m:
browser/mer_browser.m:
browser/name_mangle.m:
browser/term_rep.m:
browser/tree234_cc.m:
Fix inconsistencies between (a) the order in which functions and predicates
are declared, and (b) the order in which they are defined.
In most modules, either the order of the declarations or the order
of the definitions made sense, and I changed the other to match.
In some modules, neither made sense, so I changed *both* to an order
that *does* make sense (i.e. it has related predicates together).
In some places, put dividers between groups of related
functions/predicates, to make the groups themselves more visible.
In some places, fix comments or programming style.
browser/MDB_FLAGS.in:
Since all the modules in this directory are now free from any warnings
generated by --warn-inconsistent-pred-order-clauses, specify that option
by default in this directory to keep it that way.
|
||
|
Zoltan Somogyi
|
0821b301f2 |
Require that types/insts/modes in interfaces be defined in the interface.
compiler/module_qual.m:
The interface of a module A contains items (e.g. predicate declarations)
that refer to entities such as types, insts, modes etc. They may refer
to those entities if (a) they are defined in the interface of module A,
(b) in a parent module of module A, or (c) if they are imported from
another module, module B, which is imported into module A in the interface
of module A.
The old algorithm that attempted to enforce this requirement had a basic
design fault: it based the decision as to whether the use of an entity
in the interface was legal solely on the name of the module that defined
that entity. This correctly implements tests (b) and (c), but it does
not even attempt to implement the interface test part of (a).
It therefore allowed exported items to refer to nonexported entities.
This diff changes the whole design approach to the test. Instead of
keeping a list of modules *all* of whose entities may be used in the
interface of the current module, record for *every* entity whether
it may be used in the interface. Set the permissions differently
in the interface and implementation sections of the current module.
Improve the formatting of the ambiguity error message.
NEWS:
Announce the stricter enforcement of the documented language rules,
in a new section for potentially compatibility-breaking changes.
compiler/check_typeclass.m:
Delete a test for a special case of the situation that module_qual.m
now tests for. If this problem occurs, module_qual.m will pick it up,
and check_typeclass.m will never even be invoked, so this copy of the test
can never succeed.
library/hash_table.m:
Fix code that violated the language rules: we export a type that
includes another type, but didn't export the second type. We now do.
browser/declarative_analyser.m:
browser/declarative_edt.m:
compiler/coverage_profiling.m:
Fix code that violated the language rules. We used to export predicates
and functions whose argument types included nonexported types. As it
happens, none of those predicates and functions actually need to be
exported, so keep them private.
In coverage_profiling.m, don't abstract export a type that is not
used outside the module, and give a function a name that doesn't
clash with a type name.
tests/invalid/bug17.{m,err_exp}:
A new test case to test the error message we get if the module interface
refers to a nonexported type.
tests/invalid/bad_instance.err_exp:
This test case used to get two kinds of errors, one of which was
the illegal use of nonexported type in an exported abstract instance
declaration. We now discover this error earlier, and stop after we
do so. Update the expected error message.
tests/invalid/bad_instance2.{m,err_exp}:
New test case: a modified copy of bad_instance.m, testing the other
kind of error originally tested by bad_instance.m.
tests/invalid/instance_no_type.err_exp:
Update the expected error message.
tests/invalid/Mmakefile:
Enable the new test cases.
tests/benchmarks/query.m:
tests/hard_coded/unused_float_box_test.m:
tests/valid/bug300.m:
tests/valid/deforest_bug.m:
tests/valid/higher_order4.m:
tests/valid/lambda_recompute.m:
tests/valid/mert.m:
tests/valid/reuse_static.m:
tests/valid/switch_detection_bug2.m:
tests/valid/time_yaowl.m:
tests/warnings/unused_args_test.m:
Fix code that violated the language rules, typically by exporting
the type that previously, we illegally used in the module interface.
tests/recompilation/add_type_re.err_exp.2:
Expect the updated ambiguity error message.
|
||
|
Zoltan Somogyi
|
62ec97d443 |
Report imports shadowed by other imports.
If a module has two or more import_module or use_module declarations
for the same module, (typically, but not always, one being in its interface
and one in its implementation), generate an informational message about
each redundant declaration if --warn-unused-imports is enabled.
compiler/hlds_module.m:
We used to record the set of imported/used modules, and the set of
modules imported/used in the interface of the current module. However,
these sets
- did not record the distinction between imports and uses;
- did not allow distinction between single and multiple imports/uses;
- did not record the locations of the imports/uses.
The first distinction was needed only by module_qual.m, which *did*
pay attention to it; the other two were not needed at all.
To generate messages for imports/uses shadowing other imports/uses,
we need all three, so change the data structure storing such information
for *direct* imports to one that records all three of the above kinds
of information. (For imports made by read-in interface and optimization
files, the old set of modules approach is fine, and this diff leaves
the set of thus *indirectly* imported module names alone.)
compiler/unused_imports.m:
Use the extra information now available to generate a
severity_informational message about any import or use that is made
redundant by an earlier, more general import or use.
Fix two bugs in the code that generated warnings for just plain unused
modules.
(1) It did not consider that a use of the builtin type char justified
an import of char.m, but without that import, the type is not visible.
(2) It scanned cons_ids in goals in procedure bodies, but did not scan
cons_ids that have been put into the const_struct_db. (I did not update
the code here when I added the const_struct_db.)
Also, add a (hopefully temporary) workaround for a bug in
make_hlds_passes.m, which is noted below.
However, there are at least three problems that prevent us from enabling
--warn-unused-imports by default.
(1) In some places, the import of a module is used only by clauses for
a predicate that also has foreign procs. When compiled in a grade that
selects one of those foreign_procs as the implementation of the predicate,
the clauses are discarded *without* being added to the HLDS at all.
This leads unused_imports.m to generate an uncalled-for warning in such
cases. To fix this, we would need to preserve the Mercury clauses for
*all* predicates, even those with foreign procs, and do all the semantic
checks on them before throwing them away. (I tried to do this once, and
failed, but the task should be easier after the item list change.)
(2) We have two pieces of code to generate import warnings. The one in
unused_imports.m operates on the HLDS after type and mode checking,
while module_qual.m operates on the parse tree before the creation of
the HLDS. The former is more powerful, since it knows e.g. what types and
modes are used in the bodies of predicates, and hence can generate warnings
about an import being unused *anywhere* in a module, as opposed to just
unused in its interface.
If --warn-unused-imports is enabled, we will get two separate set of
reports about an interface import being unused in the interface,
*unless* we get a type or mode error, in which case unused_imports.m
won't be invoked. But in case we do get such errors, we don't want to
throw away the warnings from module_qual.m. We could store them and
throw them away only after we know we won't need them, or just get
the two modules to generate identical error_specs for each warning,
so that the sort_and_remove_dups of the error specs will do the
throwing away for us for free, if we get that far.
(3) The valid/bug100.m test case was added as a regression test for a bug
that was fixed in module_qual.m. However the bug is still present in
unused_imports.m.
compiler/make_hlds_passes.m:
Give hlds_module.m the extra information it now needs for each item_avail.
Add an XXX for a bug that cannot be fixed right now: the setting of
the status of abstract instances to abstract_imported. (The "abstract"
part is correct; the "imported" part may not be.)
compiler/intermod.m:
compiler/try_expand.m:
compiler/xml_documentation.m:
Conform to the change in hlds_module.m.
compiler/module_qual.m:
Update the documentation of the relationship of this module
with unused_imports.m.
compiler/hlds_data.m:
Document a problem with the status of instance definitions.
compiler/hlds_out_module.m:
Update the code that prints out the module_info to conform to the change
to hlds_module.m.
Print status information about instances, which was needed to diagnose
one of the bugs in unused_imports.m. Format the output for instances
nicer.
compiler/prog_item.m:
Add a convenience predicate.
compiler/prog_data.m:
Remove a type synonym that makes things harder to understand, not easier.
compiler/modules.m:
Delete an XXX that asks for the feature this diff implements.
Add another XXX about how that feature could be improved.
compiler/Mercury.options.m:
Add some more modules to the list of modules on which the compiler
should be invoked with --no-warn-unused-imports.
compiler/*.m:
library/*.m:
mdbcomp/*.m:
browser/*.m:
deep_profiler/*.m:
mfilterjavac/*.m:
Delete unneeded imports. Many of these shadow other imports, and some
are just plain unneeded, as shown by --warn-unused-imports. In a few
modules, there were a *lot* of unneeded imports, but most had just
one or two.
In a few cases, removing an import from a module, because it *itself*
does not need it, required adding that same import to those of its
submodules which *do* need it.
In a few cases, conform to other changes above.
tests/invalid/Mercury.options:
Test the generation of messages about import shadowing on the existing
import_in_parent.m test case (although it was also tested very thoroughly
when giving me the information needed for the deletion of all the
unneeded imports above).
tests/*/*.{m,*exp}:
Delete unneeded imports, and update any expected error messages
to expect the now-smaller line numbers.
|
||
|
Zoltan Somogyi
|
ef6761f508 | Bring the programming style of browser/*.m up-to-date. | ||
|
Zoltan Somogyi
|
500948d549 |
Break up mdbcomp/prim_data.m. The new modules have much better cohesion.
mdbcomp/sym_name.m:
New module, containing the part of the old prim_data.m that
dealt with sym_names.
mdbcomp/builtin_modules.m:
New module, containing the part of the old prim_data.m that
dealt with builtin modules.
mdbcomp/prim_data.m:
Remove the things that are now in the two new modules.
mdbcomp/mdbcomp.m:
deep_proiler/Mmakefile:
slice/Mmakefile:
Add the two new modules.
browser/*.m:
compiler/*.m:
deep_proiler/*.m:
mdbcomp/*.m:
slice/*.m:
Conform to the above changes.
|
||
|
Julien Fischer
|
78b0bf3c7f |
Use state variable field update syntax in more places.
Branches: main Use state variable field update syntax in more places. browser/*.m: compiler/*.m: deep_profiler/*.m: As above. |
||
|
Zoltan Somogyi
|
672f77c4ec |
Add a new compiler option. --inform-ite-instead-of-switch.
Estimated hours taken: 20 Branches: main Add a new compiler option. --inform-ite-instead-of-switch. If this is enabled, the compiler will generate informational messages about if-then-elses that it thinks should be converted to switches for the sake of program reliability. Act on the output generated by this option. compiler/simplify.m: Implement the new option. Fix an old bug that could cause us to generate warnings about code that was OK in one duplicated copy but not in another (where a switch arm's code is duplicated due to the case being selected for more than one cons_id). compiler/options.m: Add the new option. Add a way to test for the bug fix in simplify. doc/user_guide.texi: Document the new option. NEWS: Mention the new option. library/*.m: mdbcomp/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: Convert if-then-elses to switches at most of the sites suggested by the new option. At the remaining sites, switching to switches would have nontrivial downsides. This typically happens with the switched-on type has many functors, and we treat one or two specially (e.g. cons/2 in the cons_id type). Perform misc cleanups in the vicinity of the if-then-else to switch conversions. In a few cases, improve the error messages generated. compiler/accumulator.m: compiler/hlds_goal.m: (Rename and) move insts for particular kinds of goal from accumulator.m to hlds_goal.m, to allow them to be used in other modules. Using these insts allowed us to eliminate some if-then-elses entirely. compiler/exprn_aux.m: Instead of fixing some if-then-elses, delete the predicates containing them, since they aren't used, and (as pointed out by the new option) would need considerable other fixing if they were ever needed again. compiler/lp_rational.m: Add prefixes to the names of the function symbols on some types, since without those prefixes, it was hard to figure out what type the switch corresponding to an old if-then-else was switching on. tests/invalid/reserve_tag.err_exp: Expect a new, improved error message. |
||
|
Zoltan Somogyi
|
519d8f9508 |
Fix a bug in the handling of I/O actions by the debugger: the procedural
Estimated hours taken: 12
Branches: main
Fix a bug in the handling of I/O actions by the debugger: the procedural
debugger didn't implement the documented commands for printing I/O actions.
Also implement some new variants of the print commands to make it easier
to print I/O actions.
Also track down and pinpoint a bug that caused the declarative debugger
to ask questions from *outside* the tree it was asked to debug, as shown
by this example from a new test case compiled in a decldebug grade (so that
the library, and thus io.read, gets compiled with deep, not shallow tracing):
-----------------------------------------------------------------------------
mdb ./io_read_bug
1: 1 1 CALL pred io_read_bug.main/2-0 (cc_multi) io_read_bug.m:22
I/O tabling started.
mdb> g 4
Please input the number of queens and a period:
4: 3 2 CALL pred io.read/3-0 (det) io.m:4240 (io_read_bug.m:24)
mdb> f
5.
513: 3 2 EXIT pred io.read/3-0 (det) io.m:4240 (io_read_bug.m:24)
mdb> dd
[1, 3, 5, 2, 4]
main(_, _)
31 tabled IO actions: too many to show
Valid?
-----------------------------------------------------------------------------
browser/declarative_tree.m:
Put an XXX at the spot of the second bug.
browser/declarative_analyser.m:
browser/declarative_debugger.m:
Change the formatting of some code to give consistent and more
meaningful names to some arguments, and to make switches easier
to read. There are no algorithmic changes.
runtime/mercury_trace_base.[ch]:
Move the code for disabling/enabling deep profiling to the code that
does disabling/enabling of I/O actions, to put all relevant actions
for entering and leaving Mercury code together.
Note the similarity of MR_turn_debug_off/MR_turn_debug_back_on
with MR_TRACE_CALL_MERCURY, and make the similarity even greater
by adding the code for disabling/enabling deep profiling to
MR_TRACE_CALL_MERCURY (without which the deep profiler data structures
would have been screwed up by the declarative debugger).
Add a const qualifier to an argument.
trace/mercury_trace_cmd_browsing.c:
Fix the first bug: update the code of the "print" and "browse" mdb
commands to implement their documented capabilities with respect to
printing I/O actions.
Add a new capability: "print io" (or "print action") will now print
a bunch of I/O actions, starting with the first available one, and on
successive invocations will print successive bunches. This is an easy
way to print all I/O actions (without being overwhelmed by a huge
printout if there are too many).
Add a new capability: "print io limits" will now print the numbers of
the first and last I/O actions.
doc/user_guide.texi:
Document the new capabilities.
trace/mercury_trace_declarative.c:
Fix the second bug: disable debugging and then restore the old state
around calls to Mercury code from the declarative debugger.
My guess is that the bug was introduced when we gave declarative
debugging its own trace function; the one it used to share with
the procedural debugger still does the same disable/restore pair.
trace/mercury_trace_internal.c:
Delete the code now moved to mercury_trace_base.c.
trace/mercury_trace_util.[ch]:
Add a utility function for use by the new code in
mercury_trace_cmd_browsing.c, and increase robustness by more
precise representation of unsigned values.
trace/mercury_trace_cmd_dd.c:
Cosmetic fixes.
tests/debugger/declarative/tabled_read_decl.m:
Update this test case to our current coding standards. There are no
changes in the code.
tests/debugger/declarative/tabled_read_decl.{inp,out}:
Test the bug fixes by printing out a bunch of I/O actions.
tests/debugger/declarative/builtin_call_rep.exp:
Update this expected output file to conform for my recent change to
procedure representations.
tests/debugger/declarative/io_read_bug.{m,inp,exp}:
A new test case that exposes the second bug above. The .inp file
exposes the bug; the .exp file is a dummy.
tests/debugger/declarative/Mmakefile:
Add the new test case, but don't enable it yet.
tests/debugger/print_io_actions.{m,inp,exp,data}:
A new test case to test the new "print io" variant of the print
command.
tests/debugger/Mmakefile:
tests/debugger/Mercury.options:
Enable the new test case.
tests/EXPECT_FAIL_TESTS.asm_fast.gc.decldebug:
Expect the big_array_from_list test to fail in decldebug grades,
since we in that grade we can never get tail recursion, even in the
standard library.
|
||
|
Zoltan Somogyi
|
b56885be93 |
Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail.
Estimated hours taken: 12 Branches: main Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. The problem was not in lco.m, but in follow_code.m. In some cases, (specifically, the LCMC version of insert_2 in sparse_bitset.m), follow_code.m moved an impure goal (store_at_ref) into the arms of an if-then-else without marking those arms, or the if-then-else, as impure. The next pass, simplify, then deleted the entire if-then-else, since it had no outputs. (The store_at_ref that originally appeared after the if-then-else was the only consumer of its only output.) The fix is to get follow_code.m to make branched control structures such as if-then-elses, as well as their arms, semipure or impure if a goal being moved into them is semipure or impure, or if they came from an semipure or impure conjunction. Improve the optimization of the LCMC version of sparse_bitset.insert_2, which had a foreign_proc invocation of bits_per_int in it: replace such invocations with a unification of the bits_per_int constant if not cross compiling. Add a new option, --optimize-constructor-last-call-null. When set, LCMC will assign NULLs to the fields not yet filled in, to avoid any junk happens to be there from being followed by the garbage collector's mark phase. This diff also makes several other changes that helped me to track down the bug above. compiler/follow_code.m: Make the fix described above. Delete all the provisions for --prev-code; it won't be implemented. Don't export a predicate that is not now used anywhere else. compiler/simplify.m: Make the optimization described above. compiler/lco.m: Make sure that the LCMC specialized procedure is a predicate, not a function: having a function with the mode LCMC_insert_2(in, in) = in looks wrong. To avoid name collisions when a function and a predicate with the same name and arity have LCMC applied to them, include the predicate vs function status of the original procedure included in the name of the new procedure. Update the sym_name of calls to LCMC variants, not just the pred_id, because without that, the HLDS dump looks misleading. compiler/pred_table.m: Don't have optimizations like LCMC insert new predicates at the front of the list of predicates. Maintain the list of predicates in the module as a two part list, to allow efficient addition of new pred_ids at the (logical) end without using O(N^2) algorithms. Having predicates in chronological order makes it easier to look at HLDS dumps and .c files. compiler/hlds_module.m: Make module_info_predids return a module_info that is physically updated though logically unchanged. compiler/options.m: Add --optimize-constructor-last-call-null. Make the options --dump-hlds-pred-id, --debug-opt-pred-id and --debug-opt-pred-name into accumulating options, to allow the user to specify more than one predicate to be dumped (e.g. insert_2 and its LCMC variant). Delete --prev-code. doc/user_guide.texi: Document the changes in options.m. compiler/code_info.m: Record the value of --optimize-constructor-last-call-null in the code_info, to avoid lookup at every cell construction. compiler/unify_gen.m: compiler/var_locn.m: When deciding whether a cell can be static or not, make sure that we never make static a cell that has some fields initialized with dummy zeros, to be filled in for real later. compiler/hlds_out.m: For goals that are semipure or impure, note this fact. This info was lost when I changed the representation of impurity from markers to a field. mdbcomp/prim_data.m: Rename some ambiguous function symbols. compiler/intermod.m: compiler/trans_opt.m: Rename the main predicates (and some function symbols) of these modules to avoid ambiguity and to make them more expressive. compiler/llds.m: Don't print line numbers for foreign_code fragments if the user has specified --no-line-numbers. compiler/make.dependencies.m: compiler/mercury_to_mercury.m: compiler/recompilation.usage.m: Don't use io.write to write out information to files we may need to parse again, because this is vulnerable to changes to the names of function symbols (e.g. the one to mdbcomp/prim_data.m). The compiler still contains some uses of io.write, but they are for debugging. I added an item to the todo list of the one exception, ilasm.m. compiler/recompilation.m: Rename a misleading function symbol name. compiler/parse_tree.m: Don't import recompilation.m here. It is not needed (all the components of parse_tree that need recompilation.m already import it themselves), and deleting the import avoids recompiling almost everything when recompilation.m changes. compiler/*.m: Conform to the changes above. compiler/*.m: browser/*.m: slice/*.m: Conform to the change to mdbcomp. library/sparse_bitset.m: Use some better variable names. |
||
|
Julien Fischer
|
b4c3bb1387 |
Clean up in unused module imports in the Mercury system detected
Estimated hours taken: 3 Branches: main Clean up in unused module imports in the Mercury system detected by --warn-unused-imports. analysis/*.m: browser/*.m: deep_profiler/*.m: compiler/*.m: library/*.m: mdbcomp/*.m: profiler/*.m: slice/*.m: Remove unused module imports. Fix some minor departures from our coding standards. analysis/Mercury.options: browser/Mercury.options: deep_profiler/Mercury.options: compiler/Mercury.options: library/Mercury.options: mdbcomp/Mercury.options: profiler/Mercury.options: slice/Mercury.options: Set --no-warn-unused-imports for those modules that are used as packages or otherwise break --warn-unused-imports, e.g. because they contain predicates with both foreign and Mercury clauses and some of the imports only depend on the latter. |
||
|
Zoltan Somogyi
|
00741b0162 |
This diff contains no algorithmic changes.
Estimated hours taken: 6 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch more function symbols to reduce ambiguity. After this diff, the summary line from the mdb command "ambiguity -f" is Total: 351 names used 975 times, maximum 31, average: 2.78 browser/*.m: compiler/*.m: Rename function symbols to eliminate ambiguities. tests/debugger/declarative/dependency.exp: tests/debugger/declarative/dependency2.exp: Update the expected out where some internal function symbol names appear in the output of the debugger. (This output is meant for implementors only.) |
||
|
Julien Fischer
|
49faf8152a |
Fix a bunch of typos and some formatting.
Estimated hours taken: 0.5 Branches: main browser/*.m: Fix a bunch of typos and some formatting. |
||
|
Julien Fischer
|
459847a064 |
Move the univ, maybe, pair and unit types from std_util into their own
Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes. |
||
|
Zoltan Somogyi
|
7822554732 |
Replace __ with . as the module qualifier everywhere in all the modules
Estimated hours taken: 2 Branches: main browser/*.m: Replace __ with . as the module qualifier everywhere in all the modules of the browser directory. Convert the currently tab-indented modules to four-space indentation. Delete some unnecessary module qualifications. Change some type names and function symbols to avoid ambiguities. Replace a bunch of uses of DCGs with state variable notation. |
||
|
Ian MacLarty
|
521967f39f |
Implement a second version of the subterm dependency tracking algorithm
Estimated hours taken: 20 Branches: main Implement a second version of the subterm dependency tracking algorithm that uses the following heuristic to speed things up: If the subterm is being tracked through an output argument, and there is an input argument with the same name as the output argumnet, except for a numerical suffix, then the new algorithm will check if the subterm appears in the same position in the input argument. If it does then it will continue tracking the subterm in the input argument, thus bypassing the subtree rooted at the call. Since dereferencing a subterm in a large structure can be expensive, the new algorithm will only try to bypass calls to procedures it has not tried to bypass before. The set of procedures it has tried is reset each time a new explicit subtree or supertree is generated. Add a `track' command that behaves in the same way as `mark', except that it doesn't assert that the node is erroneous or inadmissible. Add an optional `--accurate' argument which tells the declarative debugger to use the original tracking algorithm. We still allow the old algorithm to be used, because there are situations where the new algorithm could find the wrong call (i.e. when a subterm appears in the same position in an input argument, but the subterm in the output argument is actually bound by a descendent call -- it just happens to be bound to the same value as the input subterm). doc/user_guide.texi: Change the documentation accordingly. browser/browse.m: browser/browser_info.m: browser/parse.m: browser/declarative_user.m: Add a `track' command that does the same thing as a `mark' command, except it doesn't assert the atom to be erroneous or inadmissible. Allow an `--accurate' or `-a' argument for the `mark' and `track' commands which indicates that the old subterm dependency tracking algorithm should be used. Pass information about tracked subterms to the declarative debugger. Do not allow a whole atom to be tracked or marked as this doesn't make sense. browser/declarative_analyser.m: browser/declarative_debugger.m: browser/declarative_edt.m: browser/declarative_oracle.m: Implement the new tracking algorithm. browser/term_rep.m: Add a predicate to dereference a subterm in another term. mdbcomp/rtti_access.m: Add a predicate to find a candidate input argument on which to apply the new heuristic. runtime/Mmakefile: runtime/mercury_layout_util.h: runtime/mercury_stack_layout.h: trace/mercury_trace_vars.c: trace/mercury_trace_vars.h: Move the function for finding the name of a variable to the runtime, so that it can be called from the declarative debugger. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/nodescend_tracking.exp: tests/debugger/declarative/nodescend_tracking.inp: tests/debugger/declarative/nodescend_tracking.m: Test the new heuristic. tests/debugger/declarative/closure_dependency.inp2: tests/debugger/declarative/closure_dependency.exp2: Expect an error message when marking a whole atom. |
||
|
Ian MacLarty
|
fefcf468a0 |
Use dicing information in the declarative debugger.
Estimated hours taken: 30 Branches: main Use dicing information in the declarative debugger. Each label in the program is assigned a suspicion based on a supplied dice. A new search mode then performs divide and query using the total suspicion of a subtree as the weighting of the subtree. browser/declarative_analyser.m: Parameterize the divide and query search mode by allowing it to work with an arbitrary weighting heuristic. Support two weighting heuristics: number of events and suspicion. Since there is still only one weight field for each suspect, if the weighting heuristic changes, then update all the weights of all the suspects. Return a different reason for asking a divide and query question, depending on the weighting heuristic. Some information (specifically how many suspect events remain and the estimated number of questions remaining for divide and query) returned by the info command depends on the current weighting heuristic being the number of events. If the current weighting heuristic is not the number of events then do not show this information. browser/declarative_debugger.m: Pass the trace node store to set_fallback_search_mode so that the weights can be recalculated if the search strategy changes. browser/declarative_edt.m: In the mercury_edt typeclass, rename the edt_weight method to edt_number_of_events and add a new method edt_subtree_suspicion. The weight field of each suspect in the search space can either be based on suspicion or number of events. Add a field to the search_space type to determine which weighting heuristic to use. Export predicates to get and set the current weighting heuristic being used. If the weighting heuristic changes the recalculate the weights of all the suspects. When calculating the weight of a suspect use the current weighting heuristic. browser/declarative_execution.m: Record a suspicion accumulator at each interface event which can be used to calculate the suspicion of a subtree in the EDT. Move the label_layout and proc_layout types as well as all utility predicates for those types to a new module, mdbcomp.label_layout. browser/declarative_oracle.m: browser/declarative_user.m: browser/debugger_interface.m: Import mdbcomp.label_layout. browser/declarative_tree.m: Adjust for the extra field in interface nodes in the annotated trace. Look at the weighting heuristic when calculating the weight of a subtree. browser/util.m: mdbcomp/program_representation.m: Move goal_path_string to mdbcomp.program_representation since it is needed in mdbcomp.label_layout. doc/user_guide.texi: Document the new search mode. mdbcomp/label_layout.m: This module contains the types label_layout and proc_layout and supporting predicates which were in mdb.declarative_execution. These types are needed in the mdbcomp.slice_and_dice module. mdbcomp/mdbcomp.m: Include label_layout. mdbcomp/slice_and_dice.m: Add functions for calculating different suspicion formulas. The intention is to experiment with different formulas in the future. Export predicates for reading a dice from the C backend. Export a predicate for retrieving the suspicion of a label given a dice. This predicate uses the suspicion_ratio_binary formula, since that seems most effective in my (as yet very limited) experience. I will implement better ways to control and customise the formula used in the future. mdbcomp/trace_counts.m: Add a function for constructing a path_port given a goal path and a trace port. If there is an unexpected exception when reading a trace counts file then print the unexpected exception. Add a predicate to convert trace count file types to a string and vica versa. runtime/mercury_stack_layout.h: Fix a typo. runtime/mercury_trace_base.c: runtime/mercury_trace_base.h: Export a function to look up the trace count slot for a label. Use this function when recording trace counts. This function will also be used in the declarative debugger backend to look up suspicions for labels. Add a function to initialise the array which records which ports need a goal path to uniquely identifiy the label. Initially I used this array elsewhere which is why I exported it. I didn't actually end up needing to use it in the final version, but I'm still exporting it, since it might be useful in the future. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/dice.exp: tests/debugger/declarative/dice.inp: tests/debugger/declarative/dice.m: Test the new search mode. tests/debugger/declarative/info.exp: tests/debugger/declarative/change_search.exp: The weigting heuristic is now printed with the info command. Also some information, such as the number of suspect events, is no longer printed if the weigthing heuristic is not the number of events (since then that information is not available). trace/mercury_trace_declarative.c: Add a function to setup the trace counts array with a suspicion for each label. For efficiency the suspicion is converted from a float to an integer between 0 and 100. If a flag is set, then increment an accumulator with the suspicion of each label executed as the annotated trace is being constructed. Store the value of the accumulator at interface events, so that the frontend can efficiently calculate the suspicion of any subtree. Remove a redundant variable and comment: the goal path is no longer passed to the frontend, because the frontend has access to the label_layout from which it can get the goal path (the variable and comment are artifacts of a previous change). When checking if a search mode is valid also check if failing and passing trace counts are required for the search mode. Allow abbreviations for the search mode arguments. trace/mercury_trace_declarative.h: Export the predicate to set up the suspicions for each label. trace/mercury_trace_internal.c: Allow passing and failing test case(s) to be passed as arguments to the dd command. If passing and failing test case(s) are supplied then record suspicions in the annotated trace even if the sdq search mode is not specified. The user could switch to the sdq search mode later on. Initialise some values which were causing warnings from the C compiler. browser/debugger_interface.m: browser/declarative_analyser.m: browser/declarative_debugger.m: browser/declarative_edt.m: browser/declarative_execution.m: browser/declarative_oracle.m: browser/declarative_tree.m: browser/declarative_user.m: browser/util.m: doc/user_guide.texi: mdbcomp/mdbcomp.m: mdbcomp/program_representation.m: mdbcomp/rtti_access.m: mdbcomp/slice_and_dice.m: mdbcomp/trace_counts.m: runtime/mercury_stack_layout.h: runtime/mercury_trace_base.c: runtime/mercury_trace_base.h: tests/debugger/declarative/Mmakefile: tests/debugger/declarative/dice.exp: tests/debugger/declarative/dice.inp: tests/debugger/declarative/dice.m: tests/debugger/declarative/info.exp: trace/mercury_trace_declarative.c: trace/mercury_trace_declarative.h: trace/mercury_trace_internal.c: |
||
|
Ian MacLarty
|
cfa50105ba |
Allow the search mode to be changed from within the declarative debugger.
Estimated hours taken: 15 Branches: main Allow the search mode to be changed from within the declarative debugger. Make binary search independent of subterm dependency tracking. The user can now perform a binary search along the path between the current question and the root of the search space using the command `mode binary' (or `m b'). browser/declarative_analyser.m: Make reask_last_question fail instead of throwing an exception if there is no last question. If it fails we recompute the question. This happens when the user resumes with a new search mode. Do not return an analyser response when showing info, since we can just call reask_last_question. Make set_fallback_search_mode set the last_search_question field to no. This will force the question to be recomputed with the new search strategy when analysis continues. Add change_search_mode which handles the users request to change the current search mode from within a declarative debugging session. Do not perform a binary search after tracking a subterm unless instructed to do so by the user. browser/declarative_debugger.m: Allow search mode changes to be undone. Handle the new change_search oracle response. Handle the fact that reask_last_question is now semidet. browser/declarative_oracle.m: Add a change_search oracle response. Add a predicate to indicate which oracle responses are undoable. browser/declarative_user.m: Add a change_search user response. doc/user_guide.texi: Rephrase the description of the undo command to take into account that search mode changes can be undone. Add a section about the binary search mode. Rearrange some text and reword some sentences slightly. tests/debugger/mdb_command_test.inp: tests/debugger/declarative/Mmakefile: tests/debugger/declarative/binary_search.exp: tests/debugger/declarative/binary_search.exp2: tests/debugger/declarative/binary_search.inp: tests/debugger/declarative/binary_search.inp2: tests/debugger/declarative/change_search.exp: tests/debugger/declarative/change_search.inp: tests/debugger/declarative/change_search.m: tests/debugger/declarative/info.exp: tests/debugger/declarative/info.inp: Test the `mode' command and do not expect the declarative debugger to automatically go into binary search mode once it has tracked a subterm. |
||
|
Ian MacLarty
|
420272e7c4 |
Implement `undo' command in the declarative debugger.
Estimated hours taken: 6
Branches: main
Implement `undo' command in the declarative debugger.
The `undo' command takes the debugger back to the state it was in before the
last answer was given (`skip' is counted as an answer in this case).
browser/declarative_analyser.m:
Add an interface predicate which allows us to get the last question
asked by the analyser.
Do not handle `show_info' in process_answer, since `show_info' is
no longer considered an answer (see below).
browser/declarative_debugger.m:
Make `show_info' an oracle response, instead of an oracle answer,
since it doesn't affect the search space.
Get rid of diagnoser_{get,set}_{analyser,oracle}, because they serve
no abstraction purpose and maintaining them is a pain.
Add a new field to the diagnoser which records the state of the
diagnoser before the previous oracle answer. This turns the
diagnoser into a stack. Add predicates to push and pop
diagnosers from this stack.
Push the current diagnoser onto the stack when an oracle answer
is received from the user.
Pop the previous diagnoser when the `undo' command is issued.
browser/declarative_oracle.m:
Add `undo' to the set of possible oracle responses.
Add a predicate which makes the current knowledge base of one oracle
the revised knowledge base of another oracle.
Fix a spelling mistake.
Add a predicate to get the output stream used to communicate with the
user.
Report whether an answer came directly from the user or not in
query_oracle.
browser/declarative_user.m:
Add the `undo' user response.
Add a predicate to get the output stream used to communicate with the
user. This is used by the diagnoser to print a "Undo stack empty"
message.
doc/user_guide.texi
Document the new command.
tests/debugger/declarative/Mmakefile:
tests/debugger/declarative/undo.exp:
tests/debugger/declarative/undo.inp:
tests/debugger/declarative/undo.m:
Test the new command.
|
||
|
Zoltan Somogyi
|
a77588f6d2 |
Add two new capabilities to the debugger.
Estimated hours taken: 8
Branches: main
Add two new capabilities to the debugger.
The first capability is the idea of "held variables", variables that the
debugger holds onto even when execution has left the event they came from.
You can hold onto a variable via the mdb command "hold varname heldvarname".
You can suffix the name of the existing variable with a term path, in which
case the new held variable will refer only to the specified part of the term.
Later mdb commands can refer to the held variable by prefixing its name with
a dollar sign. For example, after "hold HeadVar__1^2 x", "$x" will refer to
the term that was the second argument of HeadVar__1 at the program point
at which the "hold" command was executed.
The second capability is the ability to compute the diff of two terms and
express those diffs as the term paths of the function symbols at which the two
terms differ, instead of the line numbers you get by using save_to_file and the
usual Unix diff command. The mdb command is "diff var1 var2". We limit the
number of term paths of difference sites that we display at any one time;
the mdb diff command has options to control this.
NEWS:
Mention the new capabilities.
doc/user_guide.texi:
Document the new mdb commands "hold" and "diff", the new mdb command
"held_vars" which simply lists the names of all the held variables
(just as "vars" lists the names of all the nonheld variables currently
accessible), and the concept of held variables.
doc/mdb_categories:
Update this file for the new mdb commands and concepts.
browser/browse_diff.m:
This new module implements the diff operation on terms.
browser/mdb.m:
Add the new module to the list of submodules of the mdb package.
browser/*.m:
Minor cleanups, such as importing only one module per line; there
are no algorithmic changes.
trace/mercury_trace_hold_vars.[ch]:
This new module implements the database of held variables.
trace/Mmakefile:
Mention the new module.
trace/mercury_trace_internal.c:
Implement the three new mdb commands.
trace/mercury_trace_vars.[ch]:
Modify the functions that recognize variable specifications or
process them to work with held variables as well as variables from
the current environment. This required some reorganization of the
internals of this module.
Provide some a utility function, MR_trace_parse_lookup_var_path,
for converting a string representing the specification of a term
(a variable and possibly some path within it) to the type and value
of that term. Make the utility function this is based upon,
MR_lookup_unambiguous_var_spec, replace the previous but less capable
MR_convert_var_spec_to_type_value.
trace/mercury_trace_spy.c:
Conform to the change in mercury_trace_vars.c.
trace/mercury_trace_util.c:
Make a utility function more robust.
trace/mercury_trace_alias.c:
Minor cleanups.
tests/debugger/queens.{inp,exp*}:
Update this test case to test the debugger's new capabilities.
tests/debugger/completion.{inp,exp*}:
Update this test case to expect the new mdb commands, and avoid the
ambiguity between "help" and "held_vars".
|
||
|
Ian MacLarty
|
a9594132f2 |
Do not build an IO action map to pass around to predicates in the
Estimated hours taken: 4 Branches: main Do not build an IO action map to pass around to predicates in the declarative debugger that need access to IO actions. Instead look these up directly in the IO state. When using the declarative debugger to debug the Mercury compiler invoked on typecheck.m, which generates about 2.3 million IO actions, this change reduces the memory consumption by roughly half and reduces the delay between the end of execution trace generation and the asking of the first question from about 30 seconds to about 2 seconds. Use the --force-disable-tracing option to turn off tracing in the browser directory, even in .debug and .decldebug grades. configure.in Check that the --force-disable-tracing option is recongnised by the installed compiler, since we now use this option. browser/MDB_FLAGS.in: Turn off tracing for all code in the browser directory. browser/declarative_analyser.m: Remove the IO action map from the analyser state. Reformat a comment. browser/declarative_debugger.m: Do not initialise the IO action map, since it no longer exists. For final atoms, record a range of IO action numbers, instead a list of IO actions. The actions themselves can be looked up from the numbers when needed. browser/declarative_edt.m: browser/declarative_tree.m: Remove references to the IO action map. browser/declarative_user.m: Look up tabled IO actions directly in the IO state when they need to be displayed. Implement a predicate, find_tabled_io_action, which finds a particular tabled IO action given a range of IO action numbers and the sought tabled IO action number. Change several predicates to use the above instead of looking for the IO actions in a list. Implement a predicate, count_tabled_io_actions, which counts how many tabled and untabled IO actions are in a range of IO action numbers. Modify some predicates to use above. browser/io_action.m: Remove the io_action_map type and predicates used to construct values of this type. Add a new predicate, get_maybe_io_action, which looks up a possibly untabled IO action number and returns the IO action if it was tabled. The type returned by this predicate is maybe_tabled_io_action, which has two functors: tabled/1 and untabled/1. The argument of the untabled/1 functor is pointless, since it's just the IO action number, which is required to look up the return value of get_maybe_io_action in the first place. Remove the pointless argument. Add a new type, io_action_range, for recording a range of IO actions. Add an explicit `may_call_mercury' assertion to the pickup_io_action foreign proc. trace/mercury_trace_declarative.c: Do not keep track of the start and finish IO action numbers for the generated portions of the EDT and do not pass these to the frontend. We still record the current IO action number at each CALL and EXIT event. Fix a bug in the progress indicator which is exposed when event numbers become very big. |
||
|
Ian MacLarty
|
68587c5324 |
Look up atoms in the knowledge base as soon as they are added to the search
Estimated hours taken: 3 Branches: main Look up atoms in the knowledge base as soon as they are added to the search space. This generalises a feature of the debugger which I earlier removed for simplicity, where the analyser would pass a list of questions to the oracle. If the oracle had any of the questions in its knowledge base it would return those answers to the analyser, otherwise it would ask the user. This was changed so that only one question was asked of the oracle at a time. Now the analyser still asks only one question of the oracle at a time (through an analyser response), but the oracle's knowledge base is consulted every time a new suspect is added to the search space i.e. as it is being searched. The main benefit of this is that search algorithms can immediately avoid generating queries about trusted nodes. This fixes some slightly annoying behaviour with subterm dependency tracking. Previously if a subterm was bound by a trusted predicate, then this would cause a binary search to be performed between the trusted predicate and the root of the search space. It would be better for the dependency tracking algorithm to first ask about the closest untrusted call to the call that bound the subterm, since often subterms are bound by internal library predicates. The subterm dependency algorithm was unable to do this, however, because it didn't know which calls were trusted while it was tracking the subterm. Now it does. browser/declarative_analyser.m: Pass the oracle state and the io action map to any predicates that add suspects to the search space, so that the oracle's knowledge base can be consulted. Move the code that checks if a bug has been found from decide_analyser_response to the top-down search routine. This is okay since all the other search algorithms will eventually call top-down search if they can't find any unknown suspects to ask questions about. When keeping track of the last unknown suspect, double check that the suspect is still unknown before asking a question about it, since its status may have been changed because, for example, an erroneous child was added to the search space. Pass the mode of the subterm to give_up_subterm_tracking/3, since tracking of the subterm should only be stopped if it's the input to an erroneous node. browser/declarative_debugger.m: Add a subtype of decl_answer/1 that specifies those answers which can be obtained from places other than the user. Pass the oracle state to the analyser. browser/declarative_edt.m: Make first_unknown_descendent return a new type which captures whether an unknown suspect was found, an unknown suspect was not found, or an explicit_subtree was requested. Previously this predicate would fail if an explicit subtree was required, which meant that any suspects added to the search space during the call to first_unknown_descendent would have to be added again once the subtree had been generated. This also removes the need for pick_implicit_root. Pass the oracle state and the io action map to any predicates that add suspects to the search space, so that the oracle's knowledge base can be consulted. Remove the suspect_is_bug predicate, since this is now done by top-down search in the anaylser. Export non_ignored_descendents and suspect_inadmissible so the analyser can use it. Return the mode of a subterm in its origin. Make give_up_subterm_tracking consider the mode of the subterm. Check if the oracle knows the answer to a question when adding children to the search space, or adding a new suspect at the top of the search space. Also give better names to some variables in these predicates. browser/declarative_oracle.m: Export answer_known/3 so that declarative_edt can call it. tests/debugger/declarative/binary_search.exp: tests/debugger/declarative/binary_search.exp2: tests/debugger/declarative/binary_search.inp: tests/debugger/declarative/binary_search.inp2: tests/debugger/declarative/family.exp: tests/debugger/declarative/family.inp: These test cases now ask fewer questions, except for one dd session in the binary_search test case. This, however, is a fix for the quirk mentioned above where a binary search would be started if the binding node is trusted. The new behaviour is more predictable and preferable even if an extra question is asked. trace/mercury_trace_declarative.c: Fix a bug where the dd_dd command didn't work. This was introduced by an earlier diff in which I cleaned up mercury_trace_declarative.c. |
||
|
Ian MacLarty
|
cabb22d14f |
Improve the declarative debugger interface.
Estimated hours taken: 7 Branches: main Improve the declarative debugger interface. The two main changes are to use the mdb help system and not re-display the question after the user issues a command which does not answer the question. For example if the user issues an `info' command, then previously the question would be redisplayed after the requested information and if the question is big then the information would be scrolled off the screen. browser/declarative_analyser.m: Remove extra new line characters when printing info. These are no longer necessary since the question is not redisplayed. browser/declarative_debugger.m: Pass the help system from mdb to the oracle state when initialising the diagnoser. browser/declarative_oracle.m: Pass the help system to the user state when initialising the oracle state. browser/declarative_user.m: Add two new fields to the user state: one to keep a reference to the help system and one to indicate whether the current question should be displayed when getting a user input. Allow the user to redisplay the question by issuing a `print' command with no arguments. If the question is not to be displayed the show a "dd>" prompt. Change the `abort' command to `quit'. This is more consistent with the rest of mdb. doc/commands: Add a script to print all the commands in a section in the user guide. doc/generate_mdb_doc: Generate help for the declarative debugger. doc/mdb_categories: Add a category, `decl', for commands that can be executed inside the declarative debugger. Change the `dd' category to mdb_dd, because 1) `help dd' used to show help about the `dd' category AND the `dd' command and 2) `dd' is too general a category name now that we have a `decl' category. Add an item, `decl_debug' to the concepts category. doc/user_guide.texi: Document some dd commands which previously weren't documented here. Add a short overview of the declarative debugger. This is displayed when the user issues a `help' command from within the dd. Move the bit about the behaviour when no command is given to before the list of commands. This is necessary so util/info_to_mdb.c doesn't include this in the help of the last command in the list. tests/debugger/declarative/app.exp: tests/debugger/declarative/app.inp: tests/debugger/declarative/browse_arg.exp: tests/debugger/declarative/browse_arg.inp: tests/debugger/declarative/browser_mode.exp: tests/debugger/declarative/browser_mode.inp: tests/debugger/declarative/confirm_abort.exp: tests/debugger/declarative/confirm_abort.inp: tests/debugger/declarative/dependency.exp: tests/debugger/declarative/dependency.inp: tests/debugger/declarative/find_origin.exp: tests/debugger/declarative/find_origin.exp2: tests/debugger/declarative/info.exp: tests/debugger/declarative/info.inp: tests/debugger/declarative/io_stream_test.exp: tests/debugger/declarative/io_stream_test.exp2: tests/debugger/declarative/mapinit.exp: tests/debugger/declarative/mapinit.inp: tests/debugger/declarative/output_term_dep.exp: tests/debugger/declarative/output_term_dep.inp: tests/debugger/declarative/resume.exp: tests/debugger/declarative/resume.inp: tests/debugger/declarative/skip.exp: tests/debugger/declarative/skip.inp: tests/debugger/declarative/solutions.exp3: tests/debugger/declarative/tabled_read_decl.exp: Update tests. trace/mercury_trace_declarative.c: trace/mercury_trace_help.c: trace/mercury_trace_help.h: Pass the help system to the frontend. |
||
|
Ian MacLarty
|
f8fcf9d8c2 |
Only perform a consistency check on the search space if the
Estimated hours taken: 0.1 Branches: main and 0.12 Only perform a consistency check on the search space if the MR_DD_CHECK_SEARCH_SPACE C macro is defined. This check was slowing the declarative debugger down considerably. The debugger/declarative/binary_search test now takes about a second or two, instead of around 5-7 seconds previously (these are estimates). browser/declarative_analyser.m: Call a wrapper predicate which only performs the check if the C macro is defined. browser/declarative_edt.m: Add a wrapper predicate which only performs the check if the C macro is defined. |
||
|
Ian MacLarty
|
a789c0bbfc |
Include the reason why a question was asked in the information provided by the
Estimated hours taken: 14 Branches: main Include the reason why a question was asked in the information provided by the `info' command. This includes the place where a marked subterm was bound if the user marked a subterm in the previous question. browser/declarative_analyser.m Add a new type to record the reason why a question was asked. Keep this information with the last question asked in the analyser state, in case the user issues an `info' command. Display the reason when the user issues an `info' command. Change the behaviour of subterm dependency tracking slightly: if the binding node was previously skipped then ask about it anyway. The user can then see in which node the subterm was bound, which may help them in answering the previously skipped question. browser/declarative_edt.m Add two new methods to the mercury_edt typeclass. One to get the proc_label of a node and the other to convert an arg_pos to a user argument number with respect to an atom in a node. These are needed to display the question reason to the user in mdb.declarative_analyser. Add a new type to record the primitive operation that bound a subterm. browser/declarative_execution.m Add a predicate to convert an arg_pos into a user arg number. browser/declarative_oracle.m Fix a faulty comment. browser/declarative_tree.m Implement the new methods added to the mercury_edt typeclass. Return the type of primitive operation that bound a subterm. doc/user_guide.texi Document the fact that the reason is now also displayed when the `info' command is issued. tests/debugger/declarative/dependency.exp tests/debugger/declarative/dependency2.exp The type of primitive operation is now shown in the debugging output. tests/debugger/declarative/info.exp tests/debugger/declarative/info.inp tests/debugger/declarative/info.m Test the info command more thoroughly. |
||
|
Ian MacLarty
|
1a708a0ccc |
Add a new declarative debugger response, `info', which shows some information
Estimated hours taken: 6 Branches: main Add a new declarative debugger response, `info', which shows some information about the current question and the state of the bug search. browser/declarative_analyser.m Add the show_info predicate. browser/declarative_debugger.m Handle the oracle show_info response. browser/declarative_edt.m Add a new method to the mercury_edt typeclass, edt_context, which returns the filename and line number of the predicate for a node. browser/declarative_execution.m Instead of recording the goal path of a call in its parent, record the return label. The goal path and the parent context can then be derived from the return label. Add a function to get the goal path from a return label. Add a function to get the context of a label. Modify the exported predicates used to build the annotated trace to take a return label instead of the goal path. browser/declarative_oracle.m Add a `show_info' oracle response. browser/declarative_tree.m Implement trace_context which returns the filename and line number of the predicate that corresponds with a node in the annotated trace. Derive a call's goal path in its caller from the return label where necessary. browser/declarative_user.m Add and document the user response `info'. browser/dice.m Fix a line that was over 79 characters. doc/user_guide.texi Document the info command. Say that the --resume option can be used to resume an aborted or pd'd session. tests/debugger/declarative/Mmakefile tests/debugger/declarative/info.exp tests/debugger/declarative/info.inp tests/debugger/declarative/info.m Test the new response. trace/mercury_trace_declarative.c Pass the return label when constructing the annotated trace. |
||
|
Ian MacLarty
|
436c5e6a6f |
Add --resume option to `dd' command. This resumes the previous declarative
Estimated hours taken: 25 Branches: main Add --resume option to `dd' command. This resumes the previous declarative debugging session and allows the user to switch between the procedural and declarative debuggers freely. browser/declarative_analyser.m Add analysis_type type which is used to tell the analyser whether it must start a new session or resume a previous session. browser/declarative_debugger.m Add two versions of the exported diagnosis predicate: one to resume a previous session and one to start a new session. browser/declarative_user.m Print usage message to the correct output stream. doc/user_guide.texi Document the new option. runtime/mercury_stack_trace.c runtime/mercury_stack_trace.h Add a function to find the first call on the stack whose event number is less than or equal to a given event number or whose call sequence number is less than or equal to a given call sequence number. Since this new function uses some code very similar to existing code in the function that prints the stack, separate this code into a new function called MR_call_details_are_valid. trace/mercury_trace_declarative.c trace/mercury_trace_declarative.h Previously it could be safely assumed that the current event would be somewhere inside the materialized portion of the annotated trace, so it was sufficient to record the topmost node of the annotated trace and retry to there whenever we needed to build a new subtree (and to the topmost node plus some extra for a supertree). Now, however, the user may go to any event in the program before resuming the previous dd session. We could just retry to the call event for main/2, but this would be far from optimal, especially if the user is debugging code deep down in the program's call tree. Instead we retry to the first call on the stack whose event number is less than or equal to the call event number of the node we want to build a subtree for and then start forward execution from there. When building a supertree we retry to the first call on the stack whose event number is less than or equal to the event number of the call at the top of the currently materialized portion of the annotated trace. Then when we get to the call at the top of the currently materialized portion of the annotated trace through forward execution, we do a retry to the desired depth and start building the new supertree. Desribe the function of some of the global variables in more detail. Remove the global MR_edt_topmost_call_depth since it is no longer needed. Fix an inconsistency where the depth limit was being set to MR_edt_depth_step_size when starting a dd session, but to MR_edt_depth_step_size + 1 when building an additional portion of the annotated trace. Don't update the saved event details from the global event number/seqno/depth variables at the start of MR_decl_diagnosis. The globals could have been updated by a previous call to Mercury code and could have incorrect values. tests/debugger/declarative/Mmakefile tests/debugger/declarative/resume.exp tests/debugger/declarative/resume.inp tests/debugger/declarative/resume.m Test the --resume option. Specifically test the creation of a supertree and subtree from a resumed session where the user has gone to an event before and after the materialized portion of the annotated trace. trace/mercury_trace_internal.c Handle the --resume option. |
||
|
Ian MacLarty
|
c80a9d89a3 |
Fix two bugs in the declarative debugger that caused an exception to be thrown
Estimated hours taken: 3 Branches: main Fix two bugs in the declarative debugger that caused an exception to be thrown if the `dd' command was issued at a node all of whose descendents were trusted. Remove a whole lot of now useless code. browser/declarative_analyser.m Instead of aborting when no unknown or skipped suspects can be found with top down search, try to extend the search space upward. Previously this was done in decide_analyser_response, however the mechanism to determine if there were any unknown or skipped suspects in the search space (are_unknown_suspects) was faulty. This was fixed by instead checking for this condition in top_down_search, so it made sense to try to extend the search space upwards in top_down_search instead of in decide_analyser_response. The other search strategies don't need to be updated since they all revert to top down search if they can't find any unknown suspects. The fault with are_unknown_suspects was that it assumed that an unexplored suspect would have unknown children, which is not the case if it has no children at all. browser/declarative_edt.m Remove are_unknown_suspects and all supporting machinery. Fix another bug in least_skipped which determines which of two suspects was least skipped: when both suspects were not skipped the wrong suspect was returned, so when called with foldl on a search space with no skipped suspects, the starting suspect would be different from the final suspect, and choose_skipped_suspect depends on them being the same when there are no skipped suspects. tests/debugger/declarative/Mmakefile tests/debugger/declarative/all_trusted.exp tests/debugger/declarative/all_trusted.exp2 tests/debugger/declarative/all_trusted.inp tests/debugger/declarative/all_trusted.m Add a regression test. |
||
|
Ian MacLarty
|
85dff41b45 |
Add divide and query search strategy to declarative debugger.
Estimated hours taken: 80
Branches: main
Add divide and query search strategy to declarative debugger. This version of
divide and query uses the number of descendent events as a weighting instead of
the number of descendent nodes, mainly because this is easy to compute when
portions of the annotated trace are not materialized.
browser/declarative_analyser.m
Implement divide and query search.
Introduce a default search mode which can be either top-down or
divide and query.
browser/declarative_debugger.m
Export predicates so the default search mode can be set with the
`dd' command.
browser/declarative_edt.m
Implement helper predicates for divide and query search.
Maintain a weight field for each suspect and adjust this when
suspects are asserted correct, inadmissible or ignored.
Implement a check to make sure all suspects in the portion of the
search space that could contain a bug have the correct weights.
Recalculate the weights when a node is revised.
Remove some code that will never be executed in
assert_suspect_is_erroneous/3. The code handles a case when
a correct or inadmissible suspect is marked erroneous. This can
only happen when a search is being revised in which case the
correct or erroneous suspect would be marked unknown.
When marking suspects as in the complement of an erroneous subtree
stop marking if a correct or inadmissible node is encountered since
descendents of these will already have been removed from the bug
search.
Renamed the variable Leaves to StopSuspects in
propagate_status_downwards, since the value of this variable is the
list of the children of the lowest updated suspects which may or may
not be leaves.
browser/declarative_execution.m
Record REDO event numbers since these are used to calculate the
number of descendent events for backtracked over calls.
browser/declarative_tree.m
Implement predicate to calculate the number of descendent events
for a node in the EDT.
doc/user_guide.texi
Document divide and query and top-down search strategies and
document the new --default-search-mode dd option.
Put @samp{} around CALL.
tests/debugger/declarative/Mmakefile
tests/debugger/declarative/divide_and_query1.exp
tests/debugger/declarative/divide_and_query1.inp
tests/debugger/declarative/divide_and_query1.m
Test divide and query search strategy.
trace/mercury_trace_declarative.h
trace/mercury_trace_declarative.c
Record REDO event numbers.
Add some functions to set the default search mode by calling the
predicate exported from declarative_debugger.m
Add a function to check that a search mode argument string is valid.
trace/mercury_trace_internal.c
Add --default-search-mode option for `dd' command.
Use readline completion for `dd' command options.
|
||
|
Ian MacLarty
|
c511bd8b3e |
Allow the declarative debugger to search nodes above the node where the initial
Estimated hours taken: 20 Branches: main Allow the declarative debugger to search nodes above the node where the initial `dd' command was given. If the user asserts that the node at which the `dd' command was given is correct or inadmissible then the declarative debugger will ask questions about ancestors of the node at which the `dd' command was given. The declarative debugger will only say it cannot find a bug if the user asserts that the main/2 (or whatever the topmost traced call is) call is correct or inadmissible. This is useful when you've found an inadmissible node in the procedural debugger, but you're not sure where the erroneous ancestor is. Fix bug in sub-term dependency tracking when tracking an input sub-term: If the sub-term was bound by a primitive operation then the next question was about the child of the node in which the sub-term was bound, instead of the node itself. Add --depth-step-size option to mdb `dd' command. This allows the user to specify the depth of each materialized portion of the EDT. browser/declarative_analyser.m Allow analyser to request an explicit supertree from the diagnoser and respond correctly once an explicit subtree has been generated. When the primitive operation that binds a sub-term is found, the suspect_id of the node containing the primitive op is now returned, so handle this by asking the next question about the node containing the primitive op if its status is unknown. Stop tracking the sub-term if it is an input and we encounter an erroneous node. Remove previous_roots field from analyser_state. It is not needed because this information is now kept in the search space. browser/declarative_debugger.m Add new diagnoser response to tell backend to generate an explicit supertree. browser/declarative_edt.m Add methods to mercury_edt typeclass to get the parent of an EDT node, tell if two nodes refer to the same event and tell if a node is the topmost node (usually the 1st call to main/2). Make find_subterm_origin return the suspect in which a primitive operation was executed. Add predicate to incorporate a new explicit supertree into the search space. Add predicate to tell the analyser when it's okay to stop tracking a sub-term. Fix bug in find_subterm_origin so it doesn't report a child as the binding node when it should be the parent. Also replace duplicated code in find_subterm_origin with new predicate resolve_origin. Add extend_search_space_upwards predicate which attempts to add an extra node to the top of the search space. If a status is changed from erroneous to correct or vica versa then mark the suspects which were eliminated from the search space by the original status as unknown. browser/declarative_execution.m Rename call_last_exit_redo to call_last_interface, since excp and fail nodes can also go here. browser/declarative_tree.m Add implementations for new methods from mercury_edt typeclass. doc/user_guide.texi Document --depth-step-size dd option. Remove duplicate save command documentation. Add a comment about new functionality. tests/debugger/declarative/Mmakefile tests/debugger/declarative/mapinit.exp tests/debugger/declarative/mapinit.inp Use standardized event printing for mapinit test. tests/debugger/declarative/app.exp tests/debugger/declarative/app.inp tests/debugger/declarative/revise_2.exp tests/debugger/declarative/revise_2.inp Changed expected output and input because the bug search now continues in the ancestors of the node the original `dd' command was given in. tests/debugger/declarative/catch.exp Now also get a "reached unknown label" warning after the (expected) error "no support for code that catches exceptions", since now a retry is done so we can return to the original event in the mdb session. tests/debugger/declarative/explicit_subtree.exp tests/debugger/declarative/explicit_subtree.exp2 tests/debugger/declarative/explicit_subtree.inp tests/debugger/declarative/explicit_subtree.inp2 tests/debugger/declarative/explicit_subtree.m Modify this test to also test generation of an explicit supertree. trace/mercury_trace_declarative.c If requested to generate a supertree then retry to a node above the current top most node and collect events down to the current top most node. Interactively retry across IO when building the annotated trace. This is more user friendly than simply aborting if untabled IO is encountered. trace/mercury_trace_declarative.h Export MR_edt_depth_step_size so it can be set with the --depth-step-size dd option. trace/mercury_trace_internal.c Add --depth-step-size option for `dd' command. |
||
|
Ian MacLarty
|
732a892fe6 |
The main changes to the declarative debugger are:
Estimated hours taken: 200 Branches: main The main changes to the declarative debugger are: When you mark a subterm (using the term browser from within the DD), the next question will be about the node that bound that subterm. If that node is correct then a binary search will be done between that node and the last node you asserted was erroneous. The declarative debugger is now a 3-valued debugger. This means you can answer inadmissible if a call's inputs violate some precondition of the call. The debugger will also infer a call is inadmissible if you mark one of its inputs from the browser. You don't have to give an argument number when invoking the term browser from within the DD. If an argument number is omitted then the whole call is browsed as if it were a data term. The subterm dependency tracking code now has the ability to track subterms of closures, including subterms used when creating the closure by currying. Subterm dependency tracking is also now more reliable when tracing information is missing. Lots of stuff in declarative_analyser.m has been redesigned to facilitate future improvements, such as probabalistic debugging. browser/declarative_analyser.m Transferred the definition of the mercury_edt type class to declarative_edt.m. Added two new search algorithms: one to use suspicious subterm information to direct the bug search and one to do a binary search on a path in the EDT. browser/declarative_debugger.m Added inadmissible as a truth value for the declarative debugger. Added ignore and skip responses. Ignore responses are used when a call is to a trusted predicate. Ignore tells the analyser that the node is not a bug itself, though it may have buggy children. Skip means the oracle has skipped the question. browser/declarative_edt.m Definition of the EDT type class and search_space type. Search spaces are an extra layer on top of the EDT and provide useful services to the analyser such as keeping track of which nodes in the EDT might contain a bug. In the future the search space will also be used to hold information like the probability that a node is buggy. Extended the mercury_edt type class with some useful methods. browser/declarative_execution.m Added some utility predicates to extract information from a proc_id. browser/declarative_oracle.m The oracle now only answers one question at a time. This makes the implementation simpler. I plan to get the oracle to tell the analyser everything it knows, without having to ask the user, whenever children are added to the search space, so that maximum information is always available to the search algorithms. Added a mechanism so the analyser can explicitly request that a question be re-asked of the user. Made some changes to handle inadmissible calls. browser/declarative_tree.m Can now produce an i_bug as well as an e_bug. Made changes to handle dependency tracking of closure arguments. There are now two slightly different modes of subterm dependency tracking. A fall-back mode where not all trace information is available and a "full" mode that assumes everything has been traced (which will be the case if compilation was with a debug grade). The main difference is with higher order calls. Because the id of the pred being called in a higher order call is not (easily) available, we can't safely match the HO call up with events on the contour if everything is not traced. If everything is traced, then we can be sure the HO call's events will be where we expect them. Handled builtin calls which are treated as primitive ops. browser/declarative_user.m User can now browse an entire call, instead of only one argument at a time. Allowed user to answer inadmissible. browser/mdb.m Added mdb.declarative_edt. browser/program_representation.m Added builtin_call_rep to represent builtin calls. Made plain calls to UCI predicates be treated as primitive ops. Added function to say if a goal generates internal events directly. Added a function to say whether an atomic goal is identifiable (i.e. whether we can get from its goal_rep its name, module and arity). compiler/prog_rep.m Now creates builtin_call_rep atomic goal if the plain call was to a builtin. compiler/trace_params.m Made minimum tracing for decldebug grade include program representations. This is so the libraries compile with program representations, so we can do subterm dependency tracking through library calls. Trace level decl now includes the program representation. The default trace level for decldebug grade now includes the program representation. doc/user_guide.texi Updated with new features. tests/debugger/declarative/Mercury.options Removed superflous `--trace rep' options (since this is now implied by --trace decl). tests/debugger/declarative/Mmakefile Added new tests. Also made it possible to specify 3 different inputs: one for non-debugging grades, one for debug grades and one for decldebug grades. tests/debugger/declarative/binary_search.exp tests/debugger/declarative/binary_search.exp2 tests/debugger/declarative/binary_search.inp tests/debugger/declarative/binary_search.inp2 tests/debugger/declarative/binary_search.m tests/debugger/declarative/binary_search_1.m Test binary search. tests/debugger/declarative/builtin_call_rep.exp tests/debugger/declarative/builtin_call_rep.inp tests/debugger/declarative/builtin_call_rep.m Test that builtin_call_rep appears in the program representation for builtin calls. tests/debugger/declarative/catch.exp tests/debugger/declarative/catch.exp2 tests/debugger/declarative/catch.inp Use standardized output. tests/debugger/declarative/closure_dependency.exp tests/debugger/declarative/closure_dependency.exp2 tests/debugger/declarative/closure_dependency.inp tests/debugger/declarative/closure_dependency.inp2 tests/debugger/declarative/closure_dependency.m Test dependency tracking through higher order calls. tests/debugger/declarative/confirm_abort.exp tests/debugger/declarative/confirm_abort.inp If the dd command is typed then the root node is now always asked as the first question even if the oracle knows the answer (except where the predicate is trusted). Updated the test to reflect this change. tests/debugger/declarative/dependency.exp tests/debugger/declarative/dependency2.exp Arguments are now counted from the back (a change to get dependency tracking to work with higher order calls), so the debug messages printed in this test needed to be changed. tests/debugger/declarative/explicit_subtree.exp tests/debugger/declarative/explicit_subtree.exp2 tests/debugger/declarative/explicit_subtree.inp tests/debugger/declarative/explicit_subtree.inp2 tests/debugger/declarative/explicit_subtree.m Test for a bug fixed with this diff. The bug occured when the subtree for an implicit node was generated and then the explicit subtree for another implicit node to the left of the generated subtree was requested. When building the new subtree execution proceeded from where execution stopped when the previous subtree was generated, so execution never passed through nodes to the left of the previous subtree and the requested subtree wasn't built. tests/debugger/declarative/family.exp tests/debugger/declarative/family.inp Some changes to event numbers to do with changes in the way explicit subtrees are generated (see comment for tests/debugger/declarative/explicit_subtree above). Also some changes to do with the fact that the analyser now only asks the oracle one question at a time. tests/debugger/declarative/find_origin.exp tests/debugger/declarative/find_origin.exp2 tests/debugger/declarative/find_origin.exp3 tests/debugger/declarative/find_origin.inp tests/debugger/declarative/find_origin.inp2 tests/debugger/declarative/find_origin.inp3 tests/debugger/declarative/find_origin.m Test sub-term dependency tracking. tests/debugger/declarative/ho5.exp3 Changes to do with the fact that the standard library is now compiled with deep tracing in the decldebug grade. tests/debugger/declarative/ignore.exp tests/debugger/declarative/ignore.exp2 tests/debugger/declarative/ignore.inp tests/debugger/declarative/ignore.inp2 tests/debugger/declarative/ignore.m tests/debugger/declarative/ignore_1.m Test `ignore' oracle response. tests/debugger/declarative/inadmissible.exp tests/debugger/declarative/inadmissible.inp tests/debugger/declarative/inadmissible.m Test inadmissibility. tests/debugger/declarative/input_term_dep.exp tests/debugger/declarative/input_term_dep.inp Some of the bugs found are now inadmissible call bugs, since inputs were marked as incorrect. Also made changes to do with the fact that incorrect sub-terms are now followed to where they're bound. tests/debugger/declarative/lpe_example.exp3 Added new expected output when in decldebug grade. Event numbers and call depths are different now because of deep tracing in the standard library. tests/debugger/declarative/mismatch_on_call.exp tests/debugger/declarative/mismatch_on_call.exp2 tests/debugger/declarative/mismatch_on_call.inp tests/debugger/declarative/mismatch_on_call.m This test used to cause an "mismatch on call" exception to be thrown by the dependency tracking routine. tests/debugger/declarative/skip.exp tests/debugger/declarative/skip.inp tests/debugger/declarative/skip.m Test `skip' oracle response. tests/debugger/declarative/solutions.exp3 tests/debugger/declarative/solutions.inp3 Added new input and expected output for decldebug grade. Some standard modules need to be trusted since they are now deep traced in this grade. tests/debugger/declarative/special_term_dep.exp A bug is now reported as an inadmissible call. tests/debugger/declarative/throw.exp3 Because the standard library in decldebug grade is now deep traced by default event numbers are different, parent contexts are printed and "reached label with no stack layout info" warnings are not encountered. trace/mercury_trace_declarative.c Made the depth step size used when deciding which events to put in the annotated trace a variable so that it can be dynamically adjusted in the future. The EDT depth is now calculated independently instead of using event_info->MR_call_depth (which is not always consistent with the EDT depth). When generating an annotated trace for an explicit subtree the first event's preceeding event now points to the correct event in the existing annotated trace (instead of NULL). This allows the parent of the root of the new explicit subtree to be calculated. Made changes so that all the interface events of child calls of a call are included in the annotated trace, so that contours are built correctly. |
||
|
Zoltan Somogyi
|
ecdc285bc7 |
Split the existing browser library into two libraries, by making the
Estimated hours taken: 10 Branches: main Split the existing browser library into two libraries, by making the program_representation module into its own library. This is useful because the compiler refers to program_representation.m, whose code thus needs to be linked into compiler executables even if the compiler isn't compiled with debugging enabled. By creating a new library for this module, we avoid any chance of the linker dragging in the rest of the modules in the browser library. (This is a problem with an upcoming diff.). The name of the new library is "mdbcomp", because the intention is that it contain code that is shared between the debugger and the compiler. This means mostly the definitions of data structures that the compiler generates for the debugger, and the predicates that operate on them. Mmake.common.in: Allow MDB_COMP_ as a prefix for symbol names in the browser directory. Mmake.workspace: Add a make variable holding for the name of the new library, and add the name to the relevant lists of libraries. Avoid duplicating the lists of filenames that need to be updated when adding new libraries or changing their names. Mmakefile: Use make variables to refer to library names. browser/mdbcomp.m: browser/mer_mdbcomp.m: Add these files as the top modules of the new library. browser/program_representation.m: Make program_representation.m a submodule of mdbcomp, not mdb. browser/program_representation.m: browser/browser_info.m: Move a predicate from program_representation.m to browser_info.m to avoid the mdbcomp library depend on the browser library, since this would negate the point of the exercise. browser/mdb.m: Delete program_representation.m from the list of submodules. browser/Mmakefile: Update this file to handle the new module. browser/Mercury.options: Mention the new module. browser/*.m: Update the lists of imported modules. Import only one browser module per line. compiler/notes/overall_design.html: Document the new library. compiler/compile_target_code.m: Add the mdbcomp library to the list of libraries we need to link with. compiler/prog_rep.m: trace/mercury_trace_internal.c: Import program_representation.m by its new name. scripts/c2init.in: Centralize knowledge about which files need to be updated when the list of libraries changes here. scripts/c2init.in: scripts/ml.in: tools/binary: tools/binary_step: tools/bootcheck: tools/linear: tools/lml: Update the list of libraries programs are linked with. |
||
|
Mark Brown
|
c9563335ef |
Allow users of the declarative debugger to revise answers that they
Estimated hours taken: 60 Branches: main Allow users of the declarative debugger to revise answers that they have given previously. We do this by modifying the user interface to allow a default answer to be shown as part of the question; the default answer will always be some answer the user has given previously, which they can choose to either change or accept as is. Initially no questions will be candidates for revision, but if the user ever rejects a diagnosis, some or all of the questions leading directly to the bug in question will be asked again. Add an empty command to the user_command type, for when the user just presses return. If there is a default answer, the empty command is interpreted as that answer. If there is no default answer, the empty command is interpreted as the skip command, which allows the user to cycle through all the available questions by repeatedly pressing return. browser/declarative_debugger.m: Define the type decl_evidence which represents the evidence collected against a particular suspect. Pass the evidence to the oracle as required. Ensure the analyser is updated after the user rejects a diagnosis. browser/declarative_analyser.m: Collect the evidence against the prime suspect as the answers are processed, and include this evidence when the analyser response is a bug. Export the predicate revise_analysis/4 which updates the analyser state after the user has rejected a diagnosis. Pass the IO action map to prime_suspect_get_evidence so that edt_root_question can be called. browser/declarative_oracle.m: When the user rejects a bug, retract from the oracle's knowledge base any of the evidence which implicated that bug. Rather than throw this information away, we assert it in a secondary knowledge base which is consulted when we want to know if there should be a default answer provided to the user. Update the oracle_state to reflect the above change, and remove all the get_* and set_* predicates for the oracle state. That functionality is provided by labelled fields, so maintaining the get_* and set_* predicates is no longer worth the trouble. Add the predicate retract_oracle_kb/3 to remove information from a knowledge base. Use the correct (equivalence) type for exceptions. browser/declarative_user.m: Add the type user_question, which may be a plain decl_question or may be a decl_question with a default answer. Use this type in query_user* instead of decl_question. Write the command handling switch as a separate predicate. This makes it easier for one command to emulate others (e.g. the empty command). If the question has a default answer, print it as part of the prompt. Parse the empty command. doc/user_guide.texi: Update the documentation to reflect the changes. library/list.m: Add a cc_multi version of list__map. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/empty_command.exp: tests/debugger/declarative/empty_command.inp: tests/debugger/declarative/empty_command.m: tests/debugger/declarative/revise.exp: tests/debugger/declarative/revise.inp: tests/debugger/declarative/revise.m: tests/debugger/declarative/revise_2.exp: tests/debugger/declarative/revise_2.inp: tests/debugger/declarative/revise_2.m: Test cases for the new features. |
||
|
Mark Brown
|
f302f534fd |
Move the code that defines an instance of mercury_edt/2 from
Estimated hours taken: 1 Branches: main Move the code that defines an instance of mercury_edt/2 from browser/declarative_debugger.m into a module of its own. This section of code is large and reasonably self-contained, so it makes sense for it to have its own module. Moreover, declarative_debugger.m contains the main declarative debugging definitions and the upper levels of code for the front end, and the mercury_edt/2 instance doesn't fit into either of these categories. Add an exception handler to the front end, so that if declarative debugging fails for whatever reason, the debugging session can at least continue using the procedural debugger. Rather than calling error in the front end, throw exceptions that are of a type specific to the front end (so we know which errors are ours and which aren't). browser/declarative_debugger.m: Add a new type, diagnoser_exception/0. Handle these exceptions but rethrow any other kind. browser/declarative_debugger.m: browser/declarative_tree.m: Move the mercury_edt/2 instance to the new module. browser/mdb.m: Add the new module to the mdb library. browser/declarative_*.m: Call throw/1 instead of error/1. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/catch.exp: tests/debugger/declarative/catch.inp: tests/debugger/declarative/catch.m: A test case for debugging code that catches exceptions. This sort of code is still not supported by the front end, but at least we now give a decent error message and allow debugging to resume. |
||
|
Zoltan Somogyi
|
985b13ed3f |
Make I/O actions known to the declarative debugger.
Estimated hours taken: 48
Branches: main
Make I/O actions known to the declarative debugger. The debugger doesn't do
anything with them yet beyond asking about their correctness.
browser/io_action.m:
New module for representing I/O actions, and for constructing the map
from I/O action numbers to the actions themselves.
browser/mdb.m:
Include the new module.
browser/declarative_analysis.m:
Make the map from I/O action numbers to the actions themselves part
of the analyzer state, since conversions from annotated trace nodes
to EDT nodes may now require this information. This information is
stored in the analyzer state because only the analyser needs this
information (when converting annotated trace nodes to EDT tree nodes).
It is not stored in the trace node store because its lifetime is
different: its contents does not change during a tree deepening
operation.
browser/declarative_execution.m:
Store the current value of the I/O action counter with each call and
exit node. The list of I/O actions associated with the atom of the exit
node is given by the I/O actions whose counters lie between these two
values (initial inclusive, final exclusive).
browser/declarative_debugger.m:
browser/declarative_oracle.m:
Distinguish atoms associated with exit nodes from atoms associated with
call nodes, since the former, but not the latter, now have a list of
I/O actions associated with them.
browser/declarative_user.m:
Add mechanisms for printing and browsing the I/O actions associated
with EDT nodes and bugs.
runtime/mercury_trace_base.[ch]:
Move the code for finding an I/O action here from the file
mercury_trace_declarative.c, for use by browser/io_action.m.
runtime/mercury_layout_util.[ch]:
Move a utility function here from mercury_trace_declarative.c,
for use by the code moved to mercury_trace_base.c.
trace/mercury_trace_declarative.c:
When invoking the front end, pass to it the boundaries of the required
I/O action map. Cache these boundaries, so we can tell the front end
when reinvocation of the back end by the front end (to materialize
previously virtual parts of the annotated trace) does not require
the reconstruction of the I/O action map.
trace/mercury_trace_vars.[ch]:
Separate out the code for finding an I/O action from the code for
browsing it, for use in mercury_trace_declarative.c.
Note places where the implementation does not live up to the
documentation.
trace/mercury_trace.[ch]:
Add a parameter to MR_trace_retry that allows retries to cross I/O
actions without asking the user if this is OK.
trace/mercury_trace_internal.c:
trace/mercury_trace_external.c:
Pass MR_FALSE as this new parameter to MR_trace_retry.
tests/debugger/declarative/tabled_read_decl.{m,inp,exp}:
A slightly modified copy of the tests/debugger/tabled_read_decl test
case, to check the declarative debugger's handling of goals with I/O
actions.
tests/debugger/declarative/Mmakefile:
Enable the new test case.
|
||
|
Mark Brown
|
14ceb68776 |
Change the definitions of decl_question and decl_answer in the declarative
Estimated hours taken: 24 Branches: main Change the definitions of decl_question and decl_answer in the declarative debugger. Each question now contains a reference to the EDT node that generated the question, and each answer contains the reference from the question it applies to. Previously, the answers referred to the questions themselves. This change means that the analyser no longer needs to unify questions to determine what to do with an answer. The reason we need to avoid this is that questions may contain higher order terms, and these will cause a runtime abort if unified. Also, by using our new approach it is possible to simplify the analyser in a number of ways. This is the first part of a larger change to support declarative debugging of higher order code. The main task remaining is to avoid using comparison of questions in the oracle. But this will require a different approach than the one taken here, because the oracle is interested in the value of the question, not just the identity of it. browser/declarative_*.m: Propagate the effect of the changes to decl_question and decl_answer. Fix some comments which are out of date, and elaborate on some others which don't give enough information. browser/declarative_analyser.m: Remove the definition of the suspect/1 type. Its main purpose was to associate a question with its EDT node, but this is no longer required. Update the places that used suspect(T) to instead use either decl_question(T) or just T, as appropriate. Separate out the code which calculates the analyser response. This requires adding some fields to the analyser state, but this in turn means that the processing of answers can be greatly simplified. This should also make implementing more sophisticated search strategies possible, which is something we want to do in the future. browser/declarative_debugger.m: Make the changes to the two exported types. Export a function which extracts the EDT node from the question. browser/declarative_oracle.m: browser/declarative_user.m: Add a type parameter to oracle_response and user_response, similarly to the change to the other types. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/dependency2.exp: tests/debugger/declarative/dependency2.inp: tests/debugger/declarative/dependency2.m: A test case, which tests for a bug I encountered when developing this change. tests/debugger/declarative/family.exp: Because of the change to the way the analyser matches up the answers with the EDT, a different but equally valid instance of the same bug is chosen in part of this test case. Update the expected output to reflect this. |
||
|
Mark Brown
|
03a8cad379 |
Document the type variable naming conventions for mercury_edt.
Estimated hours taken: 0.1 Branches: main browser/declarative_analyser.m: Document the type variable naming conventions for mercury_edt. browser/declarative_execution.m: Document the type variable naming conventions for annotated_trace. browser/declarative_debugger.m: Document the type edt_node/1. |
||
|
Zoltan Somogyi
|
700e5cc1b6 |
Redesign the way the declarative debugger tracks dependencies, to avoid bugs
Estimated hours taken: 60
Branches: main
Redesign the way the declarative debugger tracks dependencies, to avoid bugs
and make the code comprehensible. This required tackling an issue we could
ignore before: the typeinfos added to procedure arguments by the compiler.
browsers/declarative_debugger.m:
Rewrite the dependency algorithm from scratch. It now has three phases:
materializing the contour leading up to the relevent point in the
procedure body, using that contour to construct a list of the conjoined
primitive operations executed up to that point by the procedure body,
and tracking the source of the marked subterm in this list of
primitives.
Add a mechanism to print out the result of the dependency tracking
algorithm if a flag is set, for testing and debugging.
browsers/declarative_analyser.m:
Transmit the result of the dependency tracking algorithm to where
it may be printed out.
browsers/declarative_user.m:
Update the user interface to make it switchable between viewing atoms
from the user's perspective (with compiler-generated arguments hidden)
and the implementor's perspective (with compiler-generated arguments
visible). The default view is the user view.
browsers/declarative_execution.m:
Add the immediate parent's goal path to the representation of call
events; this allows us to place the call in the body of its parent.
Expand the representation of atom arguments to include their HLDS
variable numbers, and a boolean that says whether the argument
is a programmer-visible headvar.
Use this extra information to add support for indexing lists of
arguments from either the user view or the implementor view.
Add field names to several types.
browsers/program_representation.m:
Add a field to plain calls, giving the name of the module defining
the called procedure. This is necessary to reliably distinguish
the builtin unify and compare procedures, calls to which must be
handled specially because they generate no events. (They don't need to,
since they are correct by construction.)
Add mechanisms for converting goal paths from strings to structured
terms, for use by the dependency tracking code.
Add tests on atomic goals, for use by the dependency tracking code.
Add a mechanism to let C code retrieve the types of proc_reps as well
as goal_reps.
compiler/prog_rep.m:
Fill in the module name field in plain calls.
trace/mercury_trace_vars.[ch]:
Add functions to get information about a variable specified by HLDS
number.
trace/mercury_trace_declarative.c:
Include typeinfos in the atoms constructed at interface events.
(The same code will work for typeclassinfos as well, once they
become deconstructable and hence printable.)
Fill in the extra slot in call events, and the extra slots in
representations of atom arguments.
trace/mercury_trace_internal.c:
Fix a bug in the implementation of the proc_body command: the
type of the proc_rep slot is proc_rep, not goal_rep.
tests/debugger/declarative/dependency.{m,inp,exp}:
A new test case to exercise dependency tracking. It cooperates with
instrumentation code in the browser directory to print out the result
of each trace_dependency operation.
The test case also tests the proc_body command.
tests/debugger/declarative/Mmakefile:
Enable the new test case.
|
||
|
Mark Brown
|
d9f96a8c20 |
Use record syntax for the analyser state.
Estimated hours taken: 0.25 Branches: main browser/declarative_analyser.m: Use record syntax for the analyser state. |
||
|
Mark Brown
|
75a2a90cbb |
This is the second part of a change to support term dependency analysis
Estimated hours taken: 40 Branches: main This is the second part of a change to support term dependency analysis in the declarative debugger. A `mark' command is implemented for the term browser, which allows a particular subterm to be selected and returned from the browser. The declarative debugger interprets this as a suspicious subterm, and tries to find a child or sibling node from which this subterm comes. This is used to determine the next question to be asked of the oracle. browser/browse.m: Update the browser interface to allow for marked subterms being returned from the browser. Implement and document the mark command. Rewrite run_command as a switch instead of a chain of if-then-elses. This forces all unimplemented commands to be explicitly listed, and gives better error checking. browser/browser_info.m: Add a maybe_mark field to the browser_info. It is initially `no', but is updated when the mark command is given. browser/declarative_analyser.m: Select which child or sibling node to ask about next by searching for the origin of the suspicious subterm. If the subterm has mode `out' we act as if the oracle had answered no, and if the subterm has mode `in' we act as if the oracle had answered yes. In future we may not wish to presume this -- we do so now mainly to keep the analysis algorithm simpler. browser/declarative_debugger.m: Add a functor for suspicious subterms to the decl_answer type. browser/declarative_oracle.m: Accommodate the changed answer type. The oracle does not try to store information about suspicious subterms in the knowledge base, because in principle this could lead to infinite loops (although currently this wouldn't be a problem since we don't ever use the information to move upward in the tree, so no cycle could be formed). browser/declarative_user.m: Accommodate the changed answer type, and interpret marked terms from the browser as suspicious subterms. browser/parse.m: Add the new command. browser/program_representation.m: Add a procedure to convert the browser's list(dir) to a term_path. Change atomic_goal_rep_is_call/2 so it fails for special predicates, which was originally intended. trace/mercury_trace_browse.c: Ignore the extra argument -- marked terms are not currently used in the main debugger. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/input_term_dep.*: tests/debugger/declarative/output_term_dep.*: tests/debugger/declarative/special_term_dep.*: New test cases. |
||
|
Mark Brown
|
0b062bc60f |
This is the first part of a change to support term dependency analysis
Estimated hours taken: 80 This is the first part of a change to support term dependency analysis in the declarative debugger. A method is added to the mercury_edt typeclass which finds the origin of a selected subterm in an EDT node, somewhere in the body of the call or in the body of the parent. The other parts of the change required before this can be useful are to modify the search strategy (in browser/declarative_analyser.m) to make use of the new information, and to modify the user interface to allow a subterm to be selected. They will be committed as separate changes. The typeclass method first traverses one or more contours, matching the contour events up with goals in a procedure representation. This matching process requires a left to right traversal, because we need to know which disjunct/arm/branch was taken before we can match subgoals, and the DISJ/SWTCH/THEN/ELSE events which tell us this information occur at the left edge of the subgoals to which they apply. But we must always start from the right hand side of the contour being traversed, so this means that a right to left traversal is required before the matching can start. Using the contour matched up with the atomic goals, we track the location of a subterm by looking at which variables are bound, while scanning right to left along the contour. Because this must happen after the matching, this must be a separate right to left traversal than the earlier one. Therefore the algorithm implemented here requires two passes over the contours in order to find the origin of the selected subterm. browser/declarative_execution.m: Add a maybe(goal_rep) to call nodes in the annotated trace. This is `no' if the relevant module was compiled below trace level `rep'. trace/mercury_trace_declarative.c: If the information is available, fill in the goal_rep when constructing call nodes. browser/declarative_analyser.m: Add the new method to the mercury_edt typeclass. browser/declarative_debugger.m: Implement the new method. Update for the changed call nodes. browser/program_representation.m: Add a version of goal_paths to be used by the declarative debugger, and a predicate to parse these from goal_path_strings. Add the types arg_pos and term_path to represent a subterm of a call or exit. browser/program_representation.m: compiler/prog_rep.m: No longer store conjunctions in reverse order in the goal_rep; we now store them in the same order as in the HLDS. Although we search conjunctions in reverse order, we need to match them up with contour events before doing that. This can only be done in the forwards direction, so it turns out that there is no advantage in storing them in reverse order. compiler/hlds_goal.m: compiler/trace.m: Add comments to the existing definitions of goal_path and path_step_to_string. |
||
|
Mark Brown
|
9578ff16bb |
Alter the `dd' command in mdb so that it does not assume that the answer
Estimated hours taken: 2.5
Alter the `dd' command in mdb so that it does not assume that the answer
to the first question asked is `no'. The question is somewhat redundant,
since the only sensible answer is `no', but I find that it gives useful
feedback about the symptom that is being diagnosed, and it makes clearer
why the following questions are asked.
browser/declarative_analyser.m:
Start analysis with a list of suspects which contains only the
topmost node of the debugging tree.
browser/declarative_debugger.m:
If the answer to the first question is something other than `no',
then end the diagnosis and report that no bugs were found.
tests/debugger/declarative/*.{inp,exp,exp2}:
Update test cases to handle the extra question.
|
||
|
Mark Brown
|
1c587d56af |
Implement the expanding of implicit subtrees in the declarative debugger.
Estimated hours taken: 40 Implement the expanding of implicit subtrees in the declarative debugger. When the maximum depth is reached by the front end, it now returns to the back end a request for the missing subtree. If the back end receives such a request, it restarts declarative debugging with a different topmost call and a deeper depth bound. The EDT instance needs to know when to request expansion, so CALL nodes need a flag to indicate whether they were at the maximum depth. The front end needs to be able to point out the bug and/or subtree to the back end, so CALL, EXIT and FAIL nodes need to record the event number. browser/declarative_execution.m: - Store the event number in CALL, EXIT and FAIL nodes. - Store a bool in CALL nodes which indicates whether the event was at the maximum depth or not. browser/declarative_debugger.m: - Store the event number of the buggy event in the reported bug, and pass this event number to the back end so it can go back to that event. - Add a case for expanding an implicit tree to the diagnoser_response type, and handle this response properly. - Export procedures to C that allow acces to the diagnoser_response type. - Accommodate the changes to the trace_node type. browser/declarative_analyser.m: - Store the list of previous prime suspects in the analyser state. That way they don't have to be specially dealt with when restarting analysis with an expanded subtree. - When starting analysis, assume the top node is wrong; this is not an unreasonable assumption, and the strategy works better for the case when a subtree is expanded. browser/declarative_user.m: - Accommodate changes to the reported bug. trace/mercury_trace_declarative.c: - Change the depth step size to a reasonable number, now that it works. This also has the effect of testing the change, since some test cases go deeper than the new limit. - Filter events outside the topmost call. Rather than keep track of the minimum depth, we record the topmost call sequence number and use a global to keep track of whether we have entered or left this procedure. - Factor out code in the existing mechanism for starting declarative debugging, so that it can be used to re-start debugging as well. - Accommodate the changes to the trace_node type. - Output error messages if declarative debugging fails to start properly. - Handle the reponse from the diagnoser, by jumping to the buggy event (if a bug is found) or re-executing to expand a subtree (if one is requested). - Add a new checkpoint for events which are filtered out of the annotated trace. trace/mercury_trace_internal.c: - Don't report error messages when declarative debugging fails to start. Errors are now reported by the declarative debugger before returning. tests/debugger/declarative/*.inp: tests/debugger/declarative/*.exp: tests/debugger/declarative/*.exp2: - Update to reflect the removed questions. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/filter.m: tests/debugger/declarative/filter.inp: tests/debugger/declarative/filter.exp: - New test case to cover the code which filters events which are outside the topmost call. |