mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-12 12:26:29 +00:00
Code Issues Projects Releases Wiki Activity
Files
41e75fcc78e8a2d7fa88efb34ca76ae4ebb1f3a9
mercury/runtime/mercury_conf_param.h
Zoltan Somogyi f6fafa150d Fix Mantis bug 314 for temp frames created by nondet procedures. 
Also fix some bugs in related code, and improve the related debugging
infrastructure.

-------------------

runtime/mercury_stacks.[ch]:
   Fix bug 314 for temp frames created by nondet procedures. The fix will
   probably also work for *det* procedures that create temp frames on the
   nondet stack, but I can't think of a way to test that, because det
   procedures create such frames only in very specific circumstances,
   and I cannot think of a way to nest a recursive call inside those
   circumstances.

   The problem was that when we were creating new temp frames on
   the nondet stack, we did not check whether the current nondet stack segment
   had room for them. We now do.

   The stack trace tracing code needs to know the size of each nondet stack
   frame, since it uses the size to classify frames as temp or ordinary.
   The size is given by the difference in address between the address of the
   frame and the address of the previous frame. This difference would yield
   an incorrect size and hence an incorrect frame classification if a temp
   frame were allowed to have a frame on a different segment as its
   immediate predecessor.

   We prevent this by putting an ordinary (i.e. non-temp) frame at the bottom
   of every new nondet stack segment as a sentinel. We hand-build this frame,
   since it is not an "ordinary" ordinary frame. It is not created by a call,
   so it has no meaningful success continuation, and since it does not make
   any calls, no other frame's success continuation can point to it either.

   If backtracking reaches this sentinel frame, we use this fact to free
   all the segments beyond the one the sentinel frame is in, but keep the
   frame the sentinel frame is in, since we are likely to need it again.

   Document the reason why MR_incr_sp_leaf() does not have to check
   whether a new stack segment is needed. (See the fix to llds_out_instr.m
   below.)

runtime/mercury_stack_trace.[ch]:
   When traversing the nondet stack, treat the sentinel frame specially.
   We have to, since it is an ordinary frame (i.e. it is not a temp frame),
   but it is not an "ordinary" ordinary frame: it does not make calls,
   and hence calls cannot return to it, and it does not return to any
   other frame either. It therefore does not have the layout structures
   (label and proc) that the nondet stack traversal expects to find.

   Fix an old bug: the nondet stack traversal used a simple directional
   pointer comparison to check whether it has reached the bottom of the nondet
   stack. This is NOT guaranteed to work in the presence of stack segments:
   depending on exactly what addresses new stack segments get, a stack frame
   can have an address BELOW the address of the initial stack frame
   even if it is logically ABOVE that stack frame.

   Another old bug was that a difference between two pointers, which could
   be 64 bit, was stored in an int, which could be 32 bit.

   The nondet stack traversal code used a similar directional comparison
   to implement optionally stopping at an arbitrary point on the nondet stack.
   Fixing this facility (the limit_addr parameter of MR_dump_nondet_stack)
   while preserving reasonable efficiency would not be trivial, but it would
   also be pointless, since the facility is not actually used. This diff
   deletes the parameter instead.

   Move some loop invariant code out of its loop.

trace/mercury_trace_cmd_developer.c:
trace/mercury_trace_external.c:
   Don't pass the now-deleted parameter to mercury_stack_trace.c.

runtime/mercury_wrapper.c:
   Record the zone of the initial nondet stack frame, since the fix
   of mercury_stack_trace.c needs that info, and it is much more efficient
   to set it up just once.

tests/hard_coded/bug314.{m,exp}:
   The regression test for this bug.

tests/hard_coded/Mercury.options:
   Compile the new test case with the options it needs.

tests/hard_coded/Mmakefile:
   Enable the new test case.

-------------------

runtime/mercury_wrapper.c:
   The compiler knows the number of words in a stack frame it is creating,
   not necessarily the number of bytes (though it could put bounds on that
   from the number of tag bits). Since this size must sync with the runtime,
   change the runtime's variable holding this size to also be in words.

   Note that similar changes would also be beneficial for other sizes.

compiler/llds_out_instr.m:
   Conform to the change in mercury_wrapper.c, fixing an old bug
   (mercury_wrapper.c reserved 128 BYTES for leaf procedures, but
   llds_out_instr.m was using that space for procedures whose frames
   were up to 128 WORDS in size.)

compiler/mercury_memory.c:
   Conform to the change in mercury_wrapper.c.

-------------------

runtime/mercury_memory_zones.h:
   Instead of starting to use EVERY zone at a different offset, do this
   only for the INITIAL zones in each memory area, since only on these
   is it useful. When the program first starts up, it WILL be using
   the initial parts of the det stack, nondet stack and heap, so it is
   useful to make sure that these do not collide in the cache. However,
   when we allocate e.g. the second zone in e.g. the nondet stack, we are
   no more likely to be beating on the initial part of any segment
   of the det stack than on any other part of such segments.

   If a new debug macro, MR_DEBUG_STACK_SEGMENTS_SET_SIZE is set (to an int),
   use only that many words in each segment. This allows the segment switchover
   code to be exercised and debugged with smaller test cases.

runtime/mercury_conf_param.h:
   Document the MR_DEBUG_STACK_SEGMENTS_SET_SIZE macro.

   Convert this file to four-space indentation with tabs expanded.

-------------------

runtime/mercury_overflow.h:
   Make abort messages from overflows and underflows more useful by including
   more information.

runtime/mercury_overflow.c:
   Add a new function to help with the better abort messages.
   Since this file did not exist before, create it.

runtime/Mmakefile:
   Add the new source file to the list of source files.

-------------------

runtime/mercury_debug.[ch]:
   Fix problems with the formatting of the debugging output from existing
   functions.

   Add new functions for dumping info about memory zones.

   Factor out some common code.

   Convert the header file to four-space indentation.

-------------------

runtime/mercury_grade.c:
   Generate an error if stack segments are specified together with stack
   extension

-------------------

trace/.gitignore:
util/.gitignore:
tests/debugger/.gitignore:
   List some more files.

-------------------

