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.	2002-02-24 11:53:46 +00:00
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.	2002-02-18 07:01:33 +00:00
Simon Taylor	5b16c5f3d0	Fix bugs in the code to parse and match procedure ... Estimated hours taken: 2.5 Branches: main Fix bugs in the code to parse and match procedure specifications for breakpoints: - handle nested modules. - handle names containing '/' and '-'. - use the correct arity for functions, not the arity of the corresponding predicate. trace/mercury_trace_tables.c: Fix the bugs. runtime/mercury_stack_layout.h: Add a macro to adjust the arity of functions recorded in MR_Proc_Layouts for printing. runtime/mercury_stack_trace.c: Print the correct arity of functions in stack traces and debugger events. tests/debugger/breakpoints.m: tests/debugger/breakpoints.print_list.m: tests/debugger/breakpoints.inp: tests/debugger/breakpoints.exp: Add test cases. tests/debugger/existential_type_classes.exp: tests/debugger/polymorphic_output.exp3: tests/debugger/declarative/func_call.exp: Update expected output. (I'll update the other output files after this change is installed).	2002-02-11 12:52:55 +00:00
Zoltan Somogyi	fbfd4970df	Make the debugging of minimal model tabling easier by providing a mechanism ... Estimated hours taken: 32 Branches: main Make the debugging of minimal model tabling easier by providing a mechanism to print the contents of the nondet stack, *including* the values of the variables in its stack frames, even for frames which are not ancestors of the currently executing call. runtime/mercury_stack_trace.[ch]: Add functions for traversing the nondet stack, and for keeping track of through which label control returns to each nondet stack frame, so that we know which label's layout structure to interpret the stack frame's contents. For some, this will be the return label of a call; for others, it will be the label of a resumption point stored in a redoip slot. Rename an old function to allow the new one to fit into our naming scheme. runtime/mercury_stack_trace.[ch]: runtime/mercury_tabling.c: library/exception.m: trace/mercury_trace.c: Add MR_ prefixes to the values of the enum returned by MR_stack_walk_step. Rename references to the renamed function. runtime/mercury_conf_param.h: Add macros for debugging label names and for debugging retries (which needs label names, just as debugging tabling does). Add a macro for controlling whether mercury_debug.c prints raw addresses as well as offsets (for stack pointers) or label names (for labels). The raw pointers can be useful in debugging, but they need to be turned off in test cases one wants to be reproducible. runtime/mercury_label.h: runtime/mercury_conf_param.h: Move the MR_NEED_ENTRY_LABEL_ARRAY and MR_NEED_ENTRY_LABEL_INFO macros from mercury_label.h to mercury_conf_param.h, since mercury_debug.c also needs them now. runtime/mercury_debug.c: addresses as well as offsets (for stack pointers) or label names (for labels). The raw pointers can be useful in debugging, but they need to be turned off in test cases one wants to be reproducible. runtime/mercury_init.h: runtime/mercury_wrapper.[ch]: util/mkinit.c: Add a global variable pointing to a function through which the stack walk code in runtime/mercury_stack_trace.c can invoke code from the debugger to print the values of the variables in nondet stack frames without breaking the rule prohibiting references to the trace directory from the runtime directory. runtime/mercury_wrapper.c: Define the succip of the dummy frame at the bottom of the nondet stack, to avoid dereferencing a garbage pointer during detailed stack dumps. runtime/mercury_goto.h: Add a mechanism for always registering the name of a specific label, even if label names are not being registered in general. This mechanism is intended to be used for labels such as do_fail, which occur frequently in nondet stack traces. runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: Use this mechanism for the labels defined in these modules. library/builtin.m: Define type_ctor_infos for the pseudotypes representing nondet stack frame slots unconditionally, since the debugger may now need them. trace/mercury_trace.c: Add conditionally enabled to code to make debugging retry easier. trace/mercury_trace_internal.c: Add a -d option to the nondet_stack command that causes it to print detailed nondet stack dumps, including the names and values of the variables in each nondet stack frame. trace/mercury_trace_vars.c: Provide a mechanism for printing the variables of a stack frame even when that stack frame is not an ancestor of the current call. doc/user_guide.texi: Document the new option of the nondet_stack command. tests/debugger/nondet_stack.{m,inp,exp,exp2}: A new test case to test "nondet_stack -d". tests/debugger/Mmakefile: Enable the new test case.	2001-12-04 00:44:41 +00:00
Fergus Henderson	bb52e7bc8d	Add support for `--gc none' to the MLDS->C back-end, ... Estimated hours taken: 8 Branches: main Add support for `--gc none' to the MLDS->C back-end, i.e. support the `hlc' and `hl' grades. runtime/mercury_float.h: Extra some of the code from MR_float_to_word() out into a new macro MR_make_hp_float_aligned(), for use in MR_box_float(). runtime/mercury.h: If CONSERVATIVE_GC is not defined, include "mercury_regs.h" and "mercury_engine.h", so that we get the definition of MR_hp, and "mercury_overflow.h", for MR_heap_overflow_check(). Define MR_new_object() and MR_box_float() correctly for the !CONSERVATIVE_GC case. runtime/mercury_context.h: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_debug.c: runtime/mercury_thread.c: runtime/mercury_stack_trace.c: trace/mercury_trace_util.c: Add `#ifndef MR_HIGHLEVEL_CODE ... #endif' wrappers around sections of code that are specific to the LLDS back-end. runtime/mercury_wrapper.c: library/benchmarking.m: Initialize (in mercury_wrapper.c) and use (in benchmarking.m) the MercuryEngine struct in the !CONSERVATIVE_GC case, as well as in the !MR_HIGHLEVEL_CODE case. The MercuryEngine struct is needed because that is where the heap pointer and heap zone are stored. library/table_builtin.m: Use the correct names for type_ctor_infos when MR_HIGHLEVEL_CODE is enabled. (Previously this was not an issue because these type_ctor_infos were only being used in the !CONSERVATIVE_GC case.) tests/hard_coded/Mmakefile: For the test cases which use lots of memory, increase the heap size (using the MERCURY_OPTIONS environment variable) rather than compiling them with `--gc conservative'. This avoids spurious test case failures when running the tests via `tools/bootcheck --grade hlc --no-bootcheck'.	2001-11-22 11:37:20 +00:00
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.	2001-05-31 06:00:27 +00:00
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.	2001-01-18 01:19:17 +00:00
Zoltan Somogyi	3f18f1c4f4	Add some missing MR_ prefixes. ... Estimated hours taken: 0.2 runtime/*.[ch]: Add some missing MR_ prefixes.	2000-11-28 04:31:50 +00:00
Zoltan Somogyi	090552c993	Make everything in the runtime use MR_ prefixes, and make the compiler ... Estimated hours taken: 10 Make everything in the runtime use MR_ prefixes, and make the compiler bootstrap with -DMR_NO_BACKWARDS_COMPAT. runtime/mercury_*.[ch] Add MR_ prefixes to all functions, global variables and almost all macros that could pollute the namespace. The (intentional) exceptions are 1. some function, variable, type and label names that already start with MR_, mercury_, Mercury or _entry; 2. some standard C macros in mercury_std.h; 3. the macros used in autoconfiguration (since they are used in scripts as well as the runtime, the MR_ prefix may not be appropriate for those). In some cases, I deleted things instead of adding prefixes if the "things" were obsolete and not user visible. runtime/mercury_bootstrap.h: Provide MR_-less forms of the macros for bootstrapping and for backward compatibility for user code. runtime/mercury_debug.[ch]: Add a FILE * parameter to a function that needs it. compiler/code_info.m: compiler/export.m: compiler/fact_table.m: compiler/llds.m: compiler/llds_out.m: compiler/pragma_c_gen.m: compiler/trace.m: Add MR_ prefixes to the C code generated by the compiler. library/*.m: Add MR_ prefixes to handwritten code. trace/mercury_trace_*.c: util/mkinit.c: Add MR_ prefixes as necessary. extras/concurrency/semaphore.m: Add MR_ prefixes as necessary.	2000-11-23 02:01:11 +00:00
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.	2000-10-16 01:34:14 +00:00
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.	2000-10-13 04:06:52 +00:00
Zoltan Somogyi	e60f641d9b	Make it possible to save the state of a debugger session wrt break points ... Estimated hours taken: 6 Make it possible to save the state of a debugger session wrt break points and aliases in a file that can be sourced in another debugger session to restore the state. trace/mercury_trace_internal.c: Add a new mdb command, "save <filename>", to save mdb's state to the named file. Allow the "disable", "enable" and "delete" commands to be given without arguments; such invocations refer to the most recently created breakpoint. The extension to "disable" is required by the implementation of the "save" command; the others are for symmetry. Allow the user to speficy an option to the source command that tells mdb not to complain if the named file cannot be processed. This should allow people to put into .mdbrc files commands to source saved state files if they exist and not get complaints if they don't. Make several messages conform to our convention that error messages start with "mdb: ". trace/mercury_trace_spy.[ch]: Add code to implement the part of the "save" command concerned with breakpoints. Unfortunately, there is no simple way to save the specification of breakpoints created with "break here", so for the time being they are not saved. This should not be too much of a problem, since such breakpoints are rarely used. Maintain a variable that identifies the most recently added breakpoint, if any. Also move the function to print out breakpoints here from mercury_trace_internal.c, in order to centralize knowledge about breakpoints here. trace/mercury_trace_alias.[ch]: Add code to implement the part of the "save" command concerned with aliases. Fix some occurrences of an old bug: use MR_free, not free, to free strings allocated with MR_copy_string. trace/mercury_stack_trace.[ch]: Add a version of MR_print_proc_id that prints proc ids in a form suitable for mdb procedure specifications. doc/user_guide.texi: Document the "save" command and the new usage modes of the other modified commands. tests/debugger/mdb_command_test.inp: Test the existence of documentation for the "save" command. tests/debugger/polymorphic_output.exp: Update an expected error message.	2000-09-01 00:50:29 +00:00
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.	2000-08-03 06:19:31 +00:00
Fergus Henderson	24ef39876c	Reorganize some code in the runtime. ... Estimated hours taken: 2 Reorganize some code in the runtime. These changes were motivated in part by the desire to keep the runtime for the MLDS back-end as well separated from the complications of the current LLDS back-end as possible. runtime/mercury_std.h: runtime/mercury_misc.h: Move the definition of NO_RETURN from miscury_misc.h to mercury_std.h, since it's better to define all the compiler-dependent macros like this in one spot. runtime/Mmakefile: runtime/mercury_misc.h: runtime/mercury_misc.c: runtime/mercury_debug.h: runtime/mercury_debug.c: Move the debugging stuff from mercury_misc.{h,c} to mercury_debug.{h,c}. Note that mercury_debug.c is a new file. runtime/mercury_misc.h: runtime/mercury_misc.c: runtime/mercury_reg_workarounds.h: runtime/mercury_reg_workarounds.c: Move MR_memcpy() from mercury_misc.{h,c} to mercury_reg_workarounds.{h,c}. runtime/mercury_stack_trace.c: runtime/mercury_array_macros.h: runtime/mercury_tabling.h: Add/remove/modify the #include directives to reflect the above-mentioned changes.	2000-05-08 14:01:02 +00:00
Zoltan Somogyi	f0964815a3	Support line numbers in the debugger. You now get contexts (filename:lineno ... Estimated hours taken: 40 Support line numbers in the debugger. You now get contexts (filename:lineno pairs) printed in several circumstances, and you can put breakpoints on contexts, when they correspond to trace events or to calls. The latter are implemented as breakpoints on the label layouts of the return sites. This required extending the debugging RTTI, so that associated with each module there is now a new data structure listing the source file names that contribute labels with layout structures to the code of the module. For each such source file, this table gives a list of all such labels arising from that file. The table entry for a label gives the line number within the file, and the pointer to the label layout structure. compiler/llds.m: Add a context field to the call instruction. compiler/continuation_info.m: Instead of the old division of continuation info about labels into trace ports and everything else, divide them into trace ports, resume points and return sites. Record contexts with trace ports, and record contexts and called procedure information with return sites. compiler/code_info.m: Conform to the changes in continuation_info.m. compiler/options.m: Add a new option that allows us to disable the generation of line number information for size benchmarking (it has no other use). compiler/stack_layout.m: Generate the new components of the RTTI, unless the option says not to. compiler/code_gen.m: compiler/pragma_c_gen.m: compiler/trace.m: Include contexts in the information we gather for the layouts associated with the events we generate. compiler/call_gen.m: Include contexts in the call LLDS instructions, for association with the return site's label layout structure (which is done after code generation is finished). compiler/handle_options.m: Delete the code that tests or sets the deleted options. compiler/mercury_compile.m: Delete the code that tests the deleted options. compiler/basic_block.m: compiler/dupelim.m: compiler/frameopt.m: compiler/livemap.m: compiler/llds_common.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/value_number.m: compiler/vn_*.m: Trivial changes to conform to the changes to llds.m. compiler/jumpopt.m: Do not optimize away jumps to labels with layout structures. The jumps we are particularly concerned about now are the jumps that return from procedure calls. Previously, it was okay to redirect returns from several calls so that all go to the same label, since the live variable information associated with the labels could be merged. However, we now also associate line numbers with calls, and these cannot be usefully merged. compiler/optimize.m: Pass the information required by jumpopt to it. doc/user_guide.texi: Document that you can now break at line numbers. Document the new "context" command, and the -d or --detailed option of the stack command and the commands that set ancestor levels. runtime/mercury_stack_layout.h: Extend the module layout structure definition with the new tables. Remove the conditional facility for including label numbers in label layout structures. It hasn't been used in a long time, and neither Tyson or me expect to use it to debug either gc or the debugger itself, so it has no uses left; the line numbers have superseded it. runtime/mercury_stack_trace.[ch]: Extend the code to print stack traces to also optionally print contexts. Add some utility predicates currently used by the debugger that could also be use for debugging gc or for more detailed stack traces. trace/mercury_trace_internal.c: Implement the "break <context>" command, the "context" command, and the -d or --detailed option of the stack command and the commands that set ancestor levels. Conditionally define a conditionally used variable. trace/mercury_trace_external.c: Minor changes to keep up with the changes to stack traces. Delete an unused variable. trace/mercury_trace_spy.[ch]: Check for breakpoints on contexts. trace/mercury_trace_tables.[ch]: Add functions to search the RTTI data structures for labels corresponding to a given context. trace/mercury_trace_vars.[ch]: Remember the context of the current environment. tests/debugger/queen.{inp,exp}: Test the new capabilities of the debugger. tests/debugger/*.{inp,exp}: Update the expected output of the debugger to account for contexts. In some cases, modify the input script to put contexts where they don't overflow lines.	1999-11-15 00:43:59 +00:00
Fergus Henderson	c460b3eec3	Fix a bug: MR_stack_trace_bottom and MR_nondet_stack_trace_bottom ... Estimated hours taken: 0.25 runtime/mercury_stack_trace.h: runtime/mercury_stack_trace.c: Fix a bug: MR_stack_trace_bottom and MR_nondet_stack_trace_bottom were being _defined_ in the header file. I changed it so that they were only _declared_ in the header file, and defined in the .c file.	1999-06-08 03:47:41 +00:00
Zoltan Somogyi	c2da42e6d0	Allow the compiler to handle create rvals whose arguments have a size ... Estimated hours taken: 16 Allow the compiler to handle create rvals whose arguments have a size which is different from the size of a word. Use this capability to reduce the size of RTTI information, in two ways. The first way is by rearranging the way in which we represent information about the live values at a label. Instead of an array with an entry for each live value, the entry being a pair of Words containing a shape representation and a location description respectively, use an array of shape representations (still Words), followed by an array of 32-bit ints (which may be smaller than Word) describing locations whose descriptions don't fit into 8 bits, followed by an array of 8-bit ints describing locations whose descriptions do fit into 8 bits. The second way is by reducing the sizes of some fields in the C structs used for RTTI. Several of these had to be bigger than necessary in the past because their fields were represented by the args of a create rval. On cyclone, this reduces the size of the object file for queens.m by 2.8%. IMPORTANT Until this change is reflected in the installed compiler, you will not be able to use any modules compiled with debugging in your workspaces if the workspace has been updated to include this change. This is because the RTTI data structures generated by the old installed compiler will not be compatible with the new structure definitions. The workaround is simple: if your workspace contains modules compiled with debugging, don't do a cvs update until this change has been installed. configure.in: Check whether <stdint.h> is present. If not, autoconfigure types that are at least 16 and 32 bits in size. runtime/mercury_conf.h.in: Mention the macros used by the configure script, MR_INT_LEAST32_TYPE and MR_INT_LEAST16_TYPE. runtime/mercury_conf_param.h: Document the macros used by the configure script, MR_INT_LEAST32_TYPE and MR_INT_LEAST16_TYPE. runtime/mercury_types.h: If <stdint.h> is available, get the basic integer types (intptr_t, int_least8_t, etc) from there. Otherwise, get them from the autoconfigure script. Define types such as Word in terms of these (eventually) standard types. runtime/mercury_stack_layout.h: Add macros for manipulating short location descriptions, update the types and macros for manipulating long location descriptions. Modify the way the variable count is represented (since it now must count locations with long and short descriptions separately), and move it to the structure containing the arrays it describes. Reduce the size of the some fields in structs. This required some reordering of fields to avoid the insertion of padding by the compiler, and changes to the definitions of some types (e.g. MR_determinism). runtime/mercury_layout_util.[ch]: runtime/mercury_stack_trace.c: runtime/mercury_accurate_gc.c: trace/mercury_trace.c: trace/mercury_trace_external.c: trace/mercury_trace_internal.c: Update the code to conform to the changes to stack_layout.h. compiler/llds.m: Modify the create rval in two ways. First, add an extra argument to represent the types of the arguments, which used to always be implicit always a word in size, but may now be explicit and possibly smaller (e.g. uint_least8). Second, since the code generator would do the wrong thing with creates with smaller than wordsize arguments, replace the old must-be-unique vs may-be-nonunique bool with a three-valued marker, must_be_dynamic vs must_be_static vs can_be_either. Add uint_least8, uint_least16, uint_least32 (and their signed variants) and string as llds_types. Add a couple of utility predicates for checking whether an llds_type denotes a type whose size is the same as word. compiler/llds_out.m: Use explicitly given argument types when declaring and initializing the arguments of a cell, if they are given. compiler/llds_common.m: Don't conflate creates with identical argument values but different C-level argument types. The probability of a match is minuscule anyway. compiler/stack_layout.m: Use the new representation of creates to generate the new versions of RTTI data structures. compiler/code_exprn.m: If a create is marked must_be_static, don't inspect the arguments to decide whether it can be static or not. If it can't, we'll get an abort later on in llds_out or during C compilation anyway. compiler/base_type_layout.m: When creating pseudo typeinfos, return the llds_type of the resulting rval. Minor changes required by the change in create. compiler/base_type_info.m: compiler/base_typeclass_info.m.m: compiler/code_util.m: compiler/dupelim.m: compiler/exprn_aux.m: compiler/jumpopt.m: compiler/livemap.m: compiler/lookup_switch.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/string_switch.m: compiler/unify_gen.m: compiler/vn_cost.m: compiler/vn_filter.m: compiler/vn_flush.m: compiler/vn_order.m: compiler/vn_type.m: compiler/vn_util.m: compiler/vn_verify.m: Minor changes required by the change in create. library/benchmarking.m: library/std_util.m: Use the new macros in hand-constructing proc layout structures. library/Mmakefile: Add explicit dependencies for benchmarking.o and std_util.o on ../runtime/mercury_stack_layout.h. Although this is only a subset of the truth (in reality, all library objects depend on most of the runtime headers), it is a good tradeoff between safety and efficiency. The other runtime header files tend not to change in incompatible ways. trace/Mmakefile: Add explicit dependencies for all the object files on ../runtime/mercury_stack_layout.h, for similar reasons.	1999-04-30 06:21:49 +00:00
Zoltan Somogyi	83f80266d9	Improve the facilities for printing pointers into the det and nondet ... Estimated hours taken: 1 runtime/mercury_misc.[ch]: Improve the facilities for printing pointers into the det and nondet stacks for diagnostic purposes. runtime/mercury_stack_trace.c: Use the improved facilities in mercury_misc to improve the output. trace/mercury_trace_internal.c: Use the improved facilties in mercury_misc to improve the formatting of the output of the stack_regs command.	1999-03-17 00:35:24 +00:00
Fergus Henderson	fe1bb521c4	Re-fix a bug that was causing mdb's detailed stack traces to come out ... Estimated hours taken: 0.75 Re-fix a bug that was causing mdb's detailed stack traces to come out incorrectly on some occaisions. Erwan's recent changes accidentally removed my previous fix of this bug. Also fix another occurrence of a very similar bug. And fix a compiler warning in Erwan's new code. trace/mercury_trace_external.c: runtime/mercury_stack_trace.c: Re-fix a bug: `maybe_from_full' should have type `Integer', not `Word'. runtime/mercury_stack_trace.c: Fix a compiler warning: delete the unnecessary `extern' from the definition of MR_detism_names. runtime/mercury_trace_base.c: Fix a bug: `maybe_from_full' should have type `Integer', not `bool'.	1999-02-28 02:09:33 +00:00
Erwan Jahier	cc61b711cd	Moves the definition of MR_dump_stack_record_print() and MR_print_proc_id() ... Estimated hours taken: 3 Moves the definition of MR_dump_stack_record_print() and MR_print_proc_id() from trace/ to runtime/ to be able to call MR_dump_stack_record_print() from MR_dump_stack(). Indeed we can not pass down *MR_dump_stack_record_print() as a parameter of MR_dump_stack() since MR_dump_stack() is called from the library and we have to repect the invariant "trace -> library -> runtime". runtime/mercury_stack_trace.c: Add the missing argument of MR_dump_stack_from_layout() in the body of MR_dump_stack(). runtime/mercury_stack_trace.[ch]: trace/mercury_trace_internal.c: trace/mercury_trace_tables.[ch]: Move the definition of MR_dump_stack_record_print() from mercury_trace_internal.c to mercury_stack_trace.c and MR_print_proc_id() from mercury_trace_tables.c to mercury_stack_trace.c runtime/mercury_stack_trace.[ch]: trace/mercury_trace.[ch]: Move the definition of MR_detism_names[] from mercury_trace.c to mercury_stack_trace.c.	1999-02-23 08:06:54 +00:00
Mark Brown	f31b6bf9ed	Fix some warnings about incompatible pointer types. ... Estimated hours taken: 0.2 runtime/mercury_stack_trace.h: runtime/mercury_stack_trace.c: Fix some warnings about incompatible pointer types.	1999-02-20 06:58:07 +00:00
Erwan Jahier	9760975d5e	This change implement stack dump commands for the external debugger. ... Estimated hours taken: 7 This change implement stack dump commands for the external debugger. The MR_dump_stack_record_print() defined in runtime/mercury_stack_trace.c is the function that prints the contents of the stack. We move the definition of this function to mercury_trace_internal.c and we pass down that function as a parameter of MR_dump_stack_from_layout(). The rational for this change is that we can then define a new MR_dump_stack_record_print_to_socket() in mercury_trace_external.c that prints the data to the socket as a Prolog term and pass down the address of that new function to MR_dump_stack_from_layout(). browser/debugger_interface.m: Add three new kinds of requests: stack, nondet_stack and stack_regs. trace/mercury_trace_external.c: Define new MR_dump_stack_record_print_to_socket() and MR_print_proc_id_to_socket() that sends data to the socket as Prolog terms. Add support for stack, nondet stack and stack_regs requests. runtime/mercury_stack_trace.[ch] trace/mercury_trace.[ch]: trace/mercury_trace_internal.[ch]: Move the definition of MR_dump_stack_record_print(), from mercury_stack_trace.c to mercury_trace_internal.c. Add MR_dump_stack_record_print() as an argument of all the functions that need it in mercury_stack_trace.c. Move the definition of detism_names[] from mercury_stack_trace.c to mercury_trace.c. This function is needed by both versions of MR_dump_stack_record_print(). Rename detism_names[] by MR_detism_names[]. runtime/mercury_stack_trace.[ch] trace/mercury_trace_tables.[ch]: Move the definition of MR_print_proc_id() and MR_print_proc_id_for_debugger() from mercury_stack_trace.c to mercury_trace_tables.c since MR_print_proc_id() is called in that module. Include mercury_trace.h since we now make use of detism_names[] there.	1999-02-18 23:33:02 +00:00
Fergus Henderson	b698a27f6f	Fix a bug that was causing mdb's detailed stack traces to come out ... Estimated hours taken: 0.25 Fix a bug that was causing mdb's detailed stack traces to come out incorrectly on some occaisions. runtime/mercury_stack_trace.c: Fix a bug: `maybe_from_full' should have type `Integer', not `Word'.	1999-02-08 11:18:48 +00:00
Fergus Henderson	9d0fd6601a	Add support to mdb for doing the debugger I/O in a different ... Estimated hours taken: 4 Add support to mdb for doing the debugger I/O in a different window to the I/O of the program being debugged. (TODO: I/O from the browser still goes to the standard I/O streams rather than the debugger I/O streams. I will commit that soon as a separate change.) runtime/mercury_wrapper.h: runtime/mercury_wrapper.c: Add new runtime options for specifying filenames for the mdb I/O streams. doc/user_guide.texi: Document the new options. trace/mercury_trace_internal.c: Add three new variables holding the mdb I/O streams. Initialise them based on the option settings. Change the code so that all I/O goes through these streams. trace/mercury_trace_tables.c: trace/mercury_trace_tables.h: Pass a `void *' parameter through MR_process_matching_procedures() to the function it calls. This is needed by mercury_trace_internal.c to pass `MR_mdb_in' down to MR_print_proc_id_for_debugger(). runtime/mercury_stack_trace.c: runtime/mercury_stack_trace.h: Add a `FILE *' parameter to MR_print_proc_id_for_debugger(). tests/debugger/Mmakefile: When creating the `.out' files, redirect stderr as well as stdout, since debugger error messages now go to stderr rather than stdout.	1998-12-17 13:37:19 +00:00
Fergus Henderson	f5c2cef828	Fix a few bugs in the debugger. ... Estimated hours taken: 8 Fix a few bugs in the debugger. compiler/trace.m: Fix a bug for procedures compiled with shallow tracing: if from_full is false, it still needs to save the call depth, since calls in the body of the procedure will reset the call depth to the saved value. trace/mercury_trace_internal.c: Fix a couple of problems with the retry command: - if we're already at a call port, then just print a warning rather than finishing the call and then retrying it; - restore MR_trace_from_full to TRUE before jumping to the procedure. runtime/mercury_stack_trace.c: Fix some problems with the printing of detailed stack traces: - for procedures whose stack layouts didn't include execution tracing information, the columns didn't match up; - for procedures with shallow (interface) tracing only, it was sometimes printing out bogus details. runtime/mercury_trace_base.c: Fix some formatting problems in the error message output by MR_trace_fake().	1998-12-09 12:26:45 +00:00
Zoltan Somogyi	9aee4beb06	Provide feedback for the "up", "down" and "level" commands in the debugger, ... Estimated hours taken: 4 Provide feedback for the "up", "down" and "level" commands in the debugger, in the form of a line from an enhanced stack dump. runtime/mercury_stack_layout.h: Fix the documentation of the call event number slot. runtime/mercury_stack_trace.[ch]: Generalize the stack dump routines, to make them capable of printing the call event number, call sequence number and call depth slots of calls to traced procedures. trace/mercury_trace_internal.c: Add a new option, -d or --detailed, to the stack command, which prints the call event number, call sequence number and call depth slots of every ancestor procedure that is execution traced. When changing levels, provide feedback by identifying the call to which the level is now set. The feedback is the detailed stack trace line for that call. When changing levels, check that we have exec trace info for the call, not just stack trace info. Fix an old bug: tables of long options should be and now are terminated by a NULL row. doc/user_guide.texi: Document the new option of the stack command. Fix the documentation of the errors in the level change commands. tests/debugger/queens.{inp,exp}: Test the new functionality of the stack command, and update the expected output.	1998-11-13 08:40:47 +00:00
Zoltan Somogyi	8caba4e15d	Make it possible to compile a module (e.g. std_util) without debugging, ... Estimated hours taken: 18 Make it possible to compile a module (e.g. std_util) without debugging, while still allowing debuggable code called from that module via higher-order predicates (e.g. solutions) to have a proper stack trace. compiler/options.m: Add the new option --stack-trace-higher-order. compiler/mercury_compile.m: Always invoke continuation_info and stack_layout, since it is no longer the case that either all procedures or none get layout structures generated for them, and the other modules are in a better position to make that decision. compiler/continuation_info.m: Handle the extra tests required by the change to mercury_compile.m. When we gather info about a procedure, remember whether that procedure must have a procedure layout that includes the procedure id section. compiler/stack_layout.m: Use the flag remembered by continuation_info to help decide whether we need procedure layout structures. Fix an old space wastage: after generating marker saying that the second and later groups of fields of a procedure layout are not present, do not generate another marker saying that the third group of fields is not present. Since it was in the wrong position, it did not have the right meaning; it only worked because, due to the presence of the first marker, it was never looked at anyway. compiler/code_gen.m: Use the new capability of continuation_info.m to require procedure layouts including procedure id sections for any predicate that has higher-order arguments, if --stack-trace-higher-order is set. compiler/globals.m: Rename want_return_layouts as want_return_var_layouts, since this is a more accurate representation of what the predicate does. compiler/call_gen.m: compiler/code_info.m: Conform to the change in globals.m. compiler/llds_out.m: Separate the c_modules containing compiler-generated code into two groups, those that define labels that have stack layouts and those that don't. In most cases one or the other category will be empty, but with --stack-trace-higher-order, the c_modules containing higher-order procedures will have stack layouts, while others will not. Reorganize the way the way the initialization functions are generated, by putting c_modules falling into different categories into different bunches. c_module falling into the first category always have their initialization code included, while those in the second category have it included only if the old flag MR_MAY_NEED_INITIALIZATION is set. Delete the obsolete #define of MR_STACK_TRACE_THIS_MODULE. Improve some predicate names, in an effort to prevent confusion about what a "file" is (since the code uses more than one meaning, given the presence of --split-c-files). compiler/pragma_c_gen.m: Fix an old bug: s/NONDET_FIXED_SIZE/MR_NONDET_FIXED_SIZE/. Required for the change to library/string.m. doc/user_guide.texi: Document the new option. runtime/mercury_goto.c: Simplify the conditions under which labels get added to the label table with: - The macros init_{entry,label,local}_ai always add the label to the label table without a layout structure. - The macros init_{entry,label,local}_sl always add it with a layout structure. - Whether the macros init_{entry,label,local} with no suffix add the label to the label table depends on the values of other configuration parameters, but they will never include a layout structure. The intended use is that any label that has a layout structure should be initialized with a _sl macro. Any other label that should always be in the label table if the label table is needed at all (labels such as do_fail) should be initialized with _ai. Everything else should be initialized with a suffixless macro. runtime/mercury_conf_params.c: Remove MR_USE_STACK_LAYOUTS and MR_STACK_TRACE_THIS_MODULE, since due to the simplification of mercury_goto.h, they are not used anymore. runtime/mercury_stack_layout.h: Remove the old macros for creating layout structures with bogus contents, and replace them with new macros for creating layout structures with meaningful contents. runtime/mercury_engine.c: runtime/mercury_wrapper.c: Remove bogus layout structures. Ensure the labels defined here always get into the label table. runtime/mercury_ho_call.c: Remove bogus layout structures. Add proper ones where necessary. runtime/mercury_bootstrap.c: runtime/mercury_type_info.c: Remove bogus layout structures. runtime/mercury_boostrap.h: Add this new file for bootstrapping purposes. Temporarily #define NONDET_FIXED_SIZE as MR_NONDET_FIXED_SIZE, since pragma_c_gen.m refers to the former until the update to it gets installed. runtime/Mmakefile: Add a reference to mercury_boostrap.h. library/builtin.m: Remove bogus layout structures. library/array.m: library/benchmarking.m: library/private_builtin.m: Remove bogus layout structures. Add proper ones. library/std_util.m: Remove bogus layout structures. Add proper ones. Replace references to framevar(n) with references to MR_framevar(n+1). Fix an old bug in code under #ifndef COMPACT_ARGS: in the implementation of mercury____Compare___std_util__univ_0_0_i1, the succip register was not being saved across the call to mercury__compare_3_0. library/string.m: Remove the need for bogus layout structures, by converting the implementation of string__append(out, out, in) from hand-written C module into nondet pragma C code.	1998-11-05 03:53:48 +00:00
Fergus Henderson	f086a254ee	Fix a bug in mdb where the `down' command would let you go down ... Estimated hours taken: 0.5 Fix a bug in mdb where the `down' command would let you go down past the end of the stack. runtime/mercury_stack_trace.c: Change MR_find_nth_ancestor() so that it returns an error string if the `n' that you give it is a negative number.	1998-10-30 04:51:07 +00:00
Zoltan Somogyi	e196f28971	Improve the debugger's handling of compiler-generated and inter-module-inlined ... Estimated hours taken: 3 Improve the debugger's handling of compiler-generated and inter-module-inlined procedures. compiler/stack_layout.m: Update a comment. runtime/mercury_stack_layout.h: Introduce provisions for dealing with the procedure id section of the layout structures of compiler-generated procedures. runtime/mercury_stack_trace.c: Use the new provisions to generalize the function that prints out procedure ids for both stack traces and the debugger, so that it now works for both user-written and compiler-generated procedure, and prints out the extra info needed for a full identification in cases where the defining and declaring modules are not the same. (This can happen due to intermodule inlining, or the generation of local unification procedures for imported types.) trace/mercury_trace_tables.c: Update the code to conform to the changes in mercury_stack_layout.h. We still collect layout info only from user-written procedures, which means you can put breakpoints on only user-written procedures. Putting break-points on compiler-generated procedures would be unnecessary, even in the case of user-defined equality. trace/mercury_trace_external.c: Update the code to conform to the changes in mercury_stack_layout.h, and add comments asking Erwan to eventually either generalize his code or explicitly restrict it to user-defined procedures.	1998-10-28 05:24:20 +00:00
Zoltan Somogyi	8a0ceb49aa	This checkin has several major purposes, set out in the sections below, ... Estimated hours taken: 240 This checkin has several major purposes, set out in the sections below, all connected with the implementation of the new debugger command set. DOCUMENT NEW DEBUG COMMAND SET doc/user_guide.texi: Add a new section on the debugger. The description of the commands is complete, but some of the background sections, and the section about how to build debuggable executables, are not yet done. Update the documentation of the tracing options. doc/generate_mdb_doc: A new shell script that automatically converts some of the new sections of the user guide into the online documentation of the debugger. doc/mdb_categories: The fixed initial part of the online documentation. doc/Mmakefile: Add rules for creating mdb_doc, the file that is the online documentation of the debugger, and for installing it together with mdbrc. Mmake.common.in: Define INSTALL_DOC_DIR for doc/Mmakefile. scripts/mdbrc.in: A debugger command script that reads in the online documentation and then defines some standard aliases. configure.in: Define the variable that scripts/mdb.in and scripts/mdbrc.in use to find the right files, and get configure to perform the substitutions. configure.in: scripts/mdb: scripts/mdb.in: Replace mdb with mdb.in. Mdb is now created during configuration from mdb.in, filling in the name of the file that contains the default debugger initialization commands. util/info_to_mdb.c: A program that does most of the work involved in automatically converting user guide sections into online documentation. (This couldn't easily be written in sh, because sh's read command has no notion of pushback.) util/Mmakefile: Add info_to_mdb to the list of targets. tools/bootcheck: Make sure that the tests in tests/debugger are executed with an initialization setup that is equivalent to what users will see by default. REORGANIZE TRACING OPTIONS compiler/globals.m: compiler/handle_options.m: compiler/options.m: compiler/trace.m: Reorganize the handling of trace levels around the new options --trace-internal, --trace-redo, and --trace-return. compiler/*.m: Use the new ways of getting at trace levels. tests/hard_coded/typeclasses/Mmakefile: s/--trace all/--trace deep/ SUPPORT RETRY compiler/trace.m: After every call to MR_trace(), emit code that checks whether it should jump away, and if yes, performs the jump. This is used to implement retry. (The debugger cannot execute the jump itself because it is in the wrong C stack frame.) compiler/llds.m: compiler/continuation_info.m: compiler/stack_layout.m: Modify the data structures that record information about live value at program points, to record the identity of each variable. This is necessary for the implementation of the restart command, since we do not want to confuse two distinct variables just because they have the same name. For example, a variable whose name is X and number is 5 is now recorded in the name array as "5:X". Clean up the data structure a bit, so that we don't have to store dummy names for values that are not variables. compiler/*.m: Minor changes to conform to the data structure changes. runtime/mercury_stack_layout.h: Redefine an existing macro to strip away the initial number: prefix from the "name" of a variable (keeping its original function on changed data), and add a new one to access the raw unstripped data. runtime/mercury_init.h: runtime/mercury_wrapper.h: Update the prototype of MR_trace_{fake,real}, and the type of the global that points to them. runtime/mercury_layout_util.h: Add an extra function, MR_get_register_number, for use by retry. USE FIXED STACK SLOTS FOR TRACE INFO compiler/code_gen.m: compiler/code_info.m: compiler/live_vars.m: compiler/trace.m: If execution tracing is enabled, reserve the first few stack slots to hold the event number of the call event, the call number, the call depth, the redo layout structure address (if generating redo events) and the from_full flag at the time of call (if we are doing shallow tracing). By allocating the first four of these to fixed stack slots, the debugger knows where to look for them without having to be told. It finds out the location of the fifth, if needed, from a new slot in the proc layout structure. (It is not possible to allocate all five to fixed stack slots without wasting stack space in some cases.) compiler/trace.m: Remove from the call to MR_trace the parameters that are now in fixed stack slots, since MR_trace can now look them up itself. compiler/continuation_info.m: compiler/stack_layout.m: Add an extra field to the proc_layout_info. If the module is shallow traced, this field says which stack slot holds the saved value of MR_from_full. If it is not shallow traced, this field says that there is no such stack slot. runtime/mercury_stack_layout.h: Add macros for accessing the fixed stack slots holding the event number of the call event, the call number, the call depth, and, at a redo event, the redo layout structure address. Support the new field in proc layouts that gives the location of the from-full flag (if any). runtime/mercury_trace_base.[ch]: trace/mercury_trace.[ch]: Remove the call number and call depth arguments from MR_trace and its avatars, since this info is now in fixed stack slots in every procedure that can call MR_trace. This should reduce the size of the executable significantly, since there are lots of calls to MR_trace. runtime/mercury_init.h: runtime/mercury_wrapper.h: Update the prototype of MR_trace_{fake,real}, and the type of the global that points to them. START NUMBERING FRAMEVARS FROM ONE compiler/code_info.m: compiler/live_vars.m: compiler/llds_out.m: compiler/trace.m: Start numbering framevars from 1 internally to the compiler; the runtime already starts from 1. This simplifies several tasks. ADD REDO EVENTS compiler/trace.m: compiler/code_gen.m: Before the code that executes "succeed()", emit code to push a a temp nondet frame whose redoip points to a label in the runtime that calls MR_trace for a REDO event and then fails, provided --trace-redo is set. compiler/llds.m: Add a new code address constant, do_trace_redo_fail, which stands for the address in the trace system to which calls MR_trace for the redo event and then fails. compiler/trace.m: compiler/llds_out.m: Provided we are doing redo tracing, fill in the slot that holds the layout information for the REDO event. compiler/*.m: Minor changes to conform to handle the new code address constant. browser/debugger_interface.m: Add redo to trace_port_type. runtime/mercury_trace_base.[ch]: Add a C module containing the code that calls MR_trace for REDO events. ENSURE THAT INPUT ARGUMENTS ARE ALWAYS VISIBLE compiler/trace.m: When generating the set of live variables at internal ports, the variables that are in the pre-death set of the goal into which we are entering may not be available. However, the variables in the pre-death set that are also in the resume vars set will be available, so now include info about them in the layout structure for the event. Since with tracing the non-clobbered input args are in all resume vars sets, this ensures that these input args will be available from all internal events. compiler/code_info.m: Export a previously internal predicate (current_resume_point_vars) to make this possible. BUG FIX: WANT RETURN LAYOUTS compiler/globals.m: compiler/call_gen.m: compiler/code_info.m: compiler/mercury_compile.m: Add a new pred globals__want_return_layouts, which says whether the compiler should generate layout structures for call returns. This pred centralizes the several previous copies of the test. One of those copies (the one in call_gen) was faulty, leading to a bug: in the presence of execution tracing but the absence of accurate gc, information about the variables that are live at the call return wasn't being gathered properly. BUG FIX: #include mercury_trace_base.h compiler/llds_out.m: #include mercury_trace_base.h, not mercury_trace.h, since now mercury_trace_base.h defines everything directly accessible from modules compiled with tracing. RECAST MERCURY_TRACE_UTIL AS MERCURY_LAYOUT_UTIL runtime/mercury_trace_util.[ch]: runtime/mercury_layout_util.[ch]: Rename this module from trace_util to layout_util, since it is also used by the native garbage collector. Remove "trace" from the names of functions. Get rid of the global variable MR_saved_regs, and instead thread a pointer to this data structure through the relevant functions as an extra argument. Add a lot more documentation in the header file. runtime/Mmakefile: Reflect the module rename. runtime/*.c: Refer to the new module. DELETE EASY-TO-MISUSE MACROS runtime/mercury_stacks.h: Delete the based_framevar and based_detstackvar macros, since their continued use can lead to off-by-one errors, and the saved_framevar and saved_detstackvar macros, since they are no longer used. runtime/*.c Update any references to any macros removed from mercury_stacks.h. MISC RUNTIME CHANGES runtime/mercury_trace_base.[ch]: trace/mercury_trace*.[ch]: Make typedef'd names conform to the naming convention. Make MR_trace_call_{seqno,depth} consistently Unsigned, rather than sometimes Word and sometimes Unsigned. FIX BUG: MAKE THE DEBUGGER PRINT TO STDOUT, NOT THE CURRENT STREAM library/io.m: Export to C code the predicates that return the identities and types of stdin, stdout and stderr, as well as io__print/[34]. library/std_util.m: Export to C code a predicate that returns the type_info for the type stdutil:type_info. This type_info is required if C code wants to invoke make_permanent on any type_info structure, as the debugger does. runtime/mercury_init.h: Add extern declarations for the C functions now exported from io.m. runtime/mercury_wrapper.[ch]: Add new global variables to hold the addresses of these C functions. runtime/mercury_layout_util.c: Use indirect calls through these global variables to print Mercury values, instead of lower-level code. util/mkinit.c: Assign the addresses of the functions exported from io.m to the global variables defined in mercury_wrapper.h. BUG FIX: STACK TRACE FUNCTIONS DEPEND ON THE LABEL TABLE runtime/mercury_stack_trace.c: On entry to any of the functions exported from this module, ensure that the label table is loaded by calling do_init_modules. Without a filled-in label table, the stack trace will not be able to find any stack layout info. BUG FIX: REMOVE BROWSER/*.C configure.in: When removing .c files generated by the C compiler, remove those in the browser directory as well as the compiler, library and profiler directories. IMPLEMENT NEW DEBUGGER COMMAND SET runtime/mercury_stack_trace.[ch]: Factor out the code that prints the id of a procedure into a function of its own, so that it can also be used from the debugger, ensuring appearance commonality. Add more documentation in the header file. trace/mercury_trace_internal.c: Implement the proposed command set. Command names are now words, and several commands now have options allowing the user to override the default print level or strictness of the command, or the invocation conditions or action of a break point. Allows control over command echoing and the scrolling of sequences of event reports. Supports aliases, command file sourcing etc. Implements the retry command, using the info in the fixed stack slots. trace/mercury_trace.[ch]: Extend the trace controls to support the new functionalities required by the new debugger language, which are print levels, variable-strictness commands, a more flexible finish command, and the retry command. Pass the command structure to MR_trace_event_report, since the user can now forcibly terminate the scrolling of reports. trace/mercury_trace_alias.[ch]: New module to manage aliases for the debugger. trace/mercury_trace_help.[ch]: New module to interface to browser/help.m. trace/mercury_trace_spy.[ch]: New module to manage break points. The test of whether an event matches a break point is now much more efficient than before. The new module also allows several breakpoints with different actions and different invocation conditions (e.g. all ports, entry port, interface ports or specific (possibly internal) port) to be defined on the same procedure. trace/mercury_trace_tables.[ch]: New module to manage a table of the debuggable modules, in which each such module is linked to the list of the layouts of all the procedures defined in that module. This information allows the debugger to turn the name of a predicate/function (possibly together with its arity and mode number) into the procedure layout structure required by the spy point module. Eventually it may also be useful in supplying lists of identifiers for command line completion. Modules for which no stack layout information is available will not be included in the table, since do_init_modules will not register any labels for them in the label table. trace/Mmakefile: Mention the new files. runtime/mercury_array_macros.h: A new file holding macros that can be useful in more than one module. runtime/Mmakefile: Mention the new file. runtime/mercury_conf.h.in: Mention a new configuration macro, MR_CANNOT_USE_STRUCTURE_ASSIGNMENT, used by runtime/mercury_array_macros.h. configure.in: Find out whether we need to define MR_CANNOT_USE_STRUCTURE_ASSIGNMENT. ADD TRACE DEPTH HISTOGRAMS runtime/mercury_conf_param.h: Document MR_TRACE_HISTOGRAM. runtime/mercury_trace_base.[ch]: Define the data structures for the histogram, and print the histogram when a traced program exits if MR_TRACE_HISTOGRAM is set. trace/mercury_trace.[ch]: If MR_TRACE_HISTOGRAM is defined, record a count of the number of events at each depth. This information can help us evaluate space-time tradeoffs. FACTOR OUT SHELL CODE HANDLING GRADE IMPLICATIONS scripts/final_grade_options.sh-subr: A new file to contain any code that implements implications between grade flags; currently implements the implication debug -> use trail. scripts/mgnuc.in: scripts/ml.in: Replace the code that is now in final_grade_options.sh-subr with an inclusion of final_grade_options.sh-subr. configure.in: Handle final_grade_options.sh-subr as {init,parse}_grade_options.sh-subr are handled. SIMPLIFY THE MAINTAINANCE OF CONSISTENCY BETWEEN DEBUGGER CODE AND DOCUMENTATION doc/Mmakefile: Add rules for creating mdb_command_list, a C code fragment that can included manually in trace/mercury_trace_internal.c to supply the list of valid commands, and mdb_command_test.inp, which is a list of invalid invocations of debugger commands, which tests whether the help message for such invocations can be located as expected. doc/generate_mdb_command_list: doc/generate_mdb_command_test: Awk scripts to create mdb_command_list and mdb_command_test.inp respectively from mdb_doc. tools/bootcheck: Copy mdb_command_test.inp from doc to tests/debugger. tests/debugger/Mmakefile: Add a new test that checks whether we get an internal error, unable to locate the right help node, for each invalid command invocation in mdb_command_test.inp. UPDATE TEST CASES tests/debugger/Mmakefile: Reenable queens. Conform to the new set of options. tests/debugger/*.inp: tests/debugger/*.exp: Update the inputs and expected outputs of the debugger test cases to use the new command set and output formats.	1998-10-16 06:20:28 +00:00
Zoltan Somogyi	b6892f44ac	Fix to get tests/tabling/tc_minimal to work. ... Estimated hours taken: 6 Fix to get tests/tabling/tc_minimal to work. runtime/mercury_tabling.h: Replace the macro table_allocate with two macros table_allocate_bytes and table_allocate_words, which are explicit about the unit of their size argument. Replace the macro table_reallocate with two macros table_reallocate_bytes and table_reallocate_words, which are explicit about the unit of their size argument. Replace the macro table_copy_mem with two macros table_copy_bytes and table_copy_words, which are explicit about the unit of their size argument. Fix the MR_DEBUG_TABLE_* macros, which had the old and new table pointers the wrong way around in the conditionally enabled diagnostic messages. runtime/mercury_table_*.c: Replace references to the obsolete macros with their appropriate replacements. runtime/mercury_stack trace.c: When dumping the nondet stack, print the size of each stack frame. This makes it easier to find bugs involving confusion of bytes and words :-) library/private_builtin.m: Fix some bugs involving confusion of bytes and words using the new macros from mercury_tabling.h. Make debugging easier, by using variables (whose values can be printed quite easily in gdb) instead of macros involving several casts (which cannot be printed easily in gdb), and by adding conditionally included code that prints diagnostics at saves and restores of stack segments. Delete some dead code. Clean up the formatting in some places. tests/tabling/Mmakefile: Enable the tc_minimal benchmark, since we now pass it.	1998-09-21 06:31:05 +00:00
Zoltan Somogyi	ed063bcc00	Extend the new failure handling method to optionally preserve an invariant ... Estimated hours taken: 30 Extend the new failure handling method to optionally preserve an invariant required by accurate gc: always being able to tell with respect to what MR_sp or MR_curfr to interpret the stackvars and framevars referred to by the label whose address is the redoip slot of a nondet stack frame. This basically requires limitations on the hijacking of redoip/redofr slot pairs. compiler/notes/failure.html: Describe the new extension. Change the terminology to conform to what is used in the code. compiler/llds.m: For each temporary frame on the nondet stack, specify the native stack of the procedure that created it. This is so that we know whether the temporary frame ought to have the fourth slot that specifies the right value of MR_sp. (The fourth slot is included only in temporary nondet stack frames created procedures that live on the det stack; procedures that live on the nondet stack never have any of their variables on the det stack.) Remove the modframe llds instruction, since it does not specify what frame's redoip slot it is assigning to. This is error-prone (see peephole.m below). We were not using modframe much anyway. compiler/llds_out.m: compiler/opt_debug.m: Emit either mktempframe or mkdettempframe depending on the new field in temp_frame. compiler/code_info.m: Add a fourth item to the failure state, which states whether the top frame of the nondet stack may be hijacked. Initialize it from the option --allow-hijacks. If about to do a hijack but the failure state says no, create a temporary frame instead. Separate out the code for creating temporary frames, since it is now called from more than one place. Generalize the code to handle the new type of temp frame. compiler/code_info.m: compiler/ite_gen.m: Simplify the way we transmit information about the location of the address of the nondet stack frame in which the soft cut is performed from the start of the condition to its end. Remove the predicate code_info__maybe_push_temp_frame; its functionality is now achieved in code_info.m by disabling and restoring --allow-hijacks around the generation of code for the condition. This also allows us to get rid of the code that finds out whether the condition can do any hijacking. compiler/opt_util.m: Rename next_modframe as next_assign_to_redoip, and add an additional argument that says which frame's redoip we are after. compiler/peephole.m: Use the new argument of opt_util__next_assign_to_redoip to fix a bug where a mkframe of a temporary frame (which leaves curfr unchanged) that was followed a modframe (which assigns to the redoip of curfr) was incorrectly optimized (the assignment to the redoip slot was applied to the temporary frame, not the ordinary one). compiler/*.m: Minor changes to accommodate the disappearance of modframe. runtime/mercury_stacks.h: Add macros to support four-word temp frames on the nondet stack. Make the macros that access nondet stack frame slots start with MR_, while keeping (redefined) macros needed for backward compatibility. Remove the modframe macro. Fix a dangling reference to PREDNM instead of MR_PREDNM. runtime/mercury_stack_trace.c: Modify the stack tracing code to allow for the new four-word temp frames. Use the new MR_ prefixed variants of the macros. runtime/mercury_debug.h: runtime/mercury_misc.[ch]: Remove references to modframe. tests/general/complex_failure.{m,exp}: A new test case to tickle the various ways of handling nested disjunctions and if-then-elses in the new code generator. tests/general/Mmakefile: Enable the new test case. tests/{general,hard_coded}/space.{m,exp}: Move this test case from general to hard_coded. Although NU-Prolog can execute it, it does not give the same answers as Mercury due to a different default ordering and a difference in integer size (26-bit integers in NU-Prolog) that changes the behavior of the pseudo random-number generator. tests/hard_coded/cycles2.exp: Add the missing .exp file for this existing test case. tests/hard_coded/Mmakefile: Enable the old test cases cycles, cycles2 and space, since we now pass them.	1998-07-29 08:57:09 +00:00
Fergus Henderson	de9eb85a6b	Delete unnecessary references to MR_USE_REDOFR. ... Estimated hours taken: 0.5 runtime/mercury_grade.h: runtime/mercury_imp.h: runtime/mercury_stack_trace.c: Delete unnecessary references to MR_USE_REDOFR. There's no point in having that macro, since we always use a redofr now.	1998-07-26 08:38:36 +00:00
Tyson Dowd	c8ba3551ea	An initial implementation of the accurate garbage collector. ... Estimated hours taken: 90 An initial implementation of the accurate garbage collector. WORK_IN_PROGRESS: Add an entry for the accurate garbage collector. library/builtin.m: library/mercury_builtin.m: library/std_util.m: runtime/mercury_tabling.h: Deep copy terms using the address of the value instead of just the value. library/io.m: Initialize the garbage collector's rootset with the globals. runtime/Mmakefile: Add new files to the Mmakefile. runtime/mercury_accurate_gc.h: runtime/mercury_accurate_gc.c: The new garbage collector. runtime/mercury_agc_debug.c: runtime/mercury_agc_debug.h: Debugging utilities for the new garbage collector. runtime/mercury_deep_copy.c: runtime/mercury_deep_copy.h: runtime/mercury_deep_copy_body.h: Put the deep copy code in mercury_deep_copy_body.h, and #include it with appropriate #defines in order to get a variant for deep_copy(), and one for agc_deep_copy(). agc_deep_copy() forwards pointers as it copies. Also, deep_copy (all variants) have been modified to take a pointer to the data to be copied, because some variants need to be able to modify it. runtime/mercury_engine.c: runtime/mercury_engine.h: Add a second heap_zone which is the to-space of the copying collector. Add a debug_heap_zone, which is used as a scratch heap for debugging. runtime/mercury_label.c: Instead of realloc(entry_table, ....) do entry_table = realloc(entry_table, ....) to avoid horrible bugs. Also, make sure the tables get initialized before looking up an entry label. runtime/mercury_imp.h: Include mercury_debug.h before most of the modules. (mercury_engine.h adds a new MemoryZone only if we are debugging accurate GC). runtime/mercury_memory.c: Setup the debug_memory_zone sizes. Remove an unnecessary prototype. runtime/mercury_memory_handlers.c: Add code to get the program counter and the stack pointer from the signal context. Call MR_schedule_agc() from default_handler() if doing accurate gc. runtime/mercury_memory_zones.c: Setup the hardzone regardless of whether redzones are used. Add some more debugging information. runtime/mercury_regorder.h: runtime/machdeps/alpha_regs.h: runtime/machdeps/i386_regs.h: Add definitions to make the real machine registers name/number for MR_sp available. runtime/mercury_trace_internal.c: runtime/mercury_trace_util.c: runtime/mercury_trace_util.h: Add MR_trace_write_variable(), which writes terms given their value and type_info. runtime/mercury_wrapper.c: runtime/mercury_wrapper.h: Change the size of the heap redzone when doing accurate GC. Use a small heap when debugging agc. runtime/mercury_debug.h: runtime/mercury_conf_param.h: Add new debugging macros and document them. runtime/mercury_type_info.c: Add const to the pointer arguments of MR_make_type_info.	1998-07-22 07:53:35 +00:00
Zoltan Somogyi	d1855187e5	Implement new methods of handling failures and the end points of branched ... Estimated hours taken: 260 Implement new methods of handling failures and the end points of branched control structures. compiler/notes/failure.html: Fix an omission about the handling of resume_is_known in if-then-elses. (This omission lead to a bug in the implementation.) Optimize cuts across multi goals when curfr is known to be equal to maxfr. Clarify the wording in several places. compiler/code_info.m: Completely rewrite the methods for handling failure. Separate the fields of code_info into three classes: those which do not change after initialization, those which record state that depends on where in the HLDS goal we are, and those which contain persistent data such as label and cell counters. Rename grab_code_info and slap_code_info as remember_position and reset_to_position, and add a wrapper around the remembered code_info to make it harder to make mistakes in its use. (Only the location-dependent fields of the remembered code_info are used, but putting only them into a separate data structure would result in more, not less, memory being allocated.) Gather the predicates that deal with handling branched control structures into a submodule. Reorder the declarations and definitions of access predicates to conform to the new order of fields. Reorder the declarations and definitions of the failure handling submodule to better reflect the separation of higher-level and lower-level predicates. compiler/code_gen.m: Replace code_gen__generate_{det,semi,non}_goal_2 with a single predicate, since for most HLDS constructs the code here is the same anyway (the called preds check the code model when needed). Move classification of the various kinds of unifications to unify_gen, since that is where it belongs. Move responsibility for initializing the code generator's trace info to code_info. Move the generation of code for negations to ite_gen, since the handling of negations is a cut-down version of the handling of negations. This should make the required double maintenance easier, and more likely to happen. compiler/disj_gen.m: compiler/ite_gen.m: These are the two modules that handle most failures; they have undergone a significant rewrite. As part of this rewrite, factor out the remaining common code between model_non and model_{det,semi} goals. compiler/unify_gen.m: Move classification of the various kinds of unifications here from code_gen. This allows us to keep several previously exported predicates private. compiler/call_gen.m: Factor out some code that was common to ordinary calls, higher order calls and method calls. Move the common code that checks whether we are doing tracing to trace.m. Replace call_gen__generate_{det,semi,nondet}_builtin with a single predicate. Delete the commented out call_gen__generate_complicated_unify, since it will never be needed and in any case suffered from significant code rot. compiler/llds.m: Change the mkframe instruction so that depending on one of its arguments, it can create either ordinary frames, or the cut-down frames used by the new failure handling algorithm (they have only three fixed fields: prevfr, redoip and redofr). compiler/llds_out.m: Emit a #define MR_USE_REDOFR before including mercury_imp.h, to tell the runtime we are using the new failure handling scheme. This effectively changes the grade of the compiled module. Emit MR_stackvar and MR_framevar instead of detstackvar and framevar. This is a step towards cleaning up the name-space, and a step towards making both start numbering at 0. For the time being, the compiler internally still starts counting framevars at 0; the code in llds_out.m adds a +1 offset. compiler/trace.m: Change the way trace info is initialized to fit in with the new requirements of code_info.m. Move the "are we tracing" check from the callers to the implementation of trace__prepare_for_call. compiler/*.m: Minor changes in accordance with the major ones above. compiler/options.m: Introduce a new option, allow_hijacks, which is set to "yes" by default. It is not used yet, but the idea is that when it is set to no, the code generator will not generate code that hijacks the nondet stack frame of another procedure invocation; instead, it will create a new temporary nondet stack frame. If the current procedure is model_non, it will have three fields: prevfr, redoip and redofr. If the current procedure is model_det or model_semi, it will have a fourth field that is set to the value of MR_sp. The idea is that the runtime system, which will be able to distinguish between ordinary frames (whose size is at least 5 words), 3-word and 4-word temporary frames, will now be able to use the redofr slots of all three kinds of frames and the fourth slot values of 4-word temporary frames as the addresses relative to which framevars and detstackvars respectively ought to be offset in stack layouts. compiler/handle_options.m: Turn off allow_hijacks if the gc method is accurate. runtime/mercury_stacks.h: Change the definitions for the nondet stack handling macros to accommodate the new nondet stack handling discipline. Define a new macro for creating temp nondet frames. Define MR_based_stackvar and MR_based_framevar (both of which start numbering slots at 1), and express other references, including MR_stackvar and MR_framevar and backward compatible definitions of detstackvar and framevar for hand-written C code, in terms of those two. runtime/mercury_stack_trace.[ch]: Add a new function to print a dump of the fixed elements nondet stack, for debugging my changes. (The dump does not include variable values.) runtime/mercury_trace_internal.c: Add a new undocumented command "D" for dumping the nondet stack (users should not know about this command, since the output is intelligible only to implementors). Add a new command "toggle_echo" that can cause the debugger to echo all commands. When the input to the debugger is redirected, this echo causes the output of the session to be much more readable. runtime/mercury_wrapper.c: Save the address of the artificial bottom nondet stack frame, so that the new function in mercury_stack_trace.c can find out where to stop. runtime/mercury_engine.c: runtime/mercury_wrapper.c: Put MR_STACK_TRACE_THIS_MODULE at the tops of these modules, so that the labels they define (e.g. do_fail and global_success) are registered in the label table when their module initialization functions are called. This is necessary for a meaningful nondet stack dump. runtime/mercury_grade.h: Add a new component to the grade string that specifies whether the code was compiled with the old or the new method of handling the nondet stack. This is important, because modules compiled with different nondet stack handling disciplines are not compatible. This component depends on whether MR_USE_REDOFR is defined or not. runtime/mercury_imp.h: If MR_DISABLE_REDOFR is defined, undefine off MR_USE_REDOFR before including mercury_grade.h. This is to allow people to continue working on un-updated workspaces after this change is installed; they should put "EXTRA_CFLAGS = -DMR_DISABLE_REDOFR" into Mmake.stage.params. (This way their stage1 will use the new method of handling failure, while their stage2 2&3 will use the old one.) This change should be undone once all our workspaces have switched over to the new failure handling method. tests/hard_coded/cut_test.{m,exp}: A new test case to tickle the various ways of handling cuts in the new code generator. tests/hard_coded/Mmakefile: Enable the new test case.	1998-07-20 10:04:02 +00:00
Fergus Henderson	a6359d48ed	Fix some bugs in Zoltan's recent changes that prevented it ... Estimated hours taken: 0.25 runtime/mercury_stack_trace.c: Fix some bugs in Zoltan's recent changes that prevented it from compiling with --debug.	1998-07-04 06:04:21 +00:00
Zoltan Somogyi	4ada219856	Reorganize the label table to better fit the needs of accurate gc ... Estimated hours taken: 25 Reorganize the label table to better fit the needs of accurate gc and the tracer, and reduce the size of executables. With these changes, the size of hello world, compiled with static Mercury libraries but dynamic C libraries, goes from 150+ Kb to 138+ Kb, much of which is beyond our control (e.g. Boehm gc). runtime/mercury_label.[ch]: The old label table contained both entry labels and internal labels, even though they had different kinds of layouts associated with them (proc layouts and label layouts respectively). The two kinds of labels have different usage patterns. Internal labels are needed for stack walking, which requires random access by exact label address. Entry labels are needed for finding which procedure a program counter is in for accurate GC, which requires lower-bound inexact search. The module now has two separate data structures for the two different kinds of labels. Internal labels are in a hash table, as before. Entry labels are in an array (resized on demand), which is sorted for binary search. The entry label array and its associated functions are present only if they are needed. runtime/mercury_goto.h: Call the new functions in mercury_label.c from the init_{local,label,entry}{,_sl} macros. runtime/mercury_misc.[ch] Use the new functions in mercury_label. Fix some software rot, so that the code now compiles with MR_DEBUG_GOTOS. (It still does not compile with MR_LOWLEVEL_DEBUG, but the fix for that would conflict with Tom's planned change to zone handling, so that fix should be done after Tom is done.) Note that mercury_misc.c still defines newmem() and oldmem() although they are declared in mercury_std.h. runtime/mercury_stack_trace.c: Use the new functions in mercury_label. As a result, we also need to make a few more pointers const. runtime/mercury_table.[ch]: Add a new traversal predicate to support a new function in mercury_label.c. (That function is not used yet, but will be soon.) runtime/mercury_trace.[ch]: runtime/mercury_trace_base.[ch]: Split the old mercury_trace module into two. The functions and variables that will always be linked in (because they are referenced from modules such as mercury_wrapper which are always needed) are now in mercury_trace_base; the other functions and variables stay in mercury_trace. This way, mercury_trace.o will be linked in only if some module was compiled with execution tracing. Since mercury_trace.o drags in mercury_trace_internal.o which drags in everything needed for printing arbitrary terms (which is a lot), this can be a significant win. runtime/Mmakefile: Include the new module in the library. runtime/mercury_wrapper.c: runtime/mercury_conf_param.h: Remove some obsolete MERCURY_OPTIONS options, which would be difficult to support with the new label table. Move the #ifdefs around the -P option, so that programs not compiled with MR_THREAD_SAFE will accept but ignore the option, instead of aborting with the usage message. Replace the long usage message for malformed MERCURY_OPTIONS environment variables with a pointer to the user's guide. This saves about 1 Kb on every executable. runtime/mercury_conf_param.h: Document MR_STACK_TRACE_THIS_MODULE. util/mkinit.c: Add a new flag, -i. If this flag is given, include the initialization code regardless of grade. If it is not given, include the init code only if the grade requires it. The -i should be given if you want the executable to support stack tracing, or uplevel printing in execution tracing, at the cost of making the executable link in the init functions of all the modules in the library. Put the option handling code in alphabetical order. Fix the wrong default name of the entry point. (It only worked because c2init was always overriding the default.) scripts/c2init.in: Pass through the -i flag to mkinit. Put the option handling code in alphabetical order. compiler/mercury_compile.m: If the trace level specifies any kind of tracing, pass -i to c2init. tests/debugger/Mmakefile: Add -i to the c2init flags. tests/debugger/* Update the other half the test cases (those which assume a traced library) to conform to the changes in the debugger interface. The first half were updated earlier. doc/user_guide.texi: In the environment variable section, modify the entry for MERCURY_OPTIONS to document all the options it makes sense for non-developers to use. Slight changes to two other parts of the guide to reduce duplication with the new material.	1998-07-03 02:36:09 +00:00
Fergus Henderson	92cb1108bc	Add a missing `const'. ... Estimated hours taken: 0.1 runtime/mercury_stack_trace.c: Add a missing `const'.	1998-07-02 08:09:05 +00:00
Zoltan Somogyi	f203aea15c	Allow the debugger to print the values of variables in ancestors ... Estimated hours taken: 20 Allow the debugger to print the values of variables in ancestors of the current call. This requires knowledge about which named variables are live at call return sites. Providing this information properly required fixing the interaction of execution tracing and accurate garbage collection. compiler/globals.m: Introduce a new trace level, so that there are now four: none, interface, interface_ports (corresponding to the existing three levels) and the new level interface_ports_returns, each of which requires all the information required by lower levels. Make the trace level abstract, since in the future we may want to introduce trace levels for new combinations, e.g. interfaces and returns but not internal ports. Introduce the necessary new predicates. compiler/continuation_info.m: Redefine internal_label_info to allow us to record separate info about the sets of vars needed at (a) internal ports of execution tracing and at (b) call return points for accurate gc or (now) uplevel printing during execution tracing. Neither is a subset of the other, and they need to be treated differently. compiler/mercury_compile.m: Gather information about vars at return labels if the trace level requires uplevel printing capability, even if agc is off. compiler/stack_layout.m: Fix the handling of labels which are needed both by agc and by execution tracing. If information at a return label is needed only by uplevel printing in execution tracing and not by agc, then discard all info about lvals which do not hold named variables or their typeinfos (in fact we keep all typeinfos at the moment). If a label is both the label of a port and a return label, we include in the layout structure the union of the information recorded for the two roles. Sort the var_info vector before using it to generate layout structures in an attempt to make llds_common more effective and to make lists of variables printed by the debugger look better. Record a distinguished value when there is no info about the vars live at a label, rather than (incorrectly) recording that there are no live variables. Before up-level printing, the lie was harmless; now it isn't. Remove the label number from return label layouts, since the tracer isn't expecting it. It used to be included for debugging purposes if the label was for agc, but it is possible for a label to be needed both for agc and for execution tracing. If Tyson finds he needs the label number, it can be easily turned back on for all label layouts. compiler/code_info.m: Conform to the new definition of internal_label_info. Rename an internal pred for clarity. Rename some bool parameter to correctly reflect their new meaning. compiler/*.m: Trivial changes, mostly due to making trace_level an abstract type. runtime/mercury_stack_layout.h: Remove the label number from return label layouts, since the tracer isn't expecting it. runtime/mercury_stack_trace.[ch]: Add a new function that returns the label layout structure at the Nth ancestor return continuation, together with the values of sp and curfr at that point. This required changing MR_stack_walk_step to step from an entry layout only to the return label layout. runtime/mercury_stacks.h: Add macros that let us access detstackvars and framevars based on these synthesized values of sp and curfr. runtime/mercury_trace_util.[ch]: Generalize several functions to allow them to use synthesized (as opposed to saved) values of sp and curfr in looking up values. Retain functions with the original names and signatures that call the new, general versions with the necessary additional parameters. runtime/mercury_trace_internal.c: Add a new command that sets the "ancestor level". For example, "l 2" sets it to 2, which means that the command "v" and "p" will refer to the grandparent of the current call. The ancestor level persists while the debugger is at the current event; after that it is reset to 0. The implementation involves calling the new function in mercury_stack_trace.c and the generalized functions in mercury_trace_util.c. Also add a deliberately undocumented extra command, X, which prints the stack pointers. NEWS: Add a reminder about removing the X command before release. tests/debugger/* Update half the test cases (those which assume a non-debug-grade library) to conform to the changes in the debugger interface. The others will need to be updated later.	1998-06-18 06:08:12 +00:00
Zoltan Somogyi	dc2cd8d286	Separate out the part of the stack walk function that walks one step. ... Estimated hours taken: 1.5 runtime/mercury_stack_trace.c: Separate out the part of the stack walk function that walks one step. This will be needed to implement printing of variables in upper levels. Print a level number with each stack frame in the list of ancestors. Where a line in the output represents several stack frames from the same procedure, the level number printed is the level number of the top frame. Change the output format a bit to accommodate the level number and to print the mode number the same way as the debugger does it.	1998-06-11 05:22:33 +00:00
Zoltan Somogyi	09141817ba	Fergus's recent change to the handling of some builtins broke the tracing ... Estimated hours taken: 20 Fergus's recent change to the handling of some builtins broke the tracing of those builtins. The following changes are a fix for this. compiler/polymorphism.m: Export the predicate that checks whether a predicate is a builtin that lacks the usually necessary typeinfos. Comment out a misleading and in any case not very useful progress message. compiler/liveness.m: Turn off type_info liveness for builtins without typeinfos. Since these builtins establish no gc points and shouldn't be execution traced, this is OK. Make type_info liveness part of live_info, since it can now be incorrect to look up the value of the option. (This may yield a speedup.) compiler/live_vars.m: compiler/store_alloc.m: Pass the pred_id to initial_liveness to liveness.m can do the test. compiler/passes_aux.m: Add a new traversal type that passes along the pred_id. compiler/mercury_compile.m: Turn off execution tracing for the modules builtin.m and private_builtin.m. The latter contains the interface predicates for the builtins without typeinfos. Since the interface predicates also lack the typeinfos, the compiler would get an internal abort if we left execution tracing on. In any case, these two modules contain stuff that users should consider language builtins, which means they should not be execution traced (they can still be stack traced in the right grade). Use the new traversal type for the modules that now need the pred_id. compiler/globals.m: Allow the trace level to be set from outside, in this case mercury_compile.m. The next batch of changes have to do with adding a stack dump command to the debugger. Since debugging is possible even in non-debug grades, this in turn requires allowing stack tracing to work in non-debug grades, on programs in which only some modules are compiled with execution (and hence stack) tracing. compiler/llds_out.m: compiler/mercury_compile.m: runtime/mercury_conf_param.h: Llds_out used to output "#include <mercury_imp.h>" as the first substantive thing in the generated C file. The set of #define parameters in effect when mercury_imp.h is processed determines whether the macros that optionally register stack layouts for label actually do so or not. The values of these parameters are derived from the grade, which means that with this setup it is not possible for a non-debug grade program to register its stack layouts in the label table. The new version of llds_out looks up the option that says whether this module is compiled with execution tracing or not, and if it is, it generates a #define MR_STACK_TRACE_THIS_MODULE *before* the #include of mercury_imp.h. This causes mercury_conf_param.h, included from mercury_imp.h, to define the macros MR_USE_STACK_LAYOUTS and and MR_INSERT_LABELS, which in turn cause stack layouts for labels in this module to be generated and to be inserted into the label table, *without* changing the grade string (this last part is why we do not simply define MR_STACK_TRACE). Use the same mechanism to #include mercury_trace.h when doing execution tracing, since it is simpler than the mechanism we used to use (mercury_compile.m including the #include in a list of C header file fragments). compiler/mercury_compile.m: runtime/mercury_conf_param.h: Split the MR_NEED_INITIALIZATION_CODE macro into two parts. The first, MR_MAY_NEED_INITIALIZATION, now controls whether initialization code makes it into the object file of a module. The second, MR_NEED_INITIALIZATION_AT_START, determines whether the initialization code is called before main/2. When a module is compiled with execution tracing, the macro MR_INSERT_LABELS turns on MR_MAY_NEED_INITIALIZATION but not MR_NEED_INITIALIZATION_AT_START. The debugger will make sure that the initialization code has been called before it tries to do a stack dump (which needs the initialization code to have been executed, because it needs labels to have been put into the label table so that from a return address it can find the layout of the proc to which it belongs). Define MR_NEED_INITIALIZATION_AT_START if PROFILE_TIME is defined, since if PROFILE_TIME is defined mercury_wrapper.c calls init_modules. The fact that MR_NEED_INITIALIZATION_CODE didn't used to be defined when PROFILE_TIME was defined was, I believe, a bug, which was not detected because we do not turn on PROFILE_TIME without also turning on PROFILE_CALLS. runtime/mercury_stack_trace.[ch]: Change the way stack dumps are done, to make it possible to print stack dumps from the debugger and to use trivial run-length encoding on the output (so that 100 consecutive calls to p yield the line "p * 100", rather than 100 lines of "p"). The stack routine now returns an indication of whether the stack dump was fully successful, and if not, a description of the reason why not. This requires knowing when we have found the end of the stack dump, so we provide a global variable, MR_stack_trace_bottom, which mercury_wrapper.c will set to global_success, the address main/2 goes to on success. s/multidet/multi/ runtime/mercury_wrapper.c: Set MR_stack_trace_bottom to the address of globals_success. Use MR_NEED_INITIALIZATION_AT_START to decide whether to call do_init_modules. runtime/mercury_stacks.h: Provide variants of detstackvar(n) and framevar(n) that look up sp and curfr in an array of saved regs, for use by the debugger. runtime/mercury_trace_util.c: Use the new variants of detstackvar(n) and framevar(n). This fixes an old bug on SPARCs. runtime/mercury_trace_internal.c: Completely reorganize the way debugger commands are handled. Centralize reading in command lines, and the breaking up of command lines into words. The command names are the same as they were, but command syntax is now much easier to change. Add a new command "d" to dump as much of the stack as the available information will allow. runtime/mercury_goto.h: Cosmetic changes to avoid the use of two different conditional compilation layout styles. util/mkinit.c: Since we cannot know when we generate the _init.c file whether any modules will be compiled with execution tracing and will thus need stack tracing, we must now include in the generated _init.c file the code to call the initialization functions in all the modules, even if MR_NEED_INITIALIZATION_AT_START is not set, since init_modules can be called later, from the debugger. (We should be able to use the same approach with the accurate collector.)	1998-06-08 08:29:17 +00:00
Tyson Dowd	561e0d8e19	Use stack layout data structures to do stack dumps. ... Estimated hours taken: 1 runtime/mercury_stack_trace.c: Use stack layout data structures to do stack dumps. Improve the output format, output the determinism and mode number of each predicate.	1998-04-24 06:15:27 +00:00
Tyson Dowd	dd835a5cb8	Fix stack traces, which were broken with recent tracing code changes. ... Estimated hours taken: 4 Fix stack traces, which were broken with recent tracing code changes. runtime/mercury_ho_call.c: runtime/mercury_wrapper.c: Use init_label_sl, instead of init_label. runtime/mercury_stack_layout.h: Update MR_MAKE_STACK_LAYOUT_INTERNAL_* to have new fields so that stack layouts generated in this way are correct. runtime/mercury_stack_trace.c: Change algorithm to be a little more robust (doing bit operations on a possibly negative integer probably isn't a good idea, so check the value isn't -1 first).	1998-04-18 08:06:52 +00:00
Zoltan Somogyi	67d8308260	Same as previous message.	1998-04-08 11:36:13 +00:00
Tyson Dowd	951ed445bf	Implement nondet stack dumps. ... Estimated hours taken: 1 Implement nondet stack dumps. library/require.m: Call MR_dump_stack with MR_curfr. runtime/mercury_stack_trace.c: runtime/mercury_stack_trace.h: Get MR_curfr as input. If we hit a nondet stack frame, handle moving down a frame a little differently.	1998-04-07 05:23:07 +00:00
Fergus Henderson	c315607690	Clean up the handling of configuration macros in the runtime. ... Estimated hours taken: 4 Clean up the handling of configuration macros in the runtime. runtime/mercury_conf.h.in: runtime/mercury_conf_param.h: Move the code to set configuration parameters based on the values of other configuration parameters from mercury_conf.h.in to a new file mercury_conf_param.h, because otherwise autoconf munges the code in undesirable ways (it replaces all `#undef <foo>' statements with `/* #undef <foo> */'). runtime/mercury_conf.h.in: runtime/mercury_conf_param.h: runtime/*.h: runtime/*.c: Use more meaningful names, starting with the usual `MR_' prefix, for various configuration parameters: - replace the existing configuration macros SPEED with three new macros MR_CHECK_OVERFLOW, MR_LOWLEVEL_DEBUG, and MR_DEBUG_NONDET_STACK; - rename DEBUG_GOTOS as MR_DEBUG_GOTOS, and make it implied by MR_LOWLEVEL_DEBUG; - rename DEBUG_LABELS as MR_CHOOSE_ENTRY_POINT. (But there are still many configuration parameters that don't start with `MR_', I'm afraid.) runtime/CFLAGSFILE: runtime/mercury_conf_param.h: Removed CFLAGSFILE. The documentation there was had rotted badly. I moved most of it to mercury_conf_param.h where hopefully it will stand a better chance of being kept up-to-date. I added documentation for the configuration parameters added in the last year or so. The documentation here now covers every configuration parameter that we use; please keep it that way! runtime/mercury_debug.h: Fix a bug: there was a misplaced "#endif". runtime/mercury_stack_trace.c: Fix yet another misspelling of "deterministic".	1998-03-16 12:23:40 +00:00
Tyson Dowd	f58ee880df	Add support for stack dumps, do a stack dump from error/1. ... Estimated hours taken: 12 Add support for stack dumps, do a stack dump from error/1. compiler/Mmakefile: library/Mmakefile: profiler/Mmakefile: runtime/Mmakefile: Insert EXTRA_MGNUCFLAGS before CFLAGS or EXTRA_CFLAGS becasue mgnuc stops processing its options when it encounters a non-mgnuc option. library/require.m: Call MR_dump_stack if error is called. runtime/Mmakefile: runtime/mercury_imp.h: Add #includes of new files. runtime/mercury_type_info.h: Remove conditional definition of MR_STATIC_CODE_ADDRESSES (moved into mercury_conf.h.in). runtime/mercury_accurate_gc.h: Remove stack_layout stuff, leave this file for accurate GC specific definitions. runtime/mercury_conf.h.in: Add conditional definitions of MR_INSERT_LABELS, MR_USE_STACK_LAYOUTS, MR_NEED_INITIALIZATION_CODE and MR_STATIC_CODE_ADDRESSES, depending on various other options. runtime/mercury_goto.h: Insert labels into label table if MR_INSERT_LABELS is defined, rather than NATIVE_GC. util/mkinit.c: Initialize if MR_NEED_INITIALIZATION_CODE is defined, rather than NATIVE_GC. runtime/mercury_stack_layout.h: All the old stack layout definitions from mercury_accurate_gc.h. Add code for MR_DETISM_DET_CODE_MODEL. runtime/mercury_stack_trace.c: runtime/mercury_stack_trace.h: Implement MR_dump_stack which just provides a dump of the stack as far as possible. Set MR_INSERT_LABELS and MR_USE_STACK_LAYOUTS if MR_STACK_TRACE is set. runtime/mercury_grade.h: Add _strce if stack tracing is enabled in the grade. This might not be a permanent change. runtime/mercury_ho_call.c: Remove unused label declarations. scripts/mgnuc.in: Add --stack-trace and --no-stack-trace options. Consolidate some duplicate code.	1998-03-11 06:01:17 +00:00