43 Commits

Author	SHA1	Message	Date
Peter Ross	ddd77f6f0e	Get pragma foreign_type working for the C backend. ... Estimated hours taken: 16 Branches: main Get pragma foreign_type working for the C backend. doc/reference_manual.texi: Document C pragma foreign_types. compiler/prog_data.m: Add il_foreign_type and c_foreign_type which contain all the necessary data to output a foreign_type on the respective backends. Change foreign_language_type to refer to these new types. compiler/prog_io_pragma.m: Handle the changes to foreign_language_type, and parse C foreign_type declarations. compiler/hlds_data.m: Change the hlds_data__foreign_type type so that it records both the C and IL foreign types. This will allow one to output both foreign type declarations when doing intermodule optimization. compiler/make_hlds.m: Changes so that we store both the IL and C foreign types in hlds_data__foreign_type. Also add an error checking pass where we check that there is a foreign type for the back-end we are currently compiling to. compiler/foreign.m: Change to_exported_type so that it works for both the C and IL backends by getting either the C or IL foreign_type definition. compiler/llds.m: compiler/pragma_c_gen.m: Change pragma_c_input and pragma_c_output so that they record whether or not a type is a foreign_type and if so what is the string which represents that foreign_type. compiler/llds_out.m: When outputting pragma c_code variables that represent foreign_types get the casts correct. Note that this adds the constraint on C foreign types that they are word sized, as all we are doing is casts, not boxing and unboxing. compiler/mlds.m: Change mlds__foreign_type so that we store whether a type is an IL type or a C type. It is the responsibility of the code generator that we never create a reference to a IL foreign type when on the C back-end, and vice versa. compiler/mercury_to_mercury.m: Handle changes to prog_data__foreign_type. compiler/hlds_out.m: compiler/intermod.m: compiler/magic_util.m: compiler/ml_code_gen.m: compiler/ml_type_gen.m: compiler/recompilation_usage.m: compiler/term_util.m: compiler/type_ctor_info.m: compiler/unify_proc.m: Handle changes to hlds_data__foreign_type. compiler/exprn_aux.m: compiler/livemap.m: compiler/middle_rec.m: compiler/opt_util.m: Handle changes to the pragma_c_input and pragma_c_output types. compiler/ml_code_util.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_java.m: compiler/mlds_to_c.m: Handle changes to mlds__foreign_type.	2002-05-07 11:03:17 +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	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
Zoltan Somogyi	a1f326f4e9	Add an alternative to code_exprn that does eager code generation (code_exprn ... Estimated hours taken: 140 Add an alternative to code_exprn that does eager code generation (code_exprn always does lazy code generation). Its main advantages are that the new code is significantly simpler, and that it does not generate unnecessary shuffling code. Its main disadvantage, which is that it does not eliminate the creation of unneeded cells, can be eliminated by switching on --unneeded-code. For now, you can select the use of the new code generator with the --no-lazy-code option (which was previously present but unused). This will be made the default later, after I do more performance tests. Var_locn contains stricter self-checks than code_exprn does. This required modifications to some other parts of the code generator to ensure that the self-checks do not fail unnecessarily. (This mostly took the form of explicitly killing off dead variables before calling code_info__clear_all_registers, which would complain about losing the last record of the value of a variable that was alive as far as it knew.) To make my changes simpler, also took the opportunity to simplify parts of the code generator which were handing around rvals that in fact had to be wrappers around lvals, by handing around the lvals directly. Testing this change also required fixing an old bug which prevented compiling the library with -O1 --trace deep, together with the usual intermodule optimization. The bug is that a library module reads predicates from builtin.opt or private_builtin.opt, does not eliminate them because of the -O1, and then tries to generate traced code for them. However, this fails because the builtin modules contain some predicates that cannot be made to conform to typeinfo-liveness, which is required by tracing. compiler/var_locn.m: The new module that implements eager code generation. compiler/follow_vars.m: Improve the follow_vars pass, since eager code generation requires better follow_vars information. We now generate correct information for generic calls, and record not only where some vars (e.g. those which appear as input arguments of following calls) should be put, but also which registers are not reserved for those variables and are thus available for other variables. compiler/hlds_goal.m: Modify the follow_vars field of the goal_info to record the number of the first non-reserved register. compiler/code_info.m: Replace the general-purpose predicate code_info__cache_exprn, which associated a variable with an rval without generating code, with a set of special-purpose predicates such as code_info__assign_const_to_var and code_info__assign_cell_to_var, some of which can generate code. These new predicates and some older ones (e.g. code_info__setup_call) now choose at runtime whether to call code_exprn or var_locn. The basis for the decision is checking whether the code_info structure contains an exprn_info or a var_locn_info. This is decided in code_info__init based on the value of the lazy_code option, and maintained unchanged from then on. Rename some predicates to better reflect their current possible behaviors. compiler/unify_gen.m: Call the new special-purpose predicates in code_info instead of code_info__cache_exprn. Replace an incorrect clause with a call to error, since that clause could never be invoked. compiler/call_gen.m: Hand over the task of generating the args of generic calls to code_info, since it already has code to do the right thing, which includes reserving the registers to be used for the input args. Notify the rest of the code generator after the last use of non-forward-live variables, in order to avoid spurious calls to error (it is an error to clobber the last location of a live variable). Notify the rest of the code generator when generic calls overwrite registers, to allow the proper consistency checks to be made. If an output variable is singleton, then do not make it known to the code generator. It never will never become dead, and may thus cause a spurious compiler abort if its storage is ever clobbered. Export a predicate for use by follow_vars. Factor out some common code. Call the new preds in code_info where necessary. compiler/pragma_c_gen.m: Notify the rest of the code generator after the last use of non-forward-live variables, in order to avoid spurious calls to error (it is an error to clobber the last location of a live variable). If an output variable is singleton, then do not make it known to the code generator. It never will never become dead, and may thus cause a spurious compiler abort if its storage is ever clobbered. When using var_locn, ensure that none of the input arguments of a model_semi pragma_c_code is assigned to r1. If we did, and the last reference to the value of that argument was after an assignment to SUCCESS_INDICATOR, the C compiler would be forced to generate code to shuffle the value of the argument out of the way. compiler/code_exprn.m: Minor changes to return lvals directly instead of lvals wrapped inside rvals and to conform the new format of follow_vars. Do not include the registers reserved by follow_vars in the search for a spare register. compiler/lookup_switch.m: compiler/switch_gen.m: Fix an old bug that did not matter with code_exprn but does matter with var_locn: the branch end structure was being computed in the wrong place. compiler/disj_gen.m: At the ends of non-last disjuncts, kill off the variables that we needed to know inside the disjunct but won't need to know after the disjunct, in order to avoid error messages about throwing away their state. The variables affected are those which are needed only by the resumption point of the next disjunct, not by enclosing resumption points or forward execution. compiler/arg_info.m: Associate an lval, not an rval, with each argument. compiler/*.m: Minor changes to conform to (a) the new format of follow_vars, (b) the replacement of rvals containing lvals by lvals. compiler/code_util.m: Add some utility predicates for var_locn.m. compiler/exprn_aux.m: Add some utility functions for var_locn.m. Export a predicate for var_locn.m. compiler/handle_options.m: If --no-lazy-code is set, switch on the "optimizations" on whose presence it depends. compiler/mercury_compile.m: compiler/code_gen.m: Turn off tracing for predicates that don't obey typeinfo liveness for backend_by_preds and backend_by_phases respectively. Look up options in the globals structure in the module_info, not in the globals structure in the I/O state, since this is where we turn off tracing. (We should later make sure that other parts of the compiler are also consistent on this issue.) compiler/stack_layout.m: Throw away any continuation_info structures that belong to predicates that don't obey typeinfo liveness.	2000-09-16 00:08:27 +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
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	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
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
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
Thomas Conway	5c955626f2	These changes make var' and term' polymorphic. ... Estimated hours taken: 20 These changes make `var' and `term' polymorphic. This allows us to make variables and terms representing types of a different type to those representing program terms and those representing insts. These changes do not *fix* any existing problems (for instance there was a messy conflation of program variables and inst variables, and where necessary I've just called varset__init(InstVarSet) with an XXX comment). NEWS: Mention the changes to the standard library. library/term.m: Make term, var and var_supply polymorphic. Add new predicates: term__generic_term/1 term__coerce/2 term__coerce_var/2 term__coerce_var_supply/2 library/varset.m: Make varset polymorphic. Add the new predicate: varset__coerce/2 compiler/prog_data.m: Introduce type equivalences for the different kinds of vars, terms, and varsets that we use (tvar and tvarset were already there but have been changed to use the polymorphic var and term). Also change the various kinds of items to use the appropriate kinds of var/varset. compiler/*.m: Thousands of boring changes to make the compiler type correct with the different types for type, program and inst vars and varsets.	1998-11-20 04:10:36 +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	d1855187e5	Implement new methods of handling failures and the end points of branched ... Estimated hours taken: 260 Implement new methods of handling failures and the end points of branched control structures. compiler/notes/failure.html: Fix an omission about the handling of resume_is_known in if-then-elses. (This omission lead to a bug in the implementation.) Optimize cuts across multi goals when curfr is known to be equal to maxfr. Clarify the wording in several places. compiler/code_info.m: Completely rewrite the methods for handling failure. Separate the fields of code_info into three classes: those which do not change after initialization, those which record state that depends on where in the HLDS goal we are, and those which contain persistent data such as label and cell counters. Rename grab_code_info and slap_code_info as remember_position and reset_to_position, and add a wrapper around the remembered code_info to make it harder to make mistakes in its use. (Only the location-dependent fields of the remembered code_info are used, but putting only them into a separate data structure would result in more, not less, memory being allocated.) Gather the predicates that deal with handling branched control structures into a submodule. Reorder the declarations and definitions of access predicates to conform to the new order of fields. Reorder the declarations and definitions of the failure handling submodule to better reflect the separation of higher-level and lower-level predicates. compiler/code_gen.m: Replace code_gen__generate_{det,semi,non}_goal_2 with a single predicate, since for most HLDS constructs the code here is the same anyway (the called preds check the code model when needed). Move classification of the various kinds of unifications to unify_gen, since that is where it belongs. Move responsibility for initializing the code generator's trace info to code_info. Move the generation of code for negations to ite_gen, since the handling of negations is a cut-down version of the handling of negations. This should make the required double maintenance easier, and more likely to happen. compiler/disj_gen.m: compiler/ite_gen.m: These are the two modules that handle most failures; they have undergone a significant rewrite. As part of this rewrite, factor out the remaining common code between model_non and model_{det,semi} goals. compiler/unify_gen.m: Move classification of the various kinds of unifications here from code_gen. This allows us to keep several previously exported predicates private. compiler/call_gen.m: Factor out some code that was common to ordinary calls, higher order calls and method calls. Move the common code that checks whether we are doing tracing to trace.m. Replace call_gen__generate_{det,semi,nondet}_builtin with a single predicate. Delete the commented out call_gen__generate_complicated_unify, since it will never be needed and in any case suffered from significant code rot. compiler/llds.m: Change the mkframe instruction so that depending on one of its arguments, it can create either ordinary frames, or the cut-down frames used by the new failure handling algorithm (they have only three fixed fields: prevfr, redoip and redofr). compiler/llds_out.m: Emit a #define MR_USE_REDOFR before including mercury_imp.h, to tell the runtime we are using the new failure handling scheme. This effectively changes the grade of the compiled module. Emit MR_stackvar and MR_framevar instead of detstackvar and framevar. This is a step towards cleaning up the name-space, and a step towards making both start numbering at 0. For the time being, the compiler internally still starts counting framevars at 0; the code in llds_out.m adds a +1 offset. compiler/trace.m: Change the way trace info is initialized to fit in with the new requirements of code_info.m. Move the "are we tracing" check from the callers to the implementation of trace__prepare_for_call. compiler/*.m: Minor changes in accordance with the major ones above. compiler/options.m: Introduce a new option, allow_hijacks, which is set to "yes" by default. It is not used yet, but the idea is that when it is set to no, the code generator will not generate code that hijacks the nondet stack frame of another procedure invocation; instead, it will create a new temporary nondet stack frame. If the current procedure is model_non, it will have three fields: prevfr, redoip and redofr. If the current procedure is model_det or model_semi, it will have a fourth field that is set to the value of MR_sp. The idea is that the runtime system, which will be able to distinguish between ordinary frames (whose size is at least 5 words), 3-word and 4-word temporary frames, will now be able to use the redofr slots of all three kinds of frames and the fourth slot values of 4-word temporary frames as the addresses relative to which framevars and detstackvars respectively ought to be offset in stack layouts. compiler/handle_options.m: Turn off allow_hijacks if the gc method is accurate. runtime/mercury_stacks.h: Change the definitions for the nondet stack handling macros to accommodate the new nondet stack handling discipline. Define a new macro for creating temp nondet frames. Define MR_based_stackvar and MR_based_framevar (both of which start numbering slots at 1), and express other references, including MR_stackvar and MR_framevar and backward compatible definitions of detstackvar and framevar for hand-written C code, in terms of those two. runtime/mercury_stack_trace.[ch]: Add a new function to print a dump of the fixed elements nondet stack, for debugging my changes. (The dump does not include variable values.) runtime/mercury_trace_internal.c: Add a new undocumented command "D" for dumping the nondet stack (users should not know about this command, since the output is intelligible only to implementors). Add a new command "toggle_echo" that can cause the debugger to echo all commands. When the input to the debugger is redirected, this echo causes the output of the session to be much more readable. runtime/mercury_wrapper.c: Save the address of the artificial bottom nondet stack frame, so that the new function in mercury_stack_trace.c can find out where to stop. runtime/mercury_engine.c: runtime/mercury_wrapper.c: Put MR_STACK_TRACE_THIS_MODULE at the tops of these modules, so that the labels they define (e.g. do_fail and global_success) are registered in the label table when their module initialization functions are called. This is necessary for a meaningful nondet stack dump. runtime/mercury_grade.h: Add a new component to the grade string that specifies whether the code was compiled with the old or the new method of handling the nondet stack. This is important, because modules compiled with different nondet stack handling disciplines are not compatible. This component depends on whether MR_USE_REDOFR is defined or not. runtime/mercury_imp.h: If MR_DISABLE_REDOFR is defined, undefine off MR_USE_REDOFR before including mercury_grade.h. This is to allow people to continue working on un-updated workspaces after this change is installed; they should put "EXTRA_CFLAGS = -DMR_DISABLE_REDOFR" into Mmake.stage.params. (This way their stage1 will use the new method of handling failure, while their stage2 2&3 will use the old one.) This change should be undone once all our workspaces have switched over to the new failure handling method. tests/hard_coded/cut_test.{m,exp}: A new test case to tickle the various ways of handling cuts in the new code generator. tests/hard_coded/Mmakefile: Enable the new test case.	1998-07-20 10:04:02 +00:00
Fergus Henderson	73131e8df3	Undo Zoltan's bogus update of all the copyright dates. ... Estimated hours taken: 0.75 library/*.m: compiler/*.m: Undo Zoltan's bogus update of all the copyright dates. The dates in the copyright header should reflect the years in which the file was modified (and no, changes to the copyright header itself don't count as modifications).	1998-01-23 12:57:08 +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
Tyson Dowd	2a97f96d1a	Generate stack layouts for accurate garbage collection. ... Estimated hours taken: 50 Generate stack layouts for accurate garbage collection. compiler/base_type_layout.m: Change the order of some arguments so that threaded data structures are more often in the final two arguments (allows easy use of higher order predicates). Simplify some code using higher order preds. Export base_type_layout__construct_pseudo_type_info, as stack_layout.m needs to be able to generate pseudo_type_infos too. Fix problems with cell numbers being re-used -- get the next cell number from module_info, and update module_info after processing base_type_layouts. compiler/code_gen.m: Add information about each procedure to the continuation info. Handle new field in c_procedure. compiler/continuation_info.m: Redesign most of this module to deal with labels that are continuation points for multiple calls. Change the order of some arguments so that threaded data structures are in the final two arguments. Cleaned up and documented code. compiler/dupelim.m: compiler/exprn_aux.m: Handle new label_entry data type. compiler/export.m: compiler/opt_debug.m: Handle new label_entry and general data types. compiler/llds_out.m: Add an argument to get_proc_label to control whether a "mercury_" prefix is wanted. Handle new label_entry and general data types. compiler/llds.m: Add a new alternative for data_const - a label_entry. Add a new alternative for data_name - general, which allows any sort of data, with names generated elsewhere. Add the pred_proc_id as a field of c_procedure. compiler/optimize.m: compiler/llds_common.m: compiler/optimize.m: Handle new field in c_procedure. compiler/mercury_compile.m: Generate layout information after code has been generated, and output stack layouts. compiler/notes/compiler_design.html: Document new stack_layout module. compiler/stack_layout.m: New file - generates the LLDS code that defines global constants to hold the stack_layout structures. compiler/options.m: compiler/handle_options.m: Add --stack-layout option which outputs stack layouts. Make accurate gc imply stack_layout.	1997-11-08 13:12:08 +00:00
Fergus Henderson	04b720630b	Update the copyright messages so that (a) they contain the correct years ... and (b) they say "Copyright (C) ... _The_ University of Melbourne".	1997-07-27 15:09:59 +00:00
Simon Taylor	27d156bbb5	Implemented a :- use_module directive. This is the same as ... Estimated hours taken: 14 Implemented a :- use_module directive. This is the same as :- import_module, except all uses of the imported items must be explicitly module qualified. :- use_module is implemented by ensuring that unqualified versions of items only get added to the HLDS symbol tables if they were imported using import_module. Indirectly imported items (from `.int2' files) and items declared in `.opt' files are treated as if they were imported with use_module, since all uses of them should be module qualified. compiler/module_qual.m Keep two sets of type, mode and inst ids, those which can be used without qualifiers and those which can't. Renamed some predicates which no longer have unique names since '__' became a synonym for ':'. Made mq_info_set_module_used check whether the current item is in the interface, rather than relying on its caller to do the check. Removed init_mq_info_module, since make_hlds.m now uses the mq_info built during the module qualification pass. compiler/prog_data.m Added a pseudo-declaration `used', same as `imported' except uses of the following items must be module qualified. Added a type need_qualifier to describe whether uses of an item need to be module qualified. compiler/make_hlds.m Keep with the import_status whether current item was imported using a :- use_module directive. Use the mq_info structure passed in instead of building a new one. Ensure unqualified versions of constructors only get added to the cons_table if they can be used without qualification. compiler/hlds_module.m Added an extra argument to predicate_table_insert of type need_qualifier. Only add predicates to the name and name-arity indices if they can be used without qualifiers. Changed the structure of the module-name-arity index, so that lookups can be made without an arity, such as when type-checking module qualified higher-order predicate constants. This does not change the interface to the module_name_arity index. Factored out some common code in predicate_table_insert which applies to both predicates and functions. compiler/hlds_pred.m Removed the opt_decl import_status. It isn't needed any more since all uses of items declared in .opt files must now be module qualified. Added some documentation about when the clauses_info is valid. compiler/intermod.m Ensure that predicate and function calls in the `.opt' file are module qualified. Use use_module instead of import_module in `.opt' files. compiler/modules.m Handle use_module directives. Report a warning if both use_module and import_module declarations exist for the same module. compiler/mercury_compile.m Collect inter-module optimization information before module qualification, since it can't cause conflicts any more. This means that the mq_info structure built in module_qual.m can be reused in make_hlds.m, instead of building a new one. compiler/prog_out.m Add a predicate prog_out__write_module_list, which was moved here from module_qual.m. compiler/typecheck.m Removed code to check that predicates declared in `.opt' files were being used appropriately, since this is now handled by use_module. compiler/*.m Added missing imports, mostly for prog_data and term. NEWS compiler/notes/todo.html doc/reference_manual.texi Document `:- use_module'. tests/valid/intermod_lambda_test.m tests/valid/intermod_lambda_test2.m tests/invalid/errors.m tests/invalid/errors2.m Test cases.	1997-06-29 23:11:42 +00:00
Fergus Henderson	8c60f93849	Fix a bug where tag_switch.m was generating references to non-existent ... Estimated hours taken: 4 Fix a bug where tag_switch.m was generating references to non-existent labels for det switches that don't cover the full range of the type. llds.m: Add new alternative `do_not_reached' to the code_addr type. exprn_aux.m: dupelim.m: livemap.m: llds_out.m: opt_util.m: opt_debug.m: Add new code to handle `do_not_reached'. tag_switch.m: When generating tag switch jump tables for det switches that do not cover the whole type, which can happen if the initial inst of the switch variable is a bound(...) inst that represents a subtype, make sure that we don't generate references to undefined labels for cases that occur in the switch var's type but not in the switch var's initial inst. Instead, make such references refer to a label that jumps to `do_not_reached'.	1997-04-17 07:49:11 +00:00
Zoltan Somogyi	a4a1a7788c	Add support for taking the addresses of words on the heap as well as on ... Estimated hours taken: 7 Add support for taking the addresses of words on the heap as well as on on either stack. This will be used later to support tail recursion modulo constructor application as well as parallelism. The support provided is a first draft. Since nothing in the compiler currently generates code that uses the new facilities, they have not been tested yet beyond ensuring that they don't interfere with the old functionality of the compiler. llds: Add a new type, mem_ref, that denotes a reference to a stackvar, a framevar, or to a field of a cell on the heap. Add a new function symbol to the type rval: mem_addr(mem_ref), which represents the address of the word denoted by the mem_ref. Add a new function symbol to the type lval: mem_ref(rval). Given that Rval is an address, mem_ref(Rval) denotes the word at that address. The value of Rval should have originally come from a mem_addr(_) type rval, but that value could have been store in registers, stack slots etc since then. code_exprn, code_info, dupelim, exprn_aux, garbage_out, livemap, llds_common, llds_out, middle_rec, opt_debug, opt_util, vn_cost, vn_filter: Added code to handle the new mem_ref type and the new alternatives in lval and rval. exprn_aux: Make exprn_aux__substitute_lval_in_lval more thorough. vn_type: Add vn shadows of the new things in llds. vn_flush, vn_order, vn_util: Handle the new things in llds and/or their vn shadows.	1997-01-21 05:05:31 +00:00
Zoltan Somogyi	54bb1c4a67	Move the code that generates code for pragma_c_codes to a new module. ... Estimated hours taken: 3 code_gen, pragma_c_code: Move the code that generates code for pragma_c_codes to a new module. llds: Change the representation of reg and temp lvals, in order to create the concept of a "register type" and to reduce memory requirements. Also add a comment indicating a possible future extension dealing with model_non pragma_c_codes. code_exprn, code_info: Add the ability to request registers of a given type, or a specific register, when acquiring registers. bytecode, bytecode_gen, call_gen, dupelim, exprn_aux, follow_vars, frameopt, garbage_out, jumpopt, llds_out, middle_rec, opt_debug, opt_util, store_alloc, string_switch, tag_switch, unify_gen, vn_block, vn_cost, vn_filter, vn_flush, vn_order, vn_temploc, vn_type, vn_util, vn_verify: Small changes to accommodate the new register representation. hlds_goal: Add a comment indicating a possible future extension dealing with model_non pragma_c_codes. inlining: Add a comment indicating a how to deal with a possible future extension dealing with model_non pragma_c_codes.	1996-12-31 09:58:59 +00:00
Fergus Henderson	07635fbf96	Fix things so that we can now generate unboxed floats as ... Estimated hours taken: 24 Fix things so that we can now generate unboxed floats as static constants. We do this by generating static constants as structs rather than as arrays. Reorganize the way llds_out.m handles types to simplify the code and eliminate unnecessary casts in the generated C code. llds.m, vn_type.m: Change `llds_type' to be more precise, by adding two new alternatives (data_ptr and code_ptr) to the categories, and modifying the various type predicates accordingly. llds.m, base_type_info.m, base_type_layout.m, garbage_out.m, llds_common.m, opt_debug.m, unify_gen.m. Remove the "has pointers?" field from the `c_data' and `data_addr' types in llds.m and from the `cell_info' type in llds_common.m, since they're not needed anymore. (Instead llds_out.m uses `llds__rval_type' etc. to figure out whether something has pointers.) base_type_info.m, base_type_layout.m: Fix a bug: the `exported' field in the `c_data' type needs to be set to yes for `Status = abstract_exported' types as well as for `Status = exported' types. exprn_aux.m: If unboxed_float is yes, then floats are now considered constants. llds_out.m: Change `output_rval' and `output_lval' so that they output a value as its natural type, rather than cast to Integer or Word. Add a new predicate `output_rval_as_type(Rval, Type)', and change most of the calls to `output_rval' to instead call `output_rval_as_type' specifying the appropriate type. Similarly add `output_lval_as_word' and change some of the calls to `output_lval' to call `output_lval_as_word' instead. Eliminate `output_rval_as_float', since its functionality has been folded into `output_rval' and `output_rval_as_type'. Delete `output_rval_lval', since it's not needed anymore. Neither is the `args_have_pointers' predicate. Merge the shared code in for handling `c_data' modules and `create' rvals into a new predicate output_const_term_decl; this predicate outputs struct declarations for the generated terms, so we can now output floats in such terms without needing to do type punning in static constants. options.m: `--single-prec-float' is no longer an alias for `--unboxed-float'. Also fix a couple of other parts of the help message.	1996-12-19 08:15:04 +00:00
Thomas Conway	8e4e537a38	These changes have 2 parts: ... Estimated hours taken: 3 These changes have 2 parts: * Fix a bug in unify_gen triggered by zoltans fix to a bug triggered by dmo's graphics project and add a test case for it. * Fix a couple of small bugs in the testing procedures where they required you to have . in your path. mercury/compiler/code_exprn.m, mercury/compiler/code_info.m: add the predicate code_{exprn,info}__materialize_vars_in_rval/5 which generates code to materialize the vars in an rval and updates the exprn info appropriately. This predicate was added because it is needed for generating the sub-unifications where a deconstruction has assignments into the term (ie field(....) = var; rather than the other way around). mercury/compiler/exprn_aux.m: export exprn_aux__vars_in_rval. mercury/compiler/follow_vars.m: fix a singleton variable warning. mercury/compiler/unify_gen.m: When generating code to assign into the fields of a term within a deconstruction, materialize any variables in the the field expression (into which you are going to assign) before doing the assignment. Before this fix, the code generator was emitting code that contained var(M), which with certain combinations of opt flags was causing an abort in llds_out. tests/runtests: tiny bugfix so that runtests works for people who don't have `.' in their path. tests/valid/Mmake: enable `two_way_unif' which tests the bugfix in unify_gen shown above mercury/tools/bootcheck: tiny bugfix so that runtests works for people who don't have `.' in their path.	1996-11-05 07:10:51 +00:00
Zoltan Somogyi	8bd1aaa9de	Rename address_const to code_addr_const, and add base_type_info_const ... Estimated hours taken: 15 hlds_data: Rename address_const to code_addr_const, and add base_type_info_const as a new alternative in cons_id, and make corresponding changes to cons_tag. Make hlds_type__defn an abstract type. llds: Rename address_const to code_addr_const, and add data_addr_const as a new alternative in rval_const. Change type "label" to have four alternatives, not three: local/2 (for internal labels), c_local (local to a C module), local/1 (local a Mercury module but not necessarily to a C module, and exported. llds_out: Keep track of the things declared previously, and don't declare them again unnecessarily. Associate indentation with the following item rather than the previous item (the influence of 244); this results in braces being put in different places than previously, but should be easier to maintain. Handle the new forms of addresses and labels. Refer to c_local labels as STATIC when not using --split-c-files. code_info: Use a presently junk field to store a cell counter, which is used to allocate distinguishing numbers to create'd cells. Previously we used the label counter, which meant that label numbers changed when we optimized away some creates. Handle the new forms of addresses and labels. exprn_aux: Handle the new forms of addresses and labels. We are now more precise in figuring out what label address forms will be considered constants by the C compilers. others: Changes to handle the new forms of addresses and labels, and/or to access hlds_type__defn as an abstract type.	1996-08-05 12:05:14 +00:00
Zoltan Somogyi	40e727614d	Add a boolean argument to the create rval, which should be set to true ... Estimated hours taken: 2 llds.m: Add a boolean argument to the create rval, which should be set to true if the cell created must have a unique reference. vn_type.m: Add a corresponding argument to vn_create. others: Fix references to creates and vn_creates.	1996-08-04 23:18:56 +00:00
Zoltan Somogyi	9e31ef9baa	Split llds into two parts. llds.m defines the data types, while llds_out.m ... Estimated hours taken: 1.5 Split llds into two parts. llds.m defines the data types, while llds_out.m has the predicates for printing the code. Removed the call_closure instruction. Instead, we use calls to the system-defined addresses do_call_{det,semidet,nondet}_closure. This is how call_closure was implemented already. The advantage of the new implementation is that it allows jump optimization of what used to be call_closures, without new code in jumpopt.	1996-04-24 08:59:06 +00:00
Zoltan Somogyi	649b6908c3	Rename branch_delay_slot to have_delay_slot. ... Estimated hours taken: 8 options.m: Rename branch_delay_slot to have_delay_slot. Set optimize_delay_slot in -O2 only if have_delay_slot was set earlier. This is possible now because the default optimization level is now set in mc. mercury_compile: Change verbose output a bit to be more consistent. dead_proc_elim: Export the predicates that will eventually be needed by inlining.m. inlining.m: Use the information about the number of times each procedure is called to inline local nonrecursive procedures that are called exactly once. EXCEPT that this is turned off at the moment, since the inlining of parse_dcg_goal_2 in prog_io, which this change enables, causes the compiler to emit incorrect code. prog_io: Moved the data type definitions to prog_data. (Even though prog_io.m is ten times the size of prog_data.m, the sizes of the .c files are not too dissimilar.)	1996-04-24 01:00:23 +00:00
Fergus Henderson	974d3b9247	Do some more work on improving floating-point performance: ... Estimated hours taken: 2 Do some more work on improving floating-point performance: emit boxed floating point constants as static ground terms. options.m: Add new option --unboxed-float. exprn_aux.m Add --unboxed-float to the `exprn_opts' that affect whether or not things can be static constants. If --unboxed-float is not set, and --static-ground-terms is, then consider float_consts to be constant. code_exprn.m, lookup_switch.m: Trivial changes to handle new arity of exprn_opts type. llds.m: If --unboxed-float is not set, and --static-ground-terms is, then output `static const Float mercury_float_const_...' declarations for float_consts.	1996-04-07 07:41:52 +00:00
Fergus Henderson	1bf905b515	Fix a second occurrence of the problem with casts in the initializers ... Estimated hours taken: 1 (plus lots of time debugging the problem via email) Fix a second occurrence of the problem with casts in the initializers of static constants causing gcc to generate non-position-independent code. This prevented the use of gcc on AIX RS/6000 systems, and was also preventing us from creating genuinely shared shared libraries on Solaris. compiler/llds.m: Emit static constants as `const Word * mercury_const_n [] = { ... }' rather than `const Word mercury_const_n [] = { ... }' not just in the case when the constant contains code addresses, but also when it contains data addresses, including addresses of other static constants and/or string literals. exprn_aux.m: Add nondet (in, out) modes to the ..._contain_rval predicates, which nondeterministically generate all the contained rvals, and export args_contain_rval. For use by llds.m as required by the above change.	1996-04-06 19:00:24 +00:00
Zoltan Somogyi	c8da041006	Made a start towards getting better code generated for nested creates ... Estimated hours taken: 4 code_exprn: Made a start towards getting better code generated for nested creates and towards getting rid of useless "shuffle lval" instructions. Also, some minor cleanup. exprn_aux: Add some auxiliary predicates for the new code_exprn. delay_info: Remove a useless import of hlds, which is now empty.	1996-04-05 08:27:21 +00:00
Zoltan Somogyi	b4f71d7b53	Both code_exprn and lookup_switch had code to check whether an ... Estimated hours taken: 2 exprn_aux: Both code_exprn and lookup_switch had code to check whether an expression is constant or not. Some of the code is different due to different handling of variables in rvals, but exprn_aux now contains the common subset. This common subset used to treat some address constants incorrectly, simply by not considering them; they are now considered and treated properly. code_exprn, lookup_switch, exprn_aux: Remove redundant option lookups in the process of checking for constant expressions. code_exprn: Other minor cleanups, including removal of a block of code Tom says was "deep magic" (but which turns out to be unnecessary). code_info: Removed some dead code. options: Added real support for --opt-level, in the form of a table of default values of options for each optimization level between 0 and 5 (both inclusive). This needs a new form of documentation. How do you do tables in texinfo?	1996-03-11 10:32:20 +00:00
Zoltan Somogyi	3224e94532	A new pass to remove unnecessary assignment unifications. ... excess: A new pass to remove unnecessary assignment unifications. mercury_compile: Call the new excess assignment module. options: Add a new option, excess_assign, to control the new optimization. Add another, num-real-regs, to specify how many of r1, r2 etc are actually real registers. The default is now set to 5 for kryten; later it should be supplied by the mc script, with a value determined at configuration time. tag_switch: Use num-real-regs to figure out whether it is likely to be worthwhile to eliminate the common subexpression of taking the primary tag of a variable. Also fix an old performance bug: the test for when a jump table is worthwhile was reversed. value_number, vn_block: Do value numbering on extended basic blocks, not basic blocks. vn_debug: Modify an information message. labelopt: Clean up an export an internal predicate for value numbering. Replace bintree_set with set. middle_rec: Prepare for the generalization of middle recursion optimization to include predicates with an if-then-else structure. cse_detection: Fix a bug: when hoisting a common desconstruction X = f(Yi), create new variables for the Yi. This avoids problems with any of the Yis appearing in other branches of the code. goal_util: Add a new predicate for use by cse_detection. common: Fix a bug: recompute instmap deltas, since they may be affected by the optimization of common structures. code_info: Make an error message more explicit. det_analysis: Restrict import list to the needed modules. *.m: Import assoc_list.	1995-10-27 09:39:28 +00:00
Zoltan Somogyi	693543830f	Added last call optimization for nondet predicates. ... jumpopt: Added last call optimization for nondet predicates. llds: Added a new lval type to represent the succip slot of nondet stack frames. other files: Changes required by the change to llds (there is a minor unrelated change in vn_cost as well). Tyson: please check my changes to code_info__get_shape_num and garbage_out__write_liveval.	1995-09-06 02:22:24 +00:00
Fergus Henderson	fdb97147c7	Export a pred for use by llds.m. ... exprn_aux.m: Export a pred for use by llds.m. llds.m: Write out static constants with type `const Word * []' rather than `const Word []' if they contain code addresses, since for shared libraries on Irix 5, gcc does not support casting code addresses to words in the initializers for static constants	1995-05-27 18:10:00 +00:00
Fergus Henderson	f7e5d837e1	A bunch of bug fixes! ... code_info.m: Bug fix: change generate_pre_commit and generate_commit so that the values which need to be saved and restored are always pushed onto the det stack, even in nondet predicates. The reason is that if the committed goal fails, curfr is not valid, so we can't restore the fields from the nondet stack. (This way may well be more efficient anyway.) disj_gen.m, ite_gen.m: Handle the case when the current failure continuation is unknown on entry to the disjunction or nondet if-then-else by creating a new frame on the nondet stack. (Originally we just aborted in this case; recently we "fixed" this, but it turned out that the fix was not correct, for the same reason as the above-mentioned bug in pre_commit/commit. llds.m: Add succfr/1 and prevfr/1 to the rval type in llds.m, since they were needed by the above bug fixes. (This caused dozens of changes elsewhere to handle the new types.) Also fix a trivial bug that I recently introduced which prevented --mod-comments from working. live_vars.m: Fix bug in allocation of stack slots for nondet code. (This is the one that caused the bug that ksiew and I found when writing a calculator program.) peephole.m: Disable the succeed_discard() optimization, since it causes incorrect code to be generated. It was replacing modframe(do_fail) ... succeed() with modframe(do_fail) ... succeed_discard() even when there were instructions such as mkframe() in between. modes.m, hlds.m: When modechecking switches, record the binding of the switch variable as we enter each case, so that we get the determinism analysis right. mercury_compile.pp: Make sure that we set the exit status to be non-zero if we find any errors. typecheck.m, modes.m, undef_types.m, undef_modes.m: Don't invoke type-checking if there are undefined types. Don't invoke mode-checking if there are undefined modes. This avoids the problem of the compiler aborting with an internal error if there are undefined types/modes.	1995-05-12 13:44:58 +00:00
Fergus Henderson	ac4f8ba0fb	Add copyright messages. ... compiler/*: Add copyright messages. Change all occurences of *.nl in comments to *.m. compiler/mercury_compile.pp: Change the output to the .dep files to use *.m rather than *.nl. (NOTE: this means that `mmake' will not work any more if you call your files *.nl!!!)	1995-03-30 21:03:41 +00:00
Fergus Henderson	c9b3ccbd2e	label_opt was erroneously optimizing away code which was not dead, ... opt_util.m, exprn_aux.m: label_opt was erroneously optimizing away code which was not dead, because it was not considering references to the code via address_consts in rvals. So I've changed opt_util__instr_labels to return those labels too, and added some new utility preds in exprn_aux to deal with that. exprn_aux.m: Remove expr_aux__expr_is_constant/1, since it was not used (and it was broken anyway).	1995-03-21 09:44:38 +00:00
Thomas Conway	56185418db	a new module for manipulating rvals and lvals. ... exprn_aux.nl: a new module for manipulating rvals and lvals. code_exprn.nl: the new bottom level of the new code generator. This replaces a large chunk of code_info. *code* & *gen*: various small changes to use the new bottom level of the code generator.	1995-03-15 08:07:56 +00:00