41 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	8d57bbfb27	Fix the failure of the user event related test cases on saturn and other ... Estimated hours taken: 0.5 Branches: main Fix the failure of the user event related test cases on saturn and other 64 bit machines. The problem was that MR_LongLvals, which were 32 bits in size, were being asked store pointers to closures, which on these platforms are 64 bits. The fix is to make MR_LongLvals contain MR_Unsigneds, whose size adjusts to the platform. runtime/mercury_stack_layout.h: Make the change described above. Change the macros for looking up long and short lval descriptions to return the semantic types MR_LongLval and MR_ShortLval, not the physical types they are equivalent to. This will make similar problems easier to spot in future. runtime/mercury_layout_util.c: trace/mercury_trace.c: Conform to the change to mercury_stack_layout.h. compiler/stack_layout.m: Give the size of the rvals represent MR_LongLvals as unsigned, not as uint_least32_t.	2007-01-08 09:15:22 +00:00
Zoltan Somogyi	455e1eea75	The runtime had two different conventions for naming types. ... Estimated hours taken: 2 Branches: main The runtime had two different conventions for naming types. One convention, used mostly in the debugger-related modules, added underscores between capitalized words; example: MR_Label_Layout. The other convention, used in most modules, used capitalized words without underscores (e.g. MR_TypeInfo). This diff standardizes on the second convention. It has no algorithmic changes, only renames of types. runtime/*.[ch]: trace/*.[ch]: compiler/*.m: library/*.m: mdbcomp/*.m: Effect the change described above. The only substantive change is that runtime/mercury_stack_layout.h used to define *two* types for trace levels: MR_TraceLevel and MR_Trace_Level, and this diff standardizes on just one (they had equivalent definitions). runtime/mercury_bootstrap.h: Add a #define from the old name to the new for all the changed type names that the installed compiler can put into .c files. We can delete these #defines some time after this diff has bootstrapped. slice/.mgnuc_opts: Restore the --no-mercury-stdlib-dir option, without which the slice directory won't compile after this change (because it looks for type names in the installed runtime header files, which define the old versions of type names).	2006-11-29 05:18:42 +00:00
Zoltan Somogyi	9eed887d33	This diff is the second step in implementing trace events. ... Estimated hours taken: 24 Branches: main This diff is the second step in implementing trace events. It modifies label layouts to include room for solver-event-specific information, and modifies the compiler to generate this information. Modifications to the debugger to use this information, user-level documentation and test cases will come later. runtime/mercury_stack_layout.h: Modify label layouts to allow them to hold information about solver events. Modify the macros creating label layouts to include a null pointer as the value of the label layout's solver event field. For each such macro, add a version that puts a pointer to the label's solver event structure in that field. Modify the definition of the MR_Long_Lval type to allow the representation of constants, since without this capability solver events would often need to be preceded by code to put constant values (e.g. solver ids) into lvals. To make it easier to locate all the places where MR_Long_Lvals are used (which need to be updated), change the type MR_Long_Lval from a synonym for an int to a structure containing an int. runtime/mercury_types.h: Add the typedefs now required for mercury_stack_layout.h. runtime/mercury_goto.h: Add a macro needed by mercury_stack_layout.h. runtime/mercury_grade.h: Change the binary compatibility version number for debug grades, due to the change to label layouts. runtime/mercury_layout_util.c: Update the functions interpreting MR_Long_Lvals to conform to the change in mercury_stack_layout.h. runtime/mercury_deep_profiling_hand.h: Fix a bug, possibly the bug preventing us from bootchecking in deep profiling grades: stack slot numbers of ProcStatic structures are supposed to be plain integers, not MR_Long_Lvals. runtime/mercury_stack_trace.c: library/exception.m: trace/mercury_trace.c: Conform the change in MR_Long_Lval. runtime/mercury_trace_base.[ch]: Add a new port: the solver event port. Add a macro and a function for solver events: MR_SOLVER_EVENT and MR_solver_trace. For now, they do the same thing as MR_EVENT and MR_trace, but in future, they can do something else (e.g. generate information for a visualization tool). mdbcomp/prim_data.m: Add a new port: the solver event port. Rename all ports to eliminate clashes with language keywords such as "call". mdbcmp/trace_counts.m: browser/declarative_execution.m: slice/mcov.m: compiler/tupling.m: Conform to the change in port names, and to the addition of the new port. compiler/trace_params.m: Conform to the change in port names, and to the addition of the new port. Rename some function symbols to avoid some ambiguities. trace/mercury_trace_declarative.c: Ignore the solver port when building the annotated trace, since it doesn't fit into it. compiler/prog_event.m: Extend the representation of events to include names for the event attributes. compiler/call_gen.m: Implement event goals. The implementation consists of a call to MR_SOLVER_EVENT with a layout structure whose solver event field points to a solver event structure giving the event goal's arguments. Rename some function symbols to avoid some ambiguities. compiler/trace_gen.m: Add a predicate for generating solver events. Conform to the change in port names. Rename some function symbols to avoid some ambiguities. compiler/code_info.m: When recording trace layout information for a label, take an extra argument describing the label layout's associated solver event, if any. compiler/continuation_info.m: Extend the first representation of label layouts to include room for solver events. compiler/stack_layout.m: Convert the representation of solver events in continuation_info.m's data structure to the data structure required by layout_out.m. Conform to the changes in MR_Long_Lvals. compiler/layout.m: Extend the compiler's internal representation of the contents of label layout structures to accommodate the optional solver event field. compiler/layout_out.m: Generate the extended label layout structures, using the new macros in mercury_stack_layout.h if necessary. Conform to the change in the MR_Long_Lval type. Conform to the change in port names. Rename some function symbols to avoid some ambiguities. compiler/global_data.m: Modify rval_type_as_arg to require only the value of the relevant option, not a package of such options. This is for the new code in stack_layout.m. compiler/var_locn.m: Conform to the change in global_data.m. compiler/llds_out.m: Conform to the change in continuation_info.m. Delete this module's unused definition of rval_type_as_arg. compiler/opt_debug.m: Conform to the change in continuation_info.m.	2006-09-29 06:34:57 +00:00
Zoltan Somogyi	803b6e44f7	Minor cleanup. ... Estimated hours taken: 0.1 Branches: main runtime/mercury_layout_util.c: Minor cleanup.	2005-10-26 05:40:10 +00:00
Zoltan Somogyi	17eb414a8f	Add a new mdb command "ambiguity" that prints out ambiguous predicate, function ... Estimated hours taken: 3 Branches: main Add a new mdb command "ambiguity" that prints out ambiguous predicate, function and type names. doc/user_guide.texi: Document the new command. doc/mdb_categories: Add the new command, as well as some others that should have been added previously but weren't. trace/mercury_trace_internal.c: Add the user interface for the new command. Fix some old cut-and-paste bugs. trace/mercury_trace_tables.[ch]: Add the implementation of the new command. runtime/mercury_type_tables.[ch]: Change the signature of the function that return the list of all type_ctor_infos to also return their number, for use in the new code in mercury_trace_tables.c. Convert to four-space indentation. runtime/mercury_layout_util.c: runtime/mercury_wrapper.c: Convert to four-space indentation. tests/debugger/completion.exp: tests/debugger/mdb_command_test.inp: Expect the mdb command added by this diff, as well as the ones added by Ralph recently.	2005-10-25 04:00:56 +00:00
Zoltan Somogyi	8190c16181	Get Mercury to work with gcc 3.4. This required fixing several problems. ... Estimated hours taken: 16 Branches: main Get Mercury to work with gcc 3.4. This required fixing several problems. One problem that caused errors is that gcc 3.4 is smart enough to figure out that in LLDS grades with gcc gotos, the C functions containing our code are not referred to, and so it optimizes them away. The fix is to ensure that mercury_<module>_init is defined always to call those functions, even if the macro that usually controls this, MR_MAY_NEED_INITIALIZATION, is not defined. The mercury_<module>_init won't be called from the init_modules function in the program's _init.c file, so there is no impact on initialization time, but gcc doesn't know this when compiling a module's .c file, so it doesn't optimize away the code we need. The cost of this change is thus only a small amount of code space. It is worth paying this cost even with compilers other than gcc 3.4 for simplicity. Actually, this size increase seems to be slightly smaller than the size reduction due to the better optimization capabilities of gcc 3.4 compared to gcc 3.2.2. A second problem is that gcc 3.4 warns about casts in lvalues being a deprecated feature. This gave lots of warnings, since we used to define several Mercury abstract machine registers, including MR_succip, MR_hp, MR_sp, MR_maxfr and MR_curfr using lvalue casts. The fix is to have two macros for each of these abstract machine registers, one of type MR_Word that you can assign to (e.g. MR_sp_word), and one of the original type that is of the right type but not an lvalue (e.g. MR_sp). The lvalue itself can't be made the right type, because MR_sp isn't a variable in its own right, but possibly defined to be a machine register. The machine register could made the right type, but only at the cost of a lot of complexity. This problem doesn't apply to the special-purpose Mercury abstract machine registers that can't be allocated to machine registers. Instead of #defining these to slots in MR_fake_reg, we make them global variables of the natural type. This should also make it easier to debug code using these registers. We treat these global variables as if they were machine registers in that MR_save_registers copies values from these global variables to slots reserved for them in the MR_fake_reg array, to allow code to loop over all Mercury abstract machine registers. These saved slots must of course be of type MR_Word, so we again need two macros to refer to them, a lvalue of type MR_Word and an rvalue with the right type. A third problem is that gcc 3.4 warns about conditionals in lvalues being a deprecated feature. This gave a few warnings, since we used to define MR_virtual_reg and MR_saved_reg using lvalues using conditionals. The fix is to have one macro (MR_virtual_reg_value) for use in rvalues and a separate macro which uses an if-then-else instead of a conditional expression (MR_virtual_reg_assign), for assignments. A fourth problem is that gcc 3.4 warns about comma operators in lvalues being a deprecated feature. This gave warnings in the few places where we refer to MR_r(N) for values of N that can map to fake registers directly, since in those cases we preceded the reference to the fake_reg array with a range check of the array index. The fix to this is to move the test to compile time for compiler-generated code. Hand-written code never refers to MR_r(N) for these values, and is very unlikely to do so in the future; instead, it refers to the underlying fake_reg array directly, since that way it doesn't have to worry about which fake registers have their own MR_rN macro and which don't. Therefore no check mechanism for hand-written code is necessary. This change mean that changing the number of MR_rN registers now requires change to the compiler as well as to the runtime system. A fifth problem is that gcc 3.4 by default assumes -fstrict-aliasing at -O2. Since we cast between integers and pointers of different types all the time, and changing that is not practical, at least in the short term, we need to disable -fstrict-aliasing when we enable -O2. NEWS: Note that Mercury now works with gcc 3.4. configure.in: scripts/mgnuc.in: Detect whether the compiler supports -fstrict-aliasing, and if so, whether it assumes it by default with -O2. If the answer is yes to both, make mgnuc specify -fno-strict-aliasing when it specifies -O2. By including it in CFLAGS_FOR_OPT, which gets put into Mercury.config, we also get -f-no-strict-aliasing when mmc invokes the C compiler directly. compiler/llds_out.m: Don't generate #ifdef MR_MAY_NEED_INITIALIZATION around the definitions and calls to the bunch functions, which call the functions we don't want the C compiler to optimize away. Generate the newly required lvalues on the left sides of assignments. We still have code to generate LVALUE_CASTs in some cases, but I don't think those cases ever arise. Add a compile-time check of register numbers. Ideally, the code generator should use stack slots instead of registers beyond the max number, but I don't recall us ever bumping into this limit by accident. compiler/fact_table.m: Use the newly required lvalues on the left sides of assignments in some hand-written C code included in generated .c files. runtime/mercury_regs.h: Make the changes described above to fix the second, third and fourth problems. We still use comma operators in lvalues when counting references to registers, but it is OK to require anyone who wants to enable this feature to use a compiler version that supports comma operators in lvalues or to ignore the warnings. Use the same mapping from Mercury abstract machine registers to the register count array as to the MR_fake_reg array. Have this mapping depend as little as possible on whether we need a real machine register to store MR_engine base, even if it costs a wasted slot in MR_fake_reg. Fix an old inconsistency: treat the Mercury abstract machine registers used for trailing the same way as the other Mercury abstract machine registers, by making MR_save_registers/MR_restore_registers copy them to and from their global variable homes. Document the requirement for the match between the runtime's and the compiler's notions of the maximum MR_rN register number. This requirement makes it harder for users to increase the number of virtual registers, but as far as I know noone has wanted to do this. Change the names of some of the macros to make them clearer. Reorder some parts of this file, and add some documentation, also in the interest of clarity. runtime/mercury_regorder.h: Delete this file after moving its contents, in much modified form, to mercury_regs.h. mercury_regorder.h was always logically part of mercury_regs.h, but was separated out to make it easier to change the mapping from Mercury abstract machine registers to machine registers. However, the cost of incompatibility caused by any such changes would be much greater that any likely performance benefit. runtime/Mmakefile: Remove the reference to mercury_regorder.h. runtime/mercury_regs.[ch]: runtime/mercury_memory_zones.[ch]: Move some functionality dealing with registers from mercury_memory_zones to mercury_regs, since it belongs there. runtime/mercury_regs.[ch]: Add a function to make it easiler to debug changes to map from Mercury abstract machine to MR_fake_reg slots. runtime/mercury_regs.[ch]: runtime/mercury_wrapper.c: Move the code to print counts of register uses from mercury_wrapper.c to mercury_regs.c. Make mercury_wrapper.c call the debugging function in mercury_regs.c if -X is specified in MERCURY_OPTIONS. runtime/mercury_bootstrap.h: Move the old MR_saved_reg and MR_virtual_reg macros from mercury_regs.h to mercury_bootstrap.h to prevent their accidental use. Since they shouldn't be used by user code, move them to the section that is not enabled by default. runtime/mercury_stacks.[ch]: Add _word versions of the macros for stack slots, for the same reason why we need them for Mercury abstract machine registers, and use them. Add global variables for the Mercury abstract machine registers for the gen, cut and pneg stacks. runtime/mercury_heap.h: Change the macros for allocating memory to assign to MR_hp_word instead of MR_hp. runtime/mercury_string.h: Change the macros for allocating strings to accomodate the updates to mercury_heap.h. Also change the expected type of the target to make it MR_String instead of MR_ConstString, since the latter requires casts in the caller. runtime/mercury_trail.h: runtime/mercury_types.h: Move the definition of the type MR_TrailEntry from mercury_trail.h to mercury_types.h, since it is now used in mercury_regs.h. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_calls.h: runtime/mercury_context.[ch]: runtime/mercury_deconstruct_macros.h: runtime/mercury_deep_copy_body.h: runtime/mercury_engine.[ch]: runtime/mercury_hand_compare_body.h: runtime/mercury_hand_unify_body.h: runtime/mercury_ho_call.c: runtime/mercury_layout_util.c: runtime/mercury_make_type_info_body.h: runtime/mercury_minimal_model.c: runtime/mercury_ml_deconstruct_body.h: runtime/mercury_ml_functor_body.h: runtime/mercury_stack_layout.h: runtime/mercury_type_desc.c: runtime/mercury_type_info.c: runtime/mercury_unify_compare_body.h: runtime/mercury_wrapper.c: Conform to the changes in the rest of the runtime. In some cases, fix inconsistencies in indentation. runtime/mercury_stack_trace.c: Add some conditionally compiled debugging code controlled by the macro MR_ADDR_DEBUG, to help debug some problems with stored stack pointers. runtime/mercury_grade.h: Increment the binary compatibility version number. This is needed to avoid potential problems when a Mercury module and the debugger are compiled with different versions of the macros in mercury_regs.h. library/exception.m: Update the code that assigns to abstract machine registers. library/array.m: library/construct.m: library/dir.m: library/io.m: library/string.m: Conform to the new definitions of allocation macros. library/time.m: Delete an unnecessary #include. trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_util.c: Conform to the changes in the rest of the runtime. tests/hard_coded/qual_test_is_imported.m: tests/hard_coded/aditi_private_builtin.m: Remove an unnecessary import to avoid a warning. tools/makebatch: Add an option --save-stage2-on-error, that saves the stage2 directory if a bootcheck fails. scripts/ml.in: Make ml more robust in the face of garbage files.	2004-07-07 07:11:22 +00:00
Zoltan Somogyi	642c902c90	Reduce the sizes of .c and .o files in debug grades by 8%. ... Estimated hours taken: 4 Branches: main Reduce the sizes of .c and .o files in debug grades by 8%. Add to mdb the capability of putting breakpoints on unify, compare and index predicates. compiler/code_gen.m: Since compiler-generated unify, index and compare pred can be presumed to be correct, compile them with shallow tracing instead of deep tracing even if the user asks for deep tracing of the rest of the module. This saves disk space, compile time and run time. Move the code for setting the trace level to generate_proc_code, where it is executed whether we generate code by predicates or by phases. compiler/trace_params.m: Provide a function for use by code_gen.m. Consider unify and compare predicates to behave as if their address were taken, since they may be called from builtin.unify or builtin.compare. compiler/jumpopt.m: Do not replace jumps with the block being jumped to if the block contains an instruction that represents a call to the debugger. In such cases, the jump is a minor cost in runtime compared to the call, and the locality benefit from not increasing the code size is quite likely to exceed that cost. compiler/llds.m: Add field names to pragma_c instructions to make the change to jumpopt easier. tests/debugger/uci.{inp,exp}: Update this test case. An update is required since we now generate fewer events from unify and compare preds due to their now being shallow traced. To make this the update easier, use the new capability of putting breakpoints on unify and compare predicates. trace/mercury_trace_tables.[ch]: Expand procedure specifications to allow the specification of unify, compare and index predicates, and expand the function that checks for matches between a procedure layout and a procedure specification accordingly. Fix two instances of a bug: if a procedure specification has no name, represent it as NULL, not as a non-NULL pointer to a null character, since the match function expects only the former. doc/user_guide.texi: Document the new definition of procedure specifications. NEWS: Mention the new definition of procedure specifications, and expand on some previous additions to the debugger. runtime/mercury_stack_trace.c: Allow mdb breakpoint specifications on uci predicates to be saved. Factor out some common data structure accesses. runtime/mercury_proc_id.h: Change the name of a macro from MR_PROC_ID_COMPILER_GENERATED to MR_PROC_ID_IS_UCI, for consistency with other names dealing with unify, compare and index predicates. runtime/*.[ch]: trace/*.[ch]: Conform to the change in mercury_proc_id.h.	2004-05-23 22:16:57 +00:00
Zoltan Somogyi	c80d143cc8	The following change is only 98% complete, not 100%. ... Estimated hours taken: 120 Branches: main The following change is only 98% complete, not 100%. I am committing it in this state because (1) we pass many more test cases in deep profiling grade with it than without it, and (2) the double maintanance involved in fixing CVS conflicts is preventing me from doing the last 2%. Get the deep profiler to work for code that sets up to catch exceptions, which for the last year or more has included the compiler, and to get it almost working for code that actually catching exceptions. The basic problem is that code that throws exceptions will in general cause several calls to "return" without executing the exit or fail port codes that the deep profiling transformation inserted into their bodies, and this leaves the data structure being built by the deep profiling inconsistent. The solution uses the same approach as we have adopted for the debugger: have the code that handles the throwing of exceptions simulate a return from each call between the throw and the catch, updating the deep profiling data structures as needed. This requires us to be able to walk the stack at runtime not just in debugging grades but also in deep profiling grades. Since the debugger already has the mechanisms required for this, we reuse them. The procedure layouts used by the debugger were designed to have three segments: the procedure stack walk information, the procedure id, and the execution tracing information. We now modify this design to make the third segment contain two pointers: to the execution tracing information (for use by the debugger), and to the procedure's proc_static structure (for use by deep profiling). Each pointer will be null unless the pointed-to structure is required by compile-time options. This common use by the debugger and by deep profiling of the stack-walk structure and the procedure id structure (which deep profiling used to generate independently and possibly redundantly) required some rearrangement of the compiler's version of these data structures. To make this rearrangement simpler, this diff removes a capability that we theoretically supported but never used: turning on stack traces without turning on execution tracing and vice versa. After this diff, stack tracing is enabled if and only if either execution tracing or deep profiling is enabled. The diff also includes improvements in the debugging infrastructure for debugging deep profiling, which were necessary for the implementation of the rest of the changes. compiler/deep_profiling.m: The code in exception.m needs to know the locations of the variables that we would pass to the exit or fail port code, so it can simulate leaving the procedure invocation through the exception port. Without this information, throwing an exception leaves the deep profiling data structures of the procedure invocations between throw and catch in an inconsistent state. Deep_profiling.m creates these variables, but it doesn't know where they will be at runtime, so it records their identities; the code generator will allocate them stack slots and record the numbers of these stack slots for placement in the now expanded proc layout structures. Deep profiling used to generate static data structures separately from the HLDS, but since the code generator now needs access to them, we store their information in proc_infos in the HLDS. Instead of passing the addresses of proc_static structures to the deep profiling port procedures, pass the address of proc_layout structures, since the information about the identities of procedures are now stored not in the proc_static structure, but in the proc_layout structure that points to the proc_static structure. compiler/hlds_pred.m: compiler/layout.m: Move the definitions of the static data structures generated by deep profiling from layout.m to hlds_pred.m, to allow deep_profiling.m to store them in proc_infos. compiler/hlds_pred.m: compiler/rtti.m: Move the definition of rtti_proc_label from rtti.m to hlds_pred.m, since some of the new data structures in hlds_pred.m need it. Despite its name, the rtti_proc_label type doesn't contain any info that doesn't belong in the HLDS. Add some information to the rtti_proc_label type that is now needed by deep profiling, e.g. record determinisms instead of just code models. Record explicitly the outcome of some tests that used to be duplicated in more than one place in the compiler, e.g. for whether the procedure (as opposed to the predicate) is imported. Change some of the field names to be more precise about the field's meaning. compiler/code_gen.m: Transmit the contents of the deep profiling data structures stored in the proc_info by deep_profiling.m to continuation_info.m, together with the layout structures created for execution tracing and the identities of the variables needed for handling exceptions, when code generation for a procedure is complete. After the goal that generates these variables, save them to stack for use by the exception handler. compiler/hlds_goal.m: Add a feature to mark the goal that generates the deep profiling variables needed by the exception handler. compiler/hlds_llds.m: Add a utility predicate for new code in code_gen.m compiler/continuation_info.m: Hold the deep profiling information computed by code_gen.m for use by stack_layout.m. compiler/layout.m: compiler/layout_out.m: Update the definitions of the data structures describing procedure layouts, and the code writing them out, to reflect the use of some parts of procedure layouts by deep profiling as well as debugging. Change the layout structures generated by deep profiling to use rtti_proc_labels, which are backend independent, instead of proc_labels, which are specific to the LLDS backend. Conform to the changes in runtime/mercury_stack_layout.h. compiler/stack_layout.m: Generate the updated version of proc_layout structures. compiler/mercury_compile.m: compiler/global_data.m: Conform to the fact that deep profiling no longer generates layout structures separate from proc_infos. compiler/llds_out.m: Register proc_layout structures instead of proc_static structures for use by runtime/mercury_deep_profiling.c. compiler/options.m: compiler/handle_options.m: Rename the require_tracing option as exec_trace, since this more directly reflects its meaning. Instead of having --debug set both require_tracing and stack_trace, make it set (be the user-visible name of) just exec_trace; the value of stack_trace is implied. Turn off the specialization of deep profiling for self-tail-recursive procedures for now. Due to the changes made by this diff in the data structures involved in debugging, it cannot be debugged until this change has been installed. Handling the full language is more important than a specialization that reduces only stack space overheads, not runtime overheads. compiler/compile_target_code.m: Conform to the changes in options.m and runtime/mercury_grade.h. compiler/hlds_data.m: Replace the deep_profiling_proc_static cons_id, and its associated tag, to deep_profiling_proc_layout, since we now generate addresses of proc layout structures, not of proc_static structures. compiler/code_util.m: Simplify some code based on the new info in rtti_proc_labels. compiler/bytecode_gen.m: compiler/dependency_graph.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_code_util.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/proc_label.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/saved_vars.m: compiler/switch_util.m: compiler/unify_gen.m: Minor changes to conform to the change from deep_profiling_proc_static to deep_profiling_proc_layout, to the change in the structure of rtti_proc_labels, to the changes in types of layout.m, and/or to the new goal feature. deep_profiler/measurements.m: Reserve space for exception counts. deep_profiler/html_format.m: Add a column for exception counts. deep_profiler/profile.m: deep_profiler/read_profile.m: Rename the data structures referring to compiler generated unify, compare and index predicates to avoid misleading names: they are not the only compiler generated predicates. deep_profiler/read_profile.m: runtime/mercury_deep_profiling.c: Update the string that identifies deep profiling data files. This is necessary because the format has changed: it now includes information about exception port counts. library/exception.m: In deep profiling grades, execute the exception port code for every procedure invocation between a throw and a catch, using the procedure layout structures now generated by the compiler for every procedure. Rename the function involved to reflect its new, more general purpose. Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code. Indent C preprocessor directives and foreign_procs according to our coding standards. library/profiling_builtin.m: Change the parameters of the call port code procedures from proc_static to proc_layout. Reach the proc_static structure from the proc_layout structure when needed. Include the proc_layout structure in any messages from assertion failures. Add some conditionally compiled debugging code. Give some variables better names. runtime/mercury_type_info.h: runtime/mercury_builtin_types.c: Move the macros required to create the proc_static structures of unify and compare predicates from mercury_type_info.h to mercury_builtin_types.c, since the latter is the only file that needs them. Use the same macros for creating the proc_static structures of hand-written unify, compare and compare_reprentation predicates as for user defined predicates. This required changing their naming scheme. runtime/mercury_unify_compare_body.h: Conform to the new naming scheme. runtime/mercury_ho_call.c: Provide the mechanism for mercury_unify_compare_body.h to conform to the new naming scheme. Remove the definitions of the proc_static structures for hand-written unify, compare and compare_reprentation predicates, since these now have to be defined together with the corresponding proc_layout structures in mercury_builtin_types.c. runtime/mercury_builtin_types.[ch]: Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code, and add the required declarations first. Handle deep profiling of compare_representation as well as unify and compare predicates on builtin types. Handle deep profiling of compare_representation on user-defined types, since this is done entirely in the runtime, not by compiler generated predicates. runtime/mercury_builtin_types_proc_layouts.h: New header file containing the declarations of the proc layout structures of the unify, compare and index predicates of builtin types. Logically, these declarations belong in mercury_builtin_types.h, but putting them there causes problems for the linker; the details are explained in the file itself. runtime/Mmakefile: Add the new header file. runtime/mercury_minimal_model.[ch]: Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code, and add the required declarations first. runtime/mercury_grade.h: Replace the MR_REQUIRE_TRACING grade option with MR_EXEC_TRACING. Besides being better named, the MR_EXEC_TRACING option implies MR_STACK_TRACE. Besides the overall binary compatibility version number, add subsidiary version numbers for binary compatibility in deep profiling and debugging grades. These will make it easier to bootstrap changes (such as this) that affect binary compatibility only in such grades. runtime/mercury_trace_base.c: trace/mercury_trace.c: Conform to the new names of the configuration parameters. runtime/mercury_hand_compare_body.h: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_unify_compare_body.h: runtime/mercury_ho_call.c: tools/make_port_code: Pass proc_layout structures instead of proc_static structures to deep profiling port routines. runtime/mercury_conf_param.h: Make MR_DEEP_PROFILING as well as MR_EXEC_TRACING imply MR_STACK_TRACE, since deep profiling now needs stack tracing. (MR_STACK_TRACE needs to be set in this file, because tests in this file depend on knowing its value, and this file is among the first files included (in this case indirectly) in mercury_imp.h.) Document the macros controlling the debugging of deep profiling. Enable printing of label names when the relevant deep profiling debugging macro is set. runtime/mercury_debug.c: runtime/mercury_deep_rec_depth_actions.h: runtime/mercury_deep_rec_depth_body.h: runtime/mercury_exception_catch_body.h: Get to proc_statics via proc_layouts. runtime/mercury_deep_call_port_body.c: runtime/mercury_deep_leave_port_body.c: Get to proc_statics via proc_layouts. Allow the debugger to disable deep profiling in Mercury code that is part of the debugger, not of the user program being executed. Add some more assertions. runtime/mercury_engine.[ch]: Add a new debugging flag that controls at runtime whether we generate a human readable Deep.debug equivalent to the binary Deep.data files. (We already had a mechanism for controlling this at compile time, but this isn't flexible enough.) runtime/mercury_wrapper.c: Allow this new debugging flag to be set from MERCURY_OPTIONS. runtime/mercury_deep_profiling.[ch]: Respect this new debugging flag. Update the hand-written proc_static structures representing the runtime system. Print out addresses of proc_layout as well as proc_static structures when assertions fail. Add a field to the measurement structure for exception port counts, and write out this field with the other port counts. Remove procedure id information from proc_static structures, deep profiling now uses the procedure id in the proc_layout structure. Add to proc_static structures fields that specify where, if anywhere, the variables needed by exception.m to executed the exception port code are in the procedure's stack frame. Define a global flag that allows the debugger to disable deep profiling in Mercury code that is part of the debugger, not of the user program being executed. Increase type safety by providing two versions of the function for registering proc_layouts, one for the proc_layout structures of user-defined predicates and one for unify, compare and index predicates. Fix a bug that occurs only if MR_DEEP_PROFILING_EXPLICIT_CALL_COUNTS is defined (which it usually isn't): the initial call count was wrong. runtime/mercury_deep_profiling_hand.h: Fix a bug: the handwritten code saving deep profiling variables was saving them in slots that didn't belong to the relevant stack frame. Update to conform to the modified definitions of proc_static structures and the fact that we now reach them via proc_layout structures. runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: Fix the other side of the bug in mercury_deep_profiling_hand.h by reserving the right number of stack slots in the stack frames of the various modes of exception__catch. Make it harder to make the same bug in the future by getting the needed info from the place in mercury_stacks.h that defines the structure of the relevant stack frame. runtime/mercury_proc_id.h: Rename the procedure id structure fields referring to compiler generated unify, compare and index predicates: they are not the only compiler-generated predicates. runtime/mercury_stack_layout.h: Change procedure layout structures to allow them to be used for deep profiling as well as for debugging, as described in the prologue above. We don't need the capability to support label layout structures with links to misnamed proc layout structures, and supporting it is inconvenient, so delete the capability. runtime/mercury_debug.c: runtime/mercury_deep_profiling_hand.h: runtime/mercury_layout_util.c: runtime/mercury_ml_expand_body.h: runtime/mercury_stack_trace.c: runtime/mercury_types.h: trace/mercury_trace_external.c: Conform to the new names of the procedure id structure fields. runtime/mercury_std.h: Add some more arities for MR_PASTE for use in some of the modified modules in the runtime. trace/mercury_trace_internal.c: Disable deep profiling actions in Mercury code that is part of the debugger, not of the program being debugged. scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make changes parallel to the ones in runtime/mercury_grade.h: delete --stack-trace as an independent option, and make --debug set its own option, not --require-tracing. scripts/canonical_grade.sh-subr: scripts/final_grade_options.sh-subr: scripts/c2init.in: scripts/mgnuc.in: scripts/ml.in: Conform to the changes in grade options for debugging and for deep profiling. tools/bootcheck: If Mmake.stage.{browser,deep,library,runtime,trace}.params exist, copy them to become the file Mmake.$dir.params in stage2/$dir (where dir is derived from the name of the original file in the obvious way). This allows more flexibility in the creation of the stage2; for example, it allows some directories (e.g. runtime or library) to be compiled with more debugging than other directories (e.g. compiler). This may be required because compiling all directories with lots of debugging may cause the linker to thrash. Add an option, --disable-debug-libs, that clobbers the libraries that should be linked in only in debugging grades. To conserve disk space, remove Deep.data files created by the bootcheck by default. Add an option, --keep-deep-data, to preserve these files. Use a consistent mechanism (test -f) for testing the existence of all files whose existence is tested. When recording modification times, record the modification times of some more files. tests/hard_coded/Mmakefile: In deep profiling grades, disable the test cases that we don't now pass in such grades, and document the reasons for their failure. Fix the misclassification of the write_binary test case.	2004-05-19 04:00:01 +00:00
Zoltan Somogyi	5ba9584a9b	Make it easier to debug code that handles typeclass_infos, by ... Estimated hours taken: 1 Branches: main Make it easier to debug code that handles typeclass_infos, by - renaming the macros that access the fields of typeclass_infos and base_typeclass_infos to better reflect their purpose, - adding a new macro when one macro was being used for two different purposes, and - providing versions of those macros that perform sanity checks on each access. runtime/mercury_type_info.h: Make the changes described above. runtime/mercury_conf_param.h: Document the macros, MR_CHECK_TYPECLASS_REFS, whose definition enables the runtime checks. library/private_builtin.m: Use the updated names of the macros, and standardize indentation. runtime/mercury_deep_copy_body.h: runtime/mercury_ho_call.c: runtime/mercury_layout_util.c: runtime/mercury_tabling.c: runtime/mercury_type_info.c: runtime/mercury_unify_compare_body.h: Use the updated names of the macros. runtime/mercury_type_info.c: Add a function for reporting violations of the sanity checks.	2004-01-21 02:52:38 +00:00
Fergus Henderson	9656086353	Implement accurate GC for type class methods. ... Estimated hours taken: 24 Branches: main Implement accurate GC for type class methods. Accurate GC now supports the whole Mercury language. compiler/ml_closure_gen.m: Generate GC tracing code for the type class method instance wrapper functions whose addresses get stored in typeclass_infos. This code generates a closure layout for the method instance procedure, and then calls MR_materialize_closure_params(), passing it the typeclass_info and the closure layout. runtime/mercury_layout_util.h: runtime/mercury_layout_util.c: Add new routine MR_materialize_typeclass_info_params(), for use by the code generated by ml_closure_gen.m. This is similar to MR_materialize_closure_params() except that it works on a typeclass_info rather than an MR_Closure. compiler/ml_code_util.m: Change ml_bump_function_labels so that it also bumps the constant sequence number, and rename it as ml_bump_counters. This is needed to avoid clashes between different local closure_layout constants after they get hoisted to the top level by ml_elim_nested.m. compiler/rtti_to_mlds.m: Update to reflect the changed interface to ml_gen_closure_wrapper and ml_code_util.m. compiler/ml_elim_nested.m: Update the accurate GC TODO list. compiler/options.m: doc/user_guide.texi: Document that accurate GC is now supported. NEWS: Mention that we now support accurate GC.	2003-09-25 07:56:47 +00:00
Zoltan Somogyi	3e766fcd11	Print streams sensibly in the debugger. ... Estimated hours taken: 6 Branches: main Print streams sensibly in the debugger. runtime/mercury_library_types.h: Define MercuryFilePtr as a shorthand for MercuryFile *. library/io.m: Define a user-friendly representation for streams that includes not just the stream's name but all the info about the stream that user using mdb may wish to know about the stream, as well as a unique stream id. Make the changes required to maintain this improved stream database. If the program is being executed under mdb, then do not ever delete items from the stream database, since e.g. the declarative debugger may need to print the stream's representation even after the stream is closed. (If executing outside mdb, then we delete a stream's entry from the stream database when the stream is closed, as before.) To allow the debugger to detect which variables are I/O streams, change the stream types from being equivalent to c_pointer (and thus indistinguishable from other c_pointers) to their own type. Implement this type as MercuryFilePtr in the C backend. In the IL backend, we represent it as Object[], the minimum representation change possible. Use the C type definition to get rid of many casts. When writing streams, write the user-friendly representation, not a meaningless <<c_pointer>>. runtime/mercury_init.h: runtime/mercury_wrapper.[ch]: runtime/mercury_layout_util.c: The change in stream's representation changes the types of some of the arguments of functions exported to C from io.m; conform to those changes. browser/browse.m: browser/sized_pretty.m: In each of the mechanisms that the debugger can use to display terms, pass along the stream name database. browser/browser_info.m: When deconstructing terms that are streams, return the stream's user-friendly id, not a c_pointer. browser/browse_test.m: Update this test program to test the new way of printing streams. runtime/mercury_trace_base.[ch]: Define the MR_trace_ever_enabled variable to let io.m know whether it is allowed to ever discard stream info. runtime/mercury_init.h: runtime/mercury_wrapper.[ch]: Update the types of the functions dealing with streams to use MercuryFilePtr to refer to streams instead of MR_Word. These functions are implemented by Mercury predicates exported to C. runtime/mercury_wrapper.c: Set MR_trace_ever_enabled to true when execution tracing is enabled. This is the only assigment to MR_trace_ever_enabled after initialization to the default (false). tests/debugger/declarative/io_stream_test.{m,inp,exp,exp}: A new test case to test the debugger's printing of I/O streams. tests/debugger/declarative/Mmakefile: Enable the new test case.	2003-09-14 22:24:41 +00:00
Zoltan Somogyi	ab5a7c7acf	Fix two bugs in the printing of goals where the predicate concerned is an ... Estimated hours taken: 6 Branches: main Fix two bugs in the printing of goals where the predicate concerned is an compiler-generated unify, compare or index predicate. Improve the mechanisms for debugging bugs like this. runtime/mercury_layout_util.[ch]: Fix bug one: do not return the arity of a type constructor as the arity of the unify, compare or index predicate of that type constructor; return the actual arity. When the falsely returned arity was greater than the actual arity, we could get core dumps; when it was smaller, the mdb command "print goal" printed wrong output. Provide a mechanism for fixing bug two: add a utility function for computing *correctly* a procedure's original arity and the number of type_info and/or typeclass_info arguments added by the compiler. (For convenience, it also returns a predicate/function indication.) runtime/mercury_stack_layout.h: Rename the MR_comp_arity field of MR_Compiler_Proc_Id to MR_comp_type_arity, to make clear that it gives the arity of the type constructor, not the arity of the predicate, and thus avoid bugs such as those above. runtime/mercury_stack_trace.c: Use the new name of the MR_comp_type_arity field. trace/mercury_trace_declarative.c: trace/mercury_trace_vars.c: Call the new, correct utility function in runtime/mercury_layout_util to compute how many typeinfo and/or typeclassinfo arguments are added by the compiler to a unify, compare, or index procedure's arguments, instead of the different, but logically equivalent and equally wrong pieces of code here. trace/mercury_trace_external.c: Use the new name of the MR_comp_type_arity field. Leave an XXX, since I am not sure whether Morphine interprets the arity as the arity of the type constructor or as the arity of the predicate. runtime/mercury_engine.[ch]: runtime/mercury_layout_util.c: Make the printing of locations obtained from RTTI data structures switchable from mdb, to make problems like this easier to debug. tests/debugger/uci.{m,inp,exp}: A new test case to test the proper handling of unify, compare and index predicates. tests/debugger/Mercury.options: tests/debugger/Mmakefile: Enable the new test case.	2003-04-02 23:01:45 +00:00
Zoltan Somogyi	985b13ed3f	Make I/O actions known to the declarative debugger. ... Estimated hours taken: 48 Branches: main Make I/O actions known to the declarative debugger. The debugger doesn't do anything with them yet beyond asking about their correctness. browser/io_action.m: New module for representing I/O actions, and for constructing the map from I/O action numbers to the actions themselves. browser/mdb.m: Include the new module. browser/declarative_analysis.m: Make the map from I/O action numbers to the actions themselves part of the analyzer state, since conversions from annotated trace nodes to EDT nodes may now require this information. This information is stored in the analyzer state because only the analyser needs this information (when converting annotated trace nodes to EDT tree nodes). It is not stored in the trace node store because its lifetime is different: its contents does not change during a tree deepening operation. browser/declarative_execution.m: Store the current value of the I/O action counter with each call and exit node. The list of I/O actions associated with the atom of the exit node is given by the I/O actions whose counters lie between these two values (initial inclusive, final exclusive). browser/declarative_debugger.m: browser/declarative_oracle.m: Distinguish atoms associated with exit nodes from atoms associated with call nodes, since the former, but not the latter, now have a list of I/O actions associated with them. browser/declarative_user.m: Add mechanisms for printing and browsing the I/O actions associated with EDT nodes and bugs. runtime/mercury_trace_base.[ch]: Move the code for finding an I/O action here from the file mercury_trace_declarative.c, for use by browser/io_action.m. runtime/mercury_layout_util.[ch]: Move a utility function here from mercury_trace_declarative.c, for use by the code moved to mercury_trace_base.c. trace/mercury_trace_declarative.c: When invoking the front end, pass to it the boundaries of the required I/O action map. Cache these boundaries, so we can tell the front end when reinvocation of the back end by the front end (to materialize previously virtual parts of the annotated trace) does not require the reconstruction of the I/O action map. trace/mercury_trace_vars.[ch]: Separate out the code for finding an I/O action from the code for browsing it, for use in mercury_trace_declarative.c. Note places where the implementation does not live up to the documentation. trace/mercury_trace.[ch]: Add a parameter to MR_trace_retry that allows retries to cross I/O actions without asking the user if this is OK. trace/mercury_trace_internal.c: trace/mercury_trace_external.c: Pass MR_FALSE as this new parameter to MR_trace_retry. tests/debugger/declarative/tabled_read_decl.{m,inp,exp}: A slightly modified copy of the tests/debugger/tabled_read_decl test case, to check the declarative debugger's handling of goals with I/O actions. tests/debugger/declarative/Mmakefile: Enable the new test case.	2002-05-15 11:24:21 +00:00
Fergus Henderson	e8d8b655ff	Fix some misleading documentation and a misleading name for ... Estimated hours taken: 1 Branches: main runtime/mercury_layout_util.h: runtime/mercury_layout_util.c: Fix some misleading documentation and a misleading name for MR_materialize_typeinfos() and friends: s/typeinfos/type_params/g. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_deep_copy_body.h: runtime/mercury_ml_expand_body.h: trace/mercury_trace_vars.c: Use the new names.	2002-03-27 07:35:38 +00:00
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
Zoltan Somogyi	13f0e7610a	A large step towards declarative debugging of goals that do I/O. ... Estimated hours taken: 40 Branches: main A large step towards declarative debugging of goals that do I/O. This step does everything needed for that except modify the declarative debugger itself; that is for Mark to do. If you give the new option --trace-table-io-decl, the transformation performed by the compiler on I/O primitives will preserve not just the output arguments of the primitive, so that the primitive can be "reexecuted" without performing any side-effects, but also the input arguments and the identity of the I/O primitive itself. The I/O table therefore will contain a list of the I/O primitives executed by the program after I/O tabling is started. You can test this via the new debugger commands "print action <action-number>" and "browse action <action-number>". The new option is currently not documented, because the declarative debugger does not yet use the information it provides. The new debugger commands are not documented because they are meant only for implementors, at least for now. Since this change adds a field to proc_layout structures, any workspaces compiled with debugging enabled will need to do a cvs update when this change is installed. compiler/options.m: Add the option --trace-table-io-decl. When set, this causes the compiler to transform I/O action primitives to allow declarative debugging of I/O actions. compiler/handle_options.m: Make --trace-table-io-decl imply --trace-table-io. compiler/table_gen.m: Perform the transformation, which is similar to the existing --trace-table-io transformation, but preserves the identity of all non-io-state arguments (not just the outputs) and the identity of the I/O primitive itself. Provide better names for variables generated by tabling transformations. compiler/hlds_goal.m: Add extra parameters to procedures whose job it is to create new goals to name the variables in those goals. compiler/layout.m: Add a new layout structure to contain the information the runtime system needs to interpret the information saved by the new transformation. compiler/layout_out.m: Output the new layout structure. compiler/continuation_info.m: Add a field to proc_layouts to point to the declarative I/O tabling structure, and another to identify the proc_layout without using LLDS types. compiler/code_gen.m: Provide the definition of this field when appropriate. compiler/hlds_pred.m: Add a field to proc_infos to store the information from the tabling transformation until code generation. compiler/stack_layout.m: Add a mechanism for transforming the high level description of I/O action tabling data in proc_infos to the low level description we need to generate C data structures. compiler/hlds_data.m: Add a new cons_id and a new cons_tag; they are used to refer to I/O tabling structures in code generated by the new transformation. compiler/*.m: Handle the updates to global data types above. library/table_builtin.m: Modernize some old code. Fix an old off-by-one error: make I/O tabling use the first slot in the I/O action table. library/varset.m: Add a mechanism for creating a variable that is named iff the caller has a name for it. runtime/mercury_layout_util.[ch]: Add a function for materializing type parameters from an answer block, not from registers or a closure. runtime/mercury_stack_layout.h: Declare a C type for the data structure holding information about I/O primitives transformed by --trace-table-io-decl, and add a field to proc_layout structures to point to these new structures. Add a new evaluation method for --trace-table-io-decl. runtime/mercury_tabling_macros.h: Add some conditionally-compiled debugging code to the primitive for saving answers. trace/mercury_trace_vars.[ch]: Add functions for printing I/O action goals. trace/mercury_trace_internal.c: Add code for recognizing and implementing commands to print I/O action goals. trace/mercury_trace.c: Add code for handling the new eval method. tests/debugger/tabled_read.{m,inp,exp*}: Add a polymorphic I/O action primitive, add calls to it, and test the printing of both monomorphic and polymorphic action goals. tests/debugger/tabled_read_decl.{m,inp,exp*,data}: A new test case. It does the same things as the new version of tabled_read, but it is compiled with --trace-table-io-decl, not just --trace-table-io. It therefore can (and does) test the printing of tabled I/O actions. tests/debugger/Mmakefile: Add the new test case.	2002-02-20 03:14:51 +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
Zoltan Somogyi	74645f2293	Fix a bug that caused a core dump if the debugger attempted to look at stack ... Estimated hours taken: 6 Branches: main Fix a bug that caused a core dump if the debugger attempted to look at stack frames with more than 64 live variables on the stack. runtime/mercury_stack_layout.h: Fix a bug. The array of lval descriptors in a label layout structures has two components: the long descriptors and the short descriptors. The bug was that we were using an index with respect to the start of the first subarray to index into the second subarray. The fix is to subtract the length of the first subarray from the index first. (This problem rarely bit before because the first subarray's length is almost always zero.) runtime/mercury_layout_util.c: Improve existing debugging code, but make its compilation conditional. The difference this makes in runtime is not significant for the debugger, but would be significant for native gc. runtime/mercury_conf_param.h: Document the macro the debugging code is conditional on. trace/mercury_trace_vars.c: Set unused fields of Var_Spec structures to explicitly invalid values, to avoid possible misinterpretation when using gdb. tests/debugger/lval_desc_array.{m,inp,exp,exp2}: A regression test to check for the presence of the bug. tests/debugger/Mmakefile: Enable the new test case.	2001-12-10 06:50:15 +00:00
Fergus Henderson	5e0cfaf6bd	Fix a bug where MR_deep_copy() was crashing when copying closures ... Estimated hours taken: 3 Branches: main, release Fix a bug where MR_deep_copy() was crashing when copying closures for polymorphic predicates. runtime/mercury_layout_util.h: runtime/mercury_layout_util.c: Add MR_materialize_closure_typeinfos(), for use by mercury_deep_copy_body.h. runtime/mercury_deep_copy.c: #include mercury_layout_util.h, for MR_materialize_closure_typeinfos(). runtime/mercury_deep_copy_body.h: Fix a bug: when copying closures, use MR_materialize_closure_typeinfos() to get the type_infos for the already-applied closure arguments from the closure itself, rather than trying to get them from the arguments of the typeinfo for the closure (the latter holds the type-infos for the yet-to-be-applied arguments, not the already-applied arguments). tests/hard_coded/Mmakefile: tests/hard_coded/copy_pred_2.m: tests/hard_coded/copy_pred_2.exp: Add a test case.	2001-08-07 23:12:32 +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	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
Tyson Dowd	5384f88ac2	Updates to the accurage garbage collector (including fixes to get it to ... Estimated hours taken: 8 Updates to the accurage garbage collector (including fixes to get it to compile and also to use the MR_Long_Lval and MR_Short_Lval code). A prototype of non-det stack tracing. runtime/mercury_accurate_gc.c: runtime/mercury_accurate_gc.h: runtime/mercury_agc_debug.c: runtime/mercury_agc_debug.h: Updates to the GC necessary to get it to compile. runtime/mercury_conf_param.h: runtime/mercury_wrapper.c: Add an option to set the heap very small (useful for debugging). runtime/mercury_deep_copy.c: runtime/mercury_deep_copy_body.h: Start adding checks for traversal range (things that aren't on the heap, but might contain pointers into the heap). Not all of the checks have been done yet. runtime/mercury_layout_util.c: runtime/mercury_layout_util.h: Fix a type -- MR_TypeInfo instead of MR_Word. runtime/mercury_memory_handlers.c: Add get_curfr_from_context runtime/mercury_stack_layout.h: Fix a comment. Define MR_SHORT_LVAL_NUMBER to find the number (e.g. register number or stack from) from a short lval.	2000-11-07 08:58:35 +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
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
Zoltan Somogyi	c2a696d8b6	Clean up the runtime system's handling of type_infos and pseudo_type_infos. ... Estimated hours taken: 40 Clean up the runtime system's handling of type_infos and pseudo_type_infos. This cleanup has two major aspects. First, it represents type_infos and pseudo_type_infos with distinct C types, and reducing the use of casts to the minimum. These casts are in two kinds of places: in a few macros defined in runtime/mercury_type_info.h, and at the interfaces between C code and Mercury code (since Mercury code represents (pseudo-)type_infos, like everything else, as Words). Part of this aspect is the separation of the type "MR_TypeInfo" from the type "MR_TypeInfoParams"; a MR_TypeInfo can be used as a source of type parameters directly only when it is first order. Second, it removes the confusion between the types named "type_info" and "type_ctor_info" defined by the modules private_builtin.m and std_util.m, by renaming the types defined in std_util.m to "type_desc" and "type_ctor_desc". To avoid doing this cleanup twice, this diff also removes support for the old type_ctor_info representation. This in turn makes it feasible to provide conditionally enabled code to support unification and comparison by RTTI. runtime/mercury_grade.h: Increment the binary compatibility version number. This is required by the dropping of support for old type_ctor_info representations. runtime/mercury_type_info.h: Define the types MR_TypeInfo, MR_PseudoTypeInfo and MR_TypeInfoParams, and macros that operate on them. Remove the types and macros that were useful only with the old RTTI representation. Move the section that deals with initializing code addresses in type_ctor_info structure for grades without static code addresses to the logical place. Add a const qualifier to the MR_sectag_alternatives field in MR_DuPtagLayout, since this simplifies code manipulating du types. Convert the whole file to 4 space indentation, since it is a nuisance if only part of it is so indented. runtime/mercury_deep_copy.h: runtime/mercury_deep_copy_body.h: runtime/mercury_tabling.h: runtime/mercury_tabling.c: Clean up the implementation as described above. runtime/mercury_type_info.c: runtime/mercury_make_type_info_body.h: Clean up the implementation as described above. Eliminate the code duplication between the function MR_make_type_info and MR_create_type_info, and their helpers, which do the same thing except for how they allocate memory, by putting the common code into the new file mercury_make_type_info_body.h, and including it twice in two different #define contexts. Move the (updated) documentation of those functions to mercury_type_info.h, where it belongs. runtime/mercury_ho_call.c: runtime/mercury_unify_compare_body.h: Clean up the implementation as described above. Eliminate the code duplication between the implementation of unify and compare, which do very similar jobs, by putting the common code into the new file mercury_unify_compare_body.h, and including it three times in two different #define contexts. The third time is for defining the body of a C function which does the same thing as compare. This is necessary for unification and comparison by RTTI, since the unification or comparison of two structured terms requires comparing their subterms. (There is no need for a separate C function for unification; the C comparison function is sufficient.) mercury_unify_compare_body.h has conditional support for unification and comparison by RTTI. Although this has been tested and is known to work, it is turned off for the moment. This may change after benchmarking. runtime/Mmakefile: Add the new include files to the list. library/std_util.m: Rename type_info to type_desc and type_ctor_info to type_info_desc. Keep the old names as equivalence types, for the time being. Document the representations. Move the macros that refer to type_descs and type_ctor_descs here from runtime/mercury_type_info.h, since this is the only place where they are used. Rename them to conform to the new names of the types. Clean up the implementation of the RTTI predicates and functions as described above. In the process, fix some bugs where type variables were expanded twice, with the second expansion's code being incorrect. Also factor out some common code, and unfactor some uncommon code (where a function had two uses, but its implementation was inefficient overkill for one of them). library/builtin.m: library/private_builtin.m: library/io.m: library/store.m: runtime/mercury_layout_util.[ch]: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.[ch]: When calling C functions involving type_infos, cast them to the new types. runtime/mercury_stack_layout.h: Fix a bug that was masked by casts in its client code. compiler/rtti_out.m: Delete from the output a cast made unnecessary by the new const qualifier on MR_sectag_alternatives. browser/browse.m: browser/help.m: library/io.m: library/term.m: tests/hard_coded/construct.m; tests/hard_coded/existential_types_test.m: tests/hard_coded/higher_order_type_manip.{m,exp}: Refer to the types defined in std_util.m by their new names. tests/hard_coded/existential_rtti.{m,exp}: Make the test tougher by printing out not just one deconstructed term, but deconstructed versions of all the terms created by this test.	2000-03-24 10:28:07 +00:00
David Jeffery	a4fe888da0	Change the encoding of existentially quantified type variables in ... Estimated hours taken: 2 Change the encoding of existentially quantified type variables in the RTTI; rather than representing the nth existentially quantified variable by the number (n + number of universally quantified tvars), represent it as (n + 512). This really just simplifies things, since we no longer need to look inside the type-constructor-info to find the number of universally quantified variables when instantiating a tvar at runtime. compiler/base_type_layout.m: Use the new encoding. runtime/mercury_type_info.c: Detect existentially quantified type variables using the new method. runtime/mercury_type_info.h: Add some macros. runtime/mercury_layout_util.c: Delete the code that fjh recently added which constructed a fake type constructor info.	2000-01-13 03:57:19 +00:00
Fergus Henderson	dda9788014	Fix a problem with my recent attempted bug fix for ... Estimated hours taken: 2 Fix a problem with my recent attempted bug fix for the bug that zs reported in dgj's recent change, where MR_get_arg_type_info() was crashing on the fake type_infos created by MR_materialize_typeinfos_base(). runtime/mercury_type_info.c: Delete the code in MR_get_arg_type_info() for handling the case where the type_ctor_info field is NULL. runtime/mercury_layout_util.c: Change MR_materialize_typeinfos_base() to set the type_ctor_info field to a dummy type_ctor_info, not to NULL. Using a null pointer didn't work because the code for MR_TYPEINFO_GET_TYPE_CTOR_INFO() relies on the type_ctor_info never being null.	1999-12-12 14:29:07 +00:00
Fergus Henderson	54be7a5e5c	Fix a bug that zs reported in dgj's recent change: ... Estimated hours taken: 1.5 Fix a bug that zs reported in dgj's recent change: MR_get_arg_type_info() was crashing on the fake type_infos created by MR_materialize_typeinfos_base(). runtime/mercury_layout_util.c: Change MR_materialize_typeinfos_base() to set the type_ctor_info field to NULL. runtime/mercury_type_info.c: Change the code for MR_get_arg_type_info() so that it handles the case where the type_ctor_info field is NULL.	1999-12-10 15:53:34 +00:00
Zoltan Somogyi	b5fe9274d1	Delete unused variable. ... Estimated hours taken: 0.1 runtime/mercury_layout_util.c: Delete unused variable.	1999-11-05 02:32:00 +00:00
Fergus Henderson	88a513b580	Reorganize the routines for allocating and deallocating memory: ... Estimated hours taken: 8 Reorganize the routines for allocating and deallocating memory: runtime/mercury_std.h: runtime/mercury_misc.c: runtime/mercury_memory.h: runtime/mercury_memory.c: - Put the routines in the proper place. Previously the declarations and definitions of the memory allocation/deallocation routines were spread amoungst all four of these files; I moved the ones in mercury_std.h and mercury_misc.c so that they are now all defined in mercury_memory.{h,c} - Avoid unnecessary duplication The following routines did exactly the same thing, modulo bugs(!): allocate_bytes() and newmem() deallocate_bytes() and oldmem() make() and allocate_object() make_many() and allocate_array() - Use appropriate names. I added `MR_' prefixes, and ensured that macros that are not function-like macros use all uppercase. I also used a more consistent naming scheme. Previously the names used were (1) checked_malloc, checked_realloc (2a) allocate_bytes, deallocate_bytes, reallocate_bytes, allocate_object, allocate_array, resize_array (2b) newmem, oldmem, resizemem, make, make_many, resize_many The new names are (1) MR_malloc, MR_free, MR_realloc, MR_NEW, MR_NEW_ARRAY, MR_RESIZE_ARRAY (2) MR_GC_malloc, MR_GC_free, MR_GC_realloc, MR_GC_NEW, MR_GC_NEW_ARRAY, MR_GC_RESIZE_ARRAY runtime/*.[ch]: trace/*.[ch]: library/array.m: library/benchmarking.m: library/io.m: library/std_util.m: extras/odbc/odbc.m: extras/aditi/aditi.m: Use the new names.	1999-10-18 15:47:39 +00:00
Tyson Dowd	761ca66e1f	Fix a few buglets with getting type_infos from typeclass_infos. ... Estimated hours taken: 0.3 Fix a few buglets with getting type_infos from typeclass_infos. runtime/mercury_layout_util.c: Use MR_typeclass_info_type_info instead of MR_typeclass_info_superclass_info as we are generally retrieving the type_info. These macros are defined as identically so this buglet wasn't causing any problems. runtime/mercury_stack_layout.h: Mention another thing that can interpret the index of a typeinfo within a typeclass info.	1999-10-18 06:53:47 +00:00
Zoltan Somogyi	f143c3891f	Get the debugger to sort variables better. ... Estimated hours taken: 12 Get the debugger to sort variables better. trace/mercury_trace_vars.[ch]: A new module to manage the debugger's information about the variables live at the current program point (which can be defined as the combination of a specific event and an ancestor level). This new module centralizes the management of the (sorted) list of current variables. This in turn allows us to use a better sorting method, one that orders VarName15 correctly wrt both VarName2 and VarName. The new module also uses the type, not the name, of a variable to decide whether to exclude it from the list of variables that may be presented to the user (e.g. if it is a typeinfo or a typeclassinfo). trace/mercury_trace_internal.c: trace/mercury_trace_external.c: Use the new module's facilities. This factors out some "mostly" common code. trace/Mmakefile: Add the new module. runtime/mercury_layout_util.[ch]: Remove the code recently moved here from trace/mercury_trace_internal, as well as the filtered versions of some functions, since they are not needed anymore. Move the code for MR_make_var_list to trace/mercury_trace_external, since that is the only place where it is used (or is at all likely to be used). Since its new home is next to several very similar functions, this should also reduce the probability that any required maintenance will be overlooked. Also alter its coding style to conform to its new neighbours. Move the definition of MR_Var_Spec to trace/mercury_trace_vars.h. tests/debugger/*.exp: Update the expected output files. In most cases, this is just because the new module outputs different white space, but in some cases, it also reflects that the debugger now prints variables in a different order.	1999-05-27 01:01:33 +00:00
Erwan Jahier	045aa58368	Incorporate the term brower stuff in the external debugger. ... Estimated hours taken: 20 Incorporate the term brower stuff in the external debugger. browser/browse.m: Define browse__browse_external() which is the same as browse__browse() but for the case where the term browser is called from the external debugger. Add an argument in predicates that need it to indicate whether the term browser was called from the external or the internal debugger. Define write_string_debugger/4, nl_debugger/3, write_int_debugger/4, print_format_debugger/4 predicates and call them in place of io__write_string/4, io__nl/3, io__write_int/4, and io__print/4 respectively. If the term browser is called from the internal debugger, those predicates call the predicates they replace; otherwise, they send their argument to the socket via a term of type term_browser_response. browser/debugger_interface.m Define a new debugger request `browse/1'. Define get_variable_name/2 that allows to retrieve from mercury_trace_external.c the name of the variable to browse. browser/parse.m: Define parse__read_command_external/3 that parses the browser command sent through the socket. runtime/mercury_layout_util.c: trace/mercury_trace_internal.c: Move the definition of MR_trace_find_var() and MR_trace_validate_var_count() from mercury_trace_internal.c to mercury_layout_util.c to make it available to the external debugger. runtime/mercury_layout_util.h: trace/mercury_trace_internal.c: Move the definition of MR_Var_Spec_Kind and MR_Var_Spec from mercury_trace_internal.c to mercury_layout_util.h to make it available to mercury_layout_util.c. trace/mercury_trace_browse.ch: Define the function MR_trace_browse_external() which is the same as MR_trace_browse() except it uses the external debugger socket instead of mdb_in and mdb_out. trace/mercury_trace_external.c: Define MR_trace_browse_one_external(), MR_trace_browse_var_external() which are the same as MR_trace_browse_one() and MR_trace_browse_var() of mercury_trace_internal.c, but for the use of the external debugger. Define MR_get_variable_name() that calls get_variable_name/2 defined in debugger_interface.m.	1999-05-21 14:38:21 +00:00
Zoltan Somogyi	f97297c65d	Compress the representation of value shape information. ... Estimated hours taken: 3 Compress the representation of value shape information. Instead of a pointer to a two-word cell containing a pseudotypeinfo and a dummy inst, just have the pseudotypeinfo itself. However, we were previously using small integer "pointers" to represent special kinds of values such as saved succips, hps, etc. Since pseudotypeinfos use small integer values for their own purposes (to represent type variables), we can't continue doing this. Therefore this change also creates type_ctor_info structures for each of these special kinds of values. These values are only used by the garbage collector, so nothing else is affected. compiler/stack_layout.m: Effect the above change. library/builtin.m: Add type_ctor_info structures and their components for the new kinds of values. runtime/mercury_stack_layout.h: Delete the section on shape information, since we don't generate such structures anymore. runtime/mercury_layout_util.c: Access pseudotypeinfos directly, not through the shape structure. runtime/mercury_type_info.h: Add new values to the type_ctor_layout enum for the special kinds of values.	1999-05-07 08:09:05 +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	3bf462e0b7	Switch to a closure representation that includes runtime type and procedure id ... Estimated hours taken: 36 Switch to a closure representation that includes runtime type and procedure id information, so that closures can be copied, garbage collected, printed, etc. This RTTI information is not yet used. Adding code to use it would be futile until Tyson finishes his changes to the other RTTI data structures. Note also that this change provides the information required for solving the problem of trying to deep copy closures only for grades that include --typeinfo-liveness. Providing this info for other grades is future work. configure.in: Find out what the right way to refer to a variable-sized array at the end of a struct is. runtime/mercury_ho_call.h: New file to define the structure of closures and macros for accessing closures. runtime/Mmakefile: Add the new header file. runtime/mercury_ho_call.c: Add an entry point to handle calls to new-style closures. The code to handle old-style closures, which was unnecessarily duplicated for each code model, stays until all the installed compilers use the new closure representation. Until that time, the new entry point will contain code to detect the use of old-style closures and invoke the old code instead. This allows stage1s compiled with old compilers to use the old style and stage2 to use the new style without any special tricks anywhere else. Add a new entry point to handle method calls of all code models. The old entry points, which had the same code, will also be deleted after this change has been bootstrapped. runtime/mercury_calls.h: Remove the macros that call closures. Their interface sucked, they were not used, and their implementation is now out of date. runtime/mercury_stack_layout.h: Add a new type, MR_Type_Param_Locns, for use by the C type representing closures. Since MR_Stack_Layout_Vars has a field, MR_slvs_tvars, which references a data structure identical in every way to MR_Type_Param_Locns, change the type of that field to this new type, instead of the previous cheat. runtime/mercury_layout_util.h: Minor update to conform to the new type of the MR_slvs_tvars field. (This is the only use of that field in the system.) runtime/mercury_type_info.h: Add new types MR_TypeInfo and MR_PseudoTypeInfo. For now, they are just Word, but later we can make them more accurate. In the meantime, we can refer to them instead of to Word, making code clearer. One such reference is now in mercury_ho_call.h. compiler/notes/release_checklist.html: Add a reminder to remove the redundant code from mercury_ho_call.c after bootstrapping. compiler/llds.m: Replace three code addresses for calling closures and another three for calling methods with one each. compiler/call_gen.m: compiler/dupelim.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/llds_out.m: Trivial updates in accordance with the change to llds.m compiler/code_info.m: Move the code to handle layouts to continuation_info.m, since that's where it belongs. Leave only the code for picking up parameters from code_infos and for putting results back in there. Remove the redundant arguments of code_info__init, and extract them from ProcInfo, to make clear that they are related. compiler/code_gen.m: Since we pass ProcInfo to code_info__init, don't pass its components. compiler/continuation_info.m: Add the code moved from code_info.m, in a form which takes explicit arguments for things that used be hidden in the code_info. Add new code, closely related to the moved code, that creates layout info from a procedure's argument info, rather than from a (part of) the current code generator state. This way, it can be invoked from places that don't have a code_info for the procedure for which they want to generate layouts. This is the case when we generate layouts for closures. compiler/par_conj_gen.m: compiler/trace.m: Minor changes required by the move of stuff from code_info to continuation_info. compiler/stack_layout.m: Export some predicates for use by unify_gen. compiler/unify_gen.m: Switch to creating new style closures, complete with layout info. Optimize the code for extending closures a bit. By copying the fixed words of the closure outside the loop, we avoid incurring the loop overhead twice. compiler/code_util.m: Add a couple of utility predicates for continuation_info.m and unify_gen.m library/benchmarking.m: library/std_util.m: Refer to the new entry point for handling closures. browser/dl.m: Use the new closure representation. Note that extras/dynamic_linking/dl.m, which is supposed to be the same as browser/dl.m but is not, should also be updated, but this will be handled later by Fergus. tests/hard_coded/closure_extension.{m,exp}: A new test case to exercise the code for extending closures. tests/hard_coded/Mmakefile: Enable the new test case.	1999-04-16 06:05:49 +00:00
Zoltan Somogyi	1e481ac6e9	Fix a small bug that only affects the behavior of the program ... Estimated hours taken: 0.2 runtime/mercury_layout_util.c: Fix a small bug that only affects the behavior of the program only when layout structures have unexpected contents. Improve the documentation a bit.	1999-03-26 03:21:23 +00:00
Fergus Henderson	875c9de295	Improve efficiency on SPARCs, by replacing calls to save_transient_registers() ... Estimated hours taken: 0.5 Improve efficiency on SPARCs, by replacing calls to save_transient_registers() with calls to save_transient_hp() where appropriate -- the latter is defined to do nothing for conservative GC. runtime/mercury_regs.h: Add save_transient_hp() and restore_transient_hp() macros which only guarantee to save/restore the heap pointer. runtime/mercury_deep_copy.c: runtime/mercury_deep_copy.h: runtime/mercury_heap.h: runtime/mercury_layout_util.c: runtime/mercury_string.h: runtime/mercury_tabling.h: runtime/mercury_type_info.c: Use save_transient_hp() instead of save_transient_regs() and restore_transient_hp() instead of restore_transient_regs(). runtime/mercury_trail.c: runtime/mercury_trail.h: Comment out a pair of calls to save/restore_transient_regs(), add a similar pair, also commented out, and document why neither pair is needed. runtime/mercury_type_info.c: Add some comments.	1999-03-10 22:05:27 +00:00
Erwan Jahier	048016ba14	Fix a bug in the external debugger. The execution was crashing during the ... Estimated hours taken: 3 Fix a bug in the external debugger. The execution was crashing during the printing of polymorphic arguments. In runtime/mercury_layout_util.c, MR_get_type_filtered() and MR_get_type_and_value_filtered() were calling MR_get_type() and MR_get_type_and_value() without type_info information (third argument set to NULL), which is needed to retrieve polymorphic types. runtime/mercury_layout_util.[ch]: Pass down type_info in argument of MR_get_type_and_value_filtered() and MR_get_type_filtered() to be able to call MR_get_type_and_value() and MR_get_type() with type_info information. runtime/mercury_layout_util.c Filter out variables which names begin by "TypeClassInfo" in MR_get_type_and_value_filtered() (as it was already done in MR_get_type_filtered()). runtime/mercury_layout_util.c trace/mercury_trace_external.c: In a few functions, do not try to retrieve information about live variables if it does not exist any. trace/mercury_trace_external.c: Pass type_info in argument of MR_get_type_and_value_filtered() and MR_get_type_filtered(). Filter out in MR_trace_make_var_names_list() the variable names that are also filtered in MR_get_type_and_value_filtered().	1999-02-19 16:11:48 +00:00
Zoltan Somogyi	6b9583eb74	Extend the layout scheme to handle typeinfos inside typeclass infos, ... Estimated hours taken: 16 Extend the layout scheme to handle typeinfos inside typeclass infos, and thus enable the debugger (and later native gc) to work with programs that use type classes and existential types. compiler/llds.m: Change the data structure that holds information about the locations of the typeinfo variables of the tvars active at call return sites from set(pair(tvar, lval)) to map(tvar, set(layout_locn)). The change from set to map avoids the possibility of inadvertently duplicating the info for a give type variable. The change to explicitly keep a set of locations in which the typeinfo var may be found allows us to use set intersection on those sets if (a) the program point may be reached via more than one path, and (b) not all paths have the same sets. Both of these can happen in programs that use type classes. The change from lval to layout_locn (which encodes either an lval, or an lval representing a typeclass info and an (indirect) offset inside that typeclass info) is necessary support programs with type classes. compiler/continuation_info.m: Change the data structure that holds information about the locations of the typeinfo variables of the tvars active at a particular program point the same way and for the same reasons as in llds.m. Take set intersections of typeinfo var locations whenever we find multiple live variable info records for the same label. compiler/call_gen.m: Delay the construction of the return live variable information until the code generator state has been updated to reflect where things will be on return, instead of trying to cobble up this info into the code generator state that reflects the point just before the call. Apart from being cleaner, this is necessary to avoid compiler aborts for programs that use existential types. The old compiler could not find the typeinfos of any existentially quantified type vars, since they do not exist before the call. compiler/code_info.m: Rewrite and generalize the code for generating live value information. compiler/trace.m: Remove the specialized code for generating live value information; call code_info instead. compiler/stack_layout.m: Pick one of several possible locations for a typeinfo var. Generate the new indirect layout location descriptions. Reduce the number of tag bits used to describe different kinds of lvals, to leave more room for the indirect information. compiler/*.m: Conform to the above data structure changes. compiler/hlds_pred.m: Clarify the documentation of type_info_locn. runtime/mercury_stack_layout.h: Update the section that deals with MR_Live_Lval to take indirect typeinfo locations into account. runtime/mercury_layout_util.c: Handle indirect typeinfo locations when interpreting layout structures. runtime/mercury_layout_util.c: trace/mercury_trace_internal.c: Ignore variables whose names start with TypeClassInfo. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: Add markers to remind Tyson to handle indirect typeinfo locations. tests/debugger/implied_instance.{m,inp,exp}: tests/debugger/multi_paramster.{m,inp,exp}: tests/debugger/existential_type_classes.{m,inp,exp}: Copies of the tests in tests/hard_coded/typeclasses, modified to avoid or delay I/O, so that the calls to I/O preds that may or may not be traced to do not affect the output. tests/debugger/Mmakefile: Add the new test cases. Remove references to the *_lib variants of the old test cases. They are not necessary if I/O is delayed until after the last reported trace event. tests/hard_coded/typeclasses/Mmakefile: Remove --trace deep from existential_type_classes, since that aspect of the test case is now covered in the debugger directory.	1998-10-23 00:41:48 +00:00
Zoltan Somogyi	16f3d4ccaa	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:21 +00:00