62 Commits

Author	SHA1	Message	Date
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
Fergus Henderson	4be69fa961	Eliminated a lot of the dependencies on the the `code_model' type, ... Estimated hours taken: 6 Eliminated a lot of the dependencies on the the `code_model' type, and move that type from llds.m into a new module `code_model'. The aim of this change is to improve the modularity of the compiler by reducing the number of places in the compiler front-end that depend on back-end concepts and the number of places in the MLDS back-end which depend on the LLDS. compiler/code_model.m: New module. Contains the code_model type and associated procedures. compiler/llds.m: Move the code_model type into code_model.m. compiler/hlds_goal.m: Move the goal_info_get_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/hlds_out.m: Delete `hlds_out__write_code_model', since it wasn't being used. compiler/hlds_pred.m: Move the proc_info_interface_code_model procedure into code_model.m, to avoid having the HLDS modules import code_model. compiler/goal_path.m: When computing the `maybe_cut' field for `some' goals, compute it by comparing the determinism rather than by comparing the goal_infos. compiler/unique_modes.m: Use determinism and test for soln_count = at_most_many rather than using code_model and testing for model_non. compiler/inlining.m: Test for determinism nondet/multi rather than testing for code_model model_non. compiler/hlds_pred.m: compiler/det_report.m: Change valid_code_model_for_eval_method, which succeeded unless the eval_method was minimal_model and the code_model was model_det, to valid_determinism_for_eval_method, which succeeds unless the eval_method is minimal_model and the determinism cannot fail. As well as avoiding a dependency on code_model in the HLDS modules, this also fixes a bug where det_report could give misleading error messages, saying that `multi' was a valid determinism for `minimal_model' predicates, when in fact the compiler will always report a determinism error if you declare a `minimal_model' predicate with determinism `multi'. (Actually the code in which this bug occurs is in fact unreachable, but this is no doubt also a bug... I'll address that one in a separate change.) compiler/lookup_switch.m: Simplify the code a bit by using globals__lookup_*_option rather than globals__get_option and then getopt__lookup_option. compiler/*.m: Add `import_module' declarations for `code_model', and in some cases remove `import_module' declarations for `llds'.	2000-11-23 04:32:51 +00:00
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
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	75354e38bb	Deforestation. ... Estimated hours taken: 400 Deforestation. This increases the code size of the compiler by ~80k when compiling with --intermodule-optimization --deforestation. The improvement from deforestation is not measurable for mmc -C make_hlds.m. Compile time for make_hlds.m increased from 50.7 seconds to 52.2 seconds when running deforestation. compiler/simplify.m compiler/common.m Provide a nicer interface for simplifying a goal, not an entire procedure. Rework the interface to avoid manipulating lots of booleans. Return an estimate of the improvement in cost from simplification. Remove failing cases and disjuncts. Add an option to optimize common structures even across calls. Remove code to merge branched goals, since that is now done by deforestation. Fix a bug: the code to collect instmap_deltas for cases was not including the switched-on variable in the instmap_delta, which caused an abort in merge_instmap_delta if the switched on variable was further instantiated in the switch. This came up while compiling the compiler with --deforestation. compiler/det_report. Output duplicate call warnings even if --warn-simple-code is not set. XXX fix the same problem with `:- pragma obsolete'. compiler/code_aux.m Update code_aux__cannot_loop to use termination information. compiler/hlds_pred.m compiler/dnf.m Pass the type_info_varmap and typeclass_info_varmap into hlds_pred__define_new_pred. Restrict the variables of the new procedure onto the variables of the goal. Make sure all relevant type_infos are passed into the new procedure if --typeinfo-liveness is set. compiler/modes.m compiler/unique_modes.m compiler/mode_info.m compiler/modecheck_unify.m Put `how_to_check_goal' into the mode_info, rather than passing it around. Add a field to the `check_unique_modes' case which controls whether unique modes is allowed to choose a different procedure. For deforestation, this is not allowed, since it could result in choosing a less efficient procedure after generalisation. compiler/options.m New options: --deforestation --deforestation-depth-limit Safety net for termination of the algorithm. --deforestation-cost-factor Fudge factor for working out whether deforestation was worthwhile. --deforestation-vars-threshold Like --inline-vars-threshold. Enable deforestation at -O3. Removed an unnecessary mode for option_defaults_2, since it resulted in a warning about disjuncts which cannot succeed. compiler/handle_options.m --no-reorder-conj implies --no-deforestation. compiler/inlining.m Separate code to rename goals into inlining__do_inline_call. compiler/hlds_goal.m Added predicates goal_list_nonlocals, goal_list_instmap_delta and goal_list_determinism to approximate information about conjunctions. compiler/hlds_module.m Added module_info_set_pred_proc_info to put an updated pred_info and proc_info back into the module_info. compiler/hlds_out.m Exported hlds_out__write_instmap for debugging of deforestation. Bracket module names on constructors where necessary. compiler/mercury_compile.m Call deforestation. Use the new interface to simplify.m. compiler/intermod.m Put recursive predicates with a top-level branched goal into `.opt' files. goal_util.m Added goal_calls_pred_id to work out if a predicate is recursive before mode analysis. Export goal_util__goals_goal_vars for use by deforestation. Give a better message for a missing variable in a substitution. compiler/instmap.m Give a better message for inst_merge failing. compiler/notes/compiler_design.m Document the new modules. library/varset.m Add varset__select to project a varset's names and values onto a set of variables. doc/user_guide.texi Document deforestation. Remove a reference to a non-existent option, --no-specialize. util/mdemangle.c profiler/demangle.m tests/misc_tests/mdemangle_test.{exp,inp} Handle the `DeforestationIn__' predicate names introduced by deforestation, similar to the `IntroducedFrom__' for lambda goals. New files: deforest.m Deforestation. pd_cost.m Cost estimation. pd_debug.m Debugging output. pd_info.m State type and version control. pd_term.m Termination checking. pd_util.m Utility predicates	1998-04-27 04:05:12 +00:00
Fergus Henderson	11d8161692	Add support for nested modules. ... Estimated hours taken: 50 Add support for nested modules. - module names may themselves be module-qualified - modules may contain `:- include_module' declarations which name sub-modules - a sub-module has access to all the declarations in the parent module (including its implementation section). This support is not yet complete; see the BUGS and LIMITATIONS below. LIMITATIONS - source file names must match module names (just as they did previously) - mmc doesn't allow path names on the command line any more (e.g. `mmc --make-int ../library/foo.m'). - import_module declarations must use the fully-qualified module name - module qualifiers must use the fully-qualified module name - no support for root-qualified module names (e.g. `:parent:child' instead of `parent:child'). - modules may not be physically nested (only logical nesting, via `include_module'). BUGS - doesn't check that the parent module is imported/used before allowing import/use of its sub-modules. - doesn't check that there is an include_module declaration in the parent for each module claiming to be a child of that parent - privacy of private modules is not enforced ------------------- NEWS: Mention that we support nested modules. library/ops.m: library/nc_builtin.nl: library/sp_builtin.nl: compiler/mercury_to_mercury.m: Add `include_module' as a new prefix operator. Change the associativity of `:' from xfy to yfx (since this made parsing module qualifiers slightly easier). compiler/prog_data.m: Add new `include_module' declaration. Change the `module_name' and `module_specifier' types from strings to sym_names, so that module names can themselves be module qualified. compiler/modules.m: Add predicates module_name_to_file_name/2 and file_name_to_module_name/2. Lots of changes to handle parent module dependencies, to create parent interface (`.int0') files, to read them in, to output correct dependencies information for them to the `.d' and `.dep' files, etc. Rewrite a lot of the code to improve the readability (add comments, use subroutines, better variable names). Also fix a couple of bugs: - generate_dependencies was using the transitive implementation dependencies rather than the transitive interface dependencies to compute the `.int3' dependencies when writing `.d' files (this bug was introduced during crs's changes to support `.trans_opt' files) - when creating the `.int' file, it was reading in the interfaces for modules imported in the implementation section, not just those in the interface section. This meant that the compiler missed a lot of errors. library/graph.m: library/lexer.m: library/term.m: library/term_io.m: library/varset.m: compiler/*.m: Add `:- import_module' declarations to the interface needed by declarations in the interface. (The previous version of the compiler did not detect these missing interface imports, due to the above-mentioned bug in modules.m.) compiler/mercury_compile.m: compiler/intermod.m: Change mercury_compile__maybe_grab_optfiles and intermod__grab_optfiles so that they grab the opt files for parent modules as well as the ones for imported modules. compiler/mercury_compile.m: Minor changes to handle parent module dependencies. (Also improve the wording of the warning about trans-opt dependencies.) compiler/make_hlds.m: compiler/module_qual.m: Ignore `:- include_module' declarations. compiler/module_qual.m: A couple of small changes to handle nested module names. compiler/prog_out.m: compiler/prog_util.m: Add new predicates string_to_sym_name/3 (prog_util.m) and sym_name_to_string/{2,3} (prog_out.m). compiler/*.m: Replace many occurrences of `string' with `module_name'. Change code that prints out module names or converts them to strings or filenames to handle the fact that module names are now sym_names intead of strings. Also change a few places (e.g. in intermod.m, hlds_module.m) where the code assumed that any qualified symbol was fully-qualified. compiler/prog_io.m: compiler/prog_io_goal.m: Move sym_name_and_args/3, parse_qualified_term/4 and parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m, since they are very similar to the parse_symbol_name/2 predicate already in prog_io.m. Rewrite these predicates, both to improve maintainability, and to handle the newly allowed syntax (module-qualified module names). Rename parse_qualified_term/5 as `parse_implicit_qualified_term'. compiler/prog_io.m: Rewrite the handling of `:- module' and `:- end_module' declarations, so that it can handle nested modules. Add code to parse `include_module' declarations. compiler/prog_util.m: compiler/*.m: Add new predicates mercury_public_builtin_module/1 and mercury_private_builtin_module/1 in prog_util.m. Change most of the hard-coded occurrences of "mercury_builtin" to call mercury_private_builtin_module/1 or mercury_public_builtin_module/1 or both. compiler/llds_out.m: Add llds_out__sym_name_mangle/2, for mangling module names. compiler/special_pred.m: compiler/mode_util.m: compiler/clause_to_proc.m: compiler/prog_io_goal.m: compiler/lambda.m: compiler/polymorphism.m: Move the predicates in_mode/1, out_mode/1, and uo_mode/1 from special_pred.m to mode_util.m, and change various hard-coded definitions to instead call these predicates. compiler/polymorphism.m: Ensure that the type names `type_info' and `typeclass_info' are module-qualified in the generated code. This avoids a problem where the code generated by polymorphism.m was not considered type-correct, due to the type `type_info' not matching `mercury_builtin:type_info'. compiler/check_typeclass.m: Simplify the code for check_instance_pred and get_matching_instance_pred_ids. compiler/mercury_compile.m: compiler/modules.m: Disallow directory names in command-line arguments. compiler/options.m: compiler/handle_options.m: compiler/mercury_compile.m: compiler/modules.m: Add a `--make-private-interface' option. The private interface file `<module>.int0' contains all the declarations in the module; it is used for compiling sub-modules. scripts/Mmake.rules: scripts/Mmake.vars.in: Add support for creating `.int0' and `.date0' files by invoking mmc with `--make-private-interface'. doc/user_guide.texi: Document `--make-private-interface' and the `.int0' and `.date0' file extensions. doc/reference_manual.texi: Document nested modules. util/mdemangle.c: profiler/demangle.m: Demangle names with multiple module qualifiers. tests/general/Mmakefile: tests/general/string_format_test.m: tests/general/string_format_test.exp: tests/general/string__format_test.m: tests/general/string__format_test.exp: tests/general/.cvsignore: Change the `:- module string__format_test' declaration in `string__format_test.m' to `:- module string_format_test', because with the original declaration the `__' was taken as a module qualifier, which lead to an error message. Hence rename the file accordingly, to avoid the warning about file name not matching module name. tests/invalid/Mmakefile: tests/invalid/missing_interface_import.m: tests/invalid/missing_interface_import.err_exp: Regression test to check that the compiler reports errors for missing `import_module' in the interface section. tests/invalid/*.err_exp: tests/warnings/unused_args_test.exp: tests/warnings/unused_import.exp: Update the expected diagnostics output for the test cases to reflect a few minor changes to the warning messages. tests/hard_coded/Mmakefile: tests/hard_coded/parent.m: tests/hard_coded/parent.child.m: tests/hard_coded/parent.exp: tests/hard_coded/parent2.m: tests/hard_coded/parent2.child.m: tests/hard_coded/parent2.exp: Two simple tests case for the use of nested modules with separate compilation.	1998-03-03 17:48:14 +00:00
Zoltan Somogyi	5013dd9c76	Implement nondet pragma C codes. ... Estimated hours taken: 40 Implement nondet pragma C codes. runtime/mercury_stacks.h: Define a new macro, mkpragmaframe, for use in the implementation of nondet pragma C codes. This new macro includes space for a struct with a given sruct tag in the nondet stack frame being created. compiler/{prog_data.m,hlds_goal.m}: Revise the representation of pragma C codes, both as the item and in the HLDS. compiler/prog_io_pragma.m: Parse nondet pragma C declarations. Fix the indentation in some places. compiler/llds.m: Include an extra argument in mkframe instructions. This extra argument gives the details of the C structure (if any) to be included in the nondet stack frame to be created. Generalize the LLDS representation of pragma C codes. Instead of a fixed sequence of <assign from inputs, user c code, assign to outputs>, let the sequence contain these elements, as well as arbitrary compiler-generated C code, in any order and possibly with repetitions. This flexibility is needed for nondet pragma C codes. Add a field to pragma C codes to say whether they can call Mercury. Some optimizations can do a better job if they know that a pragma C code cannot call Mercury. Add another field to pragma C codes to give the name of the label they refer to (if any). This is needed to prevent labelopt from incorrectly optimizing away the label definition. Add a new alternative to the type pragma_c_decl, to describe the declaration of the local variable that points to the save struct. compiler/llds_out.m: Output mkframe instructions that specify a struct as invoking the new mkpragmaframe macro, and make sure that the struct is declared just before the procedure that uses it. Other minor changes to keep up with the changes to the representation of pragma C code in the LLDS, and to make the output look a bit nicer. compiler/pragma_c_gen.m: Add code to generate code for nondet pragma C codes. Revise the utility predicates and their data structures a bit to make this possible. compiler/code_gen.m: Add code for the necessary special handling of prologs and epilogs of procedures defined by nondet pragma C codes. The prologs need to be modified to include a programmer-defined C structure in the nondet stack frame and to communicate the location of this structure to the pragma C code, whereas the functionality of the epilog is taken care of by the pragma C code itself. compiler/make_hlds.m: When creating a proc_info for a procedure defined by a pragma C code, we used to insert unifications between the headvars and the vars of the pragma C code into the body goal. We now perform substitutions instead. This removes a factor that would complicate the generation of code for nondet pragma C codes. Pass a moduleinfo down the procedures that warn about singletons (and other basic scope errors). When checking whether to warn about an argument of a pragma C code not being mentioned in the C code fragment, we need to know whether the argument is input or output, since input variables should appear in some code fragments in a nondet pragma C code and must not appear in others. The mode_is_{in,out}put checks need the moduleinfo. (We do not need to check for any variables being mentioned where they shouldn't be. The C compiler will fail in the presence of any errors of that type, and since those variables could be referred to via macros whose definitions we do not see, we couldn't implement a reliable test anyway.) compiler/opt_util.m: Recognize that some sorts of pragma_c codes cannot affect the data structures that control backtracking. This allows peepholing to do a better job on code sequences produced for nondet pragma C codes. Recognize that the C code strings inside some pragma_c codes refer to other labels in the procedure. This prevents labelopt from incorrectly optimizing away these labels. compiler/dupelim.m: If a label is referred to from within a C code string, then do not attempt to optimize it away. compiler/det_analysis.m: Remove a now incorrect part of an error message. compiler/*.m: Minor changes to conform to changes to the HLDS and LLDS data structures.	1998-01-13 10:14:23 +00:00
Zoltan Somogyi	bb4442ddc1	Update copyright dates for 1998. ... Estimated hours taken: 0.5 compiler/*.m: Update copyright dates for 1998.	1998-01-13 10:06:08 +00:00
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	04b720630b	Update the copyright messages so that (a) they contain the correct years ... and (b) they say "Copyright (C) ... _The_ University of Melbourne".	1997-07-27 15:09:59 +00:00
Simon Taylor	27d156bbb5	Implemented a :- use_module directive. This is the same as ... Estimated hours taken: 14 Implemented a :- use_module directive. This is the same as :- import_module, except all uses of the imported items must be explicitly module qualified. :- use_module is implemented by ensuring that unqualified versions of items only get added to the HLDS symbol tables if they were imported using import_module. Indirectly imported items (from `.int2' files) and items declared in `.opt' files are treated as if they were imported with use_module, since all uses of them should be module qualified. compiler/module_qual.m Keep two sets of type, mode and inst ids, those which can be used without qualifiers and those which can't. Renamed some predicates which no longer have unique names since '__' became a synonym for ':'. Made mq_info_set_module_used check whether the current item is in the interface, rather than relying on its caller to do the check. Removed init_mq_info_module, since make_hlds.m now uses the mq_info built during the module qualification pass. compiler/prog_data.m Added a pseudo-declaration `used', same as `imported' except uses of the following items must be module qualified. Added a type need_qualifier to describe whether uses of an item need to be module qualified. compiler/make_hlds.m Keep with the import_status whether current item was imported using a :- use_module directive. Use the mq_info structure passed in instead of building a new one. Ensure unqualified versions of constructors only get added to the cons_table if they can be used without qualification. compiler/hlds_module.m Added an extra argument to predicate_table_insert of type need_qualifier. Only add predicates to the name and name-arity indices if they can be used without qualifiers. Changed the structure of the module-name-arity index, so that lookups can be made without an arity, such as when type-checking module qualified higher-order predicate constants. This does not change the interface to the module_name_arity index. Factored out some common code in predicate_table_insert which applies to both predicates and functions. compiler/hlds_pred.m Removed the opt_decl import_status. It isn't needed any more since all uses of items declared in .opt files must now be module qualified. Added some documentation about when the clauses_info is valid. compiler/intermod.m Ensure that predicate and function calls in the `.opt' file are module qualified. Use use_module instead of import_module in `.opt' files. compiler/modules.m Handle use_module directives. Report a warning if both use_module and import_module declarations exist for the same module. compiler/mercury_compile.m Collect inter-module optimization information before module qualification, since it can't cause conflicts any more. This means that the mq_info structure built in module_qual.m can be reused in make_hlds.m, instead of building a new one. compiler/prog_out.m Add a predicate prog_out__write_module_list, which was moved here from module_qual.m. compiler/typecheck.m Removed code to check that predicates declared in `.opt' files were being used appropriately, since this is now handled by use_module. compiler/*.m Added missing imports, mostly for prog_data and term. NEWS compiler/notes/todo.html doc/reference_manual.texi Document `:- use_module'. tests/valid/intermod_lambda_test.m tests/valid/intermod_lambda_test2.m tests/invalid/errors.m tests/invalid/errors2.m Test cases.	1997-06-29 23:11:42 +00:00
Tyson Dowd	cbcb23d17b	Enable --warn-interface-imports by default. ... Estimated hours taken: 3 Enable --warn-interface-imports by default. This was turned off while list and term were defined in mercury_builtin.m, since it caused many warnings. Fix all the unused interface imports that have been added since then. compiler/options.m: Enable --warn-interface-imports by default. compiler/module_qual.m: Fix formatting inconsistencies with module names in warning messages. (".m" was not appended to module names if there was only one module). compiler/*.m: library/*.m: tests/invalid/type_loop.m: tests/warnings/*.m: Remove usused interface imports, or move them into implementation (mostly bool, list and std_util).	1997-05-21 02:16:53 +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
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
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
Zoltan Somogyi	bc97676d98	Change the definition of is_builtin to use less space. ... Estimated hours taken: 2 hlds_goal: Change the definition of is_builtin to use less space. bytecode_gen, code_aux, code_gen, code_util, dependency_graph, follow_code, higher_order, inlining, live_vars, make_hlds, modecheck_unify, modes, polymorphism, stratify, unused_args: Fixes to accommodate the change to is_builtin.	1996-12-24 02:42:21 +00:00
Zoltan Somogyi	5544174d7c	An overhaul of the code saving and restoring heap pointers and tickets, ... Estimated hours taken: 3 An overhaul of the code saving and restoring heap pointers and tickets, and some other changes that affect the interface of code_info. code_info: The predicates that handle save heap pointers and tickets now return the slot these things are stored in; the predicates that restore and/or discard these values must give them back. This should avoid the problem we used to have with the same slot being used to store both a heap pointer and a ticket. Rename some predicates to better reflect their purpose. Accept pre_ and post_goal_update preds and the type lookup preds from code_aux, since this is where they belong. code_aux: Move pre_ and post_goal_update preds and the type lookup preds to code_info, since that is where they belong. call_gen: Fix the bug that broke nondet tailcalls for the case when the tailcall is a higher order call. code_gen: Use the new way of saving and restoring heap pointers. We now save tickets across negations; the absence of code to do this was a bug. disj_gen: Use the new way of saving and restoring heap pointers and tickets. Avoid restoring anything in the first disjunct. In pruned disjunctions, avoid saving the heap pointer more than once. (This does mean that we may restore it in some cases were we didn't used to, but such cases can be expected to be quite rare.) ite_gen: Use the new way of saving and restoring heap pointers and tickets. dense_switch, lookup_switch, middle_rec, unify_gen: Rename some called predicates as required by the changes to the other modules.	1996-12-22 06:37:44 +00:00
Zoltan Somogyi	21a6cafa40	Restructure into several submodules to give the module logical ... Estimated hours taken: 3 code_info: Restructure into several submodules to give the module logical structure. Make very slight alterations in the interface. call_gen, code_gen: Use the new interface of code_info. code_aux: Add comments. code_util: Fix a bug caught by Fergus' review. disj_gen, ite_gen, liveness: Fix some comments.	1996-12-20 08:11:00 +00:00
Zoltan Somogyi	3243dbe238	The only significant change in this checkin is that liveness.m now ... Estimated hours taken: 0.5 The only significant change in this checkin is that liveness.m now tries to compute the best resume_locs for negations (it already did for if-then-elses and disjunctions; leaving out negations was an oversight in my earlier checkin). The other changes are only syntactic: I have removed the cont-lives and nondet-lives field from goal_info, since they are not used anymore. I have replaced the nondet-lives field in code_info, which is not used anymore, with a follow-vars field, which is not used yet (but will be). Some of the "read" access predicates in hlds_goal did not have "get" in their name; I added them.	1996-12-18 11:09:52 +00:00
Zoltan Somogyi	08a5f48e2c	Take the code generator a big step closer to notes/ALLOCATION. ... Estimated hours taken: _____ Take the code generator a big step closer to notes/ALLOCATION. The new code generator emits code that is smaller and faster than the code we used to emit. Nondet liveness is no longer used; nondet live sets are always empty. In code that was being modified anyway, remove its handling. Other uses will be removed later (this keeps this change from being far too big; as it is it is merely too big). Similarly for cont-lives. In several places, clarify the code that gathers several code pieces together. call_gen: Unset the failure continuation and flush the resume vars to their stack slots before nondet calls. Move the code that decides whether a nondet call can be a tailcall to code_info. code_aux: Remove the code to handle resume points, since these are now handled in the specific constructs that need them. Replace it with a sanity check. code_exprn: Add a predicate to place multiple vars. code_gen: Remove the predicate code_gen__generate_forced_goal, since it packaged together some operations that should be executed at different times. Don't unset the failure continuation after every nondet goal; this is now done in the constructs that need it. Modify the handling of negation to use resume point info according to notes/ALLOCATION. Remove the predicate code_gen__ensure_vars_are_saved which was use to save all lives variables to the stack before nondet disjunctions and if-then-elses; we don't do that anymore. code_info: Significantly simplify and document the handling of failure continuations, and make the types involved abstract types. Factor out common code in the handling of det and semi commits. Keep track of "zombies", variables that are dead wrt forward execution but whose values we need because they may be needed at a resume point we can reach. Remove several now unneeded predicates, and introduce new predicates to help other modules. code_util: Add a couple of predicates to check whether ia goal cannot fail before flushing all variables to the stack, and whether a goal cannot flush any variables to the stack. These are used in liveness to decide which entry labels will be needed at resume points. disj_gen: Unify the handling of det and semi disjunctions. Model the code handling of nondet disjunctions on the code handling pruned disjunctions. It is possible that the handling of nondet and pruned disjunctions can also be unified; the new code should make this significantly easier. Make the code conform to notes/ALLOCATION. This means saving only the variables mentioned in the resume_point field, not flushing all live variables to the stack at the start of a nondet disjunction, handling zombies, and using the new method of flushing variables at the ends of branched structures. ite_gen: Unify the handling of det and semi if-then-elses. Model the code handling of nondet if-then-elses on the code handling det/semi if-then-elses. It is possible that the handling of nondet and pruned if-then-elses can also be unified; the new code should make this significantly easier. Make the code conform to notes/ALLOCATION. This means saving only the variables mentioned in the resume_point field, not flushing all live variables to the stack at the start of a nondet if-then-else, handling zombies, and using the new method of flushing variables at the ends of branched structures. Apply the new rules about liveness in if-then-elses, which say that the else part is parallel not to the then part but to the conjunction of the condition and the then part. dense_switch, lookup_switch, string_switch, switch_gen, tag_switch, middle_rec: Use the new method of flushing variables at the ends of branched structures. Don't call remake_with_store map; switch_gen will do so. Fix an old bug in lookup_switch. The code in switch_gen which looked for the special case of a two-way switch used to use a heuristic to decide which one was recursive and which one was a base case. We now check the codes of the cases. hlds_goal: Adjust the structure of the resume_point field to make it easier to use. Add a more convenient access predicate. hlds_out: Don't print the nondet liveness and cont live fields, since they are not used anymore. Comment out the printing of the context field, which is rarely useful. Modify the printing of the resume_point field to conform to its new definition. live_vars: Use the resume_point field, not the nondetlives field, to decide which variables may be needed on backward execution. Remove some code copied from liveness.m. liveness: Put the several pieces of information we thread through the traversal predicates into a single tuple. Don't put variables which are local to one branch of a branched structure into the post-birth sets of other branches. Apply the new rules about liveness in if-then-elses, which say that the else part is parallel not to the then part but to the conjunction of the condition and the then part. Variables that are needed in the else part but not in the condition or the then part now die in at the start of the condition (they will be protected by the resume point on the condition). We now treat pruned and non-pruned disjunctions the same way wrt deadness; the old way was too conservative (it had to be). We still mishandle branches which produce some variables but can't succeed. mercury_compile: Liveness now prints its own progress message with -V; support this. store_alloc: When figuring out what variables need to be saved across calls, make sure that we put in interference arcs between those variables and those that are required by enclosing resume points. Don't compute cont-lives, since they are not used anymore. livemap: Fix the starting comment.	1996-12-18 08:56:10 +00:00
Zoltan Somogyi	b72a942944	Start using resume_point information to save variables to their ... Estimated hours taken: 3 code_aux, code_info: Start using resume_point information to save variables to their stack slots when they become forward dead. code_gen, middle_rec: Handle the code fragments that can now result from pre and post goal updates. live_vars: Make sure that variables that can be put into stack slots at resumption points get stack slots allocated to them. liveness: Fix a bug in the computation of resume_point sets. llds_common: Fix some comments.	1996-11-25 10:07:59 +00:00
Zoltan Somogyi	613f8c06d4	Replace the two delta_liveness fields of the goal_info with four ... Estimated hours taken: 1.5 goal_util: Replace the two delta_liveness fields of the goal_info with four separate fields, {pre,post}{births,deaths}, since they were being used separate most of the time in any case. The new arrangement will require less storage. other files: Use the interface predicates for getting at these sets separately. There are no algorithmic changes in this checkin.	1996-11-22 01:56:32 +00:00
Zoltan Somogyi	92bd26cdc8	The first step towards the implementation of the new ALLOCATION strategy: ... Estimated hours taken: 0.75 The first step towards the implementation of the new ALLOCATION strategy: renamed call_info to stack_slots. There are no algorithmic changes in this checkin.	1996-11-21 09:25:34 +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
Fergus Henderson	5fe0f4f82c	A bunch of changes required to fix problems in code generation for ... Estimated hours taken: 24 A bunch of changes required to fix problems in code generation for model_det and model_semi disjunctions. simplify.m: Don't convert all model_det and model_semi disjunctions into if-then-elses, because that doesn't work if the disjuncts have output variables, which can happen (e.g. with cc_nondet disjunctions) disj_gen.m: Fix a bug in the code generation for semidet disjunctions: don't forget to jump to the end of the disjunction after each disjunct! liveness.m, live_vars.m, store_alloc.m, disj_gen.m: Treat backtracking in model_det and model_semi disjunctions as shallow backtracking rather than deep backtracking. This means that rather than pushing all live variables onto the stack at the start of a model_det/semi disjunction, and using the nondet_lives to keep track of them, we instead treat these disjunctions a bit more like an if-then-else and use the ordinary liveness/deadness to keep track of them. code_aux.m: Change code_aux__pre_goal_update so that it only applies the post-deaths if the goal is atomic. Applying the *post*-deaths to the set of live variables in the *pre*-goal update only makes sense for atomic goals. (I think previously we only ever generated post-deaths for atomic goals, but now we generate them also for goals inside model_det or model_semi disjunctions.) code_gen.pp, middle_rec.m: Pass an is-atomic flag to code_aux__pre_goal_update. hlds_goal.m: Add some comments. goal_util.m: Fix bugs in goal_util__name_apart_goalinfo. It wasn't applying the substitution to all the appropriate fields. code_exprn.m: Improve the error message for one of the internal errors. hlds_out.m: Print the stack slot allocations in the HLDS dump again.	1996-10-29 20:10:17 +00:00
Simon Taylor	0d4a24ce0f	Some fixes Fergus suggested for my previous sets of changes. ... Estimated hours taken: 3 Some fixes Fergus suggested for my previous sets of changes. Give error messages for circular equivalence types. compiler/equiv_type.m Detect and report circular equivalence types. Previously the unification preds for circular equivalence types looped. compiler/typecheck.m Fixed printing of constants in write_functor_name - foo instead of foo/0 compiler/code_aux.m Undid my previous change to code_aux__contains_only_builtins, which made the code less general than it could be. compiler/inlining.m Changed inlining__simple_goal to disregard complicated_unify. compiler/polymorphism.m Make sure bound insts are not module qualified.	1996-10-11 04:56:19 +00:00
Simon Taylor	5d3fc10571	- Inter-module optimization. ... Estimated hours taken: 50 - Inter-module optimization. Allows inlining and higher-order specialization across module boundaries. Gives ~10% speed-up on the compiler compiling to C. - The code to handle explicit type qualification. The test to recognise a type qualification is semidet_fail'ed until we work out which operator to use. - Improved data structures in module_qual.m. Also, module qualification of the modes of lambda expressions is now done in make_hlds.m, since it is more convenient now that type qualifications are module qualified there also. * Type qualification and module qualifiers on higher-order predicate constants and function calls still need to be implemented before this will work on all programs. * To create a version of a program using this optimization method, add --intermodule-optimization to MCFLAGS, mmake change_clean, mmake depend, then make as normal. * mmake change_clean removes the executable, the .dep file and all .cs and .os. compiler/intermod.m Handle input and output of .opt files. compiler/modules.m Added some new dependencies in the .d files for the .c and .opt files if inter-module optimization is being used. Also added .opt and .optdate to the list of things for mmake realclean to remove. Added a target, change_clean, which removes only those files necessary to force a rebuild using --intermodule-optimization. These are <module>, <module>.dep and all the .c, .o and .s files. compiler/options.m Added options: --make-optimization-interface - make the .opt file. --intermodule-optimization - puts extra dependencies into .d files and turns on input of .opt files. compiler/make_hlds.m Changes to give items from .opt files the correct import_status. Also, when matching pragma_c_code clauses to the declared modes of the predicates, expand and match on the initial and final insts of the argument modes, not the modes themselves, since items in .opt files have the modes expanded. Module qualify the modes of lambda expressions in unravel_unification rather than during mode analysis. Parse explicit type qualifications, and add these to the vartypes. At the moment this is disabled. compiler/typecheck.m Get the head type params from the tvarset, not from the arg types, so that tvars in type qualifications are included. Added checks to prevent matching of predicates, functions and constructors which should not be visible to a clause. compiler/module_qual.m Module qualify explicit type qualifications. More efficient data structures. compiler/mercury_to_mercury.m Export some predicates. Make sure C code strings are properly quoted in the .opt files. compiler/hlds_out.m Output function calls correctly. Alter hlds_out__write_goal to write out type qualifications on all functors if writing a .opt file. compiler/hlds_pred.m Added a new import_status opt_imported for clauses and declarations read from a .opt file. Pred and func declarations read from a .opt file get an `opt_decl' import_status so that the compiler doesn't expect clauses for them and local preds can't use them. Also added import_status abstract_imported and abstract_exported to describe types which have only an abstract definition imported or exported. Added a field to clauses_info to store the map(var, type) from explicit type qualifications. Renamed pred_info_set_status/3 to pred_info_set_import_status/3 to be consistent with pred_info_import_status/2. compiler/hlds_data.m Added an import_status field to the hlds__mode_defn and hlds__inst_defn so that intermod.m knows what has already been exported. compiler/equiv_type.m Pass out the equiv_map and export a predicate used to expand type qualifications. compiler/dead_proc_elim.m Remove non-optimized versions of opt_imported preds. All optimizations must give the optimized version an import_status of local. compiler/code_util.m Changed code_util__make_local_entry_label so that `localcall's are used for recursive calls in exported predicates. compiler/code_aux.m Changed code_aux__contains_only_builtins_2 so that it doesn't check for complicated unifies, since any time this is called, complicated unifies have either not been created (when called when writing the .opt files) or have been converted to calls (when called during inlining). compiler/higher_order.m Make sure that the specialized versions get unique names. compiler/mercury_compile.pp Add calls to intermod.m predicates. compiler/bytecode_gen.m Bracketed some '->'/2 insts so that they can be parsed by SICStus. compiler/peephole.m Replace computed_gotos where all the targets are the same with an unconditional goto. compiler/notes/COMPILER_DESIGN Documented intermod.m. library/list.m Added list__all_same/1, which is true if all elements of a list are identical. Also added list__last/2, which returns the final element of a list, failing on the empty list. library/io.m Change the format specifier for io__write_float so that the decimal point is always output. Without this, the result may not be a valid Mercury floating point constant. library/varset.m Add predicate varset__create_name_var_map/2 to create a mapping from variable name to variable id given a varset. This is used in processing type qualifications. scripts/Mmake.rules scripts/Mmake.vars.in Add suffixes, rules and options for .opt and .optdate. scripts/mercury_update_interface.in Work-around for a problem with parallel gmake. mc --make-interface was being run twice in a row on the same module. The first call mercury_update_interface moves module.int.tmp to module.int, then the second can't find module.int.tmp. The work-around is to ignore the exit status of the mv. Some cleaning up: compiler/*.m Fixed some out of date comments about the handling of complicated_unify. Also commented some dead code to do with generation of code for complicated_unify. compiler/modes.m compiler/mode_info.m Moved code to module qualify modes of lambda expressions into make_hlds. Moved predicates resolve_pred_overloading and find_matching_pred_id into typecheck, renaming with a typecheck__ prefix, so that these can be called from intermod.m. compiler/undef_modes.m compiler/undef_types.m Removed - their functionality is now in module_qual.m, except for checking for looping equivalence types. compiler/no_builtin.m compiler/nit_builtin.m Removed - they were made useless (if they weren't already) by the removal of the --builtin-module option. compiler/notes/AUTHORS Updated student email addresses.	1996-09-11 08:56:25 +00:00
Zoltan Somogyi	a15c032df7	Flesh out the code already here for traversing module_infos, ... Estimated hours taken: 4 passes_aux: Flesh out the code already here for traversing module_infos, making it suitable to handle all the passes of the back end. mercury_compile: Use the traversal code in passes_aux to invoke the back end passes over each procvedure in turn. Print a one-line message for each predicate if -v is given (this fixes a long-standing bug). excess.m, follow_code.m, follow_vars.m, live_vars.m, lveness.m, store_alloc.m: Remove the code to traverse module_infos, since it is now unnecessary. export.m: Remove an unused argument from export__produce_header_file_2. others: Move imports from interfaces to implementations, or in some cases remove them altogether.	1996-08-03 12:06:26 +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
Zoltan Somogyi	cac7d6a246	Fix allocation to work properly for --args compact. ... Estimated hours taken: 30+ arg_info: Fix allocation to work properly for --args compact. bytecode*: Handle complex deconstruction unifications. Not really tested because I can't find a test case. bytecode_gen, call_gen, code_util: Use the new method to handle builtin predicates/functions. We now handle reverse mode arithmetic and unary plus/minus as builtins. code_gen, code_init, follow_vars, hlds_pred: Put back the initial follow_vars field of the proc_info, since this may allow the code generator to emit better code at the starts of of predicates. inlining: Don't inline recursive predicates. goals_util: Add a predicate to find out if a goal calls a particular predicate. Used in inlining to find out if a predicate is recursive. unused_args: Remove code that used to set the mode of unused args to free->free. Since this changes the arg from top_in to top_unused *without* code in other modules being aware of the change, this screws up --args compact. llds, llds_out, garbage_out: Prepare for the move to the new type_info structure by adding a new "module" type for defining structures holding type_infos. Not currently generated or output. llds, opt_debug, opt_util, vn_type, vn_cost, vn_temploc: Change the argument of temp to be a reg, not an int, allowing floating point temporaries. vn_type: Add information about the number of floating point registers and temporaries to the parameter structure (these are currently unused). llds, dupelim, frameopt, livemap, middle_rec, value_number, vn_filter, vn_verify: Add an extra field to blocks giving the number of float temporaries. options: Add parameters to configure the number of floating point registers and temporaries. mercury_compile: Add an extra excess assign phase at the start of the middle pass. This should reduce the size of the code manipulated by the other phases, and gives more accurate size information to inlining. (The excess assign phase before code generation is I think still needed since optimizations can introduce such assignments.) value_number: Optimize code sequences before and after assignments to curfr separately, since such assignments change the meaning of framevars. This fixes the bug that caused singleton variable warnings to contain garbage. vn_block, vn_flush, vn_order, vn_util: Add special handling of assignments to curfr. This is probably unnecessary after my change to value_number, and will be removed again shortly :-( vn_flush: Improve the code generated by value numbering (1) by computing values into the place that needs them in some special circumstances, and (2) by fixing a bug that did not consider special registers to be as fast as r1 etc. vn_util: Improve the code generated by value numbering by removing duplicates from the list of uses of a value before trying to find out if there is more than one use. simplify: Avoid overzealous optimization of main --> { ..., error(...) }. handle_options: Fix an error message. code_aux: Break an excessive long line.	1996-05-29 10:56:45 +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	9e31ef9baa	Split llds into two parts. llds.m defines the data types, while llds_out.m ... Estimated hours taken: 1.5 Split llds into two parts. llds.m defines the data types, while llds_out.m has the predicates for printing the code. Removed the call_closure instruction. Instead, we use calls to the system-defined addresses do_call_{det,semidet,nondet}_closure. This is how call_closure was implemented already. The advantage of the new implementation is that it allows jump optimization of what used to be call_closures, without new code in jumpopt.	1996-04-24 08:59:06 +00:00
Zoltan Somogyi	d344165793	Add a new option, --branch-delay-slot, intended for use by mc on ... Estimated hours taken: 3 options: Add a new option, --branch-delay-slot, intended for use by mc on the basis of the configuattion script. It says whether the machine architecture has delays slots on branches. The setting of option should affect whether we set --optimize-delay-slots at -O2, but this doesn't work yet. hlds_goal: Add an extra field to hold follow_vars infromation to disjunctions, switches and if-then-elses. I intend to use this information to generate better code. *.m: Changes to accommodate the extra field.	1996-04-20 08:37:36 +00:00
Zoltan Somogyi	2833bfffb7	Divided the old hlds.m into four files: ... Estimated hours taken: 10 hlds, hlds_module, hlds_pred, hlds_goal, hlds_data: Divided the old hlds.m into four files: hlds_module.m defines the data structures that deal with issues that are wider than a single predicate. These data structures are the module_info structure, dependency_info, the predicate table and the shape table. hlds_pred.m defined pred_info and proc_info, pred_id and proc_id. hlds_goal.m defines hlds__goal, hlds__goal_{expr,info}, and the other parts of goal structures. hlsd_data.m defines the HLDS types that deal with issues related to data and its representation: function symbols, types, insts, modes. It also defines the types related to determinism. hlds.m is now an empty module. I have not removed it from CVS because we may need the name hlds.m again, and CVS does not like the reuse of a name once removed. other modules: Import the necessary part of hlds. det_analysis: Define a type that was up to now improperly defined in hlds.m. prog_io: Move the definition of type determinism to hlds_data. This decision may need to be revisited when prog_io is broken up. dnf, lambda: Simplify the task of defining predicates. llds: Fix some comments. mercury_compile: If the option -d all is given, dump all HLDS stages. shape, unused_args: Fix formatting.	1996-04-02 12:12:24 +00:00
Zoltan Somogyi	c70dbe9e2b	When we are processing the flushing of create expressions, make sure ... Estimated hours taken: 2 code_exprn: When we are processing the flushing of create expressions, make sure the Lval we are creating into isn't a field reference. This avoids deep field of field of field of ... nesting. It does introduce references to high register numbers, but this is a lesser evil, and Tom and I plan to fix this anyway. arg_info, globals, options: Change --args old to --args simple. options: Make some help messages more specific. code_aux, code_exprn, code_info, det_report, make_hlds, mercury_to_goedel, prog_io, typecheck: Changes to accommodate the move from varset__lookup_name to varset__search_name.	1996-03-12 03:39:13 +00:00
Fergus Henderson	6d7f4b9b30	Undo dylan's changes in the names of some library entities, ... Estimated hours taken: 1.5 Undo dylan's changes in the names of some library entities, by applying the following sed script s/term_atom/term__atom/g s/term_string/term__string/g s/term_integer/term__integer/g s/term_float/term__float/g s/term_context/term__context/g s/term_functor/term__functor/g s/term_variable/term__variable/g s/_term__/_term_/g s/std_util__bool_/bool__/g to all the `.m' and `.pp' files in the compiler and library directories. The reason for undoing these changes was to minimize incompatibilities with 0.4 (and besides, the changes were not a really good idea in the first place). I also moved `bool' to a separate module. The main reason for that change is to ensure that the `__' prefix is only used when it genuinely represents a module qualifier. (That's what dylan's changes were trying to acheive, but `term__' does genuinely represent a module qualifier.) compiler/*.m: Apply sed script above; where appropriate, add `bool' to the list of imported modules.	1996-02-03 17:30:14 +00:00
Thomas Conway	cdfe750146	Add and fix a few comments to do with the last change. ... Estimated hours taken: 0.1 Add and fix a few comments to do with the last change. compiler/*.m: change a few comments.	1996-01-04 03:54:16 +00:00
Thomas Conway	64e07ae112	There was a problem where variables that die during forward ... Estimated hours taken: 5 There was a problem where variables that die during forward execution, and then become live again on backtracking were not being handled correctly. There was some half-working code to deal with the problem. It has now been fixed, and there are some new test cases for the regression tests. compiler/.cvsignore: added *.ql since they become very irritating after a while... compiler/inlining.m: added a couple of comments make a bit of the code more concise. compiler/*.m: changes to handle nondet-liveness correctly.	1996-01-04 01:56:10 +00:00
Dylan Shuttleworth	3ab8d92226	Change names with badly placed double underscores (ie where the part of ... Estimated hours taken: _2___ Change names with badly placed double underscores (ie where the part of a name before a double underscore is not the same as the module name.) Reflect changes in the library interface. compiler/*: Use the newer, more correct form of the term and bool names. Predicates "bool__" are now "std_util__bool" and labels of the term ADT are now "term_" instead of "term__". compiler/vn*.m: change all names "vn__*" to a correct module prefix. All the names remain qualified. compiler/hlds.m: s/\<is_builtin__/hlds__is_builtin_/g s/\<dependency_info__/hlds__dependency_info_/g compiler/unify_proc.m: s/\<unify_proc_info__/unify_proc__info_/g compiler/transform.m: s/\<reschedule__conj/transform__reschedule_conj/g	1995-12-29 03:45:20 +00:00
Zoltan Somogyi	0696cb664b	Added some comments. ... Estimated hours taken: 0.1 compiler/code_aux.m: Added some comments.	1995-11-13 10:04:11 +00:00
Zoltan Somogyi	3224e94532	A new pass to remove unnecessary assignment unifications. ... excess: A new pass to remove unnecessary assignment unifications. mercury_compile: Call the new excess assignment module. options: Add a new option, excess_assign, to control the new optimization. Add another, num-real-regs, to specify how many of r1, r2 etc are actually real registers. The default is now set to 5 for kryten; later it should be supplied by the mc script, with a value determined at configuration time. tag_switch: Use num-real-regs to figure out whether it is likely to be worthwhile to eliminate the common subexpression of taking the primary tag of a variable. Also fix an old performance bug: the test for when a jump table is worthwhile was reversed. value_number, vn_block: Do value numbering on extended basic blocks, not basic blocks. vn_debug: Modify an information message. labelopt: Clean up an export an internal predicate for value numbering. Replace bintree_set with set. middle_rec: Prepare for the generalization of middle recursion optimization to include predicates with an if-then-else structure. cse_detection: Fix a bug: when hoisting a common desconstruction X = f(Yi), create new variables for the Yi. This avoids problems with any of the Yis appearing in other branches of the code. goal_util: Add a new predicate for use by cse_detection. common: Fix a bug: recompute instmap deltas, since they may be affected by the optimization of common structures. code_info: Make an error message more explicit. det_analysis: Restrict import list to the needed modules. *.m: Import assoc_list.	1995-10-27 09:39:28 +00:00
David Jeffery	07b9ac5c4a	We now allow a declaration of the form: ... :- pragma(inline, predicate/arity). This declaration means that the corresponding predicate will be inlined. hlds.m: Add a field to the pred_info indicating whether or not to inline the pred automatically. make_hlds.m: Turn on the inline flag in the pred_info if there was a pragma(inline, ...) declaration. prog_io.m: Parse the new declaration. mercury_to_mercury.m: Spit out the new dec. inlining.m: Inline the predicate if the inlining field is set in the pred_info. polymorphism.m: code_aux.m: Add an extra paramater to calls to pred_info_init.	1995-10-23 04:51:50 +00:00
Zoltan Somogyi	5011d92212	Optionally generate while (1) loops instead of short backward branches. ... llds: Optionally generate while (1) loops instead of short backward branches. This is faster in the absence of fast jumps. options: Add a new option, --no-emit-c-loops. middle_rec: We now check if the LLDS code after the recursive call is empty. If yes, we don't generate the downward loop. code_aux: Minor cleanup associated with previous change. frameopt: Instead of blindly assuming that any code before an if_val will be able to fill the delay slot, we check whether it computes a value that is used in the condition. We now also allow a slightly wider range of user instructions to fill delay slots. opt_util: Some new preds to support the new funcionality in frameopt. tag_switch: Compute the tag of the switched-on value into a register at the start, instead of computing it in each if_val.	1995-09-15 11:26:38 +00:00
Zoltan Somogyi	bebe96be34	Look inside blocks introduced by value numbering when looking ... frameopt: Look inside blocks introduced by value numbering when looking restorations of succip. value_number, opt_util: If we are using conservative garbage collection, disable value numbering for blocks that allocate more than one cell on the heap. This allows value numbering of most blocks to work in the absence of -DALL_INTERIOR_POINTERS. all other source files: Clean up "blank" lines that nevertheless contain space or tab characters.	1995-08-27 11:10:20 +00:00
Fergus Henderson	b87de68334	Implement unique modes. We do not handle local aliasing yet, so this ... ------------------------------------------------------- Implement unique modes. We do not handle local aliasing yet, so this is still not very useful, except for io__state. Destructive update is not yet implemented. Also note that this really only implements "mostly unique" variables that may be non-unique on backtracking - we don't check that you don't backtrack over I/O, for example. prog_io.m, mode_util.m, modes.m, inst_match.m: Major changes to Handle unique modes. mercury_to_mercury.m, polymorphism.m, prog_out.m, undef_modes.m: Use `ground(Uniqueness)' rather than just `ground'. compiler/*.m: Fix compile errors now that unique modes are enforced: add a few calls to copy/2, and comment out lots of unique mode declarations that caused problems. typecheck.m, mode_info.m: Hack around the use of unique modes, which doesn't work because we don't allow local aliasing yet: make the insts `uniq_type_info' and `uniq_mode_info' not unique at all, and add a call to copy/2 when extracting the io_state from type_info or mode_info. ------------------------------------------------------- Plus a couple of unrelated changes: hlds.m: Change the modes for the special predicates from `ground -> ground' to `in', so that any error messages that show those modes come out looking nicer. Add a new shared_inst_table for shared versions of user-defined insts. mercury_to_goedel.m: Use string__is_alnum_or_underscore.	1995-08-02 07:53:53 +00:00