76 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	5f50259d16	Write to explicitly named streams in many modules. ... Right now, most parts of the compiler write to the "current output stream". This was a pragmatic choice at the time, but has not aged well. The problem is that the answer to the question "where is the current output stream going?" is not obvious in *all* places in the compiler (although it is obvious in most). When using such implicit streams, finding where the output is going to in a given predicate requires inspecting not just the ancestors of that predicate, but also all their older siblings (since any of them could have changed the current stream), *including* their entire call trees. This is usually an infeasible task. By constrast, if we explicitly pass streams to all output operations, we need only follow the places where the variable representing that stream is bound, which the mode system makes easy. This diff switches large parts of the compiler over to doing output only to explicitly passed streams, never to the implicit "current output stream". The parts it switches over are the parts that rely to a significant degree on the innermost change, which is to the "output" typeclass in parse_tree_out_info.m. This is the part that has to be switched over to explicit streams first, because (a) many modules such as mercury_to_mercury.m rely on the output typeclass, and (b) most other modules that do output call predicates in these modules. Starting anywhere else would be like building a skyscraper starting at the top. This typeclass, output(U), has two instances: output(io), and output(string), so you could output either to the current output stream, or to a string. To allow the specification of the destination stream in the first case, this diff changes the typeclass to output(S, U) with a functional dependency from U to S, with the two instances being output(io.text_output_stream, io) and output(unit, string). (The unit arg is ignored in the second case.) There is a complication with the output typeclass method, add_list, that outputs a list of items. The complication is that each item is output by a predicate supplied by the caller, but the separator between the items (usually a comma) is output by add_list itself. We don't want to give callers of this method the opportunity to screw up by specifying (possibly implicitly) two different output streams for these two purposes, so we want (a) the caller to tell add_list where to put the separators, and then (b) for add_list, not its caller, tell the user-supplied predicate what stream to write to. This works only if the stream argument is just before the di,uo pair of I/O state arguments, which differs from our usual practice of passing the stream at or near the left edge of the argument list, not near the right. The result of this complication is that two categories of predicates that are and are not used to print items in a list differ in where they put the stream in their argument lists. This makes it easy to pass the stream in the wrong argument position if you call a predicate without looking up its signature, and may require *changing* the argument order when a predicate is used to print an item in a list for the first time. A complete switch over to always passing the stream just before !IO would fix this inconsistency, but is far to big a change to make all at once. compiler/parse_tree_out_info.m: Make the changes described above. Add write_out_list, which is a variant of io.write_list specifically designed to address the "complication" described above. It also has the arguments in an order that is better suited for higher-order use. Make the same change to argument order in the class method add_list as well. Almost all of the following changes consist of passing an extra stream argument to output predicates. In some places, where I thought this would aid readability, I replaced sequences of calls to output predicates with a single io.format. compiler/prog_out.m: This module had many predicates that wrote things to the current output stream. This diff adds versions of these predicates that take an explicit stream argument. If the originals are still needed after the changes to the other modules, keep them, but add "_to_cur_stream" to the end of their names. Otherwise, delete them. (Many of the changes below replace write_xyz(..., !IO) with io.write_string(Stream, xyz_to_string(...), !IO), especially when write_xyz did nothing except call xyz_to_string and wrote out the result.) compiler/c_util.m: Add either an explicit stream argument to the argument list, or a "_current_stream" suffix to the name, of every predicate defined in this module that does output. Add a new predicate to print out the block comment containing input for mkinit. This factors out common code in the LLDS and MLDS backends. compiler/name_mangle.m: Delete all predicates that used to write to the current output stream, after replacing them if necessary with functions that return a string, which the caller can print to wherever it wants. (The "if necessary" part is there because some of the "replacement" functions already existed.) When converting a proc_label to a string, *always* require the caller to say whether the label prefix should be added to the string, instead of silently assuming "yes, add it", as calls to one of the old, now deleted predicates had it. compiler/file_util.m: Add output_to_file_stream, a version of output_to_file which simply passes the output file stream it opens to the predicate that is intended to define the contents of the newly created or updated file. The existing output_to_file, which instead sets and resets the current output stream around the equivalent predicate call, is still needed e.g. by the MLDS backend, but hopefully for not too long. compiler/mercury_to_mercury.m: compiler/parse_tree_out.m: compiler/parse_tree_out_clause.m: compiler/parse_tree_out_inst.m: compiler/parse_tree_out_pragma.m: compiler/parse_tree_out_pred_decl.m: compiler/parse_tree_out_term.m: compiler/parse_tree_out_type_repn.m: Change the code writing out parse trees to explicitly pass a stream to every predicate that does output. In some places, this allows us to avoid changing the identity of the current output stream. compiler/hlds_out.m: compiler/hlds_out_goal.m: compiler/hlds_out_mode.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_out_util.m: compiler/intermod.m: Change the code writing out HLDS code to explicitly pass a stream to every predicate that does output. (The changes to these modules belong in this diff because these modules call many of the output predicates in the parse tree package.) In hlds_out_util.m, delete some write_to_xyz(...) predicates that wrote the result of xyz_to_string(...) to the current output stream. Replace calls to the deleted predicates with calls to io.write_string with the string being written being computed by xyz_to_string. Add a predicate to hlds_out_util.m that outputs a comment containing the current context, if it is valid. This factors out code that used to be common to several of the other modules. In a few places in hlds_out_module.m, the new code generates a slighly different set of blank lines, but this should not be a problem. compiler/layout_out.m: compiler/llds_out_code_addr.m: compiler/llds_out_data.m: compiler/llds_out_file.m: compiler/llds_out_global.m: compiler/llds_out_instr.m: compiler/llds_out_util.m: compiler/opt_debug.m: compiler/rtti_out.m: Change the code writing out the LLDS to explicitly pass a stream to every predicate that does output. (The changes to these modules belong in this diff because layout_out.m and rtti_out.m call many of the output predicates in the parse tree package, and through them, the rest of the LLDS backend is affected as well.) compiler/make.module_dep_file.m: compiler/mercury_compile_main.m: compiler/mercury_compile_middle_passes.m: Replace code that sets and resets the current output stream with code that simply passes an explicit output stream to a predicate that now *takes* an explicit stream as an argument. compiler/accumulator.m: compiler/add_clause.m: compiler/code_gen.m: compiler/code_loc_dep.m: compiler/cse_detection.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/error_msg_inst.m: compiler/export.m: compiler/format_call.m: compiler/goal_expr_to_goal.m: compiler/ite_gen.m: compiler/lco.m: compiler/liveness.m: compiler/lp_rational.m: compiler/mercury_compile_front_end.m: compiler/mercury_compile_llds_back_end.m: compiler/mlds_to_c_file.m: compiler/mlds_to_c_global.m: compiler/mode_debug.m: compiler/mode_errors.m: compiler/modes.m: compiler/optimize.m: compiler/passes_aux.m: compiler/pd_debug.m: compiler/pragma_c_gen.m: compiler/proc_gen.m: compiler/prog_ctgc.m: compiler/push_goals_together.m: compiler/rat.m: compiler/recompilation.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/rtti.m: compiler/saved_vars.m: compiler/simplify_goal_conj.m: compiler/stack_opt.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.domain.m: compiler/structure_reuse.indirect.m: compiler/structure_sharing.analysis.m: compiler/superhomogeneous.m: compiler/term_constr_build.m: compiler/term_constr_data.m: compiler/term_constr_fixpoint.m: compiler/term_constr_pass2.m: compiler/term_constr_util.m: compiler/tupling.m: compiler/type_assign.m: compiler/unneeded_code.m: compiler/write_deps_file.m: Conform to the changes above, mostly by passing streams explicitly. compiler/hlds_dependency_graph.m: Conform to the changes above, mostly by passing streams explicitly. Move a predicate's definition next it only use. compiler/Mercury.options: Specify --warn-implicit-stream-calls for all the modules in which this diff has replaced all implicit streams with explicit streams. (Unfortunately, debugging this diff has shown that --warn-implicit- stream-calls detects only *some*, and not *all*, uses of implicit streams.) library/term_io.m: Fix documentation.	2020-11-14 15:07:55 +11:00
Zoltan Somogyi	181ada0dbf	Avoid -O<n> resetting previously set options. ... This implements Mantis feature request #495. NEWS: Announce the change. compiler/optimization_options.m: A new module for managing optimization options. It defines a separate bespoke type for every boolean optimization option to make it harder to confuse them. It defines a tuple type (opt_tuple) for accessing optimization options quickly. It implements the turning on (but NOT turning off) of optimizations when a given optimization level is selected. tools/make_optimization_options_middle: tools/make_optimization_options_db: The script that generates the meat of optimization_options.m, and the database of option names, kinds and initial values that it uses as its input. The script also generates some code for the special_handler predicate in compiler/options.m. tools/make_optimization_options_start: tools/make_optimization_options_end: The handwritten initial and final parts of optimization_options.m. tools/make_optimization_options: The script that pulls these parts together to form optimization_options.m. compiler/options.m: Make every optimization option a special option, to be handled by the special_handler predicate. That handling consists of simply adding a representation of the option to the end of a cord of optimization options, to be processed later by optimization_options.m. That processing will record the values of these options in the opt_tuple, which is where every other part of the compiler should get them from. Change the interface of special_handler to make the above possible. Add an "optopt_" (optimization option) prefix to the name of every optimization option, to make them inaccessible to the rest of the compiler under their old name, and thus help enforce the switch to using the opt_tuple. Any access to these options to look up their values would fail anyway, since the option data would no longer be e.g. bool(yes), but bool_special, but the name change makes this failure happen at compile time, not runtime. Reclassify a few options to make the above make sense. Some options (unneeded_code_debug, unneeded_code_debug_pred_name, and common_struct_preds) were classified as oc_opt even though they control only the *debugging* of optimizations, while some options (c_optimize and inline_alloc) were not classified as oc_opt even though we do set them automatically at some optimization levels. Delete the opt_level_number option, since it was not used anywhere. Delete the code for handling -ON and --opt-space, since that is now done in optimization_options.m. Add some XXXs. compiler/handle_options.m: Switch to using getopt_io.process_options_userdata_se, as required by the new interface of the special_handler in options.m. In the absence of errors, invoke optimization_options.m to initialize the opt_tuple. Then update the opt_tuple incrementally when processing option implications that affect optimization options. compiler/globals.m: Put the opt_tuple into a new field of the globals structure. compiler/accumulator.m: compiler/add_pragma_type_spec.m: compiler/add_trail_ops.m: compiler/code_info.m: compiler/code_loc_dep.m: compiler/compile_target_code.m: compiler/const_struct.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/disj_gen.m: compiler/erl_code_gen.m: compiler/format_call.m: compiler/global_data.m: compiler/grab_modules.m: compiler/higher_order.m: compiler/hlds_pred.m: compiler/inlining.m: compiler/intermod.m: compiler/ite_gen.m: compiler/jumpopt.m: compiler/libs.m: compiler/llds_out_code_addr.m: compiler/llds_out_data.m: compiler/llds_out_file.m: compiler/llds_out_instr.m: compiler/llds_out_util.m: compiler/matching.m: compiler/mercury_compile_front_end.m: compiler/mercury_compile_llds_back_end.m: compiler/mercury_compile_main.m: compiler/mercury_compile_middle_passes.m: compiler/mercury_compile_mlds_back_end.m: compiler/ml_disj_gen.m: compiler/ml_gen_info.m: compiler/ml_lookup_switch.m: compiler/ml_optimize.m: compiler/ml_proc_gen.m: compiler/ml_simplify_switch.m: compiler/ml_switch_gen.m: compiler/ml_unify_gen_construct.m: compiler/optimize.m: compiler/pd_util.m: compiler/peephole.m: compiler/polymorphism.m: compiler/proc_gen.m: compiler/simplify_goal_call.m: compiler/simplify_goal_scope.m: compiler/simplify_info.m: compiler/simplify_proc.m: compiler/simplify_tasks.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/tag_switch.m: compiler/tupling.m: compiler/unify_gen_construct.m: compiler/unneeded_code.m: compiler/unused_args.m: Conform to the changes above, mostly by looking up optimization options in the opt_tuple. In some places, replace bools containing optimization options with the bespoke type of that specific optimization option. library/getopt_template: Fix a bug that screwed up an error message. The bug happened when processing a --file option. If one of the options in the file was a special option whose special handler failed, the code handling that failing option returned both an error indication, and the rest of the argument list read in from the file. The code handling the --file option then *ignored* the error indication from the failed special option, and returned an error message of its own complaining about the unconsumed remaining arguments in the file, believing them to be non-option arguments, even though these arguments were never looked it to see if they were options. The fix is for the code handling --flag options to check whether the code processing the file contents found any errors, and if so, return that error *without* looking at the list of remaining arguments. In an unrelated change, factor out a duplicate call.	2020-09-28 18:16:13 +10:00
Zoltan Somogyi	15aa457e12	Delete $module arg from calls to unexpected.	2018-04-07 18:25:43 +10:00
Zoltan Somogyi	8e6033f1f1	Avoid using a soon-to-be-deleted field. ... I intend to delete the field in du_type_repns that maps cons_ids to cons_tags. The information in that map is now present in the field that maps (the names of) cons_ids to not just the tag of that cons_id, but all the other representation information for that cons_id. (The duplicate storage of that information is just a transition arrangement.) compiler/hlds_code_util.m: compiler/modecheck_goal.m: compiler/stack_opt.m: Look up the tags of cons_ids using type_util.get_cons_repn_defn, which does the task the way it should be done in the future. compiler/type_util.m: Delete the type_ctor argument of get_cons_repn_defn{,_det}, since its value can always be determined from the value of the cons_id argument. compiler/ml_unify_gen.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/unify_gen.m: Conform to the change in type_util.m.	2018-02-03 16:26:43 +11:00
Zoltan Somogyi	fb97df69ed	Make "compute type representations" a separate pass. ... The ultimate purpose of this diff is to prepare for future improvements in type representations, allowing values of some data types to be represented more compactly than up to now. The main way this diff does that is by creating a separate pass for deciding how values of each type should be represented. We have traditionally decided data representations for each type as its type definition was processed during the make_hlds pass, but these decisions were always tentative, and could be overridden later, e.g. when we processed foreign_type or foreign_enum pragmas for the type. This dispersed decision making algorithm is hard to understand, and therefore to change. This diff centralizes decisions about type representations in a separate pass that does nothing else. It leaves the algorithm distributed among several files (du_type_layout.m, make_tags.m, and add_foreign_enum.m) for now, to make reviewing this diff easier, but soon after it is committed I intend to move all the relevant code to du_type_layout.m, to centralize the decision code in "space" as well as in time. For the reason why this pass runs before any of the semantic analysis passes, instead of after all of them as I originally intended and as we discussed on m-dev in late october 2017, see the big comment at the start of du_type_layout.m. As per another part of that same discussion on m-dev, this diff makes a start on implementing a new type of item, the type_repn item, which is intended *only* to be used in compiler-generated interface files, *not* in source files. It is only a start because we can use these items only *after* the creation of a separate type representation decision pass, and this diff is already very big. The code for making the compiler understand these items will be added later. The code for generating them will be added later still, once the code for understanding them has been installed on all our systems. Since I was going to be working on the affected code anyway, this diff also carries out two other decisions that came out of that discussion: - the deletion of the ability to reserve a tag in a type for HAL, either via a compiler option or via a pragma, and - the deletion of the ability to represent a functor using the address of a statically allocated object (which we haven't used and won't use, because it slows down accesses to *all the other functors* of the type). compiler/mercury_compile_front_end.m: Invoke the new pass for making decisions about type representations after the make_hlds pass. (We used to do only the final part of it then.) Fix a bad dump stage name. Add an extra check for what it means for a module to be error free. Make a sub-switch explicit. compiler/hlds.m: compiler/make_hlds.m: Move the modules that implement the new pass from the make_hlds package to the hlds package, to give the compiler's top level access to them. Make the same move for the modules that the new pass's modules need. Since they are now part of hlds, they cannot reach into make_hlds, and I think this is a cleaner solution than forwarding predicates. Delete some forwarding predicates that are no longer needed. compiler/notes/compiler_design.html: Document the updated location of the moved modules. Add an XXX to note a place where the documentation has not been updated in the past. compiler/du_type_layout.m: Add code to implement the new pass. Keep the algorithm for deciding type representations as close to the previously used algorithm as possible, since this diff is already big enough. (The previous algorithm was scattered across add_type.m, add_foreign_enum.m, and make_hlds_passes.m.) Simplifications and optimizations will come later, after this module is merged with make_tags.m and with (at least) the foreign_enum half of add_foreign_enum.m. compiler/make_tags.m: Keep the functionality of this module, which does both the first part of deciding type representations (tentatively assigning tags to functors, an assignment that may be overridden later), and the last part (packing multiple adjacent less-than-word-sized enum args into a single word, if possible.), but simplify it where possible, and note possibilities for further improvements. compiler/add_foreign_enum.m: This module has two halves, one dealing with foreign_enum pragmas and one dealing with foreign_export_enum pragmas. Change the half that deals with foreign_enum pragmas to just build a data structure that du_type_layout.m will need to make its decisions, this structure being a map from type_ctors to the foreign enum specification applicable to the current target language. Include in this structure a component that add_foreign_enum.m itself can use to report better error messages for duplicate foreign_enum pragmas; this component records, for each type_ctor and language, the context of the previous foreign_enum pragma for that combo. Change the input for the half that deals with foreign_export_enum pragmas to reflect the fact that it is invoked by du_type_layout.m after all decisions about type representations have already been made. compiler/add_special_pred.m: Move this module from the make_hlds package to the hlds package, since the code that adds special preds for type is now called from du_type_layout.m. Change the names of predicates to make clear whether they add only the declaration of a predicate, only its definition, or both. Don't try to pre-guess whether the implementation of a type's compare predicate will need an index predicate. Let the code that generates calls to the index predicate both declare and define the index predicate. This change removes the potential for inconsistencies between the two pieces of code. compiler/add_pred.m: Move this module from the make_hlds package to the hlds package, since add_special_pred.m needs access to it. compiler/add_type.m: When adding a type definition to the HLDS, don't try to decide its representation. Any such decision was tentative anyway, due to the possibility of e.g. the later processing of foreign_type or foreign_enum pragmas for the type. Likewise, don't try to create the special (unify, compare) predicates for the type. Leave both tasks to the du_type_layout pass. Likewise, don't try to pack the representation of types, or record no_tag types in the table of no_tag types, during the post-processing pass either; leave both of these to du_type_layout as well. Rename the predicate that post_processes type definitions to reflect the two tasks left for it to do. compiler/prog_data.m: Do not store width information about the arguments of those data constructors in the parse tree. That information is not computed until later; until then, it was always filled in with dummy values. (But see hlds_data.m below.) Use bespoke types to represent the presence or absence of user-specified unify and compare predicates. Change the representation of data constructors to use a single "maybe" type, not two lists, to denote the presence or absence of existentially typed arguments. Give the HLDS the ability to hold representation information about abstract types that in the future we will get from type_repn items in the defining modules' interface files. Delete the uses_reserved_tag type, since we never use reserved tags anymore. compiler/prog_item.m: Add the new type_repn item type, which is not used yet. Delete the reserve_tag pragma. Fix an earlier mistake in the wording of a context message. compiler/hlds_data.m: Put all the fields of hlds_du_type (the type definition variant dealing with discriminated union types) that deal with type representation issues in a single "maybe" field that is set to "no" before the type representation decision pass has been run. Add new type, constructor_repn, that stores the same information as the old constructor type (defined in prog_data.m), PLUS the information describing how terms with that data constructor are stored. Likewise, add a new type ctor_arg_rep, which likewise stores the widths of each constructor argument. When we implement argument reordering, we would store the offset of the arg as well. Since the parse tree representations of constructors and their arguments don't store representation information anymore, the cons_table they are stored in doesn't either. Make the lookup of representation information for a given constructor possible by adding a map to the new "maybe" field of hlds_du_type. Provide some utility predicates. Optimize some existing predicates. Rename some types to better reflect their meaning. compiler/hlds_module.m: Provide a slot in the module_info for storing the information gathered by make_hlds.m that is needed by the new pass. compiler/make_hlds_separate_items.m: When we see either a foreign_enum or a foreign_export_enum pragma, return values of a bespoke type for them (a type defined in hlds_module.m), instead of an item_pragma. This makes handling them considerably easier. compiler/make_hlds_passes.m: With the changes in this diff, adding a type to the HLDS won't decide its representation. Therefore delete the code that used to loop over foreign_export_enum pragmas; in the absence of the final type representation information, it won't work right. Record the information that the du_type_layout pass will need in the module_info. compiler/add_pragma.m: Delete the code for passing on foreign_enum and foreign_export_enum pragmas to add_foreign_enum.m; they are now passed to add_foreign_enum.m by du_type_layout.m. Move a utility predicate to make_hlds_error.m, to allow add_foreign_enum.m to call it. compiler/make_hlds_error.m: Add the utility predicate moved from add_pragma.m. Move the module from the make_hlds to the hlds package. compiler/module_qual.m: Provide a mechanism for recording error messages about e.g. undefined types without recording that we found an undefined type. This sounds strange, but there is a valid use case. When a type definition declares a functor's argument to be of an undefined type, that error is usually fatal; we stop the compiler from proceeding even to typechecking, since the typechecker will probably abort with a map lookup failure. Most other references to undefined types are similarly fatal for the same reason. However, if e.g. a foreign_export_enum pragma refers to an undefined type, that error *won't* be visible to the typechecker, and therefore won't crash it. The error will still cause the compiler to exit without generating any target language code, but at least it will be able to run the typechecker and other semantic analysis passes. Without this change, the compiler will report only one error in the ee_invalid.m test case; with it, it reports *every* error in the test case expected output. compiler/module_qual.qualify_items.m: Use the capability describe above for undefined types in foreign_export_enum pragmas. compiler/module_qual.qual_errors.m: Delete a (somewhat incorrect) copy of a predicate in prog_item.m, to reduce code duplication. compiler/prog_type.m: Add ways to represent abstract types whose representations are nevertheless known (from type_repn items in the defining modules' interface files) to be notag or dummy types. This will be needed to fix Mantis bug #441, a fix that will probably be one of the first later changes to build on this diff. Delete a type moved to type_util.m. compiler/type_util.m: Provide extra versions of some predicates, with the difference between the old and the new versions being that one requires type representations to have been decided already, and the other one does not. Move the definition of the ctor_defn type here from prog_type.m, since prog_type.m itself does not use it, but type_util.m does. Give some predicates more meaningful names. compiler/parse_type_defn.m: Simplify the code for parsing type definitions, to make it easier to reuse to parse type_repn items. Add a sanity check that requires existential constraints to have *some* existential variables to apply to. Allow "type_is_representable_in_n_bits" as a synonym for "type_is_abstract_enum", since in the future we want to be able to pack e.g. multiple int8s, not just multiple enums, into a single word. Generate more specific error messages for some classes of malformed input. compiler/parse_type_repn.m: New module to parse type_repn items. compiler/polymorphism.m: Make some predicates that operate on type constructors take the type constructors themselves as input arguments, not a whole type *using* that type constructor. Put the arguments of those predicates in a more standard order. Note that some predicates don't belong in this module. compiler/special_pred.m: Make the code that decides whether a special predicate for a type constructor can be defined lazily avoid using type representation information. (Actually, we now make decisions about lazy vs eager definitions after type representation is available, but that was not so in an earlier version of this change, and the new code is more robust.) compiler/unify_proc.m: When we decide to generate code for a compare predicate that needs the type to have an index predicate, don't presume that the index predicate has already been declared and defined; instead, declare and define it then and there. (Index predicates are *never* called from anywhere else.) Pack the information needed to define a special predicate into a single structure, to simplify the above. Since the creation of a clause for a compare predicate may now require the declaration and definition of an index predicate, the module_info field of the unify_proc_info is now a writeable field. Give some predicates and function symbols more meaningful names. Note some problems with the existing code. compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_mode.m: compiler/add_mutable_aux_preds.m: compiler/add_pragma_tabling.m: compiler/add_pragma_type_spec.m: compiler/add_solver.m: compiler/check_typeclass.m: compiler/code_info.m: compiler/comp_unit_interface.m: compiler/ctgc.selector.m: compiler/ctgc.util.m: compiler/default_func_mode.m: compiler/det_report.m: compiler/equiv_type.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/export.m: compiler/foreign.m: compiler/get_dependencies.m: compiler/goal_expr_to_goal.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_out_module.m: compiler/inst_check.m: compiler/inst_test.m: compiler/inst_util.m: compiler/intermod.m: compiler/item_util.m: compiler/make_hlds_warn.m: compiler/ml_accurate_gc.m: compiler/ml_simplify_switch.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_cs.m: compiler/mlds_to_java.m: compiler/mode_util.m: compiler/modecheck_goal.m: compiler/module_qual.collect_mq_info.m: compiler/modules.m: compiler/parse_item.m: compiler/parse_pragma.m: compiler/parse_tree.m: compiler/parse_tree_out.m: compiler/parse_tree_out_pragma.m: compiler/post_term_analysis.m: compiler/proc_requests.m: compiler/prog_item_stats.m: compiler/qual_info.m: compiler/recompilation.check.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/resolve_unify_functor.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/simplify_goal_ite.m: compiler/stack_opt.m: compiler/state_var.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/superhomogeneous.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/trailing_analysis.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/typecheck.m: compiler/unify_gen.m: compiler/untupling.m: compiler/unused_imports.m: compiler/write_module_interface_files.m: compiler/xml_documentation.m: Conform to the changes above. tests/invalid/Mmakefile: Disable the reserve_tag test case, as it is not applicable anymore. tests/invalid/exported_foreign_enum.{m,err_exp}: tests/invalid/pragma_qual_error.{m,err_exp}: Delete reserve_tag pragmas from these test cases, and its effects from the expected outputs. tests/invalid/bad_foreign_type.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/foreign_enum_invalid.err_exp: tests/invalid/type_lhs_var.err_exp: tests/invalid/uu_type.err_exp: tests/invalid/where_abstract_enum.err_exp: tests/invalid/where_direct_arg.err_exp: Expect the updated messages for some errors. tests/valid/Mmake.valid.common: tests/valid/Mmakefile: Disable any reserve_tag test cases, as they are not applicable anymore.	2018-01-31 17:54:40 +11:00
Zoltan Somogyi	cb4158fa71	Make initial_liveness a bit faster. ... compiler/liveness.m: Instead of looking up the pred_info for the procedure being processed, get our caller to give it to us. Put the arguments of some predicates in a more logical order. compiler/stack_alloc.m: compiler/stack_opt.m: compiler/store_alloc.m: compiler/tupling.m: Pass the pred_info instead of a pred_id to initial_liveness. In all these callers, the pred_info was already available.	2015-11-15 16:52:14 +11:00
Zoltan Somogyi	cc9912faa8	Don't import anything in packages. ... Packages are modules whose only job is to serve as a container for submodules. Modules like top_level.m, hlds.m, parse_tree.m and ll_backend.m are packages in this (informal) sense. Besides the include_module declarations for their submodules, most of the packages in the compiler used to import some modules, mostly other packages whose component modules their submodules may need. For example, ll_backend.m used to import parse_tree.m. This meant that modules in the ll_backend package did not have to import parse_tree.m before importing modules in the parse_tree package. However, this had a price. When we add a new module to the parse_tree package, parse_tree.int would change, and this would require the recompilation of ALL the modules in the ll_backend package, even the ones that did NOT import ANY of the modules in the parse_tree package. This happened even at one remove. Pretty much all modules in every one of the backend have to import one or more modules in the hlds package, and they therefore have import hlds.m. Since hlds.m imported transform_hlds.m, any addition of a new middle pass to the transform_hlds package required the recompilation of all backend modules, even in the usual case of the two having nothing to do with each other. This diff removes all import_module declarations from the packages, and replaces them with import_module declarations in the modules that need them. This includes only a SUBSET of their child modules and of the non-child modules that import them.	2015-11-13 15:03:20 +11:00
Zoltan Somogyi	a722eb0cf0	Convert (C->T;E) to (if C then T else E).	2015-10-05 23:07:38 +11:00
Zoltan Somogyi	bbb2535eb5	Break up mercury_to_mercury.m. ... With almost 6000 lines, mercury_to_mercury.m was one of the biggest modules of compiler, but it was far from cohesive. This diff carves seven new modules out of it, each of which is much more cohesive. The stuff remaining in mercury_to_mercury.m is still not as cohesive as one would like, but it is now small enough that moving its individually-cohesive parts into modules of their own would be overkill. Three consequences of the old mercury_to_mercury.m's lack of cohesion were that - the order of predicate declarations often did not match the order of their implementation; - related predicates were not grouped together; - even when they were grouped together, the order of those groups was often random. This diff fixes all three of these problems for all eight successor modules of mercury_to_mercury.m: the seven new modules, and the new mercury_to_mercury.m itself. In some cases, this diff adds or improves the documentation of the predicates in mercury_to_mercury.m's successor modules. In some other cases, it just documents the lack of documentation :-(. In yet other cases, it removes "documentation" that says nothing that isn't obvious from the predicate's name. There are some algorithmic changes, but they are all trivial. compiler/parse_tree_out.m: New module containing the code to print out the top levels of parse trees, including most sorts of items. compiler/parse_tree_out_clause.m: New module containing the code to print out clauses and goals. compiler/parse_tree_out_pragma.m: New module containing the code to print out pragmas. compiler/parse_tree_out_pred_decl.m: New module containing the code to print out predicate, function and mode declarations. It is separate from parse_tree_out.m because a significant number of compiler modules need only its functionality, and not parse_tree_out.m's functionality. compiler/parse_tree_out_inst.m: New module containing the code to print out insts and modes. compiler/parse_tree_out_term.m: New module containing the code to print out variables and terms. compiler/parse_tree_out_info.m: New module containing the infrastructure of both mercury_to_mercury.m and the other new modules. compiler/parse_tree.m: Include the new modules. compiler/notes/compiler_design.html: Document the new modules. compiler/Mercury.options: Transfer an option from mercury_to_mercury.m to the successor module that needs it. compiler/*.m: Import one of the new modules either as well as, or instead of, mercury_to_mercury.m. In most cases, we need to import only one or two of mercury_to_mercury.m's successor modules; nowhere do we need to import all eight. Clean up some code in termination.m around a call to one of the new modules. tools/speedtest: Replace mercury_to_mercury.m on the list of the ten largest modules of the compiler.	2015-09-06 21:01:11 +10:00
Zoltan Somogyi	1aee1b8ade	Don't put variable names in clauses in .opt files. ... After this diff, a change in the source file that affects only variable names won't cause the recompilation of the other modules that use the changed module's .opt file. (I got a bunch of such unnecessary recompilations when giving new names to many of varset.m's variables.) compiler/prog_data.m: Add a new type named var_name_print to replace the boolean that used to specify whether we wanted to print the variable number as a suffix after the variable name. This new type allows us to specify not just that e.g. a variable numbered 10 and named Example should be printed as Example or as Example_10, but also as V_10. compiler/intermod.m: Use this capability to print variables in only the V_N form when putting clauses in .opt files. After this diff, a change in the source file that affects only variable names won't cause the recompilation of the other modules that use the change module's .opt file. Convert (C->T;E) into (if C then T else E). compiler/mercury_to_mercury.m: compiler/hlds_out_goal.m: compiler/hlds_out_mode.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_out_util.m: Generalize mercury_var_to_string, and the predicates that call it directly or indirectly, to take an argument of the var_name_print type instead of the old AppendVarNum boolean. Put the argument lists of the affected predicates in a better order, with related parameters being next to each other, and moving more global parameters before more local parameters. Add versions of mercury_var_to_string to mercury_vars_to_string that assume the print_name_only value for the var_name_print parameter, since this is typically what we want when we generate error messages. In hlds_out_pred.m, add another type, write_which_modes, to replace another boolean parameter. compiler/add_foreign_proc.m: compiler/add_pragma_type_spec.m: compiler/check_typeclass.m: compiler/code_loc_dep.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/field_access.m: compiler/format_call.m: compiler/goal_expr_to_goal.m: compiler/hlds_desc.m: compiler/layout_out.m: compiler/liveness.m: compiler/llds_out_instr.m: compiler/make_hlds_warn.m: compiler/mercury_to_mercury.m: compiler/mode_debug.m: compiler/mode_errors.m: compiler/pd_debug.m: compiler/post_typecheck.m: compiler/prog_ctgc.m: compiler/prog_io_item.m: compiler/prog_io_mutable.m: compiler/prog_io_type_defn.m: compiler/prog_io_typeclass.m: compiler/prog_util.m: compiler/purity.m: compiler/push_goals_together.m: compiler/rbmm.live_variable_analysis.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/saved_vars.m: compiler/stack_opt.m: compiler/structure_reuse.indirect.m: compiler/type_assign.m: compiler/type_constraints.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unneeded_code.m: compiler/unused_args.m: Conform to the above changes.	2015-08-22 14:42:28 +10:00
Zoltan Somogyi	04dec8c205	Carve vartypes.m, prog_detism.m and prog_rename.m out of prog_data.m. ... Besides defining most of the types representing the smaller parts of parse trees (parts smaller than items), prog_data.m also has many utility predicates that operate on values of these types. Carve the three substantial clusters of predicates out of prog_data.m, and move them into their own modules, which are each imported by fewer modules than prog_data.m itself. compiler/vartypes.m: New module containing the vartypes type and the predicates that operate on it. The new module has *much* better cohesion than the old prog_data.m. The vartypes type does not appear in any parse tree; it is used only in the HLDS. So make vartypes.m part of the hlds.m package, not parse_tree.m. Move three predicates that perform renamings and substitutions on vartypes here from prog_type_subst.m, since the latter is part of the parse_tree.m package, and thus doesn't have access to hlds.vartypes. Make private the service predicate that these three moved predicates used to rely on, since it has no other callers. compiler/prog_detism.m: New module containing utility predicates that operate on determinisms and determinism components. compiler/prog_rename.m: New module containing utility predicates that rename variables in various data structures. compiler/prog_data.m: Remove the stuff now in the three new modules. compiler/prog_type_subst.m: Remove the three predicates now in vartypes.m. compiler/mercury_to_mercury.m: Delete an unneded predicate, which was the only part of this module that referred to vartypes. compiler/prog_type.m: compiler/builtin_lib_types.m: compiler/type_util.m: Move some utility predicates that refer to vartypes from prog_type.m and builtin_lib_types.m (both part of parse_tree.m) to type_util.m (part of check_hlds.m). compiler/parse_tree.m: compiler/hlds.m: compiler/notes/compiler_design.html: Mention the new modules. compiler/accumulator.m: compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_heap_ops.m: compiler/add_pragma_type_spec.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/arg_info.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/clause_to_proc.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/code_loc_dep.m: compiler/common.m: compiler/complexity.m: compiler/const_prop.m: compiler/constraint.m: compiler/continuation_info.m: compiler/coverage_profiling.m: compiler/cse_detection.m: compiler/ctgc.datastruct.m: compiler/ctgc.util.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/disj_gen.m: compiler/equiv_type_hlds.m: compiler/erl_call_gen.m: compiler/erl_code_gen.m: compiler/erl_code_util.m: compiler/exception_analysis.m: compiler/float_regs.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/format_call.m: compiler/goal_expr_to_goal.m: compiler/goal_path.m: compiler/goal_store.m: compiler/goal_util.m: compiler/headvar_names.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_clauses.m: compiler/hlds_goal.m: compiler/hlds_llds.m: compiler/hlds_out_goal.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/inlining.m: compiler/inst_util.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/liveness.m: compiler/lookup_switch.m: compiler/make_goal.m: compiler/mark_tail_calls.m: compiler/ml_accurate_gc.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_disj_gen.m: compiler/ml_gen_info.m: compiler/ml_lookup_switch.m: compiler/ml_proc_gen.m: compiler/ml_unify_gen.m: compiler/mode_constraints.m: compiler/mode_info.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_conj.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/par_loop_control.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_rep.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/qual_info.m: compiler/quantification.m: compiler/rbmm.points_to_graph.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_liveness_info.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/set_of_var.m: compiler/simplify_goal_call.m: compiler/simplify_goal_conj.m: compiler/simplify_goal_disj.m: compiler/simplify_goal_ite.m: compiler/simplify_goal_scope.m: compiler/simplify_goal_switch.m: compiler/simplify_goal_unify.m: compiler/simplify_info.m: compiler/simplify_proc.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_constr_initial.m: compiler/term_constr_util.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/term_util.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/try_expand.m: compiler/tupling.m: compiler/type_assign.m: compiler/type_constraints.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/var_locn.m: Conform to the above changes, mostly by importing some of the three new modules as well as, or instead of, prog_data.m.	2015-08-09 19:02:12 +10:00
Zoltan Somogyi	05f5ec7d41	Fix a bug that put $typed_insts in .opt files. ... compiler/mercury_to_mercury.m: Make the predicates that output insts take a parameter that says whether we are trying to print valid Mercury code (in which case we strip any $typed_inst wrappers around other insts), or as-informative-as-possible representations of insts for debugging, in which case we do NOT strip those wrappers. When invoked on insts that CANNOT be printed as valid Mercury even though valid Mercury is being requested, abort. Rationalize the argument order of the involved predicates. Move the output_lang type here from hlds_out_util.m to make the above possible. Change the flag that governs whether item names are qualified or not from a bool to a bespoke enum type. Fix a bug involving that bool. compiler/hlds_out_mode.m: This module also has a predicate that output insts, though it already had a valid mercury/debug output flag. If it is asked to print valid Mercury, make it strip $typed_inst wrappers, and abort on insts that cannot be printed as valid Mercury. A better fix would be to eliminate this predicate, and other predicates in this module that also duplicate predicates in mercury_to_mercury.m, after generalizing the latter as needed, but that would take more time. compiler/add_clause.m: compiler/add_mutable_aux_preds.m: compiler/dep_par_conj.m: compiler/dependency_graph.m: compiler/format_call.m: compiler/goal_expr_to_goal.m: compiler/hlds_error_util.m: compiler/hlds_out_goal.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_out_util.m: compiler/intermod.m: compiler/liveness.m: compiler/make_hlds_error.m: compiler/mercury_to_mercury.m: compiler/mode_errors.m: compiler/passes_aux.m: compiler/pd_debug.m: compiler/push_goals_together.m: compiler/saved_vars.m: compiler/stack_opt.m: compiler/structure_reuse.analysis.m: compiler/structure_sharing.analysis.m: compiler/term_constr_main.m: compiler/termination.m: compiler/unneeded_code.m: Conform to the above. compiler/mode_constraint_robdd.m: compiler/mode_constraints.m: Fix an unrelated problem that ALSO prevented a bootcheck with -O5 --intermodule-optimization, which is that with these options, several predicates in both these modules accumulated enough type ambiguities for the type checker to throw up its hands in despair. The type checker should NOT be influenced by the additional types, data constructors, field names, functions and predicates added by these options to their respective tables, but it is. Fixing that bug is future work. For now, just reduce the ambiguities to the allowable level, mostly by adding module qualifiers, and by converting some function calls to predicate calls. (Function calls introduce ambiguities, since the typechecker thinks they may be partially applied predicate calls.)	2015-04-02 12:09:42 +11:00
Zoltan Somogyi	5a639e1656	Quote cons_ids consistently in error messages. ... compiler/error_util.m: Add a format piece for identifying cons_ids. compiler/hlds_out_util.m: compiler/prog_out.m: Add a version of the predicate that convert cons_ids to string that quotes appropriately for error messages. Move this predicate, and some existing predicates for converting cons_ids to strings from hlds_out_util.m to prog_out.m, so that error_util.m, which is part of the parse_tree.m package, can use them. Since cons_ids are defined in prog_data, a part of parse_tree, they should always have been here. Make the same move for some other predicates that also convert to strings values of other types defined in prog_data.m. compiler/prog_mode.m: compiler/prog_util.m: Move a predicate dealing with cons_ids from prog_mode.m to prog_out.m, since prog_out needs it now. compiler/det_report.m: compiler/post_typecheck.m: Use the new format piece where relevant. compiler/typecheck_errors.m: Use the new format piece where relevant. Avoid prevarication about singular vs plural when not necessary. tests/compiler/*.m: Conform to the above. tests/invalid/*.err_exp: Update these to expect the new error messages.	2015-01-31 20:39:19 +11:00
Zoltan Somogyi	fe785c668b	Consistently use set.is_empty and set.is_non_empty. ... compiler/*.m: deep_profiler/*.m: As above. library/set.m: library/set_bbbtree.m: library/set_ctree234.m: library/set_ordlist.m: library/set_tree234.m: library/set_unordlist.m: Add is_non_empty to the set modules that did not already have it. (Some did, some didn't.) Make the documentation of empty, is_empty, non_empty and is_non_empty consistent.	2014-11-04 23:18:43 +11:00
Zoltan Somogyi	72497d7bbf	Put "task" in the name of the types that define simplify's tasks. ... compiler/simplify_tasks.m: As above. compiler/*.m: Conform to the change to simplify_tasks.m.	2014-07-25 13:35:12 +02:00
Zoltan Somogyi	4a292707cf	Replace simplify.m (which had 4500 lines) with several submodules. ... The objective of this change is to improve module cohesion, with each of the new modules doing only one task, or two or three closely related tasks. Moving common.m into the new simplify package also improves information hiding, since the details of the simplify_info data structure that common.m needs aren't exposed to the rest of the compiler anymore. This change mostly moves code around. There are no algorithmic changes. In several places I did - make predicate names more meaningful, - reordered predicate definitions to put related predicates together (previously, the predicates involved in simplifying a particular kind of goal were often interspersed with predicates that worked only on other kinds of goals), and - improved documentation (in some places expanding it, in some places correcting comments that suffered bit-rot and were out-of-date). compiler/simplify.m: This file is now a package, including its submodules, but no code anymore. compiler/simplify_goal.m: New submodule containing generic processing of goals. compiler/simplify_goal_call.m: compiler/simplify_goal_unify.m: compiler/simplify_goal_conj.m: compiler/simplify_goal_disj.m: compiler/simplify_goal_switch.m: compiler/simplify_goal_ite.m: compiler/simplify_goal_scope.m: New submodules containing goal-type-specific processing of goals. Each of these modules is much more cohesive than the original simplify.m ever was; most export only one predicate per handled goal type. compiler/simplify_info.m: New submodule containing the definition of simplify_info and its access predicates. compiler/simplify_tasks.m: New submodule listing the tasks that the simplification pass may be asked to perform. compiler/simplify_proc.m: New submodule containing the top-level processing of procedures. compiler/common.m: Make this module a part of the simplify package. It is only ever invoked by simplification, and leaving it outside the package would require exporting more than a few internal details of simplify_info. compiler/format_call.m: Make this module a part of the simplify package. It does its job during simplification, even though the need for it is noted during determinism analysis. compiler/check_hlds.m: Remove common.m and format_call.m from the list of direct submodules of check_hlds.m. (They are now indirect submodules, through check_hlds.simplify.) compiler/notes/compiler_design.html: Document the new modules, and the new status of common and format_call.. compiler/pd_util.m: Move some code from here to the new simplify_proc.m, since it allows us to avoid exposing internal details of how simplification works. compiler/mercury_compile_front_end.m: Move a predicate here from the old simplify.m, since the job it does belongs here. Remove the ability to disable the invocation of cse_detection. This capability was only ever needed when measuring the effectiveness of determinism analysis for a paper; it hasn't been needed in a decade. compiler/cse_detection.m: Improve the top level comment. compiler/options.m: doc/user_guide.texi: Remove the option that used to control the invocation of cse_detection. compiler/*.m: Conform to the split of simplify.m, importing its submodules where needed.	2014-07-24 10:47:12 +02:00
Zoltan Somogyi	16bd4acd2f	Shorten lines longer than 79 characters. ... Estimated hours taken: 2 Branches: main compiler/*.m: Shorten lines longer than 79 characters.	2012-10-24 05:49:47 +00:00
Zoltan Somogyi	6d1bc24d0b	Make vartypes an abstract data type, in preparation for exploring ... Estimated hours taken: 4 Branches: main compiler/prog_data.m: Make vartypes an abstract data type, in preparation for exploring better representations for it. compiler/mode_util.m: Provide two different versions of a predicate. The generic version continues to use map lookups. The other version knows it works on prog_vars, so it can use the abstract operations on them provided by prog_data.m. compiler/accumulator.m: compiler/add_class.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/arg_info.m: compiler/builtin_lib_types.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/clause_to_proc.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/common.m: compiler/complexity.m: compiler/const_prop.m: compiler/constraint.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/ctgc.datastruct.m: compiler/ctgc.util.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/disj_gen.m: compiler/equiv_type_hlds.m: compiler/erl_call_gen.m: compiler/erl_code_gen.m: compiler/erl_code_util.m: compiler/exception_analysis.m: compiler/float_regs.m: compiler/follow_vars.m: compiler/format_call.m: compiler/goal_path.m: compiler/goal_util.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_clauses.m: compiler/hlds_goal.m: compiler/hlds_out_goal.m: compiler/hlds_out_pred.m: compiler/hlds_pred.m: compiler/hlds_rtti.m: compiler/inlining.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/liveness.m: compiler/lookup_switch.m: compiler/mercury_to_mercury.m: compiler/ml_accurate_gc.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_disj_gen.m: compiler/ml_lookup_switch.m: compiler/ml_proc_gen.m: compiler/ml_unify_gen.m: compiler/mode_info.m: compiler/modecheck_call.m: compiler/modecheck_conj.m: compiler/modecheck_goal.m: compiler/modecheck_unify.m: compiler/modecheck_util.m: compiler/modes.m: compiler/par_loop_control.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_type_subst.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/qual_info.m: compiler/rbmm.points_to_info.m: compiler/rbmm.region_liveness_info.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/stack_alloc.m: compiler/stack_opt.m: compiler/store_alloc.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/switch_detection.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_constr_util.m: compiler/term_traversal.m: compiler/term_util.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/try_expand.m: compiler/tupling.m: compiler/type_constraints.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/typecheck_info.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/untupling.m: compiler/unused_args.m: compiler/var_locn.m: Conform to the above. compiler/prog_type.m: compiler/rbmm.points_to_graph.m: Conform to the above. Move some comments where they belong. compiler/stm_expand.m: Conform to the above. Do not export a predicate that is not used outside this module. Disable some debugging output unless it is asked for. Remove unnecessary prefixes on variable names. library/version_array.m: Instead writing code for field access lookalike functions and defining lookup, set etc in terms of them, write code for lookup, set etc, and define the field access lookalike functions in terms of them. Change argument orders of some internal predicates to be more state variable friendly. Fix typos in comments. tests/hard_coded/version_array_test.exp: Conform to the change to version_array.m.	2012-07-02 01:16:39 +00:00
Zoltan Somogyi	77adfe5439	Add all the copyright year updates that were left off in my previous commit ... Estimated hours taken: 0.1 Branches: main Add all the copyright year updates that were left off in my previous commit over the ext protocol.	2012-06-08 15:46:21 +00:00
Zoltan Somogyi	ee63cb8d84	Heavily polymorphic code, such as that generated by g12, often builds the same ... Estimated hours taken: 80 Branches: main Heavily polymorphic code, such as that generated by g12, often builds the same typeinfos and typeclass infos over and over again. We have long had caches that avoid building a new typeinfo or typeclass info if some variable in the current scope already contains the right value, but a program that has many scopes may still build the same typeinfo or typeclass info many times. If that typeinfo or typeclass info is a ground term, the code generators will recognize that fact, and will turn all the constructions of that ground term in different scopes into referencess to the same constant structure. However, in the meantime, the program can be much bigger than necessary. In the motivating test case for this change, a single call to fdic_post is preceded by 133 goals that build the four typeclass infos it needs. The main idea of this diff is to construct constant typeinfos and typeclass infos out of line, in a separate data structure. Polymorphism then binds variables representing typeinfo and typeclass infos to reference to these constant structures. In the motivating example, this allows polymorphism.m to insert just four goals before the call to fdic_post, the minimal possible number: one for each typeclass info that predicate needs. On Leslie's bug344 program, this change speeds up the compiler by a factor of five to eight (reducing compile time from about 80 or 85 seconds to 10 or 15). There is a drawback to this scheme, but it is minor. That drawback is that once a constant structure is entered into our database of constant structures, it cannot (yet) be removed. Even if all the references to a constant structure are eliminated by optimizations, the structure will remain. ------------------------------------------ CHANGES IN THE FRONT END compiler/const_struct.m: A new module to look after our new database of constant structures. Currently, its use is enable only on the LLDS and MLDS C backends. compiler/hlds.m: compiler/notes/compiler_design.html: Add the new module to the HLDS package. compiler/hlds_module.m: Include the constant structure database in the module_info. compiler/hlds_data.m: Add two new cons_ids, which refer to typeinfos and typeclass infos implemented as constant structures. Move the code for calculating the number of extra instance args in base_typeclass_infos here from base_typeclass_info.m, since polymorphism.m now needs it too. We can now also eliminate the duplicate copy of that code in higher_order.m. Make an independent optimization: make the restrict_list_elements function more efficient by avoiding redundant tests. compiler/polymorphism.m: When building typeinfo and typeclass infos, keep track of whether the structure being built is constant. If it is, then put it in the database of constant structures, and replace the code building it with a simple reference to that new entry. Since I now expect most goal sequences inserted before goals to be short, consistent use lists of goals to represent these, since the costs of conversions to and from cord form are unlikely to be paid back by the higher efficiency of cord operations on longer sequences. When we want to get the typeclass info of a superclass out of the typeclass info of a subclass, if the typeclass info of the subclass is known, do the extraction here. We used to do this optimization only in higher_order.m, but doing so here reduces the size of the HLDS between polymorphism.m and higher_order.m, and thus improves compilation time. Reorganize some of the structure of this module to make the above changes possible. In particular, our new approach requires making snapshots of the varsets and vartypes, and later restoring those snapshots if the variables allocated turn out to be unnecessary, due to all of them describing the components of a constant structure. The correctness of such code is much easier to check if the taking and restoring of each snapshot takes places in a single predicate. Remove the code moved to higher_order.m. Add some debugging code for now. If no issues arise in the next few weeks, it can be deleted. compiler/modecheck_unify.m: Treat unifications whose right hand side has a cons_id referring to a constant structure specially. compiler/base_typeclass_info.m: Replace the code that is now in num_extra_instance_args with a call to that predicate. Put the arguments of some predicates in a more logical order. compiler/higher_order.m: When looking up the components of existing typeclass infos, handle cases where those typeclass infos are constant structures. Give some types, fields and variables better names. Avoid a redundant map search. Avoid some redundant tests by providing separate predicates to handle higher order calls and method calls. Move the predicate is_typeclass_info_manipulator here from polymorphism.m, since this is the only module that uses that predicate. ------------------------------------------ CHANGES IN THE LLDS BACKEND: compiler/llds.m: Add a type to map constant structure numbers to rvals together with their LLDS types. Introduce a type to represent rvals together with their LLDS types. compiler/mercury_compile_llds_back_end.m: Before we generate code for the predicates of the module, convert the constant structures to typed LLDS rvals. Create a map mapping each constant structure number to the corresponding typed rvals. compiler/proc_gen.m: Take that map, and put it into the code_info, to allow references to those structures to be translated. Put the arguments of some predicates into a more logical order. compiler/code_info.m: Include a map giving the representation of each constant structure in the code_info. compiler/unify_gen.m: Add the predicates needed to convert the constant structures of a module to LLDS rvals. For now, this code works only on the kinds of constant structures generated by polymorphism.m. Handle unifications whose right hand side is a reference to a constant structure. compiler/global_data.m: compiler/stack_layout.m: Use the new typed_rval type where relevant. ------------------------------------------ CHANGES IN THE MLDS BACKEND: compiler/ml_proc_gen.m: Before we generate code for the predicates of the module, convert the constant structures to typed MLDS rvals. Create a map mapping each constant structure number to the corresponding typed rvals. Factor out some code into a predicate of its own. compiler/ml_gen_info.m: Include a map giving the representation of each constant structure in the ml_gen_info. Also add to the ml_gen_info an indication of what GC system we are generating code for, since the code generator needs to know this often. compiler/ml_unify_gen.m: Add the predicates needed to convert the constant structures of a module to MLDS rvals. For now, this code works only on the kinds of constant structures generated by polymorphism.m. Handle unifications whose right hand side is a reference to a constant structure. Simplify some existing code. ------------------------------------------ MINOR CHANGES: mdbcomp/prim_data.m: Add a predicate that gets both the module name and the base name from a sym_name at the same time. This is used for minor speedups in other code updated in this diff. compiler/dead_proc_elim.m: Scan constant structures for references to entities that need to be kept alive. compiler/term_constr_build.m: compiler/term_traversal.m: Do not build size constraints from references to constant structures. The sizes of constant terms don't change, so they are irrelevant when building constraints for finding argument size changes. ------------------------------------------ TRIVIAL CHANGES TO CONFORM TO OTHER CHANGES: compiler/hlds_out_module.m: Print out the constant structure database if asked. doc/user_guide.tex: Document how to ask for it. compiler/hlds_out_util.m: Print out the new cons_ids. compiler/hlds_out_mode.m: Print out the new cons_ids in insts. Remove a compiler abort, to help debug a problem. Improve the structure of a predicate. compiler/hlds_out_goal.m: Fix some missing newlines. compiler/hlds_code_util.m: Add some utility predicates needed by the modules above. Conform to the changes above. compiler/mlds_to_il.m: Reorder some predicates. Conform to the changes above. compiler/bytecode_gen.m: compiler/ctgc.selector.m: compiler/dependency_graph.m: compiler/erl_unify_gen.m: compiler/export.m: compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/llds_out_globals.m: compiler/mercury_to_mercury.m: compiler/ml_global_data.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/module_qual.m: compiler/prog_rep.m: compiler/prog_type.m: compiler/prog_util.m: compiler/rbmm.execution_path.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/type_ctor_info.m: compiler/unused_imports.m: compiler/var_locn.m: compiler/xml_documentation.m: Conform to the changes above. ------------------------------------------ OTHER INDEPENDENT CHANGES: compiler/handle_options.m: Add a dump option that is useful for debugging when working on polymorphism.m and constant structures. compiler/equiv_type_hlds.m: Fix an old performance bug: make the code handling try goals keep the old memory cells representing such goals, instead of rebuilding them, if no changes took place inside them. compiler/ml_accurate_gc.m: Move a test earlier, to allow us to avoid more work in the common case. compiler/erl_code_gen.m: compiler/error_util.m: compiler/hhf.m: compiler/inst_util.m: compiler/ml_code_util.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/modecheck_call.m: compiler/modecheck_util.m: compiler/post_typecheck.m: compiler/size_prof.m: compiler/stack_opt.m: compiler/stratify.m: compiler/unused_args.m: compiler/post_type_analysis.m: library/erland_rtti_implementation.m: Minor cleanups. ------------------------------------------ CHANGES TO THE TEST SUITE: tests/invalid/any_passed_as_ground.err_exp2: tests/invalid/invalid_default_func_1.err_exp2: tests/invalid/invalid_default_func_3.err_exp2: tests/invalid/try_detism.err_exp2: Add second expected output files for these tests. We need alternate expected outputs because the numbers of some of the typeinfo variables mentioned in error message are different depending on whether or not const structures are enabled.	2012-06-08 15:37:07 +00:00
Paul Bone	23d549b036	Handle stack slot allocation for loop_control scopes: ... Variables communicated to and from the spawned off computation now have stack slots allocated. Variables that need stack slots in the spawned off computation must have distinct stack slots to those that need stack slots between the spawned off computation and the recursive call, including the recursive call itself. compiler/live_vars.m: Refactored the parallel_stackvars structure. It now makes a little more sense for loop control scopes. It is also abstracted away by a number of new predicates, making it easier to work with. To support this a new field has been added to the alloc_data type, this is necessary for detecting recursive calls. A new method has been added to the stack_alloc_info(T) typeclass to communicate information about loop control scopes to the stack slot allocation algorithm. compiler/hlds_llds.m: Create a new type, need_for_loop_control that contains the sets of stackvars that must have distinct stack slots for the purposes of loop control. Update a comment on the maybe_need field of the llds_code_gen_structure to refer to loop control scopes as well as parallel conjunctions. compiler/par_conj_gen.m: Make corrections in how variable locations are managed during code generation for loop control scopes. compiler/set_of_var.m: Provide new set operations cartesian_product and cartesian_product_list. compiler/stack_alloc.m: compiler/stack_opt.m: compiler/tupling.m: Conform to changes in live_vars.m	2011-10-12 00:38:20 +00:00
Zoltan Somogyi	4b6c8966b1	When computing the interference graph for the stack alloc pass, we used to put ... Estimated hours taken: 3 Branches: main When computing the interference graph for the stack alloc pass, we used to put all live variables into the graph, and then filtered out the dummy variables from every set of live variables. Since a dummy variable can and often does appear in more than one set, all sets had to be inspected, filtered and then rebuilt. This rebuilding was redundant work. We now create an array that tells us which variables are of dummy type (making the test faster), and avoid putting such variables into live sets in the first place (avoiding the redundant rebuilding). This change reduces the time taken by the stack alloc pass for zm_enums.m in a debug grade by about a quarter (from about 16s to about 12s). compiler/live_vars.m: Add this array to the data structure passed around by the code that gathers live sets. Add code to compute the array. Pass that data structure to the code that records live sets. We used to pass the goal_info, but that turns out to not be needed. compiler/stack_alloc.m: Use the array to filter out dummy variables *before* adding them to live sets. compiler/stack_opt.m: compiler/tupling.m: Conform to the changes in live_vars.m. compiler/set_of_var.m: Add a predicate version of trues-only filter to set_of_var.m.	2011-07-22 03:31:41 +00:00
Zoltan Somogyi	7487590f2d	Predicates with many variables, such as some of those in zm_enums.m, ... Estimated hours taken: 24 Branches: main Predicates with many variables, such as some of those in zm_enums.m, tickle pretty bad behavior in the liveness and stack_alloc passes. This is because those passes manipulate sets of variables, which in such cases are large sets of variables, and the quadratic behavior of repeated operations on sets represents as sorted lists hurts us. This diff changes the representation of the sets of variables involved in those two passes, which are the prebirth, postbirth, predeath and postdeath sets in goal_infos, to be values of an abstract type (set_of_progvar). By default, these are implemented using tree_bitsets, which have much better worst case behaviour that set_ordlists. When compiling zm_enums with debugging enabled, this diff speeds up the liveness pass by about half and the stack alloc pass by about a third, with the overall speedup being about 6% (due to some other expensive passes). On tools/speedtest -l, the result is a 3.4% slowdown. Since the slowdown worsens slightly if I make the abstract representation of sets of prog_vars be the existing representation (an ordinary set), I think this slowdown is due to the conversions that are now required in some places between the abstract representation and an explicit set(prog_var) representation. As such, as other uses of set(progvar) get converted to set_of_progvar, this slowdown should disappear. compiler/set_of_var.m: The new module that contains the set_of_progvar abstract data type. This module also contains a copy of the code of the graph_colour module. Since the set_of_progvar type is private, this is necessary if we want all the set operations done by graph colouring (which does the bulk of the work of the stack alloc pass) to use the preferred set representation. compiler/graph_colour.m: Note that this module is no longer used. compiler/stack_alloc.m: compiler/liveness.m: Switch over to using the new module. compiler/parse_tree.m: Include set_of_var among the modules of this package. (It is in this package because the prog_var type is defined in this package.) compiler/test_bitset.m: A module that allows new set implementations to be tested. It is an extended and specialized version of the bitset_tester module from tests/hard_coded. compiler/hlds_llds.m: Use the set_of_progvar type for the prebirth, postbirth, predeath and postdeath sets in goal_infos, and for other liveness-related sets of variables. compiler/code_info.m: Some of the fields of the code_info structure represent sets of variables, and some of the predicates defined by this module have arguments that are sets of variables. If these sets represent entities that are computed from prebirth, postbirth, predeath and postdeath sets or from other goal_info fields that have been changed to the set_of_progvar representation, change them to use the set_of_progvar representation as well, or, in a few cases, to plain sorted lists. Conform to the above change. compiler/proc_type.m: Add a utility predicate to operate of set_of_progvar. Replace a lambda expression with a named predicate. compiler/quantification.m: Until now, quantification.m used its own private abstract type (defined as tree_bitset) to represent sets. Make it use set_of_progvar instead, since it has the same purpose. This eliminates a potential maintenance problem. compiler/call_gen.m: compiler/code_gen.m: compiler/commit_gen.m: compiler/delay_construct.m: compiler/disj_gen.m: compiler/hlds_out_goal.m: compiler/hlds_rtti.m: compiler/interval.m: compiler/ite_gen.m: compiler/live_vars.m: compiler/lookup_switch.m: compiler/lookup_util.m: compiler/matching.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/pragma_c_gen.m: compiler/proc_gen.m: compiler/simplify.m: compiler/stack_opt.m: compiler/store_alloc.m: compiler/string_switch.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_sharing.domain.m: compiler/switch_util.m: compiler/trace_gen.m: compiler/tupling.m: compiler/unify_gen.m: compiler/unused_args.m: Conform to the above change. library/map.m: Add a utility predicate, map.select_sorted_list, which functions the same way as map.select, but takes a sorted list as argument instead of a set. library/set_ordlist.m: Bring the interface of this module closer to set.m and tree_bitset.m to make them more easily interchangeable. This required adding the predicates is_non_empty and is_singleton, as well as adding predicate forms of union_list and intersect_list. I also added missing type_spec pragmas for some predicates frequently used by the compiler. library/tree_bitset.m: Bring the interface of this module closer to set.m and set_ordlist.m to make them more easily interchangeable. This required adding the predicates is_non_empty and is_singleton, and both function and predicate forms of union_list and intersect_list. Fix an old bug in the difference operation. Given SetA - SetB, if SetA was the empty set, then this operation would correctly return the empty set if SetB was small (represented by a leaf list), but would incorrectly return SetB if it was large (represented by an interior node list).	2011-07-21 06:58:34 +00:00
Zoltan Somogyi	295415090e	Convert almost all remaining modules in the compiler to use ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all remaining modules in the compiler to use "$module, $pred" instead of "this_file" in error messages. In a few cases, the old error message was misleading, since it contained an incorrect, out-of-date or cut-and-pasted predicate name. tests/invalid/unresolved_overloading.err_exp: Update an expected output containing an updated error message.	2011-05-23 05:08:24 +00:00
Julien Fischer	9ae7fe6b70	Change the argument ordering of predicates in the set module. ... Branches: main Change the argument ordering of predicates in the set module. library/set.m: Change predicate argument orders to match the versions in the svset module. Group function definitions with the corresponding predicates rather than at the end of the file. Delete Ralph's comments regarding the argument order in the module interface: readers of the library reference guide are unlikely to be interested in his opinion of the argument ordering ten or so years ago. Add extra modes for set.map/3 and set.map_fold/5. library/svset.m: library/eqvclass.m: library/tree234.m: library/varset.m: browser/*.m: compiler/*.m: deep_profiler/*.m: mdbcomp/trace_counts.m: extras/moose/grammar.m: extras/moose/lalr.m: extras/moose/moose.m: tests/hard_coded/bitset_tester.m: Conform to the above change. NEWS: Announce the above changes.	2011-05-06 05:03:29 +00:00
Julien Fischer	78b0bf3c7f	Use state variable field update syntax in more places. ... Branches: main Use state variable field update syntax in more places. browser/*.m: compiler/*.m: deep_profiler/*.m: As above.	2011-05-05 07:11:52 +00:00
Julien Fischer	322e498a50	Change places where we create an empty map and the immediately do a det_insert ... Branches: main Change places where we create an empty map and the immediately do a det_insert into it to use the recently added singleton map function. compiler/add_pragma.m: compiler/common.m: compiler/dep_par_conj.m: compiler/higher_order.m: compiler/hlds_data.m: compiler/inst_match.m: compiler/lco.m: compiler/modecheck_goal.m: compiler/modules.m: compiler/polymorphism.m: compiler/pred_table.m: compiler/rbmm.region_resurrection_renaming.m: compiler/simplify.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/switch_util.m: compiler/term_pass2.m: compiler/tupling.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/unneeded_code.m: deep_profiler/autopar_search_callgraph.m: deep_profiler/html_format.m: As above.	2011-05-05 06:39:37 +00:00
Julien Fischer	9f68c330f0	Change the argument order of many of the predicates in the map, bimap, and ... Branches: main Change the argument order of many of the predicates in the map, bimap, and multi_map modules so they are more conducive to the use of state variable notation, i.e. make the order the same as in the sv* modules. Prepare for the deprecation of the sv{bimap,map,multi_map} modules by removing their use throughout the system. library/bimap.m: library/map.m: library/multi_map.m: As above. NEWS: Announce the change. Separate out the "highlights" from the "detailed listing" for the post-11.01 NEWS. Reorganise the announcement of the Unicode support. benchmarks/*/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: extras/*/*.m: mdbcomp/*.m: profiler/*.m: tests/*/*.m: ssdb/*.m: samples/*/*.m slice/*.m: Conform to the above change. Remove any dependencies on the sv{bimap,map,multi_map} modules.	2011-05-03 04:35:04 +00:00
Paul Bone	d43239d6a7	Move some of the goal path code from compiler/goal_path.m to the mdbcomp ... library where it can be used by the deep profiler. Also move the goal path code from program_representation.m to the new module, goal_path.m in mdbcomp/ mdbcomp/goal_path.m: New module containing goal path code. mdbcomp/program_representation.m: Original location of goal path code. compiler/goal_path.m: Move some of this goal_path code into mdbcomp/goal_path.m mdbcomp/feedback.automatic_parallelisation.m: mdbcomp/rtti_access.m: mdbcomp/slice_and_dice.m: mdbcomp/trace_counts.m: browser/debugger_interface.m: browser/declarative_execution.m: browser/declarative_tree.m: compiler/build_mode_constraints.m: compiler/call_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/coverage_profiling.m: compiler/deep_profiling.m: compiler/format_call.m: compiler/goal_path.m: compiler/goal_util.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_out_goal.m: compiler/hlds_out_pred.m: compiler/hlds_pred.m: compiler/interval.m: compiler/introduce_parallelism.m: compiler/layout_out.m: compiler/llds.m: compiler/mode_constraint_robdd.m: compiler/mode_constraints.m: compiler/mode_ordering.m: compiler/ordering_mode_constraints.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_rep.m: compiler/prop_mode_constraints.m: compiler/push_goals_together.m: compiler/rbmm.condition_renaming.m: compiler/smm_common.m: compiler/stack_layout.m: compiler/stack_opt.m: compiler/trace_gen.m: compiler/tupling.m: compiler/type_constraints.m: compiler/typecheck.m: compiler/unify_gen.m: compiler/unneeded_code.m: deep_profiler/Mmakefile: deep_profiler/analysis_utils.m: deep_profiler/coverage.m: deep_profiler/create_report.m: deep_profiler/display_report.m: deep_profiler/dump.m: deep_profiler/mdprof_fb.automatic_parallelism.m: deep_profiler/message.m: deep_profiler/old_query.m: deep_profiler/profile.m: deep_profiler/program_representation_utils.m: deep_profiler/read_profile.m: deep_profiler/recursion_patterns.m: deep_profiler/report.m: deep_profiler/var_use_analysis.m: slice/Mmakefile: slice/mcov.m: Conform to the move of the goal path code.	2011-01-13 00:36:56 +00:00
Zoltan Somogyi	1c3bc03415	Make the system compiler with --warn-unused-imports. ... Estimated hours taken: 2 Branches: main, release Make the system compiler with --warn-unused-imports. browser/*.m: library/*.m: compiler/*.m: Remove unnecesary imports as flagged by --warn-unused-imports. In some files, do some minor cleanup along the way.	2010-12-30 11:18:04 +00:00
Zoltan Somogyi	a2cd0da5b3	The existing representation of goal_paths is suboptimal for several reasons. ... Estimated hours taken: 80 Branches: main The existing representation of goal_paths is suboptimal for several reasons. - Sometimes we need forward goal paths (e.g. to look up goals), and sometimes we need reverse goal paths (e.g. when computing goal paths in the first place). We had two types for them, but - their names, goal_path and goal_path_consable, were not expressive, and - we could store only one of them in goal_infos. - Testing whether goal A is a subgoal of goal B is quite error-prone using either form of goal paths. - Using a goal path as a key in a map, which several compiler passes want to do, requires lots of expensive comparisons. This diff replaces most uses of goal paths with goal ids. A goal id is an integer, so it can be used as a key in faster maps, or even in arrays. Every goal in the body of a procedure gets its id allocated in a depth first search. Since we process each goal before we dive into is descendants, the goal representing the whole body of a procedure always gets goal id 0. The depth first traversal also builds up a map (the containing goal map) that tells us the parent goal of ever subgoal, with the obvious exception of the root goal itself. From the containing goal map, one can compute both reverse and forward goal paths. It can also serve as the basis of an efficient test of whether the goal identified by goal id A is an ancestor of another goal identified by goal id B. We don't yet use this test, but I expect we will in the future. mdbcomp/program_representation.m: Add the goal_id type. Replace the existing goal_path and goal_path_consable types with two new types, forward_goal_path and reverse_goal_path. Since these now have wrappers around the list of goal path steps that identify each kind of goal path, it is now ok to expose their representations. This makes several compiler passes easier to code. Update the set of operations on goal paths to work on the new data structures. Add a couple of step types to represent lambdas and try goals. Their omission prior to this would have been a bug for constraint-based mode analysis, or any other compiler pass prior to the expansion out of lambda and try goals that wanted to use goal paths to identify subgoals. browser/declarative_tree.m: mdbcomp/rtti_access.m: mdbcomp/slice_and_dice.m: mdbcomp/trace_counts.m: slice/mcov.m: deep_profiler/*.m: Conform to the changes in goal path representation. compiler/hlds_goal: Replace the goal_path field with a goal_id field in the goal_info, indicating that from now on, this should be used to identify goals. Keep a reverse_goal_path field in the goal_info for use by RBMM and CTGC. Those analyses were too hard to convert to using goal_ids, especially since RBMM uses goal_paths to identify goals in multi-pass algorithms that should be one-pass and should not NEED to identify any goals for later processing. compiler/goal_path: Add predicates to fill in goal_ids, and update the predicates filling in the now deprecated reverse goal path fields. Add the operations needed by the rest of the compiler on goal ids and containing goal maps. Remove the option to set goal paths using "mode equivalent steps". Constraint based mode analysis now uses goal ids, and can now do its own equivalent optimization quite simply. Move the goal_path module from the check_hlds package to the hlds package. compiler/*.m: Conform to the changes in goal path representation. Most modules now use goal_ids to identify goals, and use a containing goal map to convert the goal ids to goal paths when needed. However, the ctgc and rbmm modules still use (reverse) goal paths. library/digraph.m: library/group.m: library/injection.m: library/pprint.m: library/pretty_printer.m: library/term_to_xml.m: Minor style improvements.	2010-12-20 07:47:49 +00:00
Zoltan Somogyi	8a28e40c9b	Add the predicates sorry, unexpected and expect to library/error.m. ... Estimated hours taken: 2 Branches: main Add the predicates sorry, unexpected and expect to library/error.m. compiler/compiler_util.m: library/error.m: Move the predicates sorry, unexpected and expect from compiler_util to error. Put the predicates in error.m into the same order as their declarations. compiler/*.m: Change imports as needed. compiler/lp.m: compiler/lp_rational.m: Change imports as needed, and some minor cleanups. deep_profiler/*.m: Switch to using the new library predicates, instead of calling error directly. Some other minor cleanups. NEWS: Mention the new predicates in the standard library.	2010-12-15 06:30:36 +00:00
Zoltan Somogyi	90c505afe0	Eliminate dependencies between the processing of different predicates or ... Estimated hours taken: 16 Branches: main Eliminate dependencies between the processing of different predicates or procedures in as many cases as possible in passes_aux.m and in optimize.m, so that they can be processed in parallel. The effect of this diff on performance is negligible (a 0.1% speedup, within the noise limit). compiler/passes_aux.m: Don't export predicates that do not need to be exported. Since they were each used for one thing, inline them into their callers. Simplify the main traversal predicates to do just what is needed, and specialize them to their tasks. For tasks that do not update the module_info, the I/O state or anything else while updating a proc_info, allow the procedures of the module to be processed in parallel. Use a systematic naming scheme for the tasks. Use pred_proc_ids to identify the procedure being processed in all tasks, to avoid unnecessary variations in whether the predicates invoked by the tasks need the pred_id, the proc_id or both. compiler/mercury_compile_front_end.m: compiler/mercury_compile_middle_end.m: Update this code to conform to the changes in passes_aux.m. In several cases, conform to changes in the predicates inside the tasks as well, since (after the changes described below) several don't take a pair of I/O states anymore. compiler/mercury_compile_llds_back_end.m: Update this code to conform to the changes in passes_aux.m. In several cases, conform to changes in the predicates inside the tasks as well, since (after the changes described below) several don't take a pair of I/O states anymore. Allow the optimization of different procedures to be done in parallel with --trad-passes. compiler/accumulator.m: compiler/complexity.m: compiler/follow_code.m: compiler/loop_inv.m: compiler/mark_tail_calls.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/store_alloc.m: compiler/structure_sharing.analysis.m: compiler/tupling.m: Conform to the change in passes_aux.m. compiler/deforest.m: compiler/delay_construct.m: compiler/liveness.m: compiler/optimize.m: compiler/pd_info.m: compiler/pd_util.m: compiler/saved_vars.m: compiler/stack_alloc.m: compiler/stack_opt.m: compiler/unneeded_code.m: Conform to the change in passes_aux.m. Consistently use trace goals for progress messages, and eliminate I/O states outside those trace goals.	2010-08-05 03:07:09 +00:00
Zoltan Somogyi	30aafc69a0	Split up three big compiler modules: llds_out.m, hlds_out.m (5000+ lines each) ... Estimated hours taken: 12 Branches: main Split up three big compiler modules: llds_out.m, hlds_out.m (5000+ lines each) and deep_profiling.m (3000+ lines). Put the predicates in the resulting smaller modules into cohesive groups where possible. A few of the predicates in the original modules were unused; this diff deletes them. There are no algorithmic changes. compiler/llds_out_code_addr.m: New module containing the part of llds_out.m that outputs code addresses and labels. compiler/llds_out_data.m: New module containing the part of llds_out.m that outputs lvals, rvals and their components. compiler/llds_out_global.m: New module containing the part of llds_out.m that generates global static C data structures. compiler/llds_out_instr.m: New module containing the part of llds_out.m that outputs instructions compiler/llds_out_file.m: New module containing the top level part of llds_out.m, which coordinates the generation of a whole C source file. compiler/llds_out_util.m: New module containing the utility parts of llds_out.m. compiler/llds_out.m: Replace everything in this file with just the includes of the submodules that now have all its previous contents. compiler/hlds_llds.m: Move a predicate here from llds_out.m, since it is a utility predicate operating on a type defined here. compiler/rtti_out.m: Move a predicate here from llds_out.m, since it is a predicate generating output from a rtti type. compiler/hlds_out_mode.m: The part of hlds_out.m that deals with writing out insts and modes. compiler/hlds_out_goal.m: The part of hlds_out.m that deals with writing out goals. compiler/hlds_out_pred.m: The part of hlds_out.m that deals with writing out predicates and procedures. compiler/hlds_out_module.m: The part of hlds_out.m that deals with writing out module-wide tables. compiler/hlds_out_util.m: Parts of hlds_out.m that don't fit in anywhere else. compiler/hlds_out.m: Replace everything in this file with just the includes of the submodules that now have all its previous contents. compiler/simplify.m: compiler/hlds_goal.m: Move some insts from simplify.m to hlds_goal.m to allow hlds_out_goal.m to use them also. compiler/coverage_profiling.m: The part of deep_profiling.m that deals with coverage profiling. compiler/deep_profiling.m: Remove the code moved to coverage_profiling.m, and export the utility predicates needed by coverage_profiling.m. Remove the things moved to prog_data.m and hlds_goal.m. Put the predicates into a more logical order. compiler/hlds_goal.m: Move some predicates here from deep_profiling.m, since they belong here. compiler/prog_data.m: Move a type from deep_profiling.m here, since it belongs here. compiler/add_pragma.m: Add a predicate from llds_out.m that is used only here. compiler/*.m: Conform to the changes above.	2009-11-04 03:44:52 +00:00
Zoltan Somogyi	4ebe3d0d7e	Stop storing globals in the I/O state, and divide mercury_compile.m ... Estimated hours taken: 60 Branches: main Stop storing globals in the I/O state, and divide mercury_compile.m into smaller, more cohesive modules. (This diff started out as doing only the latter, but it became clear that this was effectively impossible without the former, and the former ended up accounting for the bulk of the changes.) Taking the globals out of the I/O state required figuring out how globals data flowed between pieces of code that were often widely separated. Such flows were invisible when globals could be hidden in the I/O state, but now they are visible, because the affected code now passes around globals structures explicitly. In some cases, the old flow looked buggy, as when one job invoked by mmc --make could affect the globals value of its parent or the globals value passed to the next job. I tried to fix such problems when I saw them. I am not 100% sure I succeeded in every case (I may have replaced old bugs with new ones), but at least now the flow is out in the open, and any bugs should be much easier to track down and fix. In most cases, changes the globals after the initial setup are intended to be in effect only during the invocation of a few calls. This used to be done by remembering the initial values of the to-be-changed options, changing their values in the globals in the I/O state, making the calls, and restoring the old values of the options. We now simply create a new version of the globals structure, pass it to the calls to be affected, and then discard it. In two cases, when discovering reasons why (1) smart recompilation should not be done or (2) item version numbers should not be generated, the record of the discovery needs to survive this discarding. This is why in those cases, we record the discovery by setting a mutable attached to the I/O state. We use pure code (with I/O states) both to read and to write the mutables, so this is no worse semantically than storing the information in the globals structure inside the I/O state. (Also, we were already using such a mutable for recording whether -E could add more information.) In many modules, the globals information had to be threaded through several predicates in the module. In some places, this was made more difficult by predicates being defined by many clauses. In those cases, this diff converts those predicates to using explicit disjunctions. compiler/globals.m: Stop storing the globals structure in the I/O state, and remove the predicates that accessed it there. Move a mutable and its access predicate here from handle_options.m, since here is when the mutables treated the same way are. In a couple of cases, the value of an option is available in a mutable for speed of access from inside performance-critical code. Set the values of those mutables from the option when the processing of option values is finished, not when it is starting, since otherwise the copies of each option could end up inconsistent. Validate the reuse strategy option here, since doing it during ctgc analysis (a) is too late, and (b) would require an update to the globals to be done at an otherwise inconvenient place in the code. Put the reuse strategy into the globals structure. Two fields in the globals structure were unused. One (have_printed_usage) was made redundant when the one predicate that used it itself became unused; the other (source_file_map) was effectively replaced by a mutable some time ago. Delete these fields from the globals. Give the fields of the globals structure a distinguishing prefix. Put the type declarations, predicate declarations and predicate definitions in a consistent order. compiler/source_file_map.m: Record this module's results only in the mutable (it serves as a cache), not in globals structure. Use explicitly passed globals structure for other purposes. compiler/handle_options.m: Rename handle_options as handle_given_options, since it does not process THE options to the program, but the options it is given, and even during the processing of a single module, it can be invoked up the three times in a row, each time being given different options. (It was up to four times in a row before this diff.) Make handle_given_options explicitly return the globals structure it creates. Since it does not take an old global structure as input and globals are not stored in the I/O state, it is now clear that the globals structure it returns is affected only by the default values of the options and the options it processes. Before this diff, in the presence of errors in the options, handle_options *could* return (implicitly, in the I/O state) the globals structure that happened to be in the I/O state when it was invoked. Provide a separate predicate for generating a dummy globals based only on the default values of options. This allows by mercury_compile.m to stop abusing a more general-purpose predicate from handle_options.m, which we no longer export. Remove the mutable and access predicate moved to globals.m. compiler/options.m: Document the fact that two options, smart_recompilation and generate_item_version_numbers, should not be used without seeing whether the functionalities they call for have been disabled. compiler/mercury_compile_front_end.m: compiler/mercury_compile_middle_passes.m: compiler/mercury_compile_llds_back_end.m: compiler/mercury_compile_mlds_back_end.m: compiler/mercury_compile_erl_back_end.m: New modules carved out of the old mercury_compile.m. They each cover exactly the areas suggested by their names. Each of the modules is more cohesive than the old mercury_compile.m. Their code is also arranged in a more logical order, with predicates representing compiler passes being defined in the order of their invocation. Some of these modules export predicates for use by their siblings, showing the dependencies between the groups of passes. compiler/top_level.m: compiler/notes/compiler_design.html: Add the new modules. compiler/mark_static_terms.m: Move this module from the ml_backend package to the hlds package, since (a) it does not depend on the MLDS in any way, and (b) it is also needed by a compiler pass (loop invariants) in the middle passes. compiler/hlds.m: compiler/ml_backend.m: compiler/notes/compiler_design.html: Reflect mark_static_terms.m's change of package. compiler/passes_aux.m: Move the predicates for dumping out the hLDS here from mercury_compile.m, since the new modules also need them. Look up globals in the HLDS, not the I/O state. compiler/hlds_module.m: Store the prefix (common part) of HLDS dump file names in the HLDS itself, so that the code moved to passes_aux.m can figure out the file name for a HLDS dump without doing system calls. Give the field names of some structures prefixes to avoid ambiguity. compiler/mercury_compile.m: Remove the code moved to the other modules. This module now looks after only option handling (such as deciding whether to generate .int3 files, .int files, .opt files etc), and the compilation passes up to and including the creation of the first version of the HLDS. Everything after that is subcontracted to the new modules. Simplify and make explicit the flow of globals information. When invoking predicates that could disable smart recompilation, check whether they have done so, and if yes, update the globals accordingly. When compiling via gcc, we need to link into the executable the object files of any separate C files we generate for C code foreign_procs, which we cannot translate into gcc's internal structures without becoming a C compiler as well as a Mercury compiler. Instead of adding such files to the accumulating option for extra object files in the globals structure, we return their names using the already existing mechanism we have always used to link the object files of fact tables into the executable. Give several predicates more descriptive names. Put predicates in a more logical order. compiler/make.m: compiler/make.dependencies.m: compiler/make.module_target.m: compiler/make.module_dep_file.m: compiler/make.program_target.m: compiler/make.util.m: Require callers to supply globals structures explicitly, not via the I/O state. Afterward pass them around explicitly, passing modified versions to mercury_compile.m when invoking it with module- and/or task-specific options. Due the extensive use of partial application for higher order code in these modules, passing around the globals structures explicitly is quite tricky here. There may be cases where a predicate uses an old globals structure it got from a closure instead of the updated module- and/or task-specific globals it should be using, or vice versa. However, it is just as likely that, this diff fixes old problems by preventing the implicit flow of updated-only-for-one-invocation globals structures back to the original invoking context. Although I have tried to be careful about this, it is also possible that in some places, the code is using an updated-for-an-invocation globals structure in some but not all of the places where it SHOULD be used. compiler/c_util.m: compiler/compile_target_code.m: compiler/compiler_util.m: compiler/error_util.m: compiler/file_names.m: compiler/file_util.m: compiler/ilasm.m: compiler/ml_optimize.m: compiler/mlds_to_managed.m: compiler/module_cmds.m: compiler/modules.m: compiler/options_file.m: compiler/pd_debug.m: compiler/prog_io.m: compiler/transform_llds.m: compiler/write_deps_file.m: Require callers to supply globals structures explicitly, not via the I/O state. In some cases, the explicit globals structure argument allows a predicate to dispense with the I/O states previously passed to it. In some modules, rename some predicates, types and/or function symbols to avoid ambiguity. compiler/read_modules.m: Require callers to supply globals structures explicitly, not via the I/O state. Record when smart recompilation and the generation of item version numbers should be disabled. compiler/opt_debug.m: compiler/process_util.m: Require callers to supply the needed options explicitly, not via the globals in the I/O state. compiler/analysis.m: compiler/analysis.file.m: compiler/mmc_analysis.m: Make the analysis framework's methods take their global structures as explicit arguments, not as implicit data stored in the I/O state. Stop using `with_type` and `with_inst` declarations unnecessarily. Rename some predicates to avoid ambiguity. compiler/hlds_out.m: compiler/llds_out.m: compiler/mercury_to_mercury.m: compiler/mlds_to_c.m: compiler/mlds_to_java.m: compiler/optimize.m: Make these modules stop accessing the globals from the I/O state. Do this by requiring the callers of their top predicates to explicitly supply a globals structure. To compensate for the cost of having to pass around a representation of the options, look up the values of the options of interest just once, to make further access much faster. (In the case of mlds_to_c.m, the code already did much of this, but it still had a few accesses to globals in the I/O state that this diff eliminates.) If the module exports a predicate that needs these pre-looked-up options, then export the type of this data structure and its initialization function. compiler/frameopt.m: Since this module needs only one option from the globals, pass that option instead of the globals. compiler/accumulator.m: compiler/add_clause.m: compiler/closure_analysis.m: compiler/complexity.m: compiler/deforest.m: compiler/delay_construct.m: compiler/elds_to_erlang.m: compiler/exception_analysis.m: compiler/fact_table.m: compiler/intermod.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/pd_util.m: compiler/post_term_analysis.m: compiler/recompilation.usage.m: compiler/size_prof.usage.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.m: compiler/structure_sharing.analysis.m: compiler/tabling_analysis.m: compiler/term_constr_errors.m: compiler/term_constr_fixpoint.m: compiler/term_constr_initial.m: compiler/term_constr_main.m: compiler/term_constr_util.m: compiler/trailing_analysis.m: compiler/trans_opt.m: compiler/typecheck_info.m: Look up globals information from the HLDS, not the I/O state. Conform to the changes above. compiler/gcc.m: compiler/maybe_mlds_to_gcc.pp: compiler/mlds_to_gcc.m: Look up globals information from the HLDS, not the I/O state. Conform to the changes above. Convert these modules to our current programming style. compiler/termination.m: Look up globals information from the HLDS, not the I/O state. Conform to the changes above. Report some warnings with error_specs, instead of immediately printing them out. compiler/export.m: compiler/il_peephole.m: compiler/layout_out.m: compiler/rtti_out.m: compiler/liveness.m: compiler/make_hlds.m: compiler/make_hlds_passes.m: compiler/mlds_to_il.m: compiler/mlds_to_ilasm.m: compiler/recompilation.check.m: compiler/stack_opt.m: compiler/superhomogeneous.m: compiler/tupling..m: compiler/unneeded_code.m: compiler/unused_args.m: compiler/unused_import.m: compiler/xml_documentation.m: Conform to the changes above. compiler/equiv_type_hlds.m: Give the field names of a structure prefixes to avoid ambiguity. Stop using `with_type` and `with_inst` declarations unnecessarily. compiler/loop_inv.m: compiler/pd_info.m: compiler/stack_layout.m: Give the field names of some structures prefixes to avoid ambiguity. compiler/add_pragma.m: Add notes. compiler/string.m: NEWS: Add a det version of remove_suffix, for use by new code above.	2009-10-14 05:28:53 +00:00
Zoltan Somogyi	77a6a6c10c	Implement several more changes that together speed up compilation time ... Estimated hours taken: 16 Branches: main Implement several more changes that together speed up compilation time on training_cars_full by 12%, and also improve tools/speedtest -h by 7.2% and tools/speedtest by 1.6%. The first change is designed to eliminate the time that the compiler spends constructing error messages that are then ignored. The working predicates of prog_io_sym_name used to always return a single result, which either gave a description of the thing being looked, or an error message. However, in many places, the caller did not consider not finding the thing being looked for to be an error, and thus threw away the error message, keeping only the "not found" indication. For each predicate with such callers, this diff provides a parallel predicate that indicates "not found" simply by failing. This allows us to eliminate the construction of the error message, the preparation for the construction of the error message (usually by describing the context), and the construction of the "ok" wrapper. The second change is to specialize the handling of from_ground_term_construct scopes in the termination analyzer. To make this easier, I also cleaned up of the infrastructure of the termination analyzer. The third change is to avoid traversing from_ground_term_construct scopes in quantification.m when finding the variables in a goal, since termination analysis no longer needs the information it gathers. The fourth change is to avoid traversing second and later conjuncts in conjunctions twice. The first step in handling conjunctions is to call implicitly_quantify_conj, which builds up a data structure that pairs each conjunct with the variables that occur free in all the conjuncts following it. However, after this was done and each conjunct was annotated with its nonlocals, we used to compute the variables that occur free in the conjunction as a whole from scratch. This diff changes the code so that we now compute that set based on the information we gathered earlier, avoiding a redundant traversal. The fifth change is to create specialized, lower-arity versions of many of the predicates in quantification.m. These versions are intended for traversals that take place after the compiler has replaced lambda expressions with references to separate procedures. These traversals do not need to pass around arguments representing the variables occurring free in the (now non-existent) lambda expressions. compiler/prog_io_sym_name.m: Make the first change described above. Change some predicate names to adopt a consistent naming scheme in which predicates that do the same job and differ only in how they handle errors have names that differ only in a "try_" prefix. Add some predicate versions that do common tests on the output of the base versions. For example, try_parse_sym_name_and_no_args is a version of try_parse_sym_name_and_args that insists on finding an empty argument list. Remove the unused "error term" argument that we used to need a while ago. Move some predicate definitions to make their order match the order of their declarations. Turn a predicate into a function for its caller's convenience. compiler/term_constr_build.m: Make the second change described above by modeling each from_ground_term_construct scope as a single unification, assigning the total size of the ground term to the variable being built. compiler/term_constr_util.m: Put the arguments of some predicates into a more standard order. compiler/lp_rational.m: Change the names of some function symbols to avoid both the use of graphic characters that require quoting and clashes with other types. Change the names of some predicates to make their purpose clear, and to avoid ambiguity. compiler/quantification.m: Make the third, fourth and fifth changes described above. compiler/*.m: Conform to the changes above.	2009-09-08 02:43:41 +00:00
Zoltan Somogyi	b72243cadf	Lookups in the map from type_ctors to their definitions are relatively ... Estimated hours taken: 6 Branches: main Lookups in the map from type_ctors to their definitions are relatively expensive, due to the cost of repeatedly comparing type_ctors, comparisons that are relatively expensive. This diff replaces that direct map with a two-stage map, the first stage being a map on the type constructor name (a plain string), and the second stage being a map of the full type_ctor. Most of the job of searching is done by the first map, since the second map can be expected to have only one entry most of the time. An earlier diff yielded a reduction of 1.1% in compilation time, as measured by a version of tools/speedtest which compiles six modules in grade hlc.gc. The speedup when compiling in grade asm_fast.gc was 0.6%. (The MLDS code generator does more lookups of type definitions than the LLDS code generator.) This diff also has some more changes that led to some further speedups, but I don't have the original basis for comparison anymore. Note that making the type table's type abstract leads to a slowdown, but the faster data structure more than compensates for it. compiler/hlds_data.m: Make the type table an abstract type, and change its representation as described above. Provide the operations on it that are needed by the other modules of the compiler. compiler/*.m: Use the operations provided by hlds_data.m instead of operations on maps to access the type table. In several cases replace old code that iterated on keys and looked up the associated values in the map, with new code that iterates on an association list that puts the value right next to its key (a list that the old code just threw away). In other cases, change code that iterated on a list of the keys to iterating on the whole assoc_list instead, paying attention only to the keys. This is faster, since it avoids allocating memory for the list of keys. compiler/type_ctor_info.m: This module used to use a roundabout method of generating type_ctor_gen_infos for the builtin types conceptually defined in builtin.m. It used to add their type_ctors to the list of user-defined type_ctors it processed, and the code that processed each type_ctor would check whether it was one of these, and if yes, handle them specially. This diff makes the code handle these builtin type_ctors and user-defined type_ctors separately, avoiding a whole bunch of tests. compiler/typecheck_errors.m: Sort lists of types shown in error messages. The new data type table would naturally lead to slightly different orders of types in error messages than the old one; this change neutralizes such effects for the future. tests/invalid/ambiguous_overloading.err_exp: tests/invalid/errors2.err_exp: tests/warnings/ambiguous_overloading.exp: Expect sorted types in error messages.	2009-09-04 02:28:10 +00:00
Zoltan Somogyi	0329ea98ec	Make all the front-end passes that do not currently return errors as a ... Estimated hours taken: 3 Branches: main Make all the front-end passes that do not currently return errors as a list of error specifications do so. Use trace goals to print progress and debugging messages. compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/polymorphism.m: compiler/simplify.m: compiler/stratify.m: compiler/switch_detection.m: compiler/try_expand.m: Effect the change described above. In stratify.m, replace some booleans with purpose-specific types. compiler/error_util.m: Add support for inst_check.m's new needs. compiler/passes_aux.m: Update the traversal alternative used by simplify to meet simplify's new needs. compiler/mercury_compile.m: Conform to the changes above. Amongst other things, this means printing the error specifications returned by the various passes. compiler/structure_sharing.analysis.m: Conform to the changes above. compiler/prop_mode_constraints.m: Minor style cleanups. tests/warnings/inst_with_no_type.exp: Expect the new, properly sorted output.	2009-07-21 04:10:45 +00:00
Zoltan Somogyi	d69ba1a1f0	Include the type_ctor in cons_ids for user-defined types. ... Estimated hours taken: 32 Branches: main Include the type_ctor in cons_ids for user-defined types. The intention is two-fold: - It prepares for a future in which we allow more than one function symbol to with the same name to be defined in a module. - It makes the HLDS code more self-contained. In many places, processing construction and deconstruction unifications required knowing which type the cons_id belongs to, but until now, code couldn't know that unless it kept track of the type of the variable unified with the cons_id. With this diff, user-defined cons_ids are represented as cons(SymName, Arity, TypeCtor) The last field is filled in during post-typecheck. After that time, any module qualification in the SymName (which may initially be partial) is redundant, since it is also available in the TypeCtor. In the future, we could make all those SymNames be just unqualified(_) at that time. We could also replace the current maps in HLDS type definitions with full cons_id keys with just name/arity keys (since the module qualifier is a given for any given type definition), we could also support partially qualified cons_ids in source code using a map from name/arity pairs to a list of all the type_ctors that have function symbols with that name/arity, instead of our current practice of inserting all possible partially module qualified version of every cons_id into a single giant table, and we could do the same thing with the field names table. This diff also separates tuples out from user-defined types, since in many respects they are different (they don't have a single type_ctor, for starters). It also separates out character constants, since they were alreay treated specially in most places, though not in some places where they *ought* to have been treated specially. Take the opportunity to give some other cons_ids better names. compiler/prog_data.m: Make the change described above, and document it. Put the implementations of the predicates declared in each part of this module next to the declarations, instead of keeping all the code until the very end (where it was usually far from their declarations). Remove three predicates with identical definitions from inst_match.m, inst_util.m and mode_constraints.m, and put the common definition in prog_data.m. library/term_io.m: Add a new predicate that is basically a reversible version of the existing function espaced_char, since the definition of char_consts needs reversibilty. compiler/post_typecheck.m: For functors of user-defined types, record their type_ctor. For tuples and char constants, record them as such. compiler/builtin_lib_types.m: compiler/parse_tree.m: compiler/notes/compiler_design.html: New module to centralize knowledge about builtin types, specially handled library types, and their function symbols. Previously, the stuff now in this module used to be in several different places, including prog_type.m and stm_expand.m, and some of it was duplicated. mdbcomp/prim_data.m: Add some predicates now needed by builtin_lib_types.m. compiler/builtin_ops.m: Factor out some duplicated code. compiler/add_type.m: Include the relevant type_ctors in the cons_ids generated in type definitions. compiler/hlds_data.m: Document an existing type better. Rename a cons_tag in sync with its corresponding cons_id. Put some declarations into logical order. compiler/hlds_out.m: Rename a misleadingly-named predicate. compiler/prog_ctgc.m: compiler/term_constr_build.m: Add XXXs for questionable existing code. compiler/add_clause.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/bytecode_gen.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/complexity.m: compiler/ctgc_selector.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/delay_partial_inst.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/erl_rtti.m: compiler/erl_unify_gen.m: compiler/export.m: compiler/field_access.m: compiler/foreign.m: compiler/format_call.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_desc.m: compiler/hlds_goal.m: compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/inst_graph.m: compiler/inst_match.m: compiler/inst_util.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/make_tags.m: compiler/mercury_compile.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/mlds_to_java.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_ordering.m: compiler/mode_util.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/polymorphism.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/prog_io_util.m: compiler/prog_mode.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/prog_type.m: compiler/prog_util.m: compiler/purity.m: compiler/qual_info.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/simplify.m: compiler/simplify.m: compiler/special_pred.m: compiler/ssdebug.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbagem: compiler/superhomoegenous.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/try_expand.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unify_modes.m: compiler/untupling.m: compiler/unused_imports.m: compiler/xml_documentation.m: Minor changes, mostly to ignore the type_ctor in cons_ids in places where it is not needed, take the type_ctor from the cons_id in places where it is more convenient, conform to the new names of some cons_ids, conform to the changes in hlds_out.m, and/or add now-needed imports of builtin_lib_types.m. In some places, the handling previously applied to cons/2 (which included tuples and character constants as well as user-defined function symbols) is now applied only to user-defined function symbols or to user-defined function symbols and tuples, as appropriate, with character constants being handled more like the other kinds of constants. In inst_match.m, rename a whole bunch of predicates to avoid ambiguities. In prog_util.m, remove two predicates that did almost nothing yet were far too easy to misuse.	2009-06-11 07:00:38 +00:00
Zoltan Somogyi	b000cb322e	Provide compiler support for Software Transactional Memory through the new ... Estimated hours taken: 80 by zs, and lots more by lmika Branches: main Provide compiler support for Software Transactional Memory through the new atomic goal. This work was done by Leon Mika; I merely brought it up to date, resolved conflicts, and cleaned up a few things. There are still several aspects that are as yet incomplete. library/ops.m: Add the operators needed for the syntax of atomic scopes. library/stm_builtin.m: Add the builtin operations needed for the implementation of atomic goals. compiler/hlds_goal.m: Add a new HLDS goal type, which represents an atomic goal and its possible fallbacks (in case an earlier goal throws an exception). Rename the predicate goal_is_atomic as goal_expr_has_subgoals, since now its old name would be misleading. compiler/prog_data.m: compiler/prog_item.m: Add a parse tree representation of the new kind of goal. compiler/prog_io_goal.m: Parse the new kind of goal. compiler/add_clause.m: Translate atomic goals from parse tree form to HLDS. compiler/typecheck.m: compiler/typecheck_errors.m: Do type checking of atomic goals. compiler/modes.m: Do mode checking of atomic goals, and determine whether they are nested or not. compiler/unique_modes.m: Do unique mode checking of atomic goals. compiler/stm_expand.m: New module to expand atomic goals into sequences of simpler goals. library/stm_builtin.m: Add the primitives needed by the transformation. Improve the existing debugging support. mdbcomp/prim_data.m: Add utility functions to allow stm_expand.m to refer to modules in the library. mdbcomp/program_representation.m: Expand the goal_path type to allow the representation of components of atomic goals. compiler/notes/compiler_design.html: Document the new module. compiler/transform_hlds.m: Include the new module in the compiler. compiler/mercury_compile.m: Invoke the STM transformation. compiler/hlds_module.m: Add an auxiliary counter used by the STM transformation. compiler/hlds_pred.m: Add a new predicate origin: the STM transformation. compiler/modules.m: Import the STM builtin module automatically if the module contains any atomic goals. 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/cse_detection.m: compiler/deep_profiling.m: compiler/code_util.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/exception_analysis.m: compiler/follow_code.m: compiler/format_call.m: compiler/goal_form.m: compiler/goal_path.m: compiler/goal_util.m: compiler/granularity.m: compiler/hlds_out.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/intermod.m: compiler/lambda.m: compiler/layout_out.m: compiler/lco.m: compiler/lookup_switch.m: compiler/make_hlds_warn.m: compiler/mark_static_terms.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_code_gen.m: compiler/mode_constraint_robdd.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/mode_util.m: compiler/ordering_mode_constraints.m: compiler/pd_cost.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_rep.m: compiler/prog_type.m: compiler/prop_mode_constraints.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_info.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prog.m: compiler/smm_common.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/switch_detection.m: compiler/unused_imports.m: compiler/granularity.m: compiler/granularity.m: Conform to the changes above. Mostly this means handling the new kind of goal. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/build_mode_constraints.m: compiler/closure_analysis.m: compiler/dead_proc_elim.m: compiler/deforest.m: compiler/follow_vars.m: compiler/higher_order.m: compiler/live_vars.m: compiler/liveness.m: compiler/loop_inv.m: compiler/module_qual.m: compiler/prog_util.m: compiler/purity.m: compiler/quantification.m: compiler/store_alloc.m: compiler/stratify.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/trailing_analysis.m: Conform to the changes above. Mostly this means handling the new kind of goal. Switch syntax from clauses to disj. runtime/mercury_stm.[ch]: Implement the primitives needed by the STM transformation. Add more debugging support to the existing primitives. library/term.m: Generalize get_term_context to work on terms of all kinds.	2008-02-27 07:23:57 +00:00
Zoltan Somogyi	f2a92143c4	Add prefixes to the field names of a bunch of structures, to make ... Estimated hours taken: 6 Branches: main compiler/*.m: Add prefixes to the field names of a bunch of structures, to make tags files more useful (by avoiding getting a bunch of irrelevant matches when searching for an identifier). In some cases, add prefixes to the names of function symbols and predicates, for the same reason. In some cases, rename the variables holding the structures, when doing so improves the clarity of code. (When a module passes around structures of more than one kind, it shouldn't name *both* of them just "Info".) Take some other opportunities for cleanups, e.g. using type_to_ctor_and_args_det instead of just plain type_to_ctor_and_args and a call to error.	2008-01-29 04:59:45 +00:00
Zoltan Somogyi	672f77c4ec	Add a new compiler option. --inform-ite-instead-of-switch. ... Estimated hours taken: 20 Branches: main Add a new compiler option. --inform-ite-instead-of-switch. If this is enabled, the compiler will generate informational messages about if-then-elses that it thinks should be converted to switches for the sake of program reliability. Act on the output generated by this option. compiler/simplify.m: Implement the new option. Fix an old bug that could cause us to generate warnings about code that was OK in one duplicated copy but not in another (where a switch arm's code is duplicated due to the case being selected for more than one cons_id). compiler/options.m: Add the new option. Add a way to test for the bug fix in simplify. doc/user_guide.texi: Document the new option. NEWS: Mention the new option. library/*.m: mdbcomp/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: Convert if-then-elses to switches at most of the sites suggested by the new option. At the remaining sites, switching to switches would have nontrivial downsides. This typically happens with the switched-on type has many functors, and we treat one or two specially (e.g. cons/2 in the cons_id type). Perform misc cleanups in the vicinity of the if-then-else to switch conversions. In a few cases, improve the error messages generated. compiler/accumulator.m: compiler/hlds_goal.m: (Rename and) move insts for particular kinds of goal from accumulator.m to hlds_goal.m, to allow them to be used in other modules. Using these insts allowed us to eliminate some if-then-elses entirely. compiler/exprn_aux.m: Instead of fixing some if-then-elses, delete the predicates containing them, since they aren't used, and (as pointed out by the new option) would need considerable other fixing if they were ever needed again. compiler/lp_rational.m: Add prefixes to the names of the function symbols on some types, since without those prefixes, it was hard to figure out what type the switch corresponding to an old if-then-else was switching on. tests/invalid/reserve_tag.err_exp: Expect a new, improved error message.	2007-11-23 07:36:01 +00:00
Zoltan Somogyi	168f531867	Add new fields to the goal_info structure for region based memory management. ... Estimated hours taken: 4 Branches: main Add new fields to the goal_info structure for region based memory management. The fields are currently unused, but (a) Quan will add the code to fill them in, and then (b) I will modify the code generator to use the filled in fields. compiler/hlds_goal.m: Make the change described above. Group all the procedures that access goal_info components together. Some of the getters were predicates while some were functions, so this diff changes them all to be functions. (The setters remain predicates.) compiler/*.m: Trivial changes to conform to the change in hlds_goal.m. In simplify.m, break up a huge (800+ line) predicate into smaller pieces.	2007-08-07 07:10:09 +00:00
Zoltan Somogyi	2bada9761f	Eliminate some code duplication by unifying the two goal_path types have had ... Estimated hours taken: 2 Branches: main Eliminate some code duplication by unifying the two goal_path types have had until now: one in mdbcomp/program_representation.m and compiler/hlds_goal.m, which differed in only one detail (whether we record the total number of arms in a switch). The new type is in program_representation.m, but with the definition from goal_path.m. Add a "step_" prefix to the function symbols of the goal_path_step type, to avoid ambiguity with the hlds goals the steps describe. Turn the predicates operating on goal_paths into functions for greater convenience of use. mdbcomp/program_representation.m: compiler/hlds_goal.m: Make the change described above. browser/*.m: compiler/*.m: mdbcomp/*.m: slice/*.m: Conform to the change above. tests/debugger/*.exp: Expect the extra information now available for goal path steps describing switches.	2007-01-06 10:56:27 +00:00
Zoltan Somogyi	ba93a52fe7	This diff changes a few types from being defined as equivalent to a pair ... Estimated hours taken: 10 Branches: main This diff changes a few types from being defined as equivalent to a pair to being discriminated union types with their own function symbol. This was motivated by an error message (one of many, but the one that broke the camel's back) about "-" being used in an ambiguous manner. It will reduce the number of such messages in the future, and will make compiler data structures easier to inspect in the debugger. The most important type changed by far is hlds_goal, whose function symbol is now "hlds_goal". Second and third in importance are llds.instruction (function symbol "llds_instr") and prog_item.m's item_and_context (function symbol "item_and_context"). There are some others as well. In several places, I rearranged predicates to factor the deconstruction of goals into hlds_goal_expr and hlds_goal_into out of each clause into a single point. In many places, I changed variable names that used "Goal" to refer to just hlds_goal_exprs to use "GoalExpr" instead. I also changed variable names that used "Item" to refer to item_and_contexts to use "ItemAndContext" instead. This should make reading such code less confusing. I renamed some function symbols and predicates to avoid ambiguities. I only made one algorithmic change (at least intentionally). In assertion.m, comparing two goals for equality now ignores goal_infos for all kinds of goals, whereas previously it ignored them for most kinds of goals, but for shorthand goals it was insisting on them being equal. This seemed to me to be a bug. Pete, can you confirm this?	2007-01-06 09:23:59 +00:00
Julien Fischer	b4c3bb1387	Clean up in unused module imports in the Mercury system detected ... Estimated hours taken: 3 Branches: main Clean up in unused module imports in the Mercury system detected by --warn-unused-imports. analysis/*.m: browser/*.m: deep_profiler/*.m: compiler/*.m: library/*.m: mdbcomp/*.m: profiler/*.m: slice/*.m: Remove unused module imports. Fix some minor departures from our coding standards. analysis/Mercury.options: browser/Mercury.options: deep_profiler/Mercury.options: compiler/Mercury.options: library/Mercury.options: mdbcomp/Mercury.options: profiler/Mercury.options: slice/Mercury.options: Set --no-warn-unused-imports for those modules that are used as packages or otherwise break --warn-unused-imports, e.g. because they contain predicates with both foreign and Mercury clauses and some of the imports only depend on the latter.	2006-12-01 15:04:40 +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
Zoltan Somogyi	00741b0162	This diff contains no algorithmic changes. ... Estimated hours taken: 6 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch more function symbols to reduce ambiguity. After this diff, the summary line from the mdb command "ambiguity -f" is Total: 351 names used 975 times, maximum 31, average: 2.78 browser/*.m: compiler/*.m: Rename function symbols to eliminate ambiguities. tests/debugger/declarative/dependency.exp: tests/debugger/declarative/dependency2.exp: Update the expected out where some internal function symbol names appear in the output of the debugger. (This output is meant for implementors only.)	2006-08-22 05:04:29 +00:00
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
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