124 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	2bef47ce85	Extend the information we record about procedures when debugging is enabled ... Estimated hours taken: 20 Branches: main (for now, after more testing, on release branch too) Extend the information we record about procedures when debugging is enabled to include information about the tabling transformation, if the procedure in question is tabled. This is useful to developers in debugging the tabling mechanism, and can be useful to general users by helping them understand the space (and hence time) costs of tabling. Add a new mdb command "table" that uses this information to print programmer-selected subsets of the tables of a tabled procedure. compiler/hlds_pred.m: Generalize the existing field in procedures that used to hold information about I/O tabling to contain information about tabling in general, including forms other than I/O tabling. compiler/continuation_info.m: compiler/code_gen.m: compiler/stack_layout.m: Conform to the changes in hlds_pred.m. compiler/layout.m: Provide Mercury parallels for the new data structures in mercury_stack_layout.h. compiler/layout_out.m: Generate the new data structures in mercury_stack_layout.h. compiler/table_gen.m: Generate the new data structures in hlds_pred.m. compiler/llds_common.m: compiler/opt_debug.m: Conform to the changes in layout.m compiler/llds_out.m: Abstract out existing code into a new procedure to make it available to layout_out.m. Make tabling pointer variables their natural type. compiler/modules.m: Fix an old bug: implicitly import table_builtin.m in .mm grades. doc/mdb_categories: doc/user_guide.texi: Document the new mdb command "table". runtime/mercury_types.h: Move some type definitions here from mercury_tabling.h and mercury_stack_layout.h. This was necessary to avoid problems with circular #includes, in which a.h #includes b.h to get access to a definition, but b.h #includes a.h, which is prevented by the macro guarding against duplicate definition, which causes syntax errors in the rest of b.h because the rest of b.h depends on typedefs in a.h that occur in a.h *after* the #include of b.h. runtime/mercury_label.h: Adjust the list of #includes after the change to mercury_types.h. runtime/mercury_stack_layout.h: Extend the debugging data structures with constructs that describe the call tables, answer tables and answer blocks of tabled procedures. Delete typedefs that are now in mercury_types.h. runtime/mercury_tabling.[ch]: Add new functions to allow lookups without insertions in hash tables containing ints, floats and strings. Add new functions to return the entire contents of these hash tables. Change to four-space indentation where this wasn't done previously. runtime/mercury_grade.h: Increment the binary compatbility version number, partially to account for the change to mercury_stack_layout.h in this diff, but mostly to account for all the other diffs to mercury_stack_layout.h since the last released version. trace/mercury_trace_tables.[ch]: Rename MR_print_proc_id_for_debugger as MR_print_proc_id_and_nl, since this better describes what the function does. trace/mercury_trace_util.[ch]: Add a new function MR_trace_is_integer that reads in signed integers. Rename MR_trace_is_number as MR_trace_is_natural_number, since the former would now be ambiguous. Add a new function MR_trace_is_float that reads in floating point values. library/string.m: Document that MR_trace_is_float uses the same logic as MR_trace_is_float. trace/mercury_trace_browse.c: trace/mercury_trace_vars.c: Update calls to MR_trace_is_number. trace/mercury_trace_internal.c: Implement the new mdb command "table". Update calls to MR_trace_is_number and to MR_print_proc_id_for_debugger. tests/debugger/print_table.{m,inp,exp}: New test case to test the new mdb command. tests/debugger/Mmakefile: Enable the new test case. Disable the sensitive test cases in .mm grades. tests/debugger/completion.exp: Update the expected output to include the new mdb command. tests/debugger/mdb_command_test.inp: Update this automatically generated file to include the new mdb command.	2002-11-15 04:50:49 +00:00
Zoltan Somogyi	404abb0c57	Another step towards RTTI in Mercury. ... Estimated hours taken: 32 Branches: main Another step towards RTTI in Mercury. This step redefines the representation of type_ctor_infos inside the compiler to be identical to the representation we will need for efficient interpretation of RTTI data structures in Mercury, following on from an earlier step which did the same for (pseudo)typeinfos. Instead of the type_ctor_info being broken down into its components in type_ctor_info.m, the breakdown process is now performed in rtti_out.m (for the LLDS backend) and rtti_to_mlds.m (for the MLDS backend). Eventually, the IL and Java backends will stop using rtti_to_mlds.m for this purpose, and will instead write out the type_ctor_data structures as static data to be interpreted directly. We now predefine the C types representing type_info and pseudo_type_infos for types of arity up to 20 for the LLDS C backend as well as for the MLDS C backend. The LLDS backend can define them for higher arities on demand; the MLDS backend (for now) still cannot. runtime/mercury_type_info.h: To be able to represent all the kinds of types we now support - add a data structure for converting values of reserved_addr types from their printable representation to their internal representation (it was previously missing), and - add a type_ctor_rep to represent foreign types. Add missing MR_ prefixes on some field names. Add typedefs for all the types that the rtti_names can refer to. There were already such typedefs in runtime/mercury.h for the MLDS grades, we now have them for the LLDS grades too. Predefine the C types representing type_info and pseudo_type_infos for types of arity up to 20. There were already such typedefs in runtime/mercury.h for the MLDS grades, we now have them for the LLDS grades too. runtime/mercury.h: Delete the typedefs that are now in mercury_type_info.h. runtime/mercury.h: Delete the definitions of the C types representing type_info and pseudo_type_infos, since these are now in mercury_type_info.h. #include mercury_type_info.h. compiler/rtti.m: Add new, purely Mercury data structures for representing type_ctor_infos and their components, designed both for efficient interpretation and as a source for the generation of static data structures in C. This entailed deleting most of the alternatives of the rtti_data type while preserving their rtti_name equivalents; the deleted alternatives represent tables are no longer created in type_ctor_info.m but which are created dynamically in rtti_out.m and rtti_to_mlds.m (which need a way for one table to refer to another). Centralize the correspondence between rtti_names and the C and Java types of the corresponding structures (the C and Java names differ in prefixes only). Among other things, this remove the double maintenance problem we have previously with the LLDS and MLDS backends maintaining their own maps of the correspondence. Add utility predicates on the new data structures for use by both rtti_out.m and rtti_to_mlds.m. compiler/hlds_module.m: Always store the ids of unification and comparison procedures in type_ctor_gen_infos, to simplify their handling. compiler/type_ctor_info.m: Generate the new data structures for representing type_ctor_infos. Conform to the changed data structures for type_ctor_gen_infos. compiler/rtti_out.m: compiler/rtti_to_mlds.m: Rewrite substantial parts of these modules to convert the new data structures for representing type_ctor_infos to sets of discrete structures dynamically. Most of the dynamically created structures are unique by construction, but this is not true for typeinfos and pseudo-typeinfos. Therefore add mechanisms to ensure that we don't generate redundant structures representing typeinfos and pseudo-typeinfos. compiler/mlds_to_c.m: compiler/mlds_to_java.m: Use the standard mechanisms for creating C and Java type names. compiler/mlds_to_gcc.m: Conform to the changed data structures in rtti.m and mercury_type_info.h. compiler/opt_debug.m: Conform to the changed data structures in rtti.m. compiler/dead_proc_elim.m: Conform to the changed data structures for type_ctor_gen_infos. compiler/pseudo_type_info.m: Add a predicate to construct a representation of a type that may or may not be ground. compiler/mlds_to_gcc.m: java/runtime/TypeCtorRep.java: library/private_builtin.m: library/rtti_implemenation.m: runtime/mercury_mcpp.{cpp,h}: Add the type_ctor_rep for foreign types to the lists of type_ctor_reps. library/construct.m: library/deconstruct.m: Add missing MR_ prefixes on field names. runtime/mercury_construct.c: runtime/mercury_deconstruct.c: runtime/mercury_deep_copy_body.h: runtime/mercury_ml_expand_body.h: runtime/mercury_tabling.c: runtime/mercury_type_info.c: runtime/mercury_unify_compare_body.h: Handle the type_ctor_rep for foreign types. Add missing MR_ prefixes on field names. library/list.m: Add two utility predicates, is_empty and is_not_empty, for use with higher order code. NEWS: Mention the new predicates in list.m. Delete a duplicate entry.	2002-08-01 11:52:29 +00:00
Zoltan Somogyi	f6f04fb5b3	To handle the tracing of dependencies in polymorphic predicates, the ... Estimated hours taken: 4 Branches: main To handle the tracing of dependencies in polymorphic predicates, the declarative debugger will soon need to know, for each procedure, the full list of that procedure's head variables, not just the list of programmer-created head variables. To this end, we add to each procedure's layout structure a vector of the head variables' variable numbers. Code to make use of this new vector will be in a later change. compiler/layout.m; Add a way to refer to the head variable number vector. compiler/layout_out.m; compiler/opt_debug.m; Add code to output the head variable number vector. compiler/stack_layout.m; Add code to generate the head variable number vector. Fix some old variable names. runtime/mercury_stack_layout.h; Add the head variable number vector to procedure layouts. Add some missing documentation.	2002-04-12 10:08:24 +00:00
Zoltan Somogyi	43fbf4b956	A step towards RTTI in Mercury. ... Estimated hours taken: 40 Branches: main A step towards RTTI in Mercury. This step redefines the representation of pseudo-typeinfos inside the compiler to be identical to the representation we will need for efficient interpretation of RTTI data structures in Mercury. Later steps will do likewise for typectorinfos. In the end, we will have two implementations of RTTI: the current low-level, very efficient one written in C, which will be used by the C backends (both LLDS and MLDS), and a new, higher-level one which will use Mercury data structures and Mercury predicates for interpretation (along the lines of library/rtti_implementation.m) for the Java and IL backends. A large part of this change concerns the fact that pseudo-typeinfos can now contain typeinfos as well as other pseudo-typeinfos, and they do in the frequent case that the type of an argument is ground. Given that typeinfos are just special cases of pseudo-typeinfos, the code for handling the two types is usually similar, with common code factored out when relevant. In the process of redesigning the data structures concerning (pseudo-) typeinfos, I also fixed an old naming scheme that has become misleading. The representation of a (pseudo-) typeinfo depends on whether the principal type constructor is fixed arity or not. We used to denote this distinction with the phrases first-order vs higher-order, since at first the only variable arity type constructors were pred and func. However, this hasn't been true since we added tuples. I have changed the naming scheme to be fixed-arity vs variable-arity. compiler/rtti.m: Add new, purely Mercury data structures for representing typeinfos and pseudo-typeinfos, designed both for efficient interpretation and as a source for the generation of static data structures in C. compiler/pseudo_type_info.m: Delete the type definitions here, since they are superseded by the new definitions in rtti.m. Add predicates for constructing typeinfos as well as pseudo-typeinfos, since now we need those too. Conform to the changed data structures for (pseudo-) typeinfos. compiler/ll_pseudo_type_info.m: compiler/ml_closure_gen.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/opt_debug.m: compiler/type_ctor_info.m: Conform to the changed data structures for (pseudo-) typeinfos. compiler/mlds.m: Since the MLDS now refers to type_infos, add their type (mlds__type_info_type) to the list of types the MLDS knows about. compiler/ml_code_util.m: compiler/mlds_to_c.m: compiler/mlds_to_il.m: compiler/mlds_to_java.m: Handle mlds__type_info_type. compiler/mlds_to_gcc.m: Conform to the changed data structures for (pseudo-) typeinfos, and handle mlds__type_info_type. runtime/mercury_bootstrap.h: Override the compiler-generated names of the type_ctor_infos of the variable arity type constructors. The MLDS backend requires these to be module qualified; the LLDS backend requires them to be unqualified. This is a problem because the same code now generates the compiler's internal representation of pseudo-typeinfos for both backends. The temporary solution is to have the compiler generate these names module qualified, and have these macros convert them to the unqualified form. (The long term solution should be to always module qualify everything, but doing that is for another change.) runtime/mercury_type_info.h: Change the naming scheme from first order vs higher order to fixed arity vs variable arity. library/construct.m: library/deconstruct.m: runtime/mercury.c: runtime/mercury_construct.c: runtime/mercury_deconstruct.c: runtime/mercury_deep_copy_body.h: runtime/mercury_make_type_info_body.h: runtime/mercury_ml_expand_body.h: runtime/mercury_tabling.c: runtime/mercury_type_desc.c: runtime/mercury_type_info.c: runtime/mercury_unify_compare_body.h: Conform to the new naming scheme. runtime/mercury.h: Conform to the new naming scheme. Declare fixed and variable arity types for typeinfos as well as pseudo-typeinfos, since pseudo-typeinfos can now refer to typeinfos.	2002-04-12 01:24:25 +00:00
Fergus Henderson	7597790760	Use sub-modules to structure the modules in the Mercury compiler directory. ... The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c.	2002-03-20 12:37:56 +00:00
Zoltan Somogyi	41a27af862	Change type_id to the more descriptive type_ctor everywhere. ... Estimated hours taken: 6 Branches: main compiler/*.m: Change type_id to the more descriptive type_ctor everywhere.	2002-03-07 08:30:28 +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
Fergus Henderson	def21a3675	Add RTTI support for the new reserved address data representations. ... Estimated hours taken: 18 Branches: main Add RTTI support for the new reserved address data representations. runtime/mercury_type_info.h: runtime/mercury_mcpp.h: runtime/mercury.h: library/private_builtin.m: library/rtti_implementation.m: Add MR_TYPECTOR_REP_RESERVED_ADDR (with and without _USEREQ) to the MR_TypeCtorRep enum, for discriminated union types containing one or more functors represented using reserved addresses, and add new RTTI structs to hold information about how such types are represented. compiler/type_ctor_info.m: compiler/mlds_to_gcc.m: compiler/opt_debug.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: Add appropriate code to generate these new RTTI structs. runtime/mercury_deep_copy_body.h: runtime/mercury_ml_expand_body.h: runtime/mercury_unify_compare_body.h: runtime/mercury_tabling.c: library/std_util.m: Add code to handle the MR_TYPECTOR_REP_RESERVED_ADDR alternative, using the information in the new RTTI structs.	2001-10-24 07:43:25 +00:00
Zoltan Somogyi	04e614485d	Implement deep profiling; merge the changes on the deep2 branch back ... Estimated hours taken: 500 Branches: main Implement deep profiling; merge the changes on the deep2 branch back onto the trunk. The main documentation on the general architecture of the deep profiler is the deep profiling paper. doc/user_guide.texi: Document how to use the deep profiler. deep_profiler: deep_profiler/Mmakefile: A new directory holding the deep profiler and its mmakefile. Mmakefile: Add targets for the new directory. Add support for removing inappropriate files from directories. deep_profiler/interface.m: The deep profiler consists of two programs: mdprof_cgi.m, which acts as a CGI "script", and mdprof_server.m, which implements the server process that the CGI script talks to. Interface.m defines the interface between them. script/mdprof.in: A shell script template. ../configure uses it to generate mdprof, which is a wrapper around mdprof_cgi that tells it how to find mdprof_server. deep_profiler/mdprof_cgi.m: The CGI "script" program. deep_profiler/mdprof_server.m: The top level predicates of the server. deep_profiler/profile.m: The main data structures of the server and their operations. deep_profiler/read_profile.m: Code for reading in profiling data files. deep_profiler/startup.m: Code for post-processing the information in profiling data files, propagating costs from procedures to their ancestors and performing various kinds of summaries. deep_profiler/server.m: Code for responding to requests from the CGI script. deep_profiler/cliques.m: Code to find cliques in graphs. deep_profiler/array_util.m: deep_profiler/util.m: Utility predicates. deep_profiler/dense_bitset.m: An implementation of (part of) the set ADT with dense bit vectors. deep_profiler/measurements.m: Operations on profiling measurements. deep_profiler/timeout.m: An implementation of a timeout facility. deep_profiler/conf.m: Functions that depend on autoconfigured settings. configure.in: Find out what command to use to find the name of the local host. Install deep profiling versions of the standard library along with the other profiling versions. runtime/mercury_conf.h.in: Add some macros for deep_profiler/conf.m to use. library/profiling_builtin.m: runtime/mercury_deep_call_port_body.h: runtime/mercury_deep_leave_port_body.h: runtime/mercury_deep_redo_port_body.h: A new library module that implements deep profiling primitives. Some of these primitives have many versions, whose common code is factor is factored out in three new include files in the runtime. compiler/deep_profiling.m: New module to perform the program transformations described in the paper. compiler/notes/compiler_design.html: Document the new compiler module. compiler/mercury_compiler.m: Invoke the new module in deep profiling grades. Allow global static data to be generated by deep_profiling.m. compiler/options.m: Add options to turn on deep profiling and (for benchmarking purposes) control its implementation. Add an optiooption disable tailcall optimization in the LLDS backend, to help benchmarking deep profiling. compiler/jumpopt.m: compiler/optimize.m: Obey the option to disable tailcalls. compiler/handle_options.m: Handle the implications of deep profiling. compiler/modules.m: In deep profiling grades, automatically import profiling_builtin.m. compiler/prog_util.m: doc/Makefile: library/library.m: Handle the new builtin module. compiler/export.m: In deep profiling grades, wrap deep profiling code around exported procedures to handle the "unscheduled call" aspects of callbacks to Mercury from the foreign language. compiler/higher_order.m: profiler/demangle.m: util/demangle.c: When creating a name for a higher-order-specialized predicate, include the mode number in the name. compiler/add_trail_ops.m: compiler/type_util.m: Move c_pointer_type from add_trail_ops to type_util, so it can also be used by deep_profiling.m. compiler/hlds_goal.m: Add a new goal feature that marks a tail call, for use by deep_profiling.m. compiler/hlds_pred.m: Add a new field to proc_info structures for use by deep_profiling.m. Add a mechanism for getting proc_ids for procedure clones. Remove next_proc_id, an obsolete and unused predicate. compiler/hlds_data.m: Add a new cons_id to refer to the proc_static structure of a procedure. compiler/bytecode_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/switch_util.m: compiler/unify_gen.m: Trivial changes to handle the new cons_id, goal feature and/or proc_info argument. compiler/rtti.m: Add a utility predicate for extracting pred_id and proc_id from an rtti_proc_label, for use by hlds_out.m compiler/layout.m: compiler/layout_out.m: compiler/llds.m: compiler/llds_common.m: Add support for proc_static and call_site_static structures. compiler/layout_out.m: compiler/llds_out.m: Add code for the output of proc_static structures. compiler/code_util.m: Make code_util__make_proc_label_from_rtti a function, and export it. util/mkinit.c: compiler/llds_out.m: compiler/layout.m: compiler/modules.m: Add support for a fourth per-module C function, for writing out proc_static structures (and the call_site_static structures they contains). Since proc_static structures can be referred to from LLDS code (and not just from other static structures and compiler-generated C code), reorganize the declarations of static structures slightly. Change the schema for the name of the first per-module C function slightly, to make it the addition of the fourth function easier. The scheme now is: mercury__<modulename>__init mercury__<modulename>__init_type_tables mercury__<modulename>__init_debugger mercury__<modulename>__write_out_proc_statics Improve formatting of the generated C code. library/*.m: runtime/mercury.c: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_tabling.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: trace/mercrury_trace.[ch]: trace/mercrury_trace_declarative.c: trace/mercrury_trace_external.c: trace/mercrury_trace_internal.c: Conform to the new scheme for initialization functions for hand-written modules. compiler/mercury_compile.m: library/benchmarking.m: runtime/mercury_conf_param.h: runtime/mercury.h: runtime/mercury_engine.c: runtime/mercury_goto.c: runtime/mercury_grade.h: runtime/mercury_ho_call.c: runtime/mercury_label.[ch]: runtime/mercury_prof.[ch]: Add an MR_MPROF_ prefix in front of the C macros used to control the old profiler. compiler/handle_options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make deep profiling completely separate from the old profiling system, by making the deep profiling grade independent of MR_MPROF_PROFILE_TIME and the compiler option --profile-time. library/array.m: library/builtin.m: library/std_util.m: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_compare_body.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of hand-written unification and comparison procedures. Make the reporting of array bounds violations switchable between making them fatal errors, as we currently, and reporting them by throwing an exception. Throwing an exception makes debugging code using arrays easier, but since exceptions aren't (yet) propagated across engine boundaries, we keep the old behaviour as the default; the new behaviour is for implementors. runtime/mercury_deep_profiling_hand.h: New file that defines macros for use in Mercury predicates whose definition is in hand-written C code. library/exception.m: runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of the various modes of builtin_catch. Provide a function that C code can use to throw exceptions. library/benchmarking.m: library/exception.m: library/gc.m: library/std_util.m: runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_overflow.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_thread.c: runtime/mercury_wrapper.c: Add prefixes to the names of the fields in the engine and context structures, to make code using them easier to understand and modify. runtime/mercury_deep_profiling.[ch]: New module containing support functions for deep profiling and functions for writing out a deep profiling data file at the end of execution. runtime/mercury_debug.[ch]: Add support for debugging deep profiling. Add support for watching the value at a given address. Make the buffered/unbuffered nature of debugging output controllable via the -du option. Print register contents only if -dr is specified. runtime/mercury_goto.h: runtime/mercury_std.h: Use the macros in mercury_std.h instead of defining local variants. runtime/mercury_goto.h: runtime/mercury_stack_layout.h: runtime/mercury_stack_trace.c: runtime/mercury_tabling.c: trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Standardize some of the macro names with those used in the debugger paper. runtime/mercury_heap.h: Add support for memory profiling with the deep profiler. runtime/mercury_prof.[ch]: runtime/mercury_prof_time.[ch]: Move the functionality that both the old profiler and the deep profiler need into the new module mercury_prof_time. Leave mercury_prof containing stuff that is only relevant to the old profiler. runtime/mercury_prof.[ch]: runtime/mercury_strerror.[ch]: Move the definition of strerror from mercury_prof to its own file. runtime/mercury_wrapper.[ch]: Add support for deep profiling. Add suppory for controlling whether debugging output is buffered or not. Add support for watching the value at a given address. runtime/Mmakefile: Mention all the added files. scripts/mgnuc.in: Add an option for turning on deep profiling. Add options for controlling the details of deep profiling. These are not documented because they are intended only for benchmarking the deep profiler itself, for the paper; they are not for general use. tools/bootcheck: Compile the deep_profiler directory as well as the other directories containing Mercury code. Turn off the creation of deep profiling data files during bootcheck, since all but one of these in each directory will be overwritten anyway. Add support for turning on --keep-objs by default in a workspace. tools/speedtest: Preserve any deep profiling data files created by the tests. trace/mercury_trace.c: Trap attempts to perform retries in deep profiling grades, since they would lead to core dumps otherwise. util/Mmakefile: Avoid compile-time warnings when compiling getopt. tests/*/Mmakefile: tests/*/*/Mmakefile: In deep profiling grades, switch off the tests that test features that don't work with deep profiling, either by design or because the combination hasn't been implemented yet.	2001-05-31 06:00:27 +00:00
Zoltan Somogyi	7add5e0b0d	Disable value numbering, now that it is no longer needed. ... Estimated hours taken: 0.5 Branches: main Disable value numbering, now that it is no longer needed. The value numbering source files are not deleted from the CVS repository, since that would make their restoration (in the unlikely event that this is needed) inconvenient, but they will no longer be compiled or included in compiler executables. doc/user_guide.texi: compiler/options.m: Delete the options dealing with value numbering. compiler/optimize.m: Do not invoke value numbering. compiler/handle_options.m: Delete code that handles implications involving value numbering. compiler/opt_debug.m: Delete code for debugging value numbering, since leaving it in would require importing value numbering modules and would thus drag them into the compiler executable. compiler/value_number.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_debug.m: compiler/vn_filter.m: compiler/vn_flush.m: compiler/vn_order.m: compiler/vn_table.m: compiler/vn_temploc.m: compiler/vn_type.m: compiler/vn_util.m: compiler/vn_verify.m: Delete these now obsolete modules. compiler/notes/compiler_design.html: Delete mentions of value numbering and its modules. tests/general/accumulator/Mmakefile: tests/hard_coded/Mmakefile: Remove references to options removed by this change.	2001-05-15 07:12:04 +00:00
Zoltan Somogyi	9c58f97e3b	Add a new optimization, --use-local-vars, to the LLDS backend. ... Estimated hours taken: 20 Branches: main Add a new optimization, --use-local-vars, to the LLDS backend. This optimization is intended to replace references to fake registers and stack slots with references to temporary variables in C code, since accessing these should be cheaper. With this optimization and one for delaying construction unifications, the eager code generator should generate code at least good as that produced by the old value numbering pass. This should make it possible to get rid of value numbering, which is much harder to maintain. compiler/use_local_vars.m: New module containing the optimization. compiler/notes/compiler_design.html: Mention the new module. compiler/exprn_aux.m: Add new utility predicates for use by use_local_vars. If --debug-opt is specified, do not dump instruction sequences to standard output. Instead, put them in separate files, where they can be compared more easily. compiler/options.m: Add the --use-local-vars option to control whether the use_local_vars pass gets run. compiler/llds.m: Add liveness information to the c_code and pragma_foreign_code LLDS instructions, in order to allow use_local_vars to work in the presence of automatically-generated C code (e.g. by debugging). compiler/livemap.m: Use the new liveness information to generate useful livemap information even in the presence of automatically generated C code. compiler/code_gen.m: compiler/code_info.m: compiler/dupelim.m: compiler/frameopt.m: compiler/llds_common.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pragma_c_gen.m: compiler/trace.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_filter.m: compiler/vn_verify.m: Provide and/or ignore this additional liveness information. compiler/wrap_block.m: The post_value_number pass wraps LLDS instruction sequences using temporaries in a block instruction which actually declares those temporaries. It used to be used only by value numbering; it is now also used by use_local_vars. It has therefore been renamed and put in its own file. compiler/optimize.m: Invoke use_local_vars if required, and call wrap_blocks instead of post_value_number. compiler/value_number.m: Since the value numbering pass still cannot handle automatically generated C code, check for it explicitly now that livemap carries out only a weaker check. compiler/basic_block.m: Add a module qualification. library/set.m: library/set_bbbtree.m: library/set_ordlist.m: library/set_unordlist.m: Add a new predicate, union_list, to each implementation of sets, for use by some of the new code above. tests/general/array_test.m: Print out the result of each operation as soon as it is done, so that if you get a seg fault, you know which operations have completed and which haven't.	2001-04-24 03:59:13 +00:00
Peter Ross	d89afe3839	Merge changes from the reuse branch back onto the main branch. ... Estimated hours taken: 0.25 Branches: main Merge changes from the reuse branch back onto the main branch. compiler/ml_unify_gen.m: Handle the case where the tag on the cell to be reused is unknown. compiler/hlds_goal.m: Add a field which records what possible cons_ids the cell to be reused can be tagged with. compiler/builtin_ops.m: Add the unary builtin operator strip_tag. compiler/bytecode.m: compiler/c_util.m: compiler/java_util.m: compiler/llds.m: compiler/mlds_to_il.m: compiler/opt_debug.m: bytecode/mb_disasm.c: bytecode/mb_exec.c: Handle the strip_tag operator.	2001-03-13 12:40:19 +00:00
Fergus Henderson	9d453c5a7b	Delete the `cast_to_unsigned' unary operator from builtin_ops, and ... Estimated hours taken: 4 Delete the `cast_to_unsigned' unary operator from builtin_ops, and replace it with an `unsigned_le' binary operator for doing unsigned less-then-or-equal comparisons. This change makes the semantics and typing of the builtin operators more consistent. compiler/builtin_ops.m: Delete the `cast_to_unsigned' unary_op. Add a new `unsigned_le' binary_op. compiler/dense_switch.m: compiler/lookup_switch.m: compiler/ml_simplify_switch.m: Use `binop(unsigned_le, X, Y)' rather than `binop(<=, unop(cast_to_unsigned, X), Y)'. compiler/bytecode.m: compiler/c_util.m: compiler/llds.m: compiler/llds_out.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/opt_debug.m: compiler/vn_util.m: compiler/vn_cost.m: Delete code for handling `cast_to_unsigned' and instead add code for handling `unsigned_le'. compiler/vn_cost.m: Also add `mktag' and `unmktag' as zero_cost_unops. compiler/c_util.m: Add a new procedure `c_util__unsigned_comparison_op', for use by llds_out.m.	2001-01-20 15:42:48 +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
Fergus Henderson	4be69fa961	Eliminated a lot of the dependencies on the the `code_model' type, ... Estimated hours taken: 6 Eliminated a lot of the dependencies on the the `code_model' type, and move that type from llds.m into a new module `code_model'. The aim of this change is to improve the modularity of the compiler by reducing the number of places in the compiler front-end that depend on back-end concepts and the number of places in the MLDS back-end which depend on the LLDS. compiler/code_model.m: New module. Contains the code_model type and associated procedures. compiler/llds.m: Move the code_model type into code_model.m. compiler/hlds_goal.m: Move the goal_info_get_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/hlds_out.m: Delete `hlds_out__write_code_model', since it wasn't being used. compiler/hlds_pred.m: Move the proc_info_interface_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/goal_path.m: When computing the `maybe_cut' field for `some' goals, compute it by comparing the determinism rather than by comparing the goal_infos. compiler/unique_modes.m: Use determinism and test for soln_count = at_most_many rather than using code_model and testing for model_non. compiler/inlining.m: Test for determinism nondet/multi rather than testing for code_model model_non. compiler/hlds_pred.m: compiler/det_report.m: Change valid_code_model_for_eval_method, which succeeded unless the eval_method was minimal_model and the code_model was model_det, to valid_determinism_for_eval_method, which succeeds unless the eval_method is minimal_model and the determinism cannot fail. As well as avoiding a dependency on code_model in the HLDS modules, this also fixes a bug where det_report could give misleading error messages, saying that `multi' was a valid determinism for `minimal_model' predicates, when in fact the compiler will always report a determinism error if you declare a `minimal_model' predicate with determinism `multi'. (Actually the code in which this bug occurs is in fact unreachable, but this is no doubt also a bug... I'll address that one in a separate change.) compiler/lookup_switch.m: Simplify the code a bit by using globals__lookup_*_option rather than globals__get_option and then getopt__lookup_option. compiler/*.m: Add `import_module' declarations for `code_model', and in some cases remove `import_module' declarations for `llds'.	2000-11-23 04:32:51 +00:00
Fergus Henderson	e6769ef622	Record the module that each instance declaration came from. ... Estimated hours taken: 8 Record the module that each instance declaration came from. This is needed for the IL back-end, which includes that module name in the symbol name that it generates for each instance declaration. compiler/prog_data.m: Add a module_name field to the `instance' item. compiler/prog_io_typeclass.m: When parsing `instance' declarations, store the module name that they came from in the module_name field of the `instance' item. compiler/hlds_data.m: Add a module_name field to the `hlds_instance_defn' structure. compiler/make_hlds.m: Copy the module_name field from the `instance' item to the `hlds_instance_defn' structure. compiler/polymorphism.m: Fix an old XXX: when constructing `base_typeclass_info_const's, use the module name from the `hlds_instance_defn', rather than hard-coding the invalid value "some bogus module name". compiler/rtti.m: Add a module_name field to the `base_typeclass_info' rtti_name and rtti_data. compiler/base_typeclass_info.m: Copy the module_name field in the `hlds_instance_defn' to the module_name field in the `base_typeclass_info' rtti_data and rtti_name. compiler/rtti_to_mlds.m: When constructing mlds `data_addr's, use the module_name from the `base_typeclass_info' rtti_name, rather than assuming that such references always refer to instance declarations in the current module. (That assumption would be a safe one currently, but doing it this way is probably a bit more robust against future changes.) compiler/*.m: Trivial changes to reflect the above data structure changes.	2000-11-01 05:12:14 +00:00
Simon Taylor	51732e925d	Reverse the order of the arguments of internal labels ... Estimated hours taken: 0.25 compiler/llds.m: compiler/*.m: Reverse the order of the arguments of internal labels to make comparison more efficient (the proc_labels will almost always be equal). This change reduces the time taken by `mmc -C make_hlds' by 1-2%.	2000-10-31 02:15:48 +00:00
Zoltan Somogyi	fdccd65e30	The debugger's retry command at the moment works only from a final port for ... Estimated hours taken: 60 The debugger's retry command at the moment works only from a final port for the call to be retried, the reason being that the RTTI does not have the information required to make sure that the state of the stacks is reset correctly. If you invoke retry from a non-final port, the current implementation skips forward to a final port and then does the retry; this does not work if you get a core dump or a infinite loop during the forward skip. This change adds the required info to the RTTI and thus enables direct retries from the middle of calls. The information added has two components. First, if a procedure that lives on the nondet stack allocates any temporary nondet stack frames, then it must record the old value of maxfr in a stack slot so that retry can restore it. Second, if a procedure is tabled, then it must record the call table tip node corresponding to the actual input arguments, so we can reset this node to uninitialized (if we don't, then the retried call will find the active call marker and report an infinite loop error). The support for retries across minimal model calls is not finished yet. Finding out what the right thing to do in such cases is a research project, one that cannot even be started until minimal model tabling works reliably in the *absence* of retries. However, such retries do grossly wrong things at the moment; this change is a definite improvement. It attempts to perform the retry from the fail port, since that is the only time when the minimal model tabling data structures are quiescent. The "fail" command I added to the debugger command set to let this be done is not complete yet and is therefore undocumented; the problem is that a call to a model_non predicate in a committed choice context will not get to the fail port. I added goal paths to return layouts so that we will eventually be able to tell when execution leaves a committed choice context surrounding an ancestor of a model_non predicate call, but this functionality is not yet implemented. compiler/stack_layout.m: Generate the three new fields: the evaluation method, (maybe) the id of the stack slot containing the saved value of maxfr, and (maybe) the id of the stack slot containing the call table tip. compiler/continuation_info.m: Record the information about the new fields for later use by stack_layout.m. Add a new field to record the goal path of calls for their return layouts. Fix a screwed comment for the continuation_info data structure. compiler/llds.m: Add a new field to call() instructions to hold the goal path of the call. Add a utility function for use by trace.m. compiler/call_gen.m: Fill in this new field. compiler/trace.m: compiler/live_vars.m: Reserve the fixed stack slot for the saved maxfr if necessary, and if the call table tip node is needed, make sure that the variable holding its address is allocated a low-numbered stack slot (otherwise, its number may not fit into the MR_int_least8_t field in the proc_layout). compiler/trace.m: If necessary, fill in the saved maxfr slot. If necessary, initialize the call table tip slot. compiler/hlds_goal.m: Add a goal feature which marks its goal as defining the variable representing the call table tip node. Add a field to the goal path step representing quantification; the field says whether the quantification changes the determinism of the goal (i.e. whether it cuts away solutions). compiler/hlds_pred.m: compiler/hlds_out.m: Add two fields to proc_infos which (a) record which variable, if any, holds the call table tip node, and (b) record whether the procedure's layout structure needs to reserve a slot for the saved value of maxfr. compiler/table_gen.m: Put this feature on the appropriate goal. Also, rename a predicate to make it reflect its purpose better. compiler/code_gen.m: Generate code to put the call table tip variable in its stack slot immediately after it has been generated. Add a sanity check to ensure that if a procedure that lives on the det stack can create a temporary nondet frame, and debugging is enabled, then it did have a stack slot reserved for the saved maxfr. compiler/code_util.m: Add a predicate to make a conservative prediction of whether a procedure may allocate a temporary nondet stack frame. We cannot just generate the code and see, because the code generator needs to know which variables live in which stack slots, and we cannot decide that until we know whether we need a stack slot for the saved value of maxfr. Make an unrelated predicate semidet procedure use a det helper, in order to make it more robust in the face of changes to the HLDS (e.g. it was missing code for handling bi_implications). compiler/code_info.m: Record whether a procedure has in fact created a temporary nondet stack frame. compiler/handle_options.m: Disable hijacks if debugging is enabled. The code we now use to restore the stacks for direct retries works only if the retry does not "backtrack" over a hijacked nondet stack frame whose hijack has not been undone. Note that code compiled without debugging may still hijack nondet stack frames. Execution may reemerge from the nondebugged region in one of two ways. If the nondebugged code returns, then it will have undone hijack, and the retry code will work. If the nondebugged code calls debugged code, there will be a region on the stacks containing no debugging information, and the retry command will refuse to perform retries that go into or beyond this region. Both cases preserve correctness. compiler/*.m: Trivial changes to conform to changes in data structures. runtime/mercury_stack_layout.h: Add three new fields to proc layouts: the numbers of the stack slots (if any) storing the saved maxfr and the call table tip, and a representation of the procedure's evaluation method. runtime/mercury_stack_trace.[ch]: Now that return layouts contain goal paths, print them in stack dumps only if the include_trace_data flag is set (in mdb, this requires the -d flag of the "stack" command). Pass this flag around directly, instead of encoding its value in the NULL vs non-NULL values of sp and curfr. runtime/mercury_regorder.h: Provide a mechanism to access the values of the first few rN registers from a save area, for use in debugging low-level C code in the runtime and the trace directories. trace/mercury_trace.[ch]: Reimplement MR_trace_retry to allow retries from the middle. If the stack segment being retried over contains minimal model procedures, we must still arrange to skip to the end of the retried call. If this call is a minimal model generator, skipping to just any final port is not sufficient to guarantee correctness on retry; to ensure that subgoal is complete, we must skip to a fail port. trace/mercury_trace.[ch]: trace/mercury_trace_internal.c: Implement a debugger command, "fail", which skips to the fail port or the exception port of the specified ancestor. Since procedures that are not model_non are not guaranteed to get to such a port, this command reports an error if the specified call is not model_non. Actually, even calls to model_non procedures may not get to the fail port, as explained above; this is why the command is not yet documented. trace/mercury_trace.c: trace/mercury_trace_util.[ch]: Move some functions to print parts of the Mercury abstract machine state from mercury_trace to mercury_trace_util, so that they are available for use in debugging e.g. mercury_trace_declarative. trace/mercury_trace_internal.c: trace/mercury_trace_external.c: trace/mercury_trace_declarative.c: Use the new implementation of retries. At the moment, only the internal debugger implements the full functionality. The declarative debugger issues retry commands only from situations where the missing functionality is not (yet) needed. The external debugger should continue to work correctly, but Erwan may wish to update it to exploit the availability of the fail command. trace/mercury_trace*.[ch]: Fix MR_prefixes, and a signed/unsigned mismatch. doc/user_guide.texi: Document the new "fail" command, but comment it out for now. tests/debugger/retry.{m,inp,exp,exp2}: A new test case for exercising retry. tests/debugger/Mmakefile: Enable the new test case. tests/debugger/*.exp: Update the expected output, given the extra info now output e.g. for exception events and detailed stack traces.	2000-10-13 04:06:52 +00:00
Peter Ross	35d1d914e7	Update the MLDS backend to handle structure reuse and compile time gc. ... Estimated hours taken: 20 Update the MLDS backend to handle structure reuse and compile time gc. Note that currently no pass on the main branch currently generates this information yet. mlds.m: Add a new instruction delete_object which is to be inserted whenever a lval can be compile time garbage collected. ml_unify_gen.m: Handle the case where the HowToConstruct field of a construction is reuse_cell(_). Handle the case where a deconstruction can be compile time gc'd. hlds_goal.m: Add a new field, can_cgc, to deconstruction unifications. This field is `yes' if the deconstruction unification can be compile time garbage collected. hlds_out.m: Output the can_cgc field. Output unification information if we request the structure reuse information. ml_elim_nested.m: mlds_to_c.m: Handle the delete_object instruction. builtin_ops.m: Fix a bug where body was an unary op instead of a binary op. bytecode.m: c_util.m: llds.m: opt_debug.m: vn_cost.m: Changes to reflect that body is a binary op. bytecode_gen.m: code_aux.m: common.m: cse_detection.m: dependency_graph.m: det_analysis.m: goal_util.m: higher_order.m: mark_static_terms.m: mode_util.m: modecheck_unify.m: pd_cost.m: pd_util.m: prog_rep.m: rl_exprn.m: rl_key.m: simplify.m: switch_detection.m: term_traversal.m: unify_gen.m: unused_args.m: Handle the can compile time gc field in deconstruction unifications.	2000-10-06 10:18:39 +00:00
Zoltan Somogyi	12af7b3793	Consistently use counters to allocate label numbers and cell numbers ... Estimated hours taken: 12 Consistently use counters to allocate label numbers and cell numbers throughout the LLDS backend. compiler/hlds_module.m: Change the module_info structure to store a counter instead of an integer for cell numbers. compiler/llds.m: Change the c_procedure structure to include a proc_label and a counter, to allow LLDS to LLDS optimizations to use this counter to allocate new label numbers. (The labels also include the proc_label.) compiler/code_info.m: Change the code_info structure to store counters instead of integers for both label numbers and cell numbers. compiler/code_gen.m: When creating the c_procedure, copy the final value of the counter from code_info to the c_procedure. compiler/opt_util.m: Delete the existing, inefficient procedure for allocating label numbers, and modify the interface of the get_prologue predicate to no longer return the proc_label (since it can now be looked up more directly). compiler/*.m: Minor changes to conform to the new data structures and to use counters instead of direct addition.	2000-08-11 08:19:24 +00:00
Fergus Henderson	4bb527330e	Implement typeclasses for the MLDS back-end. ... Estimated hours taken: 15 Implement typeclasses for the MLDS back-end. compiler/rtti.m: Add base_typeclass_info as a new alternative in the rtti_name and rtti_data types. compiler/base_typeclass_info.m: Change it to define base_typeclass_infos as rtti_data rather than comp_gen_c_data. compiler/mercury_compile.m: Modify to reflect the changes to base_typeclass_info.m's interface. Also change the order in which we run the MLDS passes: make sure to generate all the MLDS, including that generated by rtti_to_mlds.m, before running the MLDS transformation passes ml_tailcall.m and ml_elim_nested.m, since the wrapper functions that rtti_to_mlds.m generates for typeclass methods can contain code which those two MLDS transformation passes need to transform. compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/mlds_to_c.m: compiler/opt_debug.m: Handle base_typeclass_infos. compiler/mlds_to_c.m: Fix a bug where it was not properly mangling variable names. Note that polymorphism.m can introduce variable names that contain operators, e.g. `TypeClassInfo_for_+'. This bug broke tests/hard_coded/operator_classname.m. I also changed it to mangle label names. compiler/rtti_to_mlds.m: Pass down the module_info, so that ml_gen_init_method can use it when generate wrapper functions for type class methods. compiler/ml_unify_gen.m: Export the ml_gen_closure_wrapper procedure, for use by rtti_to_mlds for type class methods. compiler/ml_code_util.m: Add a new predicate `ml_gen_info_bump_func_label', for use by rtti_to_mlds.m when generating wrapper Add some functions defining magic numbers related to the representation of type_infos, base_typeclass_infos, and closures. compiler/ml_call_gen.m: Handle type class method calls. compiler/llds_out.m: Split the code for outputting a base_typeclass_info name into a separate subroutine, and export that subroutine, for use by rtti_out.m. compiler/llds_out.m: compiler/rtti_out.m: Change llds_out.m so that it calls a new predicate output_base_typeclass_info_storage_type_name, defined in rtti_out.m, when outputting base_typeclass_info declarations. This is needed because base_typeclass_infos are now defined as RTTI constants with type `Code * []', and so need to be handled as such by rtti_out.m rather than being assumed to be structs like the other LLDS data_names. Also move the code for handling dynamic initialization of method pointers from llds_out.m to rtti_out.m, at the same time changing it to handle their new definitions as rtti_data rather than comp_gen_c_data. compiler/mlds.m: Delete the type `base_data', since it is no longer needed. compiler/notes/type_class_transformation.html: Fix a documentation bug: the second field of base_typeclass_infos is the number of instance constraints, not the number of unconstrained type variables. compiler/notes/compiler_design.html: Document the use of the rtti modules in the MLDS back-end, and improve the documentation of their use in the LLDS back-end. runtime/mercury.h: Add a typedef for `MR_BaseTypeclassInfo', for use by the code generated by rtti_to_mlds.m and mlds_to_c.m for base_typeclass_infos. Also add another work-around declaration of an MR_TypeCtorInfo; with this, the browser directory now compiles.	2000-05-10 18:09:45 +00:00
Zoltan Somogyi	78e4768104	Fix a bug that was causing the compiler to output bogus declarations ... Estimated hours taken: 4 Fix a bug that was causing the compiler to output bogus declarations of nonexistent layout structures, using undefined C structure tags. For some reason, gcc accepted these declarations on all our platforms except taifun. compiler/llds.m: We used to have one field in pragma_c instructions that could name a label that cannot be renamed by optimizations. In some instructions, this label had a layout structure, in others it didn't. We now have two fields, one for labels that have layout structures and one for labels that don't. compiler/llds_out.m: Declare the C global variable holding the layout structure of a fixed (non-renamable) label referred to by a pragma_c instruction only if that label does have a layout structure. compiler/*.m: Minor changes to conform to the changes to pragma_c instructions.	2000-04-26 05:40:45 +00:00
Simon Taylor	7622eb1d36	Finish the implementation of Aditi updates. ... Estimated hours taken: 120 Finish the implementation of Aditi updates. compiler/hlds_goal.m: Refactor the aditi_builtin type so that operations with similar syntax and implementations are grouped together. Add operations to delete a single tuple (`aditi_delete') and to modify tuples (`aditi_bulk_modify'). compiler/*.m: Minor changes required by refactoring the aditi_builtin type. compiler/make_hlds.m: Parse `aditi_delete' and `aditi_bulk_modify' goals. Parse a nicer syntax for `aditi_bulk_delete' and `aditi_bulk_insert' goals (e.g. aditi_bulk_delete(p(_, X, _) :- X > 2)). compiler/rl_out.pp: For each base relation, generate RL procedures to apply deletions and modifications to the relation. `aditi_bulk_modify' takes a closure which produces tuples which contain both the attributes of the tuple to delete and the tuple to insert. The modification RL procedure performs two projections on the closure result to produce the tuples to delete and the tuples to delete. The input stream to the rl_PROC_delete RL instruction must contain only tuples taken from the relation to delete from -- the deletion is done using the tuple-id rather than the tuple contents. The generated deletion procedure performs a semi-join of the relation to delete from with the relation containing the tuples to delete. compiler/rl.m: Add predicates to generate the names of the modification and deletion RL procedures generated for each base relation. compiler/rl_exprn.m: Generate the projection expressions required by the modification RL procedures generated for each base relation. Generate the equi-join expressions required by the modification and deletion RL procedures generated for each base relation. compiler/unify_gen.m: Implement code generation for `aditi_bottom_up' closures. compiler/rl.m: compiler/magic.m: Factor out the code used to create the name of the RL procedure used to interface top-down Mercury to Aditi, for use by unify_gen.m to generate `aditi_bottom_up' closures. compiler/code_util.m: Add predicate code_util__make_user_proc_label, which constructs a label name from the given all the individual pieces of information used to construct it, rather than just a pred_id and proc_id. This is used to produce the RL procedure name for an `aditi_bottom_up' closure, so that the code doesn't have to work out what the pred_id of the magic sets transformed procedure is. compiler/magic.m: Always create new procedures to interface Mercury to Aditi, to make it easier for unify_gen.m to work out what the name of the interface procedure is -- don't optimize the case of a predicate with no input arguments. Alter the goal generated for the interface procedures so that it doesn't matter whether the interface procedure and the procedure it interfaces to are compiled together by rl_gen.m -- the old code generated for these procedures assumed they were compiled separately, which wasn't always the case. Don't pass a `magic_info' through the code to generate the C interface procedures -- only the module_info field was required. compiler/magic_util.m: compiler/magic.m: compiler/context.m: Don't pass a `magic_info' through magic_util__create_input_test_unifications -- only the module_info and proc_info fields were used. compiler/post_typecheck.m: compiler/magic_util.m: Don't report errors for the second `aditi__state' argument of the closure passed to `aditi_bulk_modify'. compiler/purity.m: Change the mode of the second `aditi__state' argument of the closure passed to `aditi_bulk_modify' to `unused'. compiler/call_gen.m: Generate `aditi_delete' and `aditi_bulk_modify'. Remove the `aditi__state' from the tuple to insert passed to an `aditi_insert' or `aditi_delete' operation -- the relation on disk does not contain the `aditi__state' attribute. extras/aditi/aditi.m: Implement the updates. Allocate all memory on the Mercury heap to avoid memory leaks when a transaction aborts. Uncaught exceptions within a transaction now cause the transaction to abort, and the exception is rethrown to the caller. If using trailing, add trail entries for the output relation and cursor created for a call to an Aditi procedure, so that they will be cleaned up if only one solution of the call is needed or if an exception is thrown. Include line numbers in the debugging messages if an Aditi API function fails. compiler/llds.m: compiler/*.m: Rename the `do_aditi_modify' label to `do_aditi_bulk_modify' -- we may eventually want to implement a modification goal type which doesn't produce all modified tuples before applying the update. doc/reference_manual.texi: Document `aditi_delete' and `aditi_bulk_modify'. Add some extra spacing in the Aditi update section to improve readability. tests/valid/aditi_update.m: tests/invalid/aditi_update_errors.m: tests/invalid/aditi_update_errors.err_exp: tests/invalid/aditi_update_mode_errors.m: tests/invalid/aditi_update_mode_errors.err_exp: Changed to fit in with the new syntax. tests/valid/Mmakefile: Code generation for Aditi updates now works, so enable full compilation of the aditi_update.m test case, rather than just checking for errors.	2000-04-14 08:39:24 +00:00
Fergus Henderson	cbbd48080f	Restructure the handling of RTTI and pseudo_type_infos ... Estimated hours taken: 30 Restructure the handling of RTTI and pseudo_type_infos to reduce dependencies on the LLDS. compiler/rtti.m: - Change the various occurrences of llds__rval to rtti_data. - Add `field_types' and `pseudo_type_info' as new alternatives in the rtti_data and rtti_name types, to provide ways of representing things that were previously represented as create() llds__rvals. compiler/rtti_out.m: - Add some documentation to the interface. - Modify to handle the changes to rtti.m. compiler/type_ctor_info.m: - Modify to handle the changes to rtti.m. - Don't thread the cell_count or module_info through most of the code here, since it is no longer necessary. - Modify the interface to eliminate dependency on LLDS: change generate_llds to return a list(rtti_data) rather than a list(llds__comp_gen_c_data), and rename it as generate_rtti. compiler/mercury_compile.m: Update to reflect the changed interface to type_ctor_info.m. compiler/pseudo_type_info.m: Rewrite much of this module to eliminate all dependencies on LLDS. Rather than generating an llds__rval, this module now generates a new type pseudo_type_info (which is used in the pseudo_type_info alternative of the rtti_data type). compiler/ll_pseudo_type_info.m: New file, contains the parts of pseudo_type_info.m that depended on LLDS. This is needed for stack_layout.m, which still needs pseudo_type_infos represented as llds__rvals. compiler/stack_layout.m: Call the routines in ll_pseudo_type_info rather than those in pseudo_type_info. compiler/llds_common.m: Don't traverse rtti_data rvals, since they can't contain create() rvals anymore. compiler/opt_debug.m: Handle the new `field_types' and `pseudo_type_info' alternatives in the rtti_data and rtti_name types. compiler/rtti.m: compiler/rtti_out.m: compiler/llds_out.m: The predicate `rtti_address_would_include_code_addrs' was duplicated in both rtti.m and rtti_out.m. I deleted the version in rtti.m, exported the version in rtti_out.m, and changed llds_out.m to call the version in rtti_out.m. runtime/mercury_type_info.h: - Define macros for defining MR_TypeInfo and MR_PseudoTypeInfo struct types of different arities, for use by the code generated by compiler/rtti_out.m. - Define MR_TypeCtorInfo as a pointer to a _const_ struct type, to avoid the need to generate casts to cast-away-const in various places in compiler/rtti_out.m. Likewise for MR_PseudoTypeInfo. (It would be nice to do the same thing for MR_TypeInfo, since we never modify MR_TypeInfo values after constructing them, but currently they are modified by the MR_fill_in_*() macros which are used to construct them.) - Fix a couple of places where macro arguments were not properly parenthesized.	2000-04-02 08:09:50 +00:00
Fergus Henderson	84c8146d0d	Fix several bugs in the trail handling. ... Estimated hours taken: 20 Fix several bugs in the trail handling. Also improve the documentation of trailing, and add a new macro MR_choicepoint_newer() to the public trailing interface. The bugs which this change fixes are: - choice point ids were being reused after commits, rather than only after backtracking; - for if-then-elses with nondet conditions, the generated code was using MR_commit rather than MR_solve as the MR_untrail_reason; - for semidet disjunctions, when committing to a particular disjunct the generated code was not calling MR_reset_ticket(..., MR_commit) to invoke function trail entries, and was also leaking a trail ticket - the all-solutions predicates in std_util.m were leaking trail tickets (i.e. allocating them but not pruning or discarding them). runtime/mercury_trail.h: runtime/mercury_regorder.h: runtime/mercury_regs.h: runtime/mercury_wrapper.c: runtime/mercury_context.h: runtime/mercury_engine.h: A bunch of changes to add a new virtual register `MR_ticket_high_water': - in mercury_trail.h, add MR_ticket_high_water_var variable; - in mercury_regorder.h, add MR_ticket_high_water macro; - in mercury_regs.h, add MR_TICKET_HIGH_WATER_RN macro; - in mercury_wrapper.c, change print_register_usage_counts() to handle MR_TICKET_HIGH_WATER_RN. - in mercury_context.h and mercury_engine.h, add code to save/restore this new register when appropriate. runtime/mercury_trail.h: - Change MR_store_ticket() so that it does `MR_ticket_counter = ++MR_ticket_high_water' rather than just `MR_ticket_counter++'. - Add new macros MR_prune_ticket() and MR_prune_tickets_to(), which only reset MR_ticket_counter, not MR_ticket_high_water. - Change the old macros MR_discard_ticket() and MR_discard_tickets_to() so that they reset both MR_ticket_high_water and MR_ticket_counter. - Add new macro MR_choicepoint_newer(). - Enclose macro arguments in parentheses. - Some minor changes to the documentation. doc/reference_manual.texi: Document MR_choicepoint_newer(). Update the documentation to reflect the fact that exceptions are now a standard part of Mercury. Clarify the documentation in the "Avoiding Redundant Trailing" section, and add a longish example. compiler/notes/trailing.html: Add some documentation on the trail and how we manage it. compiler/llds.m: compiler/mlds.m: Add new `prune_ticket' and `prune_tickets_to' instructions, corresponding to the new macros defined in runtime/mercury_trail.h. Comment out the `discard_tickets_to' instruction, since it is no longer used in the compiler (the MR_discard_tickets_to() macro is only used by library/exception.m and the debugger's retry command). Replace the duplicated documentation in mlds.m with a pointer to llds.m. compiler/ite_gen.m: compiler/code_gen.m: compiler/code_info.m: Change the trail handling code generated after commits so that the ticket is pruned rather than discarded. compiler/ite_gen.m: When generating the reset_ticket instruction for if-then-elses with nondet conditions, use `solve' rather than `commit' as the reset_trail_reason. compiler/disj_gen.m: Add code to generate a reset_ticket(..., commit) instruction at the end of every non-last disjunct in semidet disjunctions. compiler/dupelim.m: compiler/livemap.m: compiler/llds_common.m: compiler/llds_out.m: compiler/ml_elim_nested.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/value_number.m: compiler/vn_*.m: Trivial modifications to handle the changes to the trailing instructions. library/exception.m: Change the trail handling code so that when the goal in an exception handler succeeds (rather than failing or throwing an exception), the trail ticket we created on entry to the handler is pruned rather than discarded. library/std_util.m: Add a new impure predicate `discard_trail_ticket', which calls MR_discard_ticket(), and call it in `builtin_aggregate' and `do_while' to discard the ticket that gets allocated by the call to MR_store_ticket() in `get_registers'.	2000-03-20 05:27:30 +00:00
Zoltan Somogyi	4ccc3b32ac	Cleanup of the type_ctor_infos and their components, to achieve two goals. ... Estimated hours taken: 65 Cleanup of the type_ctor_infos and their components, to achieve two goals. First, the new data structure is defined in strongly typed C, with only two unions, whereas the old data structure was defined by a bunch of macros that used casts all over the place. The new design should therefore make it significantly easier to debug code that uses RTTI, and to get it right in the first place. Second, the new data structures are logically organized, whereas the old ones had several bad features (such as fixed fields coming after variable-length arrays in "structures") required by backward compatibility. For the time being, the runtime system will be able to handle type_ctor_infos using both the old and the new data structures, which are distinguished by the type_ctor_info's version number. To minimize the disruption caused by such bootstrapping, this change also incorporates an improvement in the RTTI: for most pseudo_type_infos included in the RTTI, it records information that allows the runtime system to tell whether the pseudo_type_info is ground or not; if it is, then the runtime need not scan the pseudo_type_info looking for type parameters to expand. Based on statistics I have gathered, this will eliminate between half and two thirds of all such scans when we do unification and comparison by RTTI. This change does not impact the structures of typeinfos, base_typeclass_infos or typeclass_infos. runtime/mercury_type_info.h: Define the C types for the new type_ctor_info components. Update the C type for type_ctor_infos themselves, and the macros that act on it. Centralize the list of files that depend on type info representation here. Make the names of the two macros that give the number of (all kinds of) type info vars and the number of existential type info vars consistent. runtime/mercury_std.h: Change a comment to refer to one of these renamed macros by its new name. compiler/rtti.m: compiler/rtti_out.m: New files: rtti.m defines new types that allow us to construct Mercury representations of the C structures we want to emit, and rtti_out.m converts those representations to C definitions. These files are intended to be independent of whether the backend is LLDS or MLDS. At the moment, there are several vestiges that tie them to LLDS, mostly due to (a) the lack of a shared common infrastructure between llds_out.m and mlds_to_c.m, and (b) the continued use of the old representation of (pseudo-) typeinfos as rvals. These concerns will be addressed in a future change. compiler/llds.m: Update the definition of the comp_gen_c_data and data_addr types to account for the new RTTI structures. compiler/llds_out.m: Update the code to output comp_gen_c_data and data_addr values to account for the new RTTI structures. Make some parts of the code more modular, so that rtti_out.m can use what used to be selected parts of predicates. Export several predicates for use by rtti_out.m. Some of these should later be moved to a file for infrastructure shared by llds_out.m and mlds_to_*.m. Others should be made internal again when the representation of typeinfos is made independent of the LLDS. Rename some predicates to better reflect their purpose. compiler/base_type_layout.m: compiler/base_type_info.m: These files are obsoleted by this change. They remain in CVS, but are no longer used. All of base_type_info.m has been moved into type_ctor_info.m, and so have the parts of base_type_layout.m that create the functors and layout structures inside type_ctor_infos; the remaining part of base_type_layout.m is now in pseudo_type_info.m. compiler/pseudo_type_info.m: New file containing the code to create pseudo_type_infos from base_type_layout.m, slightly updated for the new compiler structure. compiler/type_ctor_info.m: New module: almost total rewrite of the base_type_info.m and the relevant part of base_type_layout.m for the new data structure. Do not invoke base_typeclass_info.m, since the structures it creates are not parts of the type_ctor_infos. compiler/ml_base_type_info.m: Comment out obsolete unfinished code. It should be replaced by calls to type_ctor_info, once type_ctor_info's dependence on LLDS has been eliminated. compiler/hlds_module.m: Rename the data structure from which type_ctor_infos are generated. Delete the data structure from which type_ctor_layouts were generated, since it is redundant. Switch to using field names. compiler/make_tags.m: compiler/hlds_data.m: make_tags.m had code that duplicated much of the the functionality of an existing predicate in hlds_data.m. This change moves that predicate to hlds_data where it belongs, and gives it an appropriate name. compiler/mercury_compile.m: Do not invoke the predicates that used to be in base_type_layouts directly; let type_ctor_info do it for the types for which it is appropriate. Do invoke base_typeclass_info directly. compiler/dead_proc_elim.m: compiler/llds_common.m: compiler/opt_debug.m: compiler/stack_layout.m: compiler/unify_gen.m: Trivial changes to conform to the changes in the representation of compiler-generated C data. compiler/notes/compiler_design.html: Updates to reflect the new files. runtime/mercury_deep_copy_body.h: runtime/mercury_tabling.c: runtime/mercury_type_info.c: Provide alternate implementations of functionality that used the old functors and layout structures, to use the new ones instead if the relevant type_ctor_info's version number calls for it. In many cases, doing this cleanly required reducing the scopes of variables. runtime/mercury_tabling.[ch]: Note where additional work on tabling of typeclass infos is needed, but do not do the work yet, since it would conflict with DJ's coming change. library/std_util.m: Provide alternate implementations of functionality that used the old functors and layout structures, to use the new ones instead if the relevant type_ctor_info's version number calls for it. In many cases, doing this cleanly required reducing the scopes of variables. The predicates get_functor and construct take an integer argument that identifies a functor of a du type. The integer used to be the functor's ordinal number in the type definition, but this was not documented. It is now the functor's position in the list of the type's functors sorted first on name and then on arity. This functionality is potentially more useful, since io__read could do binary instead of linear search when looking for a given functor. This is an incompatibility, but a very minor one. Add a new predicate, get_functor_ordinal, to provide a way to convert lexicographic position into ordinal position. This is not used yet. Rename the two different kinds of variables named "info" so that one can tell them apart. tests/hard_coded/construct.exp: Update the expected output of this test based on the new definition of the meaning of functor numbers in the get_functor and construct predicates in std_util. tests/hard_coded/deep_copy.{m,exp}: Add some code to test the "type contains var" bit vector in du functor descriptions. tests/hard_coded/existential_rtti.{m,exp}: Make the test case print out results as it goes along, to make it easier which subtask a core dump is coming from. Update the expected output accordingly.	2000-03-10 13:38:21 +00:00
Simon Taylor	3a26ad82d5	Add information required for structure reuse and compile time garbage ... Estimated hours taken: 2 Add information required for structure reuse and compile time garbage collection to the LLDS. The code generator does not yet generate this information. This will be committed to the main branch to avoid CVS conflicts. compiler/llds.m: Add an LLDS instruction `free_heap(rval)', which applies the MR_free_heap macro to its argument. Add a `maybe(rval)' field to `create' rvals to hold the address of a cell to reuse. This field should always be `no' after code generation, because all non-constant creates are converted into lower-level operations during code generation. compiler/value_number.m: Don't reorder instructions around a `free_heap' instruction to avoid generating code which looks at deallocated memory. compiler/*.m: Handle the new instruction and field.	2000-01-14 01:11:11 +00:00
Zoltan Somogyi	f0964815a3	Support line numbers in the debugger. You now get contexts (filename:lineno ... Estimated hours taken: 40 Support line numbers in the debugger. You now get contexts (filename:lineno pairs) printed in several circumstances, and you can put breakpoints on contexts, when they correspond to trace events or to calls. The latter are implemented as breakpoints on the label layouts of the return sites. This required extending the debugging RTTI, so that associated with each module there is now a new data structure listing the source file names that contribute labels with layout structures to the code of the module. For each such source file, this table gives a list of all such labels arising from that file. The table entry for a label gives the line number within the file, and the pointer to the label layout structure. compiler/llds.m: Add a context field to the call instruction. compiler/continuation_info.m: Instead of the old division of continuation info about labels into trace ports and everything else, divide them into trace ports, resume points and return sites. Record contexts with trace ports, and record contexts and called procedure information with return sites. compiler/code_info.m: Conform to the changes in continuation_info.m. compiler/options.m: Add a new option that allows us to disable the generation of line number information for size benchmarking (it has no other use). compiler/stack_layout.m: Generate the new components of the RTTI, unless the option says not to. compiler/code_gen.m: compiler/pragma_c_gen.m: compiler/trace.m: Include contexts in the information we gather for the layouts associated with the events we generate. compiler/call_gen.m: Include contexts in the call LLDS instructions, for association with the return site's label layout structure (which is done after code generation is finished). compiler/handle_options.m: Delete the code that tests or sets the deleted options. compiler/mercury_compile.m: Delete the code that tests the deleted options. compiler/basic_block.m: compiler/dupelim.m: compiler/frameopt.m: compiler/livemap.m: compiler/llds_common.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/value_number.m: compiler/vn_*.m: Trivial changes to conform to the changes to llds.m. compiler/jumpopt.m: Do not optimize away jumps to labels with layout structures. The jumps we are particularly concerned about now are the jumps that return from procedure calls. Previously, it was okay to redirect returns from several calls so that all go to the same label, since the live variable information associated with the labels could be merged. However, we now also associate line numbers with calls, and these cannot be usefully merged. compiler/optimize.m: Pass the information required by jumpopt to it. doc/user_guide.texi: Document that you can now break at line numbers. Document the new "context" command, and the -d or --detailed option of the stack command and the commands that set ancestor levels. runtime/mercury_stack_layout.h: Extend the module layout structure definition with the new tables. Remove the conditional facility for including label numbers in label layout structures. It hasn't been used in a long time, and neither Tyson or me expect to use it to debug either gc or the debugger itself, so it has no uses left; the line numbers have superseded it. runtime/mercury_stack_trace.[ch]: Extend the code to print stack traces to also optionally print contexts. Add some utility predicates currently used by the debugger that could also be use for debugging gc or for more detailed stack traces. trace/mercury_trace_internal.c: Implement the "break <context>" command, the "context" command, and the -d or --detailed option of the stack command and the commands that set ancestor levels. Conditionally define a conditionally used variable. trace/mercury_trace_external.c: Minor changes to keep up with the changes to stack traces. Delete an unused variable. trace/mercury_trace_spy.[ch]: Check for breakpoints on contexts. trace/mercury_trace_tables.[ch]: Add functions to search the RTTI data structures for labels corresponding to a given context. trace/mercury_trace_vars.[ch]: Remember the context of the current environment. tests/debugger/queen.{inp,exp}: Test the new capabilities of the debugger. tests/debugger/*.{inp,exp}: Update the expected output of the debugger to account for contexts. In some cases, modify the input script to put contexts where they don't overflow lines.	1999-11-15 00:43:59 +00:00
Zoltan Somogyi	89065f0a1e	Fix a bug in frameopt reported by Serge Varennes on April 15, 1999. ... Estimated hours taken: 8 Fix a bug in frameopt reported by Serge Varennes on April 15, 1999. The bug was that frameopt recognized that a procedure did not need a stack frame, and deleted the frame setup code, but did not redirect the failure branches inside inlined model_semi pragma_c instructions, so that they still led to code that deallocated the (now nonexistent) stack frame. This meant that calls to this procedure violated the invariant which says that calls leave MR_sp unchanged. compiler/llds.m: Add a new pragma C component (pragma_c_fail_to) that represents the branch to a label on failure of a model_semi piece of C code, instead of handling this by generating a string containing the C code that branches to this label. Record the failure label as a new field in pragma_c instructions. The point of this change is that it makes it possible to substitute the failure label in frameopt. Add also a pragma_c_noop component to make the generated code somewhat better optimizable. compiler/pragma_c_gen.m: Generate the new LLDS components. compiler/llds_out.m: Output the new LLDS components. Move a predicate declaration away from the middle of another predicate. compiler/frameopt.m: Perform substitutions on pragma C code labels that occur only in pragma_c_fail_to components. If a pragma_c instruction has any other references to labels, we now assume that the block containing the instruction needs a stack frame, since those labels can't be substituted with their non-teardown parallels if this block is moved to a context without a stack frame. compiler/basic_block.m: compiler/dupelim.m: compiler/frameopt.m: compiler/opt_util.m: Both basic_block.m and dupelim.m had code that substantially duplicated code in frameopt.m. This change factors out the differences among the versions and moves the unified predicates to opt_util.m. compiler/code_gen.m: compiler/code_info.m: compiler/dupelim.m: compiler/livemap.m: compiler/llds_common.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/trace.m: compiler/value_number.m: compiler/vn_*.m: Trivial updates to conform to the changes in llds.m. tests/hard_coded/frameopt_pragma_redirect.{m,exp}: A new test case that exhibits the problem. (It is not the original test cases submitted by Serge Varennes, because that code depended on non-standard functions in ieeefp.h.) tests/hard_coded/Mmakefile: Enable the new test case.	1999-11-12 03:47:08 +00:00
Zoltan Somogyi	5aa3e6134c	Shallow traced procedures do not fill in most of their stack slots holding ... Estimated hours taken: 6 Shallow traced procedures do not fill in most of their stack slots holding debugging information unless they are called from deep traced code, yet the code in the runtime that handles redo events for such procedures was using the values in those slots. This changes fixes that problem, by adding another piece of code in the runtime for handling redo events for shallow traced procedures. compiler/llds.m: Rename do_trace_redo_fail as do_trace_redo_fail_deep and add a new label, do_trace_redo_fail_shallow. compiler/trace.m: Select which label gets included as the redoip in the temporary frame that generates redo events, and document the assumptions about stack slots used by the new label. compiler/dupelim.m: compiler/exprn_aux.m: compiler/livemap.m: compiler/llds_out.m: compiler/opt_debug.m: compiler/opt_util.m: Conform to the changes in llds.m. runtime/mercury_trace_base.c: Add the label and code for handling redo events in shallow traced procedures. runtime/mercury_stack_layout.h: Add a macro used by mercury_trace_base.c. tests/debugger/shallow.{m,inp,exp}: New test case. It is the same code as queens.m, but compiled with shallow tracing. It segfaults before but not after this change. tests/debugger/Mmakefile: Enable the new test case. Comment out a rule for a disabled test case, to avoid make warnings.	1999-08-24 08:52:06 +00:00
Simon Taylor	2725b1a331	Aditi update syntax, type and mode checking. ... Estimated hours taken: 220 Aditi update syntax, type and mode checking. Change the hlds_goal for constructions in preparation for structure reuse to avoid making multiple conflicting changes. compiler/hlds_goal.m: Merge `higher_order_call' and `class_method_call' into a single `generic_call' goal type. This also has alternatives for the various Aditi builtins for which type declarations can't be written. Remove the argument types field from higher-order/class method calls. It wasn't used often, and wasn't updated by optimizations such as inlining. The types can be obtained from the vartypes field of the proc_info. Add a `lambda_eval_method' field to lambda_goals. Add a field to constructions to identify which RL code fragment should be used for an top-down Aditi closure. Add fields to constructions to hold structure reuse information. This is currently ignored -- the changes to implement structure reuse will be committed to the alias branch. This is included here to avoid lots of CVS conflicts caused by changing the definition of `hlds_goal' twice. Add a field to `some' goals to specify whether the quantification can be removed. This is used to make it easier to ensure that indexes are used for updates. Add a field to lambda_goals to describe whether the modes were guessed by the compiler and may need fixing up after typechecking works out the argument types. Add predicate `hlds_goal__generic_call_id' to work out a call_id for a generic call for use in error messages. compiler/purity.m: compiler/post_typecheck.m: Fill in the modes of Aditi builtin calls and closure constructions. This needs to know which are the `aditi__state' arguments, so it must be done after typechecking. compiler/prog_data.m: Added `:- type sym_name_and_arity ---> sym_name/arity'. Add a type `lambda_eval_method', which describes how a closure is to be executed. The alternatives are normal Mercury execution, bottom-up execution by Aditi and top-down execution by Aditi. compiler/prog_out.m: Add predicate `prog_out__write_sym_name_and_arity', which replaces duplicated inline code in a few places. compiler/hlds_data.m: Add a `lambda_eval_method' field to `pred_const' cons_ids and `pred_closure_tag' cons_tags. compiler/hlds_pred.m: Remove type `pred_call_id', replace it with type `simple_call_id', which combines a `pred_or_func' and a `sym_name_and_arity'. Add a type `call_id' which describes all the different types of call, including normal calls, higher-order and class-method calls and Aditi builtins. Add `aditi_top_down' to the type `marker'. Remove `aditi_interface' from type `marker'. Interfacing to Aditi predicates is now handled by `generic_call' hlds_goals. Add a type `rl_exprn_id' which identifies a predicate to be executed top-down by Aditi. Add a `maybe(rl_exprn_id)' field to type `proc_info'. Add predicate `adjust_func_arity' to convert between the arity of a function to its arity as a predicate. Add predicates `get_state_args' and `get_state_args_det' to extract the DCG state arguments from an argument list. Add predicate `pred_info_get_call_id' to get a `simple_call_id' for a predicate for use in error messages. compiler/hlds_out.m: Write the new representation for call_ids. Add a predicate `hlds_out__write_call_arg_id' which replaces similar code in mode_errors.m and typecheck.m. compiler/prog_io_goal.m: Add support for `aditi_bottom_up' and `aditi_top_down' annotations on pred expressions. compiler/prog_io_util.m: compiler/prog_io_pragma.m: Add predicates - `prog_io_util:parse_name_and_arity' to parse `SymName/Arity' (moved from prog_io_pragma.m). - `prog_io_util:parse_pred_or_func_name_and_arity to parse `pred SymName/Arity' or `func SymName/Arity'. - `prog_io_util:parse_pred_or_func_and_args' to parse terms resembling a clause head (moved from prog_io_pragma.m). compiler/type_util.m: Add support for `aditi_bottom_up' and `aditi_top_down' annotations on higher-order types. Add predicates `construct_higher_order_type', `construct_higher_order_pred_type' and `construct_higher_order_func_type' to avoid some code duplication. compiler/mode_util.m: Add predicate `unused_mode/1', which returns `builtin:unused'. Add functions `aditi_di_mode/0', `aditi_ui_mode/0' and `aditi_uo_mode/0' which return `in', `in', and `out', but will be changed to return `di', `ui' and `uo' when alias tracking is implemented. compiler/goal_util.m: Add predicate `goal_util__generic_call_vars' which returns any arguments to a generic_call which are not in the argument list, for example the closure passed to a higher-order call or the typeclass_info for a class method call. compiler/llds.m: compiler/exprn_aux.m: compiler/dupelim.m: compiler/llds_out.m: compiler/opt_debug.m: Add builtin labels for the Aditi update operations. compiler/hlds_module.m: Add predicate predicate_table_search_pf_sym, used for finding possible matches for a call with the wrong number of arguments. compiler/intermod.m: Don't write predicates which build `aditi_top_down' goals, because there is currently no way to tell importing modules which RL code fragment to use. compiler/simplify.m: Obey the `cannot_remove' field of explicit quantification goals. compiler/make_hlds.m: Parse Aditi updates. Don't typecheck clauses for which syntax errors in Aditi updates are found - this avoids spurious "undefined predicate `aditi_insert/3'" errors. Factor out some common code to handle terms of the form `Head :- Body'. Factor out common code in the handling of pred and func expressions. compiler/typecheck.m: Typecheck Aditi builtins. Allow the argument types of matching predicates to be adjusted when typechecking the higher-order arguments of Aditi builtins. Change `typecheck__resolve_pred_overloading' to take a list of argument types rather than a `map(var, type)' and a list of arguments to allow a transformation to be performed on the argument types before passing them. compiler/error_util.m: Move the part of `report_error_num_args' which writes "wrong number of arguments (<x>; expected <y>)" from typecheck.m for use by make_hlds.m when reporting errors for Aditi builtins. compiler/modes.m: compiler/unique_modes.m: compiler/modecheck_call.m: Modecheck Aditi builtins. compiler/lambda.m: Handle the markers for predicates introduced for `aditi_top_down' and `aditi_bottom_up' lambda expressions. compiler/polymorphism.m: Add extra type_infos to `aditi_insert' calls describing the tuple to insert. compiler/call_gen.m: Generate code for Aditi builtins. compiler/unify_gen.m: compiler/bytecode_gen.m: Abort on `aditi_top_down' and `aditi_bottom_up' lambda expressions - code generation for them is not yet implemented. compiler/magic.m: Use the `aditi_call' generic_call rather than create a new procedure for each Aditi predicate called from C. compiler/rl_out.pp: compiler/rl_gen.m: compiler/rl.m: Move some utility code used by magic.m and call_gen.m into rl.m. Remove an XXX comment about reference counting being not yet implemented - Evan has fixed that. library/ops.m: compiler/mercury_to_mercury.m: doc/transition_guide.texi: Add unary prefix operators `aditi_bottom_up' and `aditi_top_down', used as qualifiers on lambda expressions. Add infix operator `==>' to separate the tuples in an `aditi_modify' call. compiler/follow_vars.m: Thread a `map(prog_var, type)' through, needed because type information is no longer held in higher-order call goals. compiler/table_gen.m: Use the `make_*_construction' predicates in hlds_goal.m to construct constants. compiler/*.m: Trivial changes to add extra fields to hlds_goal structures. doc/reference_manual.texi: Document Aditi updates. Use @samp{pragma base_relation} instead of @samp{:- pragma base_relation} throughout the Aditi documentation to be consistent with other parts of the reference manual. tests/valid/Mmakefile: tests/valid/aditi_update.m: tests/valid/aditi.m: Test case. tests/valid/Mmakefile: Remove some hard-coded --intermodule-optimization rules which are no longer needed because `mmake depend' is now run in this directory. tests/invalid/*.err_exp: Fix expected output for changes in reporting of call_ids in typecheck.m. tests/invalid/Mmakefile tests/invalid/aditi_update_errors.{m,err_exp}: tests/invalid/aditi_update_mode_errors.{m,err_exp}: Test error messages for Aditi updates. tests/valid/aditi.m: tests/invalid/aditi.m: Cut down version of extras/aditi/aditi.m to provide basic declarations for Aditi compilation such as `aditi__state' and the modes `aditi_di', `aditi_uo' and `aditi_ui'. Installing extras/aditi/aditi.m somewhere would remove the need for these.	1999-07-13 08:55:28 +00:00
Fergus Henderson	773bd702cc	Some more changes to minimize the complexity of the intermodule dependencies. ... Estimated hours taken: 2.5 Some more changes to minimize the complexity of the intermodule dependencies. In particular, ensure that bytecode.m does not need to import llds.m. compiler/llds.m: compiler/builtin_ops.m: Move the definitions of the unary_op and binary_op types into a new module `builtin_ops'. These types are used by three of the different back-ends (bytecode, llds, and mlds) and therefore deserve to be in their own module. compiler/bytecode.m: Define a type `byte_reg_type' and use that instead of llds__reg_type. Delete the import of module llds. compiler/notes/compiler_design.html: Document the new module builtin_ops. compiler/rl_exprn.m: Add a comment explaining why we need to import llds (and builtin_ops). compiler/base_type_layout.m: compiler/bytecode.m: compiler/code_util.m: compiler/dense_switch.m: compiler/ite_gen.m: compiler/jumpopt.m: compiler/llds_out.m: compiler/lookup_switch.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/rl_exprn.m: compiler/string_switch.m: compiler/tag_switch.m: compiler/transform_llds.m: compiler/unify_gen.m: compiler/value_number.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_flush.m: compiler/vn_type.m: compiler/vn_util.m: compiler/vn_verify.m: Add imports of module builtin_ops to lots of modules that imported llds.	1999-07-10 07:20:09 +00:00
Zoltan Somogyi	e3232306cb	Add a module layout structure containing a string table and a table of ... Estimated hours taken: 14 Add a module layout structure containing a string table and a table of pointers to the proc layouts of the module's procedures. This speeds up debugger initialization, and reduces the executable size of the compiler by almost 1.2 Mb (about 3.7%) when compiled with debugging. Instead of representing variables names as strings (32 or 64 bit pointers) in the debugger's static data structures, with the string's prefix representing the variable's number (e.g. "5:X"), represent them as a 16-bit variable number and a 16 bit offset into the module-wide string table. This gains simplicity of processing (no more search for the ":") and reduces the amount of storage required, a bit on 32-bit platforms (we don't have to store "5:ModuleInfo" and "10:ModuleInfo" strings separately, and there are no string prefixes to store) and more on 64-bit platforms. The 16-bit limits are generous. A procedure with more than 64K variables will take forever to compile (that is why we impose a 4K limit on the number of variables in inlining), and even the string tables of typecheck.m and make_hlds require less than four kilobytes each. Exceeding the limits would require code no human would write. Automatically generated code may be a problem, but the help the debugger can give on such code is limited already. In any case, we detect overflows and handle them sensibly. This change does not enhance the debugger to take advantage of the easier availability of variable numbers, except to improve the implementation of retry; that will come later. The inclusion of the procedure table in the module layout structure reduces the cost of registering all procedures in all modules, a task usually performed at the time of the setting of the first breakpoint. This used to require processing all the internal labels in the label table, and thus used to take a few seconds for large executables. The sweep of all internal labels is no longer required, so registering is now much faster. runtime/mercury_stack_layout.h: Add the definition of MR_Module_Layout. Modify label layouts to represent names as offsets in the string table, not as raw character pointers. This required modifing proc layouts to include a pointer to the module's layout, so you can find the string table. Update the macros that look up variable names. runtime/mercury_layout_util.h: Use the updated macros for looking up variable names. runtime/mercury_wrapper.[ch]: Add a new indirect pointer, MR_register_module_layout, which points to a function that registers a module layout, or is NULL if debugging is not enabled. runtime/mercury_init.h: Declare the function whose address may be assigned to MR_register_module_layout in a <main>_init.c file. util/mkinit.c: Initialize MR_register_module_layout with either the address of MR_register_module_layout_real or NULL, depending on whether debugging is enabled or not. compiler/continuation_info.m: Don't give names (V_n) to nameless variables, because we don't want them to be included in the variables debugging knows about. compiler/llds.m: Add a new function symbol to the type data_addr, which stands for the module layout structure of the named (now always the current) module. Add a new function symbol to the type rval_const. The new function symbols, multi_string_const, contains an array of characters of an explicitly given length, which consists of several strings, each terminated by a null character. compiler/llds_out.m: Accommodate the changes to llds.m, and expand the module initialization code to register the module layout structure, if the pointer to the registration function is not NULL. compiler/stack_layout.m: Generate the new data structures for representing variable names, as well as the module layout. compiler/mercury_compile.m: Rename some variables to reflect the fact that stack_layout.m can now include a module layout structure in the list of static layout structures it returns. compiler/dupelim.m: compiler/exprn_aux.m: compiler/jumpopt.m: compiler/opt_debug.m: Minor changes to accommodate multi_string_consts. trace/mercury_trace_tables.[ch]: Replace the old data structures for recording information about each debuggable module with the module layout structure, and register module layout structures directly, instead of trying to discover them through the internal label table. trace/mercury_trace.[ch]: Now that it is more easily accessible, use variable numbers instead of variable names to find the current locations of the input arguments when implementing retry. Unlike our previous method, this works even if the user names some variables HeadVar__1, etc. Remove an unnecessary export of an internal function. trace/mercury_trace_external.c: trace/mercury_trace_internal.c: runtime/mercury_layout_util.c: Use the updated macros for looking up variable names.	1999-05-28 05:29:51 +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
Tyson Dowd	9e3a8eae9c	During the writing of the RTTI paper, we decided that type_ctor_info ... Estimated hours taken: 8 During the writing of the RTTI paper, we decided that type_ctor_info was a much better name than base_type_info. Rename base_type* as type_ctor*, except we don't rename the modules base_type_info and base_type_layout just yet. Most of these changes were made using the following sed patterns: s/base_type_info/type_ctor_info/g s/base_type_layout/type_ctor_layout/g s/base_type_functors/type_ctor_functors/g s/BASETYPE_INFO/TYPE_CTOR_INFO/g s/TYPEFUNCTORS/TYPE_CTOR_FUNCTORS/g s/TYPELAYOUT/TYPE_CTOR_LAYOUT/g s/BASE_TYPEINFO/TYPE_CTOR_INFO/g s/BASE_TYPE_INFO/TYPE_CTOR_INFO/g s/BaseTypeInfo/TypeCtorInfo/g s/BaseTypeLayout/TypeCtorLayout/g s/base_type(/type_ctor(/g s/:- module type_ctor_info/:- module base_type_info/g s/:- module type_ctor_layout/:- module base_type_layout/g s/type_ctor_info__/base_type_info__/g s/type_ctor_layout__/base_type_layout__/g /import_module/s/type_ctor_info/base_type_info/g /import_module/s/type_ctor_layout/base_type_layout/g compiler/*.m: library/*.m: runtime/*.{c,h}: profiler/demangle.m: util/mdemangle.c: Applied the above sed commands. runtime/mercury_bootstrap.h: Add bootstrapping #defines so the type_ctor_* substitutions in the library don't cause link problems. Delete some redundant bootstrapping definitions.	1999-03-22 08:09:52 +00:00
Simon Taylor	18430aaef1	Aditi compilation. ... Estimated hours taken: 1200 Aditi compilation. compiler/options.m: The documentation for these is commented out because the Aditi system is not currently useful to the general public. --aditi: enable Aditi compilation. --dump-rl: write the intermediate RL to `<module>.rl_dump'. --dump-rl-bytecode: write a text version of the bytecodes to `<module>.rla' --aditi-only: don't produce a `.c' file. --filenames-from-stdin: accept a list of filenames to compile from stdin. This is used by the query shell. --optimize-rl, --optimize-rl-cse, --optimize-rl-invariants, --optimize-rl-index, --detect-rl-streams: Options to control RL optimization passes. --aditi-user: Default owner of any Aditi procedures, defaults to $USER or "guest". --generate-schemas: write schemas for base relations to `<module>'.base_schema and schemas for derived relations to `<module>'.derived_schema. This is used by the query shell. compiler/handle_options.m: Handle the default for --aditi-user. compiler/hlds_pred.m: compiler/prog_data.m: compiler/prog_io_pragma.m: compiler/make_hlds.m: Add some Aditi pragma declarations - `aditi', `supp_magic', `context', `naive', `psn' (predicate semi-naive), `aditi_memo', `aditi_no_memo', `base_relation', `owner' and `index'. Separate out code to parse a predicate name and arity. compiler/hlds_pred.m: Add predicates to identify Aditi procedures. Added markers `generate_inline' and `aditi_interface', which are used internally for Aditi code generation. Add an `owner' field to pred_infos, which is used for database security checks. Add a field to pred_infos to hold the list of indexes for a base relation. compiler/make_hlds.m: Some pragmas must be exported if the corresponding predicates are exported, check this. Make sure stratification of Aditi procedures is checked. Predicates with a mode declaration but no type declaration are no longer assumed to be local. Set the `do_aditi_compilation' field of the module_info if there are any local Aditi procedures or base relations. Check that `--aditi' is set if Aditi compilation is required. compiler/post_typecheck.m: Check that every Aditi predicate has an `aditi__state' argument, which is used to ensure sequencing of updates and that Aditi procedures are only called within transactions. compiler/dnf.m: Changed the definition of disjunctive normal form slightly so that a call followed by some atomic goals not including any database calls is considered atomic. magic.m can handle this kind of goal, and it results in more efficient RL code. compiler/hlds_module.m: compiler/dependency_graph.m: Added dependency_graph__get_scc_entry_points which finds the procedures in an SCC which could be called from outside. Added a new field to the dependency_info, the aditi_dependency_ordering. This contains all Aditi SCCs of the original program, with multiple SCCs merged where possible to improve the effectiveness of differential evaluation and the low level RL optimizations. compiler/hlds_module.m: Add a field to record whether there are any local Aditi procedures in the current module. Added versions of module_info_pred_proc_info and module_info_set_pred_proc_info which take a pred_proc_id, not a separate pred_id and proc_id. compiler/polymorphism.m: compiler/lambda.m: Make sure that predicates created for closures in Aditi procedures have the correct markers. compiler/goal_util.m: Added goal_util__switch_to_disjunction, goal_util__case_to_disjunct (factored out from simplify.m) and goal_util__if_then_else_to_disjunction. These are require because supplementary magic sets can't handle if-then-elses or switches. compiler/type_util.m: Added type_is_aditi_state/1. compiler/mode_util.m: Added partition_args/5 which partitions a list of arguments into inputs and others. compiler/inlining.m: Don't inline memoed procedures. Don't inline Aditi procedures into non-Aditi procedures. compiler/intermod.m: Handle Aditi markers. Clean up handling of markers which should not appear in `.opt' files. compiler/simplify.m: Export a slightly different interface for use by magic.m. Remove explicit quantifications where possible. Merge multiple nested quantifications. Don't report infinite recursion warnings for Aditi procedures. compiler/prog_out.m: Generalised the code to output a module list to write any list. compiler/code_gen.m: compiler/arg_info.m: Don't process Aditi procedures. compiler/mercury_compile.m: Call magic.m and rl_gen.m. Don't perform the low-level annotation passes on Aditi procedures. Remove calls to constraint.m - sometime soon a rewritten version will be called directly from deforestation. compiler/passes_aux.m: Add predicates to process only non-Aditi procedures. compiler/llds.m: compiler/llds_out.m: Added new `code_addr' enum members, do_{det,semidet,nondet}_aditi_call, which are defined in extras/aditi/aditi.m. compiler/call_gen.m: Handle generation of do_*_aditi_call. compiler/llds_out.m: Write the RL code for the module as a constant char array in the `.c' file. compiler/term_errors.m: compiler/error_util.m: Move code to describe predicates into error_util.m Allow the caller to explicitly add line breaks. Added error_util:list_to_pieces to format a list of strings. Reordered some arguments for currying. compiler/hlds_out.m: Don't try to print clauses if there are none. runtime/mercury_init.h: util/mkinit.c: scripts/c2init.in: Added a function `mercury__load_aditi_rl_code()' to the generated `<module>_init.c' file which throws all the RL code for the program at the database. This should be called at connection time by `aditi__connect'. Added an option `--aditi' which controls the output `mercury__load_aditi_rl_code()'. compiler/notes/compiler_design.html: Document the new files. Mmakefile: bindist/Mmakefile: Don't distribute extras/aditi yet. New files: compiler/magic.m: compiler/magic_util.m: Supplementary magic sets transformation. Report errors for constructs that Aditi can't handle. compiler/context.m: Supplementary context transformation. compiler/rl_gen.m: compiler/rl_relops.m: Aditi code generation. compiler/rl_info.m: Code generator state. compiler/rl.m: Intermediate RL representation. compiler/rl_util: Predicates to collect information about RL instructions. compiler/rl_dump.m: Print out the representation in rl.m. compiler/rl_opt.m: Control low-level RL optimizations. compiler/rl_block.m: Break a procedure into basic blocks. compiler/rl_analyse.m: Generic dataflow analysis for RL procedures. compiler/rl_liveness.m: Make sure all relations are initialised before used, clear references to relations that are no longer required. compiler/rl_loop.m: Loop invariant removal. compiler/rl_block_opt.m: CSE and instruction merging on basic blocks. compiler/rl_key.m: Detect upper/lower bounds for which a goal could succeed. compiler/rl_sort.m: Use indexing for joins and projections. Optimize away unnecessary sorting and indexing. compiler/rl_stream.m: Detect relations which don't need to be materialised. compiler/rl_code.m: RL bytecode definitions. Automatically generated from the Aditi header files. compiler/rl_out.m: compiler/rl_file.m: Output the RL bytecodes in binary to <module>.rlo (for use by Aditi) and in text to <module>.rla (for use by the RL interpreter). Also output the schema information if --generate-schemas is set. compiler/rl_exprn.m: Generate bytecodes for join conditions. extras/aditi/Mmakefile: extras/aditi/aditi.m: Definitions of some Aditi library predicates and the interfacing and transaction processing code.	1998-12-06 23:49:14 +00:00
Zoltan Somogyi	27f024b2e9	Reorganize the handling of global data structures, and expose the table ... Estimated hours taken: 16 Reorganize the handling of global data structures, and expose the table pointers for tabled predicates to allow the tables to be reset to empty by hand-written C code for benchmarking purposes. compiler/hlds_module.m: Introduce a new submodule for dealing with global data. At the moment it deals with (a) layout structures and (b) tabling pointers. compiler/continuation_info.m: Remove the data structures and predicates whose equivalents are now in hlds_module. compiler/llds.m: Introduce a new kind of item, that of compiler-generated variables whose value is not defined by rvals. At the moment, the only such item is a tabling pointer variable. compiler/mercury_compile.m: Include the new kind of item in the generated LLDS. compiler/table_gen.m: Use the new kind of item instead of a static variable declaration in pragma C code to hold the tabling pointer. Remove lots of spaces at ends of lines, since many of these screw up paragraph commands in vi. compiler/base_type_layout.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/llds_out.m: compiler/mercury_to_mercury.m: compiler/switch_gen.m: compiler/transform_llds.m: compiler/unify_gen.m: Handle the changes in the data structures. library/private_builtin.m: Remove the predicate get_table, which is no longer used after the changes to table_gen.m.	1998-11-24 03:57:47 +00:00
Zoltan Somogyi	620ce80408	Make stack layout structures work in grades that do not have static code ... Estimated hours taken: 16 Make stack layout structures work in grades that do not have static code addresses. (Although it seems that those grades do not work in the absence of layout structures.) compiler/llds_out.m: If an entry label has a layout structure, then during its initialization, output a macro that will, if necessary, initialize the code address inside its layout structure. Do not output a const before a layout structure if the macro will actually initialize a code address inside it. compiler/llds.m: Separate out proc_layouts from internal_layouts in the type data_name, since only proc_layouts have code addresses in them. Clarify the existing documentation of the label type's alternatives. This should help prevent the recurrence of bugs like the one in mercury_goto.h. compiler/stack_layout.m: Replace code addresses inside proc layout structures with a dummy value if code addresses are not static. runtime/mercury_goto.h: Fix a long-standing bug: init_local should treat its argument as a procedure entry label, not as a label internal to a procedure. runtime/mercury_stack_layout.h: In the macros for creating proc layouts by hand-written C code, allow for the absence of static code addresses, and add a new macro that fills in the code address slot in proc layouts at initialization time if necessary. library/benchmarking.m: library/private_builtin.m: library/std_util.m: Add calls to the new initialization macro to accompany hand-written proc layout structures.	1998-11-12 03:16:29 +00:00
Zoltan Somogyi	8a0ceb49aa	This checkin has several major purposes, set out in the sections below, ... Estimated hours taken: 240 This checkin has several major purposes, set out in the sections below, all connected with the implementation of the new debugger command set. DOCUMENT NEW DEBUG COMMAND SET doc/user_guide.texi: Add a new section on the debugger. The description of the commands is complete, but some of the background sections, and the section about how to build debuggable executables, are not yet done. Update the documentation of the tracing options. doc/generate_mdb_doc: A new shell script that automatically converts some of the new sections of the user guide into the online documentation of the debugger. doc/mdb_categories: The fixed initial part of the online documentation. doc/Mmakefile: Add rules for creating mdb_doc, the file that is the online documentation of the debugger, and for installing it together with mdbrc. Mmake.common.in: Define INSTALL_DOC_DIR for doc/Mmakefile. scripts/mdbrc.in: A debugger command script that reads in the online documentation and then defines some standard aliases. configure.in: Define the variable that scripts/mdb.in and scripts/mdbrc.in use to find the right files, and get configure to perform the substitutions. configure.in: scripts/mdb: scripts/mdb.in: Replace mdb with mdb.in. Mdb is now created during configuration from mdb.in, filling in the name of the file that contains the default debugger initialization commands. util/info_to_mdb.c: A program that does most of the work involved in automatically converting user guide sections into online documentation. (This couldn't easily be written in sh, because sh's read command has no notion of pushback.) util/Mmakefile: Add info_to_mdb to the list of targets. tools/bootcheck: Make sure that the tests in tests/debugger are executed with an initialization setup that is equivalent to what users will see by default. REORGANIZE TRACING OPTIONS compiler/globals.m: compiler/handle_options.m: compiler/options.m: compiler/trace.m: Reorganize the handling of trace levels around the new options --trace-internal, --trace-redo, and --trace-return. compiler/*.m: Use the new ways of getting at trace levels. tests/hard_coded/typeclasses/Mmakefile: s/--trace all/--trace deep/ SUPPORT RETRY compiler/trace.m: After every call to MR_trace(), emit code that checks whether it should jump away, and if yes, performs the jump. This is used to implement retry. (The debugger cannot execute the jump itself because it is in the wrong C stack frame.) compiler/llds.m: compiler/continuation_info.m: compiler/stack_layout.m: Modify the data structures that record information about live value at program points, to record the identity of each variable. This is necessary for the implementation of the restart command, since we do not want to confuse two distinct variables just because they have the same name. For example, a variable whose name is X and number is 5 is now recorded in the name array as "5:X". Clean up the data structure a bit, so that we don't have to store dummy names for values that are not variables. compiler/*.m: Minor changes to conform to the data structure changes. runtime/mercury_stack_layout.h: Redefine an existing macro to strip away the initial number: prefix from the "name" of a variable (keeping its original function on changed data), and add a new one to access the raw unstripped data. runtime/mercury_init.h: runtime/mercury_wrapper.h: Update the prototype of MR_trace_{fake,real}, and the type of the global that points to them. runtime/mercury_layout_util.h: Add an extra function, MR_get_register_number, for use by retry. USE FIXED STACK SLOTS FOR TRACE INFO compiler/code_gen.m: compiler/code_info.m: compiler/live_vars.m: compiler/trace.m: If execution tracing is enabled, reserve the first few stack slots to hold the event number of the call event, the call number, the call depth, the redo layout structure address (if generating redo events) and the from_full flag at the time of call (if we are doing shallow tracing). By allocating the first four of these to fixed stack slots, the debugger knows where to look for them without having to be told. It finds out the location of the fifth, if needed, from a new slot in the proc layout structure. (It is not possible to allocate all five to fixed stack slots without wasting stack space in some cases.) compiler/trace.m: Remove from the call to MR_trace the parameters that are now in fixed stack slots, since MR_trace can now look them up itself. compiler/continuation_info.m: compiler/stack_layout.m: Add an extra field to the proc_layout_info. If the module is shallow traced, this field says which stack slot holds the saved value of MR_from_full. If it is not shallow traced, this field says that there is no such stack slot. runtime/mercury_stack_layout.h: Add macros for accessing the fixed stack slots holding the event number of the call event, the call number, the call depth, and, at a redo event, the redo layout structure address. Support the new field in proc layouts that gives the location of the from-full flag (if any). runtime/mercury_trace_base.[ch]: trace/mercury_trace.[ch]: Remove the call number and call depth arguments from MR_trace and its avatars, since this info is now in fixed stack slots in every procedure that can call MR_trace. This should reduce the size of the executable significantly, since there are lots of calls to MR_trace. runtime/mercury_init.h: runtime/mercury_wrapper.h: Update the prototype of MR_trace_{fake,real}, and the type of the global that points to them. START NUMBERING FRAMEVARS FROM ONE compiler/code_info.m: compiler/live_vars.m: compiler/llds_out.m: compiler/trace.m: Start numbering framevars from 1 internally to the compiler; the runtime already starts from 1. This simplifies several tasks. ADD REDO EVENTS compiler/trace.m: compiler/code_gen.m: Before the code that executes "succeed()", emit code to push a a temp nondet frame whose redoip points to a label in the runtime that calls MR_trace for a REDO event and then fails, provided --trace-redo is set. compiler/llds.m: Add a new code address constant, do_trace_redo_fail, which stands for the address in the trace system to which calls MR_trace for the redo event and then fails. compiler/trace.m: compiler/llds_out.m: Provided we are doing redo tracing, fill in the slot that holds the layout information for the REDO event. compiler/*.m: Minor changes to conform to handle the new code address constant. browser/debugger_interface.m: Add redo to trace_port_type. runtime/mercury_trace_base.[ch]: Add a C module containing the code that calls MR_trace for REDO events. ENSURE THAT INPUT ARGUMENTS ARE ALWAYS VISIBLE compiler/trace.m: When generating the set of live variables at internal ports, the variables that are in the pre-death set of the goal into which we are entering may not be available. However, the variables in the pre-death set that are also in the resume vars set will be available, so now include info about them in the layout structure for the event. Since with tracing the non-clobbered input args are in all resume vars sets, this ensures that these input args will be available from all internal events. compiler/code_info.m: Export a previously internal predicate (current_resume_point_vars) to make this possible. BUG FIX: WANT RETURN LAYOUTS compiler/globals.m: compiler/call_gen.m: compiler/code_info.m: compiler/mercury_compile.m: Add a new pred globals__want_return_layouts, which says whether the compiler should generate layout structures for call returns. This pred centralizes the several previous copies of the test. One of those copies (the one in call_gen) was faulty, leading to a bug: in the presence of execution tracing but the absence of accurate gc, information about the variables that are live at the call return wasn't being gathered properly. BUG FIX: #include mercury_trace_base.h compiler/llds_out.m: #include mercury_trace_base.h, not mercury_trace.h, since now mercury_trace_base.h defines everything directly accessible from modules compiled with tracing. RECAST MERCURY_TRACE_UTIL AS MERCURY_LAYOUT_UTIL runtime/mercury_trace_util.[ch]: runtime/mercury_layout_util.[ch]: Rename this module from trace_util to layout_util, since it is also used by the native garbage collector. Remove "trace" from the names of functions. Get rid of the global variable MR_saved_regs, and instead thread a pointer to this data structure through the relevant functions as an extra argument. Add a lot more documentation in the header file. runtime/Mmakefile: Reflect the module rename. runtime/*.c: Refer to the new module. DELETE EASY-TO-MISUSE MACROS runtime/mercury_stacks.h: Delete the based_framevar and based_detstackvar macros, since their continued use can lead to off-by-one errors, and the saved_framevar and saved_detstackvar macros, since they are no longer used. runtime/*.c Update any references to any macros removed from mercury_stacks.h. MISC RUNTIME CHANGES runtime/mercury_trace_base.[ch]: trace/mercury_trace*.[ch]: Make typedef'd names conform to the naming convention. Make MR_trace_call_{seqno,depth} consistently Unsigned, rather than sometimes Word and sometimes Unsigned. FIX BUG: MAKE THE DEBUGGER PRINT TO STDOUT, NOT THE CURRENT STREAM library/io.m: Export to C code the predicates that return the identities and types of stdin, stdout and stderr, as well as io__print/[34]. library/std_util.m: Export to C code a predicate that returns the type_info for the type stdutil:type_info. This type_info is required if C code wants to invoke make_permanent on any type_info structure, as the debugger does. runtime/mercury_init.h: Add extern declarations for the C functions now exported from io.m. runtime/mercury_wrapper.[ch]: Add new global variables to hold the addresses of these C functions. runtime/mercury_layout_util.c: Use indirect calls through these global variables to print Mercury values, instead of lower-level code. util/mkinit.c: Assign the addresses of the functions exported from io.m to the global variables defined in mercury_wrapper.h. BUG FIX: STACK TRACE FUNCTIONS DEPEND ON THE LABEL TABLE runtime/mercury_stack_trace.c: On entry to any of the functions exported from this module, ensure that the label table is loaded by calling do_init_modules. Without a filled-in label table, the stack trace will not be able to find any stack layout info. BUG FIX: REMOVE BROWSER/*.C configure.in: When removing .c files generated by the C compiler, remove those in the browser directory as well as the compiler, library and profiler directories. IMPLEMENT NEW DEBUGGER COMMAND SET runtime/mercury_stack_trace.[ch]: Factor out the code that prints the id of a procedure into a function of its own, so that it can also be used from the debugger, ensuring appearance commonality. Add more documentation in the header file. trace/mercury_trace_internal.c: Implement the proposed command set. Command names are now words, and several commands now have options allowing the user to override the default print level or strictness of the command, or the invocation conditions or action of a break point. Allows control over command echoing and the scrolling of sequences of event reports. Supports aliases, command file sourcing etc. Implements the retry command, using the info in the fixed stack slots. trace/mercury_trace.[ch]: Extend the trace controls to support the new functionalities required by the new debugger language, which are print levels, variable-strictness commands, a more flexible finish command, and the retry command. Pass the command structure to MR_trace_event_report, since the user can now forcibly terminate the scrolling of reports. trace/mercury_trace_alias.[ch]: New module to manage aliases for the debugger. trace/mercury_trace_help.[ch]: New module to interface to browser/help.m. trace/mercury_trace_spy.[ch]: New module to manage break points. The test of whether an event matches a break point is now much more efficient than before. The new module also allows several breakpoints with different actions and different invocation conditions (e.g. all ports, entry port, interface ports or specific (possibly internal) port) to be defined on the same procedure. trace/mercury_trace_tables.[ch]: New module to manage a table of the debuggable modules, in which each such module is linked to the list of the layouts of all the procedures defined in that module. This information allows the debugger to turn the name of a predicate/function (possibly together with its arity and mode number) into the procedure layout structure required by the spy point module. Eventually it may also be useful in supplying lists of identifiers for command line completion. Modules for which no stack layout information is available will not be included in the table, since do_init_modules will not register any labels for them in the label table. trace/Mmakefile: Mention the new files. runtime/mercury_array_macros.h: A new file holding macros that can be useful in more than one module. runtime/Mmakefile: Mention the new file. runtime/mercury_conf.h.in: Mention a new configuration macro, MR_CANNOT_USE_STRUCTURE_ASSIGNMENT, used by runtime/mercury_array_macros.h. configure.in: Find out whether we need to define MR_CANNOT_USE_STRUCTURE_ASSIGNMENT. ADD TRACE DEPTH HISTOGRAMS runtime/mercury_conf_param.h: Document MR_TRACE_HISTOGRAM. runtime/mercury_trace_base.[ch]: Define the data structures for the histogram, and print the histogram when a traced program exits if MR_TRACE_HISTOGRAM is set. trace/mercury_trace.[ch]: If MR_TRACE_HISTOGRAM is defined, record a count of the number of events at each depth. This information can help us evaluate space-time tradeoffs. FACTOR OUT SHELL CODE HANDLING GRADE IMPLICATIONS scripts/final_grade_options.sh-subr: A new file to contain any code that implements implications between grade flags; currently implements the implication debug -> use trail. scripts/mgnuc.in: scripts/ml.in: Replace the code that is now in final_grade_options.sh-subr with an inclusion of final_grade_options.sh-subr. configure.in: Handle final_grade_options.sh-subr as {init,parse}_grade_options.sh-subr are handled. SIMPLIFY THE MAINTAINANCE OF CONSISTENCY BETWEEN DEBUGGER CODE AND DOCUMENTATION doc/Mmakefile: Add rules for creating mdb_command_list, a C code fragment that can included manually in trace/mercury_trace_internal.c to supply the list of valid commands, and mdb_command_test.inp, which is a list of invalid invocations of debugger commands, which tests whether the help message for such invocations can be located as expected. doc/generate_mdb_command_list: doc/generate_mdb_command_test: Awk scripts to create mdb_command_list and mdb_command_test.inp respectively from mdb_doc. tools/bootcheck: Copy mdb_command_test.inp from doc to tests/debugger. tests/debugger/Mmakefile: Add a new test that checks whether we get an internal error, unable to locate the right help node, for each invalid command invocation in mdb_command_test.inp. UPDATE TEST CASES tests/debugger/Mmakefile: Reenable queens. Conform to the new set of options. tests/debugger/*.inp: tests/debugger/*.exp: Update the inputs and expected outputs of the debugger test cases to use the new command set and output formats.	1998-10-16 06:20:28 +00:00
Zoltan Somogyi	ed063bcc00	Extend the new failure handling method to optionally preserve an invariant ... Estimated hours taken: 30 Extend the new failure handling method to optionally preserve an invariant required by accurate gc: always being able to tell with respect to what MR_sp or MR_curfr to interpret the stackvars and framevars referred to by the label whose address is the redoip slot of a nondet stack frame. This basically requires limitations on the hijacking of redoip/redofr slot pairs. compiler/notes/failure.html: Describe the new extension. Change the terminology to conform to what is used in the code. compiler/llds.m: For each temporary frame on the nondet stack, specify the native stack of the procedure that created it. This is so that we know whether the temporary frame ought to have the fourth slot that specifies the right value of MR_sp. (The fourth slot is included only in temporary nondet stack frames created procedures that live on the det stack; procedures that live on the nondet stack never have any of their variables on the det stack.) Remove the modframe llds instruction, since it does not specify what frame's redoip slot it is assigning to. This is error-prone (see peephole.m below). We were not using modframe much anyway. compiler/llds_out.m: compiler/opt_debug.m: Emit either mktempframe or mkdettempframe depending on the new field in temp_frame. compiler/code_info.m: Add a fourth item to the failure state, which states whether the top frame of the nondet stack may be hijacked. Initialize it from the option --allow-hijacks. If about to do a hijack but the failure state says no, create a temporary frame instead. Separate out the code for creating temporary frames, since it is now called from more than one place. Generalize the code to handle the new type of temp frame. compiler/code_info.m: compiler/ite_gen.m: Simplify the way we transmit information about the location of the address of the nondet stack frame in which the soft cut is performed from the start of the condition to its end. Remove the predicate code_info__maybe_push_temp_frame; its functionality is now achieved in code_info.m by disabling and restoring --allow-hijacks around the generation of code for the condition. This also allows us to get rid of the code that finds out whether the condition can do any hijacking. compiler/opt_util.m: Rename next_modframe as next_assign_to_redoip, and add an additional argument that says which frame's redoip we are after. compiler/peephole.m: Use the new argument of opt_util__next_assign_to_redoip to fix a bug where a mkframe of a temporary frame (which leaves curfr unchanged) that was followed a modframe (which assigns to the redoip of curfr) was incorrectly optimized (the assignment to the redoip slot was applied to the temporary frame, not the ordinary one). compiler/*.m: Minor changes to accommodate the disappearance of modframe. runtime/mercury_stacks.h: Add macros to support four-word temp frames on the nondet stack. Make the macros that access nondet stack frame slots start with MR_, while keeping (redefined) macros needed for backward compatibility. Remove the modframe macro. Fix a dangling reference to PREDNM instead of MR_PREDNM. runtime/mercury_stack_trace.c: Modify the stack tracing code to allow for the new four-word temp frames. Use the new MR_ prefixed variants of the macros. runtime/mercury_debug.h: runtime/mercury_misc.[ch]: Remove references to modframe. tests/general/complex_failure.{m,exp}: A new test case to tickle the various ways of handling nested disjunctions and if-then-elses in the new code generator. tests/general/Mmakefile: Enable the new test case. tests/{general,hard_coded}/space.{m,exp}: Move this test case from general to hard_coded. Although NU-Prolog can execute it, it does not give the same answers as Mercury due to a different default ordering and a difference in integer size (26-bit integers in NU-Prolog) that changes the behavior of the pseudo random-number generator. tests/hard_coded/cycles2.exp: Add the missing .exp file for this existing test case. tests/hard_coded/Mmakefile: Enable the old test cases cycles, cycles2 and space, since we now pass them.	1998-07-29 08:57:09 +00:00
Zoltan Somogyi	d1855187e5	Implement new methods of handling failures and the end points of branched ... Estimated hours taken: 260 Implement new methods of handling failures and the end points of branched control structures. compiler/notes/failure.html: Fix an omission about the handling of resume_is_known in if-then-elses. (This omission lead to a bug in the implementation.) Optimize cuts across multi goals when curfr is known to be equal to maxfr. Clarify the wording in several places. compiler/code_info.m: Completely rewrite the methods for handling failure. Separate the fields of code_info into three classes: those which do not change after initialization, those which record state that depends on where in the HLDS goal we are, and those which contain persistent data such as label and cell counters. Rename grab_code_info and slap_code_info as remember_position and reset_to_position, and add a wrapper around the remembered code_info to make it harder to make mistakes in its use. (Only the location-dependent fields of the remembered code_info are used, but putting only them into a separate data structure would result in more, not less, memory being allocated.) Gather the predicates that deal with handling branched control structures into a submodule. Reorder the declarations and definitions of access predicates to conform to the new order of fields. Reorder the declarations and definitions of the failure handling submodule to better reflect the separation of higher-level and lower-level predicates. compiler/code_gen.m: Replace code_gen__generate_{det,semi,non}_goal_2 with a single predicate, since for most HLDS constructs the code here is the same anyway (the called preds check the code model when needed). Move classification of the various kinds of unifications to unify_gen, since that is where it belongs. Move responsibility for initializing the code generator's trace info to code_info. Move the generation of code for negations to ite_gen, since the handling of negations is a cut-down version of the handling of negations. This should make the required double maintenance easier, and more likely to happen. compiler/disj_gen.m: compiler/ite_gen.m: These are the two modules that handle most failures; they have undergone a significant rewrite. As part of this rewrite, factor out the remaining common code between model_non and model_{det,semi} goals. compiler/unify_gen.m: Move classification of the various kinds of unifications here from code_gen. This allows us to keep several previously exported predicates private. compiler/call_gen.m: Factor out some code that was common to ordinary calls, higher order calls and method calls. Move the common code that checks whether we are doing tracing to trace.m. Replace call_gen__generate_{det,semi,nondet}_builtin with a single predicate. Delete the commented out call_gen__generate_complicated_unify, since it will never be needed and in any case suffered from significant code rot. compiler/llds.m: Change the mkframe instruction so that depending on one of its arguments, it can create either ordinary frames, or the cut-down frames used by the new failure handling algorithm (they have only three fixed fields: prevfr, redoip and redofr). compiler/llds_out.m: Emit a #define MR_USE_REDOFR before including mercury_imp.h, to tell the runtime we are using the new failure handling scheme. This effectively changes the grade of the compiled module. Emit MR_stackvar and MR_framevar instead of detstackvar and framevar. This is a step towards cleaning up the name-space, and a step towards making both start numbering at 0. For the time being, the compiler internally still starts counting framevars at 0; the code in llds_out.m adds a +1 offset. compiler/trace.m: Change the way trace info is initialized to fit in with the new requirements of code_info.m. Move the "are we tracing" check from the callers to the implementation of trace__prepare_for_call. compiler/*.m: Minor changes in accordance with the major ones above. compiler/options.m: Introduce a new option, allow_hijacks, which is set to "yes" by default. It is not used yet, but the idea is that when it is set to no, the code generator will not generate code that hijacks the nondet stack frame of another procedure invocation; instead, it will create a new temporary nondet stack frame. If the current procedure is model_non, it will have three fields: prevfr, redoip and redofr. If the current procedure is model_det or model_semi, it will have a fourth field that is set to the value of MR_sp. The idea is that the runtime system, which will be able to distinguish between ordinary frames (whose size is at least 5 words), 3-word and 4-word temporary frames, will now be able to use the redofr slots of all three kinds of frames and the fourth slot values of 4-word temporary frames as the addresses relative to which framevars and detstackvars respectively ought to be offset in stack layouts. compiler/handle_options.m: Turn off allow_hijacks if the gc method is accurate. runtime/mercury_stacks.h: Change the definitions for the nondet stack handling macros to accommodate the new nondet stack handling discipline. Define a new macro for creating temp nondet frames. Define MR_based_stackvar and MR_based_framevar (both of which start numbering slots at 1), and express other references, including MR_stackvar and MR_framevar and backward compatible definitions of detstackvar and framevar for hand-written C code, in terms of those two. runtime/mercury_stack_trace.[ch]: Add a new function to print a dump of the fixed elements nondet stack, for debugging my changes. (The dump does not include variable values.) runtime/mercury_trace_internal.c: Add a new undocumented command "D" for dumping the nondet stack (users should not know about this command, since the output is intelligible only to implementors). Add a new command "toggle_echo" that can cause the debugger to echo all commands. When the input to the debugger is redirected, this echo causes the output of the session to be much more readable. runtime/mercury_wrapper.c: Save the address of the artificial bottom nondet stack frame, so that the new function in mercury_stack_trace.c can find out where to stop. runtime/mercury_engine.c: runtime/mercury_wrapper.c: Put MR_STACK_TRACE_THIS_MODULE at the tops of these modules, so that the labels they define (e.g. do_fail and global_success) are registered in the label table when their module initialization functions are called. This is necessary for a meaningful nondet stack dump. runtime/mercury_grade.h: Add a new component to the grade string that specifies whether the code was compiled with the old or the new method of handling the nondet stack. This is important, because modules compiled with different nondet stack handling disciplines are not compatible. This component depends on whether MR_USE_REDOFR is defined or not. runtime/mercury_imp.h: If MR_DISABLE_REDOFR is defined, undefine off MR_USE_REDOFR before including mercury_grade.h. This is to allow people to continue working on un-updated workspaces after this change is installed; they should put "EXTRA_CFLAGS = -DMR_DISABLE_REDOFR" into Mmake.stage.params. (This way their stage1 will use the new method of handling failure, while their stage2 2&3 will use the old one.) This change should be undone once all our workspaces have switched over to the new failure handling method. tests/hard_coded/cut_test.{m,exp}: A new test case to tickle the various ways of handling cuts in the new code generator. tests/hard_coded/Mmakefile: Enable the new test case.	1998-07-20 10:04:02 +00:00
Thomas Conway	a70b59e83c	Add a test to find the number of words needed to represent a ... configure.in: Add a test to find the number of words needed to represent a synchronization term. boehm_gc/gc.h: fix a declaration by replacing the args () with (void). boehm_gc/solaris_pthreads.c: add a missing include check the return values of pthread calls. compiler/*.m: Add handling for the new HLDS goal type par_conj. Add handling for the four new LLDS instructions: init_sync_term fork join_and_terminate join_and_continue compiler/code_info.m: add a new alternative for slot_contents - sync_term. compiler/handle_options.m: add .par as part of the grade compiler/hlds_goal.m: add the new goal type par_conj. compiler/instmap.m: add instmap__unify which takes a list of instmaps and abstractly unifies them. add unify_instmap_delta which tajes two instmap deltas and abstractly unifies them. compiler/llds.m: add the new llds instructions. compiler/mode_info.m: add par_conj as a lock reason. library/Makefile: work around a bug in the solaris version pthread.h library/benchmarking.m: reference the stack zones from the engine structure rather than from global variables. library/{nc,sp}_builtin.nl: add an op declaration for &. library/std_util.m: change references to global variables to references inside the engine structure. runtime/Mmakefile: add mercury_thread.{c,h} add THREADLIBS to the libraries runtime/*.{c,h} Remove some old junk from the previous processes/shrd-mem changes that found their way into the repository. Add MR_ prefixes to lots of names. runtime/mercury_context.c: Add init_thread_stuff for creating and initializing a context structure for the current thread. runtime/mercury_context.h: add a field to the mercury context which stores the thread id of the thread where this context originated. add various macros for implementing the new llds instructions. runtime/mercury_engine.c: initialize the engine structure, rather than a bunch of globals. runtime/mercury_engine.h: declare the mercury_engine structure. runtime/mercury_regorder.h: if MR_THREAD_SAFE, and there is at least one global register then use mr0 as a pointer to the mercury engine structure. scripts/init_grade_options.sh-subr add thread_safe scripts/mgnuc.in add THREAD_OPTS scripts/ml.in: add THREAD_LIBS	1998-06-09 02:16:31 +00:00
Zoltan Somogyi	d10af74168	This change introduces interface tracing, and makes it possible to successfully ... Estimated hours taken: 50 This change introduces interface tracing, and makes it possible to successfully bootstrap the compiler with tracing (either interface or full). compiler/options.m: Change the bool options --generate-trace into a string option --trace with three valid values: minimal, interface and full. The last two mean what they say; the intention is that eventually minimal will mean no tracing in non-tracing grades and interface tracing in tracing grades. compiler/globals.m: Add a new global for the trace level. compiler/handle_options.m: Convert the argument of --trace to a trace level. Use only consistent 4-space indentation in the deeply nested if-then-else. compiler/trace.m: Implement interface tracing. Rename trace__generate_depth_reset_code as trace__prepare_for_call, since it does more than reset the depth if this module is compiled with interface tracing. Do not check whether tracing is enabled before calling MR_trace; let MR_trace make the check. This trades increased non-tracing execution time for a substantial code size reduction (which may in turn benefit execution time). compiler/call_gen.m: Call trace__generate_depth_reset_code by its new name. compiler/code_info.m: Fix a bug in the handling of non/semi commits. When entering a commit, we used to push a clone of whatever the top failure continuation was. However, the resume setup for this continuation could have started with a label that assumed that the resume vars were in their original locations (which are often registers), whereas the method of backtracking to that point only guarantees the survival of stack slots, not registers. (This bug caused two lines of incorrect code to be generated among the approx 30 million lines of code in the stage 2 compiler when compiled with tracing.) Fix another bug (previously untriggered as far as I know) in the handling of multi/det commits. This one was breaking the invariant that the resume vars set of each entry on the failure continuation stack included the resume vars set of every other entry below it, which meant that the values of these resume vars were not guaranteed to be preserved. compiler/stack_layout.m: Make layout structures local to their module. They are not (yet) referred to by name from other modules, and by declaring them to be global we caused their names to be included even in stripped executables, adding several megabytes to the size of the binary. (The names are not stripped because a dynamically linked library may want to refer to them.) Change the mercury_data__stack_layout__ prefix on the names of generated globals vars to just mercury_data__layout__. It is now merely too long instead of far too long. Include the label number in the label layout structure and the number of typeinfo variables in a var_info structure only with native gc. Their only use is in debugging native gc. Fix some documentation rot. compiler/llds.m: Add a new field to the pragma_c instruction that says whether the compiler-generated C code fragments access any stack variables. compiler/frameopt.m: Use the new field in pragma_c's to avoid a bug. Because frameopt was assuming that the pragma_c instruction that filled in the stack slots containing the call sequence number and depth did not access the stack, it moved the pragma_c before the incr_sp that allocates the frame (it was trying to get it out of the loop). compiler/*.m: Minor changes to set or ignore the extra field in pragma_c, to refer to layout structures via the new prefix, or to handle the --trace option. doc/user_guide.texi: Update the documentation for --trace. runtime/mercury_types.h: Add the type Unsigned. runtime/mercury_goto.h: Use the shorter layout prefix. runtime/mercury_stack_layout.h: Use the shorter layout prefix, and include the label number only with native gc. runtime/mercury_trace.[ch]: runtime/mercury_trace_internal.[ch]: runtime/mercury_trace_external.[ch]: runtime/mercury_trace_util.[ch]: Divide the old mercury_trace.[ch] into several components, with one module for the internal debugger, one for the interface to the external debugger, one for utilities needed by both. Mercury_trace.c now has only the top-level stuff that steers between the two debuggers. runtime/mercury_trace.[ch]: Add the new global variable MR_trace_from_full. Before each call, the calling procedure assigns TRUE to this variable if the caller is fully traced, and FALSE otherwise. Interface traced procedures generate trace events only if this variable is TRUE when they are called (fully traced callee procedures ignore the initial value of the variable). Make MR_trace return immediately without doing anything unless tracing is enabled and a new extra argument to MR_trace is TRUE. This extra argument is always TRUE for trace events in fully traced procedures, while for trace events from interface traced procedures, its value is set from the value of MR_trace_from_full at the time that the procedure was called (i.e. the event is ignored unless the interface traced procedure was called from a fully traced procedure). runtime/mercury_trace.[ch]: runtime/mercury_trace_internal.[ch]: For global variables that are stored in stack slots, make their type Word rather than int. Use a new function MR_trace_event_report instead of calling MR_trace_event with a NULL command structure pointer to indicate that the event is to be reported but there is to be no user interaction. Use %ld formats in printfs and casts to long for better portability. runtime/mercury_trace_internal.c: Save trace-related globals across calls to Mercury library code in the debugger, since otherwise any trace events in this code could screw up e.g. the event number or the call number sequence. Create separate functions for printing port names and determinisms. runtime/mercury_wrapper.h: Disable the tracing of the initialization and finalization code written in Mercury. runtime/Mmakefile: Update for the new source and header files. tests/debugger/{debugger_regs,interpreter,queens}_lib.{m,inp,exp}: One new copy of each existing test case. These ones are intended to be used when the stage 2 library is compiled with tracing, which affects the tests by adding events for the library procedures called from the test programs. The .m files are the same as before; one of the .inp files is a bit different; the .exp files reflect the correct output when the library is compiled with full tracing. tests/debugger/Mmakefile: Provide separate targets for the new set of test cases. Use --trace full instead of --generate-trace. tests/debugger/runtests: Try both the new set of test cases if the old set fails, and report failure only if both sets fail. This is simpler than trying to figure out which set should be really tested, and the probability of a false positive is negligible.	1998-05-16 07:31:33 +00:00
Fergus Henderson	11d8161692	Add support for nested modules. ... Estimated hours taken: 50 Add support for nested modules. - module names may themselves be module-qualified - modules may contain `:- include_module' declarations which name sub-modules - a sub-module has access to all the declarations in the parent module (including its implementation section). This support is not yet complete; see the BUGS and LIMITATIONS below. LIMITATIONS - source file names must match module names (just as they did previously) - mmc doesn't allow path names on the command line any more (e.g. `mmc --make-int ../library/foo.m'). - import_module declarations must use the fully-qualified module name - module qualifiers must use the fully-qualified module name - no support for root-qualified module names (e.g. `:parent:child' instead of `parent:child'). - modules may not be physically nested (only logical nesting, via `include_module'). BUGS - doesn't check that the parent module is imported/used before allowing import/use of its sub-modules. - doesn't check that there is an include_module declaration in the parent for each module claiming to be a child of that parent - privacy of private modules is not enforced ------------------- NEWS: Mention that we support nested modules. library/ops.m: library/nc_builtin.nl: library/sp_builtin.nl: compiler/mercury_to_mercury.m: Add `include_module' as a new prefix operator. Change the associativity of `:' from xfy to yfx (since this made parsing module qualifiers slightly easier). compiler/prog_data.m: Add new `include_module' declaration. Change the `module_name' and `module_specifier' types from strings to sym_names, so that module names can themselves be module qualified. compiler/modules.m: Add predicates module_name_to_file_name/2 and file_name_to_module_name/2. Lots of changes to handle parent module dependencies, to create parent interface (`.int0') files, to read them in, to output correct dependencies information for them to the `.d' and `.dep' files, etc. Rewrite a lot of the code to improve the readability (add comments, use subroutines, better variable names). Also fix a couple of bugs: - generate_dependencies was using the transitive implementation dependencies rather than the transitive interface dependencies to compute the `.int3' dependencies when writing `.d' files (this bug was introduced during crs's changes to support `.trans_opt' files) - when creating the `.int' file, it was reading in the interfaces for modules imported in the implementation section, not just those in the interface section. This meant that the compiler missed a lot of errors. library/graph.m: library/lexer.m: library/term.m: library/term_io.m: library/varset.m: compiler/*.m: Add `:- import_module' declarations to the interface needed by declarations in the interface. (The previous version of the compiler did not detect these missing interface imports, due to the above-mentioned bug in modules.m.) compiler/mercury_compile.m: compiler/intermod.m: Change mercury_compile__maybe_grab_optfiles and intermod__grab_optfiles so that they grab the opt files for parent modules as well as the ones for imported modules. compiler/mercury_compile.m: Minor changes to handle parent module dependencies. (Also improve the wording of the warning about trans-opt dependencies.) compiler/make_hlds.m: compiler/module_qual.m: Ignore `:- include_module' declarations. compiler/module_qual.m: A couple of small changes to handle nested module names. compiler/prog_out.m: compiler/prog_util.m: Add new predicates string_to_sym_name/3 (prog_util.m) and sym_name_to_string/{2,3} (prog_out.m). compiler/*.m: Replace many occurrences of `string' with `module_name'. Change code that prints out module names or converts them to strings or filenames to handle the fact that module names are now sym_names intead of strings. Also change a few places (e.g. in intermod.m, hlds_module.m) where the code assumed that any qualified symbol was fully-qualified. compiler/prog_io.m: compiler/prog_io_goal.m: Move sym_name_and_args/3, parse_qualified_term/4 and parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m, since they are very similar to the parse_symbol_name/2 predicate already in prog_io.m. Rewrite these predicates, both to improve maintainability, and to handle the newly allowed syntax (module-qualified module names). Rename parse_qualified_term/5 as `parse_implicit_qualified_term'. compiler/prog_io.m: Rewrite the handling of `:- module' and `:- end_module' declarations, so that it can handle nested modules. Add code to parse `include_module' declarations. compiler/prog_util.m: compiler/*.m: Add new predicates mercury_public_builtin_module/1 and mercury_private_builtin_module/1 in prog_util.m. Change most of the hard-coded occurrences of "mercury_builtin" to call mercury_private_builtin_module/1 or mercury_public_builtin_module/1 or both. compiler/llds_out.m: Add llds_out__sym_name_mangle/2, for mangling module names. compiler/special_pred.m: compiler/mode_util.m: compiler/clause_to_proc.m: compiler/prog_io_goal.m: compiler/lambda.m: compiler/polymorphism.m: Move the predicates in_mode/1, out_mode/1, and uo_mode/1 from special_pred.m to mode_util.m, and change various hard-coded definitions to instead call these predicates. compiler/polymorphism.m: Ensure that the type names `type_info' and `typeclass_info' are module-qualified in the generated code. This avoids a problem where the code generated by polymorphism.m was not considered type-correct, due to the type `type_info' not matching `mercury_builtin:type_info'. compiler/check_typeclass.m: Simplify the code for check_instance_pred and get_matching_instance_pred_ids. compiler/mercury_compile.m: compiler/modules.m: Disallow directory names in command-line arguments. compiler/options.m: compiler/handle_options.m: compiler/mercury_compile.m: compiler/modules.m: Add a `--make-private-interface' option. The private interface file `<module>.int0' contains all the declarations in the module; it is used for compiling sub-modules. scripts/Mmake.rules: scripts/Mmake.vars.in: Add support for creating `.int0' and `.date0' files by invoking mmc with `--make-private-interface'. doc/user_guide.texi: Document `--make-private-interface' and the `.int0' and `.date0' file extensions. doc/reference_manual.texi: Document nested modules. util/mdemangle.c: profiler/demangle.m: Demangle names with multiple module qualifiers. tests/general/Mmakefile: tests/general/string_format_test.m: tests/general/string_format_test.exp: tests/general/string__format_test.m: tests/general/string__format_test.exp: tests/general/.cvsignore: Change the `:- module string__format_test' declaration in `string__format_test.m' to `:- module string_format_test', because with the original declaration the `__' was taken as a module qualifier, which lead to an error message. Hence rename the file accordingly, to avoid the warning about file name not matching module name. tests/invalid/Mmakefile: tests/invalid/missing_interface_import.m: tests/invalid/missing_interface_import.err_exp: Regression test to check that the compiler reports errors for missing `import_module' in the interface section. tests/invalid/*.err_exp: tests/warnings/unused_args_test.exp: tests/warnings/unused_import.exp: Update the expected diagnostics output for the test cases to reflect a few minor changes to the warning messages. tests/hard_coded/Mmakefile: tests/hard_coded/parent.m: tests/hard_coded/parent.child.m: tests/hard_coded/parent.exp: tests/hard_coded/parent2.m: tests/hard_coded/parent2.child.m: tests/hard_coded/parent2.exp: Two simple tests case for the use of nested modules with separate compilation.	1998-03-03 17:48:14 +00:00
Zoltan Somogyi	5013dd9c76	Implement nondet pragma C codes. ... Estimated hours taken: 40 Implement nondet pragma C codes. runtime/mercury_stacks.h: Define a new macro, mkpragmaframe, for use in the implementation of nondet pragma C codes. This new macro includes space for a struct with a given sruct tag in the nondet stack frame being created. compiler/{prog_data.m,hlds_goal.m}: Revise the representation of pragma C codes, both as the item and in the HLDS. compiler/prog_io_pragma.m: Parse nondet pragma C declarations. Fix the indentation in some places. compiler/llds.m: Include an extra argument in mkframe instructions. This extra argument gives the details of the C structure (if any) to be included in the nondet stack frame to be created. Generalize the LLDS representation of pragma C codes. Instead of a fixed sequence of <assign from inputs, user c code, assign to outputs>, let the sequence contain these elements, as well as arbitrary compiler-generated C code, in any order and possibly with repetitions. This flexibility is needed for nondet pragma C codes. Add a field to pragma C codes to say whether they can call Mercury. Some optimizations can do a better job if they know that a pragma C code cannot call Mercury. Add another field to pragma C codes to give the name of the label they refer to (if any). This is needed to prevent labelopt from incorrectly optimizing away the label definition. Add a new alternative to the type pragma_c_decl, to describe the declaration of the local variable that points to the save struct. compiler/llds_out.m: Output mkframe instructions that specify a struct as invoking the new mkpragmaframe macro, and make sure that the struct is declared just before the procedure that uses it. Other minor changes to keep up with the changes to the representation of pragma C code in the LLDS, and to make the output look a bit nicer. compiler/pragma_c_gen.m: Add code to generate code for nondet pragma C codes. Revise the utility predicates and their data structures a bit to make this possible. compiler/code_gen.m: Add code for the necessary special handling of prologs and epilogs of procedures defined by nondet pragma C codes. The prologs need to be modified to include a programmer-defined C structure in the nondet stack frame and to communicate the location of this structure to the pragma C code, whereas the functionality of the epilog is taken care of by the pragma C code itself. compiler/make_hlds.m: When creating a proc_info for a procedure defined by a pragma C code, we used to insert unifications between the headvars and the vars of the pragma C code into the body goal. We now perform substitutions instead. This removes a factor that would complicate the generation of code for nondet pragma C codes. Pass a moduleinfo down the procedures that warn about singletons (and other basic scope errors). When checking whether to warn about an argument of a pragma C code not being mentioned in the C code fragment, we need to know whether the argument is input or output, since input variables should appear in some code fragments in a nondet pragma C code and must not appear in others. The mode_is_{in,out}put checks need the moduleinfo. (We do not need to check for any variables being mentioned where they shouldn't be. The C compiler will fail in the presence of any errors of that type, and since those variables could be referred to via macros whose definitions we do not see, we couldn't implement a reliable test anyway.) compiler/opt_util.m: Recognize that some sorts of pragma_c codes cannot affect the data structures that control backtracking. This allows peepholing to do a better job on code sequences produced for nondet pragma C codes. Recognize that the C code strings inside some pragma_c codes refer to other labels in the procedure. This prevents labelopt from incorrectly optimizing away these labels. compiler/dupelim.m: If a label is referred to from within a C code string, then do not attempt to optimize it away. compiler/det_analysis.m: Remove a now incorrect part of an error message. compiler/*.m: Minor changes to conform to changes to the HLDS and LLDS data structures.	1998-01-13 10:14:23 +00:00
Zoltan Somogyi	bb4442ddc1	Update copyright dates for 1998. ... Estimated hours taken: 0.5 compiler/*.m: Update copyright dates for 1998.	1998-01-13 10:06:08 +00:00
Zoltan Somogyi	42c540ad67	Give duplicate code elimination more teeth in dealing with similar arguments ... Estimated hours taken: 20 Give duplicate code elimination more teeth in dealing with similar arguments of different function symbols. For the source code :- type t1 ---> f(int) ; g(int, int). :- pred p1(t1::in, int::out) is det. p1(f(Y), Y). p1(g(Y, _), Y). we now generate the C code Define_entry(mercury__xdup__p1_2_0); r1 = const_mask_field(r1, (Integer) 0); proceed(); thus avoiding the cost of testing the function symbol. runtime/mercury_tags.h: Add two new macros, mask_field and const_mask_field, that behave just like field and const_field except that instead of stripping off a known tag from the pointer, they strip (mask) off an unknown tag. compiler/llds.m: Change the first argument of the lval field/3 from tag to maybe(tag). Make the comments on some types more readable. compiler/llds_out.m: If the first arg of the lval field/3 is no, emit a (const_)mask_field macro; otherwise, emit a (const_)field macro. compiler/basic_block.m: New module to convert sequences of instructions to sequences of basic blocks and vice versa. Used in the new dupelim.m. compiler/dupelim.m: Complete rewrite to give duplicate code elimination more teeth. Whereas previously we eliminated blocks of code only if they exactly duplicated other blocks of code, we now look for blocks that can be "anti-unified". For example, the blocks r1 = field(mktag(0), r2, 0) goto L1 and r1 = field(mktag(1), r2, 0) <fall through to L1> anti-unify, with the most specific common generalization being r1 = mask_field(r2, 0) goto L1 If several basic blocks antiunify, we replace one copy with the antiunified block and try to eliminate the others. We do not eliminate blocks that can be fallen into, since eliminating them would require introducing a goto, which would slow the code down. compiler/peephole,m: If a conditional branch to a label is followed by that label or by an unconditional branch to that label, eliminate the branch. Dupelim produces this kind of code. compiler/{code_exprn,exprn_aux,lookup_switch,opt_debug,unify_gen}.m: Minor changes required by the change to field/3. compiler/{frameopt,jumpopt,labelopt,mercury_compile,optimize,value_number}.m: s/__main/_main/ in predicate names. compiler/jumpopt.m: Add some documentation. compiler/unify_gen.m: Fix a module qualified predicate name reference that would not work in Prolog. compiler/notes/compiler_design.html: Document the new file basic_block.m.	1997-12-22 06:59:25 +00:00
David Jeffery	7406335105	This change implements typeclasses. Included are the necessary changes to ... Estimated hours taken: 500 or so This change implements typeclasses. Included are the necessary changes to the compiler, runtime and library. compiler/typecheck.m: Typecheck the constraints on a pred by adding constraints for each call to a pred/func with constraints, and eliminating constraints by applying context reduction. While reducing the constraints, keep track of the proofs so that polymorphism can produce the tyepclass_infos for eliminated constraints. compiler/polymorphism.m: Perform the source-to-source transformation which turns code with typeclass constraints into code without constraints, but with extra "typeclass_info", or "dictionary" parameters. Also, rather than always having a type_info directly for each type variable, sometimes the type_info is hidden inside a typeclass_info. compiler/bytecode*.m: Insert some code to abort if bytecode generation is used when typeclasses are used. compiler/call_gen.m: Generate code for a class_method_call, which forms the body of a class method (by selecting the appropriate proc from the typeclass_info). compiler/dead_proc_elim.m: Don't eliminate class methods if they are potentially used outside the module compiler/hlds_data.m: Define data types to store: - the typeclass definitions - the instances of a class - "constraint_proof". ie. the proofs of redundancy of a constraint. This info is used by polymorphism to construct the typeclass_infos for a constraint. - the "base_tyepclass_info_constant", which is analagous the the base_type_info_constant compiler/hlds_data.m: Define the class_method_call goal. This goal is inserted into the body of class method procs, and is responsible for selecting the appropriate part of the typeclass_info to call. compiler/hlds_data.m: Add the class table and instance table to the module_info. compiler/hlds_out.m: Output info about base_typeclass_infos and class_method_calls compiler/hlds_pred.m: Change the representation of the locations of type_infos from "var" to type_info_locn, which is either a var, or part of a typeclass_info, since now the typeclass_infos contain the type_infos for the type that they constrain. Add constraints to the pred_info. Add constraint_proofs to the pred_info (so that typeclass.m can annotate the pred_info with the reasons that constraints were eliminated, so that polymorphism.m can in turn generate the typeclass_infos for the constraints). Add the "class_method" marker. compiler/lambda.m: A feable attempt at adding class ontexts to lambda expressions, untested and almost certainly not working. compiler/llds_out.m: Output the code addresses for do_*det_class_method, and output appropriately mangled symbol names for base_typeclass_infos. compiler/make_hlds.m: Add constraints to the types on pred and func decls, and add class and instance declarations to the class_table and instance_table respectively. compiler/mercury_compile.m: Add the check_typeclass pass. compiler/mercury_to_mercury.m: Output constraints of pred and funcs, and output typeclass and instance declarations. compiler/module_qual.m: Module qualify typeclass names in pred class contexts, and qualify the typeclass and instance decls themselves. compiler/modules.m: Output typeclass declarations in the short interface too. compiler/prog_data.m: Add the "typeclass" and "instance" items. Define the types to store information about the declarations, including class contexts on pred and func decls. compiler/prog_io.m: Parse constraints on pred and func declarations. compiler/prod_out.m: Output class contexts on pred and func decls. compiler/type_util.m: Add preds to apply a substitution to a class_constraint, and to a list of class constraints. Add type_list_matches_exactly/2. Also add typeclass_info and base_typeclass_info as types which should not be optimised as no_tag types (seeing that we cheat a bit about their representation). compiler/notes/compiler_design.html: Add notes on module qualification of class contexts. Needs expansion to include more stuff on typeclasses. compiler/*.m: Various minor changes. New Files: compiler/base_typeclass_info.m: Produce one base_typeclass_info for each instance declaration. compiler/prog_io_typeclass.m: Parse typeclass and instance declarations. compiler/check_typeclass.m: Check the conformance of an instance declaration to the typeclass declaration, including building up a proof of how superclass constraints are satisfied so that polymorphism.m is able to construct the typeclass_info, including the superclass typeclass_infos. library/mercury_builtin.m: Implement that base_typeclass_info and typeclass_info types, as well as the predicates type_info_from_typeclass_info/3 to extract a type_info from a typeclass_info, and superclass_from_typeclass_info/3 for extracting superclasses. library/ops.m: Add "typeclass" and "instance" as operators. library/string.m: Add a (in, uo) mode for string__length/3. runtime/mercury_ho_call.c: Implement do_call_*det_class_method, which are the pieces of code responsible for extracting the correct code address from the typeclass_info, setting up the arguments correctly, then executing the code. runtime/mercury_type_info.h: Macros for accessing the typeclass_info structure.	1997-12-19 03:10:47 +00:00
Fergus Henderson	05267d2834	Add support for memory profiling. ... Estimated hours taken: 40 (+ unknown time by Zoltan) Add support for memory profiling. (A significant part of this change is actuallly Zoltan's work. Zoltan did the changes to the compiler and a first go at the changes to the runtime and library. I rewrote much of Zoltan's changes to the runtime and library, added support for the new options/grades, added code to interface with mprof, did the changes to the profiler, and wrote the documentation.) [TODO: add test cases.] NEWS: Mention support for memory profiling. runtime/mercury_heap_profile.h: runtime/mercury_heap_profile.c: New files. These contain code to record heap profiling information. runtime/mercury_heap.h: Add new macros incr_hp_msg(), tag_incr_hp_msg(), incr_hp_atomic_msg(), and tag_incr_hp_atomic_msg(). These are like the non-`msg' versions, except that if PROFILE_MEMORY is defined, they also call MR_record_allocation() from mercury_heap_profile.h to record heap profiling information. Also, fix up the indentation in lots of places. runtime/mercury_prof.h: runtime/mercury_prof.c: Added code to dump out memory profiling information to files `Prof.MemoryWords' and `Prof.MemoryCells' (for use by mprof). Change the format of the `Prof.Counts' file so that the first line says what it is counting, the units, and a scale factor. Prof.MemoryWords and Prof.MemoryCells can thus have exactly the same format as Prof.Counts. Also cleaned up the interface to mercury_prof.c a bit, and did various other minor cleanups -- indentation changes, changes to use MR_ prefixes, additional comments, etc. runtime/mercury_prof_mem.h: runtime/mercury_prof_mem.c: Rename prof_malloc() as MR_prof_malloc(). Rename prof_make() as MR_PROF_NEW() and add MR_PROF_NEW_ARRAY(). runtime/mercury_wrapper.h: Minor modifications to reflect the new interface to mercury_prof.c. runtime/mercury_wrapper.c: runtime/mercury_label.c: Rename the old `-p' (primary cache size) option as `-C'. Add a new `-p' option to disable profiling. runtime/Mmakefile: Add mercury_heap_profile.[ch]. Put the list of files in alphabetical order. Delete some obsolete stuff for supporting `.mod' files. Mention that libmer_dll.h and libmer_globals.h are produced by Makefile.DLLs. runtime/mercury_imp.h: Mention that libmer_dll.h is produced by Makefile.DLLs. runtime/mercury_dummy.c: Change a comment to refer to libmer_dll.h rather than libmer_globals.h. compiler/llds.m: Add a new field to `create' and `incr_hp' instructions holding the name of the type, for heap profiling. compiler/unify_gen.m: Initialize the new field of `create' instructions with the appropriate type name. compiler/llds_out.m: Output incr_hp_msg() / tag_incr_hp_msg() instead of incr_hp() / tag_incr_hp(). compiler/*.m: Minor changes to most files in the compiler back-end to accomodate the new field in `incr_hp' and `create' instructions. library/io.m: Add `io__report_full_memory_stats'. library/benchmarking.m: Add `report_full_memory_stats'. This uses the information saved by runtime/mercury_heap_profile.{c,h} to print out a report of memory usage by procedures and by types. Also modify `report_stats' to print out some of that information. compiler/mercury_compile.m: If `--statistics' is enabled, call io__report_full_memory_stats at the end of main/2. This will print out full memory statistics, if the compiler was compiled with memory profiling enabled. compiler/options.m: compiler/handle_options.m: runtime/mercury_grade.h: scripts/ml.in: scripts/mgnuc.in: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Add new option `--memory-profiling' and new grade `.memprof'. Add `--time-profiling' as a new synonym for `--profiling'. Also add `--profile-memory' for more fine-grained control: `--memory-profiling' implies both `--profile-memory' and `--profile-calls'. scripts/mprof_merge_runs: Update to handle the new format of Prof.Counts and to also merge Prof.MemoryWords and Prof.MemoryCells. profiler/options.m: profiler/mercury_profile.m: Add new options `--profile memory-words' (`-m'), `--profile memory-cells' (`-M') and `--profile time' (`-t'). Thes options make the profiler select a different count file, Prof.MemoryWords or Prof.MemoryCells instead of Prof.Counts. specific to time profiling. profiler/read.m: profiler/process_file.m: profiler/prof_info.m: profiler/generate_output.m: Update to handle the new format of the counts file. When reading the counts file, look at the first line of the file to determine what is being profiled. profiler/globals.m: Add a new global variable `what_to_profile' that records what is being profiled. profiler/output.m: Change the headings to reflect what is being profiled. doc/user_guide.texi: Document memory profiling. Document new options. doc/user_guide.texi: compiler/options.m: Comment out the documentation for `.proftime'/`--profile-time', since doing time and call profiling seperately doesn't work, because the code addresses change when you recompile with a different grade. Ditto for `.profmem'/`--profile-memory'. Also comment out the documentation for `.profcalls'/`--profile-calls', since it is redundant -- `.memprof' produces the same information and more. configure.in: Build a `.memprof' grade. (Hmm, should we do this only if `--enable-all-grades' is specified?) Don't ever build a `.profcalls' grade.	1997-12-05 15:49:06 +00:00