109 Commits

Author	SHA1	Message	Date
Ian MacLarty	ac651b033b	Only report mode warnings if they occur in all modes. ... Estimated hours taken: 5 Branches: main Only report mode warnings if they occur in all modes. simplify.m already had code to remove error_specs that do not occur in all modes, so move this code to error_util.m and reuse it in modes.m. Also only report mode warnings for user defined predicates. Do not report them for compiler generated predicates (after making the change in the previous paragraph, the compiler issued a warning for a generated unification predicate in term_to_xml.m). compiler/cse_detection.m: Conform to new interface of modecheck_proc. compiler/error_util.m: Add an abstract type error_spec_accumulator and predicates for working with this type. The new type is used for accumulating errors over multiple modes of a predicate. The code for accumulating error specs has been moved from simplify.m. There was a bug in this code caused by the arguments of the pair in the error_spec_accumulator type getting mixed up. This bug has now been fixed. Add mode_report_control to the modecheck phase, so we can mark which error specs should only be reported if they occur in all modes. compiler/mode_errors.m: Delete report_mode_errors and report_mode_warnings, since these are no longer used. Export mode_error_info_to_spec and mode_warning_info_to_spec for converting mode errors and warnings to error specs. Conform to changes in error_util.m. compiler/modecheck_unify.m: Do not supress warnings if the mode may use a subtype, since we want such warnings to be displayed if the occur in all modes. Only report mode warnings if the predicate is not a compiler generated predicate. compiler/modes.m: Delete modecheck_pred_mode and modecheck_proc_info, since they are not used anywhere. In modecheck_proc and modecheck_proc_general report a list of error specs, instead of the number of errors. These predicates are now no longer responsible for printing the errors, they just return the error specs. We need to do it this way so we can accumulate the errors over all modes (eliminating any warnings that don't occur in all modes) before printing them. Report errors in modecheck_pred_mode_2, after all modes have been processed. Accumulate the error specs in modecheck_procs, using the new predicates in error_util.m. Move the code for only reporting the first error encountered for a proc from mode_errors.m to here. Also improve the comment for that bit of code. Conform to changes in error_util.m. compiler/pd_util.m: Conform to changes in error_util.m. compiler/simplify.m: Move the code for accumulating error specs to error_util.m compiler/unify_proc.m: compiler/unique_modes.m: Conform to changes elsewhere. tests/invalid/ho_type_mode_bug.err_exp: The order the errors are reported has changed here, because we now call write_error_specs to report mode errors. tests/invalid/qualified_cons_id2.err_exp: tests/warnings/simple_code.exp: tests/warnings/simple_code.m: We now correctly report a warning we didn't report before.	2007-05-28 01:06:25 +00:00
Zoltan Somogyi	b56885be93	Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. ... Estimated hours taken: 12 Branches: main Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. The problem was not in lco.m, but in follow_code.m. In some cases, (specifically, the LCMC version of insert_2 in sparse_bitset.m), follow_code.m moved an impure goal (store_at_ref) into the arms of an if-then-else without marking those arms, or the if-then-else, as impure. The next pass, simplify, then deleted the entire if-then-else, since it had no outputs. (The store_at_ref that originally appeared after the if-then-else was the only consumer of its only output.) The fix is to get follow_code.m to make branched control structures such as if-then-elses, as well as their arms, semipure or impure if a goal being moved into them is semipure or impure, or if they came from an semipure or impure conjunction. Improve the optimization of the LCMC version of sparse_bitset.insert_2, which had a foreign_proc invocation of bits_per_int in it: replace such invocations with a unification of the bits_per_int constant if not cross compiling. Add a new option, --optimize-constructor-last-call-null. When set, LCMC will assign NULLs to the fields not yet filled in, to avoid any junk happens to be there from being followed by the garbage collector's mark phase. This diff also makes several other changes that helped me to track down the bug above. compiler/follow_code.m: Make the fix described above. Delete all the provisions for --prev-code; it won't be implemented. Don't export a predicate that is not now used anywhere else. compiler/simplify.m: Make the optimization described above. compiler/lco.m: Make sure that the LCMC specialized procedure is a predicate, not a function: having a function with the mode LCMC_insert_2(in, in) = in looks wrong. To avoid name collisions when a function and a predicate with the same name and arity have LCMC applied to them, include the predicate vs function status of the original procedure included in the name of the new procedure. Update the sym_name of calls to LCMC variants, not just the pred_id, because without that, the HLDS dump looks misleading. compiler/pred_table.m: Don't have optimizations like LCMC insert new predicates at the front of the list of predicates. Maintain the list of predicates in the module as a two part list, to allow efficient addition of new pred_ids at the (logical) end without using O(N^2) algorithms. Having predicates in chronological order makes it easier to look at HLDS dumps and .c files. compiler/hlds_module.m: Make module_info_predids return a module_info that is physically updated though logically unchanged. compiler/options.m: Add --optimize-constructor-last-call-null. Make the options --dump-hlds-pred-id, --debug-opt-pred-id and --debug-opt-pred-name into accumulating options, to allow the user to specify more than one predicate to be dumped (e.g. insert_2 and its LCMC variant). Delete --prev-code. doc/user_guide.texi: Document the changes in options.m. compiler/code_info.m: Record the value of --optimize-constructor-last-call-null in the code_info, to avoid lookup at every cell construction. compiler/unify_gen.m: compiler/var_locn.m: When deciding whether a cell can be static or not, make sure that we never make static a cell that has some fields initialized with dummy zeros, to be filled in for real later. compiler/hlds_out.m: For goals that are semipure or impure, note this fact. This info was lost when I changed the representation of impurity from markers to a field. mdbcomp/prim_data.m: Rename some ambiguous function symbols. compiler/intermod.m: compiler/trans_opt.m: Rename the main predicates (and some function symbols) of these modules to avoid ambiguity and to make them more expressive. compiler/llds.m: Don't print line numbers for foreign_code fragments if the user has specified --no-line-numbers. compiler/make.dependencies.m: compiler/mercury_to_mercury.m: compiler/recompilation.usage.m: Don't use io.write to write out information to files we may need to parse again, because this is vulnerable to changes to the names of function symbols (e.g. the one to mdbcomp/prim_data.m). The compiler still contains some uses of io.write, but they are for debugging. I added an item to the todo list of the one exception, ilasm.m. compiler/recompilation.m: Rename a misleading function symbol name. compiler/parse_tree.m: Don't import recompilation.m here. It is not needed (all the components of parse_tree that need recompilation.m already import it themselves), and deleting the import avoids recompiling almost everything when recompilation.m changes. compiler/*.m: Conform to the changes above. compiler/*.m: browser/*.m: slice/*.m: Conform to the change to mdbcomp. library/sparse_bitset.m: Use some better variable names.	2007-01-19 07:05:06 +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
Zoltan Somogyi	c06e22e3ba	Instead of printing each error message immediately, pass them back to ... Estimated hours taken: 1 Branches: main compiler/table_gen.m: compiler/unused_args.m: Instead of printing each error message immediately, pass them back to mercury_compile.m to print them all at once. compiler/mercury_compile.m: Do the printing. compiler/hlds_goal.m: compiler/inst_graph.m: library/float.m: library/int.m: library/math.m: Rename some predicates to avoid ambiguity. compiler/*.m: Conform to the changes above.	2006-12-27 03:18:04 +00:00
Zoltan Somogyi	e21193c283	Rename a bunch of predicates and function symbols to eliminate ... Estimated hours taken: 6 Branches: main browser/*.m: compiler/*.m: Rename a bunch of predicates and function symbols to eliminate ambiguities. The only real change is factoring out some common code in the mlds and llds code generators, replacing them with single definitions in switch_util.m.	2006-10-15 23:26:56 +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	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	e12ca34b2a	Fix a bug reported by Peter Hawkins. The problem occurred with switches with ... Estimated hours taken: 6 Branches: main, release Fix a bug reported by Peter Hawkins. The problem occurred with switches with multiple arms that shared code. Switch detection expands such arms by making copies of the shared code. Requantification then renames the variables in these copies apart, but the new variables are not being entered into the RTTI varmaps. This leads to an assertion failure. compiler/quantification.m: Update the RTTI varmaps after renaming apart. Failing to add any freshly introduced variables into the RTTI varmaps makes them inconsistent. compiler/add_clause.m: compiler/add_pragma.m: compiler/cse_detection.m: compiler/equiv_type_hlds.m: compiler/follow_code.m: compiler/hlds_clauses.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/lambda.m: compiler/mode_constraints.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/tupling.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Conform to the above change. Minor formatting fixes. tests/valid/Mmakefile: tests/valid/hawkins_switch_bug.m: Test case for the above.	2006-08-04 10:51:22 +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	9d23d8e2e7	Implement the trace goal construct we discussed, for now for the LLDS backends ... Estimated hours taken: 70 Branches: main Implement the trace goal construct we discussed, for now for the LLDS backends only. Since the syntax of trace goals is non-trivial, useful feedback on syntax errors inside trace goal attributes is essential. With the previous setup, this wasn't possible, since the code that turned terms into parse tree goals turned *all* terms into goals; it couldn't recognize any errors, sweeping them under the rug as calls. This diff changes that. Now, if this code recognizes a keyword that indicates a particular construct, it insists on the rest of the code following the syntax required for that construct, and returns error messages if it doesn't. We handle the trace goal attributes that specify state variables to be threaded through the trace goal (either the I/O state or a mutable variable) in add_clause.m, at the point at which we transform the list of items to the HLDS. We handle the compile-time condition on trace goals in the invocation of simplify at the end of semantics analysis, by eliminating the goal if the compile-time condition isn't met. We handle run-time conditions on trace goals partially in the same invocation of simplify: we transform trace goals with runtime conditions into an if-then-else with the trace goal as the then part and `true' as the else part, the condition being a foreign_proc that is handled specially by the code generator, that special handling being to replace the actual code of the foreign_proc (which is a dummy) with the evaluation of the runtime condition. Since these changes require significant changes to some of our key data structures, I took the liberty of doing some renaming of function symbols at the same time to avoid using ambiguities with respect to language keywords. library/ops.m: Add "trace" as an operator. compiler/prog_data.m: Define data types to represent the various attributes of trace goals. Rename some function symbols to avoid ambiguities. compiler/prog_item.m: Extend the parse tree representation of goals with a trace goal. compiler/mercury_to_mercury.m: Output the new kind of goal and its components. compiler/hlds_goal.m: Extend the HLDS representation of scopes with a scope_reason representing trace goals. Add a mechanism (an extra argument in foreign_procs) to allow the representation of goals that evaluate runtime trace conditions. Since this requires modifying all code that traverses the HLDS, do some renames that were long overdue: rename not as negation, rename call as plain_call, and rename foreign_proc as call_foreign_proc. These renames all avoid using language keywords as function symbols. Change the way we record goals' purities. Instead of optional features to indicate impure or semipure, which is error-prone, use a plain field in the goal_info, accessed in the usual way. Add a way to represent that a goal contains a trace goal, and should therefore be treated as if it were impure when considering whether to optimize it away. Reformat some comments describing function symbols. compiler/hlds_out.m: Output the new construct in the HLDS. compiler/prog_io_util.m: Generalize the maybe[123] types to allow the representation of more than one error message. Add functions to extract the error messages. Add a maybe4 type. Rename the function symbols of these types to avoid massive ambiguity. Change the order of some predicates to bring related predicates next to each other. compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: Rework these modules almost completely to find and accumulate syntax errors as terms are being parsed. In some cases, this allowed us to replace "XXX this is a hack" markers with meaningful error-reporting code. In prog_io_goal.m, add code for parsing trace goals. In a bunch of places, update obsolete coding practices, such as using nested chains of closures instead of simple sequential code, and using A0 and A to refer to values of different types (terms and goals respectively). Use more meaningful variable names. Break up some too-large predicates. compiler/superhomogeneous.m: Find and accumulate syntax errors as terms are being parsed. compiler/add_clause.m: Add code to transform trace goals from the parse tree to the HLDS. This is where the IO state and mutable variable attributes of trace goals are handled. Eliminate the practice of using the naming scheme Body0 and Body to refer to values of different types (prog_item.goal and hlds_goal respectively). Use error_util for some error messages. library/private_builtin.m: Add the predicates referred to by the transformation in add_clause.m. compiler/goal_util.m: Rename a predicate to avoid ambiguity. compiler/typecheck.m: Do not print error messages about missing clauses if some errors have been detected previously. compiler/purity.m: Instead of just computing purity, compute (and record) also whether a goal contains a trace goal. However, treat trace goals as pure. compiler/mode_info.m: Add trace goals as a reason for locking variables. Rename some function symbols to avoid ambiguity. compiler/modes.m: When analyzing trace goal scopes, lock the scope's nonlocal variables to prevent them from being further instantiated. compiler/det_analysis.m: Insist on the code in trace goal scopes being det or cc_multi. compiler/det_report.m: Generate the error message if the code in a trace goal scope isn't det or cc_multi. compiler/simplify.m: At the end of the front end, eliminate trace goal scopes if their compile-time condition is false. Transform trace goals with runtime conditions as described at the top. Treat goals that contain trace goals as if they were impure when considering whether to optimize them away. compiler/mercury_compile.m: Tell simplify when it is being invoked at the end of the front end. Rename a predicate to avoid ambiguity. compiler/trace_params.m: Provide the predicates simplify.m need to be able to evaluate the trace goal conditions regarding trace levels. compiler/trace.m: compiler/trace_gen.m: Rename the trace module as trace_gen, since "trace" is now an operator. Rename some predicates exported by the module, now that it is no longer possible to preface calls with "trace." as a module qualifier. compiler/notes/compiler_design.html: Document this name change. compiler/options.m: Rename the trace option as trace_level internally, since "trace" is now an operator. The user-visible name remains the same. Add the new --trace-flag option. Delete an obsolete option. compiler/handle_options.m: Rename the function symbols of the grade_component type, since "trace" is now an operator. compiler/llds.m: Extend the LLDS with a mechanism to refer to C global variables. For now, these are used to refer to C globals that will be created by mkinit to represent the initial values of the environment variables referred to by trace goals. compiler/commit_gen.m: Check that no trace goal with a runtime condition survives to code generation; they should have been transformed by simplify.m. compiler/code_gen.m: Tell commit_gen.m what kind of scope it is generating code for. compiler/pragma_c_gen.m: Generate code for runtime conditions when handling the foreign_procs created by simplify.m. compiler/code_info.m: Allow pragma_c_gen.m to record what environment variables it has generated references to. compiler/proc_gen.m: Record the set of environment variables a procedure refers to in the LLDS procedure header, for efficient access by llds_out.m. compiler/llds_out.m: Handle the new LLDS construct, and tell mkinit which environment variables need C globals created for them. compiler/pd_util.m: Rename some predicates to avoid ambiguity. compiler/*.m: Conform to the changes above, mainly the renames of function symbols and predicates, the changed signatures of some predicates, and the new handling of purity. util/mkinit.c: Generate the definitions and the initializations of any C globals representing the initial status (set or not set) of environment variables needed by trace goals. library/assoc_list.m: Add some predicates that are useful in prog_io*.m. library/term_io.m: Minor cleanup. tests/hard_coded/trace_goal_{1,2}.{m,exp}: New test cases to test the new construct, identical except for whether the trace goal is enabled at compile time. tests/hard_coded/trace_goal_env_{1,2}.{m,exp}: New test cases to test the new construct, identical except for whether the trace goal is enabled at run time. tests/hard_coded/Mercury.options: tests/hard_coded/Mmakefile: Enable the new test cases. tests/invalid/*.err_exp: Update the expected output for the new versions of the error messages now being generated.	2006-07-27 05:03:54 +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	5af71b60ac	Remove support for the Aditi backend. It is a pain to have to update it every ... Estimated hours taken: 2 Branches: main Remove support for the Aditi backend. It is a pain to have to update it every time a data structure changes when we don't see any benefit from it, and its presence makes compilation of the compiler directory take about 10% longer (since the Aditi backend modules are roughly 10% of the code in the compiler directory). Deleting the Aditi-specific data structures from the HLDS should also speed up compilation a little bit. I have spoken to Rao and he is fine with this step. Aditi users, if there are any, can continue to use the Aditi support in release 0.12.*. I also tagged the last version on the trunk to support aditi with the name "last_aditi". The need for modifications in this Aditi support is likely to be very rare to nonexistent, if the recent past is any guide: the Aditi backend hasn't seen a nontrivial modification in a year or more. This diff removes a net 31492 lines. compiler/add_aditi.m: compiler/aditi_backend.pp: compiler/aditi_builtin_ops.m: compiler/context.m: compiler/dnf.m: compiler/magic.m: compiler/magic_util.m: compiler/rl.m: compiler/rl_analyse.m: compiler/rl_block.m: compiler/rl_block_opt.m: compiler/rl_code.m: compiler/rl_dump.m: compiler/rl_exprn.m: compiler/rl_file.pp: compiler/rl_gen.m: compiler/rl_info.m: compiler/rl_key.m: compiler/rl_liveness.m: compiler/rl_loop.m: compiler/rl_opt.m: compiler/rl_out.pp: compiler/rl_relops.m: compiler/rl_sort.m: compiler/rl_stream.m: Remove these compiler modules, since they existed only to support the Aditi backend. compiler/hlds_goal.m: Delete the Aditi-specific components of goals (e.g. the aditi-builtin kind of generic calls and Aditi-evaluated lambdas). compiler/hlds_pred.m: Delete the Aditi-specific components of pred_infos. compiler/prog_data.m: Delete the Aditi-specific items. compiler/passes_aux.m: Don't worry about processing all procedures or just all non-Aditi procedures. compiler/add_clause.m: Add a predicate from a deleted module that is now used only here. compiler/*.m: Conform to the data structure changes above. compiler/notes/*.html: Remove references to the Aditi backend. tests/invalid/aditi.m: tests/invalid/aditi_errors.err_exp: tests/invalid/aditi_errors.m: tests/invalid/aditi_private_builtin.m: tests/invalid/aditi_state_errors.err_exp: tests/invalid/aditi_state_errors.m: tests/invalid/aditi_update_derived_relation.err_exp: tests/invalid/aditi_update_derived_relation.m: tests/invalid/aditi_update_errors.err_exp: tests/invalid/aditi_update_errors.m: tests/invalid/aditi_update_mode_errors.err_exp: tests/invalid/aditi_update_mode_errors.m: tests/valid/aditi.m: tests/valid/aditi_calls_mercury.m: tests/valid/aditi_error_bug.m: tests/valid/aditi_error_bug2.m: tests/valid/aditi_error_bug3.m: tests/valid/aditi_private_builtin.m: tests/valid/aditi_query.m: tests/valid/aditi_update.m: tests/valid/base_relation.m: tests/valid/base_relation2.m: tests/valid/ite_to_disj.m: Remove these Aditi-specific tests. tests/*/Mmakefile: Remove the references to these Aditi-specific tests.	2006-02-23 09:37:30 +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	21685c9e22	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 6 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-11-04 03:41:09 +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	c745c93c1d	Fix an old bug: when invoking the compiler with -vS, many of the statistics ... Estimated hours taken: 1 Branches: main Fix an old bug: when invoking the compiler with -vS, many of the statistics printed didn't say what they are for, because the relevant messages were enabled only with -V. compiler/options.m: Add a new option, detailed_statistics. This option is not visible to users. compiler/handle_options.m: Set detailed_statistics only if -v and -S are both set. compiler/mercury_compile.m: compiler/modes.m: compiler/modules.m: compiler/optimize.m: compiler/typecheck_errors.m: In a bunch of places where progress messages are enabled only with -V and not with -v, consult detailed_statistics instead of statistics to decide whether to print statistics, in order to make sure you get only interpretable statistics. compiler/make_hlds_passes.m: Print messages before two statistics reports, because otherwise the statistics are not interpretable. Don't print stats for module optimization, since it is now a no-op. compiler/cse_detection.m: Print statistics if detailed_statistics is set. This is useful because in some cases, cse_detection can be expensive (it reruns mode analysis). compiler/simplify.m: Print statistics if detailed_statistics is set. This is useful because in some cases, simplify can be expensive.	2005-10-25 06:33: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	d609181cb9	Consider types of the form ... Estimated hours taken: 30 Branches: main Consider types of the form :- type x ---> f. to be dummy types, since they contain no information. Optimize them the same way we currently optimize io.state and store.store. runtime/mercury_type_info.h: Add a new type_ctor_rep for dummy types. runtime/mercury_tabling.h: Add a representation for "tabled" dummy types, which don't actually have a level in the trie, so that the runtime system can handle that fact. runtime/mercury_ml_expand_body.h: When deconstructing a value of a dummy type, ignore the actual value (since it will contain garbage) and instead return the only possible value of the type. runtime/mercury_construct.c: runtime/mercury_deconstruct.c: runtime/mercury_deep_copy_body.c: runtime/mercury_tabling.c: runtime/mercury_unify_compare_body.h: library/rtti_implementation.m: Handle the type_ctor_rep of dummy types. runtime/mercury_builtin_types.c: Provide a place to record profiling information about unifications and comparisons for dummy types. runtime/mercury_mcpp.h: java/runtime/TypeCtorRep.java: library/private_builtin.m: Add a new type_ctor_rep for dummy types, and fix some previous discrepancies in type_ctor_reps. mdbcomp/prim_data.m: Move a bunch of predicates for manipulating special_pred_ids here from the browser and compiler directories. Rename the function symbols of the special_pred_id type to avoid the need to parenthesize the old `initialise' function symbol. Convert to four-space indentation. mdbcomp/rtti_access.m: Don't hardcode the names of special preds: use the predicates in prim_data.m. Convert to four-space indentation. browser/declarative_execution.m: Delete some predicates whose functionality is now in mdbcomp/prim_data.m. compiler/hlds_data.m: Replace the part of du type that says whether a type an enum, which used to be a bool, with something that also says whether the type is a dummy type. Convert to four-space indentation. compiler/make_tags.m: Compute the value for the new field of du type definitions. compiler/hlds_out.m: Write out the new field of du type definitions. compiler/rtti.m: Modify the data structures we use to create type_ctor_infos to allow for dummy types. Convert to four-space indentation. compiler/type_ctor_info.m: Modify the code that generates type_ctor_infos to handle dummy types. compiler/type_util.m: Provide predicates for recognizing dummy types. Convert to four-space indentation. compiler/unify_proc.m: Generate the unify and compare predicates of dummy types using a new code scheme that avoids referencing arguments that contain garbage. When generating code for unifying or comparing other types, ignore any arguments of function symbols that are dummy types. Don't use DCG style access predicates. compiler/higher_order.m: Specialize the unification and comparison of values of dummy types. Break up an excessively large predicate, and factor out common code from the conditions of a chain of if-then-elses. compiler/llds.m: For each input and output of a foreign_proc, include a field saying whether the value is of a dummy type. compiler/pragma_c_gen.m: Fill in the new fields in foreign_proc arguments. compiler/hlds_goal.m: Rename some predicates for constructing unifications to avoid unnecessary ad-hoc overloading. Clarify their documentation. Rename a predicate to make clear the restriction on its use, and document the restriction. Add a predicate for creating simple tests. Add a utility predicate for setting the context of a goal directly. compiler/modules.m: Include dummy types interface files, even if they are private to the module. This is necessary because with the MLDS backend, the generated code inside the module and outside the module must agree whether a function returning a value of the type returns a real value or a void value, and this requires them to agree on whether the type is dummy or not. The impact on interface files is minimal, since very few types are dummy types, and changing a type from a dummy type to a non-dummy type or vice versa is an ever rarer change. compiler/hlds_pred.m: Provide a representation in the compiler of the trie step for dummy types. compiler/layout_out.m: Print the trie step for dummy types. compiler/table_gen.m: Don't table values of dummy types, and record the fact that we don't by including a dummy trie step in the list of trie steps. compiler/add_pragma.m: compiler/add_special_pred.m: compiler/add_type.m: compiler/aditi_builtin_ops.m: compiler/bytecode.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/det_report.m: compiler/exception_analysis.m: compiler/inst_match.m: compiler/livemap.m: compiler/llds_out.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_il.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/opt_util.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/qual_info.m: compiler/rl.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/rtti_out.m: compiler/simplify.m: compiler/size_prof.m: compiler/term_constr_initial.m: compiler/term_constr_util.m: compiler/term_norm.m: compiler/termination.m: compiler/trace.m: compiler/typecheck.m: compiler/unify_gen.m: Conform to the changes above. compiler/export.m: compiler/exprn_aux.m: compiler/foreign.m: compiler/polymorphism.m: compiler/proc_label.m: compiler/rtti_to_mlds.m: compiler/special_pred.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/state_var.m: compiler/switch_util.m: compiler/trace_params.m: Conform to the changes above. Convert to four-space indentation. compiler/mlds_to_java.m: compiler/var_locn.m: Conform to the changes above, which requires threading the module_info through the module. Convert to four-space indentation. compiler/mercury_compile.m: Pass the module_info to mlds_to_java.m. compiler/ml_util.m: compiler/polymorphism.m: compiler/type_ctor_info.m: compiler/type_util.m: Delete some previously missed references to the temporary types used to bootstrap the change to the type_info type's arity. compiler/polymorphism.m: Turn back on an optimization that avoids passing parameters (such as type_infos) to foreign_procs if they are not actually referred to. compiler/prog_data.m: Convert to four-space indentation. library/svvarset.m: Add a missing predicate. trace/mercury_trace.c: Delete the unused function that used to check for dummy types. tests/debugger/field_names.{m,inp,exp}: Add to this test case a test of the handling of dummy types. Check that their values can be printed out during normal execution, and that the debugger doesn't consider them live nondummy variables, just as it doesn't consider I/O states live nondummy variables.	2005-10-05 06:34:27 +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	6df9a05856	This diff cleans up a bunch of modules. It has no algorithmic changes ... Estimated hours taken: 10 Branches: main This diff cleans up a bunch of modules. It has no algorithmic changes other than in the formatting of error messages. compiler/error_util.m: Delete the obsolete predicate append_punctuation, since the suffix format component can now do more, and do it more easily. compiler/goal_util.m: compiler/hlds_goal.m: compiler/hlds_llds.m: compiler/instmap.m: compiler/const_prop.m: Change the argument order of some the predicates exported by these modules to make them easier to use with state variable syntax. compiler/*.m: Convert a bunch of these modules to four space indentation, and fix departures from our coding style. Conform to the changed argument order above. Use suffixes instead of append_punctuation. library/string.m: Add string.foldl2. tests/invalid/circ_*.err_exp: tests/warnings/unused_args_*.exp: Expect the updated error messages, which format sym_names consistently the same way as other messages.	2005-08-30 04:12:17 +00:00
Mark Brown	38d9ef3479	Package the type_info_varmap and typeclass_info_varmap types into an ADT ... Estimated hours taken: 25 Branches: main Package the type_info_varmap and typeclass_info_varmap types into an ADT called rtti_varmaps. There are two main purposes for this: - We wish to extend this set of maps with new maps. Doing this will be a lot easier and less error prone if all of the maps are packaged in a single data structure. - Any new maps that we add may contain redundant information that just makes searching the maps more efficient. Therefore they must be kept consistent with the existing maps. Having all the maps inside an ADT makes it easier to ensure this. This change also includes two extensions to the maps. First, the typeclass_info_map is made reversible so that it is possible to efficiently look up the constraint for a given typeclass_info variable. Second, a new map from prog_vars to types makes it possible to efficiently look up the type that a given type_info variable is for. These two changes mean that it is no longer necessary to consult the argument of type_info/1 or typeclass_info/1 to find this information. (We still do put that information there, though; changing the RTTI is left for a separate change.) compiler/hlds_pred.m: Move items relating to type_infos and typeclass_infos into a section of their own. Add a type `rtti_var_info' to hold information about the contents of a type_info or typeclass_info variable. Define the rtti_varmaps abstract data type. This data structure consists of the type_info_varmap and the typeclass_info_varmap. Add a new map, type_info_type_map, which is like the inverse to the type_info_varmap. The difference is that the latter can point to locations that are inside a typeclass_info variable, whereas the former only refers to type_info variables. Note that the combined maps do not form a bijection, or even an injection, since it is possible for two different type variables to point to the same location (that is, if they are aliased). Make the typeclass_info_varmap reversible, by using the new module injection.m. Unlike the type_info_varmap, this map is always injective since the same typeclass_info cannot be used for two different constraints. The predicates rtti_det_insert_type_info_locn and set_type_info_locn, which update the type_info_varmap, contain sanity checks to ensure that only type variables that have already been registered with the type_info_type_map are used, and that the information in both maps is consistent. Use the rtti_varmaps structure in proc_info and clauses_info, in place of type_info_varmap and typeclass_info_varmap. compiler/polymorphism.m: Remove polymorphism__type_info_or_ctor_type/2 and polymorphism__typeclass_info_class_constraint/2, to ensure that nobody tries to use the information in the type argument. Replace them with two similar predicates that test if a type is type_info or typeclass_info, but that don't return the argument. Ensure that the new type_info_type_map in the rtti_varmaps is kept up to date by threading the rtti_varmaps through a few more places. Some of these places are exported, so this part of the change affects other modules as well. Fix a comment that referred to a non-existent predicate. compiler/type_util.m: Remove the predicates apply_substitutions_to_var_map/5 and apply_substitutions_to_typeclass_var_map/5. The functionality is now provided by the new ADT. compiler/cse_detection.m: Rewrite update_existential_data_structures/4 to use the interface provided by rtti_varmaps. The algorithm for doing this has changed in the following ways: - The first pass, which builds a map from changed locations in the first branch to the tvars concerned, is modified slightly to traverse over the keys instead of over key-value pairs. - The second pass, which previously calculated the induced type substitution and reconstructed the type_info_varmap now only does the former. - Applying the prog_var transformation and the induced type substitution is done at the end, using the interface to rtti_varmaps. compiler/goal_util.m: Rewrite goal_util__extra_nonlocal_typeinfos/6 to avoid the need for using map__member/3 on the typeclass_info_varmap (about which the existing comments say "this is probably not very efficient..."), and to be more efficient in general. Previously, we nondeterministically generated non-local type vars and then tested each constraint to see if it had the type var in it. Now, we go through each constraint one at a time and check if any of the type variables in it are non-local. This is more efficient because we only need to find one non-local type in order to include the typeclass_info in the non-locals -- the remaining (duplicate) solutions are pruned away. compiler/higher_order.m: Use the new maps instead of looking at the arguments of type_info/1 and typeclass_info/1 types. We plan to remove this information from type_info and typeclass_info types in future. Previously, this module used the type argument in order to update the varmaps when the curried arguments of a higher order call are added as arguments to the procedure in which the call occurs. We now look up this information at the point where the curried arg variables are known, and store this information in higher_order_arg alongside the types where it used to be stored. This structure is threaded through to the place where the information is needed. Fix a cut and paste bug in higher_order_arg_depth/1. It was previously calling higher_order_args_size/1 in the recursive call, instead of calling higher_order_args_depth/1. compiler/inlining.m: In inlining__do_inline_call, apply the substitutions to the entire rtti_varmaps structure, not just to the type_info_varmap. (XXX Is there a good reason why the substitution should _not_ be applied to the typeclass_info varmap?) compiler/magic_util.m: Avoid using polymorphism__type_info_or_ctor_type/2 and polymorphism__typeclass_info_class_constraint/2, as these are no longer supported. compiler/*.m: Straightforward changes to use the new ADT. library/injection.m: New library module. This provides an `injection' type which is similar to the existing `bimap' type in that it implements back-to-back maps, but doesn't have such stringent invariants imposed. In particular, the reverse map is not required to be injective. This type is used to model the relationship between prog_constraints and program variables that hold typeclass_infos for them. Namely, the typeclass_info for a constraint can be held in two different variables, but one variable can never hold the typeclass_info for two distinct constraints. library/library.m: Add the new library module. library/list.m: Add list__foldl_corresponding and list__foldl2_corresponding, which traverse two lists in parallel, which one or two accumulators, and abort if there is a length mismatch. NEWS: Mention the changes to the standard library.	2005-07-22 12:32:07 +00:00
Mark Brown	c52d4c114c	Move some predicates dealing with typeclass constraints from ... Estimated hours taken: 0.1 Branches: main compiler/prog_type.m: compiler/prog_util.m: Move some predicates dealing with typeclass constraints from prog_util to prog_type. compiler/check_typeclass.m: compiler/cse_detection.m: compiler/recompilation.version.m: Minor changes to the imported modules.	2005-04-02 17:10:01 +00:00
Mark Brown	4427723508	Remove the assumption made by polymorphism.m that all type variables ... Estimated hours taken: 240 Branches: main Remove the assumption made by polymorphism.m that all type variables appearing in class constraints also appear in the type being constrained. This is a first step towards adding functional dependencies, since in the presence of functional dependencies (or "improvement" in general) this assumption no longer holds. The assumption made by polymorphism manifests itself in the fact that constraints on atomic goals are reconstructed by unifying the types of formal parameters with the types of actual arguments, and then applying the resulting substitution to the constraints. Any type variables in constraints that don't appear in the formal parameters will therefore remain unbound. This change overcomes the assumption by building up a map from constraint identifiers to constraints during typechecking, and then looking up this map in order to reconstruct the constraint during the polymorphism transformation. To support this, the type 'class_constraint' has been removed and replaced by two distinct types, 'prog_constraint' and 'hlds_constraint'. The former is part of the parse tree and holds the same information as the old class_constraint. The latter is part of the HLDS, and is used during typechecking; in addition to the information in prog_constraints, it also stores a set of identifiers that represent where the constraint came from. These identifiers are used as the keys in the aforementioned map. At this stage the constraint identifiers are only used by typechecking to build the constraint map. Other passes use either prog_constraints or hlds_constraints with an empty set of identifiers. compiler/hlds_data.m: Define the constraint_id type, which is used to uniquely identify class constraints. A better scheme than this one has been suggested, but that will be left to a later change. An XXX comment to that effect has been added. Define the hlds_constraint type, which is like prog_constraint but it also includes a set of constraint_ids. Define a set of predicates to initialise and manipulate these. Define the constraint_map type here. Move the definition of constraint_proof_map to here, where it more sensibly belongs. Update the comments in hlds_instance_defn slightly, with information that I found I needed to know when making this change. compiler/hlds_pred.m: Add a field to the pred_info to store the constraint_map. Move the definition of constraint_proof_map from here. compiler/hlds_out.m: Print out a representation of the constraint map if it isn't empty. compiler/type_util.m: Change the predicates that used to operate on class_constraints so that they now operate on hlds_constraints. The old versions of these predicates have now moved to prog_util. Add some utility predicates to manipulate constraint_maps. Add a predicate to apply a variable renaming to constraint_proof_maps. compiler/prog_data.m: Rename class_constraint(s) to prog_constraint(s). compiler/prog_util.m: Provide a set of predicates for manipulating prog_constraints. compiler/typecheck.m: Ensure that goal_paths are filled in before the first iteration of typechecking. Pass the hlds_goal_info down through typecheck_goal_2 so that the goal_path can be retrieved when needed to assign identifiers to constraints. Thread the goal_path through to wherever it is needed. Store hlds_constraints in the args_type_assign rather than prog_constraints, so that the required information is available when creating the new set of type_assigns. Do likewise for the cons_type_info type. Don't pass the module_info through make_pred_cons_info*, since it isn't used. Do pass the goal_path, though, so that constraints in cons_type_infos can be given the correct identifier. Add a constraint_map field to the typecheck_info, initialised to empty. When retrieving the final information from a typecheck_info, return the resulting constraint_map, after applying any type bindings. Ensure that any constraints that may not have been entered into the constraint_map are put there now. Call the new predicate in type_util to rename the constraint_proof_map, rather than doing it longhand here. Make the following changes to context reduction: - Thread the constraint_map through, so that it can be updated as constraints are eliminated. - Instead of simply calling sort_and_remove_dups on the set of constraints remaining after one iteration, merge the constraints in such a way that the complete set of constraint_ids is retained. - Disregard the constraint_ids when deleting newly introduced constraints that are equivalent to constraints that have already been seen. - Simplify the code of find_matching_instance_rule_2 by moving the deterministic code out of the condition of the if-then-else. Move find_first_map into the library. compiler/polymorphism.m: Ensure that the goal_path is set when constructing lambda goals. In process_call, look up the constraints in the constraint_map using the goal_path as part of the key, rather than calculating the constraints by applying the ParentToActual type substitution. Rearrange this code so that it is divided into easier to understand blocks. Add a field to the poly_info to store the constraint_map, and initialise it from the pred_info. compiler/goal_path.m: Fill slots in lambda_goals, since constraints inside these will otherwise not be identified properly. The goal_paths inside here do not entirely make sense, since there is no goal_path_step for the lambda_goal itself. However, there is enough information retained to distinguish these goal_paths from any other possible goal_path, which is all that we require to identify constraints. Add a warning not to fill in the goal slots between the typechecking and polymorphism passes, since doing so could potentially render the constraint_maps incorrect. compiler/make_hlds.m: Initialise the constraint_map to empty in pred_infos. Move the code for updating the superclass_table into a separate predicate. Initially this change was made because, in an earlier version of the change, the superclass_table had some extra information that needed to be filled in. That part of the change is not needed in this diff, but the new predicate simplifies the code a bit so I've left it there. compiler/check_typeclass.m: Convert the prog_constraints into hlds_constraints before passing them to typecheck.reduce_context_by_rule_application. They are assigned no identifiers, since these constraints are not required to be put into the constraint map. Change the name of the function get_constraint_id to get_constraint_class_id, since it would now be ambiguous otherwise. compiler/cse_detection.m: Import parse_tree__prog_util, since that is where renamings of prog_constraints are now defined. compiler/higher_order.m: Initialise pred_infos here with an empty constraint_map. compiler/post_typecheck.m: When binding type vars to void, apply the void substitution to the constraint_map. compiler/table_gen.m: Pass the constraint_map when creating a new pred_info. compiler/unused_args.m: Create the pred_info with an empty constraint_map. The constraint_map won't be used by this stage anyway. compiler/*.m: Update to use the new type names. Also update to use the existing type synonyms typeclass_info_varmap and constraint_proof_map. Change names of predicates and functions to use prog_constraint instead of class_constraint, where applicable. library/list.m: Add find_first_map from typecheck. Also add find_first_map{2,3}, since at one stage during development I needed find_first_map3, and, although it's not used in the current diff, there is little point removing it now.	2005-04-01 14:29:19 +00:00
Zoltan Somogyi	8b8b3b7d3f	Replace the some() HLDS goal with a more general scope() goal, which can be ... Estimated hours taken: 12 Branches: main Replace the some() HLDS goal with a more general scope() goal, which can be used not just for existential quantification but also for other purposes. The main such purposes are new goal types that allow the programmer to annotate arbitrary goals, and not just whole procedure bodies, with the equivalents of promise_pure/promise_semipure and promise_only_solution: promise_pure ( <impure/semipure goal> ) promise_semipure ( <impure goal> ) promise_equivalent_solutions [OutVar1, OutVar2] ( <cc_multi/cc_nondet goal that computed OutVar1 & OutVar2> ) Both are intended to be helpful in writing constraint solvers, as well as in other situations. doc/reference_manual.texi: Document the new constructs. library/ops.m: Add the keywords of the new constructs to the list of operators. Since they work similarly to the "some" operator, they have the same precedence. compiler/hlds_goal.m: Replace the some(Vars, SubGoal) HLDS construct, with its optional keep_this_commit attribute, with the new scope(Reason, SubGoal) construct. The Reason argument may say that this scope is an existential quantification, but it can also say that it represents a purity promise, the introduction of a single-solution context with promise_equivalent_solutions, or a decision by a compiler pass. It can also say that the scope represents a set of goals that all arise from the unraveling of a unification between a variable and a ground term. This was intended to speed up mode checking by significantly reducing the number of delays and wakeups, but the cost of the scopes themselves turned out to be bigger than the gain in modechecking speed. Update the goal_path_step type to refer to scope goals instead of just existential quantification. compiler/prog_data.m: Add new function symbols to the type we use to represent goals in items to stand for the new Mercury constructs. compiler/prog_io_goal.m: Add code to read in the new language constructs. compiler/prog_io_util.m: Add a utility predicate for use by the new code in prog_io_goal.m. compiler/make_hlds.m: Convert the item representation of the new constructs to the HLDS representation. Document how the from_ground_term scope reason would work, but do not enable the code. compiler/purity.m: When checking the purity of goals, respect the new promise_pure and promise_semipure scopes. Generate warnings if such scopes are redundant. compiler/det_analysis.m: Make the insides of promise_equivalent_solutions goals single solution contexts. compiler/det_report.m: Provide mechanisms for reporting inappropriate usage of promise_equivalent_solutions goals. compiler/instmap.m: Add a utility predicate for use by one of the modules above. compiler/deep_profiling.m: Use one of the new scope reasons to prevent simplify from optimizing away commits of goals that have been made impure, instead of the old keep_this_commit goal feature. compiler/modes.m: Handle from_ground_term scopes when present; for now, they won't be present, since make_hlds isn't creating them. compiler/options.m: Add two new compiler options, for use by implementors only, to allow finer control over the amount of output one gets with --debug-modes. (I used them when debugging the performance of the from_ground_term scope reason.) The options are --debug-modes-minimal and --debug-modes-verbose. compiler/handle_options.m: Make the options that are meaningful only in the presence of --debug-modes imply --debug-modes, since this allows more convenient (shorter) invocations. compiler/mode_debug.m: Respect the new options when deciding how much data to print when debugging of the mode checking process is enabled. compiler/switch_detect.m: Rename a predicate to make it differ from another predicate by more than just its arity. compiler/passes_aux.m: Bring this module up to date with our current style guidelines, by using state variable syntax where appropriate. compiler/*.m: Minor changes to conform to the change in the HLDS and/or parse tree goal type. mdbcomp/program_representation.m: Rename the some goal to the scope goal, and the same for path steps, to keep them in sync with the HLDS. browser/declarative_tree.m: Conform to the change in goal representations. tests/hard_coded/promise_equivalent_solutions_test.{m,exp}: A new test case to test the handling of the promise_equivalent_solutions construct. tests/hard_coded/Mmakefile: Enable the new test. tests/hard_coded/purity/promise_pure_test.{m,exp}: A new test case to test the handling of the promise_pure and promise_semipure constructs. tests/hard_coded/purity/Mmakefile: Enable the new test. tests/invalid/promise_equivalent_solutions.{m,err_exp}: A new test case to test the error messages for improper use of the promise_pure and promise_semipure constructs. tests/invalid/Mmakefile: Enable the new test.	2005-03-24 05:34:41 +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
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	7bf0cd03af	Reduce the overhead of all forms of tabling by eliminating in many cases ... Estimated hours taken: 32 Branches: main Reduce the overhead of all forms of tabling by eliminating in many cases the overhead of transferring data across the C/Mercury boundary. These involve lots of control transfers as well as assignments to and from Mercury abstract machine registers, which are not real machine registers on x86 machines. Benchmarking in Uppsala revealed this overhead to be a real problem. The way we do that is by changing the tabling transformation so that instead of generating sequences of calls to predicates from library/table_builtin.m, we generate sequences of calls to C macros from runtime/mercury_tabling_pred.h, and emit the resulting code string as the body of a foreign_proc goal. (The old transformation is still available via a new option, --no-tabling-via-extra-args.) Since the number of inputs and outputs of the resulting C code sequences are not always fixed (they can depend on the number of input or output arguments of predicate being transformed), implementing this required adding to foreign_procs a new field that allows the specification of extra arguments to be passed to and from the given foreign code fragment. For now, this mechanism is implemented only by the C backends, since it is needed only by the C backends. (We don't support yet tabling on other backends.) To simplify the new implementation of the field on foreign_procs, consolidate three existing fields into one. Each of these fields was a list with one element per argument, so turning them into a single list with a combined record per argument should also improve reliability, since it reduces the likelyhood of updates leaving the data structure inconsistent. The goal paths of components of a tabled predicate depend on whether -no-tabling-via-extra-args was specified. To enable the expected outputs of the debugger test cases testing tabling, we add a new mdb command, goal_paths, that controls whether goal paths are printed by the debugger at events, and turn off the printing of events in the relevant test cases. Also, prepare for a future change to optimize the trie structure for user-defined types by handling type_infos (and once we support them, typeclass_infos) specially. compiler/table_gen.m: Change the tabling transformation along the lines described above. To allow us to factor out as much of the new code as possible, we change the meaning of the call_table_tip variable for minimal model subgoals: instead of the trie node at the end of the answer table, it is not now the subgoal reachable from it. This change has no effect as yet, because we use call_table_tip variables only to perform resets across retries in the debugger, and we don't do retries across calls to minimal model tabled predicates. Put predicates into logical groups. library/table_builtin.m: runtime/mercury_tabling_preds.h: When the new transformations in table_gen.m generate foreign_procs with variable numbers of arguments, the interfaces of those foreign_procs often do not match the interfaces of the existing library predicates at their core: they frequently have one more or one fewer argument. To prevent any possible confusion, in such cases we add a new variant of the predicate. These predicates have the suffix _shortcut in their name. Their implementations are dummy macros that do nothing; they serve merely as placeholders before or after which the macros that actually do the work are inserted. Move the definitions of the lookup, save and restore predicates into mercury_tabling_preds.h. Make the naming scheme of their arguments more regular. runtime/mercury_minimal_model.c: runtime/mercury_tabling_preds.h: Move the definition of a predicate from mercury_minimal_model.c to mercury_tabling_preds.h, since the compiler now needs to be able to generate an inlined version of it. compiler/hlds_goal.m: Replace the three existing fields describing the arguments of foreign_procs with one, and add a new field describing the extra arguments that may be inserted by table_gen.m. Add utility predicates for processing the arguments of foreign_procs. Change the order of some existing groups of declarations make it more logical. compiler/hlds_pred.m: runtime/mercury_stack_layout.h: Extend the data structures recording the structure of tabling tries to allow the representation of trie steps for type_infos and typeclass_infos. runtime/mercury_tabling_macros.c: Fix a bug regarding the tabling of typeclass_infos, which is now required for a clean compile. compiler/pragma_c_gen.m: compiler/ml_code_gen.m: Modify the generation of code for foreign_procs to handle extra arguments, and to conform to the new data structures for foreign_proc arguments. compiler/llds.m: The tabling transformations can now generate significantly sized foreign_procs bodies, which the LLDS code generator translates to pragma_c instructions. Duplicating these by jump optimization may lose more by worsening locality than it gains in avoiding jumps, so we add an extra field to pragma_c instructions that tells jumpopt not to duplicate code sequences containing such pragma_cs. compiler/jumpopt.m: Respect the new flag on pragma_cs. compiler/goal_util.m: Add a predicate to create foreign_procs with specified contents, modelled on the existing predicate to create calls. Change the order of the arguments of that existing predicate to make it more logical. compiler/polymorphism.m: Conform to the new definition of foreign_procs. Try to simplify the mechanism for generating the type_info and typeclass_info arguments of foreign_proc goals, but it is not clear that this code is even ever executed. compiler/aditi_builtin_ops.m: compiler/assertion.m: compiler/bytecode_gen.m: compiler/clause_to_proc.m: compiler/code_gen.m: compiler/code_info.m: compiler/code_util.m: compiler/constraint.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/dnf.m: compiler/dupelim.m: compiler/equiv_type_hlds.m: compiler/exprn_aux.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/frameopt.m: compiler/goal_form.m: compiler/goal_path.m: compiler/higher_order.m: compiler/higher_order.m: compiler/hlds_module.m: compiler/hlds_out.m: compiler/inlining.m: compiler/ite_gen.m: compiler/layout_out.m: compiler/livemap.m: compiler/liveness.m: compiler/llds_out.m: compiler/loop_inv.m: compiler/magic.m: compiler/make_hlds.m: compiler/mark_static_terms.m: compiler/middle_rec.m: compiler/modes.m: compiler/modules.m: compiler/opt_debug.m: compiler/pd_cost.m: compiler/prog_rep.m: compiler/purity.m: compiler/quantification.m: compiler/reassign.m: compiler/rl_exprn.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/store_alloc.m: compiler/stratify.m: compiler/switch_detection.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/termination.m: compiler/trace.m: compiler/typecheck.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unneeed_code.m: compiler/unused_args.m: compiler/use_local_vars.m: Conform to the new definition of foreign_procs, pragma_cs and/or table trie steps, or to changed argument orders. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/equiv_type.m: compiler/intermod.m: compiler/lambda.m: compiler/lco.m: compiler/module_util.m: compiler/opt_util.m: compiler/stack_opt.m: compiler/trans_opt.m: Conform to the new definition of foreign_procs. Bring these modules up to date with our current code style guidelines, using predmode declarations, state variable syntax and unification expressions as appropriate. compiler/mercury_compile.m: Conform to the changed argument order of a predicate in trans_opt.m. compiler/options.m: Add the --no-tabling-via-extra-args option, but leave the documentation commented out since the option is for developers only. doc/user_guide.texi: Document --no-tabling-via-extra-args option, though leave the documentation commented out since the option is for developers only. doc/user_guide.texi: doc/mdb_categories: Document the new goal_paths mdb command. trace/mercury_trace_internals.c: Implement the new goal_paths mdb command. tests/debugger/completion.exp: Conform to the presence of the goal_paths mdb command. tests/debugger/mdb_command_test.inp: Test the existence of documentation for the goal_paths mdb command. tests/debugger/print_table.{inp,exp*}: tests/debugger/retry.{inp,exp*}: Use the goal_paths command to avoid having the expected output depend on the presence or absence of --tabling-via-extra-args. tests/tabling/table_foreign_output.{m,exp}: Add a new test case to test the save/restore of arguments of foreign types. tests/tabling/Mmakefile: Enable the new test case. tests/tabling/test_tabling: Make this script more robust. Add an option for testing only the standard model forms of tabling.	2004-06-07 09:07:23 +00:00
Zoltan Somogyi	b39a3d855f	This diff makes hlds_module.m and many callers of its predicates easier to read ... Estimated hours taken: 6 Branches: main This diff makes hlds_module.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/hlds_module.m: Bring (most of) this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. (The 'most of' is because I left the part of the module dealing with predicate tables alone, not wishing to cause a conflict for Pete.) Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. compiler/*.m: Conform to the changes in hlds_module.m. This mostly means using the new argument orders of predicates exported by hlds_module.m, and switching to state variable notation. Replace old-style lambdas with new-style lambdas or with partially applied named procedures in updated code. Replace unnecessary occurrences of four-space indentation with standard indentation in updated code. library/list.m: library/map.m: library/tree234.m: Add list__foldl4 and map__foldl3, since in some compiler modules, state variable notation is more convenient (and the code more efficient) if we don't have to bundle up several data structures into a tuple just to iterate over them. Change the fold predicates to use state variable notation. NEWS: Mention the new library functions.	2003-10-31 03:27:39 +00:00
Zoltan Somogyi	8693e293a2	This diff makes hlds_pred.m and many callers of its predicates easier to read ... Estimated hours taken: 4 Branches: main This diff makes hlds_pred.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/hlds_pred.m: Bring this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. Standardize indentation. compiler/*.m: Conform to the changes in hlds_pred.m. This mostly means using the new argument orders of predicates exported by hlds_pred.m. Where this is now conveniently possible, change predicates to use state variable notation. In some modules, using state variable notation required changing the orders of arguments in the module's top predicate. compiler/passes_aux.m: Change the order of arguments in the calls this module makes to allow the callees to use state variable notation. Convert this module to state variable notation too.	2003-10-24 06:17:51 +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
Fergus Henderson	ef7ed9c2f5	Support impurity declarations for higher-order code. ... Estimated hours taken: 24 Branches: main Support impurity declarations for higher-order code. In particular, allow `impure' and `semipure' annotations on higher-order types, higher-order calls, and lambda expresions. NEWS: doc/reference_manual.texi: Document the new language feature. compiler/hlds_goal.m: compiler/hlds_pred.m: Add `purity' field to - the `higher_order' alternative of the hlds_goal.generic_call type - the `higher_order' alternative of the hlds_pred.generic_call_id type - the `lambda_goal' alternative of the hlds_goal.unify_rhs type compiler/type_util.m: Add a new `purity' argument to the procedures dealing with higher-order types. Add code for parsing impure/semipure higher-order types. compiler/lambda.m: compiler/make_hlds.m: compiler/typecheck.m: compiler/post_typecheck.m: compiler/purity.m: compiler/polymorphism.m: Various minor changes to support impure/semipure higher-order lambda expressions. compiler/polymorphism.m: compiler/pseudo_type_info.m: XXX ought to change these to include purity in the RTTI for higher-order function types. compiler/simplify.m: Don't try to optimize semipure/impure higher-order calls. compiler/assertion.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/det_analysis.m: compiler/det_util.m: compiler/equiv_type.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/intermod.m: compiler/magic.m: compiler/magic_util.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/pd_util.m: compiler/prog_rep.m: compiler/pseudo_type_info.m: compiler/quantification.m: compiler/recompilation.usage.m: compiler/rl_gen.m: compiler/stratify.m: compiler/switch_detection.m: compiler/term_traversal.m: compiler/term_util.m: compiler/unify_gen.m: compiler/unique_modes.m: Trivial changes to handle the new purity fields and/or arguments. tests/hard_coded/purity/Mmakefile: tests/hard_coded/purity/impure_func_t5_fixed2.m: tests/hard_coded/purity/impure_func_t5_fixed2.exp: tests/hard_coded/purity/impure_func_t5_fixed2.exp2: tests/hard_coded/purity/impure_pred_t1_fixed3.m: tests/hard_coded/purity/impure_pred_t1_fixed3.exp: tests/invalid/purity/Mmakefile: tests/invalid/purity/impure_func_t5_fixed.m: tests/invalid/purity/impure_func_t5_fixed.err_exp: tests/invalid/purity/impure_pred_t1_fixed.m: tests/invalid/purity/impure_pred_t1_fixed.err_exp: Add new test cases to test the new feature. tests/invalid/purity/impure_func_t5.err_exp: tests/invalid/purity/impure_pred_t1.err_exp: tests/invalid/purity/impure_pred_t2.err_exp: tests/invalid/purity/purity.err_exp: tests/invalid/purity/purity_nonsense.err_exp: Update the expected error messages for existing test cases. tests/invalid/purity/.cvsignore: New file, copied from tests/invalid/.cvsignore.	2003-01-27 09:21:03 +00:00
Simon Taylor	9dbcf4714a	Fix a bug which caused type-incorrect HLDS to be generated by mode ... Estimated hours taken: 5 Branches: main Fix a bug which caused type-incorrect HLDS to be generated by mode analysis, which then caused a compiler abort in simplification. In the code below, mode analysis must treat the headvar unification as a construction followed by a var-var unification. If it is treated as a deconstruction, the argument unifications will be ill-typed. :- type t ---> some [T] f(T) => enum(T). :- pred p(t::in) is semidet. p('new f'(1)). compiler/modecheck_unify.m: Make sure unifications with a RHS of the form 'new f(X)' are always classified as constructions. compiler/hlds_goal.m: compiler/*.m: Add a field to var-functor unifications which identifies those which must be treated as constructions. compiler/polymorphism.m: Fill in the field. tests/hard_coded/Mmakefile: tests/hard_coded/unify_existq_cons.{m,exp}: Test case.	2002-07-22 06:30:04 +00:00
Zoltan Somogyi	189b9215ae	This diff implements stack slot optimization for the LLDS back end based on ... Estimated hours taken: 400 Branches: main This diff implements stack slot optimization for the LLDS back end based on the idea that after a unification such as A = f(B, C, D), saving the variable A on the stack indirectly also saves the values of B, C and D. Figuring out what subset of {B,C,D} to access via A and what subset to access via their own stack slots is a tricky optimization problem. The algorithm we use to solve it is described in the paper "Using the heap to eliminate stack accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot. That paper also describes (and has examples of) the source-to-source transformation that implements the optimization. The optimization needs to know what variables are flushed at call sites and at program points that establish resume points (e.g. entries to disjunctions and if-then-elses). We already had code to compute this information in live_vars.m, but this code was being invoked too late. This diff modifies live_vars.m to allow it to be invoked both by the stack slot optimization transformation and by the code generator, and allows its function to be tailored to the requirements of each invocation. The information computed by live_vars.m is specific to the LLDS back end, since the MLDS back ends do not (yet) have the same control over stack frame layout. We therefore store this information in a new back end specific field in goal_infos. For uniformity, we make all the other existing back end specific fields in goal_infos, as well as the similarly back end specific store map field of goal_exprs, subfields of this new field. This happens to significantly reduce the sizes of goal_infos. To allow a more meaningful comparison of the gains produced by the new optimization, do not save any variables across erroneous calls even if the new optimization is not enabled. compiler/stack_opt.m: New module containing the code that performs the transformation to optimize stack slot usage. compiler/matching.m: New module containing an algorithm for maximal matching in bipartite graphs, specialized for the graphs needed by stack_opt.m. compiler/mercury_compile.m: Invoke the new optimization if the options ask for it. compiler/stack_alloc.m: New module containing code that is shared between the old, non-optimizing stack slot allocation system and the new, optimizing stack slot allocation system, and the code for actually allocating stack slots in the absence of optimization. Live_vars.m used to have two tasks: find out what variables need to be saved on the stack, and allocating those variables to stack slots. Live_vars.m now does only the first task; stack_alloc.m now does the second, using code that used to be in live_vars.m. compiler/trace_params: Add a new function to test the trace level, which returns yes if we want to preserve the values of the input headvars. compiler/notes/compiler_design.html: Document the new modules (as well as trace_params.m, which wasn't documented earlier). compiler/live_vars.m: Delete the code that is now in stack_alloc.m and graph_colour.m. Separate out the kinds of stack uses due to nondeterminism: the stack slots used by nondet calls, and the stack slots used by resumption points, in order to allow the reuse of stack slots used by resumption points after execution has left their scope. This should allow the same stack slots to be used by different variables in the resumption point at the start of an else branch and nondet calls in the then branch, since the resumption point of the else branch is not in effect when the then branch is executed. If the new option --opt-no-return-calls is set, then say that we do not need to save any values across erroneous calls. Use type classes to allow the information generated by this module to be recorded in the way required by its invoker. Package up the data structures being passed around readonly into a single tuple. compiler/store_alloc.m: Allow this module to be invoked by stack_opt.m without invoking the follow_vars transformation, since applying follow_vars before the form of the HLDS code is otherwise final can be a pessimization. Make the module_info a part of the record containing the readonly data passed around during the traversal. compiler/common.m: Do not delete or move around unifications created by stack_opt.m. compiler/call_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/var_locn.m: Allow the code generator to delete its last record of the location of a value when generating code to make an erroneous call, if the new --opt-no-return-calls option is set. compiler/code_gen.m: Use a more useful algorithm to create the messages/comments that we put into incr_sp instructions, e.g. by distinguishing between predicates and functions. This is to allow the new scripts in the tool directory to gather statistics about the effect of the optimization on stack frame sizes. library/exception.m: Make a hand-written incr_sp follow the new pattern. compiler/arg_info.m: Add predicates to figure out the set of input, output and unused arguments of a procedure in several different circumstances. Previously, variants of these predicates were repeated in several places. compiler/goal_util.m: Export some previously private utility predicates. compiler/handle_options.m: Turn off stack slot optimizations when debugging, unless --trace-optimized is set. Add a new dump format useful for debugging --optimize-saved-vars. compiler/hlds_llds.m: New module for handling all the stuff specific to the LLDS back end in HLDS goal_infos. compiler/hlds_goal.m: Move all the relevant stuff into the new back end specific field in goal_infos. compiler/notes/allocation.html: Update the documentation of store maps to reflect their movement into a subfield of goal_infos. compiler/*.m: Minor changes to accomodate the placement of all back end specific information about goals from goal_exprs and individual fields of goal_infos into a new field in goal_infos that gathers together all back end specific information. compiler/use_local_vars.m: Look for sequences in which several instructions use a fake register or stack slot as a base register pointing to a cell, and make those instructions use a local variable instead. Without this, a key assumption of the stack slot optimization, that accessing a field in a cell costs only one load or store instruction, would be much less likely to be true. (With this optimization, the assumption will be false only if the C compiler's code generator runs out of registers in a basic block, which for the code we generate should be unlikely even on x86s.) compiler/options.m: Make the old option --optimize-saved-vars ask for both the old stack slot optimization (implemented by saved_vars.m) that only eliminates the storing of constants in stack slots, and the new optimization. Add two new options --optimize-saved-vars-{const,cell} to turn on the two optimizations separately. Add a bunch of options to specify the parameters of the new optimizations, both in stack_opt.m and use_local_vars.m. These are for implementors only; they are deliberately not documented. Add a new option, --opt-no-return-cells, that governs whether we avoid saving variables on the stack at calls that cannot return, either by succeeding or by failing. This is for implementors only, and thus deliberately documented only in comments. It is enabled by default. compiler/optimize.m: Transmit the value of a new option to use_local_vars.m. doc/user_guide.texi: Update the documentation of --optimize-saved-vars. library/tree234.m: Undo a previous change of mine that effectively applied this optimization by hand. That change complicated the code, and now the compiler can do the optimization automatically. tools/extract_incr_sp: A new script for extracting stack frame sizes and messages from stack increment operations in the C code for LLDS grades. tools/frame_sizes: A new script that uses extract_incr_sp to extract information about stack frame sizes from the C files saved from a stage 2 directory by makebatch and summarizes the resulting information. tools/avg_frame_size: A new script that computes average stack frame sizes from the files created by frame_sizes. tools/compare_frame_sizes: A new script that compares the stack frame size information extracted from two different stage 2 directories by frame_sizes, reporting on both average stack frame sizes and on specific procedures that have different stack frame sizes in the two versions.	2002-03-28 03:44:41 +00:00
Fergus Henderson	7597790760	Use sub-modules to structure the modules in the Mercury compiler directory. ... The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c.	2002-03-20 12:37:56 +00:00
Adrian Pellas-Rice	1c65d003f7	Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. ... Estimated hours taken: 4.5 Branches: main Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. compiler/hlds_goal.m Create a new type, the `shorthand_goal_expr', for goals kinds that are implemented by a (ordinary_hlds + shorthand) -> (ordinary_hlds) transformation. At present, bi_implication is the only kind of of goal that is implemented in this way. Moved bi_implication functor from the type goal_expr to the new shorthand_goal_expr type. Added the functor shorthand to the goal_expr type. compiler/*.m Change switches on hlds_goal_expr that call error when they recognise `bi_implication' from calling error when they recognise `bi_implication' to calling error when they recognise `shorthand'. For all predicates K that a) switch on hlds_goal_expr and b) perform non-trivial processing when they recognise `bi_implication' change K such that it now calls K_shorthand upon recognising the functor `shorthand'. Define K_shorthand to switch on shorthand_goal_expr, where the code for the `bi_implication' case formerly contained in K is now contained in K_shorthand.	2001-04-07 14:05:03 +00:00
Tyson Dowd	711da78188	Rename foreign_code as foreign_proc where appropriate in the compiler. ... Estimated hours taken: 4.0 Branches: main Rename foreign_code as foreign_proc where appropriate in the compiler. The rationale for this change is that it makes maintaining the code much simpler because it is clear whether `foreign' refers to a slab of code (foreign_code) or a procedure (foreign_proc). :- type pragma_foreign_code_attributes :- type pragma_foreign_proc_attributes The functors for pragma_type foreign(Lang, BodyCode) foreign(Attributes, Name, PredOrFunc, Vars, Varset, Impl) become foreign_code(Lang, BodyCode) foreign_proc(Attributes, Name, PredOrFunc, Vars, Varset, Impl) And the HLDS goal `pragma_foreign_code' becomes `foreign_proc'. compiler/*.m: Update the compiler to use the new names.	2001-04-03 03:20:33 +00:00
Zoltan Somogyi	639dd4943c	Put back the earlier clarification of cse_detection code, but without ... Estimated hours taken: 16 compiler/cse_detection.m: Put back the earlier clarification of cse_detection code, but without the bug this time :-( The bug was that cse_detection did not insist on all branches of the branched control structure containing a copy of the "common" deconstruction unification. By hoisting that unification before the branched control structure, cse_detection was effectively adding a test into some computation paths. Fix common subexpression elimination so that it works when the deconstruction it hoists out of a branched control structure involves a functor with existentially typed arguments. compiler/switch_detection.m: Modify the code called by cse_detection to look for deconstruction unifications to make it explicit whether the search was successful. compiler/options.m: Put the default value of --compare-specialization back to 4, now that the bug that prevented it from working at levels above 1 (in the presence of existentially typed arguments) has been fixed.	2000-12-08 06:50:17 +00:00
Fergus Henderson	64886eff13	Back out Zoltan's recent change, since I think it broke the ... Estimated hours taken: 0.5 compiler/cse_detection.m: Back out Zoltan's recent change, since I think it broke the compiler -- the symptom is that the stage 2 compiler was reporting spurious mode errors when building the stage 3 compiler.	2000-12-06 16:48:24 +00:00
Zoltan Somogyi	30a7319d32	Make the code for finding common subexpressions significantly clearer ... Estimated hours taken: 4 compiler/cse_detection.m: Make the code for finding common subexpressions significantly clearer by using a single type for each possible state of the search, instead of dividing the state between a maybe and a bool. Instead of passing around several data structures separately, wrap them up in a cse_info data structure. Extend the cse_info data structure with fields that will be required to fix common subexpression elimination over existentially typed functors. Switch to using predmode declarations when appropriate. compiler/switch_detection.m: Remove some redundancy from a comment.	2000-12-05 02:03:45 +00:00
Tyson Dowd	477ecb18f6	Implement pragma foreign_code for Managed C++. ... Estimated hours taken: 60 Implement pragma foreign_code for Managed C++. Currently you can only write MC++ code if your backend is capable of generating use MC++ as its "native" foreign language. The IL backend is the only backend that does this at the moment (the other backends have C as their "native" foreign language). Most of the machinery is in place to call from C to (normal) C++ but there is little work done on actually spitting out the C++ code into a separate file. The IL backend does this step already with managed C++. The intention is to turn foreign_code for C++ into a pragma import (which imports the C++ function from a separate file) and foreign_code for C (which calls the imported function). The C++ code will be inserted into a separate file that is compiled using C linkage. The important improvement this change gives is that you can write a module with a C and a MC++ implementations side-by-side. The target backend will select the most appropriate foreign language to use. You can override its choice using --use-foreign-language. Later on we will probably want more flexibility than just a single language selection option). This change also implements :- pragma foreign_decl, which allows header file style declarations to be written in languages other than C. compiler/code_gen.m: Reject code that is not C when generating LLDS. compiler/export.m: Start renaming C as foreign. Reject code that is not C when generating exports. compiler/foreign.m: A new module to handle foreign language interfacing. The bulk of the code for pragma import has been moved here from make_hlds. compiler/globals.m: Convert foreign language names to foreign_language. This code has been moved closer to the similar conversion we do for target language names. Add globals__io_lookup_foreign_language_option to make it easier to deterministically lookup the options relating to foreign languages. compiler/hlds_module.m: Move module_add_foreign_decl and module_add_foreign_body_code from make_hlds.m (where they were called module_add_c_header and module_add_c_code). compiler/hlds_out.m: Write the foreign language out in HLDS dumps. compiler/llds.m: Change foreign_header_info to foreign_decl_info. Change definitions of foreign_decl_code and foreign_body_code to include the language. compiler/llds_out.m: Reject code that is not C when writing out LLDS. compiler/make_hlds.m: Add foreign language information to the bodys and decls when creating them. Update error messages to refer to foreign code instead of C code. Use foreign.m to generate interfaces from the backend language to the foreign language. Hardcode C as the language for fact tables. compiler/mercury_compile.m: Collect the appropriate foreign language code together for output to the backend. compiler/intermod.m: compiler/mercury_to_mercury.m: Output the foreign language string. Change a few names to foreign_code instead of c_code. compiler/ml_code_gen.m: Filter the foreign language bodys and decls so that we only get the ones we are in (given by the use-foreign-language option). compiler/mlds_to_c.m: Abort if we are given non C foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/mlds_to_ilasm.m: Abort if we are given non MC++ foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/options.m: compiler/handle_options.m: Add --use-foreign-language as a user option to control the preferred foreign language to use as the implementation of this module. Add backend_foreign_language as an internal option which stores the foreign language that the compiler will use as a default (e.g. the natural foreign language for the backend to use). Set the preferred backend foreign language depending on the target. compiler/prog_data.m: Add managedcplusplus as a new alternative for the foreign_language type. Make c_header_code into foreign_decl. Give the foreign language for foreign_code as an attribute of the code. Write code to turn attributes into a list of strings (suitable for writing out by mercury_to_mercury). This fixes what appears to be a bug in tabled_for_io -- the tabled_for_io attribute was not being written out. Structure the code so this bug is difficult to repeat in future. compiler/prog_io_pragma.m: Parse foreign_decl. Turn c_header_code into a special case of foreign_decl. compiler/*.m: Remove the language field from pragma_foreign_code, it is now an attribute of the code. Various type and variable renamings. tests/invalid/pragma_c_code_and_clauses1.err_exp: tests/invalid/pragma_c_code_dup_var.err_exp: tests/warnings/singleton_test.exp: Update the tests to reflect the new error messages talking about :- pragma foreign_code rather than :- pragma c_code.	2000-11-17 17:48:52 +00:00
Peter Ross	35d1d914e7	Update the MLDS backend to handle structure reuse and compile time gc. ... Estimated hours taken: 20 Update the MLDS backend to handle structure reuse and compile time gc. Note that currently no pass on the main branch currently generates this information yet. mlds.m: Add a new instruction delete_object which is to be inserted whenever a lval can be compile time garbage collected. ml_unify_gen.m: Handle the case where the HowToConstruct field of a construction is reuse_cell(_). Handle the case where a deconstruction can be compile time gc'd. hlds_goal.m: Add a new field, can_cgc, to deconstruction unifications. This field is `yes' if the deconstruction unification can be compile time garbage collected. hlds_out.m: Output the can_cgc field. Output unification information if we request the structure reuse information. ml_elim_nested.m: mlds_to_c.m: Handle the delete_object instruction. builtin_ops.m: Fix a bug where body was an unary op instead of a binary op. bytecode.m: c_util.m: llds.m: opt_debug.m: vn_cost.m: Changes to reflect that body is a binary op. bytecode_gen.m: code_aux.m: common.m: cse_detection.m: dependency_graph.m: det_analysis.m: goal_util.m: higher_order.m: mark_static_terms.m: mode_util.m: modecheck_unify.m: pd_cost.m: pd_util.m: prog_rep.m: rl_exprn.m: rl_key.m: simplify.m: switch_detection.m: term_traversal.m: unify_gen.m: unused_args.m: Handle the can compile time gc field in deconstruction unifications.	2000-10-06 10:18:39 +00:00
Zoltan Somogyi	10a433374b	Restore the clipping of instmap deltas to the nonlocals set, undoing most of ... Estimated hours taken: 16 Restore the clipping of instmap deltas to the nonlocals set, undoing most of a recent change of mine. (The general cleanup parts of that change, e.g. added field names, stay.) The reason is that the previous diff changed the clipping algorithm only where the instmap deltas were being originally computed, whereas for completeness you also need to do this in places where they are recomputed after optimizations such as deforestation, and doing so would have required changes in several more parts of the compiler, which would have been tedious to maintain. Instead, I now use a different technique to solve the original problem. This technique is to change liveness.m so that it considers the first occurrence of any type(class)info variable to be a value giving occurrence even if the variable is not referred to by the instmap delta of the goal. This assumption is true in the current polymorphism design and in any extension of it that I can foresee. Type(class)info variables will therefore be born in the first goal that refers to them, even if they are not in the nonlocal set of that goal. If there are any later references to variables whose type is described in whole or in part by that typeinfo, the typeinfo will die at the last such reference, otherwise it will die in the goal in which it is born. From now on, the only module of the compile which needs to worry about the extension of the life of type(class)info variables beyond the goals referring to them is liveness.m. compiler/quantification.m: compiler/mode_info.m: compiler/mode_util.m: Reset the interfaces of quantification and mode checking to the old ones, which do not require knowing typeinfo_liveness and typeinfo varmaps. compiler/modes.m: compiler/unique_modes.m: Clip instmap deltas to the nonlocals, not the completed nonlocals. compiler/hlds_goal.m: Add a utility pred which gets the nonlocals from a goal, not a goal_info. compiler/liveness.m: Add special handling for type(class)info vars as described above. compiler/accumulator.m: compiler/cse_detection.m: compiler/deforest.m: compiler/follow_code.m: compiler/higher_order.m: compiler/lambda.m: compiler/magic.m: compiler/make_hlds.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/saved_vars.m: compiler/simplify.m: compiler/unify_proc.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Use the reset interfaces of quantification and mode checking, and eliminate redundant local copies of goal_get_nonlocals.	2000-09-16 00:08:31 +00:00
Tyson Dowd	c192d50143	Add preliminary support for a new pragma: ... Estimated hours taken: 15 Add preliminary support for a new pragma: :- pragma foreign_code(LanguageString, .... <same args as c_code>). This is intended to be the eventual replacement of pragma c_code. Presently the only valid language is "C". The existing pragma c_code is simply turned into pragma foreign_code. pragma foreign_code is not a supported pragma at the moment. There are several other changes that are intended (for example, foreign_code will be impure by default). This change also changes the HLDS goal pragma_c_code/7 to pragma_foreign_code/8 where the extra argument is the foreign language. Any code currently generating output for pragma C code simply checks that the foreign language is set to "c". Since this is the only alternative of the type foreign_language, it will always succeed. However when new alternatives are added it should be fairly easy to find where the changes need to be made. Some type names and predicate names have also been updated, however there are many more that haven't yet been touched. compiler/prog_io_pragma.m: Accept the new syntax. Turn the old syntax into the new item. compiler/hlds_goal.m: Change pragma_c_code/7 to pragma_foreign_code/8. Define the foreign_language type. compiler/llds.m: Change user_c_code/2 to user_foreign_code/3. compiler/*.m: Update the rest of the compiler to handle these types. Make a few small changes to update variable names, predicate names and type names.	2000-08-09 07:48:04 +00:00
Zoltan Somogyi	891b89e650	Make sure that all parts of the compiler use a consistent idea of which ... Estimated hours taken: 4 Make sure that all parts of the compiler use a consistent idea of which predicates should have typeinfo liveness applied to their bodies when the relevant option is set. This set is all predicates except the few in the builtin modules which do not have the required arguments. compiler/hlds_pred.m: Expand the interface of the should_use_typeinfo_liveness family of predicates to include an id of the predicate in question, to enable them to test whether the pred is a no_type_info_builtin. compiler/hlds_pred.m: compiler/polymorphism.m: Move the list of no_type_info_builtins from polymorphism to hlds_pred, since body_should_use_typeinfo_liveness also needs it now. compiler/*.m: Minor changes to pass the right arguments to predicates of the should_use_typeinfo_liveness family, directly or indirectly.	2000-08-08 04:44:54 +00:00
Zoltan Somogyi	a0a6daa06f	If we are using typeinfo liveness, then clip the instmap delta fields in ... Estimated hours taken: 16 If we are using typeinfo liveness, then clip the instmap delta fields in goal_infos not to the nonlocals, but to the nonlocals plus the type info or typeclass info variables needed to describe the types of the nonlocals (this set is now called the "typeinfo completed nonlocals"). This is necessary for the proper handling of code such as resume_typeinfos.m in tests/debugger. This involves a call to a procedure with an existentially typed argument, where the returned argument is processed only in ways that do not need the typeinfo describing it. The compiler therefore considered the typeinfo to be local to the call binding it. Its binding was therefore not recorded in the instmap delta, which in turn meant that in the absence of a value-giving occurrence, liveness.m considered it not to be born anywhere. On the other hand, with typeinfo liveness, occurrences of the argument are also considered value-using occurrences of the typeinfo, so the typeinfo was considered to die at the last such occurrence. Therefore the typeinfo died without being born. The current code generator is sloppy enough not to mind this, but the upcoming eager code generator isn't. compiler/hlds_goal.m: Document the new semantics of instmap_deltas. compiler/quantification.m: compiler/mode_util.m: compiler/modes.m: compiler/unique_modes.m: If typeinfo liveness is set, include the relevant typeinfo variables in the set of variables the instmap is limited to. compiler/modes.m: Delete some unused predicates. compiler/hlds_pred.m: Centralize the code for (maybe) completing a set of vars with the set of typeinfo vars describing their types here. compiler/call_gen.m: compiler/live_vars.m: Use the central code in hlds_pred.m. compiler/accumulator.m: compiler/cse_detection.m: compiler/follow_code.m: compiler/higher_order.m: compiler/lambda.m: compiler/liveness.m: compiler/magic.m: compiler/make_hlds.m: compiler/mode_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/simplify.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Call quantification and/or mode_util with the right arguments. In some cases, introduce field names, predmode declarations and/or shorter type names to make this change easier.	2000-08-03 08:46:44 +00:00