48 Commits

Author	SHA1	Message	Date
Fergus Henderson	dfc4e243cd	Simplify the code by deleting unnecessary uses of $(EXTRA_*), etc. ... Estimated hours taken: 1 browser/Mmakefile: compiler/Mmakefile: library/Mmakefile: profiler/Mmakefile: runtime/Mmakefile: trace/Mmakefile: util/Mmakefile: Simplify the code by deleting unnecessary uses of $(EXTRA_*), etc. This is now handled once and for all in scripts/Mmake.vars, and so it doesn't need to be separately handled by */Mmakefile. This patch also fixes an annoyance where if you set EXTRA_CFLAGS, the flags that you set were being passed to mgnuc twice.	1999-06-01 08:16:13 +00:00
Zoltan Somogyi	dc03496d06	Rewrite significant parts of minimal model tabling so that it works ... Estimated hours taken: 130 Rewrite significant parts of minimal model tabling so that it works in a much wider variety of situations, including coups. Also, clean up the tabling implementation to make it more maintainable, and introduce a new grade component, .mm, that enables minimal model tabling. (Minimal model tabling requires distributed fat, and we don't want to incur such costs unless necessary.) compiler/options.m: Add a new option --use-minimal-model, which for now is documented as "not for general use". This option is a grade option, and is required if minimal model tabling is to work. compiler/handle_options.m: When --use-minimal-model is given, do not allow nondet frame hijacks, since minimal model tabling cannot cope with hijacks. Make --use-minimal-model a grade component. compiler/code_info.m: When --use-minimal-model is given, insert calls to MR_commit_{mark,cut} around goals being committed across. This is now necessary, so that we can detect and handle sitations where a goal being committed across starts but does not complete a tabled goal. compiler/table_gen.m: Rename many of the tabling helper predicates, using a naming scheme that separates predicates used for model_non procedures from those used to implement simpler forms of tabling, while bringing out the parallels between these two sets of predicates. When calls to two tabling helper predicates always occur one after the other, merge the two into one. Generate and use more meaningful variable names; having all of the several variables inserted by this transformation named TableVar was quite confusing. library/private_builtin.m: Reorganize this file, to separate out the different sections. The contents of the non-tabling sections were not modified, only moved around. Rename the predicates referred to by table_gen.m. Move most of the type declarations and complex code out of here, into runtime/mercury_tabling.c. This makes it easier to debug them, since (a) creating a new executable is quicker, since you don't have to wait for lots of mercury compiler invocations, and (b) gdb doesn't get confused by #line directives. It also makes it easier to write them, since you don't have to !&(*U&( remember to double all your double quotes and to backslash all your backslashes. runtime/mercury_grade.h: Include a grade component reflecting whether MR_USE_MINIMAL_MODEL is defined. runtime/mercury_conf_param.h: Document MR_USE_MINIMAL_MODEL. runtime/mercury_stacks.[ch]: The changes to tabling require the addition of two new stacks, the generator stack and the cut stack. This module defines the structures of the frames of these stacks and provides the operations on these stacks. The header file also contains some additional macros that return the addresses of fixed nondet stack slots, not their contents, for use by tabling code. runtime/mercury_context.[ch]: runtime/mercury_memory.[ch]: runtime/mercury_wrapper.[ch]: Declare and set up the two new stacks, both in saved contexts and in the active context, if MR_USE_MINIMAL_MODEL is defined. runtime/mercury_regorder.h: Add four new global virtual machine registers to hold pointers to the memory areas of the two new stacks and the current offsets within them. These are defined whether MR_USE_MINIMAL_MODEL is defined or not, since the cost is minimal and the potential bugs we avoid would be hard to track down. runtime/mercury_engine.h: runtime/mercury_wrapper.c: Add support for a new debugging flag, -dS, which prints the contents of the nondet stack at several points during tabling. runtime/mercury_tabling.[ch]: The implementation of the new tabling system. Much of the new code here is stuff moved from library/private_builtin.m, but in a significantly rewritten form. There is also substantial new code, e.g. to handle the extension of saved stack segments, and to manage dependencies between subgoals in general. Improve the documentation considerably. Replace lists stored as Mercury data structures with lists stored as linked structures in the usual C fashion. This allows us to use debuggers such as ddd on these data structures, whose complexity requires this. Ensure that global names start with MR_. runtime/mercury_init.h: Explicitly include mercury_regs.h at the start. Without this, we get an error, because now mercury_wrappers.h, which mercury_init.h includes, also includes mercury_regs.h, but not before functions have been declared. runtime/Mmakefile: Refer to the new file mercury_stacks.c (mercury_stacks.h already existed, but the module consisted entirely of macros.) Fix a sorting error. scripts/{init,parse,final}_grade_options.sh-subr: scripts/mgnuc.in: Handle the new grade component. tests/tabling/* Add several new test cases that we now pass, most of which we couldn't pass before. Also add some new test cases that we don't pass yet, due to interactions between tabling and negated contexts. trace/mercury_trace_internal.c: If MR_USE_MINIMAL_MODEL is defined, add a new command to print the generator stack. (The new command is deliberately not documented in doc/mdb_doc yet, since (a) it is intended for developers only, and (b) there is no way to test MR_USE_MINIMAL_MODEL in mdb_doc.)	1999-04-20 11:48:56 +00:00
Zoltan Somogyi	3bf462e0b7	Switch to a closure representation that includes runtime type and procedure id ... Estimated hours taken: 36 Switch to a closure representation that includes runtime type and procedure id information, so that closures can be copied, garbage collected, printed, etc. This RTTI information is not yet used. Adding code to use it would be futile until Tyson finishes his changes to the other RTTI data structures. Note also that this change provides the information required for solving the problem of trying to deep copy closures only for grades that include --typeinfo-liveness. Providing this info for other grades is future work. configure.in: Find out what the right way to refer to a variable-sized array at the end of a struct is. runtime/mercury_ho_call.h: New file to define the structure of closures and macros for accessing closures. runtime/Mmakefile: Add the new header file. runtime/mercury_ho_call.c: Add an entry point to handle calls to new-style closures. The code to handle old-style closures, which was unnecessarily duplicated for each code model, stays until all the installed compilers use the new closure representation. Until that time, the new entry point will contain code to detect the use of old-style closures and invoke the old code instead. This allows stage1s compiled with old compilers to use the old style and stage2 to use the new style without any special tricks anywhere else. Add a new entry point to handle method calls of all code models. The old entry points, which had the same code, will also be deleted after this change has been bootstrapped. runtime/mercury_calls.h: Remove the macros that call closures. Their interface sucked, they were not used, and their implementation is now out of date. runtime/mercury_stack_layout.h: Add a new type, MR_Type_Param_Locns, for use by the C type representing closures. Since MR_Stack_Layout_Vars has a field, MR_slvs_tvars, which references a data structure identical in every way to MR_Type_Param_Locns, change the type of that field to this new type, instead of the previous cheat. runtime/mercury_layout_util.h: Minor update to conform to the new type of the MR_slvs_tvars field. (This is the only use of that field in the system.) runtime/mercury_type_info.h: Add new types MR_TypeInfo and MR_PseudoTypeInfo. For now, they are just Word, but later we can make them more accurate. In the meantime, we can refer to them instead of to Word, making code clearer. One such reference is now in mercury_ho_call.h. compiler/notes/release_checklist.html: Add a reminder to remove the redundant code from mercury_ho_call.c after bootstrapping. compiler/llds.m: Replace three code addresses for calling closures and another three for calling methods with one each. compiler/call_gen.m: compiler/dupelim.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/llds_out.m: Trivial updates in accordance with the change to llds.m compiler/code_info.m: Move the code to handle layouts to continuation_info.m, since that's where it belongs. Leave only the code for picking up parameters from code_infos and for putting results back in there. Remove the redundant arguments of code_info__init, and extract them from ProcInfo, to make clear that they are related. compiler/code_gen.m: Since we pass ProcInfo to code_info__init, don't pass its components. compiler/continuation_info.m: Add the code moved from code_info.m, in a form which takes explicit arguments for things that used be hidden in the code_info. Add new code, closely related to the moved code, that creates layout info from a procedure's argument info, rather than from a (part of) the current code generator state. This way, it can be invoked from places that don't have a code_info for the procedure for which they want to generate layouts. This is the case when we generate layouts for closures. compiler/par_conj_gen.m: compiler/trace.m: Minor changes required by the move of stuff from code_info to continuation_info. compiler/stack_layout.m: Export some predicates for use by unify_gen. compiler/unify_gen.m: Switch to creating new style closures, complete with layout info. Optimize the code for extending closures a bit. By copying the fixed words of the closure outside the loop, we avoid incurring the loop overhead twice. compiler/code_util.m: Add a couple of utility predicates for continuation_info.m and unify_gen.m library/benchmarking.m: library/std_util.m: Refer to the new entry point for handling closures. browser/dl.m: Use the new closure representation. Note that extras/dynamic_linking/dl.m, which is supposed to be the same as browser/dl.m but is not, should also be updated, but this will be handled later by Fergus. tests/hard_coded/closure_extension.{m,exp}: A new test case to exercise the code for extending closures. tests/hard_coded/Mmakefile: Enable the new test case.	1999-04-16 06:05:49 +00:00
Fergus Henderson	68d2f1c727	Simplify the Mmakefiles. Fix a few minor latent bugs. ... Estimated hours taken: 2 Simplify the Mmakefiles. Fix a few minor latent bugs. */Mmakefile: - Factor out some common code by defining a new variable M_ENV which holds settings of environment variables for mmc, mgnuc, etc. - For consistency, always override MERCURY_C_ALL_INCL_DIRS rather than passing extra `-I' options to mgnuc. - Make sure to always include `$(BOEHM_GC)/include' in the search path, so that it will work if we try to compile with `-O6'. - Make sure to always include `--cflags $(ALL_CFLAGS)' in MCS, so that the EXTRA_CFLAGS etc. will get passed down to gcc via mmc. - Make sure that the Mmakefiles in all directories set all the MC* variables: MCPI, MCSI, MCOI, MCTOI, etc.	1999-04-08 12:58:17 +00:00
Warwick Harvey	4a52a9b94c	Separated out all the commands to create installation directories ... Estimated hours taken: 0.5 boehm_gc/Mmakefile: browser/Mmakefile: compiler/Mmakefile: doc/Mmakefile: library/Mmakefile: runtime/Mmakefile: scripts/Mmakefile: Separated out all the commands to create installation directories into a single target in each Mmakefile, upon which all targets which used to create directories depend. This avoids a race condition with parallel installs into a new directory tree, whereby two or more `mkdir -p' commands simultaneously try to create the same missing path component, resulting in all but one failing.	1999-03-15 00:39:30 +00:00
Thomas Conway	b2b99e5b50	Improvements to coroutining support. These changes allow us to do ... Estimated hours taken: 20 Improvements to coroutining support. These changes allow us to do provide io primatives that cause the Mercury context to suspend rather than causing the engine to block. configure.in: Test to see if we can handle contexts that block on IO using select(). compiler/pragma_c_gen.m: Include the predicate name in the calls to MR_OBTAIN_GLOBAL_C_LOCK and MR_RELEASE_GLOBAL_C_LOCK for improved debugging. Fix a bug where the global lock was not being released when semidet pragma c code failed. runtime/mercury_thread.h: Change the global lock macros to include the message generated by the changes to pragma_c_gen. library/char.m: library/std_util.m: include `thread_safe' in the flags for a couple of pragma c definitions that seem to have missed out. runtime/mercury_context.{c,h}: Add a list of "pending" contexts that are blocked on a file descriptor. When the runqueue becomes empty, we call select on all the pending contexts. Move schedule from the header file to the c file (changing it from a macro to a function) for easier debugging at a slight performance cost. TODO: add a nonblocking call to select so that we can poll for io from time to time rather than waiting till there is nothing else to do. runtime/mercury_reg_workarounds.{c,h}: Make functions that forward to the FD_* macros, which on Linux attempt to use registers that we've already grabbed. Aarrggh! runtime/mercury_thread.c: Tidy up some of the conditional compilation. runtime/mercury_types.h: Remove the definition of SpinLock since we're not using them and are not likely to any time soon.	1998-12-15 00:22:29 +00:00
Fergus Henderson	fbd55b8d7c	Fix the code in the runtime so that `mmake check_headers' succeeds. ... Estimated hours taken: 3 Fix the code in the runtime so that `mmake check_headers' succeeds. runtime/*.h: Add #include statements to make all the header files self-contained. runtime/mercury_table.h: runtime/mercury_table.c: Delete these empty files. For some reason zs left these files as empty instead of deleting them when he renamed the module as mercury_hash_table.{h,c}. runtime/mercury_table_builtins.h: runtime/mercury_table_enum.h: runtime/mercury_table_any.h: runtime/mercury_table_type_info.h: runtime/mercury_table_builtins.c: runtime/mercury_table_enum.c: runtime/mercury_table_any.c: runtime/mercury_table_type_info.c: runtime/mercury_tabling.h: runtime/mercury_tabling.c: Avoid a circular dependency problem (mercury_tabling.h depended on mercury_table_*.h which in turn depended on mercury_tabling.h) by moving all the tabling code into a single module mercury_tabling.{h,c}. The new module is a total of 1100 lines of code, which is not too large IMHO. Also improve the documentation a little. runtime/Mmakefile: Update the reflect the added and removed files. Also update the rule for `mmake check_headers' so that it can make use of parallelism in parallel makes. And make a start towards enforcing namespace cleanliness -- I've added code to check it, but not to enforce it.	1998-11-09 10:24:46 +00:00
Zoltan Somogyi	8caba4e15d	Make it possible to compile a module (e.g. std_util) without debugging, ... Estimated hours taken: 18 Make it possible to compile a module (e.g. std_util) without debugging, while still allowing debuggable code called from that module via higher-order predicates (e.g. solutions) to have a proper stack trace. compiler/options.m: Add the new option --stack-trace-higher-order. compiler/mercury_compile.m: Always invoke continuation_info and stack_layout, since it is no longer the case that either all procedures or none get layout structures generated for them, and the other modules are in a better position to make that decision. compiler/continuation_info.m: Handle the extra tests required by the change to mercury_compile.m. When we gather info about a procedure, remember whether that procedure must have a procedure layout that includes the procedure id section. compiler/stack_layout.m: Use the flag remembered by continuation_info to help decide whether we need procedure layout structures. Fix an old space wastage: after generating marker saying that the second and later groups of fields of a procedure layout are not present, do not generate another marker saying that the third group of fields is not present. Since it was in the wrong position, it did not have the right meaning; it only worked because, due to the presence of the first marker, it was never looked at anyway. compiler/code_gen.m: Use the new capability of continuation_info.m to require procedure layouts including procedure id sections for any predicate that has higher-order arguments, if --stack-trace-higher-order is set. compiler/globals.m: Rename want_return_layouts as want_return_var_layouts, since this is a more accurate representation of what the predicate does. compiler/call_gen.m: compiler/code_info.m: Conform to the change in globals.m. compiler/llds_out.m: Separate the c_modules containing compiler-generated code into two groups, those that define labels that have stack layouts and those that don't. In most cases one or the other category will be empty, but with --stack-trace-higher-order, the c_modules containing higher-order procedures will have stack layouts, while others will not. Reorganize the way the way the initialization functions are generated, by putting c_modules falling into different categories into different bunches. c_module falling into the first category always have their initialization code included, while those in the second category have it included only if the old flag MR_MAY_NEED_INITIALIZATION is set. Delete the obsolete #define of MR_STACK_TRACE_THIS_MODULE. Improve some predicate names, in an effort to prevent confusion about what a "file" is (since the code uses more than one meaning, given the presence of --split-c-files). compiler/pragma_c_gen.m: Fix an old bug: s/NONDET_FIXED_SIZE/MR_NONDET_FIXED_SIZE/. Required for the change to library/string.m. doc/user_guide.texi: Document the new option. runtime/mercury_goto.c: Simplify the conditions under which labels get added to the label table with: - The macros init_{entry,label,local}_ai always add the label to the label table without a layout structure. - The macros init_{entry,label,local}_sl always add it with a layout structure. - Whether the macros init_{entry,label,local} with no suffix add the label to the label table depends on the values of other configuration parameters, but they will never include a layout structure. The intended use is that any label that has a layout structure should be initialized with a _sl macro. Any other label that should always be in the label table if the label table is needed at all (labels such as do_fail) should be initialized with _ai. Everything else should be initialized with a suffixless macro. runtime/mercury_conf_params.c: Remove MR_USE_STACK_LAYOUTS and MR_STACK_TRACE_THIS_MODULE, since due to the simplification of mercury_goto.h, they are not used anymore. runtime/mercury_stack_layout.h: Remove the old macros for creating layout structures with bogus contents, and replace them with new macros for creating layout structures with meaningful contents. runtime/mercury_engine.c: runtime/mercury_wrapper.c: Remove bogus layout structures. Ensure the labels defined here always get into the label table. runtime/mercury_ho_call.c: Remove bogus layout structures. Add proper ones where necessary. runtime/mercury_bootstrap.c: runtime/mercury_type_info.c: Remove bogus layout structures. runtime/mercury_boostrap.h: Add this new file for bootstrapping purposes. Temporarily #define NONDET_FIXED_SIZE as MR_NONDET_FIXED_SIZE, since pragma_c_gen.m refers to the former until the update to it gets installed. runtime/Mmakefile: Add a reference to mercury_boostrap.h. library/builtin.m: Remove bogus layout structures. library/array.m: library/benchmarking.m: library/private_builtin.m: Remove bogus layout structures. Add proper ones. library/std_util.m: Remove bogus layout structures. Add proper ones. Replace references to framevar(n) with references to MR_framevar(n+1). Fix an old bug in code under #ifndef COMPACT_ARGS: in the implementation of mercury____Compare___std_util__univ_0_0_i1, the succip register was not being saved across the call to mercury__compare_3_0. library/string.m: Remove the need for bogus layout structures, by converting the implementation of string__append(out, out, in) from hand-written C module into nondet pragma C code.	1998-11-05 03:53:48 +00:00
Zoltan Somogyi	16f3d4ccaa	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:21 +00:00
Zoltan Somogyi	8ddce575d4	Introduce two new directories, trace and browser, containing libraries ... Estimated hours taken: 10 Introduce two new directories, trace and browser, containing libraries holding the C and Mercury code of the debugger respectively. (Although the browser directory does not have a browser in it yet, the browser should soon become its biggest component.) Take the opportunity to rename the existing libraries, for consistency. After this change, the linking order becomes: the object of the auto-generated init file program object files trace library (libmer_trace.a) browser library (libmer_browser.a) standard library (libmer_std.a) runtime library (libmer_rt.a) Boehm collector (libgc.a) To avoid circularities, libraries cannot contain direct calls to any routines that are defined in libraries (or object files) that occur earlier in the above list. Any such calls must be made into indirect calls via function pointers. In particular, there was a circularity caused by the library calling MR_trace() which invokes the tracer which in turn invokes the library. This circularity was broken by having MR_trace(), which is defined in the runtime, call the tracer indirectly via a global variable named MR_trace_func_ptr. This global variable is initialized by the auto-generated *_init.c file. To avoid linking in the tracer even when it is not being used, this global variable is only set to point to MR_trace_real() if you're using a debugging grade or if c2init was invoked with the `-t' flag. Otherwise it is set to MR_trace_fake() which just prints an error message telling the user to rebuild the executable with debugging enabled. Makefile.DLLs: Reserve random locations for the two new libraries. Whether they work will be decided by testing on Windows. Mmake.common.in: Add variables naming the new directories, and create variables naming the libraries. Mmakefile: Add targets for the new directories, and modify existing rules as appropriate. browser/Mmakefile: Mmakefile for the new directory, modelled on library/Mmakefile. browser/browser_library.m: Umbrella file for the new directory, modelled on library/library.m. {browser,library}/debugger_interface.m: Moved this file from library to browser without change. browser/help.m: A new module for the help system of the debugger. Not yet used. compiler/Mmakefile: Update to refer to the new directories and libraries where appropriate. compiler/mercury_compile.m: If we are doing tracing, then pass -t instead of -i to c2init. compiler/modules.m: When generating the .dep file, get the grade flags passed to c2init. doc/Mmakefile: Remove the special treatment of library/debugger_interface.m. library/Mmakefile: Update to refer to the new directories and libraries where appropriate, and to conform to the new name of the library. library/library.m: Do not import debugger_interface. profiler/Mmakefile: Update to refer to the new directories and libraries where appropriate. runtime/Mmakefile: Update to refer to the new directories and libraries where appropriate, and to conform to the new name of the library. Remove references to files being moved to the trace directory. runtime/mercury_init.h: Refer to the automatically generated dll header file by its new name (renamed because the runtime library is renamed). Add declarations to support the new global variable MR_trace_func_ptr. runtime/mercury_memory_handlers.c: runtime/mercury_memory_zones.c: runtime/mercury_misc.c: Remove inappropriate #includes of "mercury_trace.h", and substitute a #include of "mercury_trace_base.h" if necessary. {runtime,trace}/mercury_trace.[ch]: {runtime,trace}/mercury_trace_external.[ch]: {runtime,trace}/mercury_trace_internal.[ch]: Move these files from the runtime to the trace directory. The only changes are the removal from mercury_trace.h of declarations added to runtime/mercury_trace_base.h, and the change from MR_trace to MR_trace_real. runtime/mercury_trace_base.[ch]: Define MR_trace(), which does an indirect call through MR_trace_func_ptr if the event should be traced. Define MR_trace_fake, which just prints an error message. Its address will be assigned to MR_trace_func_ptr if tracing is not enabled. Define the types needed by the signature of MR_trace. Fix an old bug: s/MERCURY_TRACE_PERMANENT_H/MERCURY_TRACE_BASE_H/. runtime/mercury_wrapper.[ch]: Add the new global variable MR_trace_func_ptr. scripts/c2init.in: Add a new option, -t/--trace, which enables tracing by causing the address of MR_trace_real to be assigned to MR_trace_func_ptr. Have this option be implied by the grade. Also have the old option -i (need initialization code) be implied by the grade, as well as by -t. scripts/ml.in: Include the new libraries in the link command. tests/debugger/Mmakefile: Include -t instead of -i in the list of c2init options. (-t implies -i.) tools/bootcheck: Copy and build the new directories as appropriate. The trace directory is treated like the runtime, the browser directory is treated like the library. trace/Mmakefile: Mmakefile for the new directory, modelled on runtime/Mmakefile. util/mkinit.c: Add the new option -t, as discussed above. Mmakefile for the new directory, modelled on runtime/Mmakefile. util/Mmakefile: Specify -O0, since with the default optimization level, gcc on cyclone ignores the assignment of TRUE to need_tracing when -t is given (!!!).	1998-09-29 05:12:06 +00:00
Zoltan Somogyi	db3d4daf8d	Rename mercury_table.[ch] as mercury_hash_table.[ch]. ... Estimated hours taken: 2 runtime/mercury_table.[ch]: runtime/mercury_hash_table.[ch]: Rename mercury_table.[ch] as mercury_hash_table.[ch]. The old name became confusing a while ago, when Oliver added mercury_table_*.[ch]. At the same time, rename the types, fields, functions and macros in the module, both to allude to hash tables and to make sure everything is prefixed with MR_. Do not apply sanity checks on the hash function by default. runtime/mercury_label.c: Trivial diffs to conform to the changes above. runtime/Mmakefile: Update the file names.	1998-09-15 07:19:31 +00:00
Zoltan Somogyi	5ea739d0bd	Fix some bugs in tabling, to enable the boyer test case to work. ... Estimated hours taken: 6 Fix some bugs in tabling, to enable the boyer test case to work. runtime/mercury_tabling.h: Add a new set of macros that optionally print debugging info at tabling actions. Debugging recquires compilation with -DMR_TABLE_DEBUG and -dT in MERCURY_OPTIONS. runtime/mercury_table_any.c: Use the debugging macros. Fix two bugs, one found with their help. One is that a tagged pointer to the table giving information about remote secondary tags did not have its tag stripped before use. The other is that the extraction of local secondary tags from words was done by subtracting the tag, and not by shifting out the tag, leaving the secondary tag value too high by a factor of 4 or 8. runtime/mercury_table_any.[ch]: runtime/mercury_table_enum.[ch]: Change the order of some function arguments to be consistent with the orders in the macros that call these functions. runtime/mercury_table_enum.c: Add an optional sanity check that detects the second bug above. runtime/mercury_engine.[ch]: Add a new debug flag, MR_tabledebug. Rename the flags so they always start with MR_. runtime/mercury_wrapper.c: Allow -dT in MERCURY_OPTIONS to set MR_tabledebug. runtime/*.[ch]: Trivial changes for the new names of the debug flags. runtime/Mmakefile: Reimpose alphabetical order on the list of C files. library/private_builtin.m: Use the new debugging macros in the C code that does tabling. Expose the equivalence between ml_table, ml_subgoal_table_node etc and c_pointer. The reason is % These equivalences should be local to private_builtin. However, % at the moment table_gen.m assumes that it can use a single variable % sometimes as an ml_table and other times as an ml_subgoal_table_node % (e.g. by giving the output of table_lookup_insert_int as input to % table_have_all_ans). The proper fix would be for table_gen.m to % use additional variables and insert unsafe casts. However, this % would require significant work for no real gain, so for now % we fix the problem by exposing the equivalences to code generated % by table_gen.m. library/mercury_builtin.m: Delete the contents of this obsolete file, leaving only a pointer to builtin.m and private_builtin.m. tests/tabling/Mmakefile: Enable the boyer benchmark, since we now pass it.	1998-08-24 08:24:58 +00:00
Zoltan Somogyi	137ce69e7a	Bring the handling of MERCURY_OPTION into the 90s (a bit late :-). ... Estimated hours taken: 5 Bring the handling of MERCURY_OPTION into the 90s (a bit late :-). Get rid of lack-of-prototype warnings from getopt.h. runtime/getopt.[ch]: runtime/getopt1.c: runtime/GETOPT: runtime/GETOPT/getopt.[ch]: runtime/GETOPT/getopt1.c: Move these files to a new subdirectory, GETOPT. This should avoid the nuisance warnings one gets when stdlib.h picks up the getopt.h in the runtime directory by accident. (The GETOPT directory should never need to be included in -I search paths.) runtime/mercury_getopt.[ch]: runtime/mercury_getopt1.c: Copies of the files in GETOPT, slightly modified to make sure that (1) every external symbol they define starts with MR_, and (2) we get a minimal number of compilation errors (as of now, 3 warnings about casting away const). These files are not to be modified by humans. runtime/process_getopt: This is the script that creates mercury_getopt{.h,.c,1.c} from the files in GETOPT. runtime/mercury_wrapper.c: Get rid of the -s<area><size> notation, which can hard to remember, and replace it with long options such as --heap-size=1024. Print an error message and stop if MERCURY_OPTIONS contains anything other than options. Refer to everything from mercury_getopt.h with a name that starts with MR_. runtime/Mmakefile: Mention the new source files. doc/user_guide.texi: Document the new options. NEWS: Mention the new options.	1998-08-10 07:18:25 +00:00
Tyson Dowd	bbd89318b7	Fix a bootstrapping problem. ... Estimated hours taken: 1 Fix a bootstrapping problem. runtime/Mmakefile: runtime/mercury_bootstrap.c: Add definitions that are generated in stage 1 compiler, but not stage 2. Since runtime is a library, they will be linked only if they are not generated. When the compilers are installed everywhere, this code can be moved into library/mercury_private_builtin.m.	1998-08-04 09:12:12 +00:00
Andrew Bromage	4b19bdf5de	Minor reorganisation for compatibility with FreeBSD headers. ... Estimated hours taken: 0.7 Minor reorganisation for compatibility with FreeBSD headers. The main rationale for this change (thanks Fergus) is: - the global register declarations in mercury_regs.h must come before any standard header files are #included, - the "mercury_regs.h" file needs `Word', etc. from "mercury_types.h", - hence "mercury_types.h" must not #include any standard header files; - in addition, the `MercuryFile' type needs `FILE' from <stdio.h>, - hence the `MercuryFile' type cannot be declared in "mercury_types.h". MR_ArrayType doesn't suffer from this problem, but it's moved anyway for cleanliness reasons (mercury_type_info.h was never a perfect home for it). runtime/mercury_type_info.h: Move MR_ArrayType into mercury_library_types.h. runtime/mercury_types.h: Move MercuryFile into mercury_library_types.h. runtime/mercury_library_types.h: New file, intended for the declaration of C types which are really the province of the library rather than the runtime, but which the runtime still needs. runtime/mercury_imp.h: Import mercury_library_types.h. runtime/Mmakefile: Include mercury_library_types.h in the header dependencies.	1998-07-28 03:10:01 +00:00
Tyson Dowd	376f2c69af	An initial implementation of the accurate garbage collector. ... Estimated hours taken: 90 An initial implementation of the accurate garbage collector. WORK_IN_PROGRESS: Add an entry for the accurate garbage collector. library/builtin.m: library/mercury_builtin.m: library/std_util.m: runtime/mercury_tabling.h: Deep copy terms using the address of the value instead of just the value. library/io.m: Initialize the garbage collector's rootset with the globals. runtime/Mmakefile: Add new files to the Mmakefile. runtime/mercury_accurate_gc.h: runtime/mercury_accurate_gc.c: The new garbage collector. runtime/mercury_agc_debug.c: runtime/mercury_agc_debug.h: Debugging utilities for the new garbage collector. runtime/mercury_deep_copy.c: runtime/mercury_deep_copy.h: runtime/mercury_deep_copy_body.h: Put the deep copy code in mercury_deep_copy_body.h, and #include it with appropriate #defines in order to get a variant for deep_copy(), and one for agc_deep_copy(). agc_deep_copy() forwards pointers as it copies. Also, deep_copy (all variants) have been modified to take a pointer to the data to be copied, because some variants need to be able to modify it. runtime/mercury_engine.c: runtime/mercury_engine.h: Add a second heap_zone which is the to-space of the copying collector. Add a debug_heap_zone, which is used as a scratch heap for debugging. runtime/mercury_label.c: Instead of realloc(entry_table, ....) do entry_table = realloc(entry_table, ....) to avoid horrible bugs. Also, make sure the tables get initialized before looking up an entry label. runtime/mercury_imp.h: Include mercury_debug.h before most of the modules. (mercury_engine.h adds a new MemoryZone only if we are debugging accurate GC). runtime/mercury_memory.c: Setup the debug_memory_zone sizes. Remove an unnecessary prototype. runtime/mercury_memory_handlers.c: Add code to get the program counter and the stack pointer from the signal context. Call MR_schedule_agc() from default_handler() if doing accurate gc. runtime/mercury_memory_zones.c: Setup the hardzone regardless of whether redzones are used. Add some more debugging information. runtime/mercury_regorder.h: runtime/machdeps/alpha_regs.h: runtime/machdeps/i386_regs.h: Add definitions to make the real machine registers name/number for MR_sp available. runtime/mercury_trace_internal.c: runtime/mercury_trace_util.c: runtime/mercury_trace_util.h: Add MR_trace_write_variable(), which writes terms given their value and type_info. runtime/mercury_wrapper.c: runtime/mercury_wrapper.h: Change the size of the heap redzone when doing accurate GC. Use a small heap when debugging agc. runtime/mercury_debug.h: runtime/mercury_conf_param.h: Add new debugging macros and document them. runtime/mercury_type_info.c: Add const to the pointer arguments of MR_make_type_info.	1998-07-22 07:55:19 +00:00
Fergus Henderson	c50c092bd2	Rename mercury_table_int_float_string.[hc] as ... Estimated hours taken: 0.5 runtime/Mmakefile: runtime/mercury_tabling.h: runtime/mercury_table_int_float_string.h: runtime/mercury_table_int_float_string.c: runtime/mercury_table_builtins.h: runtime/mercury_table_builtins.c: Rename mercury_table_int_float_string.[hc] as mercury_table_builtins.[hc], to avoid portability problems (reported by Chris Higgins <c.higgins@ndirect.co.uk>, who is trying to port Mercury to MacOS with MPW) with file names longer than 31 characters.	1998-07-07 19:57:43 +00:00
Zoltan Somogyi	4ada219856	Reorganize the label table to better fit the needs of accurate gc ... Estimated hours taken: 25 Reorganize the label table to better fit the needs of accurate gc and the tracer, and reduce the size of executables. With these changes, the size of hello world, compiled with static Mercury libraries but dynamic C libraries, goes from 150+ Kb to 138+ Kb, much of which is beyond our control (e.g. Boehm gc). runtime/mercury_label.[ch]: The old label table contained both entry labels and internal labels, even though they had different kinds of layouts associated with them (proc layouts and label layouts respectively). The two kinds of labels have different usage patterns. Internal labels are needed for stack walking, which requires random access by exact label address. Entry labels are needed for finding which procedure a program counter is in for accurate GC, which requires lower-bound inexact search. The module now has two separate data structures for the two different kinds of labels. Internal labels are in a hash table, as before. Entry labels are in an array (resized on demand), which is sorted for binary search. The entry label array and its associated functions are present only if they are needed. runtime/mercury_goto.h: Call the new functions in mercury_label.c from the init_{local,label,entry}{,_sl} macros. runtime/mercury_misc.[ch] Use the new functions in mercury_label. Fix some software rot, so that the code now compiles with MR_DEBUG_GOTOS. (It still does not compile with MR_LOWLEVEL_DEBUG, but the fix for that would conflict with Tom's planned change to zone handling, so that fix should be done after Tom is done.) Note that mercury_misc.c still defines newmem() and oldmem() although they are declared in mercury_std.h. runtime/mercury_stack_trace.c: Use the new functions in mercury_label. As a result, we also need to make a few more pointers const. runtime/mercury_table.[ch]: Add a new traversal predicate to support a new function in mercury_label.c. (That function is not used yet, but will be soon.) runtime/mercury_trace.[ch]: runtime/mercury_trace_base.[ch]: Split the old mercury_trace module into two. The functions and variables that will always be linked in (because they are referenced from modules such as mercury_wrapper which are always needed) are now in mercury_trace_base; the other functions and variables stay in mercury_trace. This way, mercury_trace.o will be linked in only if some module was compiled with execution tracing. Since mercury_trace.o drags in mercury_trace_internal.o which drags in everything needed for printing arbitrary terms (which is a lot), this can be a significant win. runtime/Mmakefile: Include the new module in the library. runtime/mercury_wrapper.c: runtime/mercury_conf_param.h: Remove some obsolete MERCURY_OPTIONS options, which would be difficult to support with the new label table. Move the #ifdefs around the -P option, so that programs not compiled with MR_THREAD_SAFE will accept but ignore the option, instead of aborting with the usage message. Replace the long usage message for malformed MERCURY_OPTIONS environment variables with a pointer to the user's guide. This saves about 1 Kb on every executable. runtime/mercury_conf_param.h: Document MR_STACK_TRACE_THIS_MODULE. util/mkinit.c: Add a new flag, -i. If this flag is given, include the initialization code regardless of grade. If it is not given, include the init code only if the grade requires it. The -i should be given if you want the executable to support stack tracing, or uplevel printing in execution tracing, at the cost of making the executable link in the init functions of all the modules in the library. Put the option handling code in alphabetical order. Fix the wrong default name of the entry point. (It only worked because c2init was always overriding the default.) scripts/c2init.in: Pass through the -i flag to mkinit. Put the option handling code in alphabetical order. compiler/mercury_compile.m: If the trace level specifies any kind of tracing, pass -i to c2init. tests/debugger/Mmakefile: Add -i to the c2init flags. tests/debugger/* Update the other half the test cases (those which assume a traced library) to conform to the changes in the debugger interface. The first half were updated earlier. doc/user_guide.texi: In the environment variable section, modify the entry for MERCURY_OPTIONS to document all the options it makes sense for non-developers to use. Slight changes to two other parts of the guide to reduce duplication with the new material.	1998-07-03 02:36:09 +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
Oliver Hutchison	bcf7dbf9f8	Add support for tabling. ... Estimated hours taken: 250 Add support for tabling. This change allows for model_det, model_semidet and model_non memoing, minimal model and loop detection tabling. compiler/base_type_layout.m: Update comments to reflect new runtime naming standard. compiler/det_analysis.m: Allow tabling to change the result of det analysis. This is necessary in the case of minimal model tabling which can turn a det procedure into a semidet one. compiler/det_report.m: compiler/hlds_data.m: Add code to report error messages for various non compatible tabling methods and determinism. compiler/hlds_out.m: compiler/modules.m: Remove reference to the old memo marker. compiler/hlds_pred.m: Create new type (eval_method) to define which of the available evaluation methods should be used each procedure. Add new field to the proc_info structure. Add several new predicates relating to the new eval_method type. compiler/inlining.m: compiler/intermod.m: Make sure only procedures with normal evaluation are inlined. compiler/make_hlds.m: Add code to process new tabling pragmas. compiler/mercury_compile.m: Call the tabling transformation code. compiler/modes.m: Make sure that all procedures with non normal evaluation have no unique/partially instantiated modes. Produce error messages if they do. Support for partially instantiated modes is currently missing as it represents a large amount of work for a case that is currently not used. compiler/module_qual.m: compile/prog_data.m: compiler/prog_io_pragma.m: Add three new pragma types: `memo' `loop_check' `minimal_model' and code to support them. compiler/simplify.m: Don't report infinite recursion warning if a procedure has minimal model evaluation. compiler/stratify.m: Change the stratification analyser so that it reports cases of definite non-stratification. Rather than reporting warnings for any code that is not definitely stratified. Remove reference to the old memo marker. compiler/switch_detection.m: Fix a small bug where goal were being placed in reverse order. Call list__reverse on the list of goals. compiler/table_gen.m: New module to do the actual tabling transformation. compiler/notes/compiler_design.html: Document addition of new tabling pass to the compiler. doc/reference_manual.texi: Fix mistake in example. library/mercury_builtin.m: Add many new predicates for support of tabling. library/std_util.m: library/store.m: Move the functions : ML_compare_type_info ML_collapse_equivalences ML_create_type_info to the runtime. runtime/mercury_deep_copy.c: runtime/mercury_type_info.h: runtime/mercury_type_info.c: Move the make_type_info function into the mercury_type_info module and make it public. runtime/Mmakefile: runtime/mercury_imp.h: Add references to new files added for tabling support. runtime/mercury_string.h: Change hash macro so it does not cause a name clash with any variable called "hash". runtime/mercury_type_info.c: runtime/mercury_type_info.h: Add three new functions taken from the library : MR_compare_type_info MR_collapse_equivalences MR_create_type_info. runtime/mercury_table_any.c: runtime/mercury_table_any.h: runtime/mercury_table_enum.c: runtime/mercury_table_enum.h: runtime/mercury_table_int_float_string.c: runtime/mercury_table_int_float_string.h: runtime/mercury_table_type_info.c: runtime/mercury_table_type_info.h: runtime/mercury_tabling.h: New modules for the support of tabling.	1998-05-15 07:09:29 +00:00
Tyson Dowd	cd3914c609	More cleanup of the memory management code. ... Estimated hours taken: 5 More cleanup of the memory management code. This time we clean up the signal handler setup code. runtime/Mmakefile: Add new files. runtime/mercury_memory.c: Rename setup_signal() to setup_signals(). runtime/mercury_memory_handlers.c: runtime/mercury_memory_handlers.h: Clean up signal handling. Use MR_setup_signal to setup signal handlers. Define bus_handler and segv_handler signal handlers, the old signal handlers are just one or the other (or both). runtime/mercury_prof.c: Use MR_setup_signal to setup signal handler. runtime/mercury_signal.c: runtime/mercury_signal.h: New files -- a standard interface for setting up signal handlers (a porting base, if you like).	1998-05-14 06:35:16 +00:00
Tyson Dowd	917c158436	Split mercury_memory.{c,h} into several files. ... Estimated hours taken: 5 Split mercury_memory.{c,h} into several files. Added a few comments about functions whose declarations have been moved into the header files, otherwise the content is unchanged. runtime/Mmakefile: Add new files. runtime/mercury_context.c: Add a #include "mercury_memory_handlers.h" as this module creates new zones using default_handler. runtime/mercury_memory.c: runtime/mercury_memory.h: Other code (mostly code to set up the actual memory zones we use in the Mercury runtime). runtime/mercury_memory_handlers.c: runtime/mercury_memory_handlers.h: Signal handlers for memory access violations. runtime/mercury_memory_zones.c: runtime/mercury_memory_zones.h: The implementation MemoryZone data type.	1998-05-08 02:53:41 +00:00
Fergus Henderson	6f065be64a	Fix some Mmakefile errors that were diagnosed by `--warn-undefined-variables'. ... Estimated hours taken: 1 Fix some Mmakefile errors that were diagnosed by `--warn-undefined-variables'. Also, make a small fix to mmake.in and add empty definitions for various Mmake variables to avoid spurious warnings. scripts/mmake.in: Add ` dep*' to the patterns for which we do not pass `--warn-undefined-variables'; previously it matched "$@" against `dep*', which did not catch the case of `mmake -k depend'. ^^^ scripts/Mmake.vars.in: Add definition for `ds_subdir'. Define `MLLIBS' as `$(EXTRA_MLLIBS)' rather than empty, and add empty definition for `EXTRA_MLLIBS'. Add empty definition for `MAIN_TARGET'. Mmakefile: Fix misspelling: `deps_subdir' not `dep_subdir'. Add empty definitions for `PREINSTALL_HACK', `POSTINSTALL_HACK', and `MMAKEFLAGS'. boehm_gc/Mmakefile: Add empty definition for `PROF'. runtime/Mmakefile: Add empty definition for `DLL_CFLAGS'. library/Mmakefile: Add empty definition for `CHECK_TERM_OPTS'. compiler/Mmakefile: Add empty definition for `MTAGSFLAGS'.	1998-03-30 13:03:17 +00:00
Fergus Henderson	60eac4cd0c	Pass `--warn-undefined-variables', except when making dependencies. ... Estimated hours taken: 0.75 scripts/mmake.in: Pass `--warn-undefined-variables', except when making dependencies. runtime/Mmakefile: scripts/Mmake.vars.in: Add empty definitions of a few variables, to avoid warnings with `--warn-undefined-variables'.	1998-03-27 08:34:23 +00:00
Thomas Conway	a2071fb30d	Add mercury_conf_params.h to the HDRS variable in the Mmakefile ... Estimated hours taken: 0.1 runtime/Mmakefile: Add mercury_conf_params.h to the HDRS variable in the Mmakefile so that it gets installed.	1998-03-17 03:31:28 +00:00
Tyson Dowd	f58ee880df	Add support for stack dumps, do a stack dump from error/1. ... Estimated hours taken: 12 Add support for stack dumps, do a stack dump from error/1. compiler/Mmakefile: library/Mmakefile: profiler/Mmakefile: runtime/Mmakefile: Insert EXTRA_MGNUCFLAGS before CFLAGS or EXTRA_CFLAGS becasue mgnuc stops processing its options when it encounters a non-mgnuc option. library/require.m: Call MR_dump_stack if error is called. runtime/Mmakefile: runtime/mercury_imp.h: Add #includes of new files. runtime/mercury_type_info.h: Remove conditional definition of MR_STATIC_CODE_ADDRESSES (moved into mercury_conf.h.in). runtime/mercury_accurate_gc.h: Remove stack_layout stuff, leave this file for accurate GC specific definitions. runtime/mercury_conf.h.in: Add conditional definitions of MR_INSERT_LABELS, MR_USE_STACK_LAYOUTS, MR_NEED_INITIALIZATION_CODE and MR_STATIC_CODE_ADDRESSES, depending on various other options. runtime/mercury_goto.h: Insert labels into label table if MR_INSERT_LABELS is defined, rather than NATIVE_GC. util/mkinit.c: Initialize if MR_NEED_INITIALIZATION_CODE is defined, rather than NATIVE_GC. runtime/mercury_stack_layout.h: All the old stack layout definitions from mercury_accurate_gc.h. Add code for MR_DETISM_DET_CODE_MODEL. runtime/mercury_stack_trace.c: runtime/mercury_stack_trace.h: Implement MR_dump_stack which just provides a dump of the stack as far as possible. Set MR_INSERT_LABELS and MR_USE_STACK_LAYOUTS if MR_STACK_TRACE is set. runtime/mercury_grade.h: Add _strce if stack tracing is enabled in the grade. This might not be a permanent change. runtime/mercury_ho_call.c: Remove unused label declarations. scripts/mgnuc.in: Add --stack-trace and --no-stack-trace options. Consolidate some duplicate code.	1998-03-11 06:01:17 +00:00
Fergus Henderson	e6ac077bae	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:58:34 +00:00
Tyson Dowd	c9e2a93a4d	Fix a bug in the change to clean up the runtime. ... Estimated hours taken: 0.2 Fix a bug in the change to clean up the runtime. runtime/Mmakefile: Add mercury_grade.h to the list of headers. Without this, it doesn't get installed.	1997-12-02 07:02:35 +00:00
Fergus Henderson	6834103056	s/conf.h/mercury_conf.h/g ... Estimated hours taken: 0.1 runtime/Mmakefile: s/conf.h/mercury_conf.h/g	1997-11-21 12:21:48 +00:00
Fergus Henderson	ceb344571d	Fix something that Tyson forgot in his recent change: ... Estimated hours taken: 0.25 runtime/Mmakefile: Fix something that Tyson forgot in his recent change: s/conf.h/mercury_conf.h/g	1997-11-21 06:28:08 +00:00
Tyson Dowd	7ce7d489a2	Cleaned up runtime directory. ... Estimated hours taken: 2 Cleaned up runtime directory. runtime/*.c: - Renamed all .c files as mercury_*.c Some have been renamed to make their purpose clearer. call.mod -> mercury_ho_call.c runtime/*.h: - Moved contents of .h files to mercury_*.h - *.h now contain #include mercury_*.h. They be removed later. - Updated references to conf.h -> mercury_conf.h runtime/conf.h.in: - Renamed conf.h.in as mercury_conf.h.in. Didn't leave a forwarding header for this one, as conf.h was never part of the repository anyway. runtime/Mmakefile: - Convert lists to one-per-line lists. - Add mercury_accurate_gc.h to HDRS. - Remove all .mod files - Make sure runtime.init uses the ORIG_CS not MOD_CS. - Fix the rules for "clean_o" and "clean_mod_c", which used wildcards like "*.o" to remove files. The one that removed all .c files corresponding with *.mod, instead of using MOD_CS was particularly vicious. - Cope with the file renamings. configure.in: - Cope with the file renamings.	1997-11-20 02:04:40 +00:00
Fergus Henderson	8faa624662	Fix a bug that broke grades `*.gc.prof.tr'. ... Estimated hours taken: 0.5 Fix a bug that broke grades `*.gc.prof.tr'. runtime/Mmakefile: library/Mmakefile: compiler/Mmakefile: profiler/Mmakefile: When deciding whether to link with -lgc or -lgc_prof, match against `*.gc*.prof*' rather than `*.gc*.prof'. ^	1997-11-06 06:19:38 +00:00
Zoltan Somogyi	248d00e14b	First implementation of the generation of traces for Opium-style trace ... Estimated hours taken: 7 First implementation of the generation of traces for Opium-style trace analysis. In this initial implementation, there are only three ports: call, exit and fail. Later versions will add ports that indicate entry to an arm of a switch or disjunction and to the then or else part of an if-then-else. compiler/options.m: Add a new option, --generate-trace. compiler/handle_options.m: When --generate-trace is on, turn off HLDS->HLDS optimizations that would change the behavior of the trace. compiler/code_info.m: Add a new field in code_into for storing information that is needed when generating trace code. (At the moment, this info is the identity of two stack slots storing the sequence number and depth of the current procedure call.) This info must be in the code_info structure, because it is used not only by code_gen.m but also by call_gen.m, and later by switch_gen.m, disj_gen.m and ite_gen.m. compiler/code_gen.m: Add code to initialize the tracing info in code_info and to add trace statements to procedure prologs and epilogs if --generate-trace is on. compiler/call_gen.m: Clean up the generation of code for calls, merging the three predicates for det, semi and non procedures into one, and factoring out some common code between the generation of code for normal calls and higher order calls. Add code to reset the call depth just before each (normal or higher-order) call if --generate-trace is on. compiler/trace.m: New file responsible for the generation of trace statements in the C file output by the compiler. Code in code_gen.m and call_gen.m calls trace.m; so will code in switch_gen.m, disj_gen.m and ite_gen.m. compiler/mercury_compile.m: When --generate-trace is on, include mercury_trace.h at the top of generated C files. runtime/mercury_trace.[ch]: The new runtime tracing module. The proper version will be written in Rennes, this is just for initial testing. runtime/Mmakefile: Include the new module in the runtime library. doc/user_guide.texi: Document --generate-trace.	1997-10-03 04:56:33 +00:00
Fergus Henderson	5c0582d66e	Ensure that you get a link error if you attempt to link files ... compiled with different grades. runtime/mercury_grade.h: Define a macro MR_GRADE_VAR, which is set to MR_grade_<gr>, where <gr> is one of asm_fast, asm_fast_gc_prof_tr, etc. Declare MR_GRADE_VAR as a variable. runtime/mercury_grade.c: Define the MR_GRADE_VAR variable. runtime/Mmakefile: Add references to mercury_grade.[hc]. compiler/llds_out.m: Include a reference to MR_GRADE_VAR in the generated C file. This ensures that when the file is compiled, the object file will contain a reference to MR_grade_<gr>.	1997-10-02 00:11:46 +00:00
Fergus Henderson	1f4dc56f91	Fix some bugs in the stuff for building windows DLLs. ... Estimated hours taken: 1 boehm_gc/Makefile: boehm_gc/Mmakefile: library/Mmakefile: runtime/Mmakefile: Fix some bugs in the stuff for building windows DLLs.	1997-09-29 18:13:36 +00:00
Fergus Henderson	1cd5b6dad9	Match $(GRADE) against *.gc*' rather than *.gc', so that it ... runtime/Mmakefile: library/Mmakefile: compiler/Mmakefile: profiler/Mmakefile: Match $(GRADE) against `*.gc*' rather than `*.gc', so that it will link in the GC library for grades such as `asm_fast.gc.tr'.	1997-09-14 04:06:39 +00:00
Tyson Dowd	a34557e996	Changes to installation to ease package creation for Debian. ... Estimated hours taken: 1 Changes to installation to ease package creation for Debian. Mmake.common.in: Add a FINAL_INSTALL_PREFIX variable (and various other FINAL_INSTALL_* variables). The FINAL variables should be used for any hardcoded paths that will be used in the installation process, so that the installation can be put into a temporary directory, (by overriding INSTALL_PREFIX on the command line) then moved into its final destination later. In particular, shared library paths need to be treated this way. library/Mmakefile: runtime/Mmakefile: Use FINAL_INSTALL_* variables for shared library paths.	1997-09-11 07:05:00 +00:00
Fergus Henderson	c6af510323	Implement support for DLLs on Windows. ... Estimated hours taken: 24 Implement support for DLLs on Windows. The changes consisted of 1. Adding `Makefile.DLLs', which is a file I wrote contains GNU Make rules for building DLLs. Making sure that the various Mmakefiles include that one. 2. Making sure we #include the "libfoo_dll.h" header file generated by `Makefile.DLLs' before every place that references a global variable. 3. Making sure that code which defines the DLLs is compiled with -Dlibfoo_DEFINE_DLL. 5. Changing various places to explicitly register the data segment as a root set with the conservative garbage collector. This was necessary to get GC working with DLLs under Windows (there doesn't seem to be any way of automatically finding the data segments of DLLs under win32). 6. Changing the way names are mangled to ensure that the assembler names always contain a leading underscore, since `dlltool' on gnu-win32 requires this. TODO: - Document how users can create their own DLLs. - Add support for that to Mmake. configure.in: Mmake.common.in: Add USE_DLLS variable. (Most of the Makefile changes below are conditionalized on this variable.) boehm_gc/Makefile: Add dependency $(OBJS) : libgc_dll.h. Add `-DGC_DEFINE_DLL' to CFLAGS. Include Mmakefile.DLLs. Add new targets `dll' and `test_dll'. boehm_gc/Mmakefile: Add stuff to install libgc_dll.h and libgc_globals.h. boehm_gc/gc.h: For __CYGWIN32__, #include "libgc_dll.h". This is necessary to handle global variables in DLLs on Windows. For __CYGWIN32__, define GC_INIT() to add the data segment of the current DLL or executable as a new root set. library/Mmakefile: Add stuff needed for building DLLs. runtime/wrapper.mod: library/io.m: Add call to GC_INIT() to register the root set for libmer.dll and libmercury.dll respectively. In wrapper.mod, move the call to GC_is_visible _after_ the calls to GC_INIT(). runtime/Mmakefile: Add stuff needed for building DLLs. runtime/init.h: runtime/imp.h: runtime/dummy.c: runtime/label.c: runtime/memory.c: runtime/table.c: For __CYGWIN32__, make sure we #include "libmer_dll.h". before defining global variables. This is necessary to handle global variables in DLLs on Windows. runtime/goto.h: util/mdemangle.c: prof/demangle.m: Change the way names are mangled to ensure that the assembler names always contain a leading underscore, since `dlltool' on gnu-win32 requires this. util/mkinit.c: For __CYGIN32__, when using DLLs, make sure we initialize the _impure_ptr of the DLLs that we're using. library/Mmake: runtime/Mmake: Compile with -Dlibfoo_USE_DLL options. Add code to install libfoo_dll.h and libfoo_globals.h. Include Mmakefile.DLLs.	1997-08-28 17:52:54 +00:00
Fergus Henderson	d21f5cedf3	Generalize the current support for trailing. ... Estimated hours taken: 8 Generalize the current support for trailing. Previously, the trail was hardwired, either for interfacing to CLP(R), or (in my alternative not-checked-in version) for backtrackable destructive arrays. But it couldn't handle both of these at the same time and it couldn't be extended. So we have replaced this with a more generic trail. The trail has two sorts of entries, value trail entries and function trail entries. runtime/mercury_trail.h: runtime/mercury_trail.c: New files. They provide macros MR_trail_value(), MR_trail_function(), etc. which are the new interface to the Mercury trail. (All the trailing stuff is done inside `#ifdef MR_USE_TRAIL'.) These files also implement the save_ticket(), restore_ticket(), and discard_ticket() macros that are used in the C code that the Mercury compiler generates, except that I've renamed them and changed the interface slightly. These files also define the trail memory zone MR_trail_zone, and the new virtual machine registers MR_trail_ptr and MR_ticket_counter. (Perhaps these should instead be in memory.c and regs.h respectively?) runtime/mercury_solver_backtrack.h: Deleted, since this file has been replaced by mercury_trail.h. runtime/imp.h: #include "mercury_trail.h" rather than "mercury_solver_backtrack.h" runtime/Mmakefile: Add mercury_trail.c and mercury_trail.h. Remove mercury_solver_backtrack.h. runtime/context.h: Add new fields to the Context struct to hold MR_trail_zone, MR_trail_ptr and MR_ticket_counter. Add code to handle these in save_context()/load_context(). runtime/context.mod: Add code to new_context() to initialize the trail. runtime/wrapper.h: runtime/wrapper.mod: runtime/memory.c: Add code to handle setting the trail size via the MERCURY_OPTIONS environment variable. Remove old stuff to support the solver_stack. runtime/wrapper.mod: runtime/regs.h: runtime/regorder.h: Count the usage of the new virtual machine registers MR_trail_ptr and MR_ticket_counter. (Currently they are implemented just as global variables, not registers.)	1997-08-23 22:34:18 +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
Tyson Dowd	56979ec94c	Allow the names of higher order types to be generated. ... Estimated hours taken: 5 Allow the names of higher order types to be generated. LIMITATIONS: Document limitations introduced by this change. compiler/polymorphism.m: Map higher order predicates to pred/0 and functions to func/0. library/mercury_builtin.m: Move base_type_* for pred/0 out of library (into runtime). library/std_util.m: Check for pred/0 and func/0 when comparing type infos. Create different ctor_infos for higher order preds, decode them correctly for args and functors when needed. Print functions nicely (eg func(foo) = bar). Fix ML_create_type_info so it works correctly with higher order types. runtime/type_info.h: Define macros to deal with new representation of higher order ctor_infos. runtime/deep_copy.c: Fix make_type_info so it works correctly with higher order types. runtime/Mmakefile: runtime/type_info.mod: Add definitions for pred/0 and func/0 in runtime, they are needed by deep copy. tests/hard_coded/Mmake: tests/hard_coded/higher_order_type_manip.exp: tests/hard_coded/higher_order_type_manip.m: Test case for this change.	1997-07-16 15:57:00 +00:00
Fergus Henderson	715634e5ef	Fix a problem with shared libraries on Linux. ... They weren't working because Linux requires the `-rpath' option be specified when linking the shared libraries, as well as when linking executables. Previously we only passed `-rpath' option when linking executables. configure.in: Mmake.common.in: bindist/bindist.build_vars.in: Add new configuration variables for handling `-rpath' or `-R' options: EXE_RPATH_OPT, EXE_RPATH_SEP, SHLIB_RPATH_OPT, and SHLIB_RPATH_SEP. scripts/ml.in: Rewrite the system-specific code for handling rpaths to instead use the new rpath configuration variables. library/Mmakefile: runtime/Mmakefile: When linking shared libraries that depend on other shared libraries, pass appropriate rpath options using the rpath configuration variables.	1997-06-16 13:35:34 +00:00
Fergus Henderson	ec9291a1dc	Replace the body of the `conf.h : conf.h.date' rule, ... Estimated hours taken: 0.1 runtime/Mmakefile: Replace the body of the `conf.h : conf.h.date' rule, which used to be blank, with `@true', because recent versions of GNU Make don't handle the blank rule the way we want them to (they don't recheck the file's timestamp).	1997-05-30 15:33:34 +00:00
Bert Thompson	a4989d101e	tags target now produces C tags for headers also. ... Estimated hours taken: 0.1 runtime/Mmakefile: tags target now produces C tags for headers also.	1997-05-26 11:55:03 +00:00
David Overton	4bf71fa904	Add new predicate `float__hash' to the standard library for computing a ... Estimated hours taken: 4 Add new predicate `float__hash' to the standard library for computing a non-negative integer hash value for a float. Add a C function to the runtime to do the actual hashing. This function is in the runtime so that it can be called from both the library and from C code generated for `pragma fact_table' indexing. library/float.m Add a new predicate `float__hash' that calls the runtime function `hash_float()'. runtime/mercury_float.h Add a declaration for `hash_float()'. runtime/mercury_float.c Add new file mercury_float.c for runtime code related to floats. Add a new function `hash_float()' for hashing floats.	1997-02-28 05:25:52 +00:00
Fergus Henderson	3295677d86	Ignore context.c (since it's automatically generated from context.mod). ... Estimated hours taken: 0.1 runtime/.cvsignore: Ignore context.c (since it's automatically generated from context.mod). runtime/Mmakefile: In the rule for check_headers, remove the temp file when we've finished.	1997-02-19 05:47:54 +00:00
Fergus Henderson	ddb73722b9	Rename all the Mmake' files as Mmakefile'. This is necessary to ... avoid confusion between `Mmake' and `mmake' on case-insensitive file systems.	1997-02-13 21:38:45 +00:00