93 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	2dc982cfe4	Make a representation of the program available to the deep profiler. ... Estimated hours taken: 50 Branches: main Make a representation of the program available to the deep profiler. We do this by letting the user request, via the option "--deep-procrep-file" in MERCURY_OPTIONS, that when the Deep.data file is written, a Deep.procrep file should be written alongside it. The intended use of this information is the discovery of profitable parallelism. When a conjunction contains two expensive calls, e.g. p(...) and q(...) connected by some shared variables, the potential gain from executing them in parallel is limited by how early p produces those variables and how late q consumes them, and knowing this requires access to the code of p and q. Since the debugger and the deep profiler both need access to program representations, put the relevant data structures and the operations on them in mdbcomp. The data structures are significantly expanded, since the deep profiler deals with the whole program, while the debugger was interested only in one procedure at a time. The layout structures have to change as well. In a previous change, I changed proc layout structures to make room for the procedure representation even in non-debugging grades, but this isn't enough, since the procedure representation refers to the module's string table. This diff therefore makes some parts of the module layout structure, including of course the string table, also available in non-debugging grades. configure.in: Check whether the installed compiler can process switches on foreign enums correctly, since this diff depends on that. runtime/mercury_stack_layout.[ch]: runtime/mercury_types.h: Add a new structure, MR_ModuleCommonLayout, that holds the part of the module layout that is common to deep profiling and debugging. runtime/mercury_deep_profiling.[ch]: The old "deep profiling token" enum type was error prone, since at each point in the data file, only a subset was applicable. This diff breaks up the this enum into several enums, each consisting of the choice applicable at a given point. This also allows some of the resulting enums to be used in procrep files. Rename some enums and functions to avoid ambiguities, and in one case to conform to our naming scheme. Make write_out_proc_statics take a second argument. This is a FILE * that (if not NULL) asks write_out_proc_statics to write the representation of the current module to specified stream. These module representations go into the middle part of the program representation file. Add functions to write out the prologue and epilogue of this file. Write out procedure representations if this is requested. Factor out some code that is now used in more than one place. runtime/mercury_deep_profiling_hand.h: Conform to the changes to mercury_deep_profiling.h. runtime/mercury_builtin_types.c: Pass the extra argument in the argument lists of invocations of write_out_proc_statics. runtime/mercury_trace_base.[ch]: Conform to the name change from proc_rep to proc_defn_rep in mdbcomp. runtime/mercury_grade.h: Due to the change to layout structures, increment the binary compatibility version numbers for both debug and deep profiling grades. runtime/mercury_wrapper.[ch]: Provide two new MERCURY_OPTION options. The first --deep-procrep-file, allows the user to ask for the program representation to be generated. The second, --deep-random-write, allows tools/bootcheck to request that only a fraction of all program invocations should generate any deep profiling output. The first option will be documented once it is tested much more fully. The second option is deliberately not documented. Update the type of the variable that holds the address of the (mkinit-generated) write_out_proc_statics function to accept the second argument. util/mkinit.c: Pass the extra argument in the argument list of write_out_proc_statics. mdbcomp/program_representation.m: Extend the existing data structures for representing a procedure body to represent a procedure (complete with name), a module and a program. The name is implemented as string_proc_label, a form of proc_label that can be written out to files. This replaces the old proc_id type the deep profiler. Extend the representation of switches to record the identity of the variable being switched on, and the cons_ids of the arms. Without the former, we cannot be sure when a variable is first used, and the latter is needed for meaningful prettyprinting of procedure bodies. Add code for reading in files of bytecodes, and for making sense of the bytecodes themselves. (It is this code that uses foreign enums.) mdbcomp/prim_data.m: Note the relationship of proc_label with string_proc_label. mdbcomp/rtti_access.m: Add the access operations needed to find module string tables with the new organization of layout structures. Provide operations on bytecodes and string tables generally. trace/mercury_trace_cmd_browsing.c: Conform to the change to mdbcomp/program_representation.m. compiler/layout.m: Add support for a MR_ModuleCommonLayout. Rename some function symbols to avoid ambiguities. compiler/layout_out.m: Handle the new structure. compiler/stack_layout.m: Generate the new structure and the procedure representation bytecode in deep profiling grades. compiler/llds_out.m: Generate the code required to write out the prologue and epilogue of program representation files. Pass the extra argument in the argument lists of invocations of write_out_proc_statics that tells those invocations to write out the module representations between the prologue and the epilogue. compiler/prog_rep.m: When generating bytecodes, include the new information for switches. compiler/continuation_info.m: Replace a bool with a more expressive type. compiler/proc_rep.m: Conform to the change to continuation_info.m. compiler/opt_debug.m: Conform to the change to layout.m. deep_profiler/mdprof_procrep.m: A new test program to test the reading of program representations. deep_profiler/DEEP_FLAGS.in: deep_profiler/Mmakefile: Copy the contents of the mdbcomp module to this directory on demand, instead of linking to it. This is necessary now that the deep profiler depends directly on mdbcomp even if it is compiled in a non-debugging grade. The arrangements for doing this were copied from the slice directory, which has long done the same. Avoid a duplicate include of Mmake.deep.params. Add the new test program to the list of programs in this directory. Mmakefile: Go through deep_profiler/Mmakefile when deciding whether to do "mmake depend" in the deep_profiler directory. The old actions won't work correctly now that we need to copy some files from mdbcomp before we can run "mmake depend". deep_profiler/profile.m: Remove the code that was moved (in cleaned-up form) to mdbcomp. deep_profiler/dump.m: deep_profiler/profile.m: Conform to the changes above. browser/declarative_execution.m: browser/declarative_tree.m: Conform to the changes in mdbcomp. doc/user_guide.texi: Add commented out documentation of the two new options. slice/Mmakefile: Fix formatting, and a bug. library/exception.m: library/par_builtin.m: library/thread.m: library/thread.semaphore.m: Update all the handwritten modules to pass the extra argument now required by write_out_proc_statics. tests/debugger/declarative/dependency.exp: Conform to the change from proc_rep to proc_defn_rep. tools/bootcheck: Write out deep profiling data only from every 25th invocation, since otherwise the time for a bootcheck takes six times as long in deep profiling grades than in asm_fast.gc. However, do test the ability to write out program representations. Use the mkinit from the workspace, not the installed one. Don't disable line wrapping.	2007-09-12 06:21:20 +00:00
Zoltan Somogyi	0d6c3c9fdf	Satisfy a request by Peter Ross: give mdb users the ability to specify ... Estimated hours taken: 8 Branches: main Satisfy a request by Peter Ross: give mdb users the ability to specify exactly which events inside a procedure they want to put breakpoints on. Amongst other things, this can make checking postconditions easier: you can now put a conditional breakpoint on only the exit event. runtime/mercury_stack_layout.h: Add to the exec trace part of proc layouts fields describing an array of the label layouts describing the events of the procedure. This is the most direct way to implement the new functionality. (In theory, we could search the data structures that map file names and line numbers to label layouts, but that would be complex, inefficient, and *error prone*.) To make room for the new fields, and to prepare for making the procedure body available to the deep profiler as well (which could use it to map execution frequencies of calls back to their location in the procedure body, and thus to things like the frequencies with which various switch arms are selected), move the procedure body of the execution-trace-specific part of the proc layout, and to where the deep profiler could in the future also get at it. runtime/mercury_goto.h: Add macros for declaring more than one label layout structure at a time. compiler/layout.m: Implement the changes in mercury_stack_layout.h in the compiler's data structures as well. compiler/stack_layout.m: Conform to the changes in mercury_stack_layout.h. Turn some tuples into named types. compiler/layout_out.m: Conform to the changes in mercury_stack_layout.h. Add a mechanism to declare the label layouts in the new array before referring to them, by generalizing some existing code. Make this code require that the label layouts we refer to via the macros in mercury_goto.h match the declarations generated by those macros, i.e. that they have information about variables (if debugging is enabled, they will). compiler/opt_debug.m: Conform to the change to layout.m. compiler/prog_rep.m: Make a predicate name more expressive. trace/mercury_trace_cmd_breakpoint.c: Implement the new way of using the "break" command, which is to add a port name after the procedure specification. Register procedures at the start of the function implementing the "break" command, instead of "on demand", since all alternatives eventually do demand it. Write ambiguity reports wholly to mdb's stdout, instead of partially to stderr and partially to stdout. trace/mercury_trace_spy.c: Print the port and the goal path for breakpoints on specific events. Make the invocation conditions left-aligned, not right-aligned. doc/user_guide.texi: Document the new way of using the "break" command. NEWS: Announce the new capability. tests/queens.{inp,exp,exp2}: Add tests of the new capability. tests/breakpoints.{exp,exp}: tests/lval_desc_array.{exp,exp2}: Expect the new alignment of invocation conditions.	2007-06-12 06:06:35 +00:00
Julien Fischer	9958d3883c	Fix some formatting. ... Estimated hours taken: 0 Branches: main Fix some formatting. compiler/distance_granularity.m: compiler/exception_analysis.m: compiler/implicit_parallelism.m: compiler/inst_graph.m: compiler/interval.m: compiler/layout_out.m: compiler/lp_rational.m: compiler/make.program_target.m: compiler/modules.m: compiler/prog_data.m: compiler/purity.m: compiler/recompilation.check.m: compiler/term_constr_data.m: compiler/term_util.m: compiler/xml_documentation.m: deep_profiler/mdprof_cgi.m: library/pqueue.m: profiler/output.m: Fix the positioning of commas. s/[_|_]/[_ | _]/ in a spot.	2007-05-23 10:09:24 +00:00
Zoltan Somogyi	ebb805a2d3	Currently, all disjuncts from a disjunction generate an event with the same ... Estimated hours taken: 3 Branches: main Currently, all disjuncts from a disjunction generate an event with the same port: MR_PORT_DISJ. However, the declarative debugger treats first disjuncts differently from later ones, and the g12 visualizer will want this distinction too. Therefore this diff splits MR_PORT_DISJ into two: MR_PORT_DISJ_FIRST and MR_PORT_DISJ_LATER. (The visualizer will also probably want to know when the disjunction is complete, but it is not yet known whether this should be done as a separate port type for the last disjunct or a new kind of event that happens when execution backtracks out of the disjunction overall, so we hold off for now.) runtime/mercury_trace_base.[ch]: Make the split described above. Move the user-visible names of ports from the source file to the header file to make them easier to maintain. Update the list of places that need to be updated when the list of ports is changed. Have two sets of names for trace ports: one that uniquely identifies each port, and one that conflates MR_PORT_DISJ_FIRsT and MR_PORT_DISJ_LATER. The first is for use by automatic tools, the second is for presentation to humans (so that mdb output, for example, remains the same.) Put some parts of the header file in a more logical order. browser/declarative_execution.m: mdbcomp/prim_data.m: mdbcomp/trace_counts.m: compiler/layout_out.m: trace/mercury_trace_internal.m: trace/mercury_trace_tables.m: Conform to the above changes. compiler/trace_params.m: Conform to the above changes. Start numbering ports from 0, since C enums start from 0. This change has no repercussions since we don't yet have any code that depends on the details of the encoding. compiler/trace_gen.m: Decide which kind of disj event to create. trace/mercury_trace_declarative.c: Handle first and later disjuncts separately.	2007-05-02 02:16:02 +00:00
Simon Taylor	5647714667	Make all functions which create strings from characters throw an exception ... Estimated hours taken: 15 Branches: main Make all functions which create strings from characters throw an exception or fail if the list of characters contains a null character. This removes a potential source of security vulnerabilities where one part of the program performs checks against the whole of a string passed in by an attacker (processing the string as a list of characters or using `unsafe_index' to look past the null character), but then passes the string to another part of the program or an operating system call that only sees up to the first null character. Even if Mercury stored the length with the string, allowing the creation of strings containing nulls would be a bad idea because it would be too easy to pass a string to foreign code without checking. For examples see: <http://insecure.org/news/P55-07.txt> <http://www.securiteam.com/securitynews/5WP0B1FKKQ.html> <http://www.securityfocus.com/archive/1/445788> <http://www.securityfocus.com/archive/82/368750> <http://secunia.com/advisories/16420/> NEWS: Document the change. library/string.m: Throw an exception if null characters are found in string.from_char_list and string.from_rev_char_list. Add string.from_char_list_semidet and string.from_rev_char_list_semidet which fail rather throwing an exception. This doesn't match the normal naming convention, but string.from_{,rev_}char_list are widely used, so changing their determinism would be a bit too disruptive. Don't allocate an unnecessary extra word for each string created by from_char_list and from_rev_char_list. Explain that to_upper and to_lower only work on un-accented Latin letters. library/lexer.m: Check for invalid characters when reading Mercury strings and quoted names. Improve error messages by skipping to the end of any string or quoted name containing an error. Previously we just stopped processing at the error leaving an unmatched quote. library/io.m: Make io.read_line_as_string and io.read_file_as_string return an error code if the input file contains a null character. Fix an XXX: '\0\' is not recognised as a character constant, but char.det_from_int can be used to make a null character. library/char.m: Explain the workaround for '\0\' not being accepted as a char constant. Explain that to_upper and to_lower only work on un-accented Latin letters. compiler/layout.m: compiler/layout_out.m: compiler/c_util.m: compiler/stack_layout.m: compiler/llds.m: compiler/mlds.m: compiler/ll_backend.*.m: compiler/ml_backend.*.m: Don't pass around strings containing null characters (the string tables for the debugger). This doesn't cause any problems now, but won't work with the accurate garbage collector. Use lists of strings instead, and add the null characters when writing the strings out. tests/hard_coded/null_char.{m,exp}: Change an existing test case to test that creation of a string containing a null throws an exception. tests/hard_coded/null_char.exp2: Deleted because alternative output is no longer needed. tests/invalid/Mmakefile: tests/invalid/null_char.m: tests/invalid/null_char.err_exp: Test error messages for construction of strings containing null characters by the lexer. tests/invalid/unicode{1,2}.err_exp: Update the expected output after the change to the handling of invalid quoted names and strings.	2007-03-18 23:35:04 +00:00
Zoltan Somogyi	b56885be93	Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. ... Estimated hours taken: 12 Branches: main Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. The problem was not in lco.m, but in follow_code.m. In some cases, (specifically, the LCMC version of insert_2 in sparse_bitset.m), follow_code.m moved an impure goal (store_at_ref) into the arms of an if-then-else without marking those arms, or the if-then-else, as impure. The next pass, simplify, then deleted the entire if-then-else, since it had no outputs. (The store_at_ref that originally appeared after the if-then-else was the only consumer of its only output.) The fix is to get follow_code.m to make branched control structures such as if-then-elses, as well as their arms, semipure or impure if a goal being moved into them is semipure or impure, or if they came from an semipure or impure conjunction. Improve the optimization of the LCMC version of sparse_bitset.insert_2, which had a foreign_proc invocation of bits_per_int in it: replace such invocations with a unification of the bits_per_int constant if not cross compiling. Add a new option, --optimize-constructor-last-call-null. When set, LCMC will assign NULLs to the fields not yet filled in, to avoid any junk happens to be there from being followed by the garbage collector's mark phase. This diff also makes several other changes that helped me to track down the bug above. compiler/follow_code.m: Make the fix described above. Delete all the provisions for --prev-code; it won't be implemented. Don't export a predicate that is not now used anywhere else. compiler/simplify.m: Make the optimization described above. compiler/lco.m: Make sure that the LCMC specialized procedure is a predicate, not a function: having a function with the mode LCMC_insert_2(in, in) = in looks wrong. To avoid name collisions when a function and a predicate with the same name and arity have LCMC applied to them, include the predicate vs function status of the original procedure included in the name of the new procedure. Update the sym_name of calls to LCMC variants, not just the pred_id, because without that, the HLDS dump looks misleading. compiler/pred_table.m: Don't have optimizations like LCMC insert new predicates at the front of the list of predicates. Maintain the list of predicates in the module as a two part list, to allow efficient addition of new pred_ids at the (logical) end without using O(N^2) algorithms. Having predicates in chronological order makes it easier to look at HLDS dumps and .c files. compiler/hlds_module.m: Make module_info_predids return a module_info that is physically updated though logically unchanged. compiler/options.m: Add --optimize-constructor-last-call-null. Make the options --dump-hlds-pred-id, --debug-opt-pred-id and --debug-opt-pred-name into accumulating options, to allow the user to specify more than one predicate to be dumped (e.g. insert_2 and its LCMC variant). Delete --prev-code. doc/user_guide.texi: Document the changes in options.m. compiler/code_info.m: Record the value of --optimize-constructor-last-call-null in the code_info, to avoid lookup at every cell construction. compiler/unify_gen.m: compiler/var_locn.m: When deciding whether a cell can be static or not, make sure that we never make static a cell that has some fields initialized with dummy zeros, to be filled in for real later. compiler/hlds_out.m: For goals that are semipure or impure, note this fact. This info was lost when I changed the representation of impurity from markers to a field. mdbcomp/prim_data.m: Rename some ambiguous function symbols. compiler/intermod.m: compiler/trans_opt.m: Rename the main predicates (and some function symbols) of these modules to avoid ambiguity and to make them more expressive. compiler/llds.m: Don't print line numbers for foreign_code fragments if the user has specified --no-line-numbers. compiler/make.dependencies.m: compiler/mercury_to_mercury.m: compiler/recompilation.usage.m: Don't use io.write to write out information to files we may need to parse again, because this is vulnerable to changes to the names of function symbols (e.g. the one to mdbcomp/prim_data.m). The compiler still contains some uses of io.write, but they are for debugging. I added an item to the todo list of the one exception, ilasm.m. compiler/recompilation.m: Rename a misleading function symbol name. compiler/parse_tree.m: Don't import recompilation.m here. It is not needed (all the components of parse_tree that need recompilation.m already import it themselves), and deleting the import avoids recompiling almost everything when recompilation.m changes. compiler/*.m: Conform to the changes above. compiler/*.m: browser/*.m: slice/*.m: Conform to the change to mdbcomp. library/sparse_bitset.m: Use some better variable names.	2007-01-19 07:05:06 +00:00
Zoltan Somogyi	21467b650d	Fix two bugs. The first was that a version number was out of sync ... Estimated hours taken: 0.5 Branches: main compiler/layout_out.m: Fix two bugs. The first was that a version number was out of sync with mercury_stack_layout.h and with reality. The second was that we were not printing the null character at the ends of event set descriptions. compiler/prog_event.m: Fix a couple of bugs that caused event set descriptions to be syntactically invalid: the event set name was missing, and two tokens were missing a space between them.	2007-01-12 05:49:14 +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	d66ed699a1	Add fields to structures representing the C code itself that says whether ... Estimated hours taken: 4 Branches: main Add fields to structures representing the C code itself that says whether or not the C code affects the liveness of lvals. This is intended as the basis for future improvements in the optimization of such code. Implement a new foreign_proc attribute that allows programmers to set the value of this field. Eliminate names referring to `pragma c_code' in the LLDS backend in favor of names referring to foreign_procs. compiler/llds.m: Make the changes described above. Consistently put the field containing C code last in the function symbols that contain them. compiler/prog_data.m: Make the changes described above. Rename some other function symbols to avoid ambiguity. compiler/prog_io_pragma.m: Parse the new foreign_proc attribute. doc/reference_manual.texi: Document the new attribute. compiler/pragma_c_gen.m: Rename the main predicates. compiler/opt_util.m: Change some predicates into functions, for more convenient invocation. compiler/livemap.m: Rename the predicates in this module to avoid ambiguity and the need for module qualification. compiler/*.m: Conform to the changes above.	2007-01-03 07:20:47 +00:00
Zoltan Somogyi	b61ea9de44	Implement a large chunk of the code that was previously missing for .mmos ... Estimated hours taken: 20 Branches: main Implement a large chunk of the code that was previously missing for .mmos grades. The system now correctly computes several answers for the tc_minimal test case, before going into an infinite loop (since the code for recognizing the absence of further solutions is not yet there). Significantly improve the infrastructure for debugging such changes. compiler/table_gen.m: Complete the mmos transformation. compiler/proc_gen.m: Handle the special return requirements of mmos generators, which must return not to a caller (since each generator is the root of its own SLD tree), but to a consumer in another SLD tree that is waiting for an answer. compiler/hlds_pred.m: Provide a mechanism whereby table_gen.m can communicate to proc_gen.m the requirement for this special return. compiler/trace_gen.m: When generating events, include the port and the goal path in a comment. This makes the generated C code significantly easier to understand. compiler/layout_out.m: Export a function for trace_gen.m to use. compiler/hlds_goal.m: Change goal_path_to_string to a function to make it easier to use. compiler/*.m: Conform to the change to goal_path_to_string. runtime/mercury_context.[ch]: In .mmos grades, include the current debugger call sequence number, depth, and event number in contexts, to be saved and loaded with the contexts. This allows each context to have its own separate sequence of events. This capability depends not directly on the grade, but on the macro MR_EXEC_TRACE_INFO_IN_CONTEXT. For now, this is defined only in .mmos grades, but in future, it may be useful in other grades as well. runtime/mercury_conf_param.h: Define and document MR_EXEC_TRACE_INFO_IN_CONTEXT. runtime/mercury_mm_own_stacks.[ch]: runtime/mercury_tabling_preds.h: Implement some predicates needed by the own stack transformation. Implement the code for generators returning answers to consumers, and the code for consumers scheduling generators when they need more answers. At the moment, the code for detecting when generators depend on each other is not yet written. Provide better facilities for debugging own stack minimal model grades. Fix a cut-and-paste bug (wrong macro name guarding the handwritten C module). runtime/Mmakefile: Rebuild only what needs to be rebuilt when mercury_tabling_preds.h changes. runtime/mercury_label.[ch]: Add a utility function for returning the name of an arbitrary label (internal or entry). Rename some fields to give them MR_ prefixes. Always define the functions for recording both entry and internal labels, even if they are not called from most modules, since they may be called from a few handwritten modules in the runtime. Rename a function to avoid a clash with the name of a macro, and thus allow the change to mercury_goto.h. runtime/mercury_goto.h: Fix a bug with MR_init_entry_an. This macro was supposed to always insert the entry label that is its argument into the entry table, but instead of calling the function it was meant to call, it called a macro that could be (and usually way) defined to expand to nothing. The fix is to call the function a different name than the macro, and to call the function, not the macro. runtime/mercury_wrapper.c: In own stack minimal model grades, create a main context separate from the current context, since the current context may be needed to hold a generator's state. Make MR_eng_this_context point to this context. Register all labels in the debugging variants of minimal model grades. runtime/mercury_accurate_gc.c: runtime/mercury_agc_debug.c: runtime/mercury_debug.c: library/exception.m: Conform to the change to runtime/mercury_label.h. runtime/mercury_stack_trace.c: Conform to the change to runtime/mercury_label.h. Document the link to trace/mercury_trace_internal.c. trace/mercury_trace.[ch]: trace/mercury_trace_cmd_forward.c: Split the GOTO command into two: STEP and GOTO. STEP always stops at the next event (without any test), even if it is in a different context (and possibly with a lower event number than the immediately previous event, since the event numbers in different contexts are not related). As before, GOTO always goes to the specified event number, but in .dmmos grades it can now be told that this event number should be matched only in a specified context. The specification is done by an extra argument specifying the short name of the context's generator; the ansence of such an argument means the main context. trace/mercury_trace_cmd_internal.c: In own stack grades, when the current context is that of a generator, print the subgoal the generator is working on before the event number, call depth, call sequence number and the rest of the event report. Document the link to runtime/mercury_stack_trace.c, which has similar code. trace/mercury_trace_cmd_external.c: trace/mercury_trace_cmd_declararive.c: Use the STEP command where GOTO was used for this simpler job, since this is (very slightly) faster. trace/mercury_trace_cmd_developer.c: Fix some bugs with handling own stack tables. doc/user_guide.texi: Document the new functionality of the goto mdb command. The documentation is commented out, since .mmos grades are for developers only at the moment. tools/lmc.in: Turn off C optimizations when C debugging is enabled. For some reason, the default value of --cflags-for-debug does not include -O0.	2007-01-03 05:17:21 +00:00
Zoltan Somogyi	cff0019b0b	Make the system compile programs using minimal model tabling cleanly ... Estimated hours taken: 10 Branches: main Make the system compile programs using minimal model tabling cleanly in .mmos grades. (They still do not work, since the .mmos grade's implementation is not yet complete.) compiler/prog_data.m: Split the eval method for own stack minimal model tabling in two: one for the consumer predicate, and one for the generator, since they have distinct properties. Add a utility predicate for use by llds_out and ml_code_gen. compiler/prog_out.m: Split the predicate for converting an eval method to a string into two: one used for debugging purposes (which must be full of information), and one used for generating the names of pragmas (which must conform to the user-level syntax). compiler/table_gen.m: Have the own stack transformation generate the proc_table_info now required to generate the variable containing the root of the call table, as well as the information describing the structure of the call and answer tables. Fix some software rot. compiler/hlds_out.m: Print out the tabling information that may be attached to proc_infos. compiler/llds_out.m: compiler/ml_code_gen.m: Factor out some common code from these modules, and move it to prog_data.m. compiler/add_pragma.m: compiler/hlds_pred.m: compiler/layout_out.m: Conform to the changes above. runtime/mercury_mm_own_stacks.[ch]: Record the name of the predicate in generator and consumer structures, for debugging purposes (they can be taken out once the system works). Record the context in each consumer. Fix a link error by providing a dummy statistics printing predicate. Fix a cut-and-paste bug (wrong macro name guarding the handwritten C module). runtime/mercury_tabling_preds.h: Implement some predicates needed by the own stack transformation. Fix some software rot. runtime/mercury_debug.c: Avoid warnings from the C compiler. runtime/mercury_context.c: runtime/mercury_engine.h: runtime/mercury_wrapper.c: Minor style fixes. runtime/mercury_stack_layout.h: trace/mercury_trace.c: trace/mercury_trace_cmd_developer.c: Conform to the splitting of the own stack eval method into two.	2006-12-27 04:16:39 +00:00
Zoltan Somogyi	aa25c53cf6	For each attribute of each user event, record the order in which the attribute ... Estimated hours taken: 6 Branches: main For each attribute of each user event, record the order in which the attribute it depends on, indirectly as well as directly, should be synthesized. This information allows each attribute to materialized independently of other attributes, a capability we don't yet need, but may need someday. compiler/prog_event.m: Generate this information. compiler/prog_data.m: Make room for the information generated by prog_event. compiler/layout.m: compiler/layout_out.m: Record this information in the layout structures we generate. compiler/opt_debug.m: Conform to the change to layout.m. runtime/mercury_stack_layout.h: Allow the -1 sentinel at the end of the attribute number vector. trace/mercury_trace_vars.c: Make the var_details mdb command (which is for developers only) to print the newly collected information.	2006-12-22 05:37:57 +00:00
Zoltan Somogyi	544aae2355	Implement synthesized attributes at user events. ... Estimated hours taken: 32 Branches: main Implement synthesized attributes at user events. doc/user_guide.texi: Document synthesized attributes. runtime/mercury_stack_layout.h: Include information about synthesized attributes in layout structures. Move the the information about user events that is not specific to a given event occurrence to a central table of user event specifications in the module layout structure, to reduce the space overhead, and allow a future Ducasse style execution monitor to look up information about each event without having to search all label layout structures (e.g. when compiling a set of user commands about what to do at each event into a state machine). Update the current layout structure version number. Introduce a named type to represent HLDS variable numbers in layout structures. runtime/mercury_types.h: Add typedefs for the new types in mercury_stack_layout.h. compiler/prog_data.m: compiler/prog_event.m: Record the call that synthesizes synthesized attributes in terms of attribute numbers (needed by the layout structures) as well as in terms of attribute names (the user-friendly notation). Record some other information now needed by the layout structures, e.g. the evaluation order of synthesized attributes. (Previously, we computed this order -in reverse- but then threw it away.) Do not separate out non-synthesized attributes, now that we can handle even synthesized ones. Return *all* attributes to call_gen.m. Pass the filename of the event set specification file to the event spec parser, for use in error messages. Generate better error messages for semantic errors in event set specifications. compiler/continuation_info.m: compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Generate the new layout structures, the main changes being the inclusion of synthesized attributes, and generating information about event attribute names, types and maybe synthesis calls for all possible events at once (for the module layout) instead of separately at each user event occurrence. In stack_layout.m, rename a couple of predicates to avoid ambiguities. In layout_out.m, eliminate some repetitions of terms. compiler/call_gen.m: When processing event calls, match the supplied attributes against the list of all attributes, and include information about the synthesized attributes in the generated layout structures. compiler/equiv_type.m: compiler/module_qual.m: Conform to the change in prog_data.m. compiler/opt_debug.m: Conform to the change in layout.m. compiler/hlds_out.m: Generate valid Mercury for event calls. trace/mercury_event_spec.[ch]: Record the name of the file being parsed, for use in syntax error messages when the parser is invoked by the compiler. Add a field for recording the line numbers of attributes, for use in better error messages. trace/mercury_event_parser.y: trace/mercury_event_scanner.l: Record the line numbers of attributes. Modify the grammar for event set specifications to allow C-style comments. trace/mercury_trace_internal.c Pass a dummy filename to mercury_event_spec. (The event set specifications recorded in layout structures should be free of errors, since the compiler generates them and it checked the original version for errors.) trace/mercury_trace_tables.[ch]: Conform to the new design of layout structures, and record the extra information now available. trace/mercury_trace_vars.[ch]: Record the values of attributes in two passes: first the non-synthesized attributes, then the synthesized attributes in the evaluation order recorded in the user event specification. tests/debugger/synth_attr.{m,inp,exp}: tests/debugger/synth_attr_spec: New test case to test the debugger's handling of synthesized attributes. tests/debugger/Mmakefile: tests/debugger/Mercury.options: Enable the new test case. tests/invalid/syntax_error_event.{m,err_exp}: tests/invalid/syntax_error_event_spec: New test case to test the handling of syntax errors in event set specifications. tests/invalid/synth_attr_error.{m,err_exp}: tests/invalid/synth_attr_error_spec: New test case to test the handling of semantic errors in event set specifications. tests/invalid/Mmakefile: Enable the new test cases.	2006-12-14 04:36:04 +00:00
Zoltan Somogyi	45fd0daf5a	Implement some of Mark's wish list for making user events more useful. ... Estimated hours taken: 20 Branches: main Implement some of Mark's wish list for making user events more useful. 1. When executing "print *" in mdb, we used to print both the values of all attributes and the values of all live variables. Since some attributes' values were given directly by live variables, this lead to some things being printed twice. This diff eliminates this duplication. 2. At user events, we now print the name of the event. Whether we print the other stuff we also print at events (the predicate containing the event, and its source location) is now controlled by a new mdb command, "user_event_context". 3. We would like different solvers to be compilable independently of one another. This means that neither solver's event set should depend on the existence of the events needed by the other solvers. This diff therefore eliminates the requirement that all modules of the program be compiled with the same event set specification. Instead, a program may contain modules that were compiled with different event sets. Each event set is named; the new requirement is that different named event sets may coexist in the program (each being used to compile some modules), but two event sets with the same name must be identical in all other respects as well (we need this requirement to prevent inconsistencies arising between different versions of the same event set). 4. We now generate user events even from modules compiled with --trace shallow. The problem here is that user events can occur in procedures that do not get caller events and whose ancestors may not get caller events either. Yet these procedures must still pass on debugger information such as call sequence numbers and the call depth to the predicate with the user event. This diff therefore decouples the generation of code for this basic debugger infrastructure information from the generation of call events by inventing two new trace levels, settable by the compiler only (i.e. not from the command line). The trace level "basic_user" is for procedures containing a user event whose trace level (in a shallow traced module) would otherwise be "none". The trace level "basic" is for procedures not containing a user event but which nevertheless may need to transmit information (e.g. depth) to a user event. For the foreseeable future, this means that shallow traced modules containing user events will have some debugging overhead compiled into *all* their procedures. runtime/mercury_stack_layout.h: Add a new field to MR_UserEvent structures, giving the HLDS number of the variable representing each attribute. Add a new field to module layout structures, giving the name of the event set (if any) the module was compiled with. Add the new trace levels to the MR_TraceLevel type. Update the current layout structure version number. runtime/mercury_stack_trace.[ch]: Allow the printing of the containing predicate's name and/or the filename/linenumber context to be turned off when printing contexts. Factor out some of the code involved in this printing. Give a bunch of variables better names. Rename a type to get rid of unnecessary underscores. compiler/prog_data.m: compiler/prog_event.m: Include the event set name in the information we have about the event set. compiler/simplify.m: Mark each procedure and each module that contains user events as containing user events. Use the same technique to mark each procedure that contains parallel conjunctions as containing parallel conjunctions, instead of marking the predicate containing the procedure. (Switch detection may eliminate arbitrary goals, including parallel conjunctions, from switch arms that are unreachable due to initial insts, and in any case we want to handle the procedures of a predicate independently from each other after mode analysis.) Also, change the code handling generic calls to switch on the generic call kind, and factor out some common code. compiler/hlds_module.m: compiler/hlds_pred.m: Provide slots in the proc_info and the module_info for the information gathered by simplify. compiler/trace_params.m: Implement the new trace levels described above. This required changing the signature of some of the predicates of this module. compiler/code_info.m: Record whether the compiler generated any trace events. We need to know this, because if it did, then we must generate a proc layout structure for it. compiler/proc_gen.m: Act on the information recorded by code_info.m. Factor out the code for generating the call event and its layout structure, since the conditions for generating this event have changed. compiler/continuation_info.m: compiler/call_gen.m: For each user event, record the id of the variables corresponding to each argument of a user event. compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Generate the new field (giving the HLDS variable number of each attribute) in user event structures, and the new field (event set name) in module layout structures. Allow the call event's layout structure to be missing. This is needed for user events in shallow traced modules. compiler/options.m: compiler/handle_options.m: compiler/mercury_compiler.m: Rename the option for specifying event sets from --event-spec-file-name to --event-set-file-name, since it specifies only one event set, not all events. compiler/jumpopt.m: Give some predicates better names. compiler/dep_par_conj.m: compiler/deforest.m: compiler/granularity.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/lambda.m: compiler/liveness.m: compiler/modes.m: compiler/opt_debug.m: compiler/optimize.m: compiler/size_proc.m: compiler/stack_alloc.m: compiler/store_alloc.m: compiler/table_gen.m: compiler/trace_gen.m: compiler/typecheck.m: Conform to the changes above. doc/mdb_categories: Mention the new mdb command. doc/user_guide.texi: Update the documentation of user events to account for the changes above. trace/mercury_event_parser.y: trace/mercury_event_scanner.l: Modify the grammar for event set specifications to a name for the event set. trace/mercury_event_spec.[ch]: Instead of recording information about event sets internally in this module, return a representation of each event set read in to the callers, for them to do with as they please. Include the event set name when we print the Mercury term for compiler/prog_event.m. trace/mercury_trace.c: Do not assume that every procedure that contains an event contains a call event (and hence a call event layout structure), since that is not true anymore. trace/mercury_trace_cmd_parameter.[ch]: Implement the new mdb command "user_event_context". trace/mercury_trace_cmd_internal.[ch]: Include "user_event_context" in the list of mdb commands. Print the user event name at user events. Let the current setting of the user_event_context mdb command determine what else to print at such events. Instead of reading in one event set on initialization, read in all event sets that occur in the program. trace/mercury_trace_tables.[ch]: Allow the gathering of information for more than one event set from the modules of the program. trace/mercury_trace_vars.[ch]: For each attribute value of a user event, record what the HLDS variable number of the attribute is. When printing all variables at an event, mark the variable numbers of printed attributes as being printed already, causing the variable with the same number not to be printed. Include the name of the variable (if it has one) in the description of an attribute. Without this, users may wonder why the value of the variable wasn't printed. trace/mercury_trace_cmd_browsing.[ch]: Pass the current setting of the user_event_context mdb command to runtime/mercury_stack_trace.c when printing the context of an event. tests/debugger/user_event_shallow.{m,inp,exp}: New test case to test the new functionality. This test case is the same as the user_event test case, but it is compiled with shallow tracing, and its mdb input exercises the user_event_context mdb command. tests/debugger/user_event_spec: tests/invalid/invalid_event_spec: Update these event set spec files by adding an event set name. tests/debugger/Mmakefile: tests/debugger/Mercury.options: Enable the new test case. tests/debugger/user_event.exp: Update the expected output of the old user event test case, which now prints event names, but doesn't print attribute values twice. tests/debugger/completion.exp: Expect the new "user_event_context" mdb command in the command list. tests/debugger/mdb_command_test.inp: Test the existence of the documentation for the new mdb command. tests/invalid/Mercury.options: Conform to the name change of the --event-spec-file-name option.	2006-12-05 03:51:22 +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	455e1eea75	The runtime had two different conventions for naming types. ... Estimated hours taken: 2 Branches: main The runtime had two different conventions for naming types. One convention, used mostly in the debugger-related modules, added underscores between capitalized words; example: MR_Label_Layout. The other convention, used in most modules, used capitalized words without underscores (e.g. MR_TypeInfo). This diff standardizes on the second convention. It has no algorithmic changes, only renames of types. runtime/*.[ch]: trace/*.[ch]: compiler/*.m: library/*.m: mdbcomp/*.m: Effect the change described above. The only substantive change is that runtime/mercury_stack_layout.h used to define *two* types for trace levels: MR_TraceLevel and MR_Trace_Level, and this diff standardizes on just one (they had equivalent definitions). runtime/mercury_bootstrap.h: Add a #define from the old name to the new for all the changed type names that the installed compiler can put into .c files. We can delete these #defines some time after this diff has bootstrapped. slice/.mgnuc_opts: Restore the --no-mercury-stdlib-dir option, without which the slice directory won't compile after this change (because it looks for type names in the installed runtime header files, which define the old versions of type names).	2006-11-29 05:18:42 +00:00
Zoltan Somogyi	9ec86d6a6d	The objective of this diff is to switch from a table of solver events built ... Estimated hours taken: 32 Branches: main The objective of this diff is to switch from a table of solver events built into the compiler (and eventually the debugger) into a table of events defined by a file provided by the user to the compiler, which the compiler then records in the executable for use by the debugger. The current design, for speed of implementation, uses temporary files parsed by a bison-generated parser. Since the compiler needs to be able to invoke the parser even if it is compiled in a non-debug grade, the parser is in a new library, the eventspec library, that is always linked into the Mercury compiler and is always linked into any Mercury program with debugging enabled (but is of course linked only once into a Mercury compiler which has debugging enabled). Modify the debugger to give it the ability to print the attributes of user-defined events (for now, only the non-synthesized attributes). Implement a new debugger command, "user", which goes to the next user-defined event. configure.in: Require flex and and bison to be available. doc/user_guide.texi: Document user defined events and the new debugger capabilities. doc/mdb_categories: Include "user" in the list of forward movement commands. Fix some earlier omissions in that list. runtime/mercury_stack_layout.h: Include an event number in the user-defined event structure. Include a string representing an event set specification in module layout structures. runtime/mercury_stack_layout.h: runtime/mercury_trace_base.[ch]: runtime/mercury_types.h Switch from solver events to user events in names. runtime/mercury_trace_term.[ch]: Provide a representation of flat terms, for use in representing the calls that generate synthesized attributes. Ensure that exported field names have an MR_ prefix. browser/cterm.m: Conform to the change to runtime/mercury_trace_term.h. scripts/c2init.in: scripts/ml.in: Include the eventspec library in programs compiled with debugging enabled. compiler/Mmakefile: Include the eventspec library in the compiler. compiler/options.m: Add a new option, --event-spec-file-name, that allows the user to specify the set of user-defined events the program may use. compiler/handle_options.m: Set this optimization from an environment variable (which may be set by the mmc script) if the new option is not explicitly given. compiler/prog_data.m: Define the data structures for the compiler's representation of the event set specification. Move some definitions around to group them more logically. compiler/hlds_module.m: Include the event set specification as a new field in the module_info. compiler/prog_event.m: Add the code for invoking the parser in the eventspec library, and for converting the simple term output by the parser to the compiler own representation, which contains more information (to wit, the types of the function attributes) and which has had a whole bunch of semantic checks done on it (e.g. whether synthesized attributes depend on themselves or on nonexistent attributes). Provide a function to generate a canonicalized version of the event specification file. compiler/module_qual.m: compiler/equiv_type.m: Process event spec specifications as well as items, to module qualify the names of the types of event arguments, and expanding out equivalence types. In equiv_type.m, rename some variables to make clear what kind of info they represent. compiler/mercury_compile.m: Process the event set specification file if one has been selected: read it in, module qualify it, expand its equivalence types, and add to the module_info. compiler/compile_target_code.m: Include the event_spec library when linking debuggable executables. compiler/call_gen.m: compiler/continuation_info.m: compiler/trace_gen.m: compiler/trace_params.m: mdbcomp/prim_data.m: mdbcomp/trace_counts.m: runtime/mercury_goto.h: Generate user-defined events instead of solver events. compiler/layout.m: compiler/layout_out.m: compiler/stack_layout.m: Include a canonicalized version of the event specification file in the module layout if the module has any user-defined events. compiler/code_info.m: compiler/llds_out.m: compiler/modes.m: compiler/modules.m: compiler/opt_debug.m: compiler/typecheck.m: Conform to the changes above. compiler/passes_aux.m: Rename a predicate to avoid an ambiguity. trace/Mmakefile: Add the definition and rules required to build the eventspec library. trace/mercury_event_scanner.l: trace/mercury_event_parser.y: A scanner and a parser for reading in event spec specifications. trace/mercury_event_spec_missing.h: Provide the declarations that should be (but aren't) provided by flex and bison. trace/mercury_event_spec.[ch]: The main module of the eventspec library. Provides functions to read in event set specifications from a file, and to write them out as a Mercury term in the form needed by the compiler. trace/mercury_trace_tables.c: If the module layouts being registered include event set specifications, then check their consistency. Make the specification and the consistency indication available to other modules. trace/mercury_trace_internal.c: During initialization, if the modules contain a consistent set of event set specifications, then read that specification into the debugger. (We don't yet make use of this information.) Add an extra mdb command, "user", which goes forward to the next user-defined event. trace/mercury_trace.[ch]: trace/mercury_trace_cmd_forward.[ch]: Implement the new mdb command. trace/mercury_trace_vars.[ch]: For user-defined events, include the attributes' values among the values that can be printed or browsed. trace/mercury_trace_cmd_browsing.c: trace/mercury_trace_declarative.c: Minor changes. scripts/scripts/prepare_tmp_dir_grade_part: Copy the .y and .l files to the tmp dir we use for installs. tools/bootcheck: Copy the .y and .l files of the trace directory to stage 2. tools/lmc.in: Include the eventspec library when linking debuggable executables. tests/debugger/user_event.{m,inp,exp}: tests/debugger/user_event_spec: New test case to test the new functionality. tests/debugger/Mercury.options: tests/debugger/Mmakefile: Enable the new test case. tests/debugger/completion.exp: Expect the new "user" mdb command in the completion output.	2006-11-24 03:48:30 +00:00
Zoltan Somogyi	e4e6904b53	Add a version number to the module layout structure. ... Estimated hours taken: 0.1 Branches: main Add a version number to the module layout structure. This is needed to allow future changes to layout structures to take place in a backwards compatible manner. However, this change itself is backward compatible only for programs without debugging enabled. If your installed compiler generates the new field but your runtime doesn't define it, or vice versa, you will get strange crashes whenever you use the debugger. runtime/mercury_stack_layout.h: Add a version number field to the start of the module layout structure. compiler/layout_out.m: Fill in the new field. runtime/mercury_grade.h: Increment the binary compatibility version number for debug grades.	2006-11-14 00:22:34 +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	863874df85	Document my recent change implementing coverage testing. ... Estimated hours taken: 6 Branches: main Document my recent change implementing coverage testing. At the same time, eliminate the old hack that allowed a file containing a list of file names to be considered a trace count file. We haven't needed it since the addition of mtc_union, and it can lead to incomprensible error messages. (The presence of the old hack made documenting coverage testing harder.) In the process, fix the tools code for rerunning failed test cases only. doc/user_guide.texi: Document my recent change implementing coverage testing, and the elimination of the old hack. mdbcomp/trace_counts.m: Modify the predicates for reading in trace count files along the lines above. mdbcomp/slice_and_dice.m: Modify the predicates for reading in slices and dices along the lines above. Rename some function symbols to avoid ambiguities. compiler/tupling.m: slice/mcov.m: slice/mtc_diff.m: slice/mtc_union.m: trace/mercury_trace_declarative.c: Conform to the changes above. slice/mcov.m: Fix the usage message, which referred to this program by its old name mct. Allow the output to be restricted to a set of named modules only. This is to make testing easier. slice/mtc_diff.m: Rename the long form of the -o option from --out to --output-file, to make it consistent with the other programs. tests/run_one_test: tools/bootcheck: Modify the algorithm we use to gather trace counts for the Mercury compiler from both passed and failed test cases to run mtc_union periodically instead of gathering all the trace counts file and keeping them to the end (which takes far too much disk space). Fix an old bug: gather trace counts from executions of the Mercury compiler only. tests/debugger/Mmakefile: tests/debugger/dice.passes: Modify the dice test case to compute the union of the trace counts for the passed versions of this test case to use mtc_union to create dice.passes, instead of having dice.passes statically contain the list of the names of the passed trace count files (since that capability is deleted by this diff). tools/bootcheck: tests/Mmake.common: Fix the code for rerunning failed tests only. mdbcomp/prim_data.m: Eliminate some ambiguities in predicate names. compiler/*.m: Conform to the change to prim_data.m. compiler/error_util.m: Add reading files as a phase in error messages. compiler/mercury_compile.m: Use the new facilities in error_util for printing an error message.	2006-10-02 05:21:44 +00:00
Zoltan Somogyi	9eed887d33	This diff is the second step in implementing trace events. ... Estimated hours taken: 24 Branches: main This diff is the second step in implementing trace events. It modifies label layouts to include room for solver-event-specific information, and modifies the compiler to generate this information. Modifications to the debugger to use this information, user-level documentation and test cases will come later. runtime/mercury_stack_layout.h: Modify label layouts to allow them to hold information about solver events. Modify the macros creating label layouts to include a null pointer as the value of the label layout's solver event field. For each such macro, add a version that puts a pointer to the label's solver event structure in that field. Modify the definition of the MR_Long_Lval type to allow the representation of constants, since without this capability solver events would often need to be preceded by code to put constant values (e.g. solver ids) into lvals. To make it easier to locate all the places where MR_Long_Lvals are used (which need to be updated), change the type MR_Long_Lval from a synonym for an int to a structure containing an int. runtime/mercury_types.h: Add the typedefs now required for mercury_stack_layout.h. runtime/mercury_goto.h: Add a macro needed by mercury_stack_layout.h. runtime/mercury_grade.h: Change the binary compatibility version number for debug grades, due to the change to label layouts. runtime/mercury_layout_util.c: Update the functions interpreting MR_Long_Lvals to conform to the change in mercury_stack_layout.h. runtime/mercury_deep_profiling_hand.h: Fix a bug, possibly the bug preventing us from bootchecking in deep profiling grades: stack slot numbers of ProcStatic structures are supposed to be plain integers, not MR_Long_Lvals. runtime/mercury_stack_trace.c: library/exception.m: trace/mercury_trace.c: Conform the change in MR_Long_Lval. runtime/mercury_trace_base.[ch]: Add a new port: the solver event port. Add a macro and a function for solver events: MR_SOLVER_EVENT and MR_solver_trace. For now, they do the same thing as MR_EVENT and MR_trace, but in future, they can do something else (e.g. generate information for a visualization tool). mdbcomp/prim_data.m: Add a new port: the solver event port. Rename all ports to eliminate clashes with language keywords such as "call". mdbcmp/trace_counts.m: browser/declarative_execution.m: slice/mcov.m: compiler/tupling.m: Conform to the change in port names, and to the addition of the new port. compiler/trace_params.m: Conform to the change in port names, and to the addition of the new port. Rename some function symbols to avoid some ambiguities. trace/mercury_trace_declarative.c: Ignore the solver port when building the annotated trace, since it doesn't fit into it. compiler/prog_event.m: Extend the representation of events to include names for the event attributes. compiler/call_gen.m: Implement event goals. The implementation consists of a call to MR_SOLVER_EVENT with a layout structure whose solver event field points to a solver event structure giving the event goal's arguments. Rename some function symbols to avoid some ambiguities. compiler/trace_gen.m: Add a predicate for generating solver events. Conform to the change in port names. Rename some function symbols to avoid some ambiguities. compiler/code_info.m: When recording trace layout information for a label, take an extra argument describing the label layout's associated solver event, if any. compiler/continuation_info.m: Extend the first representation of label layouts to include room for solver events. compiler/stack_layout.m: Convert the representation of solver events in continuation_info.m's data structure to the data structure required by layout_out.m. Conform to the changes in MR_Long_Lvals. compiler/layout.m: Extend the compiler's internal representation of the contents of label layout structures to accommodate the optional solver event field. compiler/layout_out.m: Generate the extended label layout structures, using the new macros in mercury_stack_layout.h if necessary. Conform to the change in the MR_Long_Lval type. Conform to the change in port names. Rename some function symbols to avoid some ambiguities. compiler/global_data.m: Modify rval_type_as_arg to require only the value of the relevant option, not a package of such options. This is for the new code in stack_layout.m. compiler/var_locn.m: Conform to the change in global_data.m. compiler/llds_out.m: Conform to the change in continuation_info.m. Delete this module's unused definition of rval_type_as_arg. compiler/opt_debug.m: Conform to the change in continuation_info.m.	2006-09-29 06:34:57 +00:00
Zoltan Somogyi	9e4fc71321	Generate slightly smaller but still equivalent C code. ... Estimated hours taken: 0.1 Branches: main compiler/layout_out.m: Generate slightly smaller but still equivalent C code.	2006-09-20 03:12:15 +00:00
Peter Wang	6a6cfaf18e	Add options to perform code generation and liveness detection for the low-level ... Estimated hours taken: 30 Branches: main Add options to perform code generation and liveness detection for the low-level backend using parallel threads. These are enabled with `--parallel-code-gen' and `--parallel-liveness' options respectively, for compilers built in grades supporting multiple engines, and running with multiple engines enabled. Currently we only attempt to use two threads. compiler/global_data.m: Use a new type `type_num' instead of `int' everywhere for common cell type numbers. Add a function `bump_type_num_counter' which takes a global_data structure and returns a global_data with the common cell type number counter incremented by some amount. This is to allow multiple threads to add new types to their own copies of the global_data structure without type numbers clashing when we try to merge them later. Add a predicate `merge_global_datas' which takes two global_datas and merges their static cell information. Add a predicate `remap_static_cell_references' which updates code using the second global_data structure (passed to merge_global_datas) to refer to static cells in the combined global_data structure. compiler/layout_out.m: compiler/llds.m: compiler/llds_out.m: compiler/opt_debug.m: Conform to the type change of common cell type numbers. compiler/options.m: doc/user_guide.texi: Add `--parallel-liveness' and `--parallel-code-gen' options. The documentation is commented out for now. compiler/handle_options.m: Make the `--parallel-liveness' and `--parallel-code-gen' options imply `--no-trad-passes'. compiler/liveness.m: Add parallel liveness detection support. The sequential liveness detection code took I/O states in order to output debugging information; make it take values of a typeclass `debug_liveness_io' instead, and make io.state an instance of the typeclass. In the parallel case we pass dummy values that don't try to output debugging information. compiler/mercury_compile.m: Run parallel liveness detection if it is enabled and liveness debugging is not enabled (see above). compiler/proc_gen.m: Add parallel code generation support. Run it if selected by the user and `--very-verbose' is not enabled (as that would require I/O).	2006-09-04 01:47:34 +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
Peter Wang	bdcb1a10c6	Make the dependent parallel conjunction transformation insert calls to ... Branches: main Make the dependent parallel conjunction transformation insert calls to `par_builtin.wait' as late as possible, and calls to `par_builtin.signal' as soon as possible. Next, combine contiguous sequences of waits, then a plain call to a non-imported procedure, then signals (where there must be at least one wait or signal) into a call to a specialised "parallel" procedure that takes futures in place of the arguments for which waiting or signalling is required. The waits and signals are then moved into the parallel procedures where they can be shifted around more and combined into further calls. compiler/dep_par_conj.m: As above. compiler/hlds_pred.m: compiler/layout_out.m: Add dependent_parallel_conjunction as a source of transformed predicates. compiler/prog_util.m: Add parallel_args as a way to build names for "parallel" procedures. compiler/simplify.m: Don't let the simplification pass do simplifications of common information between parallel conjuncts, as they would introduce dependences between conjuncts which the programmer (and the dependent parallel conjunction tranformation...) probably did not intend. library/par_builtin.m: mdbcomp/program_representation.m: Add `get/2' which gets the value associated with a future, i.e. it is like `wait/2' but assumes that the future has been signalled already. Fix a wrong assertion that a future should only be signalled once. tests/par_conj/Mercury.options: tests/par_conj/Mmakefile: tests/par_conj/dep_par_11d.exp: tests/par_conj/dep_par_11d.m: tests/par_conj/dep_par_24.exp: tests/par_conj/dep_par_24.m: tests/par_conj/dep_par_24b.exp: tests/par_conj/dep_par_24b.m: tests/par_conj/dep_par_25.exp: tests/par_conj/dep_par_25.m: tests/par_conj/dep_par_25b.exp: tests/par_conj/dep_par_25b.m: tests/par_conj/dep_par_26.exp: tests/par_conj/dep_par_26.m: tests/par_conj/dep_par_27.exp: tests/par_conj/dep_par_27.m: tests/par_conj/dep_par_28.exp: tests/par_conj/dep_par_28.m: tests/par_conj/dep_par_6b.exp: tests/par_conj/dep_par_6b.m: Add test cases.	2006-08-09 03:17:18 +00:00
Zoltan Somogyi	fb9f78b784	Fix a bug reported by Peter Hawkins. The bug was that an predicate without ... Estimated hours taken: 3 Branches: main Fix a bug reported by Peter Hawkins. The bug was that an predicate without a declared determinism but whose inferred determinism was invalid for its tabling declaration led to a compiler abort. compiler/det_analysis.m: Fix the main cause of the bug, which was that the check for the compatibility of evaluation method and determinism was performed only for predicates with declared determinisms, not those without. Centralize the printing of determinism error messages, and sort the messages first. compiler/hlds_pred.m: Fix the other half of the bug: the predicate that checked the compatibility of evaluation method and determinism was too liberal with minimal model predicates, letting through determinisms that the tabling transformation cannot (yet) support. compiler/det_report.m: Fix the formatting of the error message. compiler/prog_data.m: Rename the function symbols of the type "determinism", to avoid conflicts with language keywords. compiler/*.m: Conform to the change to prog_data.m. tests/invalid/hawkins_mm_fail_reset.{m,err_exp}: New test case for the bug being fixed. tests/invalid/Mmakefile: Enable the new test case. tests/invalid/loopcheck.err_exp: Expect the new format of the improved error message.	2006-07-12 02:51:22 +00:00
Zoltan Somogyi	74ce85d476	Provide a mechanism for collecting statistics about tabling operations, ... Estimated hours taken: 60 Branches: main Provide a mechanism for collecting statistics about tabling operations, and provide a much more convenient mechanism for resetting tables. Since it would too complex to do this while preserving the capability of setting --tabling-via-extra-args to no, eliminate that capability and the option. That option was useful only for measurements of the performance boost from setting --tabling-via-extra-args to yes in any case, so users lose no functionality. Previously, the only way to debug the low level details of the tabling mechanism was to build a runtime with a specific C macro (MR_TABLE_DEBUG) and link with that runtime; this was cumbersome. Change that so that every one of the debuggable tabling macros has a bool argument that says whether debugging is enabled or not. The compiler can then set this to MR_TRUE if the new option --table-debug is given, and to MR_FALSE otherwise. If set to MR_FALSE, the C compiler should optimize away the debug code, with zero impact on program size or speed. Since these changes to macros require nontrivial bootstrapping, which we don't want to do unnecessarily, modify the interface of the tabling macros as required to support size limits on tables. This diff also implements the parsing of size limit specifications on tables, but does not implement them yet; that is for a future change. To make the syntax simpler, this diff deletes the free-standing fast_loose_memo pragma. The same functionality is now available with a fast_loose annotation on an ordinary memo pragma. Make a bunch of changes to improve readability and maintainability in the process. These mostly take the form of renaming ambiguous and/or not sufficiently expressive function symbols. runtime/mercury_stack_layout.h: runtime/mercury_tabling.h: Move the description of structure of tables from mercury_stack_layout.h to mercury_tabling.h, since we now need it for statistics even if execution tracing is not enabled. Modify those data structures to have room for the statistics. Don't distinguish "strict", "fast_loose" and "specified" memoing as separate eval methods; treat them as just different kinds of the same eval method: "memo". Remove underscores from the names of some types that the style guide says shouldn't be there. runtime/mercury_tabling_preds.h: runtime/mercury_tabling_macros.h: Modify the approach we use for macros that implement the predicates of library/table_builtin.m. Instead of selecting between debug and nondebug based on whether MR_TABLE_DEBUG is defined or not, add an explicit argument controlling this to each debuggable macro. The advantage of the new arrangement is that it scales. Another argument controls whether we are computing statistics (and if yes, where do we put it), and a third argument controls whether we maintain back links in the tries and hash tables (this last argument is present but is ignored for now). Since the values of the arguments will be known when the .c files containing calls to these macros are compiled, we pay the space and time cost of debugging, statistics gathering and the maintenance of back links if and only we need the revelant functionality. Provide macros for limited backward compatibility with the old set of macros; these allow workspaces created by old compilers to work with the new macros in the runtime. The old macros followed the naming scheme MR_table_*, the new ones are named MR_tbl_*. runtime/mercury_table_int_fix_index_body.h: runtime/mercury_table_int_start_index_body.h: runtime/mercury_table_type_body.h: New files containing parts of the old mercury_tabling.c. Each of these files contains the body of the functions that used to be in mercury_tabling.c. The new mercury_tabling.c #includes each of these files more than once, to provide more than one variant of the old function. These variants differ in aspects such as whether debugging is enabled or statistics is being collected. Each variant therefore incurs only the time costs it needs to. (We pay the space cost of having all these variants all the time of course, but this cost is negligible.) runtime/mercury_tabling_stats_defs.h: runtime/mercury_tabling_stats_nodefs.h: runtime/mercury_tabling_stats_undefs.h: New files that serve as wrappers around the newly #included files, controlling how they handle statistics. runtime/mercury_tabling.c: Delete functions now in the new files, and #include them instead. Delete the data structures that used to contain summary statistics; the new approach keeps statistics in compiler-generated, procedure-specific data structures. runtime/mercury_trace_base.c: Use the new versions of the tabling macros to access the I/O table. runtime/mercury_type_info.h: Update some documentation for the movement of code out of mercury_tabling.c. runtime/mercury_types.h: Provide forward declarations of the identifiers denoting the new types in mercury_tabling.h. runtime/mercury_grade.h: Increment the exec trace version number, since we have changed a part of the exec trace structure. runtime/mercury_bootstrap.h: Fix some temporary issues that arise from some renames above. runtime/mercury_hash_lookup_or_add_body.h: Fix comment. runtime/Mmakefile: Mention the new files and the dependencies that involve them. library/table_builtin.m: Provide a type for representing statistics and a predicate for printing statistics. Use the updated versions of the macros in runtime/mercury_tabling_preds.h. compiler/prog_item.m: Change representation of tabling pragmas to allow room for the new attributes. Allow an item to be marked as being generated by the compiler as a result of a pragma memo attribute. We use this for the reset and statistics predicates. compiler/mercury_to_mercury.m: Write out the new attributes of the tabling pragma. compiler/prog_data.m: compiler/hlds_data.m: Change the cons_id that used to refer to a procedure's call table root to refer to the entirety of the new data structure now containing it. The compiler now needs a way to refer to the other components of this new data structure, since it contains the statistics. As in the runtime, don't distinguish "strict", "fast_loose" and "specified" memoing as separate eval methods; treat them as just different kinds of the same eval method: "memo". Rename some of the uses of the function symbols "c", "java", "il". compiler/hlds_pred.m: Add an extra field in proc_infos for storing any tabling attributes. Change the existing proc_info field that records information about the kinds of arguments of tabled procedures to record the information needed by the debugger too. This was needed to allow us to shift all the RTTI for procedure-specific tables (as opposed to the RTTI for the global I/O table) from mercury_stack_layout.h to mercury_tabling.h without duplicating the data (which would be a maintenance problem). Reformat some comments to make them easier to read. compiler/layout.m: compiler/layout_out.m: Delete the part of the exec trace information that used to record RTTI for tables, since this information is not generated only as part of the debugger data structures anymore. compiler/prog_io_pragma.m: Recognize the updated syntax for tabling pragmas. compiler/add_pragma.m: When processing tabling pragmas for inclusion in the HLDS, create any reset and statistics predicates they ask for. compiler/make_hlds_passes.m: Export a predicate now needed by add_pragma.m. Handle the new attributes on tabling pragmas compiler/globals.m: Change the function symbols of the types describing backends and foreign languages to say what they are. Previously, both types (as well as several others) included the function symbol "c"; now, they are target_c and lang_c respectively. compiler/table_gen.m: Implement the changes described at the top. When passing around varsets and vartypes, pass the arguments in the standard order. compiler/goal_util.m: compiler/hlds_goal.m: When passing around varsets and vartypes, pass the arguments in the standard order. compiler/rtti.m: Provide types for representing the runtime's data structures for tabling (which are now significantly more complex than a single word) and predicates for manipulating them, for use by both the ml and ll backends. compiler/llds.m: Replace the comp_gen_c_var type with the tabling_info_struct type, which contains the information needed to create the per-procedure tabling data structures. Replace references to call tables with references to the various components of the new tabling data structures. compiler/llds_out.m: Add code to write out tabling_info_structs. Delete the code required for the old, hacky way of resetting tables. Reorder some code more logically. compiler/proc_gen.m: Generate tabling_info_structs. compiler/stack_layout.m: Don't generate the information now generated in proc_gen.m. compiler/mlds.m: Give mlds_proc_labels their own function symbols, instead of using a pair. Rename some other function symbols to avoid ambiguity and add expressiveness. Provide for the representation of references to the various components of the new tabling data structures, and for the representation of their types. compiler/ml_code_gen.m: When generating code for a tabled procedure, generate also the data structures required for its table. compiler/rtti_to_mlds.m: compiler/ml_util.m: Move some predicates from rtti_to_mlds.m to ml_util.m, since we now also want to call them from ml_code_gen.m. compiler/name_mangle.m: Add some utility predicates. compiler/options.m: Delete the old --allow-table-reset option. Add the new --table-debug option. Comment out an implementor-only option. compiler/add_pred.m: compiler/add_solver.m: compiler/add_trail_ops.m: compiler/add_type.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/compile_target_code.m: compiler/complexity.m: compiler/dependency_graph.m: compiler/det_report.m: compiler/export.m: compiler/fact_table.m: compiler/foreign.m: compiler/global_data.m: compiler/globals.m: compiler/handle_options.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/make.dependencies.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make.util.m: compiler/make_hlds_passes.m: compiler/mercury_compile.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_elim_nested.m: compiler/ml_optimize.m: compiler/ml_switch_gen.m: compiler/ml_tailcall.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_ilasm.m: compiler/mlds_to_java.m: compiler/mlds_to_managed.m: compiler/modes.m: compiler/module_qual.m: compiler/modules.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/polymorphism.m: compiler/pragma_c_gen.m: compiler/proc_label.m: compiler/prog_data.m: compiler/prog_foreign.m: compiler/prog_item.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/prog_rep.m: compiler/prog_util.m: compiler/recompilation.version.m: compiler/size_prof.m: compiler/special_pred.m: compiler/switch_util.m: compiler/transform_llds.m: compiler/tupling.m: compiler/type_ctor_info.m: compiler/unify_gen.m: Conform to the changes above, and/or improve some comments. mdbcomp/prim_data.m: Make the names of the function symbols of the proc_label type more expressive and less ambiguous. mdbcomp/prim_data.m: mdbcomp/mdbcomp.m: mdbcomp/program_representation.m: mdbcomp/rtti_access.m: mdbcomp/slice_and_dice.m: mdbcomp/trace_counts.m: Use . instead of __ as module qualifier. Conform to the change to prim_data.m. browser/declarative_execution.m: browser/declarative_oracle.m: browser/declarative_tree.m: Conform the change to mdbcomp/prim_data.m. tests/debugger/Mercury.options: Don't specify --allow-table-reset for fib.m, since that option doesn't exist anymore. tests/debugger/fib.m: Use the new mechanism for resetting the table. tests/debugger/print_table.m: Use the new syntax for pragma memo attributes. tests/invalid/specified.{m,err_exp}: Use to the new syntax and reset method for pragma memo attributes. Test the handling of errors in the new attribute syntax. tests/tabling/Mercury.options: Don't specify --allow-table-reset for specified.m, since that option doesn't exist anymore. tests/tabling/specified.m: Use the new syntax for pragma memo attributes, and use the new mechanism for resetting tables. We could also use this test case for testing the printing of statistics, but the format of that output is still not final. tests/tabling/fast_loose.m: Use the new syntax for pragma memo attributes, and use the new mechanism for resetting tables. trace/mercury_trace.c: trace/mercury_trace_cmd_developer.c: Conform to the changes in the RTTI data structures regarding tabling. Remove underscores from the names of some types that the style guide says shouldn't be there. library/robdd.m: Comment out the tabling pragma until this change is bootstrapped. Without this, the conflict between the old calls to macros generated by the existing compiler and the new definition of those macros in the runtime would cause errors from the C compiler.	2006-06-08 08:20:17 +00:00
Zoltan Somogyi	afbec6110a	This diff simplifies the way we handle compiler-generate data in LLDS grades. ... Estimated hours taken: 2 Branches: main This diff simplifies the way we handle compiler-generate data in LLDS grades. We used to wrap several kinds of data structures up in different function symbols so they could be treated as values of a single type, comp_gen_c_data, but then we divided them up into the original caregories again when creating the output .c file. We now instead keep the various kinds of static data separate all the way through. compiler/llds.m: Delete the comp_gen_c_data type. Replace the single list of comp_gen_c_data items in the representation of C files with four lists, one for each kind of static data. compiler/llds_out.m: Make the simplifications made possible by the change to llds.m. Output references to MR_COMMON and MR_TAG_COMMON instead of MR_XCOMMON and MR_TAG_XCOMMON, since the change to make these equivalent should have been installed on all our machines by now. compiler/code_info.m: compiler/global_data.m: compiler/stack_layout.m: Modify data structures to contain data of specific types instead comp_gen_c_datas, and modify the code accordingly. This mostly means avoiding now redundant operations to wrap data structures with comp_gen_c_data's function symbols. compiler/mercury_compile.m: Build c_file structures with four lists of distinct types instead of appending them all to get a single giant list of comp_gen_c_datas. compiler/transform_llds.m: Conform to the change to llds.m. compiler/layout.m: compiler/layout_out.m: Minor style improvements.	2006-05-08 03:36:02 +00:00
Zoltan Somogyi	46a67b0b48	When the typechecker finds highly ambiguous overloading, print what symbols ... Estimated hours taken: 16 Branches: main When the typechecker finds highly ambiguous overloading, print what symbols were overloaded, and where they occurred. Without this information, it is very hard to fix the error if the predicate body is at all large. Fix some software engineering problems encountered during this process. Modify some predicates in error_util in order to simplify their typical usage. Change the type_ctor type to be not simply a sym_name - int pair but a type with its own identifying type constructor. Change several other types that were also sym_name - int pairs (mode_id, inst_id, item_name, module_qual.id and the related simple_call_id) to have their own function symbols too. compiler/typecheck_info.m: Add a field to the typecheck_info structure that records the overloaded symbols encountered. compiler/typecheck.m: When processing ambiguous predicate and function symbols, record this fact in the typecheck_info. Add a field to the cons_type_info structure to make this possible. compiler/typecheck_errors.m: When printing the message about highly ambiguous overloading, what the overloaded symbols were and where they occurred. compiler/error_util.m: Make error_msg_specs usable with plain in and out modes by separating out the capability requiring special modes (storing a higher order value in a function symbol) into its own, rarely used type. Make component_list_to_line_pieces a bit more flexible. compiler/prog_data.m: compiler/module_qual.m: compiler/recompilation.m: Change the types listed above from being equivalence types (pairs) to being proper discriminated union types. compiler/*.m: Conform to the changes above. In some cases, simplify the code's use of error_util. tests/warnings/ambiguous_overloading.{m,exp}: Greatly extend this test case to test the new functionality. tests/recompilation/*.err_exp.2 Reflect the fact that the expected messages now use the standard error_util way of quoting sym_name/arity pairs.	2006-04-20 05:37:13 +00:00
Zoltan Somogyi	4fe703c7b9	Implement a more cache-friendly translation of lookup switches. ... Estimated hours taken: 8 Branches: main Implement a more cache-friendly translation of lookup switches. Previously, for a switch such as the one in :- pred p(foo::in, string::out, bar::out, float::out) is semidet. p(d, "four", f1, 4.4). p(e, "five", f2, 5.5). p(f, "six", f4("hex"), 6.6). p(g, "seven", f5(77.7), 7.7). we generated three static cells, one for each argument, and then indexed into each one in turn to get the values of HeadVar__2, HeadVar__3 and HeadVar__4. The different static cells each represent a column here. Each of the loads accessing the columns will access a different cache block, so with this technique we expect to get as many cache misses as there are output variables. This diff changes the code we generate to use a vector of static cells where each cell represents a row. The assignments to the output variables will now access the different fields of a row, which will be next to each other. We thus expect only one cache miss irrespective of the number of output variables, at least up to the number of variables that actually fit into one cache block. compiler/global_data.m: Provide a mechanism for creating not just single (scalar) static cells, but arrays (vectors) of them. compiler/lookup_switch.m: Use the new mechanism to generate code along the lines described above. Put the information passed between the two halves of the lookup switch implementation (detection and code generation) into an opaque data structure. compiler/switch_gen.m: Conform to the new interface of lookup_switch.m. compiler/ll_pseudo_type_info.m: compiler/stack_layout.m: compiler/string_switch.m: compiler/unify_gen.m: compiler/var_locn.m: Conform to the change to global_data.m. compiler/llds.m: Define the data structures for holding vectors of static cells. Rename the function symbols we used to use to refer to static cells to make clear that they apply to scalar cells only. Provide similar mechanisms for representing static cell vectors and references to them. Generalize heap_ref heap references to allow the index to be computed at runtime, not compile time. For symmetry's sake, do likewise for stack references. compiler/llds_out.m: Add the code required to write out static cell vectors. Rename decl_ids to increase clarity and avoid ambiguity. compiler/code_util.m: compiler/exprn_aux.m: Modify code that traverses rvals to now also traverse the new rvals inside memory references. compiler/name_mangle.m: Provide the prefix for static cell vectors. compiler/layout_out.m: compiler/rtti_out.m: compiler/opt_debug.m: Conform to the change to data_addrs and decl_ids. compiler/code_info.m: Provide access to the new functionality in global_data.m, and conform to the change to llds.m. Provide a utility predicate needed by lookup_switch.m. compiler/hlds_llds.m: Fix the formatting of some comments. tools/binary: tools/binary_step: Fix the bit rot that has set in since they were last used (the rest of the system has changed quite a lot since then). I had to do so to debug one part of this change. tests/hard_coded/dense_lookup_switch2.{m,exp}: tests/hard_coded/dense_lookup_switch3.{m,exp}: New test cases to exercise the new algorithm. tests/hard_coded/Mmakefile: Enable the new test cases, as well as an old one (from 1997!) that seems never to have been enabled.	2006-03-30 02:46:08 +00:00
Julien Fischer	459847a064	Move the univ, maybe, pair and unit types from std_util into their own ... Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.	2006-03-29 08:09:58 +00:00
Zoltan Somogyi	3ebda6545f	Move the stuff currently in hlds_pred.m that deals with clauses into a new ... Estimated hours taken: 1.5 Branches: main Move the stuff currently in hlds_pred.m that deals with clauses into a new module, hlds_clauses.m. Move the stuff currently in hlds_pred.m that deals with RTTI into a new module, hlds_rtti.m. Move the stuff currently in hlds_module.m that deals with predicate tables into a new module, pred_table.m. These changes make hlds_pred.m and hlds_module.m much more cohesive, but there are no changes in algorithms. compiler/hlds_clauses.m: compiler/hlds_rtti.m: compiler/pred_table.m: New modules as described above. In some cases, fix mixleading or ambiguous predicate names in the process, and convert a few predicates to functions. compiler/hlds_pred.m: compiler/hlds_module.m: Delete the stuff moved to other modules. compiler/*.m: In modules that need the functionality moved a new module, import the new module. It is rare for all the new modules to be needed, and many modules don't need any of the new modules at all. (For example, of the 200+ modules that import hlds_module.m, only about 40 need pred_table.m.) Conform to the few minor changes to e.g. predicate names. compiler/notes/compiler_design.html: Document the new modules.	2006-03-24 03:04:20 +00:00
Zoltan Somogyi	276ed0f120	Change the way we represent static cells. Instead of generating a separate ... Estimated hours taken: 6 Branches: main Change the way we represent static cells. Instead of generating a separate global variable for each static cell, generate global variables that are arrays, each containing all the static cells of the same type. By reducing the number of symbols requiring relocation, this reduces link times, especially in debug grades (since those have lots of static cells). compiler/global_data.m: Rewrite the part of this module that handles static cells in line with the above. compiler/llds.m: Modify the data structures for representing static cells in line with the above. compiler/llds_out.m: Delete all the code for grouping together all the static cells of the same type, since it is not needed anymore. Replace with simpler code to print out the new arrays of static cells. Rename some predicates to eliminate ambiguity. compiler/opt_debug.m: Conform to the change in llds.m. compiler/rtti_out.m: Conform to the change in llds_out.m. runtime/mercury_misc.h: runtime/mercury_stack_layout.h: Create variants of the existing shorthand macros to refer to static cells not using a specified global variable but using a specified offset in a specified array. Once this change has been bootstrapped on all our machines, the old variants can be deleted.	2006-03-21 02:33:41 +00:00
Zoltan Somogyi	be5b71861b	Convert almost all the compiler modules to use . instead of __ as ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all the compiler modules to use . instead of __ as the module qualifier. In some cases, change the names of predicates and types to make them meaningful without the module qualifier. In particular, most of the types that used to be referred to with an "mlds__" prefix have been changed to have a "mlds_" prefix instead of changing the prefix to "mlds.". There are no algorithmic changes.	2006-03-17 01:40:46 +00:00
Zoltan Somogyi	e37746945c	Further cleanups, mostly renaming predicates with ambiguous names, ... Estimated hours taken: 2 Branches: main compiler/*ctgc*.m: compiler/structure_sharing*.m: Further cleanups, mostly renaming predicates with ambiguous names, and turning some lambda expressions into named predicates.	2006-03-01 03:21:20 +00:00
Julien Fischer	45fdb6c451	Use expect/3 in place of require/2 throughout most of the ... Estimated hours taken: 4 Branches: main compiler/*.m: Use expect/3 in place of require/2 throughout most of the compiler. Use unexpected/2 (or sorry/2) in place of error/1 in more places. Fix more dodgy assertion error messages. s/map(prog_var, mer_type)/vartypes/ where the latter is meant.	2005-11-28 04:11:59 +00:00
Zoltan Somogyi	6d7b63df43	Remove support for the --split-c-files option, since it hasn't worked in a ... Estimated hours taken: 1 Branches: main Remove support for the --split-c-files option, since it hasn't worked in a while, we haven't wanted to use it in a while, and the tradeoff of greatly increased compilation time for a ~10% space gain is an increasingly bad one. compiler/options.m: doc/user_guide.texi: Remove the option. NEWS: Mention the removal of the option. compiler/modules.m: Remove the references to .split executables and archives from the generated .d files. compiler/*.m: Delete the code for handling --split-c-files=yes, and make whatever simplifications this makes possible. scripts/Mmake.*: Remove the references to .split executables and archives. scripts/mgnuc.in: scripts/mgnuc_file_opts.sh-subr: Remove the references to the --split-c-files option. tests/hard_coded/split_c_files.{m,split.exp}: tests/hard_coded/mapped_module.split.exp: Delete the test cases testing the deleted functionality. tests/hard_coded/Mmakefile: Don't test split C files.	2005-11-28 02:30:36 +00:00
Zoltan Somogyi	f9fe8dcf61	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 8 Branches: main Improve the error messages generated for determinism errors involving committed choice contexts. Previously, we printed a message to the effect that e.g. a cc pred is called in context that requires all solutions, but we didn't say *why* the context requires all solutions. We now keep track of all the goals to the right that could fail, since it is these goals that may reject the first solution of a committed choice goal. The motivation for this diff was the fact that I found that locating the failing goal can be very difficult if the conjunction to the right is a couple of hundred lines long. This would have been a nontrivial problem, since (a) unifications involving values of user-defined types are committed choice goals, and (b) we can expect uses of user-defined types to increase. compiler/det_analysis.m: Keep track of goals to the right of the current goal that could fail, and include them in the error representation if required. compiler/det_report.m: Include the list of failing goals to the right in the representations of determinism errors involving committed committed choice goals. Convert the last part of this module that wasn't using error_util to use error_util. Make most parts of this module just construct error message specifications; print those specifications (using error_util) in only a few places. compiler/hlds_out.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: compiler/compiler_util.m: Error_util is still changing reasonably often, and yet it is included in lots of modules, most of which need only a few simple non-parse-tree-related predicates from it (e.g. unexpected). Move those predicates to a new module, compiler_util.m. This also eliminates some undesirable dependencies from libs to parse_tree. compiler/libs.m: Include compiler_util.m. compiler/notes/compiler_design.html: Document compiler_util.m, and fix the documentation of some other modules. compiler/*.m: Import compiler_util instead of or in addition to error_util. To make this easier, consistently use . instead of __ for module qualifying module names. tests/invalid/det_errors_cc.{m,err_exp}: Add this new test case to test the error messages for cc contexts. tests/invalid/det_errors_deet.{m,err_exp}: Add this new test case to test the error messages for unifications inside function symbols. tests/invalid/Mmakefile: Add the new test cases. tests/invalid/det_errors.err_exp: tests/invalid/magicbox.err_exp: Change the expected output to conform to the change in det_report.m, which is now more consistent.	2005-10-28 02:11:03 +00:00
Zoltan Somogyi	b2012c0c0e	Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' ... Estimated hours taken: 8 Branches: main compiler/*.m: Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' and 'mer_mode'. This is to avoid the need to parenthesize these type names in some contexts, and to prepare for the possibility of a parser that considers those words to be reserved words. Rename some other uses of those names (e.g. as item types in recompilation.m). Delete some redundant synonyms (prog_type, mercury_type) for mer_type. Change some type names (e.g. mlds__type) and predicate names (e.g. deforest__goal) to make them unique even without module qualification. Rename the function symbols (e.g. pure, &) that need to be renamed to avoid the need to parenthesize them. Make their replacement names more expressive. Convert some more modules to four space indentation. Avoid excessively long lines, such as those resulting from the automatic substitution of 'mer_type' for 'type'.	2005-10-24 04:14:34 +00:00
Zoltan Somogyi	905e4a114f	Convert a bunch of modules to four-space indentation. ... Estimated hours taken: 4 Branches: main compiler/*.m: Convert a bunch of modules to four-space indentation. In the process, fix departures from our coding standards. In some cases, do minor other cleanups such as changing argument orders to be friendly to state variables. There are no algorithmic changes.	2005-10-12 23:51:38 +00:00
Zoltan Somogyi	d609181cb9	Consider types of the form ... Estimated hours taken: 30 Branches: main Consider types of the form :- type x ---> f. to be dummy types, since they contain no information. Optimize them the same way we currently optimize io.state and store.store. runtime/mercury_type_info.h: Add a new type_ctor_rep for dummy types. runtime/mercury_tabling.h: Add a representation for "tabled" dummy types, which don't actually have a level in the trie, so that the runtime system can handle that fact. runtime/mercury_ml_expand_body.h: When deconstructing a value of a dummy type, ignore the actual value (since it will contain garbage) and instead return the only possible value of the type. runtime/mercury_construct.c: runtime/mercury_deconstruct.c: runtime/mercury_deep_copy_body.c: runtime/mercury_tabling.c: runtime/mercury_unify_compare_body.h: library/rtti_implementation.m: Handle the type_ctor_rep of dummy types. runtime/mercury_builtin_types.c: Provide a place to record profiling information about unifications and comparisons for dummy types. runtime/mercury_mcpp.h: java/runtime/TypeCtorRep.java: library/private_builtin.m: Add a new type_ctor_rep for dummy types, and fix some previous discrepancies in type_ctor_reps. mdbcomp/prim_data.m: Move a bunch of predicates for manipulating special_pred_ids here from the browser and compiler directories. Rename the function symbols of the special_pred_id type to avoid the need to parenthesize the old `initialise' function symbol. Convert to four-space indentation. mdbcomp/rtti_access.m: Don't hardcode the names of special preds: use the predicates in prim_data.m. Convert to four-space indentation. browser/declarative_execution.m: Delete some predicates whose functionality is now in mdbcomp/prim_data.m. compiler/hlds_data.m: Replace the part of du type that says whether a type an enum, which used to be a bool, with something that also says whether the type is a dummy type. Convert to four-space indentation. compiler/make_tags.m: Compute the value for the new field of du type definitions. compiler/hlds_out.m: Write out the new field of du type definitions. compiler/rtti.m: Modify the data structures we use to create type_ctor_infos to allow for dummy types. Convert to four-space indentation. compiler/type_ctor_info.m: Modify the code that generates type_ctor_infos to handle dummy types. compiler/type_util.m: Provide predicates for recognizing dummy types. Convert to four-space indentation. compiler/unify_proc.m: Generate the unify and compare predicates of dummy types using a new code scheme that avoids referencing arguments that contain garbage. When generating code for unifying or comparing other types, ignore any arguments of function symbols that are dummy types. Don't use DCG style access predicates. compiler/higher_order.m: Specialize the unification and comparison of values of dummy types. Break up an excessively large predicate, and factor out common code from the conditions of a chain of if-then-elses. compiler/llds.m: For each input and output of a foreign_proc, include a field saying whether the value is of a dummy type. compiler/pragma_c_gen.m: Fill in the new fields in foreign_proc arguments. compiler/hlds_goal.m: Rename some predicates for constructing unifications to avoid unnecessary ad-hoc overloading. Clarify their documentation. Rename a predicate to make clear the restriction on its use, and document the restriction. Add a predicate for creating simple tests. Add a utility predicate for setting the context of a goal directly. compiler/modules.m: Include dummy types interface files, even if they are private to the module. This is necessary because with the MLDS backend, the generated code inside the module and outside the module must agree whether a function returning a value of the type returns a real value or a void value, and this requires them to agree on whether the type is dummy or not. The impact on interface files is minimal, since very few types are dummy types, and changing a type from a dummy type to a non-dummy type or vice versa is an ever rarer change. compiler/hlds_pred.m: Provide a representation in the compiler of the trie step for dummy types. compiler/layout_out.m: Print the trie step for dummy types. compiler/table_gen.m: Don't table values of dummy types, and record the fact that we don't by including a dummy trie step in the list of trie steps. compiler/add_pragma.m: compiler/add_special_pred.m: compiler/add_type.m: compiler/aditi_builtin_ops.m: compiler/bytecode.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/det_report.m: compiler/exception_analysis.m: compiler/inst_match.m: compiler/livemap.m: compiler/llds_out.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_il.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/opt_util.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/qual_info.m: compiler/rl.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/rtti_out.m: compiler/simplify.m: compiler/size_prof.m: compiler/term_constr_initial.m: compiler/term_constr_util.m: compiler/term_norm.m: compiler/termination.m: compiler/trace.m: compiler/typecheck.m: compiler/unify_gen.m: Conform to the changes above. compiler/export.m: compiler/exprn_aux.m: compiler/foreign.m: compiler/polymorphism.m: compiler/proc_label.m: compiler/rtti_to_mlds.m: compiler/special_pred.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/state_var.m: compiler/switch_util.m: compiler/trace_params.m: Conform to the changes above. Convert to four-space indentation. compiler/mlds_to_java.m: compiler/var_locn.m: Conform to the changes above, which requires threading the module_info through the module. Convert to four-space indentation. compiler/mercury_compile.m: Pass the module_info to mlds_to_java.m. compiler/ml_util.m: compiler/polymorphism.m: compiler/type_ctor_info.m: compiler/type_util.m: Delete some previously missed references to the temporary types used to bootstrap the change to the type_info type's arity. compiler/polymorphism.m: Turn back on an optimization that avoids passing parameters (such as type_infos) to foreign_procs if they are not actually referred to. compiler/prog_data.m: Convert to four-space indentation. library/svvarset.m: Add a missing predicate. trace/mercury_trace.c: Delete the unused function that used to check for dummy types. tests/debugger/field_names.{m,inp,exp}: Add to this test case a test of the handling of dummy types. Check that their values can be printed out during normal execution, and that the debugger doesn't consider them live nondummy variables, just as it doesn't consider I/O states live nondummy variables.	2005-10-05 06:34:27 +00:00
Zoltan Somogyi	df0d9036cf	Optimize calls that would be tail calls in Prolog but are followed by ... Estimated hours taken: 40 Branches: main Optimize calls that would be tail calls in Prolog but are followed by construction unifications in Mercury: last call modulo construction. For now, the optimization is available only for the LLDS backend. compiler/lco.m: Turn this module from a placeholder to a real implementation of the optimization. compiler/hlds_goal.m: Allow lco.m to attach to construction unifications a note that says that certain arguments, instead of being filled in by the unification, should have their addresses taken and stored in the corresponding variables. Group this note together with the note that asks for term size profiling to avoid an increase in the sizes of goals in the compiler in most cases. compiler/hlds_pred.m: Provide a predicate for setting the name of a predicate after its creation. This functionality is used by lco.m. Extend the pred_transformation part of the pred_origin type to allow it to express that a procedure was created by lco.m. List the new primitive store_at_ref as a no-typeinfo builtin. Fix some problems with indentation. compiler/layout_out.m: Handle the new pred_transformation. compiler/unify_gen.m: When processing construction unifications that have the new feaure turned on, perform the requested action. Fix some departures from coding style. Shorten lines by deleting unnecessary module qualifications. Add some auxiliary predicates to make the code easier to read. compiler/var_locn.m: Fix an earlier oversight: when materializing variables inside rvals and lvals, look inside memory references too. Previously, the omission didn't matter, since we didn't generate such references, but now we do. Fix some departures from coding style. compiler/llds_out.m: Fix some old XXXs in code handling memory references. We didn't use to generate such references, but now we do. Move some functionality here from code_aux.m. compiler/code_info.m: Provide some primitive operations needed by the new code in var_locn.m. Delete an unneeded predicate. compiler/options.m: Rename the existing option optimize_constructor_last_call as optimize_constructor_last_call_accumulator, since that optimization is done by accumulator.m. Make optimize_constructor_last_call be the option that calls for the new optimization. compiler/handle_options.m: Handle the implications of the new option. compiler/mercury_compile.m: Invoke the lco module by its new interface. librrary/private_builtin.m: Add a new primitive operation, store_at_ref, for use by the new optimization. Switch the module to four-space indentation. compiler/add_clause.m: Comment out the warning for clauses for builtin, since this is needed to bootstrap the addition of the new builtin. compiler/term_constr_initial.m: Handle the new builtin. compiler/accumulator.m: Conform to the change in options. compiler/builtin_ops.m: Provide a third template for builtins, for use by store_at_ref. Convert the file to four-space indentation. compiler/call_gen.m: Generate code following the new builtin template. compiler/rl_exprn.m: Minor changes to conform to the changes in builtin templates. compiler/quantification.m: Minor changes to conform to the changes in construct unifications. Don't make the "get" predicates operating on quantification_infos to return the "new" quantification_info: it is always the same as the old one. compiler/aditi_builtin_ops.m: compiler/common.m: compiler/deep_profiling.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/lambda.m: compiler/magic_util.m: compiler/ml_unify_gen.m: compiler/modecheck_unify.m: compiler/polymorphism.m: compiler/size_prof.m: Minor changes to conform to the changes in construct unifications. compiler/dependency_graph.m: Add a new predicate to recompute the dependency information, even if a previous (and possibly now inaccurate) version is present. Change the interface to make it clearer, by changing bools into types specific to the situation. Convert the file to four-space indentation. compiler/mode_constraints.m: Minor changes to conform to the changes in dependency_graph.m. compiler/code_aux.m: Delete this module. Half its functionality has been moved into llds_out.m, half to middle_rec.m (its only user). compiler/goal_form.m: Move the predicates in this module that are used only by middle_rec.m to middle_rec.m. Convert the file to four-space indentation. compiler/goal_util.m: compiler/det_util.m: Move update_instmap from det_util to goal_util, since it is usefulness extends beyond determinism analysis. Convert det_util.m to four-space indentation. compiler/middle_rec.m: Move here the code required only here from code_aux and goal_form. Update the moved code for the changes in construct unifications. The updates are specific to middle_rec.m: they wouldn't be of use to other modules. They basically say that any code that takes the addresses of fields cannot be handled by middle_rec.m. compiler/code_gen.m: compiler/det_analysis.m: compiler/live_vars.m: compiler/ll_backend.m: compiler/loop_inv.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/notes/compiler_design.html: Minor changes to conform to the deletion of code_aux.m and/or the movement of code from det_util to goal_util.m. compiler/opt_debug.m: Print info for vars in rvals. compiler/hlds_module.m: Convert a lambda to an explicit predicate to make some code easier to read. Switch the module to four-space indentation.	2005-09-13 04:56:20 +00:00
Mark Brown	3fc6b3f128	Change the representation of types in the compiler. ... Estimated hours taken: 30 Branches: main Change the representation of types in the compiler. We also add some support for handling kinds, which will be used later when we have a kind system. There are a number of places where kinds are not yet handled correctly -- we assume that all kinds will be `star'. Each of these locations is flagged with a comment that contains "XXX kind inference:". compiler/prog_data.m: Implement the new version of type (type). Change the definition of type_param to be a variable instead of a term, since all parameters must be variables anyway. Implement versions of varset.merge_* which work with tvarsets and produce renamings instead of substitutions. Renamings are more convenient than substitutions because we don't need to know the kinds of type variables in order to build the renaming, and in any case the substitutions shouldn't have anything other than variables in the range so renamings will be more efficient and safe. Define the type of kinds, and provide a couple of utility predicates to operate on them. compiler/prog_io.m: Parse type definition heads as a sym_name and list of type_params, rather than a functor. Handle this change in other predicates. Allow parse errors to be returned by get_with_type/3, and handle these errors. Remove parse_type/2. This predicate didn't do any processing, it just forwarded handling to convert_type/2. compiler/prog_io_typeclass.m: Change type_is_functor_and_vars to handle the new representation of types. In doing so, we retain the old behaviour that pure predicates pass this test, but no other pred or func types. This behaviour is arguably incorrect, but there is little point changing the behaviour at the moment. Instead we should remove these kind of restrictions entirely, but that should be done later. compiler/prog_io_util.m: Provide predicates to both parse and unparse types. We need to unparse types before printing them out, since we do a lot of special case handling when printing out terms and we don't want to duplicate this functionality for types. compiler/module_qual.m: Remove report_invalid_type. We now report ill-formed types during parsing. compiler/superhomogeneous.m: Handle errors from the parsing of type expressions. compiler/prog_out.m: Provide a predicate to convert builtin_types to their string names, and vice-versa. compiler/prog_type.m: Add a bunch of simple tests to use on types which may have kind annotations present. In such cases, types do not have a canonical representation so the simple handling of these tests is not what we want. (Note that these are only required in early phases. The kind annotations -- when they are implemented -- will be removed before type checking.) Consistently handle the application of renamings, substitutions and recursive substitutions to various data structures. compiler/mercury_to_mercury.m: Implement mercury_output_type, mercury_format_type and mercury_type_to_string. These convert the type to a term before formatting -- the reason for this is so that appropriate parentheses are used when formatting operators. This results in some slight changes to error messages, which are reflected in changes to the expected output files in the tests. Remove the old version of mercury_type_to_string. Change the argument ordering of mercury_format_var to be consistent with mercury_format_type. (Other predicates in this module should probably be changed in a similar way, since this argument ordering is more amenable to higher-order programming. But that can be left for another change.) compiler/type_util.m: Implement type unification. The behaviour is much the same as the previous behaviour, except that we now handle apply/N types properly, and we also allow for kind annotations. Implement an occurs check for types. Remove the example definition of replace_eqv_type. It isn't used and would no longer work anyway even if it would have worked before. Add a tvar_kind_map field to ctor_defn. The functions type_info_type and type_ctor_info_type now return types with `void' as their argument, rather than the type that the type_info or type_ctor_info was for. Remove type_util.real_vars/2, since it no longer does anything different from prog_type.vars/2. Remove the commented out implementation of type_to_ctor_and_args/3. Its implementation is in prog_type.m, and has changed significantly in any case. compiler/add_clause.m: Move parse_purity_annotation/3 to prog_io_util.m. compiler/check_typeclass.m: Remove apply_substitution_to_var_list/3, since we now have predicates in prog_type.m to handle such things. compiler/continuation_info.m: compiler/trace.m: Use prog_type.vars/2 instead of type_util.real_vars/2. The two predicates have the same meaning now since type_infos don't contain any type variables. compiler/hlds_data.m: Add tvar_kind_map fields to hlds_type_defn and hlds_class_defn. compiler/hlds_pred.m: Add a tvar_kind_map field to pred_info. compiler/polymorphism.m: Add a tvar_kind_map field to poly_info. Remove unify_corresponding_types, which is no longer used. compiler/hlds_out.m: Use mercury_output_type/5 instead of term_io__write_term/4 and mercury_output_term/5. compiler/post_typecheck.m: Build the void substitution directly rather than building intermediate lists. compiler/recompilation.version.m: Use term__list_subsumes instead of type_list_subsumes, which now operates only on types. This follows up on what was suggested in an XXX comment. compiler/typecheck_errors.m: Use unparse_type/2 to format error messages. compiler/typecheck_info.m: Don't export write_type_with_bindings/5. It is no longer used outside of this module. compiler/*.m: Conform to the above changes. library/rtti_implementation.m: Fix a syntax error that went undetected in our previous implementation, and amazingly enough was compiled correctly anyway. library/term.m: Move the versions of term__unify, term__unify_list and term__list_subsumes that were implemented specifically for types to here. The version of term_unify that takes a list of bound variables (i.e., variables that should not be bound any further) is used by the subsumption check, which in turn is used by recompilation.version.m. tests/invalid/kind.err_exp: tests/invalid/tc_err1.err_exp: tests/invalid/tc_err2.err_exp: tests/misc_tests/pretty_print_test.exp: Update the expected output of these tests to match what we now do.	2005-09-12 05:25:01 +00:00
Zoltan Somogyi	f7c8e5899d	Add a new tabling method, one which specifies how each argument should ... Estimated hours taken: 20 Branches: main Add a new tabling method, one which specifies how each argument should be treated, like this: :- pragma memo(p(in, in, in, out), [value, addr, promise_implied, output]). doc/reference_manual.texi: Document the new tabling method. compiler/prog_data.m: Add a new tabling method, one which specifies how each argument should be treated. compiler/hlds_pred.m: Provide for the description of untabled input arguments of tabled procedures. compiler/prog_io_pragma.m: Parse the new tabling method. Fix a bunch of formatting problems. compiler/add_pragma.m: When adding a tabling pragma to the HLDS, check that if the pragma individually specifies the tabling methods of a procedure's arguments, then those tabling methods agree with the modes of those arguments. Fix an old bug: check whether a tabled predicate's arguments are fully input or fully output, and print an error message if not. We used to check this only in table_gen.m, but there we could only abort the compiler if the check failed. Factor out some common code and thereby fix an old bug: check for conflicting tabling pragmas not just when adding the pragma to all procedures of a predicate, but also when adding it to only a specified procedure. compiler/table_gen.m: Implement the new tabling method. compiler/prog_out.m: compiler/layout_out.m: Conform to the changes above. runtime/mercury_stack_layout.h: Provide for the description of untabled input arguments of tabled procedures. trace/mercury_trace.c: Handle the new tabling method. trace/mercury_trace_internal.c: Handle the new tabling method. Delete the defaults from some switches on enums to allow gcc to recognize missing cases. Handle the untabled input arguments of tabled procedures: skip over them when printing procedures' call tables. Enable better completion for mdb's "table" command. trace/mercury_trace_tables.[ch]: Rename the breakpoint completer the proc_spec completer, since it does completions on procedure specifications. tests/debugger/print_table.{m,inp,exp}: Modify this test case to test the ability to print the tables of predicates with some untabled arguments. tests/tabling/specified.{m,exp}: New test case to check the functioning of the new tabling method by testing whether it is in fact faster to table the address of an argument instead of its value, or to not table it at all. Since the gains here are not quite as dramatic as tabled vs untabled, use a slightly looser criterion for comparing speeds than we use in the various versions of the fib test case. tests/tabling/Mmakefile: tests/tabling/Mercury.options: Enable the new test case, and set up the option it needs. tests/invalid/specified.{m,err_exp}: New test case, a slight variant of tests/tabling/specified.m, to check the compiler's ability to detect errors in the new form of tabling pragma. tests/invalid/Mmakefile: Enable the new test case.	2005-08-14 03:20:59 +00:00
Zoltan Somogyi	6e2d095a98	Add a new form of tabling pragma, fast_loose_memo. ... Estimated hours taken: 12 Branches: main Add a new form of tabling pragma, fast_loose_memo. It differs from memo in only one way: for arguments of user-defined types, instead of tabling every single function symbol in the value, it tables a pointer to the term instead. (Actually, it tables the contents of the selected argument register, so it works even if the value is not a pointer.) As the name implies, this form of tabling is faster than memo. The tradeoff is that it is looser: if two invocations specify two terms that are at different addresses but have the same value, this new form of tabling will not recognize the commonality. doc/reference_manual.texi: Document the new pragma. compiler/prog_data.m: Generalize the type specifying eval methods to allow the expression of the new form of tabling. compiler/prog_io_pragma.m: Parse the new form of tabling pragma. compiler/hlds_pred.m: Handle the new, more general form of memoing. Add the required provisions for the representation of the new form of trie step in tables. compiler/table_gen.m: Implement the new form of tabling as a minor variant of memo tabling. Convert this module to four-space indentation to reduce the number of bad line breaks. compiler/layout_out.m: compiler/prog_out.m: Conform to the changes above. library/table_builtins.m: Add the primitives required to implement fast_loose_memo. Fix an old bug: make table_lookup_insert_poly call the right macro. runtime/mercury_tabling.h: runtime/mercury_tabling_macros.h: runtime/mercury_tabling_preds.h: Provide the basic mechanism of fast_loose_memo tabling: a hash table that works on MR_Words. runtime/mercury_stack_layout.h: Allow the representation of the new evaluation method and the new form of trie step. tests/tabling/fast_loose.{m,exp}: Add this test case of the operation of fast_loose tabling. The test case pronounces success only if fast_loose_memo is measured to be significantly faster than plain memo. tests/tabling/Mmakefile: Enable the new test case.	2005-06-07 03:00:10 +00:00
Ian MacLarty	f362356b17	Make the user friendly names of predicates introduced by lambda expressions ... Estimated hours taken: 4 Branches: main Make the user friendly names of predicates introduced by lambda expressions (more) unique. This is necessary so they can be distinguished from each other in trace count files. If two or more lambda expression appear in the same context, then include their sequence number in that context in the user friendly predicate name. compiler/hlds_module.m: Instead of keeping a counter of how many lambdas appear in a module, keep a seperate counter for each context (filename/lineno). This way we only need to include the sequence number in the predicate name if there are two or more lambdas in the same context. compiler/hlds_pred.m: Add a new field to the `lambda' functor which records the count of the lambda expressin in its context. compiler/hlds_out.m: Unify with lambda/3 instead of lambda/2. compiler/lambda.m: Use the sequence number of the lambda expression in its context when creating the predicate origin. compiler/layout.m: Store the origin of a closure predicate in the layout data of the closure, so that it's user friendly name can be included in the generated C code. compiler/layout_out.m: When generating a user friendly name for lambda expression predicates, include the sequence number of the lambda expression if the sequence number is greater than one. compiler/stack_layout.m: Pass the closure origin to the closure layout construction predicate. compiler/unify_gen.m: Pass the closure origin when constructing the closure layout. tests/debugger/Mmakefile: tests/debugger/lambdatest.exp: tests/debugger/lambdatest.inp: tests/debugger/lambdatest.m: Test that the predicate names for lambda expressions are unique, even if they appear in the same call. tests/debugger/higher_order.exp: tests/debugger/lambda_expr.exp: tests/debugger/declarative/find_origin.exp: tests/debugger/declarative/find_origin.exp2: tests/debugger/declarative/higher_order.exp: tests/debugger/declarative/higher_order.exp2: tests/debugger/declarative/ho2.exp2: tests/debugger/declarative/trust.exp: tests/hard_coded/deconstruct_arg.exp: Expect the new (more) unique predicate names.	2005-05-26 00:17:06 +00:00
Zoltan Somogyi	309910d736	Change the mechanism we use to transmit a representation of procedure bodies ... Estimated hours taken: 16 Branches: main Change the mechanism we use to transmit a representation of procedure bodies from the compiler to the declarative debugger from Mercury terms to a bytecode. This achieves two objectives. First, the code for Mercury terms worked only as long as the compiler used the same data representation as the program being compiled; it generated incorrect term representations when e.g. the compiler generating code in reserve tag grades. Second, the new representation is significantly smaller. The total size of the .c files in the compiler directory in grade asm_fast.gc.decldebug.tr is now only 213 Mb compared with 313 Mb previously (a reduction of almost one third). The executable file size of a compiler compiled in asm_fast.gc.decldebug.tr is now only 59 Mb, compare with 64 Mb previously (a reduction of almost 8%, and there is room for further reductions). The overhead of the decldebug grade when compared with a plain debug grade now only about 25%, compared to about 36% before. The downside is that the procedure body representation must now be constructed by the declarative debugger from the bytecode instead of being available directly. We minimize this effect by using a cache to ensure that each procedure's body representation is constructed at most once. browser/declarative_execution.m: Do not include the procedure representation in call nodes. This should make the annotated trace somewhat smaller and quicker to construct. Since this code will be executed many more times than the number of procedures whose bodies are needed by subterm dependency tracking, the overall effect of this change on speed should be positive. Instead, add code to construct procedure body representations on demand from bytecode, which is reachable indirectly through the call's node label label structure. browser/declarative_tree.m: Conform to the new structure of call nodes. compiler/prog_rep.m: Replace the code that generated the term representation of procedure bodies with code that generates a bytecode representation of procedure bodies. compiler/static_term.m: Delete this file, since it is no longer needed. compiler/notes/compiler_design.html: Document the deletion of static_term.m. mdbcomp/program_representation.m: Add the definitions related to the structure of the bytecode that are shared by the compiler and the declarative debugger. This includes the representations of determinisms. compiler/code_model.m: To prevent requiring double maintenance, use the facilities now in mdbcomp/program_representation.m to encode determinisms. runtime/mercury_stack_layout.h: compiler/layout.m: compiler/layout_out.m: compiler/opt_debug.m: compiler/stack_layout.m: Replace the proc layout field holding the procedure representation term with the field holding the procedure representation bytecode. runtime/mercury_grade.h: Record the breaking of backward compatibility in debug grades. compiler/options.m: Add an option for use by compiler implementors while implementing changes like this. runtime/mercury_trace_base.[ch]: Add the hash table that caches the results of bytecode translations. trace/mercury_trace_declarative.c: Do not include procedure representations when constructing call nodes, since it is no longer necessary. trace/mercury_trace_internal.c: Update the code that deals with procedure bodies to use the bytecode representation.	2005-03-31 04:44:33 +00:00
Zoltan Somogyi	3c60c0e485	Change a bunch of modules to import only one module per line, even ... Estimated hours taken: 4 Branches: main compiler/*.m: Change a bunch of modules to import only one module per line, even from the library. compiler/mlds_to_il.m: compiler/mlds_to_managed.m: Convert these modules to our current coding style. Use state variables where appropriate. Use predmode declarations where possible.	2005-03-22 06:40:32 +00:00
Julien Fischer	601fe20aba	Simplify the structure of the compiler by removing the cycle ... Estimated hours taken: 3.5 Branches: main Simplify the structure of the compiler by removing the cycle parse_tree -> backend_libs -> check_hlds -> parse_tree from the package dependency graph. I've done this by factoring out the code in backend_libs.foreign and backend_libs.name_mangle that is needed by the frontend of the compiler and putting it in a new module, parse_tree.prog_foreign. This removes the dependency between the parse_tree and backend_libs packages. The obvious downside to this is that the name mangler is now split in two, although such a division was always in implicit in the predicates of the name_mangle module anyway, ie. between those bits that operate on the HLDS/MLDS/LLDS level data structures and those that don't. compiler/name_mangle.m: compiler/foreign.m: compiler/prog_foreign.m: Move code for dealing with foreign language procedures that is required by the parse_tree package into a new module, prog_foreign. Update the formatting in some of these modules so that they match our current coding standard. compiler/*.m: Update to reflect the above change. compiler/notes/compiler_design.html: Include the new module. Fix some spelling errors.	2005-03-21 04:45:51 +00:00
Peter Wang	d8c47d42ea	This change adds a tupling transformation to the compiler. ... Estimated hours taken: two months Branches: main This change adds a tupling transformation to the compiler. It takes the HLDS and tries to find opportunities for procedures to pass some arguments to each as a tuple rather than as individual arguments. compiler/interval.m: compiler/stack_opt.m: compiler/backend_libs.m: Moved the predicate from stack_opt.m that builds up information about intervals into a new module backend_libs__interval, and generalised it for use by the tupling transformation. The predicate was called `optimize_live_sets_in_goal' and was renamed to `build_interval_info_in_goal'. Also moved the predicate `record_decisions_in_goal'. compiler/transform_hlds.m: compiler/tupling.m: New module `tranform_hlds__tupling'. compiler/mercury_compile.m: Added code to run the tupling pass. Run a simplification pass after the untupling transformation. The untupling transformation generates procedures that really should be simplified, and it should help the tupling transformation (which runs directly after untupling). compiler/options.m: Add the options --tuple, --tuple-trace-counts-file, --tuple-costs-ratio and --tuple-min-args. compiler/handle_options.m: Disable --tuple when debugging is on. compiler/hlds_goal.m: compiler/common.m: compiler/saved_vars.m Add `tuple_opt' goal feature. compiler/hlds_pred.m: compiler/layout_out.m: Add a new `tuple' functor for `pred_transformation'. compiler/untupling.m: Made the untupling transformation give better names to the head variables in the untupled versions of procedures that it generates. This is needed for the tupling transformation to find related head variables between procedures in an SCC. mdbcomp/trace_counts.m: Add predicate `restrict_trace_counts_to_module'. library/list.m: Add `nth_member_lookup/3', a deterministic version of `nth_member_search/3'.	2005-03-06 05:17:42 +00:00