88 Commits

Author	SHA1	Message	Date
Simon Taylor	18430aaef1	Aditi compilation. ... Estimated hours taken: 1200 Aditi compilation. compiler/options.m: The documentation for these is commented out because the Aditi system is not currently useful to the general public. --aditi: enable Aditi compilation. --dump-rl: write the intermediate RL to `<module>.rl_dump'. --dump-rl-bytecode: write a text version of the bytecodes to `<module>.rla' --aditi-only: don't produce a `.c' file. --filenames-from-stdin: accept a list of filenames to compile from stdin. This is used by the query shell. --optimize-rl, --optimize-rl-cse, --optimize-rl-invariants, --optimize-rl-index, --detect-rl-streams: Options to control RL optimization passes. --aditi-user: Default owner of any Aditi procedures, defaults to $USER or "guest". --generate-schemas: write schemas for base relations to `<module>'.base_schema and schemas for derived relations to `<module>'.derived_schema. This is used by the query shell. compiler/handle_options.m: Handle the default for --aditi-user. compiler/hlds_pred.m: compiler/prog_data.m: compiler/prog_io_pragma.m: compiler/make_hlds.m: Add some Aditi pragma declarations - `aditi', `supp_magic', `context', `naive', `psn' (predicate semi-naive), `aditi_memo', `aditi_no_memo', `base_relation', `owner' and `index'. Separate out code to parse a predicate name and arity. compiler/hlds_pred.m: Add predicates to identify Aditi procedures. Added markers `generate_inline' and `aditi_interface', which are used internally for Aditi code generation. Add an `owner' field to pred_infos, which is used for database security checks. Add a field to pred_infos to hold the list of indexes for a base relation. compiler/make_hlds.m: Some pragmas must be exported if the corresponding predicates are exported, check this. Make sure stratification of Aditi procedures is checked. Predicates with a mode declaration but no type declaration are no longer assumed to be local. Set the `do_aditi_compilation' field of the module_info if there are any local Aditi procedures or base relations. Check that `--aditi' is set if Aditi compilation is required. compiler/post_typecheck.m: Check that every Aditi predicate has an `aditi__state' argument, which is used to ensure sequencing of updates and that Aditi procedures are only called within transactions. compiler/dnf.m: Changed the definition of disjunctive normal form slightly so that a call followed by some atomic goals not including any database calls is considered atomic. magic.m can handle this kind of goal, and it results in more efficient RL code. compiler/hlds_module.m: compiler/dependency_graph.m: Added dependency_graph__get_scc_entry_points which finds the procedures in an SCC which could be called from outside. Added a new field to the dependency_info, the aditi_dependency_ordering. This contains all Aditi SCCs of the original program, with multiple SCCs merged where possible to improve the effectiveness of differential evaluation and the low level RL optimizations. compiler/hlds_module.m: Add a field to record whether there are any local Aditi procedures in the current module. Added versions of module_info_pred_proc_info and module_info_set_pred_proc_info which take a pred_proc_id, not a separate pred_id and proc_id. compiler/polymorphism.m: compiler/lambda.m: Make sure that predicates created for closures in Aditi procedures have the correct markers. compiler/goal_util.m: Added goal_util__switch_to_disjunction, goal_util__case_to_disjunct (factored out from simplify.m) and goal_util__if_then_else_to_disjunction. These are require because supplementary magic sets can't handle if-then-elses or switches. compiler/type_util.m: Added type_is_aditi_state/1. compiler/mode_util.m: Added partition_args/5 which partitions a list of arguments into inputs and others. compiler/inlining.m: Don't inline memoed procedures. Don't inline Aditi procedures into non-Aditi procedures. compiler/intermod.m: Handle Aditi markers. Clean up handling of markers which should not appear in `.opt' files. compiler/simplify.m: Export a slightly different interface for use by magic.m. Remove explicit quantifications where possible. Merge multiple nested quantifications. Don't report infinite recursion warnings for Aditi procedures. compiler/prog_out.m: Generalised the code to output a module list to write any list. compiler/code_gen.m: compiler/arg_info.m: Don't process Aditi procedures. compiler/mercury_compile.m: Call magic.m and rl_gen.m. Don't perform the low-level annotation passes on Aditi procedures. Remove calls to constraint.m - sometime soon a rewritten version will be called directly from deforestation. compiler/passes_aux.m: Add predicates to process only non-Aditi procedures. compiler/llds.m: compiler/llds_out.m: Added new `code_addr' enum members, do_{det,semidet,nondet}_aditi_call, which are defined in extras/aditi/aditi.m. compiler/call_gen.m: Handle generation of do_*_aditi_call. compiler/llds_out.m: Write the RL code for the module as a constant char array in the `.c' file. compiler/term_errors.m: compiler/error_util.m: Move code to describe predicates into error_util.m Allow the caller to explicitly add line breaks. Added error_util:list_to_pieces to format a list of strings. Reordered some arguments for currying. compiler/hlds_out.m: Don't try to print clauses if there are none. runtime/mercury_init.h: util/mkinit.c: scripts/c2init.in: Added a function `mercury__load_aditi_rl_code()' to the generated `<module>_init.c' file which throws all the RL code for the program at the database. This should be called at connection time by `aditi__connect'. Added an option `--aditi' which controls the output `mercury__load_aditi_rl_code()'. compiler/notes/compiler_design.html: Document the new files. Mmakefile: bindist/Mmakefile: Don't distribute extras/aditi yet. New files: compiler/magic.m: compiler/magic_util.m: Supplementary magic sets transformation. Report errors for constructs that Aditi can't handle. compiler/context.m: Supplementary context transformation. compiler/rl_gen.m: compiler/rl_relops.m: Aditi code generation. compiler/rl_info.m: Code generator state. compiler/rl.m: Intermediate RL representation. compiler/rl_util: Predicates to collect information about RL instructions. compiler/rl_dump.m: Print out the representation in rl.m. compiler/rl_opt.m: Control low-level RL optimizations. compiler/rl_block.m: Break a procedure into basic blocks. compiler/rl_analyse.m: Generic dataflow analysis for RL procedures. compiler/rl_liveness.m: Make sure all relations are initialised before used, clear references to relations that are no longer required. compiler/rl_loop.m: Loop invariant removal. compiler/rl_block_opt.m: CSE and instruction merging on basic blocks. compiler/rl_key.m: Detect upper/lower bounds for which a goal could succeed. compiler/rl_sort.m: Use indexing for joins and projections. Optimize away unnecessary sorting and indexing. compiler/rl_stream.m: Detect relations which don't need to be materialised. compiler/rl_code.m: RL bytecode definitions. Automatically generated from the Aditi header files. compiler/rl_out.m: compiler/rl_file.m: Output the RL bytecodes in binary to <module>.rlo (for use by Aditi) and in text to <module>.rla (for use by the RL interpreter). Also output the schema information if --generate-schemas is set. compiler/rl_exprn.m: Generate bytecodes for join conditions. extras/aditi/Mmakefile: extras/aditi/aditi.m: Definitions of some Aditi library predicates and the interfacing and transaction processing code.	1998-12-06 23:49:14 +00:00
Zoltan Somogyi	27f024b2e9	Reorganize the handling of global data structures, and expose the table ... Estimated hours taken: 16 Reorganize the handling of global data structures, and expose the table pointers for tabled predicates to allow the tables to be reset to empty by hand-written C code for benchmarking purposes. compiler/hlds_module.m: Introduce a new submodule for dealing with global data. At the moment it deals with (a) layout structures and (b) tabling pointers. compiler/continuation_info.m: Remove the data structures and predicates whose equivalents are now in hlds_module. compiler/llds.m: Introduce a new kind of item, that of compiler-generated variables whose value is not defined by rvals. At the moment, the only such item is a tabling pointer variable. compiler/mercury_compile.m: Include the new kind of item in the generated LLDS. compiler/table_gen.m: Use the new kind of item instead of a static variable declaration in pragma C code to hold the tabling pointer. Remove lots of spaces at ends of lines, since many of these screw up paragraph commands in vi. compiler/base_type_layout.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/llds_out.m: compiler/mercury_to_mercury.m: compiler/switch_gen.m: compiler/transform_llds.m: compiler/unify_gen.m: Handle the changes in the data structures. library/private_builtin.m: Remove the predicate get_table, which is no longer used after the changes to table_gen.m.	1998-11-24 03:57:47 +00:00
Zoltan Somogyi	620ce80408	Make stack layout structures work in grades that do not have static code ... Estimated hours taken: 16 Make stack layout structures work in grades that do not have static code addresses. (Although it seems that those grades do not work in the absence of layout structures.) compiler/llds_out.m: If an entry label has a layout structure, then during its initialization, output a macro that will, if necessary, initialize the code address inside its layout structure. Do not output a const before a layout structure if the macro will actually initialize a code address inside it. compiler/llds.m: Separate out proc_layouts from internal_layouts in the type data_name, since only proc_layouts have code addresses in them. Clarify the existing documentation of the label type's alternatives. This should help prevent the recurrence of bugs like the one in mercury_goto.h. compiler/stack_layout.m: Replace code addresses inside proc layout structures with a dummy value if code addresses are not static. runtime/mercury_goto.h: Fix a long-standing bug: init_local should treat its argument as a procedure entry label, not as a label internal to a procedure. runtime/mercury_stack_layout.h: In the macros for creating proc layouts by hand-written C code, allow for the absence of static code addresses, and add a new macro that fills in the code address slot in proc layouts at initialization time if necessary. library/benchmarking.m: library/private_builtin.m: library/std_util.m: Add calls to the new initialization macro to accompany hand-written proc layout structures.	1998-11-12 03:16:29 +00:00
Zoltan Somogyi	8a0ceb49aa	This checkin has several major purposes, set out in the sections below, ... Estimated hours taken: 240 This checkin has several major purposes, set out in the sections below, all connected with the implementation of the new debugger command set. DOCUMENT NEW DEBUG COMMAND SET doc/user_guide.texi: Add a new section on the debugger. The description of the commands is complete, but some of the background sections, and the section about how to build debuggable executables, are not yet done. Update the documentation of the tracing options. doc/generate_mdb_doc: A new shell script that automatically converts some of the new sections of the user guide into the online documentation of the debugger. doc/mdb_categories: The fixed initial part of the online documentation. doc/Mmakefile: Add rules for creating mdb_doc, the file that is the online documentation of the debugger, and for installing it together with mdbrc. Mmake.common.in: Define INSTALL_DOC_DIR for doc/Mmakefile. scripts/mdbrc.in: A debugger command script that reads in the online documentation and then defines some standard aliases. configure.in: Define the variable that scripts/mdb.in and scripts/mdbrc.in use to find the right files, and get configure to perform the substitutions. configure.in: scripts/mdb: scripts/mdb.in: Replace mdb with mdb.in. Mdb is now created during configuration from mdb.in, filling in the name of the file that contains the default debugger initialization commands. util/info_to_mdb.c: A program that does most of the work involved in automatically converting user guide sections into online documentation. (This couldn't easily be written in sh, because sh's read command has no notion of pushback.) util/Mmakefile: Add info_to_mdb to the list of targets. tools/bootcheck: Make sure that the tests in tests/debugger are executed with an initialization setup that is equivalent to what users will see by default. REORGANIZE TRACING OPTIONS compiler/globals.m: compiler/handle_options.m: compiler/options.m: compiler/trace.m: Reorganize the handling of trace levels around the new options --trace-internal, --trace-redo, and --trace-return. compiler/*.m: Use the new ways of getting at trace levels. tests/hard_coded/typeclasses/Mmakefile: s/--trace all/--trace deep/ SUPPORT RETRY compiler/trace.m: After every call to MR_trace(), emit code that checks whether it should jump away, and if yes, performs the jump. This is used to implement retry. (The debugger cannot execute the jump itself because it is in the wrong C stack frame.) compiler/llds.m: compiler/continuation_info.m: compiler/stack_layout.m: Modify the data structures that record information about live value at program points, to record the identity of each variable. This is necessary for the implementation of the restart command, since we do not want to confuse two distinct variables just because they have the same name. For example, a variable whose name is X and number is 5 is now recorded in the name array as "5:X". Clean up the data structure a bit, so that we don't have to store dummy names for values that are not variables. compiler/*.m: Minor changes to conform to the data structure changes. runtime/mercury_stack_layout.h: Redefine an existing macro to strip away the initial number: prefix from the "name" of a variable (keeping its original function on changed data), and add a new one to access the raw unstripped data. runtime/mercury_init.h: runtime/mercury_wrapper.h: Update the prototype of MR_trace_{fake,real}, and the type of the global that points to them. runtime/mercury_layout_util.h: Add an extra function, MR_get_register_number, for use by retry. USE FIXED STACK SLOTS FOR TRACE INFO compiler/code_gen.m: compiler/code_info.m: compiler/live_vars.m: compiler/trace.m: If execution tracing is enabled, reserve the first few stack slots to hold the event number of the call event, the call number, the call depth, the redo layout structure address (if generating redo events) and the from_full flag at the time of call (if we are doing shallow tracing). By allocating the first four of these to fixed stack slots, the debugger knows where to look for them without having to be told. It finds out the location of the fifth, if needed, from a new slot in the proc layout structure. (It is not possible to allocate all five to fixed stack slots without wasting stack space in some cases.) compiler/trace.m: Remove from the call to MR_trace the parameters that are now in fixed stack slots, since MR_trace can now look them up itself. compiler/continuation_info.m: compiler/stack_layout.m: Add an extra field to the proc_layout_info. If the module is shallow traced, this field says which stack slot holds the saved value of MR_from_full. If it is not shallow traced, this field says that there is no such stack slot. runtime/mercury_stack_layout.h: Add macros for accessing the fixed stack slots holding the event number of the call event, the call number, the call depth, and, at a redo event, the redo layout structure address. Support the new field in proc layouts that gives the location of the from-full flag (if any). runtime/mercury_trace_base.[ch]: trace/mercury_trace.[ch]: Remove the call number and call depth arguments from MR_trace and its avatars, since this info is now in fixed stack slots in every procedure that can call MR_trace. This should reduce the size of the executable significantly, since there are lots of calls to MR_trace. runtime/mercury_init.h: runtime/mercury_wrapper.h: Update the prototype of MR_trace_{fake,real}, and the type of the global that points to them. START NUMBERING FRAMEVARS FROM ONE compiler/code_info.m: compiler/live_vars.m: compiler/llds_out.m: compiler/trace.m: Start numbering framevars from 1 internally to the compiler; the runtime already starts from 1. This simplifies several tasks. ADD REDO EVENTS compiler/trace.m: compiler/code_gen.m: Before the code that executes "succeed()", emit code to push a a temp nondet frame whose redoip points to a label in the runtime that calls MR_trace for a REDO event and then fails, provided --trace-redo is set. compiler/llds.m: Add a new code address constant, do_trace_redo_fail, which stands for the address in the trace system to which calls MR_trace for the redo event and then fails. compiler/trace.m: compiler/llds_out.m: Provided we are doing redo tracing, fill in the slot that holds the layout information for the REDO event. compiler/*.m: Minor changes to conform to handle the new code address constant. browser/debugger_interface.m: Add redo to trace_port_type. runtime/mercury_trace_base.[ch]: Add a C module containing the code that calls MR_trace for REDO events. ENSURE THAT INPUT ARGUMENTS ARE ALWAYS VISIBLE compiler/trace.m: When generating the set of live variables at internal ports, the variables that are in the pre-death set of the goal into which we are entering may not be available. However, the variables in the pre-death set that are also in the resume vars set will be available, so now include info about them in the layout structure for the event. Since with tracing the non-clobbered input args are in all resume vars sets, this ensures that these input args will be available from all internal events. compiler/code_info.m: Export a previously internal predicate (current_resume_point_vars) to make this possible. BUG FIX: WANT RETURN LAYOUTS compiler/globals.m: compiler/call_gen.m: compiler/code_info.m: compiler/mercury_compile.m: Add a new pred globals__want_return_layouts, which says whether the compiler should generate layout structures for call returns. This pred centralizes the several previous copies of the test. One of those copies (the one in call_gen) was faulty, leading to a bug: in the presence of execution tracing but the absence of accurate gc, information about the variables that are live at the call return wasn't being gathered properly. BUG FIX: #include mercury_trace_base.h compiler/llds_out.m: #include mercury_trace_base.h, not mercury_trace.h, since now mercury_trace_base.h defines everything directly accessible from modules compiled with tracing. RECAST MERCURY_TRACE_UTIL AS MERCURY_LAYOUT_UTIL runtime/mercury_trace_util.[ch]: runtime/mercury_layout_util.[ch]: Rename this module from trace_util to layout_util, since it is also used by the native garbage collector. Remove "trace" from the names of functions. Get rid of the global variable MR_saved_regs, and instead thread a pointer to this data structure through the relevant functions as an extra argument. Add a lot more documentation in the header file. runtime/Mmakefile: Reflect the module rename. runtime/*.c: Refer to the new module. DELETE EASY-TO-MISUSE MACROS runtime/mercury_stacks.h: Delete the based_framevar and based_detstackvar macros, since their continued use can lead to off-by-one errors, and the saved_framevar and saved_detstackvar macros, since they are no longer used. runtime/*.c Update any references to any macros removed from mercury_stacks.h. MISC RUNTIME CHANGES runtime/mercury_trace_base.[ch]: trace/mercury_trace*.[ch]: Make typedef'd names conform to the naming convention. Make MR_trace_call_{seqno,depth} consistently Unsigned, rather than sometimes Word and sometimes Unsigned. FIX BUG: MAKE THE DEBUGGER PRINT TO STDOUT, NOT THE CURRENT STREAM library/io.m: Export to C code the predicates that return the identities and types of stdin, stdout and stderr, as well as io__print/[34]. library/std_util.m: Export to C code a predicate that returns the type_info for the type stdutil:type_info. This type_info is required if C code wants to invoke make_permanent on any type_info structure, as the debugger does. runtime/mercury_init.h: Add extern declarations for the C functions now exported from io.m. runtime/mercury_wrapper.[ch]: Add new global variables to hold the addresses of these C functions. runtime/mercury_layout_util.c: Use indirect calls through these global variables to print Mercury values, instead of lower-level code. util/mkinit.c: Assign the addresses of the functions exported from io.m to the global variables defined in mercury_wrapper.h. BUG FIX: STACK TRACE FUNCTIONS DEPEND ON THE LABEL TABLE runtime/mercury_stack_trace.c: On entry to any of the functions exported from this module, ensure that the label table is loaded by calling do_init_modules. Without a filled-in label table, the stack trace will not be able to find any stack layout info. BUG FIX: REMOVE BROWSER/*.C configure.in: When removing .c files generated by the C compiler, remove those in the browser directory as well as the compiler, library and profiler directories. IMPLEMENT NEW DEBUGGER COMMAND SET runtime/mercury_stack_trace.[ch]: Factor out the code that prints the id of a procedure into a function of its own, so that it can also be used from the debugger, ensuring appearance commonality. Add more documentation in the header file. trace/mercury_trace_internal.c: Implement the proposed command set. Command names are now words, and several commands now have options allowing the user to override the default print level or strictness of the command, or the invocation conditions or action of a break point. Allows control over command echoing and the scrolling of sequences of event reports. Supports aliases, command file sourcing etc. Implements the retry command, using the info in the fixed stack slots. trace/mercury_trace.[ch]: Extend the trace controls to support the new functionalities required by the new debugger language, which are print levels, variable-strictness commands, a more flexible finish command, and the retry command. Pass the command structure to MR_trace_event_report, since the user can now forcibly terminate the scrolling of reports. trace/mercury_trace_alias.[ch]: New module to manage aliases for the debugger. trace/mercury_trace_help.[ch]: New module to interface to browser/help.m. trace/mercury_trace_spy.[ch]: New module to manage break points. The test of whether an event matches a break point is now much more efficient than before. The new module also allows several breakpoints with different actions and different invocation conditions (e.g. all ports, entry port, interface ports or specific (possibly internal) port) to be defined on the same procedure. trace/mercury_trace_tables.[ch]: New module to manage a table of the debuggable modules, in which each such module is linked to the list of the layouts of all the procedures defined in that module. This information allows the debugger to turn the name of a predicate/function (possibly together with its arity and mode number) into the procedure layout structure required by the spy point module. Eventually it may also be useful in supplying lists of identifiers for command line completion. Modules for which no stack layout information is available will not be included in the table, since do_init_modules will not register any labels for them in the label table. trace/Mmakefile: Mention the new files. runtime/mercury_array_macros.h: A new file holding macros that can be useful in more than one module. runtime/Mmakefile: Mention the new file. runtime/mercury_conf.h.in: Mention a new configuration macro, MR_CANNOT_USE_STRUCTURE_ASSIGNMENT, used by runtime/mercury_array_macros.h. configure.in: Find out whether we need to define MR_CANNOT_USE_STRUCTURE_ASSIGNMENT. ADD TRACE DEPTH HISTOGRAMS runtime/mercury_conf_param.h: Document MR_TRACE_HISTOGRAM. runtime/mercury_trace_base.[ch]: Define the data structures for the histogram, and print the histogram when a traced program exits if MR_TRACE_HISTOGRAM is set. trace/mercury_trace.[ch]: If MR_TRACE_HISTOGRAM is defined, record a count of the number of events at each depth. This information can help us evaluate space-time tradeoffs. FACTOR OUT SHELL CODE HANDLING GRADE IMPLICATIONS scripts/final_grade_options.sh-subr: A new file to contain any code that implements implications between grade flags; currently implements the implication debug -> use trail. scripts/mgnuc.in: scripts/ml.in: Replace the code that is now in final_grade_options.sh-subr with an inclusion of final_grade_options.sh-subr. configure.in: Handle final_grade_options.sh-subr as {init,parse}_grade_options.sh-subr are handled. SIMPLIFY THE MAINTAINANCE OF CONSISTENCY BETWEEN DEBUGGER CODE AND DOCUMENTATION doc/Mmakefile: Add rules for creating mdb_command_list, a C code fragment that can included manually in trace/mercury_trace_internal.c to supply the list of valid commands, and mdb_command_test.inp, which is a list of invalid invocations of debugger commands, which tests whether the help message for such invocations can be located as expected. doc/generate_mdb_command_list: doc/generate_mdb_command_test: Awk scripts to create mdb_command_list and mdb_command_test.inp respectively from mdb_doc. tools/bootcheck: Copy mdb_command_test.inp from doc to tests/debugger. tests/debugger/Mmakefile: Add a new test that checks whether we get an internal error, unable to locate the right help node, for each invalid command invocation in mdb_command_test.inp. UPDATE TEST CASES tests/debugger/Mmakefile: Reenable queens. Conform to the new set of options. tests/debugger/*.inp: tests/debugger/*.exp: Update the inputs and expected outputs of the debugger test cases to use the new command set and output formats.	1998-10-16 06:20:28 +00:00
Zoltan Somogyi	ed063bcc00	Extend the new failure handling method to optionally preserve an invariant ... Estimated hours taken: 30 Extend the new failure handling method to optionally preserve an invariant required by accurate gc: always being able to tell with respect to what MR_sp or MR_curfr to interpret the stackvars and framevars referred to by the label whose address is the redoip slot of a nondet stack frame. This basically requires limitations on the hijacking of redoip/redofr slot pairs. compiler/notes/failure.html: Describe the new extension. Change the terminology to conform to what is used in the code. compiler/llds.m: For each temporary frame on the nondet stack, specify the native stack of the procedure that created it. This is so that we know whether the temporary frame ought to have the fourth slot that specifies the right value of MR_sp. (The fourth slot is included only in temporary nondet stack frames created procedures that live on the det stack; procedures that live on the nondet stack never have any of their variables on the det stack.) Remove the modframe llds instruction, since it does not specify what frame's redoip slot it is assigning to. This is error-prone (see peephole.m below). We were not using modframe much anyway. compiler/llds_out.m: compiler/opt_debug.m: Emit either mktempframe or mkdettempframe depending on the new field in temp_frame. compiler/code_info.m: Add a fourth item to the failure state, which states whether the top frame of the nondet stack may be hijacked. Initialize it from the option --allow-hijacks. If about to do a hijack but the failure state says no, create a temporary frame instead. Separate out the code for creating temporary frames, since it is now called from more than one place. Generalize the code to handle the new type of temp frame. compiler/code_info.m: compiler/ite_gen.m: Simplify the way we transmit information about the location of the address of the nondet stack frame in which the soft cut is performed from the start of the condition to its end. Remove the predicate code_info__maybe_push_temp_frame; its functionality is now achieved in code_info.m by disabling and restoring --allow-hijacks around the generation of code for the condition. This also allows us to get rid of the code that finds out whether the condition can do any hijacking. compiler/opt_util.m: Rename next_modframe as next_assign_to_redoip, and add an additional argument that says which frame's redoip we are after. compiler/peephole.m: Use the new argument of opt_util__next_assign_to_redoip to fix a bug where a mkframe of a temporary frame (which leaves curfr unchanged) that was followed a modframe (which assigns to the redoip of curfr) was incorrectly optimized (the assignment to the redoip slot was applied to the temporary frame, not the ordinary one). compiler/*.m: Minor changes to accommodate the disappearance of modframe. runtime/mercury_stacks.h: Add macros to support four-word temp frames on the nondet stack. Make the macros that access nondet stack frame slots start with MR_, while keeping (redefined) macros needed for backward compatibility. Remove the modframe macro. Fix a dangling reference to PREDNM instead of MR_PREDNM. runtime/mercury_stack_trace.c: Modify the stack tracing code to allow for the new four-word temp frames. Use the new MR_ prefixed variants of the macros. runtime/mercury_debug.h: runtime/mercury_misc.[ch]: Remove references to modframe. tests/general/complex_failure.{m,exp}: A new test case to tickle the various ways of handling nested disjunctions and if-then-elses in the new code generator. tests/general/Mmakefile: Enable the new test case. tests/{general,hard_coded}/space.{m,exp}: Move this test case from general to hard_coded. Although NU-Prolog can execute it, it does not give the same answers as Mercury due to a different default ordering and a difference in integer size (26-bit integers in NU-Prolog) that changes the behavior of the pseudo random-number generator. tests/hard_coded/cycles2.exp: Add the missing .exp file for this existing test case. tests/hard_coded/Mmakefile: Enable the old test cases cycles, cycles2 and space, since we now pass them.	1998-07-29 08:57:09 +00:00
Zoltan Somogyi	d1855187e5	Implement new methods of handling failures and the end points of branched ... Estimated hours taken: 260 Implement new methods of handling failures and the end points of branched control structures. compiler/notes/failure.html: Fix an omission about the handling of resume_is_known in if-then-elses. (This omission lead to a bug in the implementation.) Optimize cuts across multi goals when curfr is known to be equal to maxfr. Clarify the wording in several places. compiler/code_info.m: Completely rewrite the methods for handling failure. Separate the fields of code_info into three classes: those which do not change after initialization, those which record state that depends on where in the HLDS goal we are, and those which contain persistent data such as label and cell counters. Rename grab_code_info and slap_code_info as remember_position and reset_to_position, and add a wrapper around the remembered code_info to make it harder to make mistakes in its use. (Only the location-dependent fields of the remembered code_info are used, but putting only them into a separate data structure would result in more, not less, memory being allocated.) Gather the predicates that deal with handling branched control structures into a submodule. Reorder the declarations and definitions of access predicates to conform to the new order of fields. Reorder the declarations and definitions of the failure handling submodule to better reflect the separation of higher-level and lower-level predicates. compiler/code_gen.m: Replace code_gen__generate_{det,semi,non}_goal_2 with a single predicate, since for most HLDS constructs the code here is the same anyway (the called preds check the code model when needed). Move classification of the various kinds of unifications to unify_gen, since that is where it belongs. Move responsibility for initializing the code generator's trace info to code_info. Move the generation of code for negations to ite_gen, since the handling of negations is a cut-down version of the handling of negations. This should make the required double maintenance easier, and more likely to happen. compiler/disj_gen.m: compiler/ite_gen.m: These are the two modules that handle most failures; they have undergone a significant rewrite. As part of this rewrite, factor out the remaining common code between model_non and model_{det,semi} goals. compiler/unify_gen.m: Move classification of the various kinds of unifications here from code_gen. This allows us to keep several previously exported predicates private. compiler/call_gen.m: Factor out some code that was common to ordinary calls, higher order calls and method calls. Move the common code that checks whether we are doing tracing to trace.m. Replace call_gen__generate_{det,semi,nondet}_builtin with a single predicate. Delete the commented out call_gen__generate_complicated_unify, since it will never be needed and in any case suffered from significant code rot. compiler/llds.m: Change the mkframe instruction so that depending on one of its arguments, it can create either ordinary frames, or the cut-down frames used by the new failure handling algorithm (they have only three fixed fields: prevfr, redoip and redofr). compiler/llds_out.m: Emit a #define MR_USE_REDOFR before including mercury_imp.h, to tell the runtime we are using the new failure handling scheme. This effectively changes the grade of the compiled module. Emit MR_stackvar and MR_framevar instead of detstackvar and framevar. This is a step towards cleaning up the name-space, and a step towards making both start numbering at 0. For the time being, the compiler internally still starts counting framevars at 0; the code in llds_out.m adds a +1 offset. compiler/trace.m: Change the way trace info is initialized to fit in with the new requirements of code_info.m. Move the "are we tracing" check from the callers to the implementation of trace__prepare_for_call. compiler/*.m: Minor changes in accordance with the major ones above. compiler/options.m: Introduce a new option, allow_hijacks, which is set to "yes" by default. It is not used yet, but the idea is that when it is set to no, the code generator will not generate code that hijacks the nondet stack frame of another procedure invocation; instead, it will create a new temporary nondet stack frame. If the current procedure is model_non, it will have three fields: prevfr, redoip and redofr. If the current procedure is model_det or model_semi, it will have a fourth field that is set to the value of MR_sp. The idea is that the runtime system, which will be able to distinguish between ordinary frames (whose size is at least 5 words), 3-word and 4-word temporary frames, will now be able to use the redofr slots of all three kinds of frames and the fourth slot values of 4-word temporary frames as the addresses relative to which framevars and detstackvars respectively ought to be offset in stack layouts. compiler/handle_options.m: Turn off allow_hijacks if the gc method is accurate. runtime/mercury_stacks.h: Change the definitions for the nondet stack handling macros to accommodate the new nondet stack handling discipline. Define a new macro for creating temp nondet frames. Define MR_based_stackvar and MR_based_framevar (both of which start numbering slots at 1), and express other references, including MR_stackvar and MR_framevar and backward compatible definitions of detstackvar and framevar for hand-written C code, in terms of those two. runtime/mercury_stack_trace.[ch]: Add a new function to print a dump of the fixed elements nondet stack, for debugging my changes. (The dump does not include variable values.) runtime/mercury_trace_internal.c: Add a new undocumented command "D" for dumping the nondet stack (users should not know about this command, since the output is intelligible only to implementors). Add a new command "toggle_echo" that can cause the debugger to echo all commands. When the input to the debugger is redirected, this echo causes the output of the session to be much more readable. runtime/mercury_wrapper.c: Save the address of the artificial bottom nondet stack frame, so that the new function in mercury_stack_trace.c can find out where to stop. runtime/mercury_engine.c: runtime/mercury_wrapper.c: Put MR_STACK_TRACE_THIS_MODULE at the tops of these modules, so that the labels they define (e.g. do_fail and global_success) are registered in the label table when their module initialization functions are called. This is necessary for a meaningful nondet stack dump. runtime/mercury_grade.h: Add a new component to the grade string that specifies whether the code was compiled with the old or the new method of handling the nondet stack. This is important, because modules compiled with different nondet stack handling disciplines are not compatible. This component depends on whether MR_USE_REDOFR is defined or not. runtime/mercury_imp.h: If MR_DISABLE_REDOFR is defined, undefine off MR_USE_REDOFR before including mercury_grade.h. This is to allow people to continue working on un-updated workspaces after this change is installed; they should put "EXTRA_CFLAGS = -DMR_DISABLE_REDOFR" into Mmake.stage.params. (This way their stage1 will use the new method of handling failure, while their stage2 2&3 will use the old one.) This change should be undone once all our workspaces have switched over to the new failure handling method. tests/hard_coded/cut_test.{m,exp}: A new test case to tickle the various ways of handling cuts in the new code generator. tests/hard_coded/Mmakefile: Enable the new test case.	1998-07-20 10:04:02 +00:00
Thomas Conway	a70b59e83c	Add a test to find the number of words needed to represent a ... configure.in: Add a test to find the number of words needed to represent a synchronization term. boehm_gc/gc.h: fix a declaration by replacing the args () with (void). boehm_gc/solaris_pthreads.c: add a missing include check the return values of pthread calls. compiler/*.m: Add handling for the new HLDS goal type par_conj. Add handling for the four new LLDS instructions: init_sync_term fork join_and_terminate join_and_continue compiler/code_info.m: add a new alternative for slot_contents - sync_term. compiler/handle_options.m: add .par as part of the grade compiler/hlds_goal.m: add the new goal type par_conj. compiler/instmap.m: add instmap__unify which takes a list of instmaps and abstractly unifies them. add unify_instmap_delta which tajes two instmap deltas and abstractly unifies them. compiler/llds.m: add the new llds instructions. compiler/mode_info.m: add par_conj as a lock reason. library/Makefile: work around a bug in the solaris version pthread.h library/benchmarking.m: reference the stack zones from the engine structure rather than from global variables. library/{nc,sp}_builtin.nl: add an op declaration for &. library/std_util.m: change references to global variables to references inside the engine structure. runtime/Mmakefile: add mercury_thread.{c,h} add THREADLIBS to the libraries runtime/*.{c,h} Remove some old junk from the previous processes/shrd-mem changes that found their way into the repository. Add MR_ prefixes to lots of names. runtime/mercury_context.c: Add init_thread_stuff for creating and initializing a context structure for the current thread. runtime/mercury_context.h: add a field to the mercury context which stores the thread id of the thread where this context originated. add various macros for implementing the new llds instructions. runtime/mercury_engine.c: initialize the engine structure, rather than a bunch of globals. runtime/mercury_engine.h: declare the mercury_engine structure. runtime/mercury_regorder.h: if MR_THREAD_SAFE, and there is at least one global register then use mr0 as a pointer to the mercury engine structure. scripts/init_grade_options.sh-subr add thread_safe scripts/mgnuc.in add THREAD_OPTS scripts/ml.in: add THREAD_LIBS	1998-06-09 02:16:31 +00:00
Zoltan Somogyi	d10af74168	This change introduces interface tracing, and makes it possible to successfully ... Estimated hours taken: 50 This change introduces interface tracing, and makes it possible to successfully bootstrap the compiler with tracing (either interface or full). compiler/options.m: Change the bool options --generate-trace into a string option --trace with three valid values: minimal, interface and full. The last two mean what they say; the intention is that eventually minimal will mean no tracing in non-tracing grades and interface tracing in tracing grades. compiler/globals.m: Add a new global for the trace level. compiler/handle_options.m: Convert the argument of --trace to a trace level. Use only consistent 4-space indentation in the deeply nested if-then-else. compiler/trace.m: Implement interface tracing. Rename trace__generate_depth_reset_code as trace__prepare_for_call, since it does more than reset the depth if this module is compiled with interface tracing. Do not check whether tracing is enabled before calling MR_trace; let MR_trace make the check. This trades increased non-tracing execution time for a substantial code size reduction (which may in turn benefit execution time). compiler/call_gen.m: Call trace__generate_depth_reset_code by its new name. compiler/code_info.m: Fix a bug in the handling of non/semi commits. When entering a commit, we used to push a clone of whatever the top failure continuation was. However, the resume setup for this continuation could have started with a label that assumed that the resume vars were in their original locations (which are often registers), whereas the method of backtracking to that point only guarantees the survival of stack slots, not registers. (This bug caused two lines of incorrect code to be generated among the approx 30 million lines of code in the stage 2 compiler when compiled with tracing.) Fix another bug (previously untriggered as far as I know) in the handling of multi/det commits. This one was breaking the invariant that the resume vars set of each entry on the failure continuation stack included the resume vars set of every other entry below it, which meant that the values of these resume vars were not guaranteed to be preserved. compiler/stack_layout.m: Make layout structures local to their module. They are not (yet) referred to by name from other modules, and by declaring them to be global we caused their names to be included even in stripped executables, adding several megabytes to the size of the binary. (The names are not stripped because a dynamically linked library may want to refer to them.) Change the mercury_data__stack_layout__ prefix on the names of generated globals vars to just mercury_data__layout__. It is now merely too long instead of far too long. Include the label number in the label layout structure and the number of typeinfo variables in a var_info structure only with native gc. Their only use is in debugging native gc. Fix some documentation rot. compiler/llds.m: Add a new field to the pragma_c instruction that says whether the compiler-generated C code fragments access any stack variables. compiler/frameopt.m: Use the new field in pragma_c's to avoid a bug. Because frameopt was assuming that the pragma_c instruction that filled in the stack slots containing the call sequence number and depth did not access the stack, it moved the pragma_c before the incr_sp that allocates the frame (it was trying to get it out of the loop). compiler/*.m: Minor changes to set or ignore the extra field in pragma_c, to refer to layout structures via the new prefix, or to handle the --trace option. doc/user_guide.texi: Update the documentation for --trace. runtime/mercury_types.h: Add the type Unsigned. runtime/mercury_goto.h: Use the shorter layout prefix. runtime/mercury_stack_layout.h: Use the shorter layout prefix, and include the label number only with native gc. runtime/mercury_trace.[ch]: runtime/mercury_trace_internal.[ch]: runtime/mercury_trace_external.[ch]: runtime/mercury_trace_util.[ch]: Divide the old mercury_trace.[ch] into several components, with one module for the internal debugger, one for the interface to the external debugger, one for utilities needed by both. Mercury_trace.c now has only the top-level stuff that steers between the two debuggers. runtime/mercury_trace.[ch]: Add the new global variable MR_trace_from_full. Before each call, the calling procedure assigns TRUE to this variable if the caller is fully traced, and FALSE otherwise. Interface traced procedures generate trace events only if this variable is TRUE when they are called (fully traced callee procedures ignore the initial value of the variable). Make MR_trace return immediately without doing anything unless tracing is enabled and a new extra argument to MR_trace is TRUE. This extra argument is always TRUE for trace events in fully traced procedures, while for trace events from interface traced procedures, its value is set from the value of MR_trace_from_full at the time that the procedure was called (i.e. the event is ignored unless the interface traced procedure was called from a fully traced procedure). runtime/mercury_trace.[ch]: runtime/mercury_trace_internal.[ch]: For global variables that are stored in stack slots, make their type Word rather than int. Use a new function MR_trace_event_report instead of calling MR_trace_event with a NULL command structure pointer to indicate that the event is to be reported but there is to be no user interaction. Use %ld formats in printfs and casts to long for better portability. runtime/mercury_trace_internal.c: Save trace-related globals across calls to Mercury library code in the debugger, since otherwise any trace events in this code could screw up e.g. the event number or the call number sequence. Create separate functions for printing port names and determinisms. runtime/mercury_wrapper.h: Disable the tracing of the initialization and finalization code written in Mercury. runtime/Mmakefile: Update for the new source and header files. tests/debugger/{debugger_regs,interpreter,queens}_lib.{m,inp,exp}: One new copy of each existing test case. These ones are intended to be used when the stage 2 library is compiled with tracing, which affects the tests by adding events for the library procedures called from the test programs. The .m files are the same as before; one of the .inp files is a bit different; the .exp files reflect the correct output when the library is compiled with full tracing. tests/debugger/Mmakefile: Provide separate targets for the new set of test cases. Use --trace full instead of --generate-trace. tests/debugger/runtests: Try both the new set of test cases if the old set fails, and report failure only if both sets fail. This is simpler than trying to figure out which set should be really tested, and the probability of a false positive is negligible.	1998-05-16 07:31:33 +00:00
Fergus Henderson	11d8161692	Add support for nested modules. ... Estimated hours taken: 50 Add support for nested modules. - module names may themselves be module-qualified - modules may contain `:- include_module' declarations which name sub-modules - a sub-module has access to all the declarations in the parent module (including its implementation section). This support is not yet complete; see the BUGS and LIMITATIONS below. LIMITATIONS - source file names must match module names (just as they did previously) - mmc doesn't allow path names on the command line any more (e.g. `mmc --make-int ../library/foo.m'). - import_module declarations must use the fully-qualified module name - module qualifiers must use the fully-qualified module name - no support for root-qualified module names (e.g. `:parent:child' instead of `parent:child'). - modules may not be physically nested (only logical nesting, via `include_module'). BUGS - doesn't check that the parent module is imported/used before allowing import/use of its sub-modules. - doesn't check that there is an include_module declaration in the parent for each module claiming to be a child of that parent - privacy of private modules is not enforced ------------------- NEWS: Mention that we support nested modules. library/ops.m: library/nc_builtin.nl: library/sp_builtin.nl: compiler/mercury_to_mercury.m: Add `include_module' as a new prefix operator. Change the associativity of `:' from xfy to yfx (since this made parsing module qualifiers slightly easier). compiler/prog_data.m: Add new `include_module' declaration. Change the `module_name' and `module_specifier' types from strings to sym_names, so that module names can themselves be module qualified. compiler/modules.m: Add predicates module_name_to_file_name/2 and file_name_to_module_name/2. Lots of changes to handle parent module dependencies, to create parent interface (`.int0') files, to read them in, to output correct dependencies information for them to the `.d' and `.dep' files, etc. Rewrite a lot of the code to improve the readability (add comments, use subroutines, better variable names). Also fix a couple of bugs: - generate_dependencies was using the transitive implementation dependencies rather than the transitive interface dependencies to compute the `.int3' dependencies when writing `.d' files (this bug was introduced during crs's changes to support `.trans_opt' files) - when creating the `.int' file, it was reading in the interfaces for modules imported in the implementation section, not just those in the interface section. This meant that the compiler missed a lot of errors. library/graph.m: library/lexer.m: library/term.m: library/term_io.m: library/varset.m: compiler/*.m: Add `:- import_module' declarations to the interface needed by declarations in the interface. (The previous version of the compiler did not detect these missing interface imports, due to the above-mentioned bug in modules.m.) compiler/mercury_compile.m: compiler/intermod.m: Change mercury_compile__maybe_grab_optfiles and intermod__grab_optfiles so that they grab the opt files for parent modules as well as the ones for imported modules. compiler/mercury_compile.m: Minor changes to handle parent module dependencies. (Also improve the wording of the warning about trans-opt dependencies.) compiler/make_hlds.m: compiler/module_qual.m: Ignore `:- include_module' declarations. compiler/module_qual.m: A couple of small changes to handle nested module names. compiler/prog_out.m: compiler/prog_util.m: Add new predicates string_to_sym_name/3 (prog_util.m) and sym_name_to_string/{2,3} (prog_out.m). compiler/*.m: Replace many occurrences of `string' with `module_name'. Change code that prints out module names or converts them to strings or filenames to handle the fact that module names are now sym_names intead of strings. Also change a few places (e.g. in intermod.m, hlds_module.m) where the code assumed that any qualified symbol was fully-qualified. compiler/prog_io.m: compiler/prog_io_goal.m: Move sym_name_and_args/3, parse_qualified_term/4 and parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m, since they are very similar to the parse_symbol_name/2 predicate already in prog_io.m. Rewrite these predicates, both to improve maintainability, and to handle the newly allowed syntax (module-qualified module names). Rename parse_qualified_term/5 as `parse_implicit_qualified_term'. compiler/prog_io.m: Rewrite the handling of `:- module' and `:- end_module' declarations, so that it can handle nested modules. Add code to parse `include_module' declarations. compiler/prog_util.m: compiler/*.m: Add new predicates mercury_public_builtin_module/1 and mercury_private_builtin_module/1 in prog_util.m. Change most of the hard-coded occurrences of "mercury_builtin" to call mercury_private_builtin_module/1 or mercury_public_builtin_module/1 or both. compiler/llds_out.m: Add llds_out__sym_name_mangle/2, for mangling module names. compiler/special_pred.m: compiler/mode_util.m: compiler/clause_to_proc.m: compiler/prog_io_goal.m: compiler/lambda.m: compiler/polymorphism.m: Move the predicates in_mode/1, out_mode/1, and uo_mode/1 from special_pred.m to mode_util.m, and change various hard-coded definitions to instead call these predicates. compiler/polymorphism.m: Ensure that the type names `type_info' and `typeclass_info' are module-qualified in the generated code. This avoids a problem where the code generated by polymorphism.m was not considered type-correct, due to the type `type_info' not matching `mercury_builtin:type_info'. compiler/check_typeclass.m: Simplify the code for check_instance_pred and get_matching_instance_pred_ids. compiler/mercury_compile.m: compiler/modules.m: Disallow directory names in command-line arguments. compiler/options.m: compiler/handle_options.m: compiler/mercury_compile.m: compiler/modules.m: Add a `--make-private-interface' option. The private interface file `<module>.int0' contains all the declarations in the module; it is used for compiling sub-modules. scripts/Mmake.rules: scripts/Mmake.vars.in: Add support for creating `.int0' and `.date0' files by invoking mmc with `--make-private-interface'. doc/user_guide.texi: Document `--make-private-interface' and the `.int0' and `.date0' file extensions. doc/reference_manual.texi: Document nested modules. util/mdemangle.c: profiler/demangle.m: Demangle names with multiple module qualifiers. tests/general/Mmakefile: tests/general/string_format_test.m: tests/general/string_format_test.exp: tests/general/string__format_test.m: tests/general/string__format_test.exp: tests/general/.cvsignore: Change the `:- module string__format_test' declaration in `string__format_test.m' to `:- module string_format_test', because with the original declaration the `__' was taken as a module qualifier, which lead to an error message. Hence rename the file accordingly, to avoid the warning about file name not matching module name. tests/invalid/Mmakefile: tests/invalid/missing_interface_import.m: tests/invalid/missing_interface_import.err_exp: Regression test to check that the compiler reports errors for missing `import_module' in the interface section. tests/invalid/*.err_exp: tests/warnings/unused_args_test.exp: tests/warnings/unused_import.exp: Update the expected diagnostics output for the test cases to reflect a few minor changes to the warning messages. tests/hard_coded/Mmakefile: tests/hard_coded/parent.m: tests/hard_coded/parent.child.m: tests/hard_coded/parent.exp: tests/hard_coded/parent2.m: tests/hard_coded/parent2.child.m: tests/hard_coded/parent2.exp: Two simple tests case for the use of nested modules with separate compilation.	1998-03-03 17:48:14 +00:00
Zoltan Somogyi	5013dd9c76	Implement nondet pragma C codes. ... Estimated hours taken: 40 Implement nondet pragma C codes. runtime/mercury_stacks.h: Define a new macro, mkpragmaframe, for use in the implementation of nondet pragma C codes. This new macro includes space for a struct with a given sruct tag in the nondet stack frame being created. compiler/{prog_data.m,hlds_goal.m}: Revise the representation of pragma C codes, both as the item and in the HLDS. compiler/prog_io_pragma.m: Parse nondet pragma C declarations. Fix the indentation in some places. compiler/llds.m: Include an extra argument in mkframe instructions. This extra argument gives the details of the C structure (if any) to be included in the nondet stack frame to be created. Generalize the LLDS representation of pragma C codes. Instead of a fixed sequence of <assign from inputs, user c code, assign to outputs>, let the sequence contain these elements, as well as arbitrary compiler-generated C code, in any order and possibly with repetitions. This flexibility is needed for nondet pragma C codes. Add a field to pragma C codes to say whether they can call Mercury. Some optimizations can do a better job if they know that a pragma C code cannot call Mercury. Add another field to pragma C codes to give the name of the label they refer to (if any). This is needed to prevent labelopt from incorrectly optimizing away the label definition. Add a new alternative to the type pragma_c_decl, to describe the declaration of the local variable that points to the save struct. compiler/llds_out.m: Output mkframe instructions that specify a struct as invoking the new mkpragmaframe macro, and make sure that the struct is declared just before the procedure that uses it. Other minor changes to keep up with the changes to the representation of pragma C code in the LLDS, and to make the output look a bit nicer. compiler/pragma_c_gen.m: Add code to generate code for nondet pragma C codes. Revise the utility predicates and their data structures a bit to make this possible. compiler/code_gen.m: Add code for the necessary special handling of prologs and epilogs of procedures defined by nondet pragma C codes. The prologs need to be modified to include a programmer-defined C structure in the nondet stack frame and to communicate the location of this structure to the pragma C code, whereas the functionality of the epilog is taken care of by the pragma C code itself. compiler/make_hlds.m: When creating a proc_info for a procedure defined by a pragma C code, we used to insert unifications between the headvars and the vars of the pragma C code into the body goal. We now perform substitutions instead. This removes a factor that would complicate the generation of code for nondet pragma C codes. Pass a moduleinfo down the procedures that warn about singletons (and other basic scope errors). When checking whether to warn about an argument of a pragma C code not being mentioned in the C code fragment, we need to know whether the argument is input or output, since input variables should appear in some code fragments in a nondet pragma C code and must not appear in others. The mode_is_{in,out}put checks need the moduleinfo. (We do not need to check for any variables being mentioned where they shouldn't be. The C compiler will fail in the presence of any errors of that type, and since those variables could be referred to via macros whose definitions we do not see, we couldn't implement a reliable test anyway.) compiler/opt_util.m: Recognize that some sorts of pragma_c codes cannot affect the data structures that control backtracking. This allows peepholing to do a better job on code sequences produced for nondet pragma C codes. Recognize that the C code strings inside some pragma_c codes refer to other labels in the procedure. This prevents labelopt from incorrectly optimizing away these labels. compiler/dupelim.m: If a label is referred to from within a C code string, then do not attempt to optimize it away. compiler/det_analysis.m: Remove a now incorrect part of an error message. compiler/*.m: Minor changes to conform to changes to the HLDS and LLDS data structures.	1998-01-13 10:14:23 +00:00
Zoltan Somogyi	bb4442ddc1	Update copyright dates for 1998. ... Estimated hours taken: 0.5 compiler/*.m: Update copyright dates for 1998.	1998-01-13 10:06:08 +00:00
Zoltan Somogyi	42c540ad67	Give duplicate code elimination more teeth in dealing with similar arguments ... Estimated hours taken: 20 Give duplicate code elimination more teeth in dealing with similar arguments of different function symbols. For the source code :- type t1 ---> f(int) ; g(int, int). :- pred p1(t1::in, int::out) is det. p1(f(Y), Y). p1(g(Y, _), Y). we now generate the C code Define_entry(mercury__xdup__p1_2_0); r1 = const_mask_field(r1, (Integer) 0); proceed(); thus avoiding the cost of testing the function symbol. runtime/mercury_tags.h: Add two new macros, mask_field and const_mask_field, that behave just like field and const_field except that instead of stripping off a known tag from the pointer, they strip (mask) off an unknown tag. compiler/llds.m: Change the first argument of the lval field/3 from tag to maybe(tag). Make the comments on some types more readable. compiler/llds_out.m: If the first arg of the lval field/3 is no, emit a (const_)mask_field macro; otherwise, emit a (const_)field macro. compiler/basic_block.m: New module to convert sequences of instructions to sequences of basic blocks and vice versa. Used in the new dupelim.m. compiler/dupelim.m: Complete rewrite to give duplicate code elimination more teeth. Whereas previously we eliminated blocks of code only if they exactly duplicated other blocks of code, we now look for blocks that can be "anti-unified". For example, the blocks r1 = field(mktag(0), r2, 0) goto L1 and r1 = field(mktag(1), r2, 0) <fall through to L1> anti-unify, with the most specific common generalization being r1 = mask_field(r2, 0) goto L1 If several basic blocks antiunify, we replace one copy with the antiunified block and try to eliminate the others. We do not eliminate blocks that can be fallen into, since eliminating them would require introducing a goto, which would slow the code down. compiler/peephole,m: If a conditional branch to a label is followed by that label or by an unconditional branch to that label, eliminate the branch. Dupelim produces this kind of code. compiler/{code_exprn,exprn_aux,lookup_switch,opt_debug,unify_gen}.m: Minor changes required by the change to field/3. compiler/{frameopt,jumpopt,labelopt,mercury_compile,optimize,value_number}.m: s/__main/_main/ in predicate names. compiler/jumpopt.m: Add some documentation. compiler/unify_gen.m: Fix a module qualified predicate name reference that would not work in Prolog. compiler/notes/compiler_design.html: Document the new file basic_block.m.	1997-12-22 06:59:25 +00:00
David Jeffery	7406335105	This change implements typeclasses. Included are the necessary changes to ... Estimated hours taken: 500 or so This change implements typeclasses. Included are the necessary changes to the compiler, runtime and library. compiler/typecheck.m: Typecheck the constraints on a pred by adding constraints for each call to a pred/func with constraints, and eliminating constraints by applying context reduction. While reducing the constraints, keep track of the proofs so that polymorphism can produce the tyepclass_infos for eliminated constraints. compiler/polymorphism.m: Perform the source-to-source transformation which turns code with typeclass constraints into code without constraints, but with extra "typeclass_info", or "dictionary" parameters. Also, rather than always having a type_info directly for each type variable, sometimes the type_info is hidden inside a typeclass_info. compiler/bytecode*.m: Insert some code to abort if bytecode generation is used when typeclasses are used. compiler/call_gen.m: Generate code for a class_method_call, which forms the body of a class method (by selecting the appropriate proc from the typeclass_info). compiler/dead_proc_elim.m: Don't eliminate class methods if they are potentially used outside the module compiler/hlds_data.m: Define data types to store: - the typeclass definitions - the instances of a class - "constraint_proof". ie. the proofs of redundancy of a constraint. This info is used by polymorphism to construct the typeclass_infos for a constraint. - the "base_tyepclass_info_constant", which is analagous the the base_type_info_constant compiler/hlds_data.m: Define the class_method_call goal. This goal is inserted into the body of class method procs, and is responsible for selecting the appropriate part of the typeclass_info to call. compiler/hlds_data.m: Add the class table and instance table to the module_info. compiler/hlds_out.m: Output info about base_typeclass_infos and class_method_calls compiler/hlds_pred.m: Change the representation of the locations of type_infos from "var" to type_info_locn, which is either a var, or part of a typeclass_info, since now the typeclass_infos contain the type_infos for the type that they constrain. Add constraints to the pred_info. Add constraint_proofs to the pred_info (so that typeclass.m can annotate the pred_info with the reasons that constraints were eliminated, so that polymorphism.m can in turn generate the typeclass_infos for the constraints). Add the "class_method" marker. compiler/lambda.m: A feable attempt at adding class ontexts to lambda expressions, untested and almost certainly not working. compiler/llds_out.m: Output the code addresses for do_*det_class_method, and output appropriately mangled symbol names for base_typeclass_infos. compiler/make_hlds.m: Add constraints to the types on pred and func decls, and add class and instance declarations to the class_table and instance_table respectively. compiler/mercury_compile.m: Add the check_typeclass pass. compiler/mercury_to_mercury.m: Output constraints of pred and funcs, and output typeclass and instance declarations. compiler/module_qual.m: Module qualify typeclass names in pred class contexts, and qualify the typeclass and instance decls themselves. compiler/modules.m: Output typeclass declarations in the short interface too. compiler/prog_data.m: Add the "typeclass" and "instance" items. Define the types to store information about the declarations, including class contexts on pred and func decls. compiler/prog_io.m: Parse constraints on pred and func declarations. compiler/prod_out.m: Output class contexts on pred and func decls. compiler/type_util.m: Add preds to apply a substitution to a class_constraint, and to a list of class constraints. Add type_list_matches_exactly/2. Also add typeclass_info and base_typeclass_info as types which should not be optimised as no_tag types (seeing that we cheat a bit about their representation). compiler/notes/compiler_design.html: Add notes on module qualification of class contexts. Needs expansion to include more stuff on typeclasses. compiler/*.m: Various minor changes. New Files: compiler/base_typeclass_info.m: Produce one base_typeclass_info for each instance declaration. compiler/prog_io_typeclass.m: Parse typeclass and instance declarations. compiler/check_typeclass.m: Check the conformance of an instance declaration to the typeclass declaration, including building up a proof of how superclass constraints are satisfied so that polymorphism.m is able to construct the typeclass_info, including the superclass typeclass_infos. library/mercury_builtin.m: Implement that base_typeclass_info and typeclass_info types, as well as the predicates type_info_from_typeclass_info/3 to extract a type_info from a typeclass_info, and superclass_from_typeclass_info/3 for extracting superclasses. library/ops.m: Add "typeclass" and "instance" as operators. library/string.m: Add a (in, uo) mode for string__length/3. runtime/mercury_ho_call.c: Implement do_call_*det_class_method, which are the pieces of code responsible for extracting the correct code address from the typeclass_info, setting up the arguments correctly, then executing the code. runtime/mercury_type_info.h: Macros for accessing the typeclass_info structure.	1997-12-19 03:10:47 +00:00
Fergus Henderson	05267d2834	Add support for memory profiling. ... Estimated hours taken: 40 (+ unknown time by Zoltan) Add support for memory profiling. (A significant part of this change is actuallly Zoltan's work. Zoltan did the changes to the compiler and a first go at the changes to the runtime and library. I rewrote much of Zoltan's changes to the runtime and library, added support for the new options/grades, added code to interface with mprof, did the changes to the profiler, and wrote the documentation.) [TODO: add test cases.] NEWS: Mention support for memory profiling. runtime/mercury_heap_profile.h: runtime/mercury_heap_profile.c: New files. These contain code to record heap profiling information. runtime/mercury_heap.h: Add new macros incr_hp_msg(), tag_incr_hp_msg(), incr_hp_atomic_msg(), and tag_incr_hp_atomic_msg(). These are like the non-`msg' versions, except that if PROFILE_MEMORY is defined, they also call MR_record_allocation() from mercury_heap_profile.h to record heap profiling information. Also, fix up the indentation in lots of places. runtime/mercury_prof.h: runtime/mercury_prof.c: Added code to dump out memory profiling information to files `Prof.MemoryWords' and `Prof.MemoryCells' (for use by mprof). Change the format of the `Prof.Counts' file so that the first line says what it is counting, the units, and a scale factor. Prof.MemoryWords and Prof.MemoryCells can thus have exactly the same format as Prof.Counts. Also cleaned up the interface to mercury_prof.c a bit, and did various other minor cleanups -- indentation changes, changes to use MR_ prefixes, additional comments, etc. runtime/mercury_prof_mem.h: runtime/mercury_prof_mem.c: Rename prof_malloc() as MR_prof_malloc(). Rename prof_make() as MR_PROF_NEW() and add MR_PROF_NEW_ARRAY(). runtime/mercury_wrapper.h: Minor modifications to reflect the new interface to mercury_prof.c. runtime/mercury_wrapper.c: runtime/mercury_label.c: Rename the old `-p' (primary cache size) option as `-C'. Add a new `-p' option to disable profiling. runtime/Mmakefile: Add mercury_heap_profile.[ch]. Put the list of files in alphabetical order. Delete some obsolete stuff for supporting `.mod' files. Mention that libmer_dll.h and libmer_globals.h are produced by Makefile.DLLs. runtime/mercury_imp.h: Mention that libmer_dll.h is produced by Makefile.DLLs. runtime/mercury_dummy.c: Change a comment to refer to libmer_dll.h rather than libmer_globals.h. compiler/llds.m: Add a new field to `create' and `incr_hp' instructions holding the name of the type, for heap profiling. compiler/unify_gen.m: Initialize the new field of `create' instructions with the appropriate type name. compiler/llds_out.m: Output incr_hp_msg() / tag_incr_hp_msg() instead of incr_hp() / tag_incr_hp(). compiler/*.m: Minor changes to most files in the compiler back-end to accomodate the new field in `incr_hp' and `create' instructions. library/io.m: Add `io__report_full_memory_stats'. library/benchmarking.m: Add `report_full_memory_stats'. This uses the information saved by runtime/mercury_heap_profile.{c,h} to print out a report of memory usage by procedures and by types. Also modify `report_stats' to print out some of that information. compiler/mercury_compile.m: If `--statistics' is enabled, call io__report_full_memory_stats at the end of main/2. This will print out full memory statistics, if the compiler was compiled with memory profiling enabled. compiler/options.m: compiler/handle_options.m: runtime/mercury_grade.h: scripts/ml.in: scripts/mgnuc.in: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Add new option `--memory-profiling' and new grade `.memprof'. Add `--time-profiling' as a new synonym for `--profiling'. Also add `--profile-memory' for more fine-grained control: `--memory-profiling' implies both `--profile-memory' and `--profile-calls'. scripts/mprof_merge_runs: Update to handle the new format of Prof.Counts and to also merge Prof.MemoryWords and Prof.MemoryCells. profiler/options.m: profiler/mercury_profile.m: Add new options `--profile memory-words' (`-m'), `--profile memory-cells' (`-M') and `--profile time' (`-t'). Thes options make the profiler select a different count file, Prof.MemoryWords or Prof.MemoryCells instead of Prof.Counts. specific to time profiling. profiler/read.m: profiler/process_file.m: profiler/prof_info.m: profiler/generate_output.m: Update to handle the new format of the counts file. When reading the counts file, look at the first line of the file to determine what is being profiled. profiler/globals.m: Add a new global variable `what_to_profile' that records what is being profiled. profiler/output.m: Change the headings to reflect what is being profiled. doc/user_guide.texi: Document memory profiling. Document new options. doc/user_guide.texi: compiler/options.m: Comment out the documentation for `.proftime'/`--profile-time', since doing time and call profiling seperately doesn't work, because the code addresses change when you recompile with a different grade. Ditto for `.profmem'/`--profile-memory'. Also comment out the documentation for `.profcalls'/`--profile-calls', since it is redundant -- `.memprof' produces the same information and more. configure.in: Build a `.memprof' grade. (Hmm, should we do this only if `--enable-all-grades' is specified?) Don't ever build a `.profcalls' grade.	1997-12-05 15:49:06 +00:00
Tyson Dowd	2a97f96d1a	Generate stack layouts for accurate garbage collection. ... Estimated hours taken: 50 Generate stack layouts for accurate garbage collection. compiler/base_type_layout.m: Change the order of some arguments so that threaded data structures are more often in the final two arguments (allows easy use of higher order predicates). Simplify some code using higher order preds. Export base_type_layout__construct_pseudo_type_info, as stack_layout.m needs to be able to generate pseudo_type_infos too. Fix problems with cell numbers being re-used -- get the next cell number from module_info, and update module_info after processing base_type_layouts. compiler/code_gen.m: Add information about each procedure to the continuation info. Handle new field in c_procedure. compiler/continuation_info.m: Redesign most of this module to deal with labels that are continuation points for multiple calls. Change the order of some arguments so that threaded data structures are in the final two arguments. Cleaned up and documented code. compiler/dupelim.m: compiler/exprn_aux.m: Handle new label_entry data type. compiler/export.m: compiler/opt_debug.m: Handle new label_entry and general data types. compiler/llds_out.m: Add an argument to get_proc_label to control whether a "mercury_" prefix is wanted. Handle new label_entry and general data types. compiler/llds.m: Add a new alternative for data_const - a label_entry. Add a new alternative for data_name - general, which allows any sort of data, with names generated elsewhere. Add the pred_proc_id as a field of c_procedure. compiler/optimize.m: compiler/llds_common.m: compiler/optimize.m: Handle new field in c_procedure. compiler/mercury_compile.m: Generate layout information after code has been generated, and output stack layouts. compiler/notes/compiler_design.html: Document new stack_layout module. compiler/stack_layout.m: New file - generates the LLDS code that defines global constants to hold the stack_layout structures. compiler/options.m: compiler/handle_options.m: Add --stack-layout option which outputs stack layouts. Make accurate gc imply stack_layout.	1997-11-08 13:12:08 +00:00
Zoltan Somogyi	27f8c809ed	Preserve the comments attached to labels, for debugging purposes. ... Estimated hours taken: 1 dupelim: Preserve the comments attached to labels, for debugging purposes. llds_out: Add a predicate that displays an instruction and its comment for debugging. (Previously, you could only print the instruction for debugging.) opt_debug: Print comments on instructions if --auto-comments is given.	1997-10-31 00:41:29 +00:00
Fergus Henderson	c8642b9dd1	Fix code generation for commits and nondet if-then-elses so that ... Estimated hours taken: 9 Fix code generation for commits and nondet if-then-elses so that it computes MR_ticket_counter correctly. compiler/ite_gen.m: compiler/code_info.m: Change the way we do a soft cut when generating code for nondet if-then-elses with nondet conditions so that the ticket counter is restored correctly on backtracking. compiler/llds.m: Add new instructions `mark_trail_stack(lval)' and `discard_tickets_to(rval)' to save/restore the ticket counter. compiler/code_info.m: Save the ticket counter before doing a commit and restore it afterwards. compiler/*.m: Various minor changes to handle the new LLDS instructions. runtime/mercury_trail.h: Add new macros to implement the new LLDS instructions. compiler/livemap.m: Change the code in build_livemap_instr for mark_hp and store_ticket so that it deletes the target lval from the set of live variables, and simplify the code there for reset_ticket.	1997-08-25 17:48:57 +00:00
Fergus Henderson	02f3e99e41	Change the generated code for trailing to match the new trailing interface. ... Estimated hours taken: 3 Change the generated code for trailing to match the new trailing interface. compiler/code_gen.m: When generating code for negations, ensure that we generate a discard_ticket instruction to discard the current ticket before failing. compiler/llds.m: compiler/llds_out.m: compiler/code_info.m: Change the `restore_ticket(Rval)' instruction to `reset_ticket(Rval, Reason)', where Reason is one of undo, commit, exception, or gc, as per runtime/mercury_trail.h. A reset with Reason = undo gives the old "restore" behaviour. compiler/frameopt.m: compiler/livemap.m: compiler/llds_common.m: compiler/middle_rec.m: compiler/opt_*.m: compiler/peephole.m: compiler/value_number.m: compiler/vn_*.m: Trivial changes to handle reset_ticket/2 instead of restore_ticket/1. compiler/code_gen.m: compiler/ite_gen.m: compiler/disj_gen.m: Change the places that called code_gen__maybe_discard_ticket to instead call code_gen__maybe_reset_and_discard_ticket(...commit...).	1997-08-24 01:30:09 +00:00
Fergus Henderson	04b720630b	Update the copyright messages so that (a) they contain the correct years ... and (b) they say "Copyright (C) ... _The_ University of Melbourne".	1997-07-27 15:09:59 +00:00
Simon Taylor	312a753149	llds_out__maybe_qualify_label didn't qualify the name if it was of ... Estimated hours taken: 0.25 compiler/llds_out.m compiler/fact_table.m compiler/opt_debug.m llds_out__maybe_qualify_label didn't qualify the name if it was of the form Module__Name. Now that we parse '__' as a module qualifier, it should always qualify the label. Added llds_out__qualify_label to do this.	1997-07-17 04:29:12 +00:00
Fergus Henderson	8c60f93849	Fix a bug where tag_switch.m was generating references to non-existent ... Estimated hours taken: 4 Fix a bug where tag_switch.m was generating references to non-existent labels for det switches that don't cover the full range of the type. llds.m: Add new alternative `do_not_reached' to the code_addr type. exprn_aux.m: dupelim.m: livemap.m: llds_out.m: opt_util.m: opt_debug.m: Add new code to handle `do_not_reached'. tag_switch.m: When generating tag switch jump tables for det switches that do not cover the whole type, which can happen if the initial inst of the switch variable is a bound(...) inst that represents a subtype, make sure that we don't generate references to undefined labels for cases that occur in the switch var's type but not in the switch var's initial inst. Instead, make such references refer to a label that jumps to `do_not_reached'.	1997-04-17 07:49:11 +00:00
Andrew Bromage	d7319104f9	Making the types pred_id and proc_id (almost) abstract. ... Estimated hours taken: 7 Making the types pred_id and proc_id (almost) abstract. compiler/code_util.m: Changed the type of several predicates: code_util__make_uni_label/4 (arg 3 was int, now proc_id) code_util__inline_builtin/4 (arg 3 was proc_id, now int) Added predicate code_util__translate_builtin_2/6. compiler/hlds_module.m: Moved invalid_pred_id/1 to hlds_pred.m compiler/hlds_pred.m: Types pred_id/0 and proc_id are now abstract. Added predicates: hlds_pred__initial_pred_id/1, hlds_pred__initial_proc_id/1, hlds_pred__next_pred_id/2, hlds_pred__next_proc_id/2, pred_id_to_int/2, proc_id_to_int/2, hlds_pred__in_in_unification_proc_id/1 Moved predicate invalid_pred_id/1 (from hlds_module.m). compiler/*.m: Miscellaneous minor changes to cast pred/proc_ids to ints where appropriate.	1997-03-06 05:09:54 +00:00
Tyson Dowd	9bc2c0f235	Create new `base_type_functors' data structures, that describe the ... Estimated hours taken: 16 Create new `base_type_functors' data structures, that describe the functors of discriminated union types. This is stage 1 of changes designed to allow io__read/3 to be implemented. It will also allow the other code dealing with runtime type information to be significantly simplified. (Stage 2 will be to implement predicates to find information about the functors of discriminated union types, and construct such types, then stage 3 will be to implement io__read/3 using these predicates). compiler/base_type_info.m: - Make the base_type_info reference the base_type_functors. compiler/base_type_layout.m: - Clean up header documentation, fix inaccuracies. - Add support for creation of base_type_functors tables, document the tables created. - Add a representation of the primary and secondary tag to the descriptions created for functors. - Rename predicates since this module now creates two tables. - Split some predicates so that code can be re-used. compiler/llds.m: - Instead of base_type_info(string, arity), base_type_layout(string, arity) and the new base_type_functors(string, arity), use base_type(base_data, string, arity) where base_data is one of info, layout or functors compiler/llds_out.m: - Add llds_out__make_base_type_name, which generates identifier names for base_data data items. compiler/opt_debug.m: compiler/unify_gen.m: - Use new base_data type. library/io.m: - Define io__stream as a c_pointer, so it has base_type_layout and base_type_functors generated for it. library/mercury_builtin.m: library/std_util.m: library/uniq_arry.m: - Add definitions for base_type_functors for builtin types, and types defined in C. runtime/type_info.h: - Add definitions for base_type_functors. - Modify existing #defines (in particular, offset for type name).	1997-02-23 01:14:20 +00:00
Simon Taylor	857ce0c472	Cleaned up the handling of labels for specialized versions of predicates ... Estimated hours taken: 3 Cleaned up the handling of labels for specialized versions of predicates from other modules. compiler/llds.m: Changed the representation of proc_label slightly. Each proc_label now contains the name of the module producing the code for a predicate as well as the module containing the declaration for the predicate. compiler/code_util.m: compiler/llds_out.m: Fixed a bug in my last change that resulted in duplicate label names for specialized versions of predicates. The name of the module producing the code for the predicate is added as an extra qualifier in the label for specialised versions of predicates from other modules. compiler/base_type_info.m: compiler/opt_util.m: compiler/opt_debug.m: compiler/shapes.m: Fixed uses of proc_label.	1997-01-29 00:48:13 +00:00
Zoltan Somogyi	a4a1a7788c	Add support for taking the addresses of words on the heap as well as on ... Estimated hours taken: 7 Add support for taking the addresses of words on the heap as well as on on either stack. This will be used later to support tail recursion modulo constructor application as well as parallelism. The support provided is a first draft. Since nothing in the compiler currently generates code that uses the new facilities, they have not been tested yet beyond ensuring that they don't interfere with the old functionality of the compiler. llds: Add a new type, mem_ref, that denotes a reference to a stackvar, a framevar, or to a field of a cell on the heap. Add a new function symbol to the type rval: mem_addr(mem_ref), which represents the address of the word denoted by the mem_ref. Add a new function symbol to the type lval: mem_ref(rval). Given that Rval is an address, mem_ref(Rval) denotes the word at that address. The value of Rval should have originally come from a mem_addr(_) type rval, but that value could have been store in registers, stack slots etc since then. code_exprn, code_info, dupelim, exprn_aux, garbage_out, livemap, llds_common, llds_out, middle_rec, opt_debug, opt_util, vn_cost, vn_filter: Added code to handle the new mem_ref type and the new alternatives in lval and rval. exprn_aux: Make exprn_aux__substitute_lval_in_lval more thorough. vn_type: Add vn shadows of the new things in llds. vn_flush, vn_order, vn_util: Handle the new things in llds and/or their vn shadows.	1997-01-21 05:05:31 +00:00
Zoltan Somogyi	19504f598f	Add an extra argument to pragma_c to hold the context of the pragma ... Estimated hours taken: 1.5 llds: Add an extra argument to pragma_c to hold the context of the pragma definition. llds_out: Add code to print the context as a #line directive. This code is commented out, since it leads to mysterious crashes on some tests. pragma_c_gen: Fill in the context field in pragma_cs. dupelim, frameopt, livemap, llds_common, middle_rec, opt_debug, opt_util, value_number, vn_block, vn_filter, vn_verify: Trivial changes to handle the extra argument in pragma_cs.	1997-01-15 01:10:54 +00:00
Zoltan Somogyi	54bb1c4a67	Move the code that generates code for pragma_c_codes to a new module. ... Estimated hours taken: 3 code_gen, pragma_c_code: Move the code that generates code for pragma_c_codes to a new module. llds: Change the representation of reg and temp lvals, in order to create the concept of a "register type" and to reduce memory requirements. Also add a comment indicating a possible future extension dealing with model_non pragma_c_codes. code_exprn, code_info: Add the ability to request registers of a given type, or a specific register, when acquiring registers. bytecode, bytecode_gen, call_gen, dupelim, exprn_aux, follow_vars, frameopt, garbage_out, jumpopt, llds_out, middle_rec, opt_debug, opt_util, store_alloc, string_switch, tag_switch, unify_gen, vn_block, vn_cost, vn_filter, vn_flush, vn_order, vn_temploc, vn_type, vn_util, vn_verify: Small changes to accommodate the new register representation. hlds_goal: Add a comment indicating a possible future extension dealing with model_non pragma_c_codes. inlining: Add a comment indicating a how to deal with a possible future extension dealing with model_non pragma_c_codes.	1996-12-31 09:58:59 +00:00
Fergus Henderson	07635fbf96	Fix things so that we can now generate unboxed floats as ... Estimated hours taken: 24 Fix things so that we can now generate unboxed floats as static constants. We do this by generating static constants as structs rather than as arrays. Reorganize the way llds_out.m handles types to simplify the code and eliminate unnecessary casts in the generated C code. llds.m, vn_type.m: Change `llds_type' to be more precise, by adding two new alternatives (data_ptr and code_ptr) to the categories, and modifying the various type predicates accordingly. llds.m, base_type_info.m, base_type_layout.m, garbage_out.m, llds_common.m, opt_debug.m, unify_gen.m. Remove the "has pointers?" field from the `c_data' and `data_addr' types in llds.m and from the `cell_info' type in llds_common.m, since they're not needed anymore. (Instead llds_out.m uses `llds__rval_type' etc. to figure out whether something has pointers.) base_type_info.m, base_type_layout.m: Fix a bug: the `exported' field in the `c_data' type needs to be set to yes for `Status = abstract_exported' types as well as for `Status = exported' types. exprn_aux.m: If unboxed_float is yes, then floats are now considered constants. llds_out.m: Change `output_rval' and `output_lval' so that they output a value as its natural type, rather than cast to Integer or Word. Add a new predicate `output_rval_as_type(Rval, Type)', and change most of the calls to `output_rval' to instead call `output_rval_as_type' specifying the appropriate type. Similarly add `output_lval_as_word' and change some of the calls to `output_lval' to call `output_lval_as_word' instead. Eliminate `output_rval_as_float', since its functionality has been folded into `output_rval' and `output_rval_as_type'. Delete `output_rval_lval', since it's not needed anymore. Neither is the `args_have_pointers' predicate. Merge the shared code in for handling `c_data' modules and `create' rvals into a new predicate output_const_term_decl; this predicate outputs struct declarations for the generated terms, so we can now output floats in such terms without needing to do type punning in static constants. options.m: `--single-prec-float' is no longer an alias for `--unboxed-float'. Also fix a couple of other parts of the help message.	1996-12-19 08:15:04 +00:00
Tyson Dowd	1b37ada23c	Create base_type_layout structures, which store information about how ... Estimated hours taken: 50 Create base_type_layout structures, which store information about how Mercury data is represented in memory. compiler/base_type_layout.m: Generate base_gen_layouts from HLDS. Pass over base_gen_layouts after code generation, create layout tables, and pseudo-typeinfos as needed. compiler/base_type_info.m, compiler/dead_proc_elim.m: Allow base_type_infos to be `neutered' rather than eliminated by dead_proc_elim. This just removes references to compiler generated preds, and replaces them with references to an 'unused' pred in mercury_builtin, which prints an error message if ever used. (The base_type_infos are always needed, even if the generated preds aren't, because the layout tables refer to them). compiler/hlds_module.m: Add marker for procs eliminated in base_type_infos. Add base_gen_layout structure, and access predicates to HLDS. compiler/llds.m, compiler/llds_out.m, compiler/opt_debug.m: Add a base_type_layout data_name, for storing references to base_type_layouts. Add output code. compiler/llds_common.m: Get llds_common to process c_data structures given to it. (We'll give it the base_type_layouts). compiler/mercury_compile.m: Add a pass to generate and process the base_type_gens. Fix a newline in a ... done message. Let llds_common work on the base_type_layouts. compiler/type_util.m: Add type_util__var, which returns the type variable of a type (if it is a variable at the top level).	1996-12-09 13:50:10 +00:00
Zoltan Somogyi	3aff9711dd	Fix a bug triggered the conjunction of (1) value numbering being ... Estimated hours taken: 12 value_number, opt_util: Fix a bug triggered the conjunction of (1) value numbering being repeated in -O5 (2) middle recursion optimization and (3) the current code of modules.m. The problem was that although value numbering was producing correct code, the livevals annotations in the generated code were left unchange although they were no longer correct. The fix is a new predicate in opt_util to update the annotations and to call it in value numbering. vn_util: Fix the bug reported by Tom in compiling scene.m: simplify several kinds of patterns involving floats. These assume that floats obey the laws of reals. Later we will have to add a mechanism to prevent such simplication and reordering. (We already assume that integers obey the laws of whole numbers.) opt_debug, vn_debug: Make the format of debugging output more suitable.	1996-11-06 13:01:13 +00:00
Fergus Henderson	c9887d16ea	Mangle function names differently, so that we don't get ... Estimated hours taken: 2.5 Mangle function names differently, so that we don't get symbol name clashes between a function of arity N and a predicate of arity N+1. (This fixes a bug which resulted in error messages from the assembler.) compiler/llds.m: Add a new pred_or_func field to the proc/4 functor in the proc_label type. compiler/code_util.m: Initialize this new field. compiler/llds.m: Use this new field when printing out labels. compiler/{opt_debug.m,opt_util.m}: Ignore this new field.	1996-10-24 06:07:23 +00:00
Zoltan Somogyi	8bd1aaa9de	Rename address_const to code_addr_const, and add base_type_info_const ... Estimated hours taken: 15 hlds_data: Rename address_const to code_addr_const, and add base_type_info_const as a new alternative in cons_id, and make corresponding changes to cons_tag. Make hlds_type__defn an abstract type. llds: Rename address_const to code_addr_const, and add data_addr_const as a new alternative in rval_const. Change type "label" to have four alternatives, not three: local/2 (for internal labels), c_local (local to a C module), local/1 (local a Mercury module but not necessarily to a C module, and exported. llds_out: Keep track of the things declared previously, and don't declare them again unnecessarily. Associate indentation with the following item rather than the previous item (the influence of 244); this results in braces being put in different places than previously, but should be easier to maintain. Handle the new forms of addresses and labels. Refer to c_local labels as STATIC when not using --split-c-files. code_info: Use a presently junk field to store a cell counter, which is used to allocate distinguishing numbers to create'd cells. Previously we used the label counter, which meant that label numbers changed when we optimized away some creates. Handle the new forms of addresses and labels. exprn_aux: Handle the new forms of addresses and labels. We are now more precise in figuring out what label address forms will be considered constants by the C compilers. others: Changes to handle the new forms of addresses and labels, and/or to access hlds_type__defn as an abstract type.	1996-08-05 12:05:14 +00:00
Zoltan Somogyi	40e727614d	Add a boolean argument to the create rval, which should be set to true ... Estimated hours taken: 2 llds.m: Add a boolean argument to the create rval, which should be set to true if the cell created must have a unique reference. vn_type.m: Add a corresponding argument to vn_create. others: Fix references to creates and vn_creates.	1996-08-04 23:18:56 +00:00
Zoltan Somogyi	a15c032df7	Flesh out the code already here for traversing module_infos, ... Estimated hours taken: 4 passes_aux: Flesh out the code already here for traversing module_infos, making it suitable to handle all the passes of the back end. mercury_compile: Use the traversal code in passes_aux to invoke the back end passes over each procvedure in turn. Print a one-line message for each predicate if -v is given (this fixes a long-standing bug). excess.m, follow_code.m, follow_vars.m, live_vars.m, lveness.m, store_alloc.m: Remove the code to traverse module_infos, since it is now unnecessary. export.m: Remove an unused argument from export__produce_header_file_2. others: Move imports from interfaces to implementations, or in some cases remove them altogether.	1996-08-03 12:06:26 +00:00
Zoltan Somogyi	5f37b61f79	Add support for det stack trace dumps in debugging grades, so programmers ... Estimated hours taken: 2 Add support for det stack trace dumps in debugging grades, so programmers can find out which predicates are causing det stack overflows. llds.m: Add an extra argument to the llds instruction incr_sp. This argument says what predicate the stack frame belongs to. vn_type.m: Add a corresponding argument to the control node vn_incr_sp. the other files: Handle the extra argument of incr_sp or vn_incr_sp.	1996-08-03 09:31:35 +00:00
Simon Taylor	5d9e4158f7	Module qualification of types, insts and modes. ... Estimated hours taken: 45 Module qualification of types, insts and modes. Added a new interface file - <module>.int3. This contains the short interface qualified as much as possible given the information in the current module. When producing the .int and .int2 files for a module, the compiler uses the information in the .int3 files of modules imported in the interface to fully module qualify all items. The .int2 file is just a fully qualified version of the .int3 file. The .int3 file cannot be overwritten by the fully qualified version in the .int2 file because then mmake would not be able to tell when the interface files that depend on that .int3 file really need updating. The --warn-interface-imports option can be used to check whether a module imported in the interface really needs to be imported in the interface. compiler/module_qual.m Module qualify all types, insts and modes. Also checks for modules imported in the interface of a module that do not need to be. compiler/modules.m The .int file for a module now depends on the .int3 files of imported modules. Added code to generate the make rule for the .int file in the .d file. There is now a file .date2 which records the last time the .int2 file was updated. The .int3 files are made using the --make-short-interface option introduced a few weeks ago. compiler/options.m Added option --warn-interface-imports to enable warning about interface imports which need not be in the interface. This is off by default because a lot of modules in the library import list.m when they only need the type list, which is defined in mercury_builtin.m. Removed option --builtin-module, since the mercury_builtin name is wired into the compiler in a large number of places. compiler/prog_util.m Added a predicates construct_qualified_term/3 and construct_qualfied_term/4 which take a sym_name, a list of argument term and a context for the /4 version and give a :/2 term. compiler/type_util.m Modified type_to_type_id to handle qualified types. Also added predicates construct_type/3 and construct_type/4 which take a sym_name and a list of types and return a type by calling prog_util:construct_qualified_term. compiler/modes.m On the first iteration of mode analysis, module qualify the modes of lambda expressions. compiler/mode_info.m Added field to mode_info used to decide whether or not to module qualify lambda expressions. compiler/mode_errors.m Added dummy mode error for when module qualification fails so that mode analysis will stop. Added code to strip mercury_builtin qualifiers from error messages to improve readability. compiler/typecheck.m Strip builtin qualifiers from error messages. compiler/llds.m compiler/llds_out.m compiler/opt_util.m compiler/opt_debug.m Change the format of labels produced for the predicates to use the qualified version of the type name. compiler/mercury_compile.pp Call module_qual__module_qualify_items and make_short_interface. Remove references to undef_modes.m and undef_types.m compiler/undef_modes.m compiler/undef_types.m Removed, since their functionality is now in module_qual.m. compiler/prog_io.m Changed to qualify the subjects of type, mode and inst declarations. compiler/*.m Changes to stop various parts of the compiler from throwing away module qualifiers. Qualified various mercury_builtin builtins, e.g. in, out, term etc. where they are wired in to the compiler. compiler/hlds_data.m The mode_table and user_inst_table are now abstract types each storing the {mode | inst}_id to hlds__{mode | inst}_defn maps and a list of mode_ids or inst_ids. This was done to improve the efficiency of module qualifying the modes of lambda expressions during mode analysis. module_info_optimize/2 now sorts the lists of ids. The hlds_module interface to the mode and inst tables has not changed. compiler/hlds_module.m Added yet another predicate to search the predicate table. predicate_table_search_pf_sym_arity searches for predicates or functions matching the given sym_name, arity and pred_or_func. compiler/higher_order.m Changed calls to solutions/2 to list__filter/3. Eliminated unnecessary requantification of goals. compiler/unused_args.m Improved abstraction slightly.	1996-06-11 06:30:10 +00:00
Zoltan Somogyi	7956003f22	Remove the now unnecessary special handling of assignments to curfr. ... Estimated hours taken: 0.2 vn*, opt_debug: Remove the now unnecessary special handling of assignments to curfr.	1996-05-31 02:11:17 +00:00
Zoltan Somogyi	cac7d6a246	Fix allocation to work properly for --args compact. ... Estimated hours taken: 30+ arg_info: Fix allocation to work properly for --args compact. bytecode*: Handle complex deconstruction unifications. Not really tested because I can't find a test case. bytecode_gen, call_gen, code_util: Use the new method to handle builtin predicates/functions. We now handle reverse mode arithmetic and unary plus/minus as builtins. code_gen, code_init, follow_vars, hlds_pred: Put back the initial follow_vars field of the proc_info, since this may allow the code generator to emit better code at the starts of of predicates. inlining: Don't inline recursive predicates. goals_util: Add a predicate to find out if a goal calls a particular predicate. Used in inlining to find out if a predicate is recursive. unused_args: Remove code that used to set the mode of unused args to free->free. Since this changes the arg from top_in to top_unused *without* code in other modules being aware of the change, this screws up --args compact. llds, llds_out, garbage_out: Prepare for the move to the new type_info structure by adding a new "module" type for defining structures holding type_infos. Not currently generated or output. llds, opt_debug, opt_util, vn_type, vn_cost, vn_temploc: Change the argument of temp to be a reg, not an int, allowing floating point temporaries. vn_type: Add information about the number of floating point registers and temporaries to the parameter structure (these are currently unused). llds, dupelim, frameopt, livemap, middle_rec, value_number, vn_filter, vn_verify: Add an extra field to blocks giving the number of float temporaries. options: Add parameters to configure the number of floating point registers and temporaries. mercury_compile: Add an extra excess assign phase at the start of the middle pass. This should reduce the size of the code manipulated by the other phases, and gives more accurate size information to inlining. (The excess assign phase before code generation is I think still needed since optimizations can introduce such assignments.) value_number: Optimize code sequences before and after assignments to curfr separately, since such assignments change the meaning of framevars. This fixes the bug that caused singleton variable warnings to contain garbage. vn_block, vn_flush, vn_order, vn_util: Add special handling of assignments to curfr. This is probably unnecessary after my change to value_number, and will be removed again shortly :-( vn_flush: Improve the code generated by value numbering (1) by computing values into the place that needs them in some special circumstances, and (2) by fixing a bug that did not consider special registers to be as fast as r1 etc. vn_util: Improve the code generated by value numbering by removing duplicates from the list of uses of a value before trying to find out if there is more than one use. simplify: Avoid overzealous optimization of main --> { ..., error(...) }. handle_options: Fix an error message. code_aux: Break an excessive long line.	1996-05-29 10:56:45 +00:00
Zoltan Somogyi	89644bebb2	Fixed a bug that caused restores of succip to be put in the wrong ... Estimated hours taken: 5 peephole: Fixed a bug that caused restores of succip to be put in the wrong place, but only after predicate-wide value numbering. opt_debug: Added a couple of debugging predicates used in tracking down this bug. value_number: Fix a bug that left a livevals pseudo-op in the wrong place if a single instruction sequence contained more than one such pseudo-op. options: Add --debug-opt. Rename --vndebug to --debug-vn. Add --generate-bytecode. optimize, vn_debug: Use the new routines in opt_debug, and use the new/renamed options. store_alloc: Don't thread follow_vars through the module, since the follow_vars information is not attached directly to branched structures. We now also use the same slot to hold the store map computed by this pass; this should allow the later deletion of the store map slot from goal_infos. follow_code: Removed dead predicate. livemap: Added a comment.	1996-05-12 04:51:14 +00:00
Zoltan Somogyi	9e31ef9baa	Split llds into two parts. llds.m defines the data types, while llds_out.m ... Estimated hours taken: 1.5 Split llds into two parts. llds.m defines the data types, while llds_out.m has the predicates for printing the code. Removed the call_closure instruction. Instead, we use calls to the system-defined addresses do_call_{det,semidet,nondet}_closure. This is how call_closure was implemented already. The advantage of the new implementation is that it allows jump optimization of what used to be call_closures, without new code in jumpopt.	1996-04-24 08:59:06 +00:00
Zoltan Somogyi	1c90f19e02	Fix a typo which reflected a fundamental design error. ... Estimated hours taken: 20 vn_block: Fix a typo which reflected a fundamental design error. When finding cheaper copies of live lvals, for use in creating specialized copies (parallels) of blocks jumped to from the current location, we used to use the map reflecting the contents of lvals at the start of the block, not at the point of the jump. --pred-value-number, which uses the information computed by the buggy predicate, actually bootstrapped some time ago despite this fundamental bug! value_number: Fix a bug in the creation of parallel code sequences for computed gotos. Add some more opprtunities for printing diagnostics. Move code concerning final verification to vn_verify. vn_verify: Move the remaining code concerned with final verification from value_number to vn_verify. peephole: Add a new pattern, which transforms the sequence incr_sp N; goto L2; L1; incr_sp N; L2 into just L1; incr_sp N; L2 The pattern is of course more broadly applicable, but I have seen it only when it involves a single incr_sp between the two labels. (The longer pattern can be introduced by frameopt.) opt_util: Look inside blocks when checking whether an instruction can fall through. This improves the performance of labelopt. vn_table: Make the type vn_table abstract; add, export and use access functions. vn_util: Remove a noop predicate, since now it won't ever be made to do anything. vn_cost: Refine debugging output. vn_debug: Add some more debugging routines. opt_debug: Add some more debugging routines. det_analysis: Remove an unused argument. labelopt: Formatting change.	1996-04-11 01:02:48 +00:00
David Jeffery	126b5c3d64	CLP(R) productions, in conjunction with Arth Guinness productions presents... ... A Constraint Solver Interface For Mercury <thunderous applause> Estimated hours taken: 1 summer studentship This is the implementation of a fairly general constraint solver interface. If using a library grade *.cnstr, we emit C instructions to keep track of the solver's implicit state. This is done by storing and restoring 'tickets' - abstract handles on the solver's state. We emit a store_ticket() macro: -when entering the first disjunct of a disjunction -when entering the condition of an if-then-else We emit a restore_ticket() macro: -when entering a disjunct other than the first of a disjunction -when entering the else part of an if-then-else We emit a discard_ticket() macro: -after the restore_ticket() in the final disjunct of a disjunction -at the start of the 'then' part of an if-then-else The rules for emitting the macros is slightly more complicated than that shown above for if-then-elses (determinism of the parts must be taken into account). compiler/code_info.m: Get an llds store_ticket/restore_ticket etc. instruction compiler/disj_gen.m: Emit ticket macros in the appropriate places in a disjunction. compiler/dupelim.m: Handle the new llds instruction. compiler/frameopt.m: Handle the new llds instruction. compiler/handle_options.m: If the grade is *.cnstr, set the constraints option on. compiler/ite_gen.m: Emit ticket macros in the appopriate places in an if-then-else. compiler/livemap.m: Handle the new llds instruction. compiler/llds.m: Output the ticket macros. compiler/make_hlds.m: An irrelevant tidy-up. compiler/mercury_compile.pp: If the grade is *.cnstr, pass -DCONSTRAINTS to mgnuc compiler/middle_rec.m: Handle the new llds instruction. compiler/opt_*.m: Handle the new llds instruction. compiler/options.m: Introduce a new boolean option 'constraints'. compiler/shapes.m: Output a new shape - 'ticket'. compiler/unify_proc.m: Handle the new llds instruction. compiler/v*.m: Handle the new llds instruction.	1996-03-26 16:45:12 +00:00
Fergus Henderson	6d7f4b9b30	Undo dylan's changes in the names of some library entities, ... Estimated hours taken: 1.5 Undo dylan's changes in the names of some library entities, by applying the following sed script s/term_atom/term__atom/g s/term_string/term__string/g s/term_integer/term__integer/g s/term_float/term__float/g s/term_context/term__context/g s/term_functor/term__functor/g s/term_variable/term__variable/g s/_term__/_term_/g s/std_util__bool_/bool__/g to all the `.m' and `.pp' files in the compiler and library directories. The reason for undoing these changes was to minimize incompatibilities with 0.4 (and besides, the changes were not a really good idea in the first place). I also moved `bool' to a separate module. The main reason for that change is to ensure that the `__' prefix is only used when it genuinely represents a module qualifier. (That's what dylan's changes were trying to acheive, but `term__' does genuinely represent a module qualifier.) compiler/*.m: Apply sed script above; where appropriate, add `bool' to the list of imported modules.	1996-02-03 17:30:14 +00:00
Zoltan Somogyi	3224e94532	A new pass to remove unnecessary assignment unifications. ... excess: A new pass to remove unnecessary assignment unifications. mercury_compile: Call the new excess assignment module. options: Add a new option, excess_assign, to control the new optimization. Add another, num-real-regs, to specify how many of r1, r2 etc are actually real registers. The default is now set to 5 for kryten; later it should be supplied by the mc script, with a value determined at configuration time. tag_switch: Use num-real-regs to figure out whether it is likely to be worthwhile to eliminate the common subexpression of taking the primary tag of a variable. Also fix an old performance bug: the test for when a jump table is worthwhile was reversed. value_number, vn_block: Do value numbering on extended basic blocks, not basic blocks. vn_debug: Modify an information message. labelopt: Clean up an export an internal predicate for value numbering. Replace bintree_set with set. middle_rec: Prepare for the generalization of middle recursion optimization to include predicates with an if-then-else structure. cse_detection: Fix a bug: when hoisting a common desconstruction X = f(Yi), create new variables for the Yi. This avoids problems with any of the Yis appearing in other branches of the code. goal_util: Add a new predicate for use by cse_detection. common: Fix a bug: recompute instmap deltas, since they may be affected by the optimization of common structures. code_info: Make an error message more explicit. det_analysis: Restrict import list to the needed modules. *.m: Import assoc_list.	1995-10-27 09:39:28 +00:00
David Jeffery	f75693e80a	The C interface. ... The changes made allow declarations of the form: :- pragma(c_code, predname(Varname1::mode1, Varname2::mode2, ...), "Some C code to execute instead of a mercury clause;"). There are still a couple of minor problems to be fixed in the near future: If there is a regular clause given as well as a pragma(c_code, ...) dec, it is not handled well, and variables names '_' are not handled well. prog_io.m: parse the pragma(c_code, ...) dec. hlds.m: define a new hlds__goal_expr 'pragma_c_code'. make_hlds.m: insert the pragma(c_code, ...) dec. as a pragma_c_code into the hlds. det_analysis.m: infer that pragma_c_code goals are det. modes.m: convince the mode checker that the correct pragma variables are bound etc. quantification.m: quantify the variables in the pragma(c_code, ...) dec. code_gen.pp: convert pragma_c_code into pragma_c (in the llds). llds.m: define a new instr, pragma_c. Output the pragma_c hlds_out.m: mercury_to_mercury.m: mercury_to_goedel.m: spit out pragma(c_code, ...) decs properly *.m: handle the new pragma_c_code in the hlds or the new pragma_c in the llds	1995-10-17 11:13:13 +00:00
Zoltan Somogyi	693543830f	Added last call optimization for nondet predicates. ... jumpopt: Added last call optimization for nondet predicates. llds: Added a new lval type to represent the succip slot of nondet stack frames. other files: Changes required by the change to llds (there is a minor unrelated change in vn_cost as well). Tyson: please check my changes to code_info__get_shape_num and garbage_out__write_liveval.	1995-09-06 02:22:24 +00:00
Zoltan Somogyi	eef27b6a67	Removed the caller argument from the call, call_closure and goto LLDS ... instructions, and the last argument from local labels. All these were placeholders for info put in there by prof.m and used when emitting C code. The set of labels that serve as return points are now calculated in llds.m just before each procedure has its C code generated. This set is passed to output_instruction along with the label at the start of the procedure.	1995-09-05 10:16:19 +00:00
Fergus Henderson	760b99015c	Another big batch of changes for higher-order predicates. ... This set of changes includes most of the work necessary for mode and determinism checking of higher-order predicates. prog_io.m: Change the syntax for lambda expressions: they need to have a determinism declaration. Lambda expressions must now look like this: lambda([X::in, Y::out] is det, ...goal...). ^^^^^^ Note that both the modes and the determinism are mandatory, not optional. hlds.m: Insert a determinism field in the lambda_goal structure. hlds_out.m, inlining.m, make_hlds.m, modes.m, polymorphism.m, quantification.m, switch_detection.m, typecheck.m: Modified to use lambda_goal/4 rather than lambda_goal/3. prog_io.m: Add a new field to the `ground' inst, of type `maybe(pred_inst_info)'. We use this to store the modes and determinism of higher-order predicate terms. code_info.m, inst_match.m, mercury_to_mercury.m, mode_util.m, modes.m, polymorphism.m, shapes.m, undef_modes.m: Modified to handle higher-order pred modes: use ground/2 rather than ground/1. (Note that modes.m still requires a bit more work on this.) llds.m: Add a new field to the call_closure/3 instruction to hold the caller address for use with profiling, since the C macros require a caller address. dup_elim.m, frame_opt.m, garbage_out.m, live_map.m, middle_rec.m, opt_debug.m, opt_util.m, value_number.m, vn_*.m: Modified to use call_closure/4 rather than call_closure/3. mercury_to_mercury.m: Export mercury_output_det for use by hlds_out.m.	1995-08-26 20:04:46 +00:00
Zoltan Somogyi	1708fd6adc	Make the teardown map bidirectional, and export it. ... frameopt: Make the teardown map bidirectional, and export it. peephole: Add a new pattern to handle cases generated by fulljump optimization. This pattern uses the teardownmap, but it is disabled for the moment. optimize: Pass the teardown map where it is needed, and make sure we do a peephole pass immediately after frameopt to use the teardownmap while it is still valid. jumpopt: Rename a variable. labelopt: A block being eliminated may have the last remaining reference to the label starting another block. Therefore on the last invocation of labelopt, we iterate to a fixpoint before returning. opt_debug: Add a predicate to help debug bidirectional teardown maps. opt_util: Liberalized some optimizations, but the changes are disabled for the moment. value_number: Pass an empty teardown map to peephole. Loosen the sanity check on tags a bit. vn_order: If the new value of a location depends on its old value, avoid creating a circularity in the preferred order relation. Such circularity may be broken arbitrarily, even though we have a clear preference. vn_flush: Modify the criteria for saving the old value stored in a location about to be overwritten, in an effort to eliminate useless copies of old values. vn_util: Tighten the requirement for classifying a use as a "real" use, also in the effort to eliminate useless saves of old values. Recognize some more expression patterns as yieldsing known results. Move some functionality from vn_flush to vn_util, since it is needed by the other modification.	1995-08-25 12:56:54 +00:00
Andrew Bromage	9dddf14a3f	OK, finally, everything should be back in order.	1995-07-05 23:38:32 +00:00