runtime/mercury_context.c:
runtime/mercury_engine.[ch]:
runtime/mercury_misc.h:
compiler/notes/failure.html:
   Fix white space.
2014-04-18 02:02:35 +10:00

1144 lines
37 KiB
C
Raw Blame History

/*
** vim: ts=4 sw=4 expandtab
*/
/*
** Copyright (C) 1997-2007, 2009-2011 The University of Melbourne.
** This file may only be copied under the terms of the GNU Library General
** Public License - see the file COPYING.LIB in the Mercury distribution.
*/
/*
** mercury_conf_param.h:
** Defines various configuration parameters.
**
** Configuration parameters fall into three groups.
** They can be set automatically by autoconf.
** They can be passed on the command line (e.g. the mgnuc script
** sets some options based on the grade).
** Or their values can be implied by the settings of other parameters.
**
** The ones defined in mercury_conf.h are determined by autoconf.
** The remainder are documented and/or defined by this file,
** #included by mercury_conf.h.
*/
/*
** IMPORTANT NOTE:
** This file must not contain any #include statements,
** and may not define any global variables,
** for reasons explained in mercury_imp.h.
** This file should contain _only_ configuration macros.
*/
#ifndef MERCURY_CONF_PARAM_H
#define MERCURY_CONF_PARAM_H
/*---------------------------------------------------------------------------*/
/*
** Win32 API specific.
*/
/*
** MR_WIN32
** The Win32 API is available.
**
** MR_WIN32_GETSYSTEMINFO
** Is GetSystemInfo() available?
**
** MR_BROKEN_ST_INO
** Is the st_ino field of `struct stat' junk? Windows doesn't fill in
** this field correctly.
*/
#ifdef _WIN32
#define MR_WIN32
#define MR_WIN32_GETSYSTEMINFO
#define MR_WIN32_GETPROCESSTIMES
#define MR_BROKEN_ST_INO
#endif
/*---------------------------------------------------------------------------*/
/*
** Mac OS X specific.
*/
#if defined(__APPLE__) && defined(__MACH__)
#define MR_MAC_OSX
#endif
/*---------------------------------------------------------------------------*/
/*
** MinGW specific.
*/
/*
** NOTE: __MINGW32__ is defined on both 32- and 64-bit MinGW.
*/
#if defined(__MINGW32__)
#define MR_MINGW
#endif
#if defined(__MINGW64__)
#define MR_MINGW64
#endif
/*
** On x86_64-w64-mingw32, we need to define the macro __USE_MINGW_ANSI_STDIO
** in order to ensure that we get versions of printf, sprintf and friends
** that work properly with long long format specifiers.
*/
#if defined(__MINGW64__) && !defined(__USE_MINGW_ANSI_STDIO)
#define __USE_MINGW_ANSI_STDIO 1
#endif
/*---------------------------------------------------------------------------*/
/*
** Cygwin specific.
*/
#if defined(__CYGWIN__)
#define MR_CYGWIN
#endif
/*---------------------------------------------------------------------------*/
/*
** Solaris/SunOS specific.
*/
#if defined(__sun)
#define MR_SOLARIS
#endif
/*---------------------------------------------------------------------------*/
/*
** C compilers.
*/
/*
** MR_CLANG
** The C compiler is clang.
**
** MR_GNUC
** The C compiler is GCC.
** The value of this macro gives the major version number.
** We use this macro instead of __GNUC__ since clang also defines __GNUC__.
**
** MR_MSVC
** The C compiler is Visual C.
** The value of this macro gives the version number.
*/
#if defined(__clang__)
#define MR_CLANG __clang__
#elif defined(__GNUC__)
#define MR_GNUC __GNUC__
#elif defined(_MSC_VER)
#define MR_MSVC _MSC_VER
#endif
/*---------------------------------------------------------------------------*/
/*
** Documentation for configuration parameters which can be set on the
** command line via `-D'.
*/
/*
** Code generation options:
**
** MR_HIGHLEVEL_CODE
** MR_HIGHLEVEL_DATA
** MR_USE_GCC_NESTED_FUNCTIONS
** MR_USE_GCC_GLOBAL_REGISTERS
** MR_USE_GCC_NONLOCAL_GOTOS
** MR_USE_ASM_LABELS
** MR_CONSERVATIVE_GC (= boehm_gc *or* MPS)
** MR_BOEHM_GC
** MR_HGC
** MR_MPS_GC
** MR_NATIVE_GC
** MR_NO_TYPE_LAYOUT
** MR_BOXED_FLOAT
** MR_USE_TRAIL
** MR_USE_MINIMAL_MODEL_STACK_COPY
** MR_USE_MINIMAL_MODEL_OWN_STACKS
** MR_MINIMAL_MODEL_DEBUG
** MR_PREGENERATED_DIST
** MR_USE_SINGLE_PREC_FLOAT
** MR_EXTEND_STACKS_WHEN_NEEDED
** MR_STACK_SEGMENTS
** MR_TRAIL_SEGMENTS
** MR_INLINE_ALLOC
** MR_PIC_REG
** MR_HIGHTAGS
** MR_TAGBITS
** MR_USE_REGIONS
** MR_RBMM_DEBUG
** MR_RBMM_PROFILING
** See the documentation for
** --high-level-code
** --high-level-data
** --gcc-nested-functions
** --gcc-global-registers
** --gcc-non-local-gotos
** --gcc-asm-labels
** --gc conservative
** --gc accurate
** --no-type-layout
** --unboxed-float
** --use-trail
** --reserve-tag
** --use-minimal-model
** --minimal-model-debug
** --pregenerated-dist
** --single-prec-float
** --extend-stacks-when-needed
** --stack-segments
** --trail-segments
** --inline-alloc
** --pic-reg
** --tags
** --num-tag-bits
** --use-regions
** --use-regions-debug
** --use-regions-profiling
** (respectively) in the mmc help message or the Mercury User's Guide.
**
** MR_PIC
** The generated object code must be position independent.
** See runtime/mercury_goto.h.
**
** MR_USE_REGPARM
** For the MLDS back-end (i.e. MR_HIGHLEVEL_CODE),
** on x86, use a different (more efficient) calling convention.
** This requires the use a version of gcc more recent than gcc 2.95.2.
** For details, see the definition of the MR_CALL macro in
** runtime/mercury_std.h.
**
** MR_THREAD_SAFE
** Enable support for parallelism.
**
** MR_THREADSCOPE
** Enable support for parallelism profiling, aka 'threadscope'. This is a
** grade component. This works only with the low level C parallel grades.
**
** MR_PROFILE_PARALLEL_EXECUTION_SUPPORT
** Enable support for profiling the parallel runtime system. This collects
** counts and timings of certain runtime events. It is implied by
** MR_THREADSCOPE and must be enabled at runtime with the
** --profile-parallel-execution runtime option.
**
** MR_NO_BACKWARDS_COMPAT
** Disable backwards compatibility with C code using obsolete low-level
** constructs, e.g. referring to variables and macros without their MR_
** prefixes.
**
** MR_NO_CONF_BACKWARDS_COMPAT
** Disable backwards compatibility with C code using obsolete
** configuration macros without MR_ prefixes.
**
** MR_EXTRA_BACKWARDS_COMPAT
** Add extra backwards compatibility with C code using obsolete low-level
** constructs, e.g. referring to variables and macros without their MR_
** prefixes.
**
** MR_CHECK_DU_EQ
** When unifying or comparing two values of discriminated union types,
** check first whether the values (which are usually pointers) are equal.
**
** MR_DISABLE_CHECK_DU_EQ
** MR_CHECK_DU_EQ is turned on by default; this macro prevents this.
*/
/*
** Runtime checking options:
**
** MR_CHECK_FOR_OVERFLOW
** (Implied by MR_LOWLEVEL_DEBUG.)
** Check for overflow of the various memory
** areas, e.g. heap, det stack, nondet stack,
** before every access that might result in overflow.
** Causes the generated code to become bigger and less efficient.
** Slows down compilation.
**
** Normally MR_CHECK_FOR_OVERFLOW is not set, since
** we trap overflows using mprotect().
**
** MR_CHECK_TYPECLASS_REFS
** Check for improper use of typeclass_infos and base_typeclass_infos.
**
** MR_INCLUDE_SWITCH_DEFAULTS
** When performing switches over enum types defined in the runtime,
** include a default case even if the switch is complete, to guard against
** e.g. memory corruption of the switched-ondata item taking it outside
** the legal range of that enum.
*/
/*
** Debugging options:
**
** MR_STACK_TRACE
** Require the inclusion of the layout information needed by error/1
** and the debugger to print stack traces. Set from the values of
** MR_EXEC_TRACE and MR_DEEP_PROFILING.
**
** MR_EXEC_TRACE
** Require that all Mercury procedures linked in should be compiled
** with at least interface tracing. This effect is achieved by including
** MR_EXEC_TRACE in the mangled grade (see mercury_grade.h).
**
** MR_DECL_DEBUG
** Require that all Mercury procedures linked in should be compiled
** with a trace level that supports declarative debugging. This effect
** is achieved by including MR_DECL_DEBUG in the mangled grade
** (see mercury_grade.h).
**
** Setting MR_DECL_DEBUG requires MR_EXEC_TRACE to be set also.
**
** MR_SS_DEBUG
** Enable source-to-source debugging on all Mercury procedures.
** This effect is achieved by including MR_SS_DEBUG in the mangled
** grade (see mercury_grade.h).
**
** MR_TRACE_COUNT_DEBUG
** Enables runtime checking of the invariants involving the implementation
** of the --trace-count runtime option.
**
** MR_EXEC_TRACE_INFO_IN_CONTEXT
** (Implied by MR_USE_MINIMAL_MODEL_OWN_STACKS.)
** Allows the debugger to distinguish between different contexts.
** Currently used only by own stack minimal model tabling.
**
** MR_LOWLEVEL_DEBUG
** Enables various low-level debugging stuff,
** that was in the distant past used to debug
** the low-level code generation.
** Causes the generated code to become VERY big and VERY inefficient.
** Slows down compilation a LOT.
**
** MR_DEEP_PROFILING_LOWLEVEL_DEBUG
** Enables the debugging of the code that builds the deep profiling graph.
**
** MR_DEEP_PROFILING_DEBUG
** Enables the debugging of the code that writes out deep profiling data
** files by also printing out the same information in a human readable
** form.
**
** MR_DEEP_PROFILING_DETAIL_DEBUG
** Enables the debugging of the code that writes out the atomic components
** (integers, strings, pointers, etc) of the deep profiling data
** structures.
**
** MR_DEEP_PROFILING_LOG
** Enables the code that writes out a log of the actions of the deep
** profiling code.
**
** MR_DEBUG_DD_BACK_END
** Enables low-level debugging messages on the operation of the
** declarative debugging back end.
**
** MR_DEBUG_GOTOS
** (Implied by MR_LOWLEVEL_DEBUG.)
** Enables low-level debugging of gotos.
** Causes the generated code to become bigger and less efficient.
** Slows down compilation.
**
** MR_DEBUG_HEAP_ALLOC
** (Implied by MR_LOWLEVEL_DEBUG.)
** Uses functions to do memory allocation. These functions can generate
** diagnostic output, enforce invariants, and one can put breakpoints
** on them.
**
** MR_DEBUG_AGC_SCHEDULING
** Display debugging information while scheduling accurate garbage
** collection (for the low-level back-end).
**
** MR_DEBUG_AGC_FORWARDING
** Display debugging information when leaving or finding forwarding
** pointers during accurate garbage collection.
**
** MR_DEBUG_AGC_SAVED_HPS
** Display debugging information about saved heap pointers
** during accurate garbage collection.
**
** MR_DEBUG_AGC_PRINT_VARS
** Display the values of live variables during accurate garbage
** collection.
**
** MR_DEBUG_AGC_SMALL_HEAP
** Use a small heap (52k) to trigger garbage collection more often.
** This is the same as setting MERCURY_OPTIONS="--heap-size 52".
**
** MR_DEBUG_AGC_ALL
** Turn on all debugging information for accurate garbage collection.
** (Equivalent to all MR_DEBUG_AGC_* macros above).
**
** Note that general debugging information about accurate garbage collection
** is printed if -dG is included in MERCURY_OPTIONS. This works even if
** none of the MR_DEBUG_AGC_* macros are enabled.
**
** MR_TABLE_DEBUG
** Enables low-level debugging messages from the parts of the tabling system
** that rely on hand-written code in the runtime system's libraries.
** Low level debugging messages from code generated by the Mercury compiler,
** even if using macros defined in the runtime directory, are controlled by
** the --table-debug option of mmc.
**
** MR_DEBUG_RETRY
** Enables low-level debugging messages from retry operations in the debugger.
**
** MR_DEBUG_LABEL_NAMES
** Registers labels and their names, enabling label addresses to be converted
** back to a form in which they are usable by a developer.
** Implied by MR_DEEP_PROFILING_LOWLEVEL_DEBUG, MR_TABLE_DEBUG, and
** MR_DEBUG_RETRY.
**
** MR_DEBUG_LABEL_GOAL_PATHS
** When printing label names, print the goal path of the label as well,
** if this information is available.
** Meaningful only if MR_DEBUG_LABEL_NAMES is defined.
**
** MR_LOWLEVEL_ADDR_DEBUG
** Enables the printing of raw addresses in debugging output even for
** things (such as stack slots and labels) that can be identified by more
** human-friendly handles (such as stack offsets and label names).
**
** MR_DEBUG_JMPBUFS
** Enables low-level debugging messages from MR_call_engine and the
** code handling exceptions.
**
** MR_DEBUG_LVAL_REP
** Enables low-level debugging messages from routines concerned with
** the representation of lvals in the RTTI system.
**
** MR_DEBUG_MDPROF_SIGNAL
** Enables low-level debugging messages from the signal handling
** functions in the deep profiler.
**
** MR_STACK_EXTEND_DEBUG
** Enables low-level debugging messages when extending the stacks.
**
** MR_DEBUG_STACK_SEGMENTS
** Enables low-level debugging messages when updating the list of
** stack segments.
**
** MR_DEBUG_STACK_SEGMENTS_SET_SIZE
** If set, we reduce the effective size of each segment
** to this number of words.
**
** MR_DEBUG_TRAIL_SEGMENTS
** Enables low-level debugging messages when updating the list of
** trail segments.
**
** MR_TRACE_CHECK_INTEGRITY
** Enables the -i and --integrity options on mdb's forward movement
** commands, which cause the debugger to check the integrity of the
** representations of all the terms reachable from the stack.
**
** MR_STM_DEBUG
** Enables low-level debugging messages from the code that implements
** transactions used by software transactional memory.
**
** MR_DEBUG_DWORD_ALIGNMENT
** Enables runtime tests for misaligned double-word pointers.
*/
#ifdef MR_DEEP_PROFILING_DETAIL_DEBUG
#define MR_DEEP_PROFILING_DEBUG
#endif
/*
** Runtime code alternatives. --- Sometimes there is more than one way to do
** something, a more efficient/optimal way, and a more portable way. Use these
** options to execute the more portable code even on systems where the more
** optimal code is safe. This is useful to make test coverage a bit more even.
**
** options MR_AVOID_HANDWRITTEN_ASSEMBLER and MR_AVOID_COMPILER_INTRINSICS are
** not mutually exclusive. The first is relevant when we prefer handwritten
** assembler (in some cases this is more efficient). Where as the second is
** relevant when we prefer compiler intrinsics (usually because there's no
** advantage to handwritten assembler other than when the intrinsics are not
** supported by the compiler).
**
** MR_AVOID_HANDWRITTEN_ASSEMBLER
** Avoid using handwritten assembler in the runtime. This will usually
** default to compiler intrinsics or C code, see runtime/mercury_atomic_ops.h
**
** MR_AVOID_COMPILER_INTRINSICS
** Avoid using compiler intrinsics. This will usually fall back to hand
** written assembler, therefore it is only supported on architectures where
** hand written assembler code exists.
**
** MR_DO_NOT_USE_CPU_RELAX
** Do not compile in CPU relax instructions in spin loops; see the 'pause'
** instruction on x86. This is used when defining MR_PAUSE in
** runtime/mercury_atomic_ops.h, MR_PAUSE is used in spin-wait loops and the
** implementation of spin locks which is also in mercury_atomic_ops.h.
*/
/*
** Execution tracing and deep profiling both need stack traces, e.g.
** simulate exits from calls between an exception being thrown and being
** caught. Stack tracing is therefore automatically enabled in debugging and
** deep profiling grades.
**
** In theory, we could allow stack traces to be enabled even in non-debug,
** non-deep-profiling grades. However, if you try to do a stack trace, you
** would find it doesn't work very well unless all modules are compiled
** with stack tracing. We could define a grade for situations in which
** MR_STACK_TRACE is defined but MR_EXEC_TRACE and MR_DEEP_PROFILING aren't,
** but such a grade wouldn't be very useful. We therefore ensure that
** MR_STACK_TRACE is set iff at least one of MR_EXEC_TRACE and
** MR_DEEP_PROFILING is set.
*/
#ifdef MR_STACK_TRACE
#error "MR_STACK_TRACE set independently"
#endif
#if defined(MR_EXEC_TRACE) || defined(MR_DEEP_PROFILING)
#define MR_STACK_TRACE
#endif
#ifdef MR_HIGHLEVEL_CODE
#ifdef MR_LOWLEVEL_DEBUG
#error "MR_HIGHLEVEL_CODE and MR_LOWLEVEL_DEBUG are not supported together"
#endif
#ifdef MR_DEBUG_DD_BACK_END
#error "MR_HIGHLEVEL_CODE and MR_DEBUG_DD_BACK_END are not supported together"
#endif
#ifdef MR_DEBUG_GOTOS
#error "MR_HIGHLEVEL_CODE and MR_DEBUG_GOTOS are not supported together"
#endif
#ifdef MR_DEBUG_LABEL_NAMES
#error "MR_HIGHLEVEL_CODE and MR_DEBUG_LABEL_NAMES are not supported together"
#endif
#ifdef MR_LOWLEVEL_ADDR_DEBUG
#error "MR_HIGHLEVEL_CODE and MR_LOWLEVEL_ADDR_DEBUG are not supported together"
#endif
#ifdef MR_DEBUG_LVAL_REP
#error "MR_HIGHLEVEL_CODE and MR_DEBUG_LVAL_REP are not supported together"
#endif
#endif
#if MR_DEBUG_AGC_ALL
#define MR_DEBUG_AGC_SCHEDULING
#define MR_DEBUG_AGC_COLLECTION
#define MR_DEBUG_AGC_FORWARDING
#define MR_DEBUG_AGC_SAVED_HPS
#define MR_DEBUG_AGC_PRINT_VARS
#define MR_DEBUG_AGC_SMALL_HEAP
#endif
/*
** MR_LABEL_STRUCTS_INCLUDE_NUMBER
** Include a label number in each label layout structure.
*/
/*
** Profiling options:
**
** MR_MEASURE_REGISTER_USAGE
** Enable this if you want to measure the number of times each register
** is used. (Note that the measurement includes uses which occur inside
** debugging routines, so to get an accurate count you should not also
** enable low-level debugging.)
**
** MR_DO_CALL_STATS
** Enable this is you want to collect statistics about the number of arguments
** hidden inside closures. The stats will be appended to the file named by the
** HO_CALL_STATS environment variable.
**
** MR_MPROF_PROFILE_CALLS
** Enables call count profiling for mprof.
**
** MR_MPROF_PROFILE_TIME
** Enables time profiling for mprof.
**
** MR_MPROF_PROFILE_MEMORY
** Enables profiling of memory usage for mprof.
**
** MR_DEEP_PROFILING
** Enables deep profiling.
**
** MR_RECORD_TERM_SIZES
** Augments heap cells with an extra word recording the size of the term.
** For implementors only.
**
** MR_RECORD_TERM_SIZES_AS_CELLS
** Record the size of the term as the number of heap cells it occupies.
** If MR_RECORD_TERM_SIZES_AS_CELLS is not defined, the default is
** to record term sizes as the number of heap words. Meaningful only if
** MR_RECORD_TERM_SIZES is defined. For implementors only.
**
** MR_DEEP_PROFILING_EXPLICIT_CALL_COUNTS
** If defined, we explicitly record the number of calls in each
** call_site_dynamic, instead of computing it from the other port counts.
** Useful only for measuring the overhead of the recording. Defining this macro
** makes the generated Deep.data files incompatible with the assumptions
** of read_profile.m and measurements.m in the deep_profiler directory.
** For implementors only.
**
** MR_DEEP_PROFILING_PERF_TEST
** Allows the selective performance testing of various aspects of deep
** profiling. For implementors only.
**
** MR_USE_ACTIVATION_COUNTS
** Selects the activation counter approach to deep profiling over the
** save/restore approach (the two approaches are documented in the deep
** profiling paper). For implementors only.
*/
#ifdef MR_HIGHLEVEL_CODE
/*
** Neither deep profiling nor term size profiling are supported on the
** high level C backend (yet).
*/
#ifdef MR_DEEP_PROFILING
#error "MR_HIGHLEVEL_CODE and MR_DEEP_PROFILING both defined"
#endif
#ifdef MR_RECORD_TERM_SIZES
#error "MR_HIGHLEVEL_CODE and MR_RECORD_TERM_SIZES both defined"
#endif
#endif
/*
** Experimental options:
**
** MR_TRACE_HISTOGRAM
** Enable this if you want to count the number of execution tracing events
** at various call depths.
**
** MR_TYPE_CTOR_STATS
** If you want to keep statistics on the number of times the generic unify,
** index and compare functions are invoked with various kinds of type
** constructors, then set this macro to a string giving the name of the file
** to which the statistics should be appended when the program exits.
** Note that calls to the generic compare_representation are counted as
** calls to compare.
**
** MR_TABLE_STATISTICS
** Enable this if you want to gather statistics about the operation of the
** tabling system. The results are reported via io__report_tabling_stats.
**
** MR_STACK_FRAME_STATS
** If you want to gather statistics about the number and size of stack frames,
** then set this macro to a string giving the name of the file to which
** the statistics should be appended when the program exits.
**
** MR_COMPARE_BY_RTTI
** Enable this if you want to perform unifications and comparisons on types
** with standard equality by interpreting the RTTI data structures instead of
** invoking the type-specific unify and compare procedures. The last time we
** measured it, this lead to about a 6% slowdown. Since the code interpreting
** the data structures calls C functions, defining this macro also leads to
** problems if user-defined unify procedures abort: the exception could be
** transmitted to the parent Mercury code only by catching and retransmitting
** it, which, for efficiency reasons, the code doesn't do.
**
** MR_UNCONDITIONAL_STRUCTURE_REUSE
** Enable this to bypass the check that a cell was allocated by Boehm GC
** before reusing it.
**
** MR_RBMM_USE_MACROS
** By default, all RBMM operations are implemented by functions, but if
** this macro is enabled, we implement this with macros. Macros avoid the
** overhead of function calls, but in large programs, having lots of copies
** of the macro body will have a negative impact on locality, because we can
** expect many copies to not be in the instruction cache, while function
** bodies called from all over the place definitely should stay in the
** instruction cache.
*/
#if defined(MR_THREAD_SAFE) && defined(MR_TRACE_HISTOGRAM)
#error "MR_THREAD_SAFE and MR_TRACE_HISTOGRAM are not supported together"
#endif
#if defined(MR_THREAD_SAFE) && defined(MR_TYPE_CTOR_STATS)
#error "MR_THREAD_SAFE and MR_TYPE_CTOR_STATS are not supported together"
#endif
#if defined(MR_THREAD_SAFE) && defined(MR_TABLE_STATISTICS)
#error "MR_THREAD_SAFE and MR_TABLE_STATISTICS are not supported together"
#endif
#if defined(MR_THREAD_SAFE) && defined(MR_STACK_FRAME_STATS)
#error "MR_THREAD_SAFE and MR_STACK_FRAME_STATS are not supported together"
#endif
/*
** Neither form of the minimal model tabling works if the system recovers
** memory allocated after a choice point when backtracking to that choice
** point. This rules out the use of the native Mercury collector, as well as
** the absence of a collector. (This may change for the own stack model,
** with more work.)
*/
#if defined(MR_USE_MINIMAL_MODEL_STACK_COPY) && !defined(MR_CONSERVATIVE_GC)
#error "MR_USE_MINIMAL_MODEL_OWN_STACKS requires MR_CONSERVATIVE_GC"
#endif
#if defined(MR_USE_MINIMAL_MODEL_OWN_STACKS) && !defined(MR_CONSERVATIVE_GC)
#error "MR_USE_MINIMAL_MODEL_OWN_STACKS requires MR_CONSERVATIVE_GC"
#endif
/*
** If the execution engine uses multiple contexts, we want separate event
** counters, call counters and depth counters in each context. Currently,
** we use multiple contexts only in parallel grades, for which the debugger
** doesn't (yet) work, and in own stack minimal model grades.
*/
#ifdef MR_USE_MINIMAL_MODEL_OWN_STACKS
#define MR_EXEC_TRACE_INFO_IN_CONTEXT
#endif
#ifdef MR_MINIMAL_MODEL_DEBUG
#define MR_TABLE_STATISTICS
#endif
/*---------------------------------------------------------------------------*/
/*
** Settings of configuration parameters which can be passed on
** the command line, but which are also implied by other parameters.
*/
/*
** MR_PREGENERATED_DIST overrides configured values to take values compatible
** with pre-generated C files in the source distribution.
** It implies boxed floats so is incompatible with single-precision floats,
** which imply unboxed floats.
*/
#ifdef MR_PREGENERATED_DIST
#undef MR_LOW_TAG_BITS
#define MR_LOW_TAG_BITS 2
#ifdef MR_USE_SINGLE_PREC_FLOAT
#error "MR_PREGENERATED_DIST and MR_USE_SINGLE_PREC_FLOAT both defined"
#else
#define MR_BOXED_FLOAT 1
#endif
#endif
/*
** MR_PIC means that we are generating position independent code,
** i.e. that the file was compiled with the gcc option `-fpic' or equivalent.
*/
#if (defined(__pic__) || defined(__PIC__))
#define MR_PIC 1
#endif
/*
** NOTE: MR_PIC_REG is currently unused and does not have any affect.
** The following describes what it was previously used for:
**
** Should we keep the GOT register (e.g. ebx on i386) free for PIC code?
** We need to do this if we are generating position independent code
** (MR_PIC), or if we are linking with position independent Mercury code
** (in which case -DMR_PIC_REG will be passed on the command line).
**
** The GOT register is only needed for Unix-style shared libraries.
** Windows DLLs do not use the GOT register. So don't do this if
** __CYGWIN__ or _WIN32 is defined, even if -DMR_PIC_REG was passed
** on the command line.
*/
#if defined(MR_PIC)
#define MR_PIC_REG 1
#endif
#if defined(__CYGWIN__) || defined(_WIN32)
#undef MR_PIC_REG
#endif
/* MR_LOWLEVEL_DEBUG implies MR_DEBUG_GOTOS and MR_CHECK_FOR_OVERFLOW */
#ifdef MR_LOWLEVEL_DEBUG
#define MR_DEBUG_GOTOS
#define MR_CHECK_FOR_OVERFLOW
#endif
/*
** MR_DEEP_PROFILING_PORT_COUNTS
** Enables deep profiling of port counts.
**
** MR_DEEP_PROFILING_TIMING
** Enables deep profiling of time (obtained via clock interrupt signals).
** This is not currently supported on Windows; we always disable it on that
** platform.
**
** MR_DEEP_PROFILING_CALL_SEQ
** Enables deep profiling of time (obtained by counting call sequence numbers).
**
** MR_DEEP_PROFILING_MEMORY
** Enables deep profiling of memory usage.
**
** MR_DEEP_PROFILING_COVERAGE
** Enables deep profiling code coverage support. (Required for
** auto-parallelisation).
**
** MR_DEEP_PROFILING_COVERAGE_STATIC.
** Enables the outmoded static coverage profiling code. This disables the new
** dynamic coverage profiling code.
**
** MR_DEEP_PROFILING_COVERAGE_DYNAMIC
** Enables the collection of separate coverage information for each deep
** context in which a procedure is used.
**
** This does not need to be specified explicitly, as it is the default,
** which can be overridden by MR_DEEP_PROFILING_COVERAGE_STATIC.
*/
#ifdef MR_DEEP_PROFILING
/* This is the default set of measurements in deep profiling grades. */
#define MR_DEEP_PROFILING_PORT_COUNTS
#ifndef MR_DEEP_PROFILING_PERF_TEST
#define MR_DEEP_PROFILING_TIMING
#define MR_DEEP_PROFILING_CALL_SEQ
#define MR_DEEP_PROFILING_MEMORY
#define MR_DEEP_PROFILING_COVERAGE
#ifndef MR_DEEP_PROFILING_COVERAGE_STATIC
#define MR_DEEP_PROFILING_COVERAGE_DYNAMIC
#else
#undef MR_DEEP_PROFILING_COVERAGE_DYNAMIC
#endif
#else
#ifdef MR_DEEP_PROFILING_COVERAGE
#ifndef MR_DEEP_PROFILING_COVERAGE_STATIC
#define MR_DEEP_PROFILING_COVERAGE_DYNAMIC
#else
#undef MR_DEEP_PROFILING_COVERAGE_DYNAMIC
#endif
#else
#undef MR_DEEP_PROFILING_COVERAGE_DYNAMIC
#undef MR_DEEP_PROFILING_COVERAGE_STATIC
#endif
#endif
#else
#undef MR_DEEP_PROFILING_PORT_COUNTS
#undef MR_DEEP_PROFILING_TIMING
#undef MR_DEEP_PROFILING_CALL_SEQ
#undef MR_DEEP_PROFILING_MEMORY
#undef MR_DEEP_PROFILING_COVERAGE
#undef MR_DEEP_PROFILING_COVERAGE_DYNAMIC
#undef MR_DEEP_PROFILING_COVERAGE_STATIC
#endif
#if !defined(MR_DISABLE_CHECK_DU_EQ)
#define MR_CHECK_DU_EQ
#endif
/*
** Time profiling is not currently supported on Windows.
*/
#if defined(MR_WIN32)
#undef MR_DEEP_PROFILING_TIMING
#endif
/*---------------------------------------------------------------------------*/
/*
** Configuration parameters whose values are determined by the settings
** of other configuration parameters. These parameters should not be
** set on the command line.
**
** You must make sure that you don't test the value of any of these parameters
** before its conditional definition.
*/
/*
** Both the Boehm collector and the MPS collector are conservative.
** (Well, actually MPS supports a wide spectrum of methods, including
** fully conservative, partly conservative (mostly copying),
** and fully type-accurate collection; but currently we're using
** the conservative collector part of MPS.)
**
** If MR_CONSERVATIVE_GC is defined without specifying which
** collector to use, then default to using the Boehm collector.
*/
#if defined(MR_HGC) || defined(MR_BOEHM_GC) || defined(MR_MPS_GC)
#ifndef MR_CONSERVATIVE_GC
#define MR_CONSERVATIVE_GC
#endif
#elif defined(MR_CONSERVATIVE_GC)
#define MR_BOEHM_GC
#endif
/*
** MR_MIGHT_RECLAIM_HP_ON_FAILURE should be set if the grade allows
** the heap to be reset on failure.
**
** XXX In the long run it would be nice to allow heap reclamation on
** failure with accurate GC, but this requires liveness-accuracy,
** which is not yet implemented; see the comments in the TODO list in
** compiler/ml_elim_nested.m.
*/
#if !defined(MR_CONSERVATIVE_GC) && !defined(MR_NATIVE_GC)
#define MR_MIGHT_RECLAIM_HP_ON_FAILURE
#endif
/*
** MR_RECLAIM_HP_ON_FAILURE should be set if C code in the current translation
** unit should reclaim heap on failure of a subgoal. Note that this only
**affects heap reclamation in C code, not in Mercury code; heap reclamation
** in Mercury code is determined by mmc options (e.g.
** `--reclaim-hp-on-semidet-failure') which affect the generated C code.
**
** This is defined separately from MR_MIGHT_RECLAIM_HP_ON_FAILURE because
** in theory different translation units might be compiled with different
** settings; it might be important to reclaim heap in some translation units
** but not others. But currently we always reclaim heap on failure if we can.
*/
#ifdef MR_MIGHT_RECLAIM_HP_ON_FAILURE
#define MR_RECLAIM_HP_ON_FAILURE
#endif
/* Some sanity checking */
#ifdef MR_RECLAIM_HP_ON_FAILURE
#ifndef MR_MIGHT_RECLAIM_HP_ON_FAILURE
#error "MR_RECLAIM_HP_ON_FAILURE && ! MR_MIGHT_RECLAIM_HP_ON_FAILURE"
#endif
#ifdef MR_CONSERVATIVE_GC
/*
** Heap reclamation on failure is not supported with conservative GC,
** because the conservative collectors don't provide any way to do it.
*/
#error "MR_RECLAIM_HP_ON_FAILURE and MR_CONSERVATIVE_GC both defined"
#endif
#ifdef MR_NATIVE_GC
/*
** Heap reclamation on failure is not supported with accurate GC,
** because it requires liveness accuracy, which is not yet implemented.
** See the comments in the TODO list in compiler/ml_elim_nested.m.
*/
#error "MR_RECLAIM_HP_ON_FAILURE and MR_NATIVE_GC both defined"
#endif
#endif
/*
** Static code addresses are available unless using gcc non-local gotos,
** without assembler labels.
*/
#ifdef MR_STATIC_CODE_ADDRESSES
#error "MR_STATIC_CODE_ADDRESSES should not be defined on the command line"
#endif
#if !defined(MR_USE_GCC_NONLOCAL_GOTOS) || defined(MR_USE_ASM_LABELS)
#define MR_STATIC_CODE_ADDRESSES
#endif
/*
** Whether we are in a grade which supports the low-level parallel
** conjunction execution mechanism.
*/
#ifdef MR_LL_PARALLEL_CONJ
#error "MR_LL_PARALLEL_CONJ may not be defined on the command line"
#endif
#if !defined(MR_HIGHLEVEL_CODE) && defined(MR_THREAD_SAFE)
#define MR_LL_PARALLEL_CONJ
#endif
/*
** Check that MR_THREADSCOPE is used correctly.
*/
#if defined(MR_THREADSCOPE) && !defined(MR_THREAD_SAFE)
#error "The threadscope grade component may only be used with " \
"parallel grades"
#endif
#ifdef MR_PROFILE_PARALLEL_EXECUTION_SUPPORT
#error "MR_PROFILE_PARALLEL_EXECUTION_SUPPORT may only be implied by MR_THREADSCOPE"
#endif
#ifdef MR_THREADSCOPE
#define MR_PROFILE_PARALLEL_EXECUTION_SUPPORT
#endif
/*
** Memory attribution profiling requires the procedure names from
** memory profiling and hooks in Boehm GC.
*/
#ifdef MR_MPROF_PROFILE_MEMORY_ATTRIBUTION
#error "MR_MPROF_PROFILE_MEMORY_ATTRIBUTION should not be defined " \
"on the command line"
#endif
#if defined(MR_BOEHM_GC) && defined(MR_MPROF_PROFILE_MEMORY)
#define MR_MPROF_PROFILE_MEMORY_ATTRIBUTION
#endif
/* XXX document MR_BYTECODE_CALLABLE */
/*
** MR_DEBUG_LABEL_NAMES
** We need to be able to convert code addresses into the names of the labels
** they correspond to.
*/
/* These debugging facilities require label names */
#if defined(MR_DEEP_PROFILING_LOWLEVEL_DEBUG) || defined(MR_TABLE_DEBUG) \
|| defined(MR_DEBUG_RETRY)
#define MR_DEBUG_LABEL_NAMES
#endif
/*
** MR_INSERT_LABELS
** Labels need to be inserted into the label table. (This also means the
** initialization code needs to be run some time before the first use of the
** label table).
**
** Note that for the MLDS back-end, the calls to MR_init_entry()
** that insert the function addresses in the label table are only
** output if the right compiler options are enabled. So if you change
** the condition of this `#ifdef', and you want your changes to apply
** to the MLDS back-end too, you may also need to change the
** `need_to_init_entries' predicate in compiler/mlds_to_c.m.
*/
#ifdef MR_INSERT_LABELS
#error "MR_INSERT_LABELS should not be defined on the command line"
#endif
#if defined(MR_STACK_TRACE) || defined(MR_NATIVE_GC) \
|| defined(MR_DEBUG_GOTOS) || defined(MR_BYTECODE_CALLABLE) \
|| defined(MR_DEBUG_LABEL_NAMES)
#define MR_INSERT_LABELS
#endif
/*
** MR_INSERT_ENTRY_LABEL_NAMES
** The entry label table should contain the names of labels as well as their
** addresses and layouts (label names are quite big, so prefer not to include
** them unless they are necessary).
*/
#ifdef MR_INSERT_ENTRY_LABEL_NAMES
#error "MR_INSERT_ENTRY_LABEL_NAMES should not be defined on the command line"
#endif
#if defined(MR_MPROF_PROFILE_CALLS) || defined(MR_DEBUG_GOTOS) \
|| defined(MR_DEBUG_AGC_SCHEDULING) || defined(MR_DEBUG_LABEL_NAMES)
#define MR_INSERT_ENTRY_LABEL_NAMES
#endif
/*
** MR_INSERT_INTERNAL_LABEL_NAMES
** The internal label table should contain the names of labels as well as
** their addresses and layouts (label names are quite big, so prefer not
** to include them unless they are necessary).
*/
#ifdef MR_INSERT_INTERNAL_LABEL_NAMES
#error "MR_INSERT_INTERNAL_LABEL_NAMES should not be defined on the command line"
#endif
#if defined(MR_DEBUG_GOTOS) || defined(MR_DEBUG_AGC_SCHEDULING) \
|| defined(MR_DEBUG_LABEL_NAMES)
#define MR_INSERT_INTERNAL_LABEL_NAMES
#endif
/*
** MR_NEED_ENTRY_LABEL_ARRAY
** we need an array of the procedure entry code addresses and possibly
** their label names, sorted by the code address before use.
**
** This is required by garbage collection and for some kinds of low level
** debugging.
**
** MR_NEED_ENTRY_LABEL_INFO
** we need to register procedure entry code addresses.
**
** This is required in order to construct the sorted array of procedure entry
** code addresses, to let the mprof profiling system turn program counter
** samples back into procedure names, and to let accurate gc find out the
** layout of stack frames.
*/
#if defined(MR_NATIVE_GC) || defined(MR_DEBUG_GOTOS) \
|| defined(MR_INSERT_ENTRY_LABEL_NAMES)
#define MR_NEED_ENTRY_LABEL_ARRAY
#endif
#if defined(MR_NEED_ENTRY_LABEL_ARRAY) || defined(MR_MPROF_PROFILE_CALLS)
#define MR_NEED_ENTRY_LABEL_INFO
#endif
/*
** MR_NEED_INITIALIZATION_AT_START
** The module specific initialization code must be run before any Mercury code
** is run.
**
** You need to run initialization code for grades without static code
** addresses, for profiling, and any time you need to insert labels into
** the label table.
*/
#ifdef MR_NEED_INITIALIZATION_AT_START
#error "MR_NEED_INITIALIZATION_AT_START should not be defined on the command line"
#endif
#if !defined(MR_STATIC_CODE_ADDRESSES) || defined(MR_MPROF_PROFILE_CALLS) \
|| defined(MR_MPROF_PROFILE_TIME) || defined(MR_DEBUG_LABEL_NAMES)
#define MR_NEED_INITIALIZATION_AT_START
#endif
/*
** MR_MAY_NEED_INITIALIZATION
** The module specific initialization code may be needed, either at start
** or later.
**
** You need to run initialization code for grades without static code
** addresses, for profiling, and any time you need to insert labels
** into the label table.
*/
#ifdef MR_MAY_NEED_INITIALIZATION
#error "MR_MAY_NEED_INITIALIZATION should not be defined on the command line"
#endif
#if defined(MR_NEED_INITIALIZATION_AT_START) || defined(MR_INSERT_LABELS)
#define MR_MAY_NEED_INITIALIZATION
#endif
/*---------------------------------------------------------------------------*/
/*
** Memory protection and signal handling.
*/
#if defined(MR_HAVE_SIGINFO) && defined(MR_PC_ACCESS)
#define MR_CAN_GET_PC_AT_SIGNAL
#endif
/*
** MR_CHECK_OVERFLOW_VIA_MPROTECT
** Can check for overflow of various memory zones using mprotect() like
** functionality.
*/
#if (defined(MR_HAVE_MPROTECT) && defined(MR_HAVE_SIGINFO))
#define MR_CHECK_OVERFLOW_VIA_MPROTECT
#endif
/*
** MR_PROTECTPAGE
** MR_protect_pages() can be defined to provide the same functionality
** as the system call mprotect().
*/
#if defined(MR_HAVE_MPROTECT)
#define MR_PROTECTPAGE
#endif
/*
** MR_MSVC_STRUCTURED_EXCEPTIONS
** Use Microsoft Visual C structured exceptions for signal handling.
*/
#if defined(_MSC_VER)
#define MR_MSVC_STRUCTURED_EXCEPTIONS
#endif
/*---------------------------------------------------------------------------*/
/*
** MR_HAVE_THREAD_PINNING is defined if we can pin threads, either with
** sched_setaffinity or hwloc.
*/
#if (defined(MR_HAVE_SCHED_SETAFFINITY) && \
defined(MR_HAVE_SCHED_GETAFFINITY)) || defined(MR_HAVE_HWLOC)
#define MR_HAVE_THREAD_PINNING
#endif
/*---------------------------------------------------------------------------*/
#endif /* MERCURY_CONF_PARAM_H */
Reference in New Issue View Git Blame Copy Permalink