mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-17 06:47:17 +00:00
b51c742885663bd7ced585debc906d5d6c85b205
47 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Zoltan Somogyi
|
b51c742885 |
Allow the debugger to print higher order values and typeinfos, mainly by
Estimated hours taken: 50
Branches: main
Allow the debugger to print higher order values and typeinfos, mainly by
making the committed choice modes of the predicates in deconstruct.m to
deconstruct higher order values and typeinfos. (The non committed choice
versions will continue to return only placeholders.)
Having the debugger print typeinfos is occasionally useful but more often
it is just distracting. This change therefore adds a new debugger command,
"print_optionals", that toggles the printing of optional values. For now,
the only optional values are typeinfos.
NEWS:
Mention the new capability and the new predicates in the library.
Mention the predicates added previously that allow the caller to
specify how non-canonical terms should be handled, since the change
in their semantics that we anticipated when they were added has now
happened, and their semantics should now be more stable.
browser/browser_info.m:
Use the predicates in the deconstruct.m instead of std_util,
to make the choice of noncanonical term method handling explicit.
browser/browse.m:
When writing small terms using io__write_univ, explicitly use
the same noncanonical term handling method as browser_info.m
library/io.m:
Add predicates to retrieve the current input and output streams.
Add versions of io__write_univ that specify the stream and maybe
the method of handling noncanonical terms.
Add a mode to io__write_list that allows the closure that prints the
list elements to be cc_multi.
All of these are for the new functionality in the browser.
runtime/mercury_ml_expand_body.h:
In committed choice contexts, deconstruct closures as if they were
ordinary terms, with the function symbol being the name of the
predicate/function and the arguments being the terms stored in
the closure.
In committed choice contexts, deconstruct typeinfos as if they were
ordinary terms, with the function symbol being the name of the type
constructor and the arguments being the type constructor's arguments.
runtime/mercury_type_info.[ch]:
Add a new function, MR_collapse_ctor_equivalences, for use by
mercury_ml_expand_body.h.
Delete a redundant function comment.
library/deconstruct.m:
Document the changes in the behavior of the predicates defined in this
module as a result of the change to mercury_ml_expand_body.h.
runtime/mercury_ho_call.h:
runtime/mercury_stack_layout.h:
Add prefixes on structure field names that did not have them.
browser/dl.m:
Add prefixes where needed by the changes to mercury_ho_call.h.
runtime/mercury_layout_util.[ch]:
Remove the first argument of MR_materialize_closure_typeinfos, since
its correct value is always the same part of the second argument.
runtime/mercury_deep_copy_body.h:
Do not pass the first argument of MR_materialize_closure_typeinfos.
Add field name prefixes where necessary.
compiler/modules.m:
The mercury_builtin module is no longer part of the library.
compiler/pd_debug.m:
compiler/rl_analyze.m:
Minor updates to avoid trying to take the address of io__write_list,
since it now has more than one mode.
runtime/mercury_init.h:
runtime/mercury_wrapper.[ch]:
trace/mercury_trace_vars.[ch]:
Add a parameter to MR_trace_browse_all_on_level that specifies
whether we should print values of type type_info.
trace/mercury_trace_vars.c:
Do not ignore predicates and functions anymore.
runtime/mercury_stack_trace.c:
trace/mercury_trace.c:
trace/mercury_trace_declarative.c:
trace/mercury_trace_external.c:
Pass the new parameter of MR_trace_browse_all_on_level.
trace/mercury_trace_internal.c:
Implement the "print_optionals" command.
doc/user_guide.texi:
Document the "print_optionals" command.
tests/debugger/mdb_command_test.inp:
Test the documentation of "print_optionals".
tests/debugger/higher_order.{m,inp,exp,exp2}:
A new test case to exercise the ability to print higher order values.
Note that the format of the predicate names in the output should be
improved, but that is a separate change since doing it the right way
requires bootstrapping.
tests/debugger/Mmakefile:
Enable the new test case.
tests/debugger/nondet_stack.exp*:
Update the expected output to reflect the fact that nondet stack dumps,
being intended for debugging, include type_infos.
tests/debugger/tabled_read_decl.exp*:
Update the expected output to reflect the fact that for maximum
usefulness, the printing of I/O action atoms prints meaningful
type_infos.
tests/hard_coded/deconstruct_arg.*:
tests/hard_coded/write_reg1.*:
Expand these tests to check that we handle higher order values
correctly not just when canonicalizing but also in committed choice
modes.
|
||
|
Simon Taylor
|
b7c4a317e9 |
Add MR_ prefixes to the remaining non-prefixed symbols.
Estimated hours taken: 4 Branches: main Add MR_ prefixes to the remaining non-prefixed symbols. This change will require all workspaces to be updated The compiler will start generating references to MR_TRUE, MR_bool, etc., which are not defined in the old runtime header files. runtime/mercury_std.h: Add MR_ prefixes to bool, TRUE, FALSE, max, min, streq, strdiff, strtest, strntest, strneq, strndiff, strntest, NO_RETURN. Delete a commented out definition of `reg'. runtime/mercury_tags.h: Add an MR_ prefix to TAGBITS. configure.in: runtime/mercury_goto.h: runtime/machdeps/i386_regs.h/mercury_goto.h: Add an MR_ prefix to PIC. runtime/mercury_conf_param.h: Allow non-prefixed PIC and HIGHTAGS to be defined on the command line. runtime/mercury_bootstrap.h: Add backwards compatibility definitions. RESERVED_MACRO_NAMES: Remove the renamed macros. compiler/export.m: compiler/ml_code_gen.m: Use MR_bool rather than MR_Bool (MR_Bool is meant to be for references to the Mercury type bool__bool). runtime/mercury_types.h: Add a comment the MR_Bool is for references to bool__bool. */*.c: */*.h: */*.m: Add MR_ prefixes. |
||
|
Zoltan Somogyi
|
04e614485d |
Implement deep profiling; merge the changes on the deep2 branch back
Estimated hours taken: 500 Branches: main Implement deep profiling; merge the changes on the deep2 branch back onto the trunk. The main documentation on the general architecture of the deep profiler is the deep profiling paper. doc/user_guide.texi: Document how to use the deep profiler. deep_profiler: deep_profiler/Mmakefile: A new directory holding the deep profiler and its mmakefile. Mmakefile: Add targets for the new directory. Add support for removing inappropriate files from directories. deep_profiler/interface.m: The deep profiler consists of two programs: mdprof_cgi.m, which acts as a CGI "script", and mdprof_server.m, which implements the server process that the CGI script talks to. Interface.m defines the interface between them. script/mdprof.in: A shell script template. ../configure uses it to generate mdprof, which is a wrapper around mdprof_cgi that tells it how to find mdprof_server. deep_profiler/mdprof_cgi.m: The CGI "script" program. deep_profiler/mdprof_server.m: The top level predicates of the server. deep_profiler/profile.m: The main data structures of the server and their operations. deep_profiler/read_profile.m: Code for reading in profiling data files. deep_profiler/startup.m: Code for post-processing the information in profiling data files, propagating costs from procedures to their ancestors and performing various kinds of summaries. deep_profiler/server.m: Code for responding to requests from the CGI script. deep_profiler/cliques.m: Code to find cliques in graphs. deep_profiler/array_util.m: deep_profiler/util.m: Utility predicates. deep_profiler/dense_bitset.m: An implementation of (part of) the set ADT with dense bit vectors. deep_profiler/measurements.m: Operations on profiling measurements. deep_profiler/timeout.m: An implementation of a timeout facility. deep_profiler/conf.m: Functions that depend on autoconfigured settings. configure.in: Find out what command to use to find the name of the local host. Install deep profiling versions of the standard library along with the other profiling versions. runtime/mercury_conf.h.in: Add some macros for deep_profiler/conf.m to use. library/profiling_builtin.m: runtime/mercury_deep_call_port_body.h: runtime/mercury_deep_leave_port_body.h: runtime/mercury_deep_redo_port_body.h: A new library module that implements deep profiling primitives. Some of these primitives have many versions, whose common code is factor is factored out in three new include files in the runtime. compiler/deep_profiling.m: New module to perform the program transformations described in the paper. compiler/notes/compiler_design.html: Document the new compiler module. compiler/mercury_compiler.m: Invoke the new module in deep profiling grades. Allow global static data to be generated by deep_profiling.m. compiler/options.m: Add options to turn on deep profiling and (for benchmarking purposes) control its implementation. Add an optiooption disable tailcall optimization in the LLDS backend, to help benchmarking deep profiling. compiler/jumpopt.m: compiler/optimize.m: Obey the option to disable tailcalls. compiler/handle_options.m: Handle the implications of deep profiling. compiler/modules.m: In deep profiling grades, automatically import profiling_builtin.m. compiler/prog_util.m: doc/Makefile: library/library.m: Handle the new builtin module. compiler/export.m: In deep profiling grades, wrap deep profiling code around exported procedures to handle the "unscheduled call" aspects of callbacks to Mercury from the foreign language. compiler/higher_order.m: profiler/demangle.m: util/demangle.c: When creating a name for a higher-order-specialized predicate, include the mode number in the name. compiler/add_trail_ops.m: compiler/type_util.m: Move c_pointer_type from add_trail_ops to type_util, so it can also be used by deep_profiling.m. compiler/hlds_goal.m: Add a new goal feature that marks a tail call, for use by deep_profiling.m. compiler/hlds_pred.m: Add a new field to proc_info structures for use by deep_profiling.m. Add a mechanism for getting proc_ids for procedure clones. Remove next_proc_id, an obsolete and unused predicate. compiler/hlds_data.m: Add a new cons_id to refer to the proc_static structure of a procedure. compiler/bytecode_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/switch_util.m: compiler/unify_gen.m: Trivial changes to handle the new cons_id, goal feature and/or proc_info argument. compiler/rtti.m: Add a utility predicate for extracting pred_id and proc_id from an rtti_proc_label, for use by hlds_out.m compiler/layout.m: compiler/layout_out.m: compiler/llds.m: compiler/llds_common.m: Add support for proc_static and call_site_static structures. compiler/layout_out.m: compiler/llds_out.m: Add code for the output of proc_static structures. compiler/code_util.m: Make code_util__make_proc_label_from_rtti a function, and export it. util/mkinit.c: compiler/llds_out.m: compiler/layout.m: compiler/modules.m: Add support for a fourth per-module C function, for writing out proc_static structures (and the call_site_static structures they contains). Since proc_static structures can be referred to from LLDS code (and not just from other static structures and compiler-generated C code), reorganize the declarations of static structures slightly. Change the schema for the name of the first per-module C function slightly, to make it the addition of the fourth function easier. The scheme now is: mercury__<modulename>__init mercury__<modulename>__init_type_tables mercury__<modulename>__init_debugger mercury__<modulename>__write_out_proc_statics Improve formatting of the generated C code. library/*.m: runtime/mercury.c: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_tabling.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: trace/mercrury_trace.[ch]: trace/mercrury_trace_declarative.c: trace/mercrury_trace_external.c: trace/mercrury_trace_internal.c: Conform to the new scheme for initialization functions for hand-written modules. compiler/mercury_compile.m: library/benchmarking.m: runtime/mercury_conf_param.h: runtime/mercury.h: runtime/mercury_engine.c: runtime/mercury_goto.c: runtime/mercury_grade.h: runtime/mercury_ho_call.c: runtime/mercury_label.[ch]: runtime/mercury_prof.[ch]: Add an MR_MPROF_ prefix in front of the C macros used to control the old profiler. compiler/handle_options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make deep profiling completely separate from the old profiling system, by making the deep profiling grade independent of MR_MPROF_PROFILE_TIME and the compiler option --profile-time. library/array.m: library/builtin.m: library/std_util.m: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_compare_body.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of hand-written unification and comparison procedures. Make the reporting of array bounds violations switchable between making them fatal errors, as we currently, and reporting them by throwing an exception. Throwing an exception makes debugging code using arrays easier, but since exceptions aren't (yet) propagated across engine boundaries, we keep the old behaviour as the default; the new behaviour is for implementors. runtime/mercury_deep_profiling_hand.h: New file that defines macros for use in Mercury predicates whose definition is in hand-written C code. library/exception.m: runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of the various modes of builtin_catch. Provide a function that C code can use to throw exceptions. library/benchmarking.m: library/exception.m: library/gc.m: library/std_util.m: runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_overflow.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_thread.c: runtime/mercury_wrapper.c: Add prefixes to the names of the fields in the engine and context structures, to make code using them easier to understand and modify. runtime/mercury_deep_profiling.[ch]: New module containing support functions for deep profiling and functions for writing out a deep profiling data file at the end of execution. runtime/mercury_debug.[ch]: Add support for debugging deep profiling. Add support for watching the value at a given address. Make the buffered/unbuffered nature of debugging output controllable via the -du option. Print register contents only if -dr is specified. runtime/mercury_goto.h: runtime/mercury_std.h: Use the macros in mercury_std.h instead of defining local variants. runtime/mercury_goto.h: runtime/mercury_stack_layout.h: runtime/mercury_stack_trace.c: runtime/mercury_tabling.c: trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Standardize some of the macro names with those used in the debugger paper. runtime/mercury_heap.h: Add support for memory profiling with the deep profiler. runtime/mercury_prof.[ch]: runtime/mercury_prof_time.[ch]: Move the functionality that both the old profiler and the deep profiler need into the new module mercury_prof_time. Leave mercury_prof containing stuff that is only relevant to the old profiler. runtime/mercury_prof.[ch]: runtime/mercury_strerror.[ch]: Move the definition of strerror from mercury_prof to its own file. runtime/mercury_wrapper.[ch]: Add support for deep profiling. Add suppory for controlling whether debugging output is buffered or not. Add support for watching the value at a given address. runtime/Mmakefile: Mention all the added files. scripts/mgnuc.in: Add an option for turning on deep profiling. Add options for controlling the details of deep profiling. These are not documented because they are intended only for benchmarking the deep profiler itself, for the paper; they are not for general use. tools/bootcheck: Compile the deep_profiler directory as well as the other directories containing Mercury code. Turn off the creation of deep profiling data files during bootcheck, since all but one of these in each directory will be overwritten anyway. Add support for turning on --keep-objs by default in a workspace. tools/speedtest: Preserve any deep profiling data files created by the tests. trace/mercury_trace.c: Trap attempts to perform retries in deep profiling grades, since they would lead to core dumps otherwise. util/Mmakefile: Avoid compile-time warnings when compiling getopt. tests/*/Mmakefile: tests/*/*/Mmakefile: In deep profiling grades, switch off the tests that test features that don't work with deep profiling, either by design or because the combination hasn't been implemented yet. |
||
|
Fergus Henderson
|
9a445fd62b |
Fix a bug that broke tests/debugger/declarative/*_term_dep.m
Estimated hours taken: 0.5 Branches: main Fix a bug that broke tests/debugger/declarative/*_term_dep.m when compiled with lcc. runtime/mercury_stack_layout.h: Change the type of the proc_rep field from MR_Word to MR_Word *, to avoid casts from pointers to integers in static initializers, which are not allowed in ANSI/ISO C. trace/mercury_trace_internal.c: trace/mercury_trace_declarative.c: Add some casts to match the change to mercury_stack_layout.h. |
||
|
Mark Brown
|
d3cec16cec |
Improve meta-debugging of the declarative debugger.
Estimated hours taken: 2 Branches: main Improve meta-debugging of the declarative debugger. Add a declarative debugging mode which leaves MR_trace_enabled equal to TRUE when the front end is called, so that it generates trace events. This mode is used by invoking the mdb command 'dd_dd' with no parameters. This is a developer-only command. Rearrange code to reduce duplication. trace/mercury_trace_declarative.h: trace/mercury_trace_declarative.c: - Handle all debugging modes via MR_decl_diagnosis (subsuming the functionality of MR_decl_diagnosis_test). - Add an argument for the trace mode to MR_trace_start_decl_debug, and use this information to determine its behaviour. - Add a missing fflush of MR_mdb_out. trace/mercury_trace_internal.c: - Implement the new version of dd_dd. - Move the code for checking the current port into MR_trace_start_decl_debug. trace/mercury_trace_internal.h: - Add the new mode to MR_Trace_Mode. - Rename MR_TRACE_DECL_DEBUG_TEST to MR_TRACE_DECL_DEBUG_DUMP, since there are now two modes for testing. |
||
|
David Jeffery
|
19ceeaf30f |
Merge the changes from the HAL branch onto the main branch.
Estimated hours taken: 40
(to do this merge... 100s of hours on the HAL branch
itself by myself and Warwick Harvey though).
Merge the changes from the HAL branch onto the main branch. With the recent
changes made to the HAL implementation, this means adding just one grade,
`.rt' or --reserve-tag, which reserves one tag (zero) in each type for
use by HAL's Herbrand constraint solver. This disables no-tag types and
enumerations.
This grade will now bootstrap, and passes all tests, except for a few failing
cases in the debugger and tabling directories.
compiler/options.m:
compiler/handle_options.m:
Add the `.rt' or --reserve-tag grade option.
runtime/mercury_conf_param.h:
Document the macro MR_RESERVE_TAG
doc/user_guide.texi:
Document the `.rt' grade.
compiler/make_hlds.m:
Don't record any types as no-tag types if we are in a .rt grade.
compiler/make_tags.m:
compiler/type_ctor_info.m:
Allocate tags starting from `1' in .rt grades.
compiler/rtti_out.m:
In .rt grades, output a dummy ptag definition for tag `0'.
compiler/type_util.m:
Add predicates `type_util__constructors_are_dummy_argument_type' and
`type_constructors_are_type_info' for use when allocating tags to
ensure that type infos and dummy types (io__state/0 and store__store/1)
are still treated as no-tag types in .rt grades.
library/sparse_bitset.m:
When allocating a sparse bitset element, use tag `1' if we are in a
.rt grade.
runtime/mercury_tags.h:
Define a macro `MR_UNIV_TAG' which is `1' is we in a .rt grade and
`0' otherwise. (Now that univ is a user defined type, it is a also
assigned a `var' tag).
Also make the definitions of MR_RAW_TAG_NIL and MR_RAW_TAG_CONS take the
.rt grade into account.
runtime/mercury_type_info.h:
Define `MR_unravel_univ' and
`MR_initialise_univ' for taking apart and putting together univs.
Add a new secondary tag alternative: MR_SECTAG_VARIABLE, used to
represent Herbrand variables.
library/std_util.m:
Use MR_UNIV_TAG, MR_unravel_univ and MR_initialise_univ when
manipulating univs.
Handle the new MR_SECTAG_VARIABLE secondary tag by aborting.
runtime/mercury_deep_copy_body.h:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
Handle the new MR_SECTAG_VARIABLE secondary tag by aborting.
library/std_util.m:
Add a constant for MR_SECTAG_VARIABLE in the MC++ back end.
scripts/canonical_grade.sh-subr:
scripts/init_grade_options.sh-subr:
scripts/mgnuc.in:
scripts/parse_grade_options.sh-subr:
Process the new grade.
scripts/mmake.in:
Add an option `--include-makefile', which includes a Makefile given
as a command line argument into the Makefile generated by mmake.
This is used to implement `halmake', a make program for HAL which
just passes a bunch of extra rules and variable definitions onto
mmake.
tests/debugger/existential_type_classes.m:
tests/hard_coded/existential_types_test.m:
trace/mercury_trace_declarative.c:
trace/mercury_trace_external.c:
trace/mercury_trace_internal.c:
Use MR_UNIV_TAG.
TODO:
- The declarative debugger falls over in .rt grades. This is possibly
because compiler/static_term.m assumes that the generated code uses
the same data representation as the compiler itself. This should be
fixed, although it is not critical; the declarative debugger won't
work with trailing as is, and the .rt grade is only ever used in
conjunction with trailing (.tr) at this stage.
|
||
|
Zoltan Somogyi
|
2498d9d3fd |
Instead of generating the layout structures of labels, procs and modules
Estimated hours taken: 36 Instead of generating the layout structures of labels, procs and modules as rvals, generate them almost entirely as C structures. This will make future modifications much easier, since mismatches between what the runtime expects and what the compiler generates will now be pointed out by the C compiler. (It also reduces the size of the C source files generated with debugging enabled by about 5%.) Layout structures contain a few components that are not well-typed in C; we continue to generate these as rvals. Closure layout structures used to have a well-typed part and a non-well-typed part. We now generate the well-typed part as a separate structure, pointed to from the other. We also extend the well-typed part, so that instead of just giving the name the called procedure, it also identifies the source location where the closure was constructed. This could be useful for the debugger and for deep profiling. This diff also includes a change to get the compiler to bootstrap with lcc in grade none.gc.debug.tr: initializing the string tables in module layouts not as a string but as an array of characters. runtime/mercury_stack_layout.h: Reorganize the definitions of layout structures. Rename Stack_Layout_Entry structures as Proc_Layout structures, and Stack_Layout_Label structures as Label_Layout structures. (The debugger paper refers to the structures by the new names.) Fold the Stack_Layout_Vars structure into the structure that contains it, the Label_Layout structure. Add a Closure_Id structure that contains a Proc_Id structure as well as extra information identifying the source location where the closure was created. Create "short" versions of the Proc_Layout structures, which contain only the first one or two of the three groups of fields. Previously, the Mercury compiler would define new C types when it generated such short structures. Since we are not defining new C types anymore, there must be a C type for every kind of structure the Mercury compiler can generate. We now also have separate variants for the layouts of user-defined and compiler-generated procedures, since the format of their procedure id information is different. While the runtime system refers to their procedure id information through a union, the C types of the structures generated by the Mercury compiler do not use a union, since a union cannot be initialized through its second member. Make the constant fields of structures const, since we now generate values of those structure types, and initialize them with constant data. Move the documentation of layout structures here from stack_layout.m. runtime/mercury_ho_call.h: Instead of bodily including an MR_Proc_Id structure in closures, include a pointer to the more detailed MR_Closure_Id structure. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_init.h: runtime/mercury_label.[ch]: runtime/mercury_layout_util.[ch]: Minor updates to conform to changes in mercury_stack_layout.h. runtime/mercury_goto.h: Use separate naming schemes for label layout structures and proc layout structures. library/exception.m: Minor updates to conform to changes in mercury_stack_layout.h. compiler/layout.m: A new module that defines data structures for label, proc and module layout structures and for closure id structures. compiler/layout_out.m: A new module that converts the Mercury data structures of layout.m into declarations and definitions of C data structures. compiler/stack_layout.m: Generate the new layout structures instead of rvals. Move the documentation of layout structures from here to runtime/mercury_stack_layout.h, since this module is no longer aware of some of their details. compiler/llds.m: Make layout structures a separate kind of compiler-generated data. compiler/llds_out.m: Remove the code for the output of layout structures; call layout_out.m instead. compiler/llds_out.m: compiler/rtti_out.m: Turn some predicates into functions. compiler/code_gen.m: compiler/code_info.m: compiler/llds.m: compiler/mercury_compile.m: compiler/unify_gen.m: Instead of handling closure layouts like other static data, handle them separately. Add a counter to the code_info structure in order to allow closure id structures to be identified uniquely by a pair consisting of the id of the procedure that generates them and a closure sequence number within that procedure. compiler/llds_common.m: Look for common rvals among the rvals in layout structures. compiler/opt_debug.m: Generate developer-friendly names for layout structure references. browser/dl.m: Update the code for constructing closure layouts. |
||
|
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. |
||
|
Thomas Conway
|
1bc0b20c70 |
Back out the changes to call back into mercury to construct
trace/mercury_trace_internal.c: trace/mercury_trace_external.c: trace/mercury_trace_declarative.c: Back out the changes to call back into mercury to construct univs and construct them by hand as we did before. These guys slipped though the review earlier. |
||
|
Peter Ross
|
041b28bc69 |
Allow the trace directory to compile in the hlc grade, without it
Estimated hours taken: 0.25
Allow the trace directory to compile in the hlc grade, without it
complaining about missing header files.
mercury_trace_declarative.c:
mercury_trace_external.c:
mercury_trace_internal.c:
Change all references to "std_util.h" to "mercury.std_util.h".
|
||
|
Thomas Conway
|
de80683489 |
This change makes univ a user-defined type (in std_util.m) rather than
Estimated hours taken: 10 This change makes univ a user-defined type (in std_util.m) rather than a builtin type. The rationale for this is that the code for builtin types needs to be maintained by hand when the execution model is changed (eg introducing a new backend), but code for user defined types is modified implicitly. Note that the semantics of deconstruct/4 have changed. See the NEWS file for details. NEWS: Document the changed semantics of deconstruct/4. browser/browse.m: Fix the calls to deconstruct/4 to reflect the changed semantics of deconstruct. library/io.m: Remove the special handling of univ for io__write. Fix the calls to deconstruct/4 to reflect the changed semantics of deconstruct. library/private_builtin.m: Implement typed_unify and typed_compare in terms of type_of and unsafe_type_cast instead of univ, so that preds/funcs operating on univs can be implemented in terms of typed_unify. Add a new impure predicate var/1 which succeeds/fails depending on the instantiation of its argument. This is used to implement bidirectional predicates that require different code for different modes (cf type_to_univ/2). This is *not* mentioned in the NEWS file because it should only be used by implementors. (Well, actually, anyone who wants to do bidirectional code involving existential types may need it, but we don't exactly want to encourage its use ;-). library/std_util.m: Implement univ/0 as a user-defined type rather than a hand coded builtin type. Removed the foreign language code to implement the operations on univs (include unify/2 and compare/3). The implementations of deconstruct, et al, now call back to Mercury to construct/deconstruct univs, so the code of these has changed. Note that there has been an implicit change in the semantics of deconstruct/4, which had non-orthogonal handling of univ inputs. It now handles them orthogonally: deconstruct of a univ yields the functor "univ_cons" and its one argument which will be the wrapped value. The non-orthogonal behaviour wasn't documented before, so deconstruct/4 now behaves as its documentation describes it. library/term.m: Fix the call to deconstruct/4 to reflect the changed semantics of deconstruct. runtime/mercury.c: runtime/mercury_deep_copy_body.h: runtime/mercury_mcpp.h: runtime/mercury_tabling.c: runtime/mercury_type_info.h: runtime/mercury_unify_compare_body.h: Remove declarations and definitions for univ since it is now a user level type rather than a builtin type. trace/mercury_trace_declarative.h: trace/mercury_trace_external.h: trace/mercury_trace_internal.h: Replace the hand-coded constructions of univs with call backs to ML_construct_univ. |
||
|
Zoltan Somogyi
|
ebe9f9a3ec |
Add tabling of I/O actions for the debugger.
Estimated hours taken: 80
Add tabling of I/O actions for the debugger.
compiler/options.m:
Add a new option, --trace-table-io, that enables the tabling of I/O
actions, and another, --trace-table-io-states, that governs whether the
tabling includes the I/O state variables themselves. (You want to table
these variables iff they contain meaningful information that is not
stored in global variables.) These options are for developers only
for now.
compiler/modules.m:
Implicitly import table_builtin if --trace-table-io is specified.
compiler/prog_data.m:
Add eval_table_io as a new eval method.
compiler/hlds_pred.m:
Add a mechanism for checking whether a predicate has an input/output
pair of io__state args.
Extend the tables indexed by eval_method to handle eval_table_io.
compiler/hlds_out.m:
Print the eval method in HLDS dumps.
compiler/table_gen.m:
If a procedure has a pair of I/O state args and is defined using pragma
C code that has the tabled_for_io marker, and --trace-table-io is
specified, then perform I/O tabling on it and mark it as tabled.
compiler/notes/compiler_design.m:
Document that table_gen.m can now change the evaluation methods of
procedures (to eval_table_io).
compiler/stack_layout.m:
runtime/mercury_stack_layout.h:
Add an extra field to proc layouts. If debugging is enabled and a
procedure has I/O state arguments, this field gives the number of the
stack slot which will be filled with the I/O action counter at the
time of the call, so that on retry the debugger can reset the I/O
action counter to this value.
compiler/trace.m:
Add code to reserve and fill this stack slot.
Make the order of fields in the trace_slots structure match the order
in proc layouts.
compiler/code_info.m:
compiler/live_vars.m:
Pass a module_info to trace__setup and trace__reserved_slots.
library/io.m:
Mark the I/O primitives (i.e. procedures that are defined by pragma C
code and do I/O) with the tabled_for_io feature. (See the discussion
of I/O primitives in compiler/table_gen.m.)
Standardize the formatting of predicates defined by pragma C codes.
library/table_builtin.m:
Define the predicates that perform I/O tabling, to which calls are
inserted in I/O tabled predicates. These depend on knowing what the
maximum MR_Unsigned value is.
library/table_builtin.m:
runtime/mercury_tabling_macros.h:
Table nodes implementing a simple kind of trie, which can also be
viewed as a hash table with the hash function hash(n) = hash - start
were already supported by mercury_tabling.c. They are used to
implement I/O tabling, since I/O the tabled action numbers form a
contiguous sequence. Now allow that functionality to be accessed
from the library through macros.
runtime/mercury_trace_base.[ch]:
Add the global variables required by I/O tabling.
trace/mercury_trace.c:
Implement retry across I/O by resetting the I/O counter to the value
it had on entry to the retried call. However, since this is not safe
in general, ask the user for permission first.
trace/mercury_trace.h:
Add two extra arguments to MR_trace_retry to specify the input and
output streams on which to ask permission.
trace/mercury_trace_internal.c:
Add commands to start and stop I/O tabling. For now, they are for use
by developers only and are undocumented; I expect they will change
significantly before being let loose on users.
trace/mercury_trace_external.c:
trace/mercury_trace_declarative.c:
Pass extra arguments to MR_trace_retry to indicate that these modules
are not interested (at least for now) in retry across I/O, since they
do not (yet) have mechanisms for asking the user for permission.
tests/debugger/tabled_read.{m,inp,exp,data}:
A new test case to check retry across tabled and non-tabled I/O.
tests/debugger/Mmakefile:
Enable the new test case.
|
||
|
Fergus Henderson
|
2f737704b9 |
Add some Mmake rules to the runtime and some code to tools/bootcheck
Estimated hours taken: 16 Add some Mmake rules to the runtime and some code to tools/bootcheck so that we automatically check that the namespace remains clean. Also add some `MR_' prefixes that Zoltan missed in his earlier change. tools/bootcheck: Add an option, which is enabled by default, to build the check_namespace target in the runtime. runtime/RESERVED_MACRO_NAMES: New file. Contains a list of the macros names that don't start with `MR_' or the like. runtime/Mmakefile: Change the rule for `check_headers' so that it checks for macros that don't occur in the RESERVED_MACRO_NAMES files, as well as not starting with `MR_' prefixes, and reports errors for such macros. Also add a rule for check_objs that checks whether the object files define any global symbols that don't have the right prefixes, and a rule `check_namespace' that does both of the above. runtime/mercury_bootstrap.h: #include "mercury_types.h" and "mercury_float.h", to ensure that this header file is self-contained. Also make sure that all the old names are disabled if you compile with `-DMR_NO_BACKWARDS_COMPAT'. runtime/mercury_context.c: runtime/mercury_thread.h: runtime/mercury_thread.c: Use `bool' rather than `MR_Bool' for the argument to MR_check_pending_contexts() and the return type of MR_init_thread(), since these are C bools, not Mercury bools, and there's no requirement that they have the same size as MR_Integer. runtime/mercury_type_info.h: runtime/mercury_deep_copy_body.h: runtime/mercury_tabling.c: library/std_util.m: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_internal.c: tests/hard_coded/existential_types_test.m: Add MR_ prefixes to UNIV_OFFSET_FOR_TYPEINFO and UNIV_OFFSET_FOR_VALUE. trace/mercury_trace_external.c: trace/mercury_trace_internal.c: trace/mercury_trace_tables.c: Add MR_ prefixes to do_init_modules(). runtime/mercury_tabling.h: runtime/mercury_tabling.c: runtime/mercury_overflow.h: runtime/mercury_debug.h: Add MR_ prefixes to table_*. runtime/mercury_overflow.h: runtime/mercury_debug.h: Add MR_ prefixes to IF(). runtime/mercury_context.h: Add MR_ prefixes to IF_MR_THREAD_SAFE(). runtime/mercury_engine.h: Add MR_ prefixes to IF_NOT_CONSERVATIVE_GC(). runtime/mercury_engine.h: runtime/mercury_engine.c: extras/aditi/aditi.m: Add MR_ prefixs to do_fail, do_redo, do_not_reached, etc. compiler/trace.m: compiler/fact_table.m: compiler/llds_out.m: Add MR_ prefixes to the generated code. |
||
|
Zoltan Somogyi
|
627ad98da5 |
Add missing MR_ prefixes.
Estimated hours taken: 0.1 trace/mercury_trace_external.c: trace/mercury_trace_declarative.c: trace/mercury_trace_tables.c: Add missing MR_ prefixes. |
||
|
Mark Brown
|
2cefe05a11 |
Record the trace level that the module was compiled with in the module
Estimated hours taken: 3 Record the trace level that the module was compiled with in the module layout structure. Use this to avoid an abort if the 'dd' command is used on a module that is compiled with trace level 'deep'. compiler/trace_params.m: Encode the trace level as an integer. runtime/mercury_stack_layout.h: Add a field to MR_Module_Layout to store the encoded trace level. compiler/stack_layout.m: Fill in this field. trace/mercury_trace_declarative.c: Ignore events from modules that don't have an appropriate trace level. This effectively assumes that the events are correct, so we warn the user that this has happened. Also, disallow the 'dd' command at these events. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/deep_sub.m: tests/debugger/declarative/deep_warning.exp: tests/debugger/declarative/deep_warning.inp: tests/debugger/declarative/deep_warning.m: A test case for the new feature. |
||
|
Zoltan Somogyi
|
1c8cb6faf2 |
Get the compiler to bootstrap with -DMR_NO_BACKWARDS_COMPAT.
Estimated hours taken: 2 Get the compiler to bootstrap with -DMR_NO_BACKWARDS_COMPAT. compiler/c_util.m: compiler/rtti_out.m: Add MR_ prefixes to various type names in generated code. compiler/*.m: browser/*.m: library/*.m: Add MR_prefixes to various type and function names in pragma C code. runtime/*.[ch]: trace/*.[ch]: Add MR_prefixes to various type and function names in hand-written code. |
||
|
Zoltan Somogyi
|
fdccd65e30 |
The debugger's retry command at the moment works only from a final port for
Estimated hours taken: 60
The debugger's retry command at the moment works only from a final port for
the call to be retried, the reason being that the RTTI does not have the
information required to make sure that the state of the stacks is reset
correctly. If you invoke retry from a non-final port, the current
implementation skips forward to a final port and then does the retry;
this does not work if you get a core dump or a infinite loop during the forward
skip. This change adds the required info to the RTTI and thus enables
direct retries from the middle of calls.
The information added has two components. First, if a procedure that lives on
the nondet stack allocates any temporary nondet stack frames, then it must
record the old value of maxfr in a stack slot so that retry can restore it.
Second, if a procedure is tabled, then it must record the call table tip node
corresponding to the actual input arguments, so we can reset this node to
uninitialized (if we don't, then the retried call will find the active call
marker and report an infinite loop error).
The support for retries across minimal model calls is not finished yet.
Finding out what the right thing to do in such cases is a research project,
one that cannot even be started until minimal model tabling works reliably
in the *absence* of retries. However, such retries do grossly wrong things
at the moment; this change is a definite improvement. It attempts to perform
the retry from the fail port, since that is the only time when the minimal
model tabling data structures are quiescent. The "fail" command I added to
the debugger command set to let this be done is not complete yet and is
therefore undocumented; the problem is that a call to a model_non predicate
in a committed choice context will not get to the fail port. I added goal paths
to return layouts so that we will eventually be able to tell when execution
leaves a committed choice context surrounding an ancestor of a model_non
predicate call, but this functionality is not yet implemented.
compiler/stack_layout.m:
Generate the three new fields: the evaluation method, (maybe) the id
of the stack slot containing the saved value of maxfr, and (maybe)
the id of the stack slot containing the call table tip.
compiler/continuation_info.m:
Record the information about the new fields for later use by
stack_layout.m.
Add a new field to record the goal path of calls for their return
layouts.
Fix a screwed comment for the continuation_info data structure.
compiler/llds.m:
Add a new field to call() instructions to hold the goal path of the
call.
Add a utility function for use by trace.m.
compiler/call_gen.m:
Fill in this new field.
compiler/trace.m:
compiler/live_vars.m:
Reserve the fixed stack slot for the saved maxfr if necessary,
and if the call table tip node is needed, make sure that the variable
holding its address is allocated a low-numbered stack slot (otherwise,
its number may not fit into the MR_int_least8_t field in the
proc_layout).
compiler/trace.m:
If necessary, fill in the saved maxfr slot.
If necessary, initialize the call table tip slot.
compiler/hlds_goal.m:
Add a goal feature which marks its goal as defining the variable
representing the call table tip node.
Add a field to the goal path step representing quantification;
the field says whether the quantification changes the determinism of
the goal (i.e. whether it cuts away solutions).
compiler/hlds_pred.m:
compiler/hlds_out.m:
Add two fields to proc_infos which (a) record which variable, if any,
holds the call table tip node, and (b) record whether the procedure's
layout structure needs to reserve a slot for the saved value of maxfr.
compiler/table_gen.m:
Put this feature on the appropriate goal.
Also, rename a predicate to make it reflect its purpose better.
compiler/code_gen.m:
Generate code to put the call table tip variable in its stack slot
immediately after it has been generated.
Add a sanity check to ensure that if a procedure that lives on the det
stack can create a temporary nondet frame, and debugging is enabled,
then it did have a stack slot reserved for the saved maxfr.
compiler/code_util.m:
Add a predicate to make a conservative prediction of whether a
procedure may allocate a temporary nondet stack frame. We cannot
just generate the code and see, because the code generator needs to
know which variables live in which stack slots, and we cannot decide
that until we know whether we need a stack slot for the saved value of
maxfr.
Make an unrelated predicate semidet procedure use a det helper, in
order to make it more robust in the face of changes to the HLDS
(e.g. it was missing code for handling bi_implications).
compiler/code_info.m:
Record whether a procedure has in fact created a temporary nondet stack
frame.
compiler/handle_options.m:
Disable hijacks if debugging is enabled. The code we now use to
restore the stacks for direct retries works only if the retry does not
"backtrack" over a hijacked nondet stack frame whose hijack has not
been undone. Note that code compiled without debugging may still hijack
nondet stack frames. Execution may reemerge from the nondebugged region
in one of two ways. If the nondebugged code returns, then it will have
undone hijack, and the retry code will work. If the nondebugged code
calls debugged code, there will be a region on the stacks containing
no debugging information, and the retry command will refuse to perform
retries that go into or beyond this region. Both cases preserve
correctness.
compiler/*.m:
Trivial changes to conform to changes in data structures.
runtime/mercury_stack_layout.h:
Add three new fields to proc layouts: the numbers of the stack slots
(if any) storing the saved maxfr and the call table tip, and a
representation of the procedure's evaluation method.
runtime/mercury_stack_trace.[ch]:
Now that return layouts contain goal paths, print them in stack dumps
only if the include_trace_data flag is set (in mdb, this requires the
-d flag of the "stack" command).
Pass this flag around directly, instead of encoding its value in
the NULL vs non-NULL values of sp and curfr.
runtime/mercury_regorder.h:
Provide a mechanism to access the values of the first few rN registers
from a save area, for use in debugging low-level C code in the runtime
and the trace directories.
trace/mercury_trace.[ch]:
Reimplement MR_trace_retry to allow retries from the middle.
If the stack segment being retried over contains minimal model
procedures, we must still arrange to skip to the end of the retried
call. If this call is a minimal model generator, skipping to just any
final port is not sufficient to guarantee correctness on retry; to
ensure that subgoal is complete, we must skip to a fail port.
trace/mercury_trace.[ch]:
trace/mercury_trace_internal.c:
Implement a debugger command, "fail", which skips to the fail port or
the exception port of the specified ancestor. Since procedures that are
not model_non are not guaranteed to get to such a port, this
command reports an error if the specified call is not model_non.
Actually, even calls to model_non procedures may not get to the fail
port, as explained above; this is why the command is not yet
documented.
trace/mercury_trace.c:
trace/mercury_trace_util.[ch]:
Move some functions to print parts of the Mercury abstract machine
state from mercury_trace to mercury_trace_util, so that they are
available for use in debugging e.g. mercury_trace_declarative.
trace/mercury_trace_internal.c:
trace/mercury_trace_external.c:
trace/mercury_trace_declarative.c:
Use the new implementation of retries. At the moment, only the
internal debugger implements the full functionality. The declarative
debugger issues retry commands only from situations where the missing
functionality is not (yet) needed. The external debugger should
continue to work correctly, but Erwan may wish to update it to
exploit the availability of the fail command.
trace/mercury_trace*.[ch]:
Fix MR_prefixes, and a signed/unsigned mismatch.
doc/user_guide.texi:
Document the new "fail" command, but comment it out for now.
tests/debugger/retry.{m,inp,exp,exp2}:
A new test case for exercising retry.
tests/debugger/Mmakefile:
Enable the new test case.
tests/debugger/*.exp:
Update the expected output, given the extra info now output e.g. for
exception events and detailed stack traces.
|
||
|
Mark Brown
|
954aad1dce |
Distinguish between predicates and functions in the declarative debugger.
Estimated hours taken: 2.5
Distinguish between predicates and functions in the declarative debugger.
browser/declarative_execution.m:
Add a pred_or_func field to trace_atom.
trace/mercury_trace_declarative.c:
Construct trace atoms with the extra field.
browser/declarative_user.m:
Print function call results using function syntax.
browser/debugger_interface.m:
browser/util.m:
Move the definition of type pred_or_func to util.m, so it can
be used by the declarative debugger as well as the external debugger.
runtime/mercury_stack_layout.h:
Update a reference to the location of type pred_or_func.
tests/debugger/declarative/Mmakefile:
tests/debugger/declarative/func_call.{m,inp,exp}:
Test case for the new feature.
tests/debugger/declarative/*.exp:
tests/debugger/declarative/*.exp2:
Update expected output from tests.
|
||
|
Mark Brown
|
86fc73ee92 |
s/Word/MR_Word/g
Estimated hours taken: 0.1 trace/mercury_trace_declarative.c: s/Word/MR_Word/g Also, break lines with >80 chars. |
||
|
Peter Ross
|
ae43e3ec1d |
Change the MercuryFile structure so that it now contains pointers to
Estimated hours taken: 20
Change the MercuryFile structure so that it now contains pointers to
functions which operate on the MercuryFile. This allows us, for
example, to create a MercuryFile structure which operates on sockets and
use the predicates in io.m to operate on the socket stream.
runtime/mercury_library_types.h:
Define the new implementation of MercuryFile structure.
The MercuryFile structure now contains pointers to functions to do
all the basic I/O operations.
Define macros to access all the different parts of the MercuryFile
structure.
runtime/mercury_file.h:
runtime/mercury_file.c:
Implement a MercuryFile structure which operates on C FILE *'s.
library/io.m:
Call the basic I/O operations from the MercuryFile structure.
Explicitly check that we are using a file stream when required.
As we cannot supply a variable number of arguments to a macro,
define a new function ML_fprintf() to provide fprintf functionality.
Hide all direct access to the MercuryFile data structure behind
macros.
browser/util.m:
trace/mercury_trace_browse.c:
trace/mercury_trace_declarative.c:
trace/mercury_trace_external.c:
Hide all direct access to the MercuryFile data structure behind
macros.
extras/logged_output/Mmakefile:
extras/logged_output/README:
extras/logged_output/logged_output.m:
extras/logged_output/main.m:
Add an example of defining a new MercuryFile structure. This new
structure defines an output stream which writes to stdout and logs
to a file at the same time.
runtime/Mmakefile:
Add the new files mercury_file.{c,h}.
runtime/mercury_imp.h:
Include `mercury_file.h'.
|
||
|
Mark Brown
|
c5de0d5b0c |
Implement declarative debugging of code that throws exceptions.
Estimated hours taken: 8
Implement declarative debugging of code that throws exceptions.
This aborts if used on code that handles exceptions. There is no point
dealing with this yet, since the oracle won't handle the higher order
argument to try/2.
browser/declarative_debugger.m:
Add "unexpected exception" questions and "unhandled exception" bugs,
and generate these from EXCP events. Handle the exception case
in various switches.
Add a predicate unexpected_exception_children/4, analogous to
{wrong,missing}_answer_children/4.
browser/declarative_execution.m:
Add excp/5 nodes to the event trace, and export a C function to
construct them. Handle these nodes in various switches.
Allow contours to extend beyond NEGE events, if the status is
`undecided'. Such events have no matching NEGS or NEGF event,
so they do not mark the boundary of a separate context.
browser/declarative_oracle.m:
Store information about which exceptions should/shouldn't be thrown
from various calls, and use this information to answer questions
where possible.
browser/declarative_user.m:
Handle the new questions and bugs.
trace/mercury_trace_declarative.c:
Add a function to deal with EXCP events.
trace/mercury_trace_internal.c:
Allow declarative debugging to be started from EXCP events.
tests/debugger/declarative/Mmakefile:
tests/debugger/declarative/throw.m:
tests/debugger/declarative/throw.inp:
tests/debugger/declarative/throw.exp:
tests/debugger/declarative/throw.exp2:
A test case for this feature.
tests/debugger/declarative/queens.exp:
Update the output from this test.
|
||
|
Tyson Dowd
|
db64a3588d |
Add MR_ prefixes to the types used when generating C code.
Estimated hours taken: 4 Add MR_ prefixes to the types used when generating C code. This means types such as Word, String, Bool, Float become MR_Word, MR_String, MR_Bool, MR_Float. Also define MR_Box for both the LLDS and MLDS backends so we can use it uniformly. This is very important in environments where String or Bool have already been used as system types (for example, managed C++). And besides, we should do it anyway as part of the grand namespace cleanup. I have fixed all of the uses of the non-prefixed types in the runtime and trace directories. I haven't done it for the library and compiler directories yet (no promises that I will do it in future either). But if you see a non-prefixed type in code from now on, please consider it a bug and fix it. mercury_bootstrap.h contains #defines to map the non-prefixed types into the prefixed ones. Like many of the other namespace cleaning backwards compatibility macros, this can be turned off with MR_NO_BACKWARDS_COMPAT. This shouldn't break any code, but this kind of change affects so many things that of course there could be problems lurking in there somewhere. If you start getting errors from the C compiler after this change is installed, you will want to make sure you at least have the runtime system updated so that you are getting the backwards compatibility definitions in mercury_bootstrap.h. Then if you continue to have problems you can bug me about it. compiler/export.m: compiler/llds_out.m: compiler/mlds_to_c.m: Use MR_Word, MR_Float, MR_Bool, etc when generating C. doc/reference_manual.texi: Update the reference manual to talk about MR_Word, MR_String, MR_Char, etc. runtime/mercury_bootstrap.h: Add bootstrapping typedefs. runtime/*: trace/*: Change Word, Float, Bool, Code, String, etc to MR_Word, MR_Float, MR_Bool, MR_Code, MR_String. |
||
|
Mark Brown
|
efb9e1e546 |
Fix a bug in the handling of implicit subtrees: the debugger was not
Estimated hours taken: 8
Fix a bug in the handling of implicit subtrees: the debugger was not
always skipping gaps in the contours properly. The fix is to find an
earlier contour when a dead end is reached (at FAIL, REDO and NEGF events).
The bug was in step_left_in_contour/2, but the same bug appeared in
wrong_answer_children/4 which was doing essentially the same work.
To avoid problems like this in future, the latter has been rewritten
in terms of the former. Similarly, missing_answer_children/4 has been
rewritten in terms of a new function step_in_stratum/2.
browser/declarative_debugger.m:
Rewrite {wrong,missing}_answer_children in terms of the
step functions.
browser/declarative_execution.m:
Export the step functions for use in the mercury_edt instance;
this means that they must be polymorphic (the previous monomorphic
versions are now called *_store). step_left_in_contour/2
is the same as before except that it also handles REDO nodes,
and the clauses are grouped together logically (for readibility).
step_in_stratum/2 is a new function.
tests/debugger/declarative/Mmakefile:
tests/debugger/declarative/untraced_subgoal.m:
tests/debugger/declarative/untraced_subgoal_sub.m:
tests/debugger/declarative/untraced_subgoal.inp:
tests/debugger/declarative/untraced_subgoal.exp:
A test case for this change. This test is only effective if
there are no events from the sub-module, so it is disabled in
debug grades.
|
||
|
Mark Brown
|
06c10a341b |
Ignore compiler generated procedures in the declarative debugger
Estimated hours taken: 1.5 Ignore compiler generated procedures in the declarative debugger (that is, assume they are correct). trace/mercury_trace_declarative.c: Filter out events from compiler generated procedures, and don't allow 'dd' to be used at these events. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/comp_gen.m: tests/debugger/declarative/comp_gen.inp: tests/debugger/declarative/comp_gen.exp: New test case for these changes. |
||
|
Mark Brown
|
a5eb54cc51 |
Make the code consistent with the terminology in the DD paper.
Estimated hours taken: 0.2 Make the code consistent with the terminology in the DD paper. browser/declarative_execution.m: trace/mercury_trace_declarative.c: s/step_left_in_context/step_left_in_contour/g |
||
|
Fergus Henderson
|
bf56dfcc70 |
Fix a problem which stopped the `trace' directory from compiling in
Estimated hours taken: 1 Fix a problem which stopped the `trace' directory from compiling in MLDS grades. Also some miscellaneous cleanup of the `#include' statements in the `trace' directory. trace/mercury_trace_browse.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_help.c: Change the `#include' statements that include header files from code in the library directory so that if MR_HIGHLEVEL_C is defined, the file names are all prefixed with "mercury.". This is necessary because the MLDS back-end names those header files differently than the LLDS back-end. trace/*.c: Arrange the `#include' statements so that they are grouped according to which directory the file being included comes from. trace/mercury_trace_browse.h: trace/mercury_trace_internal.h: trace/mercury_trace_external.h: Add missing `#include' statements, to make these header files self-contained. |
||
|
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. |
||
|
Fergus Henderson
|
6ba459bdaa |
Add some `MR_' prefixes.
Estimated hours taken: 0.75 Add some `MR_' prefixes. runtime/mercury_string.h: runtime/mercury_misc.h: runtime/mercury_misc.c: runtime/mercury_make_type_info_body.h: runtime/mercury_type_info.c: runtime/mercury.c: extras/*/*.m: extras/*/*/*.m: library/*.m: trace/*.c: compiler/fact_table.m: compiler/ml_code_gen.m: compiler/stack_layout.m: Add `MR_' prefixes to fatal_error(), hash_string(), do_hash_string, and HASH_STRING_FUNC_BODY. runtime/mercury_bootstrap.h: Add backwards compatibility macros for fatal_error() and hash_string(). |
||
|
Zoltan Somogyi
|
c2a696d8b6 |
Clean up the runtime system's handling of type_infos and pseudo_type_infos.
Estimated hours taken: 40
Clean up the runtime system's handling of type_infos and pseudo_type_infos.
This cleanup has two major aspects. First, it represents type_infos and
pseudo_type_infos with distinct C types, and reducing the use of casts
to the minimum. These casts are in two kinds of places: in a few macros
defined in runtime/mercury_type_info.h, and at the interfaces between C code
and Mercury code (since Mercury code represents (pseudo-)type_infos, like
everything else, as Words). Part of this aspect is the separation of the
type "MR_TypeInfo" from the type "MR_TypeInfoParams"; a MR_TypeInfo can be
used as a source of type parameters directly only when it is first order.
Second, it removes the confusion between the types named "type_info" and
"type_ctor_info" defined by the modules private_builtin.m and std_util.m,
by renaming the types defined in std_util.m to "type_desc" and
"type_ctor_desc".
To avoid doing this cleanup twice, this diff also removes support for the
old type_ctor_info representation. This in turn makes it feasible to provide
conditionally enabled code to support unification and comparison by RTTI.
runtime/mercury_grade.h:
Increment the binary compatibility version number. This is required
by the dropping of support for old type_ctor_info representations.
runtime/mercury_type_info.h:
Define the types MR_TypeInfo, MR_PseudoTypeInfo and MR_TypeInfoParams,
and macros that operate on them.
Remove the types and macros that were useful only with the old RTTI
representation.
Move the section that deals with initializing code addresses in
type_ctor_info structure for grades without static code addresses
to the logical place.
Add a const qualifier to the MR_sectag_alternatives field in
MR_DuPtagLayout, since this simplifies code manipulating du types.
Convert the whole file to 4 space indentation, since it is a nuisance
if only part of it is so indented.
runtime/mercury_deep_copy.h:
runtime/mercury_deep_copy_body.h:
runtime/mercury_tabling.h:
runtime/mercury_tabling.c:
Clean up the implementation as described above.
runtime/mercury_type_info.c:
runtime/mercury_make_type_info_body.h:
Clean up the implementation as described above.
Eliminate the code duplication between the function MR_make_type_info
and MR_create_type_info, and their helpers, which do the same thing
except for how they allocate memory, by putting the common code into
the new file mercury_make_type_info_body.h, and including it twice
in two different #define contexts.
Move the (updated) documentation of those functions to
mercury_type_info.h, where it belongs.
runtime/mercury_ho_call.c:
runtime/mercury_unify_compare_body.h:
Clean up the implementation as described above.
Eliminate the code duplication between the implementation of unify
and compare, which do very similar jobs, by putting the common code
into the new file mercury_unify_compare_body.h, and including it three
times in two different #define contexts. The third time is for defining
the body of a C function which does the same thing as compare. This
is necessary for unification and comparison by RTTI, since the
unification or comparison of two structured terms requires comparing
their subterms. (There is no need for a separate C function for
unification; the C comparison function is sufficient.)
mercury_unify_compare_body.h has conditional support for unification
and comparison by RTTI. Although this has been tested and is known
to work, it is turned off for the moment. This may change after
benchmarking.
runtime/Mmakefile:
Add the new include files to the list.
library/std_util.m:
Rename type_info to type_desc and type_ctor_info to type_info_desc.
Keep the old names as equivalence types, for the time being.
Document the representations.
Move the macros that refer to type_descs and type_ctor_descs here from
runtime/mercury_type_info.h, since this is the only place where they
are used. Rename them to conform to the new names of the types.
Clean up the implementation of the RTTI predicates and functions
as described above. In the process, fix some bugs where type variables
were expanded twice, with the second expansion's code being incorrect.
Also factor out some common code, and unfactor some uncommon code
(where a function had two uses, but its implementation was inefficient
overkill for one of them).
library/builtin.m:
library/private_builtin.m:
library/io.m:
library/store.m:
runtime/mercury_layout_util.[ch]:
trace/mercury_trace_declarative.c:
trace/mercury_trace_external.c:
trace/mercury_trace_vars.[ch]:
When calling C functions involving type_infos, cast them to the new
types.
runtime/mercury_stack_layout.h:
Fix a bug that was masked by casts in its client code.
compiler/rtti_out.m:
Delete from the output a cast made unnecessary by the new const
qualifier on MR_sectag_alternatives.
browser/browse.m:
browser/help.m:
library/io.m:
library/term.m:
tests/hard_coded/construct.m;
tests/hard_coded/existential_types_test.m:
tests/hard_coded/higher_order_type_manip.{m,exp}:
Refer to the types defined in std_util.m by their new names.
tests/hard_coded/existential_rtti.{m,exp}:
Make the test tougher by printing out not just one deconstructed term,
but deconstructed versions of all the terms created by this test.
|
||
|
Mark Brown
|
f49968a3ff |
Fix the user interface of the declarative debugger so that it
Estimated hours taken: 15
Fix the user interface of the declarative debugger so that it
produces more readable output; the representation of atoms
is updated so that it can handle non-ground arguments.
Ensure that all DD output goes through the correct stream, so that
the debugger works properly under emacs.
browser/declarative_debugger.m:
Call a procedure in the oracle to handle bug confirmation
(including printing out the bug), rather than handle
it directly.
browser/declarative_execution.m:
Update the trace_atom type so that it can handle both ground
and free arguments. Export to C some procedures for
constructing trace atoms.
browser/declarative_oracle.m:
Export a procedure which handles bug confirmation. This calls
the declarative_user module to do the interaction, and interprets
the result.
browser/declarative_user.m:
Export a procedure to handle bug confirmation by the user.
Update to handle the changes to trace_atom.
trace/mercury_trace_declarative.c:
Construct trace_atoms by calling the new Mercury procedures
exported from browser/declarative_execution.m.
trace/mercury_trace_declarative.h:
Remove the macro that had been used to construct old style atoms.
trace/mercury_trace_vars.{c,h}:
Export a procedure to calculate the argument position of a
head variable.
tests/debugger/declarative/Mmakefile:
tests/debugger/declarative/args.{m,inp,exp,exp2}:
New test case to test mixing bound and free arguments.
tests/debugger/declarative/*.inp:
tests/debugger/declarative/*.exp:
tests/debugger/declarative/*.exp2:
Update test cases to reflect new output, and the extra question
asked for bug confirmation.
|
||
|
Mark Brown
|
71a343d1bb |
Fix the problem of test cases failing in tests/debugger/declarative
Estimated hours taken: 1.2 (including 0.2 by fjh) Fix the problem of test cases failing in tests/debugger/declarative on the alphas. browser/declarative_execution.m: Add Mercury procedures to do destructive update on trace nodes. trace/mercury_trace_declarative.h: Remove C macros that did the destructive update. trace/mercury_trace_declarative.c: Use the Mercury procedures rather than the old macros. |
||
|
Mark Brown
|
0166fe7510 |
Bring the implementation up to date with the algorithm that is
Estimated hours taken: 25 (plus ? by zs) Bring the implementation up to date with the algorithm that is described in the paper (papers/decl_debug). Add some debugging infrastructure to the back end, which was used to debug this change. browser/declarative_execution.m: - Store the call sequence number in call nodes. - Store the previous redo (if there is one) in fail nodes. - Use a functor specifically for switches. - Use a pointer to the first disj event, instead of a pointer to the event before it. - Export two new predicates for dereferencing disj node ids. - Export (to C) a procedure for accessing the call sequence number, and a procedure for getting to the first disj event. - Split the scan_backwards function into two: step_left_in_context and find_prev_contour. browser/declarative_debugger.m: trace/mercury_trace_declarative.c: - Use the updated data structure. runtime/mercury_conf_param.h: - Add the configuration parameter MR_USE_DECL_STACK_SLOT, which makes the declarative debugger use stack slots reserved by the compiler to cache the location of the call node. trace/mercury_trace_declarative.h: trace/mercury_trace_declarative.c: - Use stack slot only if MR_USE_DECL_STACK_SLOT is defined. - If not using stack slot, use the new algorithm to search for a matching call or exit event. - Avoid using a global by passing the previous node to MR_trace_decl_* and returning the new node. - Rename MR_trace_call_node_answer to MR_trace_call_node_last_interface. - Update comments. browser/declarative_execution.m: trace/mercury_trace_declarative.c: - Added debugging output for various events of interest in the back end. It is activated when MR_DEBUG_DD_BACK_END is set. tests/debugger/declarative/aadebug.m: tests/debugger/declarative/aadebug.inp: tests/debugger/declarative/aadebug.exp: tests/debugger/declarative/aadebug.exp2: - Update this test to match the example in the paper. tests/debugger/declarative/propositional.inp: tests/debugger/declarative/propositional.exp: tests/debugger/declarative/propositional.exp2: - Update this test case so it gives a similar result in debugging grades to non-debugging grades. tests/debugger/declarative/app.exp2: tests/debugger/declarative/if_then_else.exp2: - Update test case results. tests/debugger/declarative/Mmakefile: tests/debugger/declarative/backtrack.m: tests/debugger/declarative/backtrack.inp: tests/debugger/declarative/backtrack.exp: - New test case. |
||
|
Simon Taylor
|
9ba3b14098 |
Make all the modules in the browser library sub-modules of
Estimated hours taken: 1 Make all the modules in the browser library sub-modules of module `mdb', to avoid link errors when users use module names such as `parse'. browser/Mmakefile: browser/browser_library.m: browser/mdb.m: Rename browser_library.m to mdb.m. Change `:- import_module' declarations to `:- include_module' declarations. browser/Mmakefile: Remove the special case rule for `mer_browser.init' -- it doesn't work when the file names are not the same as the module name. Instead, the default rule for `mdb.init' is used and the output is copied to `mer_browser.init'. browser/.cvsignore: Rename header files, etc. browser/*.m: Add a `mdb__' prefix to the names of modules in the browser library in `:- module' and `:- import_module' declarations. trace/*.c: Rename the header files for the browser library in `#include' statements. tests/hard_coded/Mmakefile: tests/hard_coded/parse.m: tests/hard_coded/parse.exp: Test case. |
||
|
Mark Brown
|
3e065c040e |
Implement the new architecture for the front end of the
Estimated hours taken: 120 Implement the new architecture for the front end of the declarative debugger. Disable declarative debugging if conservative GC is not being used since this change relies on it. The benefits of declarative debugging in non-GC grades are not worth the extra maintenance required to support it, since even small examples require a large amount of memory. browser/declarative_analyser.m: New module which handles the analysis of EDTs, which was previously done in browser/declarative_debugger.m. browser/declarative_debugger.m: - Change the interface according to the new design. - Export types of the form decl_*, rather than edt_*. - Move the EDT analysis to the new module. - Handle the interaction between the analyser and the oracle. - Don't interact directly with the user, but go via the oracle. - New diagnoser state type. - Update the EDT instance to conform to the other changes. browser/declarative_oracle.m: - Replace oracle_answer type with oracle_response. - Allow the oracle to work with a queue of questions rather than one at a time. - Add new predicates to manipulate the knowledge base. browser/declarative_user.m: - Export the user_state type. - Handle some user commands in this module. - Handle questions properly (apart from printing atoms). browser/browser_library.m: Add the new module. trace/mercury_trace_declarative.c: - Initialise the front end state just once per session. - Make the step size much larger, since implicit subtrees are not fully supported yet. - Correct the types in a format specifier. trace/mercury_trace_declarative.c: trace/mercury_trace_internal.c: trace/mercury_trace_internal.h: - Disable declarative debugging unless conservative GC is used. |
||
|
Fergus Henderson
|
482c1f383d |
Fix a compiler warning: to print out values of
Estimated hours taken: 0.2 trace/mercury_trace_declarative.c: Fix a compiler warning: to print out values of type `Unsigned', cast them to `unsigned long' and print them using `%ul' rather than `%d'. |
||
|
Mark Brown
|
9179be5e15 |
Implement a new data structure for declarative debugging.
Estimated hours taken: 160
Implement a new data structure for declarative debugging. The
major differences between this and the old implementation are:
- The data structure is implemented in Mercury. The definition
of the type, and procedures for constructing values of that
type, have been moved from trace/mercury_trace_declarative.{c,h}
to browser/declarative_execution.m (which is a new module).
- The front end no longer needs to call the back end via an
indirect pointer---the front end does not call the back end at
all.
- The data structure is not specifically for wrong answer
analysis, it is intended to be used for any sort of analysis.
- The data structure represents execution at a lower level---the
new front end defines a more abstract view in terms of this
data structure.
Implement a test harness for debugging the front end code. This allows
the front end to run as a stand-alone program, which can then be
debugged using `mdb'.
The code in the front end does not currently handle the new structure
very nicely. This is because that code is about to undergo some major
structural changes, so there is little point cleaning it up now.
Consequently:
- Some of the code in the front end is incorrect (eg. the
user interface does not print missing answer nodes
properly).
- The tests have not been reinstated.
These things will be fixed in subsequent changes.
Likewise the compiler still reserves two stack slots, even though
only one is required. After this change the algorithm should be able
to get away with using no stack slots, so modifications to the compiler
will be postponed until then.
browser/declarative_execution.m:
New module. Implement the execution_tree typeclass, which
represents the execution of a Mercury program. Implement
two instances of this typeclass, one for normal use and one for
testing purposes.
browser/declarative_test.m:
New module. A test harness that can be compiled as a
stand-alone program, enabling the front end to be debugged.
trace/mercury_trace_declarative.c:
trace/mercury_trace_declarative.h:
- Remove the definition of the old data structure.
- Add some macros which enable the new Mercury data structure
to be destructively updated by C code.
- Change the interface to this module so that it reflects more
general diagnosis, not just wrong answer analysis.
- Implement the new algorithm.
- Call an alternative front end if in test mode.
- Update comments.
trace/mercury_trace_internal.h:
Add a new mode for debugging the declarative debugger.
trace/mercury_trace_internal.c:
Change the command from `dd_wrong' to `dd', since it is not
specifically for wrong answer analysis. Add a new command
`dd_dd' which calls the alternative front end used for testing.
runtime/mercury_init.h:
runtime/mercury_wrapper.c:
runtime/mercury_wrapper.h:
util/mkinit.c:
Remove any reference to `MR_edt_root_node', since it is no
longer used.
browser/declarative_debugger.m:
- Add a case for missing answer nodes to `edt_node'.
- Change the `evaluation_tree' typeclass into `mercury_edt'
typeclass. This is to make it more distinct from the new
`execution_tree' typeclass, which is a lower level concept.
- New interface to the diagnoser: types `diagnoser_response'
and `diagnoser_state', and procedure `diagnosis'.
- Define an instance of `mercury_edt' from an instance of
`execution_tree'.
- Updates to the analyser to get it to compile---further changes
will be forthcoming.
browser/declarative_user.m:
- Updates to the user interface to get it to compile---further
changes will be forthcoming.
browser/browser_library.m:
Import the new module (declarative_execution.m).
browser/debugger_interface.m:
browser/util.m:
Move the definitions of trace_port_type and goal_path_string
to browser/util.m, since they are now used by more than just
the external debugger.
browser/Mmakefile:
Add the test harness as a `depend' target.
browser/browse_test.m:
Use the correct interface to the browser.
|
||
|
Fergus Henderson
|
88a513b580 |
Reorganize the routines for allocating and deallocating memory:
Estimated hours taken: 8
Reorganize the routines for allocating and deallocating memory:
runtime/mercury_std.h:
runtime/mercury_misc.c:
runtime/mercury_memory.h:
runtime/mercury_memory.c:
- Put the routines in the proper place.
Previously the declarations and definitions of the memory
allocation/deallocation routines were spread amoungst
all four of these files; I moved the ones in mercury_std.h
and mercury_misc.c so that they are now all defined
in mercury_memory.{h,c}
- Avoid unnecessary duplication
The following routines did exactly the same thing,
modulo bugs(!):
allocate_bytes() and newmem()
deallocate_bytes() and oldmem()
make() and allocate_object()
make_many() and allocate_array()
- Use appropriate names.
I added `MR_' prefixes, and ensured that macros that are not
function-like macros use all uppercase. I also used a more
consistent naming scheme.
Previously the names used were
(1) checked_malloc, checked_realloc
(2a) allocate_bytes, deallocate_bytes, reallocate_bytes,
allocate_object, allocate_array, resize_array
(2b) newmem, oldmem, resizemem,
make, make_many, resize_many
The new names are
(1) MR_malloc, MR_free, MR_realloc,
MR_NEW, MR_NEW_ARRAY, MR_RESIZE_ARRAY
(2) MR_GC_malloc, MR_GC_free, MR_GC_realloc,
MR_GC_NEW, MR_GC_NEW_ARRAY, MR_GC_RESIZE_ARRAY
runtime/*.[ch]:
trace/*.[ch]:
library/array.m:
library/benchmarking.m:
library/io.m:
library/std_util.m:
extras/odbc/odbc.m:
extras/aditi/aditi.m:
Use the new names.
|
||
|
Zoltan Somogyi
|
bca4cb8162 |
Make the entire Mercury system bootstrap without backwards compatbility.
Estimated hours taken: 12 Make the entire Mercury system bootstrap without backwards compatbility. compiler/llds_out.m: compiler/pragma_c_gen.m: Add MR_ prefixes on generated code. library/builtin.m: library/exception.m: library/private_builtin.m: library/std_util.m: library/store.m: Add MR_ prefixes. runtime/mercury_deep_copy_body.h: runtime/mercury_heap.h: runtime/mercury_stacks.h: runtime/mercury_string.h: runtime/mercury_tags.h: runtime/mercury_type_info.h: Add MR_ prefixes. runtime/mercury_bootstrap.c; runtime/mercury_engine.c; runtime/mercury_ho_call.c; runtime/mercury_tabling.c; runtime/mercury_trace_base.c; runtime/mercury_type_info.c; runtime/mercury_wrapper.c; Add MR_ prefixes. In some cases, fix indentation; in functions using four-space indentation, convert all tabs to spaces. trace/mercury_trace_browse.m: trace/mercury_trace_declarative.m: trace/mercury_trace_external.m: trace/mercury_trace_help.m: Add MR_ prefixes. |
||
|
Mark Brown
|
204928ac9c |
Deep copy some data to the global heap, as it may need to be
Estimated hours taken: 6 trace/mercury_trace_declarative.c: Deep copy some data to the global heap, as it may need to be used after being backtracked over. tests/debugger/declarative/Mmakefile: Re-enable the test that was failing due to this bug. |
||
|
Mark Brown
|
f6728080fb |
Bring the declarative debugging back end up to date with the
Estimated hours taken: 1 trace/mercury_trace_declarative.c: Bring the declarative debugging back end up to date with the recent changes to stack layouts. Specifically, use the new access macros instead of inspecting the data directly. |
||
|
Mark Brown
|
5d9569900b |
Clean up the declarative debugger.
Estimated hours taken: 12 Clean up the declarative debugger. browser/declarative_debugger.m: browser/declarative_oracle.m: - Add a new type, oracle_data, to store the oracle database. - Thread an oracle database through a single call to the front end. - Replace `unknown' with a less overloaded name in some type definitions. trace/mercury_trace_declarative.c: trace/mercury_trace_declarative.h: browser/declarative_debugger.m: - Improve documentation. browser/declarative_debugger.m: - Export new type, edt_truth. - Improve the interface to the oracle. - Add a new typeclass, evaluation_tree, and update the previous interface to reflect this. - Make declarative_bug a polymorphic type, and change the constructor for buggy nodes from `wrong' to `e_bug'. |
||
|
Mark Brown
|
05fb1d86a6 |
Ensure strings are aligned before passing them to Mercury code.
Estimated hours taken: 1 trace/mercury_trace_declarative.c: Ensure strings are aligned before passing them to Mercury code. |
||
|
Mark Brown
|
dfcb358e86 |
Add the option `--enable-decl-debug' to configure, which enables
Estimated hours taken: 2 Add the option `--enable-decl-debug' to configure, which enables declarative debugging support in the internal debugger. configure.in: Add the option to configure. browser/declarative_debugger.m: runtime/mercury_wrapper.c: Avoid using MR_address_of_edt_root_node unless configured for declarative debugging. runtime/mercury_conf.h.in: runtime/mercury_conf_param.h: Move the configuration macro to mercury_conf.h.in. trace/mercury_trace_declarative.c: Define MR_edt_root_node only if configured for declarative debugging, thereby undoing a previous change. |
||
|
Mark Brown
|
59f61e4edf |
Fix a bug causing the debugger tests to get link errors.
Estimated hours taken: 3
Fix a bug causing the debugger tests to get link errors.
browser/declarative_debugger.m:
Call MR_edt_root_node indirectly via MR_address_of_edt_root_node.
runtime/mercury_wrapper.{c,h}:
Add a global function pointer, MR_address_of_edt_root_node.
util/mkinit.c:
Make sure MR_address_of_edt_root_node is initialized.
trace/mercury_trace_declarative.c:
Define MR_edt_root_node even if the declarative debugger is not
used.
|
||
|
Mark Brown
|
4fec7f6137 |
Add a front end to the declarative debugger, written in Mercury.
Estimated hours taken: 80 Add a front end to the declarative debugger, written in Mercury. Modify the back end to call this whenever an EDT is built. Also, various bug fixes and improvements. browser/declarative_debugger.m: New module. This is a first implementation of the front end of the declarative debugger. It uses a simple top-down algorithm to search the EDT for a buggy node. The results are printed in a simple format to the output stream. It is called from the back end, in trace/mercury_trace_declarative.c. browser/declarative_oracle.m: New module. This is a first implementation of an oracle for the declarative debugger. It simply passes all queries directly on to the user. browser/browser_library.m: Import the new modules. trace/mercury_trace_declarative.c: - Various fixes/improvements of comments. - Fix bugs where `int' is used instead of `Unsigned'. - Pass the event_info structure to MR_trace_decl_update_path, rather than passing various components of it. - Use the copy of MR_trace_event_number in the event_info structure rather than referring to the global variable directly. - Remove the EDT printing functions, as they have been superseded by the new front end. Call the new front end instead of these old functions. - Provide an interface to the EDT nodes that is imported by the front end. - Ensure that, after diagnosis, we end up at the same event we started at. - Fix a bug where it was assumed all procedures had at least one argument. - Ensure that the user is notified if the dd_wrong operation cannot be started due to MR_trace_retry failing. trace/mercury_trace_declarative.h: - Move a #include to the correct place. - Declare the interface to the EDT nodes. trace/mercury_trace_internal.c: Fix a bug introduced earlier. runtime/mercury_conf_param.h: Add a new configuration macro, MR_DEBUG_DD_BACK_END. When defined this causes information about the declarative debugger back end to be printed out during operation. |
||
|
Mark Brown
|
0a3b4958c1 |
Pass around event information for the tracing system in an
Estimated hours taken: 6
Pass around event information for the tracing system in an
MR_Event_Info struct instead of passing each item as a separate
argument. Use Unsigned consistently for the type of the call
depth and call sequence number.
trace/mercury_trace.h:
Add the new MR_Event_Info structure.
trace/mercury_trace.{c,h}:
trace/mercury_trace_declarative.{c,h}:
trace/mercury_trace_external.{c,h}:
trace/mercury_trace_internal.{c,h}:
Use the new structure.
runtime/mercury_trace_base.c:
Use Unsigned as the type of the call depth and sequence number.
|
||
|
Mark Brown
|
2be61d460d |
Changes to the internal tracer to implement a declarative
Estimated hours taken: 220
Changes to the internal tracer to implement a declarative
debugging back end.
runtime/mercury_conf_param.h:
Document the new MR_USE_DECLARATIVE_DEBUGGER configuration
parameter.
trace/mercury_trace_internal.{c,h}:
Declare a global variable, MR_trace_decl_mode, that stores the
current mode of the internal debugger, and an enum listing the
possible modes.
Move MR_Event_Details and MR_trace_retry into
mercury_trace_internal.h, and make the latter extern, so that
the declarative debugger back end can use them.
trace/mercury_trace_internal.c:
Call the back end in mercury_trace_declarative.c.
Add a new command, dd_wrong, to start wrong answer analysis.
trace/Mmakefile:
Add mercury_trace_declarative.{c,h} to the dependencies.
trace/mercury_trace_declarative.{c,h}:
The declarative debugging back end (new files).
|