58 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	8a28e40c9b	Add the predicates sorry, unexpected and expect to library/error.m. ... Estimated hours taken: 2 Branches: main Add the predicates sorry, unexpected and expect to library/error.m. compiler/compiler_util.m: library/error.m: Move the predicates sorry, unexpected and expect from compiler_util to error. Put the predicates in error.m into the same order as their declarations. compiler/*.m: Change imports as needed. compiler/lp.m: compiler/lp_rational.m: Change imports as needed, and some minor cleanups. deep_profiler/*.m: Switch to using the new library predicates, instead of calling error directly. Some other minor cleanups. NEWS: Mention the new predicates in the standard library.	2010-12-15 06:30:36 +00:00
Zoltan Somogyi	02f9532cc1	Optimize calls to formatting functions and predicates such as ... Estimated hours taken: 16 Branches: main Optimize calls to formatting functions and predicates such as Str = string.format("%s_%d", [s(Prefix), i(Num)]) into V1 = string.int_to_string(Num), V2 = "_" ++ V1, Str = Prefix ++ V2 essentially interpreting the format string at compile time rather than runtime. At the moment, the optimization applies to calls to string.format/3, io.format/3 and io.format/4, and only in the case where the format specifiers are just "%c", "%d", or "%s", with no widths, precisions etc, though that could be changed relatively easily, though at the cost of coupling the compiler more tightly to the implementation of library/string.m. (We don't handle %f, because float_to_string(F) yields a different string than string.format("%f", [f(F)]). The former yields e.g. "1.23", while the latter yields "1.23000".) compiler/format_call.m: Change the code that looks for malformed calls to formatting predicates to also look for well-formed, optimizable calls, and to transform them as shown above. mdbcomp/prim_data.m: List the standard library's string module here, since the compiler now needs to know what its name is (it generates calls to its predicates). compiler/options.m: doc/user_guide.texi: Add a new option, --optimize-format-calls, that calls for this optimization. Make it enabled by default. compiler/simplify.m: Since the transformation in format_call.m will typically introduce nested conjunctions, we now do it before the rest of the simplifications. We also invoke the fixups needed by the output of format_call.m if it actually optimized any code. Delete the code that used to record whether the procedure has any format calls, since it now comes too late. Decide once, when setting up for processing a procedure, whether we want to invoke format_call.m if appropriate, instead of doing it later. This allows us to reduce the size of the simplications data structure we pass around. Protect the predicates that format_call.m can generate calls to from being deleted by dead_pred_elim before the simplification pass. compiler/det_analysis.m: Since simplify.m itself cannot record early enough whether a given procedure body contains calls to formatting predicates, do it here. compiler/det_info.m: Add a new field to the det_info that records whether we have seen a call to a formatting predicate. Add another field to the det_info that records the list of errors we have found so far, so that we can stop passing it around separately. compiler/hlds_pred.m: Add a marker that allows det_analysis.m to record its conclusions. compiler/hlds_goal.m: Add utility predicate. compiler/goal_util.m: Make the predicates for creating new plain calls (and, for the sake of uniformity, calls to foreign code) take instmap_deltas, such as those created by the new utility functions in instmap.m. This allows these predicates' caller to avoid creating unnecessary intermediate data structures. compiler/instmap.m: Make an existing predicate into a function to allow it to be used more flexibly. Move some utility functions for creating instmap_deltas here from table_gen.m, so that they can be used by other modules. compiler/liveness.m: Delete an unused predicate. compiler/accumulator.m: compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/builtin_lib_types.m: compiler/common.m: compiler/complexity.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/granularity.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/pd_util.m: compiler/prog_type.m: compiler/purity.m: compiler/rbmm.region_transformation.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/table_gen.m: compiler/try_expand.m: compiler/typecheck.m: compiler/unify_proc.m: Conform to the changes above. compiler/stm_expand.m: Conform to the changes above. Also, build pairs by using "-" directly as the function symbol, instead of this module's old practice of doing it the slow way by calling the "pair" function. tests/general/string_format_lib.m: Cleanup the style of the code of this test case. tests/hard_coded/opt_format.{m,exp}: New test case to exercise the behavior of format_call.m's transformation. tests/hard_coded/Mmakefile: tests/hard_coded/Mercury.options: Enable the new test case.	2009-09-03 23:57:51 +00:00
Zoltan Somogyi	cc42c8fac5	Switch to using error_util to generate error message during the process of ... Estimated hours taken: 40 Branches: main Switch to using error_util to generate error message during the process of converting terms to prog_items. In many predicates, we used to return error messages as a string/term pair, with the string being the error message and a term, which both provided the context and was printed after the message. We now return error indications as lists of error_specs. These include a printout of the relevant term only if this helps users understand the nature or the location of the error. To make the printouts easier to understand we print variable names in them using the applicable varsets. (The old version of the compiler used to print each error term long after it lost track of the right varset, and thus used a dummy varset that yielded error messages referring to _1, _2 etc instead of the variable names used by the programmer.) Sometimes the callers of some parse predicates prepended other strings indicating the context of the error in front of the error string. This diff changes things so that now the caller instead passes a list of format components describing the context to the predicates that construct the error_specs. In some places, simplify the code, e.g. by factoring out common code, and by inlining some auxiliary predicates (we used to need these auxiliary predicates for indexing when we executed the compiler using Prolog, but those days are long past). Mark with XXXs places where I think the error messages or their contexts could be improved, and places where the structure of the code could be improved. compiler/prog_io_util.m: Change the representation of the maybeN types to use error_spec lists. compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: compiler/prog_io_typeclass.m: compiler/prog_io_util.m: Change the way we generate error messages along the lines described at the top. In several cases, this required adding extra arguments (varsets, context descriptions) to predicates for use in error messages. Some of these predicates were also used in contexts where the caller was interested only in success, and would ignore any error messages. In these cases, add a version of the predicate that does not require the extra arguments, and which is semidet (to allow the caller to avoid a test for ok). compiler/error_util.m: Add a mechanism for changing the case of the next format_component, to allow an error message to be appended to a list of format_components providing the context that generates good-looking output whether or not that context is empty. Replace some bools with purpose-specific types. Make sort_error_specs internal to the module, since outside modules should never need to use it. Use cords instead of reversed lists to simplify some parts of the internal implementation. compiler/mercury_to_mercury.m: Provide a mechanism to print out terms only if they aren't too big, for use in our error messages. compiler/prog_item.m: Delete the message_list type, and note a future improvement. compiler/prog_out.m: Delete the predicates for printing message_lists. compiler/intermod.m: compiler/modules.m: Change the way we print out error messages along the lines described at the top. compiler/add_clause.m: compiler/field_access.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/superhomogeneous.m: Conform to the changes above by modifying how we generate error messages. compiler/add_class.m: compiler/add_pragma.m: compiler/check_typeclass.m: compiler/common.m: compiler/make.module_dep_file.m: compiler/make_hlds_error.m: compiler/make_hlds_passes.m: compiler/mercury_compile.m: compiler/mode_errors.m: compiler/modes.m: compiler/options_file.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/purity.m: compiler/trans_opt.m: compiler/typecheck.m: Trivial updates to conform to the changes above. compiler/prog_data.m: Add some field names and access functions for use in the modules above. library/list.m: Add list.contains, which is list.member with the arguments reversed to make it possibly to partially apply it. tests/invalid/bad_finalise_decl.err_exp: tests/invalid/bad_initialise_decl.err_exp: tests/invalid/bad_mutable.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/conflicting_fs.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/invalid/errors.err_exp: tests/invalid/func_errors.err_exp: tests/invalid/fundeps_unbound_in_ctor.err_exp: tests/invalid/fundeps_vars.err_exp: tests/invalid/impl_def_literal_syntax.err_exp: tests/invalid/inst_list_dup.err_exp: tests/invalid/invalid_typeclass.err_exp: tests/invalid/kind.err_exp: tests/invalid/null_char.err_exp: tests/invalid/pragma_source_file.err_exp: tests/invalid/predmode.err_exp: tests/invalid/reserve_tag.err_exp: tests/invalid/some.err_exp: tests/invalid/specified.err_exp: tests/invalid/trace_goal_env.err_exp: tests/invalid/type_vars.err_exp: tests/invalid/typeclass_test_1.err_exp: tests/invalid/typeclass_test_11.err_exp: tests/invalid/typeclass_test_2.err_exp: tests/invalid/unbound_type_vars.err_exp: tests/invalid/unicode1.err_exp: tests/invalid/unicode2.err_exp: tests/invalid/uu_type.err_exp: tests/invalid/vars_in_wrong_places.err_exp: tests/invalid/with_type.err_exp: tests/invalid/purity/purity_nonsense2.err_exp: Update the expected error messages.	2008-07-16 03:31:03 +00:00
Zoltan Somogyi	cb722aa049	This diff adds an option --common-struct-preds, which allows us to restrict the ... Estimated hours taken: 1 Branches: main This diff adds an option --common-struct-preds, which allows us to restrict the set of predicates that the common struct optimization is applied to. It helped me track down Mantis bug #56. Since common-struct optimization has had several bugs in the past and also helped expose bugs elsewhere, I think this option could be helpful in the future. Its cost is only a couple of option lookups per predicate. compiler/options.m: Add the option. Since the option is for implementors only, its documentation is deliberately commented out. compiler/simplify.m: Obey the option. compiler/common.m: Avoid some unnecessary memory allocations by making a predicate return goal_exprs and goal_infos separately when its main caller wants it that way. When replacing a construct with an assignment, preserve the context of the unification. Make some variable names more expressive.	2008-05-26 03:44:09 +00:00
Mark Brown	feab1f5e66	Fix a failure to compile analysis.m in grade asm_fast.gc.decldebug. ... Estimated hours taken: 20 Branches: main Fix a failure to compile analysis.m in grade asm_fast.gc.decldebug. The problem was that common.m would leave references to type-info variables that are assigned (i.e., introduced by common.m) rather than the type-infos that come from constructions, deconstructions or procedure calls. Later on, excess-assignment removal may leave these as dangling references. The fix is to always ensure that we refer to the original type-info, not the assigned one. compiler/common.m: When generating an assignment, first apply substitutions to the RttiVarMaps which eliminate the "To" variable in favor of the "From" variable. Then duplicate the information for the "To" variable. compiler/simplify.m: Export a procedure to perform the above steps on a simplify_info. compiler/hlds_rtti.m: Make use of the prog_var_renaming type. compiler/Mercury.options: Add a note that the workaround can be removed once the compiler is installed.	2008-03-26 01:38:47 +00:00
Zoltan Somogyi	b426ee51b6	Misc style cleanups. ... Estimated hours taken: 0.1 Branches: main compiler/common.m: Misc style cleanups.	2008-02-28 06:08:29 +00:00
Zoltan Somogyi	672f77c4ec	Add a new compiler option. --inform-ite-instead-of-switch. ... Estimated hours taken: 20 Branches: main Add a new compiler option. --inform-ite-instead-of-switch. If this is enabled, the compiler will generate informational messages about if-then-elses that it thinks should be converted to switches for the sake of program reliability. Act on the output generated by this option. compiler/simplify.m: Implement the new option. Fix an old bug that could cause us to generate warnings about code that was OK in one duplicated copy but not in another (where a switch arm's code is duplicated due to the case being selected for more than one cons_id). compiler/options.m: Add the new option. Add a way to test for the bug fix in simplify. doc/user_guide.texi: Document the new option. NEWS: Mention the new option. library/*.m: mdbcomp/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: Convert if-then-elses to switches at most of the sites suggested by the new option. At the remaining sites, switching to switches would have nontrivial downsides. This typically happens with the switched-on type has many functors, and we treat one or two specially (e.g. cons/2 in the cons_id type). Perform misc cleanups in the vicinity of the if-then-else to switch conversions. In a few cases, improve the error messages generated. compiler/accumulator.m: compiler/hlds_goal.m: (Rename and) move insts for particular kinds of goal from accumulator.m to hlds_goal.m, to allow them to be used in other modules. Using these insts allowed us to eliminate some if-then-elses entirely. compiler/exprn_aux.m: Instead of fixing some if-then-elses, delete the predicates containing them, since they aren't used, and (as pointed out by the new option) would need considerable other fixing if they were ever needed again. compiler/lp_rational.m: Add prefixes to the names of the function symbols on some types, since without those prefixes, it was hard to figure out what type the switch corresponding to an old if-then-else was switching on. tests/invalid/reserve_tag.err_exp: Expect a new, improved error message.	2007-11-23 07:36:01 +00:00
Zoltan Somogyi	168f531867	Add new fields to the goal_info structure for region based memory management. ... Estimated hours taken: 4 Branches: main Add new fields to the goal_info structure for region based memory management. The fields are currently unused, but (a) Quan will add the code to fill them in, and then (b) I will modify the code generator to use the filled in fields. compiler/hlds_goal.m: Make the change described above. Group all the procedures that access goal_info components together. Some of the getters were predicates while some were functions, so this diff changes them all to be functions. (The setters remain predicates.) compiler/*.m: Trivial changes to conform to the change in hlds_goal.m. In simplify.m, break up a huge (800+ line) predicate into smaller pieces.	2007-08-07 07:10:09 +00:00
Zoltan Somogyi	ba93a52fe7	This diff changes a few types from being defined as equivalent to a pair ... Estimated hours taken: 10 Branches: main This diff changes a few types from being defined as equivalent to a pair to being discriminated union types with their own function symbol. This was motivated by an error message (one of many, but the one that broke the camel's back) about "-" being used in an ambiguous manner. It will reduce the number of such messages in the future, and will make compiler data structures easier to inspect in the debugger. The most important type changed by far is hlds_goal, whose function symbol is now "hlds_goal". Second and third in importance are llds.instruction (function symbol "llds_instr") and prog_item.m's item_and_context (function symbol "item_and_context"). There are some others as well. In several places, I rearranged predicates to factor the deconstruction of goals into hlds_goal_expr and hlds_goal_into out of each clause into a single point. In many places, I changed variable names that used "Goal" to refer to just hlds_goal_exprs to use "GoalExpr" instead. I also changed variable names that used "Item" to refer to item_and_contexts to use "ItemAndContext" instead. This should make reading such code less confusing. I renamed some function symbols and predicates to avoid ambiguities. I only made one algorithmic change (at least intentionally). In assertion.m, comparing two goals for equality now ignores goal_infos for all kinds of goals, whereas previously it ignored them for most kinds of goals, but for shorthand goals it was insisting on them being equal. This seemed to me to be a bug. Pete, can you confirm this?	2007-01-06 09:23:59 +00:00
Julien Fischer	4630fb9de7	Change the representation of some types used by mmc --make. ... Estimated hours taken: 1 Branches: main Change the representation of some types used by mmc --make. Minor formatting and style cleanups for mmc --make. There are no changes to any algorithms. compiler/make.m: Delete the compilation_task type; it is unused. Convert the target_file and linked_target_file types into du's with named fields. This is nicer in mdb then pairs. compiler/make.dependencies.m: compiler/make.module_dep_file.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/options_file.m: Conform to the above changes. Make a bunch of minor formatting and style changes. compiler/make.util.m: Add a predicate make_target_file_list required by the above. compiler/inst_graph.m: Replace DCGs with state variables. compiler/common.m: Fix some typos.	2006-11-23 04:03:43 +00:00
Zoltan Somogyi	411b45846a	Modify check_typeclass.m to gather up all error messages, and print them all ... Estimated hours taken: 12 Branches: main Modify check_typeclass.m to gather up all error messages, and print them all at once after sorting. Modify the determinism analysis pass to generate error_specs directly, instead of generating context_det_msgs and converting those to error_specs later. Separate the simplify pass's mechanism for generating error messages from the determinism pass. compiler/check_typeclass.m: Return all error messages instead of printing them when generated. Keep the error messages outside the instance_method_info structure, and give the fields of the structure names. compiler/det_analysis.m: Generate error specs directly. compiler/det_report.m: Delete the context_det_msg data type and the predicates that operated on it, since they are no longer needed. The code that used to convert a context_det_msg into an error_spec is now dispersed to the sites that generate the error report in the first place. These sites are mostly in det_analysis.m and simplify.m, with a few in other modules (e.g. common.m and format_call.m). Export some auxiliary functions that the these sites now need. compiler/simplify.m: Generate error_specs directly, instead of through context_det_msgs, and return them to the caller for printing. compiler/common.m: compiler/format_call.m: Conform to the change to det_report.m. compiler/unused_import.m: Return all error messages instead of printing them when generated. compiler/mercury_compile.m: Print the error message batches returned by the modified passes. Use the version of globals in module_infos in preference to the one in the I/O state, since we would like to phase out the latter. Don't explicitly sort error_specs, since write_error_specs will do it anyway. compiler/error_util.m: Separate the error messages of the simplify pass from those of determinism analysis. Provide a standard way to format type constructor names. Require the calls to provide the globals when printing error_specs. This is to allow callers to provide the globals from a module_info, instead of the one in the I/O state. compiler/passes_aux.m: Provide support for passes that have lists of error_specs threaded through them, as simplify now does. Rename some predicates to avoid some ambiguities. compiler/deforest.m: compiler/pd_util.m: compiler/unify_proc.m: compiler/unused_args.m: Conform to the change to the interface of determinism analysis. compiler/inlining.m: Do not thread the I/O state through this module. compiler/make.module_dep_file.m: compiler/make_hlds_passes.m: compiler/ml_tailcall.m: compiler/mode_errors.m: compiler/modes.m: compiler/modules.m: compiler/stratify.m: compiler/table_gen.m: Conform to the change in error_util. compiler/prog_data.m: Rename some function symbols to avoid some ambiguities. compiler/add_class.m: compiler/base_typeclass_info.m: compiler/hlds_out.m: compiler/intermod.m: compiler/module_qual.m: compiler/prog_io_typeclass.m: compiler/recompilation.check.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/type_class_info.m: Conform to the change in prog_data.m. tests/invalid/*err_exp: Update the expected output files to conform to the changes above. This mosly involves expecting sorted messages without duplicates.	2006-10-13 04:52:38 +00:00
Peter Ross	84ffc0924d	Fix --warn-unused-imports warnings in some of the modules. ... Estimated hours taken: 4 Branches: main library/*.m: compiler/*.m: Fix --warn-unused-imports warnings in some of the modules.	2006-09-27 06:17:09 +00:00
Zoltan Somogyi	00741b0162	This diff contains no algorithmic changes. ... Estimated hours taken: 6 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch more function symbols to reduce ambiguity. After this diff, the summary line from the mdb command "ambiguity -f" is Total: 351 names used 975 times, maximum 31, average: 2.78 browser/*.m: compiler/*.m: Rename function symbols to eliminate ambiguities. tests/debugger/declarative/dependency.exp: tests/debugger/declarative/dependency2.exp: Update the expected out where some internal function symbol names appear in the output of the debugger. (This output is meant for implementors only.)	2006-08-22 05:04:29 +00:00
Zoltan Somogyi	2b2f3d3cbe	This diff contains no algorithmic changes. ... Estimated hours taken: 8 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch of function symbols to reduce ambiguity. Basically I went through prog_data.m, prog_item.m, hlds_data.m, hlds_goal.m and hlds_pred.m looking for type definitions containing function symbol names that were either language "keywords" (e.g. "terminates", which is an annotation on foreign_procs), used with slightly different meanings in several types (e.g. "sym"), or both (e.g. "call"). When I found such type definitions, I changed the names of the function symbols, usually by adding a prefix or suffix indicating the type to all function symbols of the type. For example, the old function symbol "foreign_proc" in type "pragma_type" is now named "pragma_foreign_proc", and the names of all other function symbols in that type also start with "pragma_". All of this should yield simpler compiler error messages when we make mistakes, and will make it more likely that looking up a function symbol using a tags file will take you to the actual definition of the relevant instance of that function symbol. However, the most important benefit is the increase in the readability of unfamiliar code; the reader won't have to emulate the compiler's type ambiguity resolution algorithm (which in many cases used to require distinguishing between f/14 and f/15 by counting the arguments, e.g. for "pred_or_func"). compiler/prog_data.m: compiler/prog_item.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_pred.m: Rename function symbols as explained above. compiler/*.m: Conform to the function symbol renames. In some cases, rename other function symbols as well. Minor style fixes, e.g. replace if-then-elses with switches, or simple det predicates with functions.	2006-08-20 08:21:36 +00:00
Julien Fischer	aeeedd2c13	Standardize formatting of comments at the beginning of modules. ... compiler/*.m: Standardize formatting of comments at the beginning of modules.	2006-07-31 08:32:11 +00:00
Zoltan Somogyi	fb9f78b784	Fix a bug reported by Peter Hawkins. The bug was that an predicate without ... Estimated hours taken: 3 Branches: main Fix a bug reported by Peter Hawkins. The bug was that an predicate without a declared determinism but whose inferred determinism was invalid for its tabling declaration led to a compiler abort. compiler/det_analysis.m: Fix the main cause of the bug, which was that the check for the compatibility of evaluation method and determinism was performed only for predicates with declared determinisms, not those without. Centralize the printing of determinism error messages, and sort the messages first. compiler/hlds_pred.m: Fix the other half of the bug: the predicate that checked the compatibility of evaluation method and determinism was too liberal with minimal model predicates, letting through determinisms that the tabling transformation cannot (yet) support. compiler/det_report.m: Fix the formatting of the error message. compiler/prog_data.m: Rename the function symbols of the type "determinism", to avoid conflicts with language keywords. compiler/*.m: Conform to the change to prog_data.m. tests/invalid/hawkins_mm_fail_reset.{m,err_exp}: New test case for the bug being fixed. tests/invalid/Mmakefile: Enable the new test case. tests/invalid/loopcheck.err_exp: Expect the new format of the improved error message.	2006-07-12 02:51:22 +00:00
Julien Fischer	459847a064	Move the univ, maybe, pair and unit types from std_util into their own ... Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.	2006-03-29 08:09:58 +00:00
Zoltan Somogyi	25b8b1abc3	Fix several performance bugs that showed up when the compiler was invoked on ... Estimated hours taken: 20 Branches: main Fix several performance bugs that showed up when the compiler was invoked on Douglas Auclair's training_cars example. Also fix some minor problems that made it harder to find the information needed to localize those problems. training_cars.m is hard to compile quickly because it is big in two dimensions: it has lots of clauses, and each clause has big terms. My laptop still tries to swap itself to death on the full version of training_cars.m (it has only 512 Mb), but the compiler now works fine on a version containing about 20% of its clauses, whereas previously it couldn't compile it at all. In most cases, the changes convert N^2 algorithms to NlogN algorithms. They probably have higher constant factors and may yield small slowdowns for small N, but this is probably not noticeable. Avoiding bad worst case behavior is more important. compiler/superhomogeneous.m: Record the number of goals inserted in each goal being converted to superhomogeneous form. If this exceeds a threshold, wrap a from_ground_term scope around it. Put the predicates into a more cohesive sequence. compiler/field_access.m: Work with the code in superhomogeneous to record the number of inserted goals. Reorder the arguments of some performances to be consistent with the predicates in superhomogeneous.m. compiler/modes.m: Use the from_ground_term scope to reverse the list of inserted unifications if necessary. It is much more efficient to do this here than to let it happen by sequences of delays and wakeups. That would have quadratic complexity; this is linear. This is what I originally introduced from_ground_term scopes for. Then, the overhead was too high, because I added one scope per function symbol. This version should be fine, since there is at most one scope added per argument of an atom (clause head or call). compiler/modes.m: compiler/unique_modes.m: When we are processing goals inside a from_ground_term scope, record this fact. compiler/mode_info.m: Make it possible to record this fact. compiler/modecheck_unify.m: When we are inside a from_ground_term scope, don't try to update the insts of vars on the right hand sides of construction unifications. Since these variables came from expansion to superhomogeneous form, those variables won't occur in any following code, so updating their state is useless, and the algorithm we used to do so is linear in the size of the inst. Since the size of an inst of a variable that results from superhomogeneous expansion is itself on average proportional to the size of the original term, this change turns a quadratic algorithm into a linear one. compiler/inst_match.m: Use balanced trees instead of ordered lists to represents sets of expansions, since these sets can be large. Note an opportunity for further improvement. compiler/inst_util.m: Note another opportunity for further improvement. compiler/instmap.m: Rename several predicates to avoid ambiguities. compiler/cse_detection.m: We used to print statistics for the processing of each procedure without saying which procedure it is for; fix this. compiler/switch_detection.m: Don't print progress messages for predicates with no procedures, since they would be misleading. compiler/higher_order.m: Change an algorithm that was quadratic in the number of arms for merging the information from the different arms of disjunctions and switches to an NlogN algorithm. Change the algorithm for merging the info from two branches that quadratic in the number of variables per arm to an NlogN algorithm. Changed some type equivalences to notag types to aid robustness. compiler/quantification.m: Rename several predicates to avoid ambiguities. The sets of variables in different arms of disjunctions and switches tend to have relatively small intersections. Yet the algorithms we used to compute the set of variables free in the disjunction or switch included the variables from the already processed arms in the sets being accumulated when processing later arms, leading to the quadratic behavior. This diff changes the algorithm to process each arm independently, and then use a more balanced algorithm to summarize the result. Specialize the predicates that compute sets of free vars in various HLDS fragments to work either with ordinary_nonlocals or code_gen_nonlocals without making the same decision repeatedly. Move some code out of large predicates into predicates of their own. compiler/Mercury.options: Specify the compiler option that can exploit this specialization to make the code run faster. compiler/simplify.m: Use a more efficient data structure for recording the parameters of an invocation of simplification. Change some predicate names and function symbol names to avoid ambiguity. compiler/common.m: compiler/deforest.m: compiler/deforest.m: compiler/make_hlds_warn.m: compiler/mercury_compile.m: compiler/pd_util.m: compiler/stack_opt.m: compiler/term_constr_build.m: Conform to the changes in simplify.m and/or instmap.m. compiler/mercury_compile.m: Fix a bug in progress messages for polymorphism.m. compiler/equiv_type_hlds.m: Most of the time, substitutions inside insts have no effect, because very few insts include any reference to a types. Instead of the old approach of building new insts and then throwing them away if they are the same as the old ones, don't build new insts at all if the old inst contains no types. compiler/common.m: Change some predicate names to make them clearer. compiler/hlds_clauses.m: Record the number of clauses so far, to allow a more informative progress message to be printed. compiler/add_clause.m: Print this more informative progress message. Conform to the changes in superhomogeneous.m. compiler/code_gen.m: Use the context of the predicate's first clause (which will be the context of the first clause head) as the context of the predicate's interface events. Unlike the context of the body goal, this won't be affected by program transformations such as wrapping a from_ground_term scope around some goals. It is better for users anyway, since the old policy lead to contexts in the middle of procedure bodies if the top level goal was a disjunction, switch or if-then-else. tests/debugger/*.exp: Update the expected outputs to conform to the change to code_gen.m.	2006-03-29 00:57:46 +00:00
Zoltan Somogyi	12deb40264	Rename all the get access predicates in these modules that don't ... Estimated hours taken: 0.1 Branches: main compiler/hlds_clauses.m: compiler/hlds_pred.m: Rename all the get access predicates in these modules that don't already have put "get" in their name. (The names of the set access predicates were OK already.) compiler/*.m: Conform to the above. All this was done by this sed script: s/clauses_info_varset/clauses_info_get_varset/ s/clauses_info_explicit_vartypes/clauses_info_get_explicit_vartypes/ s/clauses_info_vartypes/clauses_info_get_vartypes/ s/clauses_info_headvars/clauses_info_get_headvars/ s/clauses_info_clauses_rep/clauses_info_get_clauses_rep/ s/clauses_info_rtti_varmaps/clauses_info_get_rtti_varmaps/ s/pred_info_import_status/pred_info_get_import_status/ s/pred_info_arg_types/pred_info_get_arg_types/ s/pred_info_typevarset/pred_info_get_typevarset/ s/pred_info_tvar_kinds/pred_info_get_tvar_kinds/ s/pred_info_procedures/pred_info_get_procedures/ s/proc_info_context/proc_info_get_context/ s/proc_info_varset/proc_info_get_varset/ s/proc_info_vartypes/proc_info_get_vartypes/ s/proc_info_headvars/proc_info_get_headvars/ s/proc_info_inst_varset/proc_info_get_inst_varset/ s/proc_info_maybe_declared_argmodes/proc_info_get_maybe_declared_argmodes/ s/proc_info_argmodes/proc_info_get_argmodes/ s/proc_info_maybe_arglives/proc_info_get_maybe_arglives/ s/proc_info_declared_determinism/proc_info_get_declared_determinism/ s/proc_info_inferred_determinism/proc_info_get_inferred_determinism/ s/proc_info_goal/proc_info_get_goal/ s/proc_info_can_process/proc_info_get_can_process/ s/proc_info_rtti_varmaps/proc_info_get_rtti_varmaps/ s/proc_info_eval_method/proc_info_get_eval_method/ s/proc_info_is_address_taken/proc_info_get_is_address_taken/ s/proc_info_stack_slots/proc_info_get_stack_slots/ s/proc_info_liveness_info/proc_info_get_liveness_info/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/	2006-03-27 09:36:34 +00:00
Zoltan Somogyi	3ebda6545f	Move the stuff currently in hlds_pred.m that deals with clauses into a new ... Estimated hours taken: 1.5 Branches: main Move the stuff currently in hlds_pred.m that deals with clauses into a new module, hlds_clauses.m. Move the stuff currently in hlds_pred.m that deals with RTTI into a new module, hlds_rtti.m. Move the stuff currently in hlds_module.m that deals with predicate tables into a new module, pred_table.m. These changes make hlds_pred.m and hlds_module.m much more cohesive, but there are no changes in algorithms. compiler/hlds_clauses.m: compiler/hlds_rtti.m: compiler/pred_table.m: New modules as described above. In some cases, fix mixleading or ambiguous predicate names in the process, and convert a few predicates to functions. compiler/hlds_pred.m: compiler/hlds_module.m: Delete the stuff moved to other modules. compiler/*.m: In modules that need the functionality moved a new module, import the new module. It is rare for all the new modules to be needed, and many modules don't need any of the new modules at all. (For example, of the 200+ modules that import hlds_module.m, only about 40 need pred_table.m.) Conform to the few minor changes to e.g. predicate names. compiler/notes/compiler_design.html: Document the new modules.	2006-03-24 03:04:20 +00:00
Zoltan Somogyi	be5b71861b	Convert almost all the compiler modules to use . instead of __ as ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all the compiler modules to use . instead of __ as the module qualifier. In some cases, change the names of predicates and types to make them meaningful without the module qualifier. In particular, most of the types that used to be referred to with an "mlds__" prefix have been changed to have a "mlds_" prefix instead of changing the prefix to "mlds.". There are no algorithmic changes.	2006-03-17 01:40:46 +00:00
Zoltan Somogyi	5b8f96f61d	Prepare for an extension of promise_equivalent_solutions that will allow us ... Estimated hours taken: 5 Branches: main Prepare for an extension of promise_equivalent_solutions that will allow us to better handle values of user-defined types. The problem is that currently, the deconstruction of a value of such a type can be followed only by code that cannot fail, otherwise the cc_multi deconstruction is not in the required single-solution context. If the following code is naturally semidet, this can be worked around by turning it into det code returning a maybe and testing the maybe outside the promise_equivalent_solutions, but this is inefficient, and in any case it does not generalize to nondet code without even more horrendous inefficiency and inconvenience. (You have to create a nondet closure and call it outside the promise_equivalent_solutions.) The solution I came up with is something is to have a construct that contains - a list of deconstructions on types with user-defined equality, - a goal, and - the list of outputs of that goal. The idea is that this would be transformed into a conjunction of the first and second items, and wrapped inside a special kind of conj that provides a scope for the implicit promise, which is that the set of solutions of the goal in the second item doesn't depend on what concrete terms the deconstructions in the first item return out of the set of concrete terms they *could* return. The deconstructions in the first item would be marked to tell determinism analysis to effectively ignore the fact that they involve user-defined equality. The actual addition of that construct is left for a future change, after we agree on the syntax. compiler/hlds_goal.m: Generalize the existing promise_equivalent_solutions scope to a promise_solutions scope with a flag that says whether in the source code it was originally the existing "promise_equivalent_solutions" construct or the new construct (which doesn't exist yet, but is indicated by the symbol "same_solutions" for now). Replace the conj and par_conj hlds_goal_exprs with a single goal expression: conj with an additional argument which is either plain_conj or parallel_conj. This was part of an earlier design in which a third kind of disjunction took the role now assigned to the new kind of promise_solutions scope, but turned out to be a good idea anyway, since in many places the compiler does treat the two kinds of conjunctions the same. This part of the change is responsible for the fact that this change results in a net *reduction* of about 40 lines. Move the most frequently used kinds of goal expressions to the front of the type declaration to allow the compiler to make better decisions about tag allocation. Add the goal marker we will add to the deconstructions in the first item. Replace the true_goal and fail_goal predicates with functions to make them easier to use, and rename their variants that take a context argument to avoid unnecessary ambiguity. compiler/*.m: Conform to the change in hlds_goal.m. Misc changes to make code more robust, e.g. replacing semidet predicates on goal expressions with functions returning bool. Misc cleanups, e.g. removal of unnecessary module qualifications that made lines too long, renaming predicates whose names include "disj" if they are also used to process parallel conjunctions (since in both parallel conjunctions and in disjunctions the goals are independent), and turning semidet predicates that switch on goal expressions into bool functions (to make similar changes more rebust in the future).	2006-02-24 05:49:43 +00:00
Zoltan Somogyi	b819fbc0a6	Give the compiler the capability of detecting errors that manifest themselves ... Estimated hours taken: 16 Branches: main Give the compiler the capability of detecting errors that manifest themselves as mismatches between the format string and the list of values to be printed in calls to string.format and io.format. This capability is controlled through two new options: --warn-known-bad-format-calls --warn-unknown-format-calls The first (which will default to "on" once this change has bootstrapped) controls whether the compiler emits warnings for statically known mismatches. The second (which will default to "off") controls whether the compiler emits warnings in cases where either the format string or the structure of the list of values to be printed is not available statically to be checked. NEWS: Mention the new capability. compiler/options.m: Add the two new options. doc/user_guide.texi: Document the new options. compiler/format_call.m: New module to implement the new capability. compiler/notes/compiler_structure.html: Document the new module. compiler/check_hlds.m: Include the new module. compiler/simplify.m: Invoke the new module if the procedure being processed contains calls to string.format or io.format. Fix an old bug: we could generate warnings or even errors when simplifying predicate bodies imported from other modules via intermodule optimization. Don't export get/set predicates that do not need to be exported. compiler/det_report.m: Add new kinds of error specifications for the errors detected by the new module. Separate out the context of each error specification, in order to allow the error messages to be sorted by context; this makes the output much easier to read. compiler/common.m: compiler/det_analysis.m: compiler/simplify.m: Conform to the change to det_report.m. mdbcomp/prim_data.m: Add a utility function for forming the possibly qualified names of library modules (such as "io" and "string"). library/Mercury.options: compiler/Mercury.options: Add the lines that disable the new checks in the modules that need them disabled. The new lines are commented out until installed compilers all understand them, at which point in time we will add the requirement to understand the option to configure.in. compiler/fact_table.m: compiler/mlds_to_il.m: Fix three bugs reported by the new check that have apparently escaped detection all this time. library/rtti_implementation.m: Change some code to avoid a spurious warning from the new checks. library/string.m: Rename a predicate to avoid an unnecessary and confusing overloading of its name. Replace __ with . as module qualifier connective. compiler/handle_options.m: library/pprint.m: Misc cleanups. tests/invalid/string_format_bad.{m,err_exp}: tests/invalid/string_format_unknown.{m,err_exp}: New test cases to test the new warnings. tests/invalid/Mmakefile: tests/invalid/Mercury.options: Enable the new test cases. tests/general/string_format_test*.exp*: Update any expected abort messages to expect . instead of __ as module qualifier connective. tests/invalid/det_errors_cc.err_exp: tests/invalid/erroneous_throw_promise.err_exp: tests/warnings/simple_code.exp: Expect the same error messages in program context order.	2006-01-27 05:52:27 +00:00
Julien Fischer	45fdb6c451	Use expect/3 in place of require/2 throughout most of the ... Estimated hours taken: 4 Branches: main compiler/*.m: Use expect/3 in place of require/2 throughout most of the compiler. Use unexpected/2 (or sorry/2) in place of error/1 in more places. Fix more dodgy assertion error messages. s/map(prog_var, mer_type)/vartypes/ where the latter is meant.	2005-11-28 04:11:59 +00:00
Julien Fischer	5f589e98fb	Various cleanups for the modules in the compiler directory. ... Estimated hours taken: 4 Branches: main Various cleanups for the modules in the compiler directory. The are no changes to algorithms except the replacement of some if-then-elses that would naturally be switches with switches and the replacement of most of the calls to error/1. compiler/*.m: Convert calls to error/1 to calls to unexpected/2 or sorry/2 as appropriate throughout most or the compiler. Fix inaccurate assertion failure messages, e.g. identifying the assertion failure as taking place in the wrong module. Add :- end_module declarations. Fix formatting problems and bring the positioning of comments into line with our current coding standards. Fix some overlong lines. Convert some more modules to 4-space indentation. Fix some spots where previous conversions to 4-space indentation have stuffed the formatting of the code up. Fix a bunch of typos in comments. Use state variables in more places; use library predicates from the sv* modules where appropriate. Delete unnecessary and duplicate module imports. Misc. other small cleanups.	2005-11-17 15:57:34 +00:00
Zoltan Somogyi	f9fe8dcf61	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 8 Branches: main Improve the error messages generated for determinism errors involving committed choice contexts. Previously, we printed a message to the effect that e.g. a cc pred is called in context that requires all solutions, but we didn't say *why* the context requires all solutions. We now keep track of all the goals to the right that could fail, since it is these goals that may reject the first solution of a committed choice goal. The motivation for this diff was the fact that I found that locating the failing goal can be very difficult if the conjunction to the right is a couple of hundred lines long. This would have been a nontrivial problem, since (a) unifications involving values of user-defined types are committed choice goals, and (b) we can expect uses of user-defined types to increase. compiler/det_analysis.m: Keep track of goals to the right of the current goal that could fail, and include them in the error representation if required. compiler/det_report.m: Include the list of failing goals to the right in the representations of determinism errors involving committed committed choice goals. Convert the last part of this module that wasn't using error_util to use error_util. Make most parts of this module just construct error message specifications; print those specifications (using error_util) in only a few places. compiler/hlds_out.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: compiler/compiler_util.m: Error_util is still changing reasonably often, and yet it is included in lots of modules, most of which need only a few simple non-parse-tree-related predicates from it (e.g. unexpected). Move those predicates to a new module, compiler_util.m. This also eliminates some undesirable dependencies from libs to parse_tree. compiler/libs.m: Include compiler_util.m. compiler/notes/compiler_design.html: Document compiler_util.m, and fix the documentation of some other modules. compiler/*.m: Import compiler_util instead of or in addition to error_util. To make this easier, consistently use . instead of __ for module qualifying module names. tests/invalid/det_errors_cc.{m,err_exp}: Add this new test case to test the error messages for cc contexts. tests/invalid/det_errors_deet.{m,err_exp}: Add this new test case to test the error messages for unifications inside function symbols. tests/invalid/Mmakefile: Add the new test cases. tests/invalid/det_errors.err_exp: tests/invalid/magicbox.err_exp: Change the expected output to conform to the change in det_report.m, which is now more consistent.	2005-10-28 02:11:03 +00:00
Zoltan Somogyi	b2012c0c0e	Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' ... Estimated hours taken: 8 Branches: main compiler/*.m: Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' and 'mer_mode'. This is to avoid the need to parenthesize these type names in some contexts, and to prepare for the possibility of a parser that considers those words to be reserved words. Rename some other uses of those names (e.g. as item types in recompilation.m). Delete some redundant synonyms (prog_type, mercury_type) for mer_type. Change some type names (e.g. mlds__type) and predicate names (e.g. deforest__goal) to make them unique even without module qualification. Rename the function symbols (e.g. pure, &) that need to be renamed to avoid the need to parenthesize them. Make their replacement names more expressive. Convert some more modules to four space indentation. Avoid excessively long lines, such as those resulting from the automatic substitution of 'mer_type' for 'type'.	2005-10-24 04:14:34 +00:00
Zoltan Somogyi	df0d9036cf	Optimize calls that would be tail calls in Prolog but are followed by ... Estimated hours taken: 40 Branches: main Optimize calls that would be tail calls in Prolog but are followed by construction unifications in Mercury: last call modulo construction. For now, the optimization is available only for the LLDS backend. compiler/lco.m: Turn this module from a placeholder to a real implementation of the optimization. compiler/hlds_goal.m: Allow lco.m to attach to construction unifications a note that says that certain arguments, instead of being filled in by the unification, should have their addresses taken and stored in the corresponding variables. Group this note together with the note that asks for term size profiling to avoid an increase in the sizes of goals in the compiler in most cases. compiler/hlds_pred.m: Provide a predicate for setting the name of a predicate after its creation. This functionality is used by lco.m. Extend the pred_transformation part of the pred_origin type to allow it to express that a procedure was created by lco.m. List the new primitive store_at_ref as a no-typeinfo builtin. Fix some problems with indentation. compiler/layout_out.m: Handle the new pred_transformation. compiler/unify_gen.m: When processing construction unifications that have the new feaure turned on, perform the requested action. Fix some departures from coding style. Shorten lines by deleting unnecessary module qualifications. Add some auxiliary predicates to make the code easier to read. compiler/var_locn.m: Fix an earlier oversight: when materializing variables inside rvals and lvals, look inside memory references too. Previously, the omission didn't matter, since we didn't generate such references, but now we do. Fix some departures from coding style. compiler/llds_out.m: Fix some old XXXs in code handling memory references. We didn't use to generate such references, but now we do. Move some functionality here from code_aux.m. compiler/code_info.m: Provide some primitive operations needed by the new code in var_locn.m. Delete an unneeded predicate. compiler/options.m: Rename the existing option optimize_constructor_last_call as optimize_constructor_last_call_accumulator, since that optimization is done by accumulator.m. Make optimize_constructor_last_call be the option that calls for the new optimization. compiler/handle_options.m: Handle the implications of the new option. compiler/mercury_compile.m: Invoke the lco module by its new interface. librrary/private_builtin.m: Add a new primitive operation, store_at_ref, for use by the new optimization. Switch the module to four-space indentation. compiler/add_clause.m: Comment out the warning for clauses for builtin, since this is needed to bootstrap the addition of the new builtin. compiler/term_constr_initial.m: Handle the new builtin. compiler/accumulator.m: Conform to the change in options. compiler/builtin_ops.m: Provide a third template for builtins, for use by store_at_ref. Convert the file to four-space indentation. compiler/call_gen.m: Generate code following the new builtin template. compiler/rl_exprn.m: Minor changes to conform to the changes in builtin templates. compiler/quantification.m: Minor changes to conform to the changes in construct unifications. Don't make the "get" predicates operating on quantification_infos to return the "new" quantification_info: it is always the same as the old one. compiler/aditi_builtin_ops.m: compiler/common.m: compiler/deep_profiling.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/lambda.m: compiler/magic_util.m: compiler/ml_unify_gen.m: compiler/modecheck_unify.m: compiler/polymorphism.m: compiler/size_prof.m: Minor changes to conform to the changes in construct unifications. compiler/dependency_graph.m: Add a new predicate to recompute the dependency information, even if a previous (and possibly now inaccurate) version is present. Change the interface to make it clearer, by changing bools into types specific to the situation. Convert the file to four-space indentation. compiler/mode_constraints.m: Minor changes to conform to the changes in dependency_graph.m. compiler/code_aux.m: Delete this module. Half its functionality has been moved into llds_out.m, half to middle_rec.m (its only user). compiler/goal_form.m: Move the predicates in this module that are used only by middle_rec.m to middle_rec.m. Convert the file to four-space indentation. compiler/goal_util.m: compiler/det_util.m: Move update_instmap from det_util to goal_util, since it is usefulness extends beyond determinism analysis. Convert det_util.m to four-space indentation. compiler/middle_rec.m: Move here the code required only here from code_aux and goal_form. Update the moved code for the changes in construct unifications. The updates are specific to middle_rec.m: they wouldn't be of use to other modules. They basically say that any code that takes the addresses of fields cannot be handled by middle_rec.m. compiler/code_gen.m: compiler/det_analysis.m: compiler/live_vars.m: compiler/ll_backend.m: compiler/loop_inv.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/notes/compiler_design.html: Minor changes to conform to the deletion of code_aux.m and/or the movement of code from det_util to goal_util.m. compiler/opt_debug.m: Print info for vars in rvals. compiler/hlds_module.m: Convert a lambda to an explicit predicate to make some code easier to read. Switch the module to four-space indentation.	2005-09-13 04:56:20 +00:00
Mark Brown	3fc6b3f128	Change the representation of types in the compiler. ... Estimated hours taken: 30 Branches: main Change the representation of types in the compiler. We also add some support for handling kinds, which will be used later when we have a kind system. There are a number of places where kinds are not yet handled correctly -- we assume that all kinds will be `star'. Each of these locations is flagged with a comment that contains "XXX kind inference:". compiler/prog_data.m: Implement the new version of type (type). Change the definition of type_param to be a variable instead of a term, since all parameters must be variables anyway. Implement versions of varset.merge_* which work with tvarsets and produce renamings instead of substitutions. Renamings are more convenient than substitutions because we don't need to know the kinds of type variables in order to build the renaming, and in any case the substitutions shouldn't have anything other than variables in the range so renamings will be more efficient and safe. Define the type of kinds, and provide a couple of utility predicates to operate on them. compiler/prog_io.m: Parse type definition heads as a sym_name and list of type_params, rather than a functor. Handle this change in other predicates. Allow parse errors to be returned by get_with_type/3, and handle these errors. Remove parse_type/2. This predicate didn't do any processing, it just forwarded handling to convert_type/2. compiler/prog_io_typeclass.m: Change type_is_functor_and_vars to handle the new representation of types. In doing so, we retain the old behaviour that pure predicates pass this test, but no other pred or func types. This behaviour is arguably incorrect, but there is little point changing the behaviour at the moment. Instead we should remove these kind of restrictions entirely, but that should be done later. compiler/prog_io_util.m: Provide predicates to both parse and unparse types. We need to unparse types before printing them out, since we do a lot of special case handling when printing out terms and we don't want to duplicate this functionality for types. compiler/module_qual.m: Remove report_invalid_type. We now report ill-formed types during parsing. compiler/superhomogeneous.m: Handle errors from the parsing of type expressions. compiler/prog_out.m: Provide a predicate to convert builtin_types to their string names, and vice-versa. compiler/prog_type.m: Add a bunch of simple tests to use on types which may have kind annotations present. In such cases, types do not have a canonical representation so the simple handling of these tests is not what we want. (Note that these are only required in early phases. The kind annotations -- when they are implemented -- will be removed before type checking.) Consistently handle the application of renamings, substitutions and recursive substitutions to various data structures. compiler/mercury_to_mercury.m: Implement mercury_output_type, mercury_format_type and mercury_type_to_string. These convert the type to a term before formatting -- the reason for this is so that appropriate parentheses are used when formatting operators. This results in some slight changes to error messages, which are reflected in changes to the expected output files in the tests. Remove the old version of mercury_type_to_string. Change the argument ordering of mercury_format_var to be consistent with mercury_format_type. (Other predicates in this module should probably be changed in a similar way, since this argument ordering is more amenable to higher-order programming. But that can be left for another change.) compiler/type_util.m: Implement type unification. The behaviour is much the same as the previous behaviour, except that we now handle apply/N types properly, and we also allow for kind annotations. Implement an occurs check for types. Remove the example definition of replace_eqv_type. It isn't used and would no longer work anyway even if it would have worked before. Add a tvar_kind_map field to ctor_defn. The functions type_info_type and type_ctor_info_type now return types with `void' as their argument, rather than the type that the type_info or type_ctor_info was for. Remove type_util.real_vars/2, since it no longer does anything different from prog_type.vars/2. Remove the commented out implementation of type_to_ctor_and_args/3. Its implementation is in prog_type.m, and has changed significantly in any case. compiler/add_clause.m: Move parse_purity_annotation/3 to prog_io_util.m. compiler/check_typeclass.m: Remove apply_substitution_to_var_list/3, since we now have predicates in prog_type.m to handle such things. compiler/continuation_info.m: compiler/trace.m: Use prog_type.vars/2 instead of type_util.real_vars/2. The two predicates have the same meaning now since type_infos don't contain any type variables. compiler/hlds_data.m: Add tvar_kind_map fields to hlds_type_defn and hlds_class_defn. compiler/hlds_pred.m: Add a tvar_kind_map field to pred_info. compiler/polymorphism.m: Add a tvar_kind_map field to poly_info. Remove unify_corresponding_types, which is no longer used. compiler/hlds_out.m: Use mercury_output_type/5 instead of term_io__write_term/4 and mercury_output_term/5. compiler/post_typecheck.m: Build the void substitution directly rather than building intermediate lists. compiler/recompilation.version.m: Use term__list_subsumes instead of type_list_subsumes, which now operates only on types. This follows up on what was suggested in an XXX comment. compiler/typecheck_errors.m: Use unparse_type/2 to format error messages. compiler/typecheck_info.m: Don't export write_type_with_bindings/5. It is no longer used outside of this module. compiler/*.m: Conform to the above changes. library/rtti_implementation.m: Fix a syntax error that went undetected in our previous implementation, and amazingly enough was compiled correctly anyway. library/term.m: Move the versions of term__unify, term__unify_list and term__list_subsumes that were implemented specifically for types to here. The version of term_unify that takes a list of bound variables (i.e., variables that should not be bound any further) is used by the subsumption check, which in turn is used by recompilation.version.m. tests/invalid/kind.err_exp: tests/invalid/tc_err1.err_exp: tests/invalid/tc_err2.err_exp: tests/misc_tests/pretty_print_test.exp: Update the expected output of these tests to match what we now do.	2005-09-12 05:25:01 +00:00
Zoltan Somogyi	2f06c5b8fe	Don't just detect when successive unifications unify the same variable with ... Estimated hours taken: 6 Branches: main Don't just detect when successive unifications unify the same variable with incompatible function symbols: also issue a warning. compiler/ml_code_gen.m: compiler/stratify.m: compiler/table_gen.m: mdbcomp/trace_counts.m: Fix pieces of code that get the new warning. compiler/modecheck_unify.m: When detecting such unifications, add warnings for them, except if the initial inst of the current restricts the set of allowed bindings of the input arguments. If the initial inst of X is bound(f), then an otherwise correct unification Y = g may fail if Y has been computed from X. (We don't whether it has, so we have to be conservative.) There are examples of such code in the library, e.g. functor in deconstruct.m. Factor out some common code. compiler/mode_errors.m: Add the infrastructure needed for printing warnings, and the two forms of this warning in particular. compiler/mode_info.m: Extend the mode_info structure to make room for warnings, and for the initial inst of the procedure arguments. Switch to four-space indentation. compiler/inst_util.m: Add a predicate that tests whether an inst may restrict the set of possible cons_ids a variable may be bound to. Change the argument order of some predicates to allow them to be used in higher order code. We don't need to make the switched-on argument the first argument anymore. Switch to four-space indentation. compiler/hlds_goal.m: Change the argument order of some predicates to allow the use of state variables. compiler/higher_order.m: compiler/instmap.m: compiler/mode_constraints.m: compiler/mode_debug.m: compiler/mode_ordering.m: compiler/modecheck_call.m: compiler/trace.m: Conform to the changed argument orders described above. Switch to four-space indentation. compiler/common.m: compiler/inst_match.m: compiler/hlds_pred.m: compiler/lambda.m: compiler/magic.m: compiler/magic_util.m: compiler/modes.m: compiler/pd_util.m: compiler/post_typecheck.m: compiler/unique_modes.m: Conform to the changed argument orders described above. tests/invalid/occurs.err_exp: Expect the extra warning. tests/warnings/Mmakefile: Enable the unify_f_g test case I accidentally committed earlier. tests/warnings/unify_f_g.{m,err_exp}: Finalize that test case. tests/warnings/simple_code.err_exp: Expect the extra warning.	2005-08-27 09:42:10 +00:00
Mark Brown	37ba982839	Another step towards the removal of constraints and types from the arguments ... Estimated hours taken: 25 Branches: main Another step towards the removal of constraints and types from the arguments of typeclass_info/1 and type_info/1. This involves ensuring that the rtti_varmaps structure contains enough information for any code that previously needed to refer to these arguments. compiler/common.m: When generating assignments between variables that hold type infos or typeclass infos, calculate a type substitution representing the aliasing of any type variables that results. This aliasing can occur if the same existentially typed data structure is deconstructed twice. The resulting substitution is applied to the simplify_info. Update the rtti_varmaps if there is information stored for one of the variables in the assignment, but not the other. compiler/simplify.m: Provide a means to apply a type substitution to the fields in a simplify_info that may contain types. compiler/hlds_pred.m: Don't use an injection to model the typeclass_info_varmap. The previous forward mapping was never intended to be complete: it only covered constraints that could be reused by later goals when doing the polymorphism transformation. Some prog_vars which hold typeclass_infos cannot be reused since they may no longer be in scope, for example, prog_vars for typeclass_infos that were constructed in an earlier disjunct. Instead of an injection we just use two separate maps. The reverse map (from prog_vars to constraints) includes all known constraints. The forward map (from constraints to prog_vars) only covers constraints for which it is safe to reuse the prog_var. These two maps are kept consistent be the fact that the latter map is never updated directly; it only has entries added when a particular prog_var is flagged as reusable. Document the fact that when looking up a typeclass_info var, we only consider those prog_vars which have been flagged as reusable. Export a predicate to update already existing type_info_type information. This is used when introducing exists_cast goals. Export a predicate to duplicate the rtti_var_info from one variable to another. This is used when introducing new variables in saved_vars.m, and when updating the rtti_varmaps in common.m. Export a predicate to return all known type_info and typeclass_info vars. This is used by hlds_out to print out the table. When applying substitutions to the rtti_varmaps, add a sanity check to ensure that the various maps remain consistent. Don't provide an interface to transform constraints. Instead, provide an interface to transform types (which is also applied to the constraint arguments). This interface is required when fully expanding equivalence types, in which case all types need to be expanded, not just those appearing in constraints. compiler/clause_to_proc.m: When adding exists_cast goals, ensure that the rtti_varmaps structure is updated with the new information. This addresses an XXX comment that was left here from an earlier change. compiler/equiv_type_hlds.m: Fully expand equivalence types in all types in the rtti_varmaps, not just those types appearing in constraints. compiler/goal_util.m: compiler/lambda.m: When calculating extra nonlocal typeinfos or constraints on lambda expressions, only consider those constraints that are able to be reused. These are the only constraints that the goal in question could possibly have used. compiler/hlds_out.m: When printing out the typeclass_info_varmap, only consider the reusable constraints. These are the only ones that have entries in the typeclass_info_varmap. Print out the available variable info for any type_info or typeclass_info variables. compiler/polymorphism.m: Thread the entire poly_info through polymorphism__new_typeclass_info_var, since it now makes use of three fields within this structure. Ensure that the rtti_varmaps field is updated with the information about the new typeclass_info var. Flag all universal constraints from the head and existential constraints from the body as being reusable. The program variables for these typeclass_infos will always be in scope wherever the constraint could appear. Typeclass infos that have been constructed from proofs within the current procedure may not be still in scope, so they are not flagged as reusable. compiler/saved_vars.m: Make sure the rtti_varmaps is updated if we rename a variable that contains a type_info or typeclass_info.	2005-08-16 15:36:19 +00:00
Mark Brown	881033facb	Introduce a distinction between variables that are typed according to the ... Estimated hours taken: 15 Branches: main Introduce a distinction between variables that are typed according to the external view of a procedure, in which the types may contain an existentially quantified type variable, and variables that are typed according to the internal view of a procedure, in which existentially quantified type variables may be bound to a known type. The distinction is maintained by adding "exists_cast" goals which assign an internal variable to its corresponding external variable. Any output head variable which is existentially typed and for which the external view differs from the internal view is replaced by a new variable. An exists_cast goal is added to the end of the procedure which casts the old headvar to the new one. We also do the same for any type_infos and typeclass_infos that are output. Exists casts are implemented as a variant on unsafe_cast generic calls. We also add other variants to distinguish the different kinds of casts: - equiv_casts for when the types are the same modulo equivalence types; - unsafe_type_casts for when the types are different but the insts are compatible; and - unsafe_type_inst_casts for when the type and inst are changed by the cast. The purpose of this change is to make it possible to include both the internal and external views in the rtti_varmaps structure. compiler/polymorphism.m: Perform the transformation on proc_infos to include the exists_cast goals. This is done at the end of the polymorphism transformation, when we recompute the argument types for the newly transformed procedure. The clauses_infos are left untouched by this transformation, since after this stage they should no longer be used. compiler/hlds_goal.m: Modify the generic_call type to include the type of cast. compiler/hlds_pred.m: Modify the generic_call_id type to include the type of cast. compiler/goal_util.m: Add an argument to `generate_unsafe_cast' which specifies the type of cast to generate. compiler/higher_order.m: Use the predicate in goal_util to generate the cast, instead of doing it manually. compiler/prog_rep.m: All variants of the cast generic call are represented in the same way. This is to avoid to the need to change the format of static data in programs compiled with full declarative debugging. If we do need the distinction to be made here, then that can be done as a separate change. compiler/purity.m: Calls to private_builtin.unsafe_type_cast are translated into unsafe_type_cast generic calls. compiler/aditi_builtin_ops.m: Use unsafe_type_inst_cast when casting between aditi_bottom_up closures and their transformed versions. compiler/common.m: Use unsafe_type_cast when generating assignments for variables whose types do not match exactly. compiler/unify_proc.m: Use equiv_type_cast when generating casts in unification, comparison and initialisation clauses for equivalence types. Use unsafe_type_cast when casting enum types to integers for the purposes of comparison or unification. compiler/*.m: Handle the new generic_calls.	2005-08-12 05:14:17 +00:00
Zoltan Somogyi	523d86f4a3	Fix a problem reported by Michael Day. When a piece of code had several updates ... Estimated hours taken: 4 Branches: main Fix a problem reported by Michael Day. When a piece of code had several updates to the fields of a cell in a row, we were constructing all the intermediate versions of the cell. With this change, we now construct only the final one. compiler/simplify.m: The cause of the problem was simplify's use of the cannot_flush predicate from goal_form.m. Each field update consists of a pair of deconstruct/construct unifications inside a removable barrier scope, but cannot_flush assumed that any goal not on its small approved list may cause a stack flush. Simplify therefore told common.m to throw away its list of known cells when emerging from the scope. The fix is to replace the use of cannot_flush with a new predicate that is explicitly written for the needs of simplify, which is not too conservative. The concern about increasing the set of output variables of an existentially quantified scope is now addressed only in simplify__goal_2 when processing scope goals, not in two places (redundantly) as before. Simplify the logic of simplify_info_maybe_clear_structs. Simplify the mechanism for initializing simplify_infos. Use more descriptive variables names in simplify__pred. Switch to four-space indentation to reduce the number of bad line breaks. compiler/pd_util.m: Conform to the new mechanism for initializing simplify_infos. compiler/goal_form.m: Delete the cannot_flush predicate, since it now has no users. compiler/common.m: Clean up some code. Break up an excessively large predicate, factor out some common code, and make comments conform to our conventions.	2005-05-18 05:49:12 +00:00
Zoltan Somogyi	c08ca7fbc8	Import only one module per line in the modules of the compiler ... Estimated hours taken: 3 Branches: main compiler/*.m: Import only one module per line in the modules of the compiler where my previous diff did not already do so. Misc other cleanups. Where relevant, use the new mechanism in tree.m. compiler/tree.m: Fix a performance problem I noticed while update :- import_module items. Instead of supplying a function to convert lists of trees to a tree, make the tree data structure able to hold a list of subtrees directly. This reduces the number of times where we have to convert list of trees to trees that are sticks just to stay within the old definition of what a tree is.	2005-03-24 02:00:43 +00:00
Peter Wang	d8c47d42ea	This change adds a tupling transformation to the compiler. ... Estimated hours taken: two months Branches: main This change adds a tupling transformation to the compiler. It takes the HLDS and tries to find opportunities for procedures to pass some arguments to each as a tuple rather than as individual arguments. compiler/interval.m: compiler/stack_opt.m: compiler/backend_libs.m: Moved the predicate from stack_opt.m that builds up information about intervals into a new module backend_libs__interval, and generalised it for use by the tupling transformation. The predicate was called `optimize_live_sets_in_goal' and was renamed to `build_interval_info_in_goal'. Also moved the predicate `record_decisions_in_goal'. compiler/transform_hlds.m: compiler/tupling.m: New module `tranform_hlds__tupling'. compiler/mercury_compile.m: Added code to run the tupling pass. Run a simplification pass after the untupling transformation. The untupling transformation generates procedures that really should be simplified, and it should help the tupling transformation (which runs directly after untupling). compiler/options.m: Add the options --tuple, --tuple-trace-counts-file, --tuple-costs-ratio and --tuple-min-args. compiler/handle_options.m: Disable --tuple when debugging is on. compiler/hlds_goal.m: compiler/common.m: compiler/saved_vars.m Add `tuple_opt' goal feature. compiler/hlds_pred.m: compiler/layout_out.m: Add a new `tuple' functor for `pred_transformation'. compiler/untupling.m: Made the untupling transformation give better names to the head variables in the untupled versions of procedures that it generates. This is needed for the tupling transformation to find related head variables between procedures in an SCC. mdbcomp/trace_counts.m: Add predicate `restrict_trace_counts_to_module'. library/list.m: Add `nth_member_lookup/3', a deterministic version of `nth_member_search/3'.	2005-03-06 05:17:42 +00:00
Zoltan Somogyi	e87f37b5be	Make this pass significantly more efficient when operating on ... Estimated hours taken: 12 Branches: main compiler/common.m: Make this pass significantly more efficient when operating on predicates with many opportunities for reusing common structures. The speed when compiling the six largest compiler modules is virtually unaffected, but the time to compile a module generated by caribou has dropped from 79 seconds to 56, a 30% reduction. The main change is avoiding repeated computations. Instead of storing the types of available structures and checking their type constructors each time they are looked at, compute the type constructor just once. Document the main data structure in significantly more detail than before. Switch to four-space indentation. Some predicates have so many levels of indentation that this is the only way to allow a reasonable amount of code on each line. compiler/simplify.m: Conform to the changed interface of common.m. Some minor cleanups. library/eqvclass.m: Improve the speed of the basic operation of adding new equivalences by avoiding the creation of new equivalence classes and then destroying them immediately. Make it possible for the caller (in our case, common.m) to speed up a sequence of equivalence tests by performing the common part of those tests just once.	2005-01-24 02:32:48 +00:00
Julien Fischer	a3352a6e5d	Do not include :- import_module' and :- use_module' declarations ... Estimated hours taken: 22 Branches: main Do not include `:- import_module' and `:- use_module' declarations in the implementation section of .int and .int2 files unless the types that they export are required by the definition of an equivalence type. This should help prevent unnecessary recompilations when new imports are made in the implementation of modules. Break up check_hlds.type_util so that predicates that do not require access to the HLDS are placed in a new module, parse_tree.prog_type. The above change requires some of these predicates. This also removes one of the dependencies between the parse_tree package on modules of the check_hlds package. Remove the remaining such dependency by moving inst_constrains_unconstrained_var/1 from check_hlds.inst_util to parse_tree.prog_mode. None of the modules in parse_tree now depend upon modules in check_hlds. Modify the parser so that import_module declarations that specify more than one module are replaced by multiple import_module declarations, with one module per declaration. This makes the above change easier to implement and is in any case required by the upcoming diff for canonicalizing module interfaces. We also do the same for use_module and include_module declarations. compiler/modules.m: Don't import modules in the implementation section of interface files unless they are required by the definition of equivalence types. compiler/prog_type.m: New module. Move procedures from type_util that do not depend on the HLDS to here so that we can use them when generating interface files. XXX There are probably others that could be moved as well - I only moved those that were immediately useful. compiler/type_util.m: Delete the procedures that have been moved to the new prog_type module. compiler/prog_io.m: Remove the dependency on check_hlds.inst_util. compiler/prog_io_typeclass.m: compiler/equiv_type.m: Remove dependencies on check_hlds.type_util. compiler/prog_util.m: Add a predicate sym_name_get_module_name/2 that is similar to sym_name_get_module_name/3 except that it fails if the input is an unqualified sym_name. compiler/inst_util.m: Delete inst_contains_unconstrained_var/1 from this module and copy it to prog_mode.m. compiler/parse_tree.m: Include the new module. Do not import the check_hlds package as all dependencies on this package have been removed. compiler/*.m: Minor changes to conform to the above. compiler/notes/compiler_design.html: Mention the new module.	2005-01-21 03:27:58 +00:00
Zoltan Somogyi	885fd4a387	Remove almost all dependencies by the modules of parse_tree.m on the modules ... Estimated hours taken: 12 Branches: main Remove almost all dependencies by the modules of parse_tree.m on the modules of hlds.m. The only such dependencies remaining now are on type_util.m. compiler/hlds_data.m: compiler/prog_data.m: Move the cons_id type from hlds_data to prog_data, since several parts of the parse tree data structure depend on it (particularly insts). Remove the need to import HLDS modules in prog_data.m by making the cons_ids that refer to procedure ids refer to them via a new type that contains shrouded pred_ids and proc_ids. Since pred_ids and proc_ids are abstract types in hlds_data, add predicates to hlds_data to shroud and unshroud them. Also move some other types, e.g. mode_id and class_id, from hlds_data to prog_data. compiler/hlds_data.m: compiler/prog_util.m: Move predicates for manipulating cons_ids from hlds_data to prog_util. compiler/inst.m: compiler/prog_data.m: Move the contents of inst.m to prog_data.m, since that is where it belongs, and since doing so eliminates a circular dependency. The separation doesn't serve any purpose any more, since we don't need to import hlds_data.m anymore to get access to the cons_id type. compiler/mode_util.m: compiler/prog_mode.m: compiler/parse_tree.m: Move the predicates in mode_util that don't depend on the HLDS to a new module prog_mode, which is part of parse_tree.m. compiler/notes/compiler_design.m: Mention prog_mode.m, and delete the mention of inst.m. compiler/mercury_to_mercury.m: compiler/hlds_out.m: Move the predicates that depend on HLDS out of mercury_to_mercury.m to hlds_out.m. Export from mercury_to_mercury.m the predicates needed by the moved predicates. compiler/hlds_out.m: compiler/prog_out.m: Move predicates for printing parts of the parse tree out of hlds_out.m to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/purity.m: compiler/prog_out.m: Move predicates for printing purities from purity.m, which is part of check_hlds.m, to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/passes_aux.m: compiler/prog_out.m: Move some utility predicates (e.g. for printing progress messages) from passes_aux.m to prog_out.m, since some predicates in submodules of parse_tree.m need to use them. compiler/foreign.m: compiler/prog_data.m: Move some types from foreign.m to prog_data.m to allow the elimination of some dependencies on foreign.m from submodules of parse_tree.m. compiler/*.m: Conform to the changes above, mostly by updating lists of imported modules and module qualifications. In some cases, also do some local cleanups such as converting predicate declarations to predmode syntax and fixing white space.	2004-06-14 04:17:03 +00:00
Zoltan Somogyi	a97c5f2862	Improve some variable names. ... Estimated hours taken: 0.1 Branches: main compiler/common.m: Improve some variable names.	2004-05-23 22:09:16 +00:00
Zoltan Somogyi	7aff9fd005	Bring these modules into line with our current style guidelines. ... Estimated hours taken: 1 Branches: main compiler/simplify.m: compiler/common.m: Bring these modules into line with our current style guidelines. Use predmode declarations where appropriate. Use state variable syntax where appropriate, and reorder arguments as necessary to make this possible. compiler/size_prof.m: Conform to the changed argument order of a predicate in simplify.m.	2004-03-08 02:30:31 +00:00
Zoltan Somogyi	d10e7858e1	Add an XXX about a missed opportunity. ... Estimated hours taken: 0.2 Branches: main compiler/common.m: Add an XXX about a missed opportunity.	2003-05-13 07:52:14 +00:00
Simon Taylor	82a950c0d9	Make Aditi work with `--highlevel-code'. ... Estimated hours taken: 80 Branches: main Make Aditi work with `--highlevel-code'. (Note that this doesn't work with the current CVS version of Aditi. The Aditi developers have rewritten the Aditi client API, and haven't maintained the old version of the API, so Mercury queries don't work at the moment. extras/aditi will be updated to use the new interface as a separate change.) extras/aditi/aditi_private_builtin.m: extras/aditi/aditi.m: Move code to implement Aditi calls and updates into a aditi_private_builtin.m. These operations are now implemented using ordinary Mercury foreign procedures, rather than hand-coded C modules. compiler/magic.m: Use calls to ordinary calls to predicates defined in extras/aditi/aditi_private_builtin.m to implement the procedures which interface between top-down Mercury code and Aditi procedures. compiler/aditi_backend.pp: compiler/aditi_builtin_ops.m: compiler/mercury_compile.m: compiler/notes/compiler_design.html: Add a pass to convert Aditi builtins (calls and updates) into ordinary calls to predicates defined in extras/aditi/aditi_private_builtin.m. compiler/hlds_goal.m: compiler/hlds_pred.m: Add a new generic_call type -- `unsafe_cast'. aditi_builtin_ops.m needs to be able to cast closures from one type and inst to another. Delete the `aditi_call' alternative for `aditi_builtin', which is not needed after the change to magic.m described above. Add predicates `construct_tuple' and `deconstruct_tuple'. compiler/*hlds.*.m: compiler/call_gen.m: compiler/ml_call_gen.m: Handle unsafe cast goals. compiler/common.m: compiler/higher_order.m: compiler/unify_proc.m: Generate unsafe_cast goals instead of calls to private_builtin.unsafe_type_cast. compiler/purity.m: compiler/notes/compiler_design.html: Convert calls to private_builtin.unsafe_type_cast into unsafe_cast goals. compiler/ml_code_gen.m: Don't attempt to generate code for Aditi procedures. Remove special case handling of calls to private_builtin.unsafe_type_cast -- such calls are now transformed away. compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/maybe_mlds_to_gcc.m: Add the RL code to the generated C file. compiler/llds_out.m: compiler/c_util.m: compiler/compile_target_code.m: Move code to generate a `.rlo' file and work out the name of the RL constant embeeded in the C file for a module into c_util.m, for use by the MLDS backend. compiler/modules.m: Automatically import aditi_private_builtin when compiling with `--aditi'. We generate a C constant for the RL code for each module, so modules compiled with `--aditi' need to be treated by the build system as if they contain foreign code. compiler/polymorphism.m: Tuple insertion and deletion no longer need special treatment. compiler/llds.m: compiler/ll_backend.*.m: Delete the Aditi alternatives of the `code_addr' type. compiler/mode_util.m: Add function versions of in_mode, out_mode, etc. compiler/prog_util.m: Add aditi_public_builtin_module (returns `aditi') and aditi_private_builtin_module (returns `aditi_private_builtin'). tests/valid/aditi_private_builtin.m: tests/invalid/aditi_private_builtin.m: tests/valid/Mercury.options: tests/invalid/Mercury.options: Add a cut down version of extras/aditi/aditi_private_builtin.m for use in running the tests.	2003-03-18 02:43:52 +00:00
Zoltan Somogyi	9551640f55	Import only one compiler module per line. Sort the blocks of imports. ... Estimated hours taken: 2 Branches: main compiler/*.m: Import only one compiler module per line. Sort the blocks of imports. This makes it easier to merge in changes. In a couple of places, remove unnecessary imports.	2003-03-15 03:09:14 +00:00
Simon Taylor	129f605d25	Fix bugs in the handling of purity in the optimization passes ... Estimated hours taken: 8 Branches: main, release Fix bugs in the handling of purity in the optimization passes (in particular constraint propagation), which caused purity annotations on goals to be lost. This caused tests/tabling/unused_args to fail on earth. compiler/hlds_goal.m: Make the version of goal_info_init called from the optimization passes take the purity as an argument. Previously, callers were constructing a goal_info then adding the purity, which was error prone. compiler/hlds_goal.m: compiler/purity.m: Move the predicates to deal with purity representation in hlds_goal_infos into hlds_goal.m. Rationale - goal_info_get_determinism is not in det_analysis.m, goal_info_get_nonlocals is not in quantification.m, etc. This makes it easier to make the purity setting code efficient. Don't allocate memory in add_goal_info_purity_feature if the call doesn't change the purity. compiler/*.m: Pass the extra argument to goal_info_init. compiler/polymorphism.m: Remove a duplicate definition of hlds_goal__make_int_const_construction. compiler/magic.m: Remove some unused code. tests/hard_coded/purity/Mmakefile: tests/hard_coded/purity/Mercury.options: tests/hard_coded/purity/purity_opt.{m,exp}: Test case.	2003-02-28 00:21:42 +00:00
Simon Taylor	660a24a7ad	Fix a bug reported by Michael Day which caused spurious ... Estimated hours taken: 8 Branches: main, release Fix a bug reported by Michael Day which caused spurious "predicate multiply defined" errors if there were predicates `module1.p' and `module2.module1.p'. compiler/hlds_module.m: For each of the predicate table search predicates which takes a module, add an extra argument which states whether the module name passed in is fully qualified. If it is, then a search for `module1.p' will not return `module2.module1.p'. The module name is guaranteed to be fully qualified for the head of predicate, clause, etc. items, and for calls occurring in `.opt' files. Add a predicate `lookup_builtin_pred_proc_id', for looking up the builtin predicates in the predicate table. compiler/goal_util.m: Move code to look up builtin predicates into hlds_module.m. Set the builtin_state field of the call goal returned by generate_simple_call correctly. compiler/hlds_pred.m: Add a function `calls_are_fully_qualified' which takes an import_status, and returns whether calls from goals with that status are always fully qualified, which is true iff the call is in a `.opt' file. compiler/prog_io.m: Module qualify the sym_names in `:- external' items. compiler/*.m: Fill in the extra argument of predicate table searches. Use `lookup_builtin_pred_proc_id' rather than `predicate_table_search_*'. compiler/prog_util.m: Add function versions of mercury_*_builtin_module. compiler/polymorphism.m: compiler/simplify.m: compiler/unify_proc.m: Use goal_util__generate_simple_call to call builtins, rather than duplicating the code. tests/valid/Mmakefile: tests/valid/nested_module_bug.m: tests/valid/intermod_bug_nested.m: Test cases.	2003-02-22 13:18:34 +00:00
Simon Taylor	fd29bedc88	Fix a bug reported by Zoltan which caused warning/optimization ... Estimated hours taken: 0.5 Branches: main compiler/common.m: Fix a bug reported by Zoltan which caused warning/optimization of duplicate calls to fail if the arguments of the calls were duplicated constants. tests/valid/Mmakefile: tests/valid/Mercury.options: tests/valid/duplicate_const.{m,exp}: Test case.	2003-02-17 06:20:06 +00:00
Simon Taylor	2255eff8b6	Fix a code generator abort reported by rafe. ... Estimated hours taken: 2.5 Fix a code generator abort reported by rafe. compiler/simplify.m: Recompute instmap deltas and rerun determinism analysis after optimizing away part of an if-then-else, to avoid a case where a conjunction with determinism `erroneous' was being given determinism `det' (which was the determinism of the enclosing if-then-else). compiler/common.m: Rerun determininsm analysis after optimizing away a duplicate call or unification with determinism other than `det'. tests/valid/Mmakefile: tests/valid/simplify_bug2.m: Test case.	2002-05-14 14:34:44 +00:00
Zoltan Somogyi	189b9215ae	This diff implements stack slot optimization for the LLDS back end based on ... Estimated hours taken: 400 Branches: main This diff implements stack slot optimization for the LLDS back end based on the idea that after a unification such as A = f(B, C, D), saving the variable A on the stack indirectly also saves the values of B, C and D. Figuring out what subset of {B,C,D} to access via A and what subset to access via their own stack slots is a tricky optimization problem. The algorithm we use to solve it is described in the paper "Using the heap to eliminate stack accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot. That paper also describes (and has examples of) the source-to-source transformation that implements the optimization. The optimization needs to know what variables are flushed at call sites and at program points that establish resume points (e.g. entries to disjunctions and if-then-elses). We already had code to compute this information in live_vars.m, but this code was being invoked too late. This diff modifies live_vars.m to allow it to be invoked both by the stack slot optimization transformation and by the code generator, and allows its function to be tailored to the requirements of each invocation. The information computed by live_vars.m is specific to the LLDS back end, since the MLDS back ends do not (yet) have the same control over stack frame layout. We therefore store this information in a new back end specific field in goal_infos. For uniformity, we make all the other existing back end specific fields in goal_infos, as well as the similarly back end specific store map field of goal_exprs, subfields of this new field. This happens to significantly reduce the sizes of goal_infos. To allow a more meaningful comparison of the gains produced by the new optimization, do not save any variables across erroneous calls even if the new optimization is not enabled. compiler/stack_opt.m: New module containing the code that performs the transformation to optimize stack slot usage. compiler/matching.m: New module containing an algorithm for maximal matching in bipartite graphs, specialized for the graphs needed by stack_opt.m. compiler/mercury_compile.m: Invoke the new optimization if the options ask for it. compiler/stack_alloc.m: New module containing code that is shared between the old, non-optimizing stack slot allocation system and the new, optimizing stack slot allocation system, and the code for actually allocating stack slots in the absence of optimization. Live_vars.m used to have two tasks: find out what variables need to be saved on the stack, and allocating those variables to stack slots. Live_vars.m now does only the first task; stack_alloc.m now does the second, using code that used to be in live_vars.m. compiler/trace_params: Add a new function to test the trace level, which returns yes if we want to preserve the values of the input headvars. compiler/notes/compiler_design.html: Document the new modules (as well as trace_params.m, which wasn't documented earlier). compiler/live_vars.m: Delete the code that is now in stack_alloc.m and graph_colour.m. Separate out the kinds of stack uses due to nondeterminism: the stack slots used by nondet calls, and the stack slots used by resumption points, in order to allow the reuse of stack slots used by resumption points after execution has left their scope. This should allow the same stack slots to be used by different variables in the resumption point at the start of an else branch and nondet calls in the then branch, since the resumption point of the else branch is not in effect when the then branch is executed. If the new option --opt-no-return-calls is set, then say that we do not need to save any values across erroneous calls. Use type classes to allow the information generated by this module to be recorded in the way required by its invoker. Package up the data structures being passed around readonly into a single tuple. compiler/store_alloc.m: Allow this module to be invoked by stack_opt.m without invoking the follow_vars transformation, since applying follow_vars before the form of the HLDS code is otherwise final can be a pessimization. Make the module_info a part of the record containing the readonly data passed around during the traversal. compiler/common.m: Do not delete or move around unifications created by stack_opt.m. compiler/call_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/var_locn.m: Allow the code generator to delete its last record of the location of a value when generating code to make an erroneous call, if the new --opt-no-return-calls option is set. compiler/code_gen.m: Use a more useful algorithm to create the messages/comments that we put into incr_sp instructions, e.g. by distinguishing between predicates and functions. This is to allow the new scripts in the tool directory to gather statistics about the effect of the optimization on stack frame sizes. library/exception.m: Make a hand-written incr_sp follow the new pattern. compiler/arg_info.m: Add predicates to figure out the set of input, output and unused arguments of a procedure in several different circumstances. Previously, variants of these predicates were repeated in several places. compiler/goal_util.m: Export some previously private utility predicates. compiler/handle_options.m: Turn off stack slot optimizations when debugging, unless --trace-optimized is set. Add a new dump format useful for debugging --optimize-saved-vars. compiler/hlds_llds.m: New module for handling all the stuff specific to the LLDS back end in HLDS goal_infos. compiler/hlds_goal.m: Move all the relevant stuff into the new back end specific field in goal_infos. compiler/notes/allocation.html: Update the documentation of store maps to reflect their movement into a subfield of goal_infos. compiler/*.m: Minor changes to accomodate the placement of all back end specific information about goals from goal_exprs and individual fields of goal_infos into a new field in goal_infos that gathers together all back end specific information. compiler/use_local_vars.m: Look for sequences in which several instructions use a fake register or stack slot as a base register pointing to a cell, and make those instructions use a local variable instead. Without this, a key assumption of the stack slot optimization, that accessing a field in a cell costs only one load or store instruction, would be much less likely to be true. (With this optimization, the assumption will be false only if the C compiler's code generator runs out of registers in a basic block, which for the code we generate should be unlikely even on x86s.) compiler/options.m: Make the old option --optimize-saved-vars ask for both the old stack slot optimization (implemented by saved_vars.m) that only eliminates the storing of constants in stack slots, and the new optimization. Add two new options --optimize-saved-vars-{const,cell} to turn on the two optimizations separately. Add a bunch of options to specify the parameters of the new optimizations, both in stack_opt.m and use_local_vars.m. These are for implementors only; they are deliberately not documented. Add a new option, --opt-no-return-cells, that governs whether we avoid saving variables on the stack at calls that cannot return, either by succeeding or by failing. This is for implementors only, and thus deliberately documented only in comments. It is enabled by default. compiler/optimize.m: Transmit the value of a new option to use_local_vars.m. doc/user_guide.texi: Update the documentation of --optimize-saved-vars. library/tree234.m: Undo a previous change of mine that effectively applied this optimization by hand. That change complicated the code, and now the compiler can do the optimization automatically. tools/extract_incr_sp: A new script for extracting stack frame sizes and messages from stack increment operations in the C code for LLDS grades. tools/frame_sizes: A new script that uses extract_incr_sp to extract information about stack frame sizes from the C files saved from a stage 2 directory by makebatch and summarizes the resulting information. tools/avg_frame_size: A new script that computes average stack frame sizes from the files created by frame_sizes. tools/compare_frame_sizes: A new script that compares the stack frame size information extracted from two different stage 2 directories by frame_sizes, reporting on both average stack frame sizes and on specific procedures that have different stack frame sizes in the two versions.	2002-03-28 03:44:41 +00:00
Fergus Henderson	7597790760	Use sub-modules to structure the modules in the Mercury compiler directory. ... The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c.	2002-03-20 12:37:56 +00:00
Zoltan Somogyi	41a27af862	Change type_id to the more descriptive type_ctor everywhere. ... Estimated hours taken: 6 Branches: main compiler/*.m: Change type_id to the more descriptive type_ctor everywhere.	2002-03-07 08:30:28 +00:00