44 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	189b9215ae	This diff implements stack slot optimization for the LLDS back end based on ... Estimated hours taken: 400 Branches: main This diff implements stack slot optimization for the LLDS back end based on the idea that after a unification such as A = f(B, C, D), saving the variable A on the stack indirectly also saves the values of B, C and D. Figuring out what subset of {B,C,D} to access via A and what subset to access via their own stack slots is a tricky optimization problem. The algorithm we use to solve it is described in the paper "Using the heap to eliminate stack accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot. That paper also describes (and has examples of) the source-to-source transformation that implements the optimization. The optimization needs to know what variables are flushed at call sites and at program points that establish resume points (e.g. entries to disjunctions and if-then-elses). We already had code to compute this information in live_vars.m, but this code was being invoked too late. This diff modifies live_vars.m to allow it to be invoked both by the stack slot optimization transformation and by the code generator, and allows its function to be tailored to the requirements of each invocation. The information computed by live_vars.m is specific to the LLDS back end, since the MLDS back ends do not (yet) have the same control over stack frame layout. We therefore store this information in a new back end specific field in goal_infos. For uniformity, we make all the other existing back end specific fields in goal_infos, as well as the similarly back end specific store map field of goal_exprs, subfields of this new field. This happens to significantly reduce the sizes of goal_infos. To allow a more meaningful comparison of the gains produced by the new optimization, do not save any variables across erroneous calls even if the new optimization is not enabled. compiler/stack_opt.m: New module containing the code that performs the transformation to optimize stack slot usage. compiler/matching.m: New module containing an algorithm for maximal matching in bipartite graphs, specialized for the graphs needed by stack_opt.m. compiler/mercury_compile.m: Invoke the new optimization if the options ask for it. compiler/stack_alloc.m: New module containing code that is shared between the old, non-optimizing stack slot allocation system and the new, optimizing stack slot allocation system, and the code for actually allocating stack slots in the absence of optimization. Live_vars.m used to have two tasks: find out what variables need to be saved on the stack, and allocating those variables to stack slots. Live_vars.m now does only the first task; stack_alloc.m now does the second, using code that used to be in live_vars.m. compiler/trace_params: Add a new function to test the trace level, which returns yes if we want to preserve the values of the input headvars. compiler/notes/compiler_design.html: Document the new modules (as well as trace_params.m, which wasn't documented earlier). compiler/live_vars.m: Delete the code that is now in stack_alloc.m and graph_colour.m. Separate out the kinds of stack uses due to nondeterminism: the stack slots used by nondet calls, and the stack slots used by resumption points, in order to allow the reuse of stack slots used by resumption points after execution has left their scope. This should allow the same stack slots to be used by different variables in the resumption point at the start of an else branch and nondet calls in the then branch, since the resumption point of the else branch is not in effect when the then branch is executed. If the new option --opt-no-return-calls is set, then say that we do not need to save any values across erroneous calls. Use type classes to allow the information generated by this module to be recorded in the way required by its invoker. Package up the data structures being passed around readonly into a single tuple. compiler/store_alloc.m: Allow this module to be invoked by stack_opt.m without invoking the follow_vars transformation, since applying follow_vars before the form of the HLDS code is otherwise final can be a pessimization. Make the module_info a part of the record containing the readonly data passed around during the traversal. compiler/common.m: Do not delete or move around unifications created by stack_opt.m. compiler/call_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/var_locn.m: Allow the code generator to delete its last record of the location of a value when generating code to make an erroneous call, if the new --opt-no-return-calls option is set. compiler/code_gen.m: Use a more useful algorithm to create the messages/comments that we put into incr_sp instructions, e.g. by distinguishing between predicates and functions. This is to allow the new scripts in the tool directory to gather statistics about the effect of the optimization on stack frame sizes. library/exception.m: Make a hand-written incr_sp follow the new pattern. compiler/arg_info.m: Add predicates to figure out the set of input, output and unused arguments of a procedure in several different circumstances. Previously, variants of these predicates were repeated in several places. compiler/goal_util.m: Export some previously private utility predicates. compiler/handle_options.m: Turn off stack slot optimizations when debugging, unless --trace-optimized is set. Add a new dump format useful for debugging --optimize-saved-vars. compiler/hlds_llds.m: New module for handling all the stuff specific to the LLDS back end in HLDS goal_infos. compiler/hlds_goal.m: Move all the relevant stuff into the new back end specific field in goal_infos. compiler/notes/allocation.html: Update the documentation of store maps to reflect their movement into a subfield of goal_infos. compiler/*.m: Minor changes to accomodate the placement of all back end specific information about goals from goal_exprs and individual fields of goal_infos into a new field in goal_infos that gathers together all back end specific information. compiler/use_local_vars.m: Look for sequences in which several instructions use a fake register or stack slot as a base register pointing to a cell, and make those instructions use a local variable instead. Without this, a key assumption of the stack slot optimization, that accessing a field in a cell costs only one load or store instruction, would be much less likely to be true. (With this optimization, the assumption will be false only if the C compiler's code generator runs out of registers in a basic block, which for the code we generate should be unlikely even on x86s.) compiler/options.m: Make the old option --optimize-saved-vars ask for both the old stack slot optimization (implemented by saved_vars.m) that only eliminates the storing of constants in stack slots, and the new optimization. Add two new options --optimize-saved-vars-{const,cell} to turn on the two optimizations separately. Add a bunch of options to specify the parameters of the new optimizations, both in stack_opt.m and use_local_vars.m. These are for implementors only; they are deliberately not documented. Add a new option, --opt-no-return-cells, that governs whether we avoid saving variables on the stack at calls that cannot return, either by succeeding or by failing. This is for implementors only, and thus deliberately documented only in comments. It is enabled by default. compiler/optimize.m: Transmit the value of a new option to use_local_vars.m. doc/user_guide.texi: Update the documentation of --optimize-saved-vars. library/tree234.m: Undo a previous change of mine that effectively applied this optimization by hand. That change complicated the code, and now the compiler can do the optimization automatically. tools/extract_incr_sp: A new script for extracting stack frame sizes and messages from stack increment operations in the C code for LLDS grades. tools/frame_sizes: A new script that uses extract_incr_sp to extract information about stack frame sizes from the C files saved from a stage 2 directory by makebatch and summarizes the resulting information. tools/avg_frame_size: A new script that computes average stack frame sizes from the files created by frame_sizes. tools/compare_frame_sizes: A new script that compares the stack frame size information extracted from two different stage 2 directories by frame_sizes, reporting on both average stack frame sizes and on specific procedures that have different stack frame sizes in the two versions.	2002-03-28 03:44:41 +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
Fergus Henderson	9d453c5a7b	Delete the `cast_to_unsigned' unary operator from builtin_ops, and ... Estimated hours taken: 4 Delete the `cast_to_unsigned' unary operator from builtin_ops, and replace it with an `unsigned_le' binary operator for doing unsigned less-then-or-equal comparisons. This change makes the semantics and typing of the builtin operators more consistent. compiler/builtin_ops.m: Delete the `cast_to_unsigned' unary_op. Add a new `unsigned_le' binary_op. compiler/dense_switch.m: compiler/lookup_switch.m: compiler/ml_simplify_switch.m: Use `binop(unsigned_le, X, Y)' rather than `binop(<=, unop(cast_to_unsigned, X), Y)'. compiler/bytecode.m: compiler/c_util.m: compiler/llds.m: compiler/llds_out.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/opt_debug.m: compiler/vn_util.m: compiler/vn_cost.m: Delete code for handling `cast_to_unsigned' and instead add code for handling `unsigned_le'. compiler/vn_cost.m: Also add `mktag' and `unmktag' as zero_cost_unops. compiler/c_util.m: Add a new procedure `c_util__unsigned_comparison_op', for use by llds_out.m.	2001-01-20 15:42:48 +00:00
Fergus Henderson	4be69fa961	Eliminated a lot of the dependencies on the the `code_model' type, ... Estimated hours taken: 6 Eliminated a lot of the dependencies on the the `code_model' type, and move that type from llds.m into a new module `code_model'. The aim of this change is to improve the modularity of the compiler by reducing the number of places in the compiler front-end that depend on back-end concepts and the number of places in the MLDS back-end which depend on the LLDS. compiler/code_model.m: New module. Contains the code_model type and associated procedures. compiler/llds.m: Move the code_model type into code_model.m. compiler/hlds_goal.m: Move the goal_info_get_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/hlds_out.m: Delete `hlds_out__write_code_model', since it wasn't being used. compiler/hlds_pred.m: Move the proc_info_interface_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/goal_path.m: When computing the `maybe_cut' field for `some' goals, compute it by comparing the determinism rather than by comparing the goal_infos. compiler/unique_modes.m: Use determinism and test for soln_count = at_most_many rather than using code_model and testing for model_non. compiler/inlining.m: Test for determinism nondet/multi rather than testing for code_model model_non. compiler/hlds_pred.m: compiler/det_report.m: Change valid_code_model_for_eval_method, which succeeded unless the eval_method was minimal_model and the code_model was model_det, to valid_determinism_for_eval_method, which succeeds unless the eval_method is minimal_model and the determinism cannot fail. As well as avoiding a dependency on code_model in the HLDS modules, this also fixes a bug where det_report could give misleading error messages, saying that `multi' was a valid determinism for `minimal_model' predicates, when in fact the compiler will always report a determinism error if you declare a `minimal_model' predicate with determinism `multi'. (Actually the code in which this bug occurs is in fact unreachable, but this is no doubt also a bug... I'll address that one in a separate change.) compiler/lookup_switch.m: Simplify the code a bit by using globals__lookup_*_option rather than globals__get_option and then getopt__lookup_option. compiler/*.m: Add `import_module' declarations for `code_model', and in some cases remove `import_module' declarations for `llds'.	2000-11-23 04:32:51 +00:00
Fergus Henderson	c7aa4140f1	Reorganize the code for handling switches in the MLDS and ... Estimated hours taken: 2 Reorganize the code for handling switches in the MLDS and LLDS back-ends to reduce code duplication. compiler/switch_util.m: New file. Contains stuff for switches that is shared between the MLDS and LLDS back-ends. compiler/ml_switch_gen.m: compiler/ml_string_switch.m: compiler/ml_tag_switch.m: compiler/switch_gen.m: compiler/string_switch.m: compiler/tag_switch.m: Move code that was duplicated in the LLDS and MLDS back-ends into string_util.m. Change some names and import_module declarations to match the new organization. compiler/notes/compiler_design.html: Document the new module switch_util.m. Also mention ml_tag_switch.m. compiler/lookup_switch.m: compiler/dense_switch.m: compiler/ml_dense_switch.m: Change some names and import_module declarations to match the new organization. (I forgot to commit these at the same time as the rest of my change described above.)	2000-11-16 10:48:42 +00:00
Fergus Henderson	287d7d0880	Use shifts and masks rather than unsigned division and ... Estimated hours taken: 0.75 compiler/lookup_switch.m: Use shifts and masks rather than unsigned division and unsigned modulus. There's two reasons for this change. The main one is to reduce the number of places where we depend on `cast_to_unsigned'. The other reason is so that we generate better code for the IL back-end (and for any future back-ends like it, e.g. the JVM back-end).	2000-11-14 07:30:18 +00:00
Zoltan Somogyi	79372969dd	Get the most important part of value numbering done at code generation time ... Estimated hours taken: 16 Get the most important part of value numbering done at code generation time when using --no-lazy-code. compiler/var_locn.m: When a field of a cell is assigned to a variable, do not associate the variable with the lvals in which it is found; instead, simply record the assignment e.g. of field N of X to Y. Later, when we need to place Y somewhere, we generate materialize X first. The point of this change is that if X is needed not just by Y but also by other variables, then we now save X in an lval after materializing it; other users of X can thus get it from faster storage. compiler/code_info.m: compiler/lookup_switch.m: compiler/unify_gen.m: Minor updates to conform to changes in the interfaces of the predicates exported from var_locn.m.	2000-09-19 03:05:16 +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	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
Fergus Henderson	773bd702cc	Some more changes to minimize the complexity of the intermodule dependencies. ... Estimated hours taken: 2.5 Some more changes to minimize the complexity of the intermodule dependencies. In particular, ensure that bytecode.m does not need to import llds.m. compiler/llds.m: compiler/builtin_ops.m: Move the definitions of the unary_op and binary_op types into a new module `builtin_ops'. These types are used by three of the different back-ends (bytecode, llds, and mlds) and therefore deserve to be in their own module. compiler/bytecode.m: Define a type `byte_reg_type' and use that instead of llds__reg_type. Delete the import of module llds. compiler/notes/compiler_design.html: Document the new module builtin_ops. compiler/rl_exprn.m: Add a comment explaining why we need to import llds (and builtin_ops). compiler/base_type_layout.m: compiler/bytecode.m: compiler/code_util.m: compiler/dense_switch.m: compiler/ite_gen.m: compiler/jumpopt.m: compiler/llds_out.m: compiler/lookup_switch.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/rl_exprn.m: compiler/string_switch.m: compiler/tag_switch.m: compiler/transform_llds.m: compiler/unify_gen.m: compiler/value_number.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_flush.m: compiler/vn_type.m: compiler/vn_util.m: compiler/vn_verify.m: Add imports of module builtin_ops to lots of modules that imported llds.	1999-07-10 07:20:09 +00:00
Simon Taylor	a4c18e979a	Most of the uses of the type `tree:tree/1' are lists of instructions. ... Estimated hours taken: 0.5 Most of the uses of the type `tree:tree/1' are lists of instructions. `tree__is_empty' is used to ask "was any code generated", but `tree__is_empty' fails for `node([])'. This has not been a problem in the past because the code generator builds up a trees of lists that are known to be non-empty. Parts of the RL generation code can create empty lists of instructions, and it can't hurt to test for this case elsewhere. compiler/tree.m: Added `tree__tree_of_lists_is_empty', which is similar to `tree__is_empty' except that `node([])' is also considered empty. compiler/lookup_switch.m: compiler/rl_gen.m: Use `tree__tree_of_lists_is_empty' instead of `tree__is_empty'.	1999-06-16 00:35:50 +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
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	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	11d8161692	Add support for nested modules. ... Estimated hours taken: 50 Add support for nested modules. - module names may themselves be module-qualified - modules may contain `:- include_module' declarations which name sub-modules - a sub-module has access to all the declarations in the parent module (including its implementation section). This support is not yet complete; see the BUGS and LIMITATIONS below. LIMITATIONS - source file names must match module names (just as they did previously) - mmc doesn't allow path names on the command line any more (e.g. `mmc --make-int ../library/foo.m'). - import_module declarations must use the fully-qualified module name - module qualifiers must use the fully-qualified module name - no support for root-qualified module names (e.g. `:parent:child' instead of `parent:child'). - modules may not be physically nested (only logical nesting, via `include_module'). BUGS - doesn't check that the parent module is imported/used before allowing import/use of its sub-modules. - doesn't check that there is an include_module declaration in the parent for each module claiming to be a child of that parent - privacy of private modules is not enforced ------------------- NEWS: Mention that we support nested modules. library/ops.m: library/nc_builtin.nl: library/sp_builtin.nl: compiler/mercury_to_mercury.m: Add `include_module' as a new prefix operator. Change the associativity of `:' from xfy to yfx (since this made parsing module qualifiers slightly easier). compiler/prog_data.m: Add new `include_module' declaration. Change the `module_name' and `module_specifier' types from strings to sym_names, so that module names can themselves be module qualified. compiler/modules.m: Add predicates module_name_to_file_name/2 and file_name_to_module_name/2. Lots of changes to handle parent module dependencies, to create parent interface (`.int0') files, to read them in, to output correct dependencies information for them to the `.d' and `.dep' files, etc. Rewrite a lot of the code to improve the readability (add comments, use subroutines, better variable names). Also fix a couple of bugs: - generate_dependencies was using the transitive implementation dependencies rather than the transitive interface dependencies to compute the `.int3' dependencies when writing `.d' files (this bug was introduced during crs's changes to support `.trans_opt' files) - when creating the `.int' file, it was reading in the interfaces for modules imported in the implementation section, not just those in the interface section. This meant that the compiler missed a lot of errors. library/graph.m: library/lexer.m: library/term.m: library/term_io.m: library/varset.m: compiler/*.m: Add `:- import_module' declarations to the interface needed by declarations in the interface. (The previous version of the compiler did not detect these missing interface imports, due to the above-mentioned bug in modules.m.) compiler/mercury_compile.m: compiler/intermod.m: Change mercury_compile__maybe_grab_optfiles and intermod__grab_optfiles so that they grab the opt files for parent modules as well as the ones for imported modules. compiler/mercury_compile.m: Minor changes to handle parent module dependencies. (Also improve the wording of the warning about trans-opt dependencies.) compiler/make_hlds.m: compiler/module_qual.m: Ignore `:- include_module' declarations. compiler/module_qual.m: A couple of small changes to handle nested module names. compiler/prog_out.m: compiler/prog_util.m: Add new predicates string_to_sym_name/3 (prog_util.m) and sym_name_to_string/{2,3} (prog_out.m). compiler/*.m: Replace many occurrences of `string' with `module_name'. Change code that prints out module names or converts them to strings or filenames to handle the fact that module names are now sym_names intead of strings. Also change a few places (e.g. in intermod.m, hlds_module.m) where the code assumed that any qualified symbol was fully-qualified. compiler/prog_io.m: compiler/prog_io_goal.m: Move sym_name_and_args/3, parse_qualified_term/4 and parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m, since they are very similar to the parse_symbol_name/2 predicate already in prog_io.m. Rewrite these predicates, both to improve maintainability, and to handle the newly allowed syntax (module-qualified module names). Rename parse_qualified_term/5 as `parse_implicit_qualified_term'. compiler/prog_io.m: Rewrite the handling of `:- module' and `:- end_module' declarations, so that it can handle nested modules. Add code to parse `include_module' declarations. compiler/prog_util.m: compiler/*.m: Add new predicates mercury_public_builtin_module/1 and mercury_private_builtin_module/1 in prog_util.m. Change most of the hard-coded occurrences of "mercury_builtin" to call mercury_private_builtin_module/1 or mercury_public_builtin_module/1 or both. compiler/llds_out.m: Add llds_out__sym_name_mangle/2, for mangling module names. compiler/special_pred.m: compiler/mode_util.m: compiler/clause_to_proc.m: compiler/prog_io_goal.m: compiler/lambda.m: compiler/polymorphism.m: Move the predicates in_mode/1, out_mode/1, and uo_mode/1 from special_pred.m to mode_util.m, and change various hard-coded definitions to instead call these predicates. compiler/polymorphism.m: Ensure that the type names `type_info' and `typeclass_info' are module-qualified in the generated code. This avoids a problem where the code generated by polymorphism.m was not considered type-correct, due to the type `type_info' not matching `mercury_builtin:type_info'. compiler/check_typeclass.m: Simplify the code for check_instance_pred and get_matching_instance_pred_ids. compiler/mercury_compile.m: compiler/modules.m: Disallow directory names in command-line arguments. compiler/options.m: compiler/handle_options.m: compiler/mercury_compile.m: compiler/modules.m: Add a `--make-private-interface' option. The private interface file `<module>.int0' contains all the declarations in the module; it is used for compiling sub-modules. scripts/Mmake.rules: scripts/Mmake.vars.in: Add support for creating `.int0' and `.date0' files by invoking mmc with `--make-private-interface'. doc/user_guide.texi: Document `--make-private-interface' and the `.int0' and `.date0' file extensions. doc/reference_manual.texi: Document nested modules. util/mdemangle.c: profiler/demangle.m: Demangle names with multiple module qualifiers. tests/general/Mmakefile: tests/general/string_format_test.m: tests/general/string_format_test.exp: tests/general/string__format_test.m: tests/general/string__format_test.exp: tests/general/.cvsignore: Change the `:- module string__format_test' declaration in `string__format_test.m' to `:- module string_format_test', because with the original declaration the `__' was taken as a module qualifier, which lead to an error message. Hence rename the file accordingly, to avoid the warning about file name not matching module name. tests/invalid/Mmakefile: tests/invalid/missing_interface_import.m: tests/invalid/missing_interface_import.err_exp: Regression test to check that the compiler reports errors for missing `import_module' in the interface section. tests/invalid/*.err_exp: tests/warnings/unused_args_test.exp: tests/warnings/unused_import.exp: Update the expected diagnostics output for the test cases to reflect a few minor changes to the warning messages. tests/hard_coded/Mmakefile: tests/hard_coded/parent.m: tests/hard_coded/parent.child.m: tests/hard_coded/parent.exp: tests/hard_coded/parent2.m: tests/hard_coded/parent2.child.m: tests/hard_coded/parent2.exp: Two simple tests case for the use of nested modules with separate compilation.	1998-03-03 17:48:14 +00:00
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
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
David Jeffery	dbe4d39d18	Fix a bug in lookup switch generation which meant that some semidet switches ... Estimated hours taken: 6 (to track it down). Fix a bug in lookup switch generation which meant that some semidet switches were always succeeding. The problem was that, when the switch was dense enough to get rid of the range check, getting rid of the range check meant that the bit vector test could now fail. It may be better to turn these on in the other order. compiler/lookup_switch.m: When we get rid of the range check, turn the bit vector test on.	1997-09-23 08:17:14 +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	0fed6d77e8	Optimize the bit-vector test for small semidet lookup switches: ... Estimated hours taken: 1 compiler/lookup_switch.m: Optimize the bit-vector test for small semidet lookup switches: in the situation where all the cases fit into a single word, we don't need to figure out at runtime which word to use. Also, some minor improvements to the maintainability of the code: move the code for figuring out how many bits per word to use into a separate procedure, and use more informative variable names in that procedure.	1997-05-07 05:43:30 +00:00
Fergus Henderson	3ec8a17ffc	Enable the code to treat `__' as an alternative syntax for module ... Estimated hours taken: 8 Enable the code to treat `__' as an alternative syntax for module qualification, after fixing various places in the compiler where we use `__' in ways that are incompatible with this. compiler/prog_io.m: compiler/prog_io_goal.m: Uncomment the code to handle `__' as module qualification. compiler/intermod.m: compiler/hlds_module.m: compiler/modecheck_unify.m: Fix bugs in the handling of module qualified higher-order terms. compiler/*.m: s/hlds__/hlds_/g compiler/passes_aux.m: s/process__/process_/g compiler/pragma_c_gen.m: compiler/code_gen.m: s/code_gen__/pragma_c_gen__/ for the predicates defined in pragma_c_gen.m (this ought to have been done when the code was first moved from code_gen.m to pragma_c_gen.m). compiler/llds.m: s/llds__proc_id/llds_proc_id/g The reason for this was to avoid ambiguity between proc_id in hlds_pred.m and llds__proc_id in llds.m. compiler/quantification.m: compiler/make_hlds.m: compiler/mercury_to_c.m: s/goal_vars/quantification__goal_vars/g The reason for this was to avoid ambiguity between goal_vars in quantification.m and goal_util__goal_vars in goal_util.m. compiler/dupelim.m: compiler/optimize.m: s/dupelim__main/dupelim_main/g The reason for this change is that a program can only have one main/2 predicate. compiler/prog_io_dcg.m: Remove the old "temporary hack" to strip off and ignore io__gc_call/1, since the new handling of `__' broke it. It was only useful for optimizing NU-Prolog performance, which we don't care about anymore. compiler/mercury_compile.m: compiler/modules.m: compiler/intermod.m: compiler/prog_io.m: Remove occurrences of io__gc_call. compiler/llds_out.m: compiler/base_type_info.m: Ensure that we properly handle the special hacks in mercury_builtin where predicates from other modules (e.g. term__context_init) are defined in mercury_builtin because they are needed for type_to_term and term_to_type. llds_out.m: don't put `mercury_builtin' in the mangled names for those symbols. base_type_info.m: handle types whose status is "imported" in their own module.	1997-02-23 06:08:34 +00:00
Fergus Henderson	f92d064168	Use nicer names for some recently introduced library predicates. ... library/int.m: Rename int__int_min as int__min_int, int__int_max as int__max_int, and int__int_bits as int__bits_per_int. This change is for aesthetic reasons. compiler/lookup_switch.m: Change calls to int__int_bits to instead call int__bits_per_int.	1997-02-19 00:49:39 +00:00
Thomas Conway	25bd0c8b0d	add the following 'limits' predicates: ... Estimated hours taken: 0.2 library/int.m: add the following 'limits' predicates: int__max/1, int__min/1, int__bits/1. compiler/lookup_switch.m: use the min of int__bits and bits_per_word when building the bitvectors (and computing the data array) for lookup switches.	1997-01-20 06:40:02 +00:00
Zoltan Somogyi	403d1064e0	Rename a bunch of predicates to make their names better reflect what they do. ... Estimated hours taken: 0.5 Rename a bunch of predicates to make their names better reflect what they do.	1996-12-26 02:07:51 +00:00
Zoltan Somogyi	5544174d7c	An overhaul of the code saving and restoring heap pointers and tickets, ... Estimated hours taken: 3 An overhaul of the code saving and restoring heap pointers and tickets, and some other changes that affect the interface of code_info. code_info: The predicates that handle save heap pointers and tickets now return the slot these things are stored in; the predicates that restore and/or discard these values must give them back. This should avoid the problem we used to have with the same slot being used to store both a heap pointer and a ticket. Rename some predicates to better reflect their purpose. Accept pre_ and post_goal_update preds and the type lookup preds from code_aux, since this is where they belong. code_aux: Move pre_ and post_goal_update preds and the type lookup preds to code_info, since that is where they belong. call_gen: Fix the bug that broke nondet tailcalls for the case when the tailcall is a higher order call. code_gen: Use the new way of saving and restoring heap pointers. We now save tickets across negations; the absence of code to do this was a bug. disj_gen: Use the new way of saving and restoring heap pointers and tickets. Avoid restoring anything in the first disjunct. In pruned disjunctions, avoid saving the heap pointer more than once. (This does mean that we may restore it in some cases were we didn't used to, but such cases can be expected to be quite rare.) ite_gen: Use the new way of saving and restoring heap pointers and tickets. dense_switch, lookup_switch, middle_rec, unify_gen: Rename some called predicates as required by the changes to the other modules.	1996-12-22 06:37:44 +00:00
Zoltan Somogyi	679eaeaec9	Remove redundant code. ... Estimated hours taken: 0.25 disj_gen: Remove redundant code. liveness: Trap some unreachable code. lookup_switch, tree: Move the code for testing code trees for emptyness to tree.m.	1996-12-21 06:39:24 +00:00
Zoltan Somogyi	08a5f48e2c	Take the code generator a big step closer to notes/ALLOCATION. ... Estimated hours taken: _____ Take the code generator a big step closer to notes/ALLOCATION. The new code generator emits code that is smaller and faster than the code we used to emit. Nondet liveness is no longer used; nondet live sets are always empty. In code that was being modified anyway, remove its handling. Other uses will be removed later (this keeps this change from being far too big; as it is it is merely too big). Similarly for cont-lives. In several places, clarify the code that gathers several code pieces together. call_gen: Unset the failure continuation and flush the resume vars to their stack slots before nondet calls. Move the code that decides whether a nondet call can be a tailcall to code_info. code_aux: Remove the code to handle resume points, since these are now handled in the specific constructs that need them. Replace it with a sanity check. code_exprn: Add a predicate to place multiple vars. code_gen: Remove the predicate code_gen__generate_forced_goal, since it packaged together some operations that should be executed at different times. Don't unset the failure continuation after every nondet goal; this is now done in the constructs that need it. Modify the handling of negation to use resume point info according to notes/ALLOCATION. Remove the predicate code_gen__ensure_vars_are_saved which was use to save all lives variables to the stack before nondet disjunctions and if-then-elses; we don't do that anymore. code_info: Significantly simplify and document the handling of failure continuations, and make the types involved abstract types. Factor out common code in the handling of det and semi commits. Keep track of "zombies", variables that are dead wrt forward execution but whose values we need because they may be needed at a resume point we can reach. Remove several now unneeded predicates, and introduce new predicates to help other modules. code_util: Add a couple of predicates to check whether ia goal cannot fail before flushing all variables to the stack, and whether a goal cannot flush any variables to the stack. These are used in liveness to decide which entry labels will be needed at resume points. disj_gen: Unify the handling of det and semi disjunctions. Model the code handling of nondet disjunctions on the code handling pruned disjunctions. It is possible that the handling of nondet and pruned disjunctions can also be unified; the new code should make this significantly easier. Make the code conform to notes/ALLOCATION. This means saving only the variables mentioned in the resume_point field, not flushing all live variables to the stack at the start of a nondet disjunction, handling zombies, and using the new method of flushing variables at the ends of branched structures. ite_gen: Unify the handling of det and semi if-then-elses. Model the code handling of nondet if-then-elses on the code handling det/semi if-then-elses. It is possible that the handling of nondet and pruned if-then-elses can also be unified; the new code should make this significantly easier. Make the code conform to notes/ALLOCATION. This means saving only the variables mentioned in the resume_point field, not flushing all live variables to the stack at the start of a nondet if-then-else, handling zombies, and using the new method of flushing variables at the ends of branched structures. Apply the new rules about liveness in if-then-elses, which say that the else part is parallel not to the then part but to the conjunction of the condition and the then part. dense_switch, lookup_switch, string_switch, switch_gen, tag_switch, middle_rec: Use the new method of flushing variables at the ends of branched structures. Don't call remake_with_store map; switch_gen will do so. Fix an old bug in lookup_switch. The code in switch_gen which looked for the special case of a two-way switch used to use a heuristic to decide which one was recursive and which one was a base case. We now check the codes of the cases. hlds_goal: Adjust the structure of the resume_point field to make it easier to use. Add a more convenient access predicate. hlds_out: Don't print the nondet liveness and cont live fields, since they are not used anymore. Comment out the printing of the context field, which is rarely useful. Modify the printing of the resume_point field to conform to its new definition. live_vars: Use the resume_point field, not the nondetlives field, to decide which variables may be needed on backward execution. Remove some code copied from liveness.m. liveness: Put the several pieces of information we thread through the traversal predicates into a single tuple. Don't put variables which are local to one branch of a branched structure into the post-birth sets of other branches. Apply the new rules about liveness in if-then-elses, which say that the else part is parallel not to the then part but to the conjunction of the condition and the then part. Variables that are needed in the else part but not in the condition or the then part now die in at the start of the condition (they will be protected by the resume point on the condition). We now treat pruned and non-pruned disjunctions the same way wrt deadness; the old way was too conservative (it had to be). We still mishandle branches which produce some variables but can't succeed. mercury_compile: Liveness now prints its own progress message with -V; support this. store_alloc: When figuring out what variables need to be saved across calls, make sure that we put in interference arcs between those variables and those that are required by enclosing resume points. Don't compute cont-lives, since they are not used anymore. livemap: Fix the starting comment.	1996-12-18 08:56:10 +00:00
Zoltan Somogyi	ee24e66a71	Switch from using a stack of store_maps in the code_info to govern what ... Estimated hours taken: 2.5 Switch from using a stack of store_maps in the code_info to govern what goes where at the end of each branched structure to using the store map fields of the goal expressions of those structures. Fix variable names where they resembled the wrong kind of map(var, lval). code_info: Remove the operations on stacks of store maps. Modify the generate_forced_saves and remake_with_store_map operations to take a store_map parameter. When making variables magically live, pick random unused variables to hold them, since we can no longer use the guidance of the top store map stack entry. This may lead to the generation of some excess move instructions at non-reachable points in the code; this will be fixed later. code_gen: Remove the store map push and pop invocations. Modify the generate_forced_goal operation to take a store_map parameter. code_exprn: Export a predicate for use by code_info. middle_rec, disj_gen, ite_gen, switch_gen, dense_switch, lookup_switch, string_switch, tag_switch: Pass the store map around to get it to invocations of the primitives in code_gen and code_info that now need it. goal_util: Name apart the new follow_vars field in hlds__goal_infos. (This should have been in the change that introduced that field.) common, constraint, cse_detection, det_analysis, dnf, excess, follow_code, intermod, lambda, lco, liveness, make_hlds, mode_util, modes, polymorphism, quantification, simplify, switch_detection, typecheck, unique_modes, unused_args: Fix variable names. follow_vars, store_alloc: Add comments.	1996-11-23 10:39:02 +00:00
Andrew Bromage	06e05928e1	Makes instmap and instmap_delta into ADTs. ... Estimated hours taken: 38 Makes instmap and instmap_delta into ADTs. compiler/code_gen.m: compiler/code_info.m: compiler/cse_detection.m: compiler/det_analysis.m: compiler/dnf.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_goal.m: compiler/hlds_out.m: compiler/hlds_pred.m: compiler/live_vars.m: compiler/liveness.m: compiler/lookup_switch.m: compiler/mode_debug.m: compiler/mode_info.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/polymorphism.m: compiler/simplify.m: compiler/store_alloc.m: compiler/switch_detection.m: compiler/transform.m: compiler/uniq_modes.m: compiler/unused_args.m: Miscellaneous minor changes to use the new instmap.m compiler/constraint.m: Removed unnecessary duplication of code in constraint__checkpoint/4 and constraint__no_output_vars/2. compiler/det_util.m: Changed no_output_vars/4 to det_no_output_vars/4, moved body of code to instmap.m. compiler/instmap.m: Added abstract types instmap/0, instmap_delta/0. Added predicates: instmap__init_reachable/1, instmap__init_unreachable/1, instmap_delta_init_reachable/1, instmap_delta_init_unreachable/1, instmap__is_reachable/1, instmap__is_unreachable/1, instmap_delta_is_reachable/1, instmap_delta_is_unreachable/1, instmap__from_assoc_list/2, instmap_delta_from_assoc_list/2, instmap__vars/2, instmap__vars_list/2, instmap_delta_changed_vars/2, instmap_delta_lookup_var/3, instmap__set/3, instmap_delta_insert/4, instmap_delta_apply_instmap_delta/3, instmap_delta_restrict/3, instmap_delta_delete_vars/3, instmap__no_output_vars/4, instmap_delta_apply_sub/4, instmap__to_assoc_list/2, instmap_delta_to_assoc_list/2. Renamed predicates: instmap__lookup_var/3 (was instmap_lookup_var/3) instmap__lookup_vars/3 (was instmap_lookup_vars/3) instmap__apply_instmap_delta/3 (was apply_instmap_delta/3) instmap__merge/5 (was instmap_merge/5) instmap__restrict/3 (was instmap_restrict/3) Moved predicates: merge_instmap_delta/5 (from mode_util.m) Removed predicates: instmapping_lookup_var/3 compiler/mode_util.m: Moved merge_instmap_delta/5 to instmap.m	1996-11-19 01:18:24 +00:00
Andrew Bromage	5c149e55b2	Mode analyser reorganisation. ... Estimated hours taken: 20 Mode analyser reorganisation. compiler/mode_util.m: Removed: instmap_init/1, apply_instmap_delta/3, instmap_lookup_var/3, instmapping_lookup_var/3, instmap_restrict/3, map_restrict/3 (all moved to instmap.m). compiler/hlds_goal.m: Removed the declarations of instmap_delta, instmap and instmapping. compiler/mode_errors.m: Added report_mode_errors/2 (was modecheck_report_errors, from modes.m). compiler/modes.m: Predicates now exported: modecheck_goal/4 modecheck_goal_expr/5 (previously named modecheck_goal_2/5) handle_extra_goals/8 mode_context_to_unify_context/3 Moved to mode_errors.m: modecheck_report_errors/2 Moved to instmap.m: compute_instmap_delta/4 instmap_merge/3 instmap_lookup_vars (was instmap_lookup_arg_list/3) compute_instmap_delta/4 Moved to mode_debug.m: Type port/0 mode_checkpoint/4 Moved to modecheck_call.m: modecheck_call_pred/7 modecheck_higher_order_call/10 modecheck_higher_order_pred_call/4 modecheck_higher_order_func_call/7 Moved to modecheck_unify.m: modecheck_unification/9 categorize_unify_var_var/12 categorize_unify_var_functor/11 categorize_unify_var_lambda/9 Moved to mode_info.m: mode_info_error/4 mode_info_add_error/3 compiler/code_gen.pp, compiler/code_info.m, compiler/constraint.m, compiler/cse_detection.m, compiler/det_analysis.m, compiler/det_util.m, compiler/dnf.m, compiler/goal_util.m, compiler/higher_order.m, compiler/hlds_out.m, compiler/hlds_pred.m, compiler/live_vars.m, compiler/liveness.m, compiler/lookup_switch.m, compiler/polymorphism.m, compiler/simplify.m, compiler/store_alloc.m, compiler/switch_detection.m, compiler/transform.m, compiler/unused_args.m: Imported instmap.m New files: compiler/instmap.m: Handle operations associated with instmaps. compiler/modecheck_unify.m: Handle mode checking of unifications. compiler/modecheck_call.m: Handle mode checking of calls compiler/mode_debug.m: Code to trace the actions of the mode checker.	1996-10-17 05:28:01 +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
Fergus Henderson	5d93f7bda6	Simplify the code by replace 10 lines of code with a ... Estimated hours taken: 0.1 compiler/lookup_switch.m: Simplify the code by replace 10 lines of code with a call to instmap_lookup_var.	1996-05-06 03:54:44 +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
Zoltan Somogyi	faf96105bb	Replace the word_size option with the two options bits_per_word and ... Estimated hours taken: 16 options: Replace the word_size option with the two options bits_per_word and bytes_per_word. The former is needed by lookup_switch, the latter by value numbering. lookup_switch: Use the new option instead of word_size. vn_type, vn_cost, vn_block, value_number: Add a new type, vn_params, containing information such as the number of bytes per word (from the option) and cost parameters. Use these cost parameters to make more realistic decisions. vn_filter: New module to filter out unnecessary uses of temporary variables, which gcc does unnecessarily badly on. value_number, vn_verify: Move verification completely to vn_verify. Tighten the verification rules relating to tags where it concerns code sequences in which the tag of an rval is taken in a statement before an if_val, but loosen them to avoid spurious rejections of code sequences containing arithmetic comparisons. Fix some missing cases from semidet switches that may have lead to overly conservative decisions. value_number, vn_order: Vn_order was making an overly conservative assumption about where to split an extended basic block if it couldn't be optimized together. Move the decision to value_number and try to make it better. The new heuristic is not enabled yet. vn_debug: Change the conditions under which one type of message is printed. vn_flush: Wrap some too long lines. llds: Fix a bug that would prevent profiling from working correctly on value numbered code: we weren't scanning instructions inside blocks when looking for return addresses. peephole: Enable an optimization previously left disabled by accident. switch_detection, tag_switch: Eliminate an unused argument.	1996-04-16 06:03:45 +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
Thomas Conway	66a5fbe65d	Documented the changed interfaces to list, std_util and graph. ... Estimated hours taken: 6 NEWS: Documented the changed interfaces to list, std_util and graph. configure.in: Added the number of bytes per word (calculated as sizeof(void *)) as a configuration variable. compiler/goal_util.m: Add an optional sanity check for ensuring that all variables in a goal get renamed in goal_util__rename_vars_in_goal[s]. Also fixed a bug in goal_util__create_variables which was giving wrong names to some variables (which lead to very confusing hlds dumps). compiler/excess.m: in the calls to goal_util__rename_vars_in_goals add the bool which indicates that we do not want to do the sanity checking operation of making sure that *all* variables get renamed. compiler/inlining.m: in the calls to goal_util__rename_vars_in_goals add the bool which indicates that we do want to do the sanity checking operation of making sure that *all* variables get renamed. Also fixed up calls to goal_util__create_variables for the bug fix described above. compiler/quantification.m: in the calls to goal_util__rename_vars_in_goals add the bool which indicates that we do not want to do the sanity checking operation of making sure that *all* variables get renamed. Also fixed up calls to goal_util__create_variables for the bug fix described above. compiler/lookup_switch.m: changed lookup_switch to use a configuration option "word_size" to find out the number of bytes (and hence the number of bits) per word, rather than having a magic number. compiler/options.m: added "word_size" for the number of bytes per word. Defaults to 4, but my next checkin will add a configuration parameter to mc.in. Don't port to any 16 bit machines in the next couple of days. ;-) also changed req_density to dense_switch_req_density and added lookup_switch_req_density for the minimum density of lookup switches. compiler/switch_gen.m: changed req_density to dense_switch_req_density and lookup_switch_req_density appropriately. library/graph.m: Add lots of comments. Fix the interface to make it more consistent. Fixed some bugs. library/list.m: Added some HO stuff from philip: list__filter/3, list__filter/4 list__filter_map, list_sort/3 (takes a cmp predicate). Moved the HO interface stuff into the interface at the top of the file. Removed list__map_maybe/3. library/std_util.m: added a pair/3 predicate from philip for avoiding type ambiguities when using -/2. added maybe_pred/3. doc/user_guide.texi: added documentation for the changes to the command line options.	1996-04-03 02:30:34 +00:00
Zoltan Somogyi	2833bfffb7	Divided the old hlds.m into four files: ... Estimated hours taken: 10 hlds, hlds_module, hlds_pred, hlds_goal, hlds_data: Divided the old hlds.m into four files: hlds_module.m defines the data structures that deal with issues that are wider than a single predicate. These data structures are the module_info structure, dependency_info, the predicate table and the shape table. hlds_pred.m defined pred_info and proc_info, pred_id and proc_id. hlds_goal.m defines hlds__goal, hlds__goal_{expr,info}, and the other parts of goal structures. hlsd_data.m defines the HLDS types that deal with issues related to data and its representation: function symbols, types, insts, modes. It also defines the types related to determinism. hlds.m is now an empty module. I have not removed it from CVS because we may need the name hlds.m again, and CVS does not like the reuse of a name once removed. other modules: Import the necessary part of hlds. det_analysis: Define a type that was up to now improperly defined in hlds.m. prog_io: Move the definition of type determinism to hlds_data. This decision may need to be revisited when prog_io is broken up. dnf, lambda: Simplify the task of defining predicates. llds: Fix some comments. mercury_compile: If the option -d all is given, dump all HLDS stages. shape, unused_args: Fix formatting.	1996-04-02 12:12:24 +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	bc2b8632b1	Add support for the compact argument passing convention. ... Estimated hours taken: 6 arg_info: Add support for the compact argument passing convention. The proper handling of higher order calls etc is still missing. globals: Added a third global type, args_method, current either "old" or "compact". passes_aux: Moved some auxiliary predicates from mercury_compile and options to passes_aux. constraint, det_analysis, make_hlds, modules, optimize, undef_types: Import and refer to passes_aux. mercury_compile, handle_options: Remove the predicates moved to passes_aux. Also move the option postprocessing code to a new module, handle_options. Another change is that we stop after syntax errors if the new option --halt-at-syntax-errors is set. handle_option: New module for option postprocessing. options: Remove the option lookup predicates, which were obsolete. Add new options --args, --halt-at-syntax-errors and --opt-level. Add a special handler for --opt-level. lookup_switch: Call getopt to look up options, not options. value_number, vn_block: Extended basic blocks with more than one incr_hp pose a problem for value numbering when using boehm_gc, because value numbering coalesces all the allocations into one. Previously we did not optimize such sequences. I modified value numbering to divide up such blocks into smaller blocks, each with at most one incr_hp, and optimize these. At the moment, some of these blocks contain deeply nested field refs, which value numbering is very slow to handle; code_exprn should be modified to fix these. value_number: Rename usemap to useset, since this is more accurate. Fixed a bug in --pred-value-number, which manifested itself as the generation of duplicate labels. labelopt: Rename usemap to useset, since this is more accurate.	1996-03-11 05:21:53 +00:00
Thomas Conway	e70dc0ea8d	Added a new kind of switch generation which generates array lookups ... Estimated hours taken: 5.0 Added a new kind of switch generation which generates array lookups for dense switches that output constants. compiler/code_gen.pp: The interface to switch_gen__generate_switch changed - we now pass the goal-info which gets used in lookup_switch. compiler/dense_switch.m: export dense_switch__calc_density/3 and dense_switch__type_range/5 which get used by lookup_switch. compiler/options.m: Added a new option "lookup-switch-size" which is the minimum number of cases that should be in a switch before we turn it into a lookup table. Currently, it defaults to 4 which is the same value as used for the "dense-switch-size" option. Some experimentation may show a better value. Also fixed the option names for "dense-switch-size" and "string-switch-size" which were "...switch_size". compiler/switch_gen.m: switch_gen__generate_switch/Lots now take the hlds__goal_info as one of its arguments, because the goal-info is needed by lookup- switches. Also, in switch_gen__generate_switch/Lots, check to see if a switch can be turned into a dense lookup table, and turn it into one if it can. compiler/lookup_switch.m: A new module that turns switches into lookup tables if the outputs of the switch are all constants. It does this by generating code for each of the cases and checking that no code actually got generated and that all the outputs were constants. The result is that for many predicates like char_to_int/2, etc instead of a computed goto with lots and lots of silly trivial cases, we get a simple lookup. This is good. There is a case where it may not be a win - if the cost of the range check and the bitvector lookup outweighs the cost of the jumps that would otherwise take place.	1996-03-06 01:35:17 +00:00