99 Commits

Author	SHA1	Message	Date
Fergus Henderson	ef7ed9c2f5	Support impurity declarations for higher-order code. ... Estimated hours taken: 24 Branches: main Support impurity declarations for higher-order code. In particular, allow `impure' and `semipure' annotations on higher-order types, higher-order calls, and lambda expresions. NEWS: doc/reference_manual.texi: Document the new language feature. compiler/hlds_goal.m: compiler/hlds_pred.m: Add `purity' field to - the `higher_order' alternative of the hlds_goal.generic_call type - the `higher_order' alternative of the hlds_pred.generic_call_id type - the `lambda_goal' alternative of the hlds_goal.unify_rhs type compiler/type_util.m: Add a new `purity' argument to the procedures dealing with higher-order types. Add code for parsing impure/semipure higher-order types. compiler/lambda.m: compiler/make_hlds.m: compiler/typecheck.m: compiler/post_typecheck.m: compiler/purity.m: compiler/polymorphism.m: Various minor changes to support impure/semipure higher-order lambda expressions. compiler/polymorphism.m: compiler/pseudo_type_info.m: XXX ought to change these to include purity in the RTTI for higher-order function types. compiler/simplify.m: Don't try to optimize semipure/impure higher-order calls. compiler/assertion.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/det_analysis.m: compiler/det_util.m: compiler/equiv_type.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/intermod.m: compiler/magic.m: compiler/magic_util.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/pd_util.m: compiler/prog_rep.m: compiler/pseudo_type_info.m: compiler/quantification.m: compiler/recompilation.usage.m: compiler/rl_gen.m: compiler/stratify.m: compiler/switch_detection.m: compiler/term_traversal.m: compiler/term_util.m: compiler/unify_gen.m: compiler/unique_modes.m: Trivial changes to handle the new purity fields and/or arguments. tests/hard_coded/purity/Mmakefile: tests/hard_coded/purity/impure_func_t5_fixed2.m: tests/hard_coded/purity/impure_func_t5_fixed2.exp: tests/hard_coded/purity/impure_func_t5_fixed2.exp2: tests/hard_coded/purity/impure_pred_t1_fixed3.m: tests/hard_coded/purity/impure_pred_t1_fixed3.exp: tests/invalid/purity/Mmakefile: tests/invalid/purity/impure_func_t5_fixed.m: tests/invalid/purity/impure_func_t5_fixed.err_exp: tests/invalid/purity/impure_pred_t1_fixed.m: tests/invalid/purity/impure_pred_t1_fixed.err_exp: Add new test cases to test the new feature. tests/invalid/purity/impure_func_t5.err_exp: tests/invalid/purity/impure_pred_t1.err_exp: tests/invalid/purity/impure_pred_t2.err_exp: tests/invalid/purity/purity.err_exp: tests/invalid/purity/purity_nonsense.err_exp: Update the expected error messages for existing test cases. tests/invalid/purity/.cvsignore: New file, copied from tests/invalid/.cvsignore.	2003-01-27 09:21:03 +00:00
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
Adrian Pellas-Rice	1c65d003f7	Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. ... Estimated hours taken: 4.5 Branches: main Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. compiler/hlds_goal.m Create a new type, the `shorthand_goal_expr', for goals kinds that are implemented by a (ordinary_hlds + shorthand) -> (ordinary_hlds) transformation. At present, bi_implication is the only kind of of goal that is implemented in this way. Moved bi_implication functor from the type goal_expr to the new shorthand_goal_expr type. Added the functor shorthand to the goal_expr type. compiler/*.m Change switches on hlds_goal_expr that call error when they recognise `bi_implication' from calling error when they recognise `bi_implication' to calling error when they recognise `shorthand'. For all predicates K that a) switch on hlds_goal_expr and b) perform non-trivial processing when they recognise `bi_implication' change K such that it now calls K_shorthand upon recognising the functor `shorthand'. Define K_shorthand to switch on shorthand_goal_expr, where the code for the `bi_implication' case formerly contained in K is now contained in K_shorthand.	2001-04-07 14:05:03 +00:00
Tyson Dowd	711da78188	Rename foreign_code as foreign_proc where appropriate in the compiler. ... Estimated hours taken: 4.0 Branches: main Rename foreign_code as foreign_proc where appropriate in the compiler. The rationale for this change is that it makes maintaining the code much simpler because it is clear whether `foreign' refers to a slab of code (foreign_code) or a procedure (foreign_proc). :- type pragma_foreign_code_attributes :- type pragma_foreign_proc_attributes The functors for pragma_type foreign(Lang, BodyCode) foreign(Attributes, Name, PredOrFunc, Vars, Varset, Impl) become foreign_code(Lang, BodyCode) foreign_proc(Attributes, Name, PredOrFunc, Vars, Varset, Impl) And the HLDS goal `pragma_foreign_code' becomes `foreign_proc'. compiler/*.m: Update the compiler to use the new names.	2001-04-03 03:20:33 +00:00
Zoltan Somogyi	639dd4943c	Put back the earlier clarification of cse_detection code, but without ... Estimated hours taken: 16 compiler/cse_detection.m: Put back the earlier clarification of cse_detection code, but without the bug this time :-( The bug was that cse_detection did not insist on all branches of the branched control structure containing a copy of the "common" deconstruction unification. By hoisting that unification before the branched control structure, cse_detection was effectively adding a test into some computation paths. Fix common subexpression elimination so that it works when the deconstruction it hoists out of a branched control structure involves a functor with existentially typed arguments. compiler/switch_detection.m: Modify the code called by cse_detection to look for deconstruction unifications to make it explicit whether the search was successful. compiler/options.m: Put the default value of --compare-specialization back to 4, now that the bug that prevented it from working at levels above 1 (in the presence of existentially typed arguments) has been fixed.	2000-12-08 06:50:17 +00:00
Zoltan Somogyi	30a7319d32	Make the code for finding common subexpressions significantly clearer ... Estimated hours taken: 4 compiler/cse_detection.m: Make the code for finding common subexpressions significantly clearer by using a single type for each possible state of the search, instead of dividing the state between a maybe and a bool. Instead of passing around several data structures separately, wrap them up in a cse_info data structure. Extend the cse_info data structure with fields that will be required to fix common subexpression elimination over existentially typed functors. Switch to using predmode declarations when appropriate. compiler/switch_detection.m: Remove some redundancy from a comment.	2000-12-05 02:03:45 +00:00
Tyson Dowd	477ecb18f6	Implement pragma foreign_code for Managed C++. ... Estimated hours taken: 60 Implement pragma foreign_code for Managed C++. Currently you can only write MC++ code if your backend is capable of generating use MC++ as its "native" foreign language. The IL backend is the only backend that does this at the moment (the other backends have C as their "native" foreign language). Most of the machinery is in place to call from C to (normal) C++ but there is little work done on actually spitting out the C++ code into a separate file. The IL backend does this step already with managed C++. The intention is to turn foreign_code for C++ into a pragma import (which imports the C++ function from a separate file) and foreign_code for C (which calls the imported function). The C++ code will be inserted into a separate file that is compiled using C linkage. The important improvement this change gives is that you can write a module with a C and a MC++ implementations side-by-side. The target backend will select the most appropriate foreign language to use. You can override its choice using --use-foreign-language. Later on we will probably want more flexibility than just a single language selection option). This change also implements :- pragma foreign_decl, which allows header file style declarations to be written in languages other than C. compiler/code_gen.m: Reject code that is not C when generating LLDS. compiler/export.m: Start renaming C as foreign. Reject code that is not C when generating exports. compiler/foreign.m: A new module to handle foreign language interfacing. The bulk of the code for pragma import has been moved here from make_hlds. compiler/globals.m: Convert foreign language names to foreign_language. This code has been moved closer to the similar conversion we do for target language names. Add globals__io_lookup_foreign_language_option to make it easier to deterministically lookup the options relating to foreign languages. compiler/hlds_module.m: Move module_add_foreign_decl and module_add_foreign_body_code from make_hlds.m (where they were called module_add_c_header and module_add_c_code). compiler/hlds_out.m: Write the foreign language out in HLDS dumps. compiler/llds.m: Change foreign_header_info to foreign_decl_info. Change definitions of foreign_decl_code and foreign_body_code to include the language. compiler/llds_out.m: Reject code that is not C when writing out LLDS. compiler/make_hlds.m: Add foreign language information to the bodys and decls when creating them. Update error messages to refer to foreign code instead of C code. Use foreign.m to generate interfaces from the backend language to the foreign language. Hardcode C as the language for fact tables. compiler/mercury_compile.m: Collect the appropriate foreign language code together for output to the backend. compiler/intermod.m: compiler/mercury_to_mercury.m: Output the foreign language string. Change a few names to foreign_code instead of c_code. compiler/ml_code_gen.m: Filter the foreign language bodys and decls so that we only get the ones we are in (given by the use-foreign-language option). compiler/mlds_to_c.m: Abort if we are given non C foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/mlds_to_ilasm.m: Abort if we are given non MC++ foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/options.m: compiler/handle_options.m: Add --use-foreign-language as a user option to control the preferred foreign language to use as the implementation of this module. Add backend_foreign_language as an internal option which stores the foreign language that the compiler will use as a default (e.g. the natural foreign language for the backend to use). Set the preferred backend foreign language depending on the target. compiler/prog_data.m: Add managedcplusplus as a new alternative for the foreign_language type. Make c_header_code into foreign_decl. Give the foreign language for foreign_code as an attribute of the code. Write code to turn attributes into a list of strings (suitable for writing out by mercury_to_mercury). This fixes what appears to be a bug in tabled_for_io -- the tabled_for_io attribute was not being written out. Structure the code so this bug is difficult to repeat in future. compiler/prog_io_pragma.m: Parse foreign_decl. Turn c_header_code into a special case of foreign_decl. compiler/*.m: Remove the language field from pragma_foreign_code, it is now an attribute of the code. Various type and variable renamings. tests/invalid/pragma_c_code_and_clauses1.err_exp: tests/invalid/pragma_c_code_dup_var.err_exp: tests/warnings/singleton_test.exp: Update the tests to reflect the new error messages talking about :- pragma foreign_code rather than :- pragma c_code.	2000-11-17 17:48:52 +00:00
Peter Ross	35d1d914e7	Update the MLDS backend to handle structure reuse and compile time gc. ... Estimated hours taken: 20 Update the MLDS backend to handle structure reuse and compile time gc. Note that currently no pass on the main branch currently generates this information yet. mlds.m: Add a new instruction delete_object which is to be inserted whenever a lval can be compile time garbage collected. ml_unify_gen.m: Handle the case where the HowToConstruct field of a construction is reuse_cell(_). Handle the case where a deconstruction can be compile time gc'd. hlds_goal.m: Add a new field, can_cgc, to deconstruction unifications. This field is `yes' if the deconstruction unification can be compile time garbage collected. hlds_out.m: Output the can_cgc field. Output unification information if we request the structure reuse information. ml_elim_nested.m: mlds_to_c.m: Handle the delete_object instruction. builtin_ops.m: Fix a bug where body was an unary op instead of a binary op. bytecode.m: c_util.m: llds.m: opt_debug.m: vn_cost.m: Changes to reflect that body is a binary op. bytecode_gen.m: code_aux.m: common.m: cse_detection.m: dependency_graph.m: det_analysis.m: goal_util.m: higher_order.m: mark_static_terms.m: mode_util.m: modecheck_unify.m: pd_cost.m: pd_util.m: prog_rep.m: rl_exprn.m: rl_key.m: simplify.m: switch_detection.m: term_traversal.m: unify_gen.m: unused_args.m: Handle the can compile time gc field in deconstruction unifications.	2000-10-06 10:18:39 +00:00
Tyson Dowd	c192d50143	Add preliminary support for a new pragma: ... Estimated hours taken: 15 Add preliminary support for a new pragma: :- pragma foreign_code(LanguageString, .... <same args as c_code>). This is intended to be the eventual replacement of pragma c_code. Presently the only valid language is "C". The existing pragma c_code is simply turned into pragma foreign_code. pragma foreign_code is not a supported pragma at the moment. There are several other changes that are intended (for example, foreign_code will be impure by default). This change also changes the HLDS goal pragma_c_code/7 to pragma_foreign_code/8 where the extra argument is the foreign language. Any code currently generating output for pragma C code simply checks that the foreign language is set to "c". Since this is the only alternative of the type foreign_language, it will always succeed. However when new alternatives are added it should be fairly easy to find where the changes need to be made. Some type names and predicate names have also been updated, however there are many more that haven't yet been touched. compiler/prog_io_pragma.m: Accept the new syntax. Turn the old syntax into the new item. compiler/hlds_goal.m: Change pragma_c_code/7 to pragma_foreign_code/8. Define the foreign_language type. compiler/llds.m: Change user_c_code/2 to user_foreign_code/3. compiler/*.m: Update the rest of the compiler to handle these types. Make a few small changes to update variable names, predicate names and type names.	2000-08-09 07:48:04 +00:00
Zoltan Somogyi	9dcab9bee2	Add a new optimization, enabled by the option --unneeded-code. ... Estimated hours taken: 40 Add a new optimization, enabled by the option --unneeded-code. This optimization removes goals whose outputs are not used at all, and moves goals whose outputs are only used on some computation branches to the starts of those branches, so they do not need to be executed on other branches. Such deletions/movements are done only when the semantic switches and the properties of the relevant goal together permit it. compiler/unneeded_code.m: A new module to perform the goal rearrangement. compiler/hlds_goal.m: The new optimization needs to know how many functors the switched-on variable can be bound to, so it can check whether a given number of switch arms covers all alternatives or not. To make access to this information convenient, we add a field to the goal_path_step alternative for switch arm entry that records this number. compiler/goal_path.m: Fill in this number. To make this possible, we thread the necessary information through the predicates in this module. compiler/type_util.m: Add a utility predicate type_util__switch_type_num_functors, for use by the new code in goal_path.m. compiler/switch_detection.m: Avoid duplicated code by using type_util__switch_type_num_functors where relevant. compiler/code_aux.m: Add three new auxiliary predicate, code_aux__goal_cannot_loop_or_throw, code_aux__goal_can_loop_or_throw and code_aux__goal_can_loop, to the existing code_aux__goal_cannot_loop. code_aux__goal_cannot_loop now checks only what its name says. compiler/trace.m: Ignore the new field when generating goal paths strings. compiler/mercury_compile.m: Invoke unneeded_code.m if required. compiler/hlds_pred.m: Add some utility predicates for use by unneeded_code.m. compiler/unused_args.m: Use the new utility predicates instead of reimplementing them. compiler/options.m: Define the --unneeded-code option, and its auxiliary, --unneeded-code-copy-limit. doc/user_guide.texi: Document the new options.	2000-07-25 09:27:38 +00:00
Fergus Henderson	d551dd1dc9	Handle quantification analysis of bi-implication (`<=>') goals correctly. ... Estimated hours taken: 10 Handle quantification analysis of bi-implication (`<=>') goals correctly. Previously we used to expand bi-implications before doing quantification analysis, which stuffed up the results of quantification analysis for those goals. We need to do quantification analysis first, and only then can we expand bi-implications. In addition, elimination of double negation needs to come after expansion of bi-implication, so I moved that from make_hlds.m to purity.m. compiler/hlds_goal.m: Add a new alternative to the HLDS goal type for bi-implications. Also add a new predicate negate_goal, for use by purity.m. compiler/make_hlds.m: Don't expand bi-implication here, instead just use the new bi_implication/2 HLDS goal type. Don't eliminated double negation here. compiler/quantification.m: Handle quantification for bi-implications. Expand bi-implications. compiler/purity.m: Eliminate double negation. compiler/hlds_out.m: Add code to print out bi-implication goals. compiler/*.m: Trivial changes to handle the new bi_implication/2 alternative in the HLDS goal type. compiler/notes/compiler_design.html: Document the above changes. tests/hard_coded/Mmakefile: tests/hard_coded/quantifier2.m: tests/hard_coded/quantifier2.exp: A regression test for the above change.	1999-10-25 03:53:14 +00:00
Simon Taylor	8bb9f777ac	Fix a bug - the code was looking for switch deconstructions ... Estimated hours taken: 1 compiler/switch_detection.m: Fix a bug - the code was looking for switch deconstructions after the first call in each branch. Doing this can remove infinite loops, which the strict sequential semantics does not allow. NEWS: Discuss the backwards incompatibility effects of this change. doc/reference_manual.texi: Add some more documentation about where the test unifications in switches can occur. tests/invalid/Mmakefile: tests/invalid/not_a_switch.m: Test case.	1999-08-31 04:16:33 +00:00
Simon Taylor	2725b1a331	Aditi update syntax, type and mode checking. ... Estimated hours taken: 220 Aditi update syntax, type and mode checking. Change the hlds_goal for constructions in preparation for structure reuse to avoid making multiple conflicting changes. compiler/hlds_goal.m: Merge `higher_order_call' and `class_method_call' into a single `generic_call' goal type. This also has alternatives for the various Aditi builtins for which type declarations can't be written. Remove the argument types field from higher-order/class method calls. It wasn't used often, and wasn't updated by optimizations such as inlining. The types can be obtained from the vartypes field of the proc_info. Add a `lambda_eval_method' field to lambda_goals. Add a field to constructions to identify which RL code fragment should be used for an top-down Aditi closure. Add fields to constructions to hold structure reuse information. This is currently ignored -- the changes to implement structure reuse will be committed to the alias branch. This is included here to avoid lots of CVS conflicts caused by changing the definition of `hlds_goal' twice. Add a field to `some' goals to specify whether the quantification can be removed. This is used to make it easier to ensure that indexes are used for updates. Add a field to lambda_goals to describe whether the modes were guessed by the compiler and may need fixing up after typechecking works out the argument types. Add predicate `hlds_goal__generic_call_id' to work out a call_id for a generic call for use in error messages. compiler/purity.m: compiler/post_typecheck.m: Fill in the modes of Aditi builtin calls and closure constructions. This needs to know which are the `aditi__state' arguments, so it must be done after typechecking. compiler/prog_data.m: Added `:- type sym_name_and_arity ---> sym_name/arity'. Add a type `lambda_eval_method', which describes how a closure is to be executed. The alternatives are normal Mercury execution, bottom-up execution by Aditi and top-down execution by Aditi. compiler/prog_out.m: Add predicate `prog_out__write_sym_name_and_arity', which replaces duplicated inline code in a few places. compiler/hlds_data.m: Add a `lambda_eval_method' field to `pred_const' cons_ids and `pred_closure_tag' cons_tags. compiler/hlds_pred.m: Remove type `pred_call_id', replace it with type `simple_call_id', which combines a `pred_or_func' and a `sym_name_and_arity'. Add a type `call_id' which describes all the different types of call, including normal calls, higher-order and class-method calls and Aditi builtins. Add `aditi_top_down' to the type `marker'. Remove `aditi_interface' from type `marker'. Interfacing to Aditi predicates is now handled by `generic_call' hlds_goals. Add a type `rl_exprn_id' which identifies a predicate to be executed top-down by Aditi. Add a `maybe(rl_exprn_id)' field to type `proc_info'. Add predicate `adjust_func_arity' to convert between the arity of a function to its arity as a predicate. Add predicates `get_state_args' and `get_state_args_det' to extract the DCG state arguments from an argument list. Add predicate `pred_info_get_call_id' to get a `simple_call_id' for a predicate for use in error messages. compiler/hlds_out.m: Write the new representation for call_ids. Add a predicate `hlds_out__write_call_arg_id' which replaces similar code in mode_errors.m and typecheck.m. compiler/prog_io_goal.m: Add support for `aditi_bottom_up' and `aditi_top_down' annotations on pred expressions. compiler/prog_io_util.m: compiler/prog_io_pragma.m: Add predicates - `prog_io_util:parse_name_and_arity' to parse `SymName/Arity' (moved from prog_io_pragma.m). - `prog_io_util:parse_pred_or_func_name_and_arity to parse `pred SymName/Arity' or `func SymName/Arity'. - `prog_io_util:parse_pred_or_func_and_args' to parse terms resembling a clause head (moved from prog_io_pragma.m). compiler/type_util.m: Add support for `aditi_bottom_up' and `aditi_top_down' annotations on higher-order types. Add predicates `construct_higher_order_type', `construct_higher_order_pred_type' and `construct_higher_order_func_type' to avoid some code duplication. compiler/mode_util.m: Add predicate `unused_mode/1', which returns `builtin:unused'. Add functions `aditi_di_mode/0', `aditi_ui_mode/0' and `aditi_uo_mode/0' which return `in', `in', and `out', but will be changed to return `di', `ui' and `uo' when alias tracking is implemented. compiler/goal_util.m: Add predicate `goal_util__generic_call_vars' which returns any arguments to a generic_call which are not in the argument list, for example the closure passed to a higher-order call or the typeclass_info for a class method call. compiler/llds.m: compiler/exprn_aux.m: compiler/dupelim.m: compiler/llds_out.m: compiler/opt_debug.m: Add builtin labels for the Aditi update operations. compiler/hlds_module.m: Add predicate predicate_table_search_pf_sym, used for finding possible matches for a call with the wrong number of arguments. compiler/intermod.m: Don't write predicates which build `aditi_top_down' goals, because there is currently no way to tell importing modules which RL code fragment to use. compiler/simplify.m: Obey the `cannot_remove' field of explicit quantification goals. compiler/make_hlds.m: Parse Aditi updates. Don't typecheck clauses for which syntax errors in Aditi updates are found - this avoids spurious "undefined predicate `aditi_insert/3'" errors. Factor out some common code to handle terms of the form `Head :- Body'. Factor out common code in the handling of pred and func expressions. compiler/typecheck.m: Typecheck Aditi builtins. Allow the argument types of matching predicates to be adjusted when typechecking the higher-order arguments of Aditi builtins. Change `typecheck__resolve_pred_overloading' to take a list of argument types rather than a `map(var, type)' and a list of arguments to allow a transformation to be performed on the argument types before passing them. compiler/error_util.m: Move the part of `report_error_num_args' which writes "wrong number of arguments (<x>; expected <y>)" from typecheck.m for use by make_hlds.m when reporting errors for Aditi builtins. compiler/modes.m: compiler/unique_modes.m: compiler/modecheck_call.m: Modecheck Aditi builtins. compiler/lambda.m: Handle the markers for predicates introduced for `aditi_top_down' and `aditi_bottom_up' lambda expressions. compiler/polymorphism.m: Add extra type_infos to `aditi_insert' calls describing the tuple to insert. compiler/call_gen.m: Generate code for Aditi builtins. compiler/unify_gen.m: compiler/bytecode_gen.m: Abort on `aditi_top_down' and `aditi_bottom_up' lambda expressions - code generation for them is not yet implemented. compiler/magic.m: Use the `aditi_call' generic_call rather than create a new procedure for each Aditi predicate called from C. compiler/rl_out.pp: compiler/rl_gen.m: compiler/rl.m: Move some utility code used by magic.m and call_gen.m into rl.m. Remove an XXX comment about reference counting being not yet implemented - Evan has fixed that. library/ops.m: compiler/mercury_to_mercury.m: doc/transition_guide.texi: Add unary prefix operators `aditi_bottom_up' and `aditi_top_down', used as qualifiers on lambda expressions. Add infix operator `==>' to separate the tuples in an `aditi_modify' call. compiler/follow_vars.m: Thread a `map(prog_var, type)' through, needed because type information is no longer held in higher-order call goals. compiler/table_gen.m: Use the `make_*_construction' predicates in hlds_goal.m to construct constants. compiler/*.m: Trivial changes to add extra fields to hlds_goal structures. doc/reference_manual.texi: Document Aditi updates. Use @samp{pragma base_relation} instead of @samp{:- pragma base_relation} throughout the Aditi documentation to be consistent with other parts of the reference manual. tests/valid/Mmakefile: tests/valid/aditi_update.m: tests/valid/aditi.m: Test case. tests/valid/Mmakefile: Remove some hard-coded --intermodule-optimization rules which are no longer needed because `mmake depend' is now run in this directory. tests/invalid/*.err_exp: Fix expected output for changes in reporting of call_ids in typecheck.m. tests/invalid/Mmakefile tests/invalid/aditi_update_errors.{m,err_exp}: tests/invalid/aditi_update_mode_errors.{m,err_exp}: Test error messages for Aditi updates. tests/valid/aditi.m: tests/invalid/aditi.m: Cut down version of extras/aditi/aditi.m to provide basic declarations for Aditi compilation such as `aditi__state' and the modes `aditi_di', `aditi_uo' and `aditi_ui'. Installing extras/aditi/aditi.m somewhere would remove the need for these.	1999-07-13 08:55:28 +00:00
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
Simon Taylor	2727699e93	Fix a bug where cse_detection failed to hoist a common deconstruction for ... Estimated hours taken: 5 Fix a bug where cse_detection failed to hoist a common deconstruction for a one-armed switch out where switch_detection expected it to, due to a call getting in the way. This resulted in switch_detection not finding a switch necessary to prove determinism correctness. compiler/switch_detection.m: compiler/cse_detection.m: Make both modules use the same code to find deconstructions of non-local variables of disjunctions. tests/valid/switch_detection_bug2.m: Test case, taken from samples/diff.	1998-09-10 06:18:48 +00:00
Thomas Conway	a70b59e83c	Add a test to find the number of words needed to represent a ... configure.in: Add a test to find the number of words needed to represent a synchronization term. boehm_gc/gc.h: fix a declaration by replacing the args () with (void). boehm_gc/solaris_pthreads.c: add a missing include check the return values of pthread calls. compiler/*.m: Add handling for the new HLDS goal type par_conj. Add handling for the four new LLDS instructions: init_sync_term fork join_and_terminate join_and_continue compiler/code_info.m: add a new alternative for slot_contents - sync_term. compiler/handle_options.m: add .par as part of the grade compiler/hlds_goal.m: add the new goal type par_conj. compiler/instmap.m: add instmap__unify which takes a list of instmaps and abstractly unifies them. add unify_instmap_delta which tajes two instmap deltas and abstractly unifies them. compiler/llds.m: add the new llds instructions. compiler/mode_info.m: add par_conj as a lock reason. library/Makefile: work around a bug in the solaris version pthread.h library/benchmarking.m: reference the stack zones from the engine structure rather than from global variables. library/{nc,sp}_builtin.nl: add an op declaration for &. library/std_util.m: change references to global variables to references inside the engine structure. runtime/Mmakefile: add mercury_thread.{c,h} add THREADLIBS to the libraries runtime/*.{c,h} Remove some old junk from the previous processes/shrd-mem changes that found their way into the repository. Add MR_ prefixes to lots of names. runtime/mercury_context.c: Add init_thread_stuff for creating and initializing a context structure for the current thread. runtime/mercury_context.h: add a field to the mercury context which stores the thread id of the thread where this context originated. add various macros for implementing the new llds instructions. runtime/mercury_engine.c: initialize the engine structure, rather than a bunch of globals. runtime/mercury_engine.h: declare the mercury_engine structure. runtime/mercury_regorder.h: if MR_THREAD_SAFE, and there is at least one global register then use mr0 as a pointer to the mercury engine structure. scripts/init_grade_options.sh-subr add thread_safe scripts/mgnuc.in add THREAD_OPTS scripts/ml.in: add THREAD_LIBS	1998-06-09 02:16:31 +00:00
Oliver Hutchison	bcf7dbf9f8	Add support for tabling. ... Estimated hours taken: 250 Add support for tabling. This change allows for model_det, model_semidet and model_non memoing, minimal model and loop detection tabling. compiler/base_type_layout.m: Update comments to reflect new runtime naming standard. compiler/det_analysis.m: Allow tabling to change the result of det analysis. This is necessary in the case of minimal model tabling which can turn a det procedure into a semidet one. compiler/det_report.m: compiler/hlds_data.m: Add code to report error messages for various non compatible tabling methods and determinism. compiler/hlds_out.m: compiler/modules.m: Remove reference to the old memo marker. compiler/hlds_pred.m: Create new type (eval_method) to define which of the available evaluation methods should be used each procedure. Add new field to the proc_info structure. Add several new predicates relating to the new eval_method type. compiler/inlining.m: compiler/intermod.m: Make sure only procedures with normal evaluation are inlined. compiler/make_hlds.m: Add code to process new tabling pragmas. compiler/mercury_compile.m: Call the tabling transformation code. compiler/modes.m: Make sure that all procedures with non normal evaluation have no unique/partially instantiated modes. Produce error messages if they do. Support for partially instantiated modes is currently missing as it represents a large amount of work for a case that is currently not used. compiler/module_qual.m: compile/prog_data.m: compiler/prog_io_pragma.m: Add three new pragma types: `memo' `loop_check' `minimal_model' and code to support them. compiler/simplify.m: Don't report infinite recursion warning if a procedure has minimal model evaluation. compiler/stratify.m: Change the stratification analyser so that it reports cases of definite non-stratification. Rather than reporting warnings for any code that is not definitely stratified. Remove reference to the old memo marker. compiler/switch_detection.m: Fix a small bug where goal were being placed in reverse order. Call list__reverse on the list of goals. compiler/table_gen.m: New module to do the actual tabling transformation. compiler/notes/compiler_design.html: Document addition of new tabling pass to the compiler. doc/reference_manual.texi: Fix mistake in example. library/mercury_builtin.m: Add many new predicates for support of tabling. library/std_util.m: library/store.m: Move the functions : ML_compare_type_info ML_collapse_equivalences ML_create_type_info to the runtime. runtime/mercury_deep_copy.c: runtime/mercury_type_info.h: runtime/mercury_type_info.c: Move the make_type_info function into the mercury_type_info module and make it public. runtime/Mmakefile: runtime/mercury_imp.h: Add references to new files added for tabling support. runtime/mercury_string.h: Change hash macro so it does not cause a name clash with any variable called "hash". runtime/mercury_type_info.c: runtime/mercury_type_info.h: Add three new functions taken from the library : MR_compare_type_info MR_collapse_equivalences MR_create_type_info. runtime/mercury_table_any.c: runtime/mercury_table_any.h: runtime/mercury_table_enum.c: runtime/mercury_table_enum.h: runtime/mercury_table_int_float_string.c: runtime/mercury_table_int_float_string.h: runtime/mercury_table_type_info.c: runtime/mercury_table_type_info.h: runtime/mercury_tabling.h: New modules for the support of tabling.	1998-05-15 07:09:29 +00:00
Fergus Henderson	49c25842cf	Fix a problem reported by Baudouin Le Charlier <ble@info.fundp.ac.be> ... where switch detection was getting confused by explicit existential quantifications. compiler/switch_detection.m: When detecting switches, traverse through some/2 goals. Also simplify the code a bit. tests/valid/Mmakefile: tests/valid/some_switch.m: Regression test for the above change.	1998-05-12 17:05:04 +00:00
Simon Taylor	d0085d8119	Assorted changes to make the HLDS type and mode correct ... Estimated hours taken: 45 Assorted changes to make the HLDS type and mode correct after lambda expansion. The HLDS is still not unique mode correct after common structure elimination. compiler/det_analysis.m Make sure the inferred_determinism field of the proc_info is filled in correctly for imported procedures and class methods. compiler/mode_util.m Fix a bug in recompute_instmap_delta_call to do with unreachable instmaps. This caused an abort a couple of months ago when compiling with --deforestation (not yet committed), but can't currently be reproduced. compiler/hlds_pred.m compiler/lambda.m Add a field to the proc_info to record which args_method should be used for this procedure. Procedures directly called by do_call_*_closure must be compiled with the `compact' argument convention to avoid the need to permute the arguments so inputs come before outputs. compiler/lambda.m compiler/higher_order.m Remove permutation of argument variables of lambda expressions so the HLDS is type and mode correct and mode analysis can be rerun. Otherwise, rerunning mode analysis will fail on tests/hard_coded/ho_order.m. compiler/arg_info.m Added arg_info__ho_call_args_method which returns an args_method which can always be directly called by do_call_*_closure (`compact'). Added arg_info__args_method_is_ho_callable to check that a given args_method can be directly called. compiler/unify_gen.m Abort if a closure is created for a procedure compiled with the simple argument convention. compiler/hlds_goal.m compiler/lambda.m Mode analysis was not storing the non-locals list on which the uni_modes field of the construction of a lambda goal was computed. If the nonlocals were renamed, the sort order could change, and the non-locals could be incorrectly matched with the arguments of the introduced lambda expression, causing a mode error. The argument list is now stored. This caused rerunning mode-checking on tests/valid/lazy_list.m after polymorphism to fail. compiler/*.m Fill in the args_method field of proc_infos with the value from the globals. Handle the extra argument to the lambda_goal unify_rhs. compiler/follow_vars.m Remove code to handle complicated unifications, since they should be removed by polymorphism.m. compiler/special_pred.m library/mercury_builtin.m Make the uniqueness of the comparison_result argument of builtin_compare_* and the automatically generated comparison procedures match that of compare/3. Unique mode errors will still be introduced if polymorphism.m specializes calls to any of the unique modes of compare/3 and then mode analysis is rerun, since the compiler-generated comparison procedures only implement the (uo, in, in) mode. (This is not yet a problem because currently we don't rerun mode analysis.) runtime/mercury_ho_call.c Remove code in do_call_*_closure to deal with the `simple' args_method. Since the output arguments no longer need to be moved, the closure call is now a tailcall. Remove some magic numbers. compiler/modecheck_unify.m Avoid some aborts and mode errors when rerunning mode analysis, especially those resulting from not_reached insts being treated as bound. Avoid aborting on higher-order predicate constants with multiple modes if lambda expansion has already been run. tests/valid/higher_order.m Add a test case for an abort in mode analysis when compiling with --deforestation (not yet committed), due to a predicate constant for a procedure with multiple modes. tests/valid/unreachable_code.m Add a test case for bogus higher-order unification mode errors in unreachable code.	1998-02-12 01:17:56 +00:00
Zoltan Somogyi	5013dd9c76	Implement nondet pragma C codes. ... Estimated hours taken: 40 Implement nondet pragma C codes. runtime/mercury_stacks.h: Define a new macro, mkpragmaframe, for use in the implementation of nondet pragma C codes. This new macro includes space for a struct with a given sruct tag in the nondet stack frame being created. compiler/{prog_data.m,hlds_goal.m}: Revise the representation of pragma C codes, both as the item and in the HLDS. compiler/prog_io_pragma.m: Parse nondet pragma C declarations. Fix the indentation in some places. compiler/llds.m: Include an extra argument in mkframe instructions. This extra argument gives the details of the C structure (if any) to be included in the nondet stack frame to be created. Generalize the LLDS representation of pragma C codes. Instead of a fixed sequence of <assign from inputs, user c code, assign to outputs>, let the sequence contain these elements, as well as arbitrary compiler-generated C code, in any order and possibly with repetitions. This flexibility is needed for nondet pragma C codes. Add a field to pragma C codes to say whether they can call Mercury. Some optimizations can do a better job if they know that a pragma C code cannot call Mercury. Add another field to pragma C codes to give the name of the label they refer to (if any). This is needed to prevent labelopt from incorrectly optimizing away the label definition. Add a new alternative to the type pragma_c_decl, to describe the declaration of the local variable that points to the save struct. compiler/llds_out.m: Output mkframe instructions that specify a struct as invoking the new mkpragmaframe macro, and make sure that the struct is declared just before the procedure that uses it. Other minor changes to keep up with the changes to the representation of pragma C code in the LLDS, and to make the output look a bit nicer. compiler/pragma_c_gen.m: Add code to generate code for nondet pragma C codes. Revise the utility predicates and their data structures a bit to make this possible. compiler/code_gen.m: Add code for the necessary special handling of prologs and epilogs of procedures defined by nondet pragma C codes. The prologs need to be modified to include a programmer-defined C structure in the nondet stack frame and to communicate the location of this structure to the pragma C code, whereas the functionality of the epilog is taken care of by the pragma C code itself. compiler/make_hlds.m: When creating a proc_info for a procedure defined by a pragma C code, we used to insert unifications between the headvars and the vars of the pragma C code into the body goal. We now perform substitutions instead. This removes a factor that would complicate the generation of code for nondet pragma C codes. Pass a moduleinfo down the procedures that warn about singletons (and other basic scope errors). When checking whether to warn about an argument of a pragma C code not being mentioned in the C code fragment, we need to know whether the argument is input or output, since input variables should appear in some code fragments in a nondet pragma C code and must not appear in others. The mode_is_{in,out}put checks need the moduleinfo. (We do not need to check for any variables being mentioned where they shouldn't be. The C compiler will fail in the presence of any errors of that type, and since those variables could be referred to via macros whose definitions we do not see, we couldn't implement a reliable test anyway.) compiler/opt_util.m: Recognize that some sorts of pragma_c codes cannot affect the data structures that control backtracking. This allows peepholing to do a better job on code sequences produced for nondet pragma C codes. Recognize that the C code strings inside some pragma_c codes refer to other labels in the procedure. This prevents labelopt from incorrectly optimizing away these labels. compiler/dupelim.m: If a label is referred to from within a C code string, then do not attempt to optimize it away. compiler/det_analysis.m: Remove a now incorrect part of an error message. compiler/*.m: Minor changes to conform to changes to the HLDS and LLDS data structures.	1998-01-13 10:14:23 +00:00
Zoltan Somogyi	bb4442ddc1	Update copyright dates for 1998. ... Estimated hours taken: 0.5 compiler/*.m: Update copyright dates for 1998.	1998-01-13 10:06:08 +00:00
David Jeffery	7406335105	This change implements typeclasses. Included are the necessary changes to ... Estimated hours taken: 500 or so This change implements typeclasses. Included are the necessary changes to the compiler, runtime and library. compiler/typecheck.m: Typecheck the constraints on a pred by adding constraints for each call to a pred/func with constraints, and eliminating constraints by applying context reduction. While reducing the constraints, keep track of the proofs so that polymorphism can produce the tyepclass_infos for eliminated constraints. compiler/polymorphism.m: Perform the source-to-source transformation which turns code with typeclass constraints into code without constraints, but with extra "typeclass_info", or "dictionary" parameters. Also, rather than always having a type_info directly for each type variable, sometimes the type_info is hidden inside a typeclass_info. compiler/bytecode*.m: Insert some code to abort if bytecode generation is used when typeclasses are used. compiler/call_gen.m: Generate code for a class_method_call, which forms the body of a class method (by selecting the appropriate proc from the typeclass_info). compiler/dead_proc_elim.m: Don't eliminate class methods if they are potentially used outside the module compiler/hlds_data.m: Define data types to store: - the typeclass definitions - the instances of a class - "constraint_proof". ie. the proofs of redundancy of a constraint. This info is used by polymorphism to construct the typeclass_infos for a constraint. - the "base_tyepclass_info_constant", which is analagous the the base_type_info_constant compiler/hlds_data.m: Define the class_method_call goal. This goal is inserted into the body of class method procs, and is responsible for selecting the appropriate part of the typeclass_info to call. compiler/hlds_data.m: Add the class table and instance table to the module_info. compiler/hlds_out.m: Output info about base_typeclass_infos and class_method_calls compiler/hlds_pred.m: Change the representation of the locations of type_infos from "var" to type_info_locn, which is either a var, or part of a typeclass_info, since now the typeclass_infos contain the type_infos for the type that they constrain. Add constraints to the pred_info. Add constraint_proofs to the pred_info (so that typeclass.m can annotate the pred_info with the reasons that constraints were eliminated, so that polymorphism.m can in turn generate the typeclass_infos for the constraints). Add the "class_method" marker. compiler/lambda.m: A feable attempt at adding class ontexts to lambda expressions, untested and almost certainly not working. compiler/llds_out.m: Output the code addresses for do_*det_class_method, and output appropriately mangled symbol names for base_typeclass_infos. compiler/make_hlds.m: Add constraints to the types on pred and func decls, and add class and instance declarations to the class_table and instance_table respectively. compiler/mercury_compile.m: Add the check_typeclass pass. compiler/mercury_to_mercury.m: Output constraints of pred and funcs, and output typeclass and instance declarations. compiler/module_qual.m: Module qualify typeclass names in pred class contexts, and qualify the typeclass and instance decls themselves. compiler/modules.m: Output typeclass declarations in the short interface too. compiler/prog_data.m: Add the "typeclass" and "instance" items. Define the types to store information about the declarations, including class contexts on pred and func decls. compiler/prog_io.m: Parse constraints on pred and func declarations. compiler/prod_out.m: Output class contexts on pred and func decls. compiler/type_util.m: Add preds to apply a substitution to a class_constraint, and to a list of class constraints. Add type_list_matches_exactly/2. Also add typeclass_info and base_typeclass_info as types which should not be optimised as no_tag types (seeing that we cheat a bit about their representation). compiler/notes/compiler_design.html: Add notes on module qualification of class contexts. Needs expansion to include more stuff on typeclasses. compiler/*.m: Various minor changes. New Files: compiler/base_typeclass_info.m: Produce one base_typeclass_info for each instance declaration. compiler/prog_io_typeclass.m: Parse typeclass and instance declarations. compiler/check_typeclass.m: Check the conformance of an instance declaration to the typeclass declaration, including building up a proof of how superclass constraints are satisfied so that polymorphism.m is able to construct the typeclass_info, including the superclass typeclass_infos. library/mercury_builtin.m: Implement that base_typeclass_info and typeclass_info types, as well as the predicates type_info_from_typeclass_info/3 to extract a type_info from a typeclass_info, and superclass_from_typeclass_info/3 for extracting superclasses. library/ops.m: Add "typeclass" and "instance" as operators. library/string.m: Add a (in, uo) mode for string__length/3. runtime/mercury_ho_call.c: Implement do_call_*det_class_method, which are the pieces of code responsible for extracting the correct code address from the typeclass_info, setting up the arguments correctly, then executing the code. runtime/mercury_type_info.h: Macros for accessing the typeclass_info structure.	1997-12-19 03:10:47 +00:00
Fergus Henderson	5976f769f7	Fix a bug for the case of a higher-order function call in code ... Estimated hours taken: 1 Fix a bug for the case of a higher-order function call in code with common sub-expression; mercury 0.7 failed this test, reporting "Software Error: modecheck fails when repeated", due to confusion between h.o. _function_ call and h.o. _predicate_ call. compiler/hlds_goal.m: Add `pred_or_func' field to HLDS higher_order_calls. compiler/modes.m: compiler/modecheck_call.m: compiler/hlds_out.m: compiler/*.m: Add code to handle new field for higher_order_call goals. tests/valid/Mmake: tests/valid/ho_func_call.m: Regression test for the above-mentioned bug.	1997-09-01 14:05:44 +00:00
Fergus Henderson	99184d3578	Implement support for types with user-defined equality predicates. ... Estimated hours taken: 30 Implement support for types with user-defined equality predicates. Types with user-defined equality predicates are called "non-canonical types"; they may have more than one representation for the same abstract value. That means that any attempt to deconstruct a value of a non-canonical type, i.e. any attempt to peek at the representation, must be cc_multi. This also implies that conceptually speaking, non-canonical types are not members of the type classes `comparable' (compare/3) or `deconstructible' (index/2, argument/3, functor/3, deconstruct/5). Since we don't support type classes yet, that just means that the type-class checking is done at runtime, i.e. any call to one of those functions for a non-canonical type will call error/1 or fatal_error(). To make non-canonical types useful, we really need type classes, so that the user can provide instance definitions for `comparable' and `deconstructible' for such types. It might also be a good idea to have a type-class `canonicalizable' which provides a function to convert its argument to some canonical type (that would require existential types to do nicely, but alternatively we could just use `univ'). Note that currently the only mechanism for promising that things are unique is via the C interface. compiler/det_analysis.m: Add code to check unifications that examine the representation of a type with a user-defined equality predicate. Any such unification must occur in a single-solution context and must not be able to fail. Such unifications determinism have determinism cc_multi. compiler/det_report.m: Add code to report errors for misuse of types with user-defined equality predicates. (Also some other stylistic improvements: split up a complicated predicate into subroutines, and avoid some unnecessary code duplication.) compiler/prog_data.m: compiler/hlds_data.m: Add a new `maybe(sym_name)' field to the du_type/3 constructor to hold the name of the user-defined equality pred for the type, if any. compiler/prog_io.m: Add code to parse the new `... where equality is <name>.' syntax. Delete the old support for `... where <condition>'. compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/mercury_to_goedel.m: Print out the new field. compiler/base_type_layout.m: compiler/code_util.m: compiler/dense_switch.m: compiler/equiv_type.m: compiler/intermod.m: compiler/make_hlds.m: compiler/mode_util.m: compiler/module_qual.m: compiler/modules.m: compiler/switch_detection.m: compiler/tag_switch.m: compiler/type_util.m: compiler/typecheck.m: compiler/unify_gen.m: Trivial changes to ignore (or leave unchanged) the new field in `du_type'. compiler/modecheck_unify.m: Pass the term__context to unify_proc__request_unify. compiler/typecheck.m: Typecheck the compiler-generated unify predicates for types with user-defined equality preds. compiler/unify_proc.m: For d.u. types, if the type has a user-defined equality predicate then generate code for the compiler-generated unify predicate that just calls the specified predicate, and generate code for the compiler-generated compare and index predicates that just calls some procedures in mercury_builtin.m that report appropriate error messages. Ensure that the automatically-generated predicates have appropriate term__contexts everywhere, so that if the user-defined equality predicate name is ambiguous, non-existent, or has the wrong type, mode, or determinism, then the error messages from type checking, mode checking, or determinism checking refer to the type declaration. library/mercury_builtin.m: Add predicates builtin_index_non_canonical_type/2 and builtin_compare_non_canonical_type/2, used by the code generated by compiler/unify_proc.m. doc/reference_manual.texi: Document the support for user-defined equality predicates. library/std_util.m: Change ML_expand() to return an indication of whether or not the type is a non-canonical type (one with a user-defined equality predicate). Change argument/2, functor/2, and deconstruct/4 to abort if called for a non-canonical type.	1997-08-22 13:57:43 +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
Andrew Bromage	9b7f11c6dd	Reorganisation of modules to do with the inst data type. ... Estimated hours taken: 20 Reorganisation of modules to do with the inst data type. This is actually the first installment of the alias tracking mode checker in disguise. A very good disguise. The rationale for this reorganisation is to reduce coupling in the part of the mode checker which is _not_ in this change (ie most of it). Alias tracking requires a new kind of inst, alias(inst_key), where an inst_key is a handle on some other sub-inst. With it goes a data structure in which to store dereferenced insts and all the operations which go with it. This code will go in the new module inst.m so that it doesn't have to go in prog_data.m. (I briefly considered putting it in instmap.m however this introduces some bad coupling since instmap.m imports hlds_module.m. Putting it in prog_data.m would cause hlds_*.m to depend on prog_data.m, but we have designed things so that the dependencies go in the other direction.) The remainder of the reorganisation is a general cleanup: the inst testing predicates (inst_is_*) have been moved out of mode_util because they are not actually operations on modes at all, and have been moved into inst_match. inst_match has then been split because otherwise it would be 2000 lines long and will get significantly bigger when aliasing is added. Roughly speaking, any operations which create new insts from old ones have been moved into a new module, inst_util while any operations which test the values of insts remain in inst_match. Also included are the removal of some NU-Prologisms since the NU-Prolog version of the compiler is no longer supported. Two changes here: - Removal of some when declarations. - A gross hack in inst_is_*_2, where two copies of the same inst were passed into the predicate so that one could be switched on. Thank NU-Prolog's lack of common subexpression elimination. compiler/inst.m: New module which contains the data types inst, uniqueness, pred_inst_info, bound_inst. compiler/inst_util.m: New module which contains predicates which perform mode checking-like operations on insts. Moved in: abstractly_unify_inst, abstractly_unify_inst_functor, inst_merge, make_mostly_uniq_inst (from inst_match.m) compiler/inst_match.m: Moved out: inst_merge, make_mostly_uniq_inst, abstractly_unify_inst, abstractly_unify_inst_functor (to inst_util.m) Moved in: inst_is_*, inst_list_is_*, bound_inst_list_is_* (from mode_util.m) Now exported: unique_matches_initial/2, unique_matches_final/2 inst_contains_instname/3, pred_inst_matches/3 (They are required by inst_util.m, and they are useful in their own right.) compiler/instmap.m: instmap_delta_lookup_var/3 reincarnated as instmap_delta_search_var/3. The reason for this change is that previously, instmap_delta_lookup_var simply returned `free' if the searched-for var did not occur in the instmap_delta. This is somewhat non-obvious behaviour. instmap_delta_search_var/3 fails in such a situation. compiler/mode_util.m: Moved out: inst_is_*, inst_list_is_*, bound_inst_list_is_* (to inst_match.m) (These are not really operations on modes.) compiler/modecheck_call.m: Moved in modecheck_higher_order_func_call/5, from modecheck_unify.m compiler/modecheck_unify.m: Moved out modecheck_higher_order_func_call/5, to modecheck_call.m where it should have been all along. compiler/prog_data.m: Moved out the types inst, uniqueness, pred_inst_info, bound_inst (to inst.m). compiler/common.m: compiler/cse_detection.m: compiler/fact_table.m: compiler/higher_order.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_out.m: compiler/intermod.m: compiler/liveness.m: compiler/llds.m: compiler/make_hlds.m: compiler/mercury_to_mercury.m: compiler/mode_debug.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/modes.m: compiler/module_qual.m: compiler/polymorphism.m: compiler/prog_io.m: compiler/prog_io_util.m: compiler/prog_util.m: compiler/simplify.m: compiler/switch_detection.m: compiler/unify_proc.m: compiler/unique_modes.m: Miscellaneous minor changes to cope with the above changes. compiler/notes/compiler_design.html: Document the new modules.	1997-07-24 01:27:21 +00:00
Fergus Henderson	1c0dd039c4	Fix a problem with my last change to output verbose progress ... Estimated hours taken: 0.25 compiler/switch_detection.m: Fix a problem with my last change to output verbose progress messages during switch detection: the messages were a bit *too* verbose.	1997-07-08 05:46:01 +00:00
Fergus Henderson	7d5136b303	Output verbose progress messages during switch detection. ... Estimated hours taken: 0.25 compiler/switch_detection.m: compiler/mercury_compile.m: Output verbose progress messages during switch detection.	1997-07-07 12:05:04 +00:00
Fergus Henderson	365d737a15	Fix a bug. It was preferring incomplete switches to ... Estimated hours taken: 8 compiler/switch_detection.m: Fix a bug. It was preferring incomplete switches to complete one-case switches, which lead to spurious determinism errors in some cases.	1997-05-11 10:52:53 +00:00
Simon Taylor	ce9ef7ebbb	Fix a determinism analysis abort which was caused by det_analysis.m not ... Estimated hours taken: 1.5 Fix a determinism analysis abort which was caused by det_analysis.m not updating the instmap to include the initial insts of the lambda variables before processing a lambda goal. This problem was also present in cse_detection.m and simplify.m. compiler/cse_detection.m compiler/det_analysis.m compiler/simplify.m Make sure that the instmap is updated before processing a lambda goal. compiler/switch_detection.m compiler/instmap.m Move some code to update the instmap before a lambda goal from switch_detection.m into a new predicate instmap__update_for_lambda_modes/5. tests/valid/Mmake tests/valid/lambda_instmap_bug.m Regression test.	1997-05-08 06:46:56 +00:00
Fergus Henderson	e3471f333f	Fix a bug in inlining of polymorphic pragma c_code procedures. ... Estimated hours taken: 3 Fix a bug in inlining of polymorphic pragma c_code procedures. The bug was that if the actual argument type has a specific type of say `float', then the C variable for the corresponding formal parameter will be declared to have type `Float', whereas without inlining the argument type would have been polymorphic and so the C variable would have been declared to have type `Word'. Hence we need to keep track of the original argument types, before any inlining or specialization has occurred, and use these original argument types to determine how to declare the C variables, rather than using the actual argument types for this particular specialization. compiler/hlds_goal.m: Add a new field to pragma_c_code goals, holding the original argument types (before any inlining or specialization) of the pragma_c_code procedure. compiler/make_hlds.m: Initialize this field with the declared argument types for the pragma c_code procedure. compiler/polymorphism.m: Update this field to account for the inserted type_info variables. compiler/code_gen.m: Pass this field to pragma_c_gen.m. compiler/pragma_c_gen.m: Use the original argument types field for the pragma variable declarations, rather than looking up the actual types of the arguments. compiler/*.m: Trivial changes to handle new field. compiler/live_vars.m: Comment out some code to avoid a warning about `fail' in the condition of an if-then-else.	1997-05-05 11:17:40 +00:00
Zoltan Somogyi	4c3b0ecb09	Replace calls to map__set with calls to either map__det_insert or ... Estimated hours taken: 3 Replace calls to map__set with calls to either map__det_insert or map__det_update. In some cases this required a small amount of code reorganization.	1997-04-07 05:39:59 +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	7b687a4a71	Support 8-bit characters, including '\0'. (Previously we didn't ... support them because NU-Prolog couldn't support them.) This required two main changes: (a) eliminating places where we explicitly assumed that character codes ranged from 1 to 127. (b) making sure that all conversions from `Char' to `Integer' are done by first explicitly casting to `UnsignedChar'. This is necessary to avoid potential problems on C compilers for which `char' is signed. library/char.m: library/char.nu.nl: Replace the implementation of char__to_int as a big table with an implementation using pragma c_code, so that it doesn't assume that character codes range from 1 to 127. Move the old implementation into a new file char.nu.nl, since it's still needed for Prolog support. Add new predicates char__min_char_value/1 and char__max_char_value/1. library/Mmakefile: Add char.nu.nl to the list of files needed for Prolog support. library/lexer.m: Rewrite io__get_token_[12] in the original (less efficient) way that they were written before conway's change in revision 1.17, to avoid assuming anything about the range of character codes. (Once this change has bootstrapped, it might be worth going back to the efficient version, modified of course to assume that character codes range from 0..255 rather than 1..127. However, at least for bootstrapping we need to use the less efficient version.) runtime/mercury_string.h: Add `UnsignedChar' typedef. library/string.m: In string__to_int_list, make sure that the conversion from `Char' to `Integer' is done by first explicitly casting to `UnsignedChar'. Also a few other minor fixes: - remove an old XXX by using make_aligned_string() - use `size_t' rather than `Word' for a string length; - add a missing `const' - remove an unnecessary cast to (char) - change a `while (--p >= Str) { ...' to `while (p > Str) { p--; ...', because pointing to one before the start of an array is not strictly ANSI-conformant. compiler/switch_detection.m: compiler/dense_switch.m: Use char__min_char_value and char__max_char_value to avoid assuming 7-bit chars. (We still don't get cross-compilation between platforms with different size characters right yet, but that's not a major issue right now.) compiler/export.m: Make sure that conversions from `Char' to `Word' are done by first explicitly casting to `UnsignedChar'. NEWS: Mention that we now support 8-bit characters. Mention the new predicates char__min_char_value/1 and char__max_char_value/1, as well as int__int_min, int__int_max, int__bits_per_int (which were added previously, with different names, but not mentioned in the NEWS file). Also make minor cleanups to a few of the other messages.	1997-02-19 05:36:24 +00:00
Zoltan Somogyi	91c4330db7	The first half of a change to introduce nondet pragma C goals. ... Estimated hours taken: 12 The first half of a change to introduce nondet pragma C goals. This half makes the necessary modifications to the HLDS; the next half will modify the LLDS and emit it. prog_data: Add a new pragma type for nondet pragma c_codes; these specify the names of a a bunch of variables to save across backtracking, and a list of label names to which backtracking may take place. Rename is_recursive to may_call_mercury, since this is a more direct expression of the meaning. prog_io: Move much of the functionality to new files. prog_io_dcg, prog_io_goal, prog_io_pragma, prog_io_util: New files, made up of pieces of prog_io. hlds_goal: Add an extra argument to the pragma_c_goals to store the extra information present in the new type of pragma c_codes. det_analysis: Take into account that the new type of pragma_c goal may have more than one solution. goal_util: Rename variables in the new field of pragma_cs. live_vars: Allocate stack slots to the saved variables in the new type of pragma_c goals. make_hlds: Handle the new type of pragma_c goals. mercury_output, hlds_out: Output the new type of pragma_c goals. garbage_out: Rename type "det" to "frame_type". others: Ignore one more arg of pragma_c goals or import prog_io_util.	1997-01-27 07:45:40 +00:00
Simon Taylor	bb2b816787	* Inter-module unused argument removal. ... Estimated hours taken: 100 * Inter-module unused argument removal. * Allow the user to specify which directories should be searched for .opt files. * Enhancements to simplify.m and common.m which will be useful for partial deduction. compiler/options.m Added and documented options: --intermod-unused-args to enable inter-module unused argument removal. --intermod-directory <dir>, same as --search-directory except used to locate .opt files. --use-search-directories-for-intermod - use the search directories for .opt files as well. --warn-simple-code - a flag to control the warnings produced by simplify.m so that they respect --inhibit-warnings. compiler/unused_args.m Use the unused argument info from the .opt file. Clobber the dependency_info if any new preds were added. compiler/hlds_module.m Added a field to the module_info to store unused argument information from .opt files. compiler/prog_data.m Add :- pragma unused_args to hold unused argument information. This should only be used in .opt files. compiler/make_hlds.m Build the unused_arg_info field in the module_info. Check that pragma unused_args only appears in .opt files. Fill in the non-locals field in the goal_info for the builtin stubs so that mode analysis computes the correct instmap delta. compiler/intermod.m Read in the unused argument information for the current module when compiling to C. This is used to ensure that clauses are produced with the correct number of removed arguments (it may be possible to remove more arguments with the information from other modules). Fix a bug in the handling of module qualified function calls and higher-order predicate constants. compiler/handle_options.m Handle --intermod-unused-args and --use-search-directories-for-intermod. compiler/mercury_compile.m Run the entire front end and polymorphism (not just up to typechecking) when building the .opt file with --intermod-unused-args. Use the new interface to simplify.m, remove calls to excess.m and common.m. compiler/code_util.m compiler/llds_out.m When generating local code for a specialized version of a predicate from another module, put this module's name on the label to avoid link errors. compiler/higher_order.m Don't add the originating module name to the name of the specialized version, since that is now done in code_util.m. Clobber the dependency graph so that inlining will work on the specialized versions in profiling grades (this will cause slightly slower compilation in profiling grades, something I need to fix). compiler/simplify.m Merge a branching goal and an adjacent switch where the branches of the first goal contain extra information about the switched on variable of the second goal. Merge the excess assignments and common subexpression elimination passes into simplify.m. compiler/excess.m The functionality of this module is now in simplify.m, but I'll leave it here for now. compiler/instmap.m Added predicates instmap__bind_var_to_functor and instmap_delta_bind_var_functor to which take a var, cons_id and an instmap and adjust the inst of the var. This is used to update the instmap at the beginning of each case in a switch. Fix a bug in merge_instmap_delta where variables whose inst had information added in one branch of a switch, disj, or ite had that changed inst included in the instmap_delta for the entire branched goal. compiler/mode_util.m Use instmap_delta_bind_var_to_functor in recompute_instmap_delta. Added predicate bind_inst_to_functor which takes a ground or bound inst and a cons_id and adjusts the top level of the inst to be bound to that cons_id. Other types of inst are left unchanged. Change recompute_instmap_delta so that the switched on variable of a switch is bound to the functor in each case even if the binding unification has been removed. Added a boolean argument to request recomputation of instmap_deltas for atomic goals. compiler/modes.m compiler/unique_modes.m Make sure that the instmap_delta for each branch of a switch includes the extra information added by the functor test. compiler/common.m Removed the goal traversal. Leave preds to be called by simplify.m to optimise common unifications and calls. Warn about and eliminate multiple calls to a predicate with the same input arguments. Replace deconstructions of known terms with assignments to the output variables where this would not make more variables live at stack flushes. compiler/follow_code.m Exported move_follow_code_select. Don't move follow code into erroneous branches. library/string.nu.nl Added string__contains_char/2. compiler/base_type_layout.m compiler/special_pred.m compiler/vn_order.m library/mercury_builtin.m Removed duplicate calls. doc/user_guide.texi Documented options. tests/warnings/duplicate_call.m tests/warnings/duplicate_call.exp Test duplicate call warning.	1997-01-20 03:27:59 +00:00
Fergus Henderson	2af7e75639	Fix a bug that Philip reported to Zoltan regarding ... Estimated hours taken: 0.5 Fix a bug that Philip reported to Zoltan regarding spurious determinism errors in lambda expressions. compiler/switch_detection.m: When detecting switches in lambda expressions, we need to insert the initial insts for the lambda variables in the instmap before processing the lambda goal.	1996-12-10 13:14:12 +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
Zoltan Somogyi	0632ae69dd	Fix a long-standing bug that caused all fixpoint iterations to stop ... Estimated hours taken: 8 livemap: Fix a long-standing bug that caused all fixpoint iterations to stop too early. By causing value_numbering to miscompile the predicate mercury_compile__maybe_unused_args, this bug caused the unwanted printing of statistics for tests/warnings/unused_args_test. Fix also another bug: we did not process the control rval in computed gotos. To my knowledge this has never been tickled. Redesign the interface of the exported predicate slightly to make it more robust. frameopt, value_number: Use the modified interface of livemap. switch_detection: For a while now we have removed arms from switches if we knew from the instantiation of the control variable that those arms could not be executed. Sometimes this results in switches with no arms. If the control variable of the switch is never used after the switch, liveness won't see the occurrence in the switch construct as a use, and will kill the variable too early, cause the code generator to abort. We now turn switches with no arms into "fail"; this improves the code generated and avoids the bug. However, liveness should still be changed to consider the occurrence of a variable in the first arg of a switch a use. code_gen, vn_block: Formatting changes.	1996-11-16 03:07:50 +00:00
Zoltan Somogyi	5d64b759db	The main changes are ... Estimated hours taken: 12 The main changes are 1 associating a name with the arguments of constructors 2 removing the follow_vars field from calls, higher-order calls and complicated unifications, since they are not used 3 merging the follow_vars and store_alloc passes, since they logically belong together 4 add a new module, lco, for detecting opportunities for last call optimization modulo constructor application; it won't actually apply the optimization until the mode system becomes expressive enough to handle it (this module detects 529 opportunities in the compiler and library) 5 make "-O3 --optimize-value-number" do the right thing; previously, it used not to apply value numbering because the vnrepeat option defaulted to zero 6 don't refer to .err2 files anymore; use .err instead. prog_data: The list associated with each value of type "constructor" now contains not only the types of the arguments but their names as well. equiv_type, hlds_data, hlds_out, make_hlds, mercury_to_{goedel,mercury}, mode_util, module_qual, shapes, type_util, unify_proc: Modify the traversal of type definitions to account for the names in the lists inside values of type "constructor". prog_io: Parse argument names. An unrelated change is that we now check whether :- pred declarations give modes to some of their arguments but not to all, in which case we return an error. hlds_goal: Remove the follow_vars field from calls, higher-order calls and complicated unifications. *.m: Handle the new arities of calls, higher order calls and complicated unifications. mercury_compile: Don't call follow_vars directly anymore, but do call lco if its option is set. Also flush the main output before a call to maybe_report_stats to prevent ugly output. store_alloc: Call follow_vars directly. follow_vars: Expose the initialization and traversal predicates for store_alloc. lco: Find opportunities for last call optimization modulo constructor application. passes_aux: Add a HLDS traversal type for lco. optimize: Consider the vnrepeat count to be zero unless value numbering is on. options: Set the default value of vnrepeat to 1. modules: Don't refer to .err2 files.	1996-11-04 06:26:51 +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
Fergus Henderson	0e1e0b0b91	Implement recursive' and non_recursive' pragma c_code declarations. ... Estimated hours taken: 4 Implement `recursive' and `non_recursive' pragma c_code declarations. This allows the compiler to optimize cases when the C code is known to not call Mercury code. It's also necessary to allow C code which modifies the hp register to work (such code must be declared `non_recursive', otherwise the registers will be saved and restored over it). To make things bootstrap OK, the old pragma c_code declarations default to `non_recursive'. prog_data.m, hlds_goal.m: Add new field c_is_recursive to pragma c_code goals. prog_io.m: Parse the new `recursive' and `non_recursive' pragma c_code declarations. make_hlds.m: Pass the c_is_recursive field from the parse tree to the HLDS. live_vars.m: For non-recursive C code, don't save variables on the stack. code_gen.pp: For non-recursive C code, don't save variables on the stack, don't mark the succip as needing to be saved, and don't call save_registers() and restore_registers(). *.m: Change c_code/5 to c_code/6.	1996-06-10 17:18:50 +00:00
Fergus Henderson	60b9fa83b6	Implement higher-order functions. ... Estimated hours taken: 12 Implement higher-order functions. Add higher-order function terms (function lambda expressions, e.g. `Func = (func(X) = Y :- Y is 2 * X)' and higher-order function calls (apply/N, e.g. `Z = apply(Func, 42)'). Add higher-order function insts and modes. hlds_goal.m: Add a new field pred_or_func to lambda_goal. prog_data.m: Add a new field pred_or_func to pred_inst_info. prog_io.m: Add support for parsing higher-order function terms and higher-order function insts and modes. make_hlds.m: Add support for parsing higher-order function terms. typecheck.m: Add support for type-checking higher-order function calls and higher-order function terms. modes.m, mode_errors.m: Add support for mode-checking higher-order function calls and higher-order function terms. higher_order.m: Handle higher-order function types and insts. hlds_pred.m: Add new predicate pred_args_to_func_args, for extracting the function arguments and function return from the arguments of a predicate that is really a function. *.m: Minor changes to handle new pred_or_func field in lambda_goals and pred_inst_infos.	1996-05-14 10:07:46 +00:00
Zoltan Somogyi	99e729814f	Make sure we don't change the goal being analyzed except possibly ... Estimated hours taken: 20 det_analysis: Make sure we don't change the goal being analyzed except possibly for the introduction of `some's (which should not hurt anything). Make sure we don't print any error messages except in the final iteration, when all the inputs to the inference are stable. If the --debug-detism options is set, print messages about the progress of inference and checking. Also moved some code around. det_report: Distinguish the handling of warning messages and error messages. simplify: Use the new ability of det_report to separate warnings and errors. passes_aux: Add a new generic pass form, for use by simplify. option: Add --debug-detism (as above), --aditi, which at the moment only enables the disjunctive normal form transformation, and --inlining/--no-inlining, which set the other three flags involved in inlining depending on whether you want standard inlining or none at all. Follow_code used to be set twice and follow_vars not at all; I fixed this. Reenabled optimize_higher_order at -O3. Moved value numbering to -O4 and pred_value_number to -O5. This makes it easier to separate value numbering from the other optimizations (which are likely to be more effective). Divided options_help into sections to avoid excessive compilation times. store_alloc: Base the store map on the follow_vars info attached to the branched structure which I added recently, and not on the follow_vars map being passed around, since it will be more accurate. hlds_out: Print information about follow_vars and store_maps when -D is given. follow_code: Undo an old hack that change to follow_vars has made counterproductive. middle_rec: Fix a bug uncovered by the change to follow_code. When looking for a register to hold the counter, it is not enough to avoid picking a register that appears in the recursive case; we must also avoid registers that occur only in the base case. livemap: Mentioning the code address succip now causes the succip to be considered live. This may or may not fix the bug with pred_value_number miscompiling unused_args.m; the other changes have caused the input to value numbering to change, and they no longer trigger the problem. (Will try to test this later.) mercury_compile: Try to make sure that we print statistics only after passes that were actually executed. Also, reduce the number of lookups of the verbose option. Move some predicates so that the order of their appearance matches the current order of invocation. vn_table: Loosen a sanity check to let xnuc2 pass through it. code_exprn, switch_detection: Minor changes.	1996-05-10 09:49:17 +00:00
Fergus Henderson	9a7da88ce0	Treat higher-order predicate calls as a new sort of goal, ... Estimated hours taken: 24 Treat higher-order predicate calls as a new sort of goal, rather than as calls to the special predicate call/N, in order to remove the fixed limit on the number of arguments and on the modes for call/N. Also, remove the restriction on output arguments preceding input arguments in lambda expressions. hlds_goal.m: Add new functor higher_order_call/6 to the hlds__goal type. *.m: Handle new functor higher_order_call/6. arg_info.m: Abstract things a bit more: the argument passing convention for a procedure may be affected by that procedure's types, modes, and code_model, as well as the arg_method. follow_vars.m: Pass down the args_method, since it is now needed for figuring out the arg_info for unifications and higher-order calls. follow_code.m: Treat complicated unifications in the same way as calls. lambda.m: When creating lambda predicates, permute the arguments so that all input arguments come before all output arguments. call_gen.m: When generating higher-order predicate calls, don't abort if outputs precede inputs; instead, generate code assuming that the called predicate's args have been permuted so that the inputs to come before all the outputs.	1996-05-02 22:44:50 +00:00
Zoltan Somogyi	e04067b552	A large step in cleaning up the determinism system. ... Estimated hours taken: 8 A large step in cleaning up the determinism system. simplify: Determinism analysis should not modify the code of the procedures it checks, yet we need to massage some goals to make them acceptable to the code generator. The obvious solution is to perform this massaging after analysis is finished. This is what this new module does. det_util: New module to hold types and predicates used in more than one module involved with the determinism system. Some types and/or predicates used to be in switch_detection, det_analysis, det_report, but the misc_info type has been expanded and renamed det_info. det_analysis: Don't modify the goal being analyzed except to insert "some" goals. This is important because the relevant part of det_analysis knows only the current inferred determinism of the goal, not its final determinism. The modification code is now in simplify (after some fixes). Import det_util. Move some utility preds to det_util. Export more of the determinism tables; some are needed in simplify. det_report: Import det_util. Move some utility preds to det_util. Add some more warning messages. cse_detection: Import det_util. switch_detection: Import det_util. Move some utility preds to det_util. passes_aux: Defined a predicate for traversing the HLDS hierarchy for processing all the non-imported procedures. Defined write_proc_progress_message to complement write_progress_message (which has been renamed write_pred_progress_message). dead_proc_elim, modes, typecheck, unique_modes: Use write_{proc/pred}_progress_message as appropriate. hlds_out: Add a new predicate hlds_out__write_pred_proc_id. hlds_module: Improve an abort message. llds_out: Formatting changes. mercury_compile: Call simplify__proc through the new traversal predicate in passes_aux.	1996-04-28 07:25:49 +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