diff options
Diffstat (limited to 'libmudflap/mf-impl.h')
| -rw-r--r-- | libmudflap/mf-impl.h | 389 |
1 files changed, 389 insertions, 0 deletions
diff --git a/libmudflap/mf-impl.h b/libmudflap/mf-impl.h new file mode 100644 index 00000000000..05120bfe4b6 --- /dev/null +++ b/libmudflap/mf-impl.h @@ -0,0 +1,389 @@ +/* Implementation header for mudflap runtime library. + Mudflap: narrow-pointer bounds-checking by tree rewriting. + Copyright (C) 2002, 2003 Free Software Foundation, Inc. + Contributed by Frank Ch. Eigler <fche@redhat.com> + and Graydon Hoare <graydon@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +In addition to the permissions in the GNU General Public License, the +Free Software Foundation gives you unlimited permission to link the +compiled version of this file into combinations with other programs, +and to distribute those combinations without any restriction coming +from the use of this file. (The General Public License restrictions +do apply in other respects; for example, they cover modification of +the file, and distribution when not linked into a combine +executable.) + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ + +#ifndef __MF_IMPL_H +#define __MF_IMPL_H + +#ifdef _MUDFLAP +#error "Do not compile this file with -fmudflap!" +#endif + +#if HAVE_PTHREAD_H +#include <pthread.h> +#elif LIBMUDFLAPTH +#error "Cannot build libmudflapth without pthread.h." +#endif + + +/* Private definitions related to mf-runtime.h */ + +#define __MF_TYPE_MAX_CEM __MF_TYPE_STACK /* largest type# for the cemetary */ +#define __MF_TYPE_MAX __MF_TYPE_GUESS + + +#ifndef max +#define max(a,b) ((a) > (b) ? (a) : (b)) +#endif + +#ifndef min +#define min(a,b) ((a) < (b) ? (a) : (b)) +#endif + +/* Address calculation macros. */ + +#define MINPTR ((uintptr_t) 0) +#define MAXPTR (~ (uintptr_t) 0) + +/* Clamp the addition/subtraction of uintptr_t's to [MINPTR,MAXPTR] */ +#define CLAMPSUB(ptr,offset) (((uintptr_t) ptr) >= (offset) ? ((uintptr_t) ptr)-((uintptr_t) offset) : MINPTR) +#define CLAMPADD(ptr,offset) (((uintptr_t) ptr) <= MAXPTR-(offset) ? ((uintptr_t) ptr)+((uintptr_t) offset) : MAXPTR) +#define CLAMPSZ(ptr,size) ((size) ? (((uintptr_t) ptr) <= MAXPTR-(size)+1 ? ((uintptr_t) ptr)+((uintptr_t) size) - 1 : MAXPTR) : ((uintptr_t) ptr)) + +#define __MF_CACHE_INDEX(ptr) ((((uintptr_t) (ptr)) >> __mf_lc_shift) & __mf_lc_mask) +#define __MF_CACHE_MISS_P(ptr,sz) ({ \ + struct __mf_cache *elem = & __mf_lookup_cache[__MF_CACHE_INDEX((ptr))]; \ + ((elem->low > (uintptr_t) (ptr)) || \ + (elem->high < (CLAMPADD((uintptr_t) (ptr), (uintptr_t) CLAMPSUB(sz,1) )))); }) +/* XXX: the above should use CLAMPSZ () */ + + + +/* Private functions. */ + +extern void __mf_violation (void *ptr, size_t sz, + uintptr_t pc, const char *location, + int type); +extern size_t __mf_backtrace (char ***, void *, unsigned); +extern int __mf_heuristic_check (uintptr_t, uintptr_t); + +/* ------------------------------------------------------------------------ */ +/* Type definitions. */ +/* ------------------------------------------------------------------------ */ + +/* The mf_state type codes describe recursion and initialization order. */ + +enum __mf_state_enum { active, reentrant }; + +/* The __mf_options structure records optional or tunable aspects of the + mudflap library's behavior. There is a single global instance of this + structure which is populated from user input (in an environment variable) + when the library initializes. */ + +struct __mf_options +{ + /* Emit a trace message for each call. */ + unsigned trace_mf_calls; + + /* Collect and emit statistics. */ + unsigned collect_stats; + + /* Set up a SIGUSR1 -> __mf_report handler. */ + unsigned sigusr1_report; + + /* Execute internal checking code. */ + unsigned internal_checking; + + /* Age object liveness periodically. */ + unsigned tree_aging; + + /* Adapt the lookup cache to working set. */ + unsigned adapt_cache; + + /* Print list of leaked heap objects on shutdown. */ + unsigned print_leaks; + + /* Detect reads of uninitialized objects. */ + unsigned check_initialization; + + /* Print verbose description of violations. */ + unsigned verbose_violations; + + /* Abbreviate duplicate object descriptions. */ + unsigned abbreviate; + + /* Emit internal tracing message. */ + unsigned verbose_trace; + + /* Support multiple threads. XXX: not yet implemented. */ + /* unsigned multi_threaded; */ + + /* Wipe stack/heap objects upon unwind. */ + unsigned wipe_stack; + unsigned wipe_heap; + + /* Maintain a queue of this many deferred free()s, + to trap use of freed memory. */ + unsigned free_queue_length; + + /* Maintain a history of this many past unregistered objects. */ + unsigned persistent_count; + + /* Pad allocated extents by this many bytes on either side. */ + unsigned crumple_zone; + + /* Maintain this many stack frames for contexts. */ + unsigned backtrace; + +#ifdef LIBMUDFLAPTH + /* Thread stack size. */ + unsigned thread_stack; +#endif + + /* Major operation mode */ + enum + { + mode_nop, /* mudflaps do nothing */ + mode_populate, /* mudflaps populate tree but do not check for violations */ + mode_check, /* mudflaps populate and check for violations (normal) */ + mode_violate /* mudflaps trigger a violation on every call (diagnostic) */ + } + mudflap_mode; + + + /* How to handle a violation. */ + + enum + { + viol_nop, /* Return control to application. */ + viol_segv, /* Signal self with segv. */ + viol_abort, /* Call abort (). */ + viol_gdb /* Fork a debugger on self */ + } + violation_mode; + + /* Violation heuristics selection. */ + unsigned heur_stack_bound; /* allow current stack region */ + unsigned heur_proc_map; /* allow & cache /proc/self/map regions. */ + unsigned heur_start_end; /* allow _start .. _end */ + unsigned heur_std_data; /* allow & cache stdlib data */ +}; + + +#ifdef PIC + +/* This is a table of dynamically resolved function pointers. */ + +struct __mf_dynamic_entry +{ + void *pointer; + char *name; + char *version; +}; + +/* The definition of the array (mf-runtime.c) must match the enums! */ +extern struct __mf_dynamic_entry __mf_dynamic[]; +enum __mf_dynamic_index +{ + dyn_calloc, dyn_free, dyn_malloc, dyn_mmap, + dyn_munmap, dyn_realloc, + dyn_INITRESOLVE, /* Marker for last init-time resolution. */ +#ifdef LIBMUDFLAPTH + dyn_pthread_create, + dyn_pthread_join, + dyn_pthread_exit +#endif +}; + +#endif /* PIC */ + +/* ------------------------------------------------------------------------ */ +/* Private global variables. */ +/* ------------------------------------------------------------------------ */ + +#ifdef LIBMUDFLAPTH +extern pthread_mutex_t __mf_biglock; +#define LOCKTH() do { extern unsigned long __mf_lock_contention; \ + int rc = pthread_mutex_trylock (& __mf_biglock); \ + if (rc) { __mf_lock_contention ++; \ + rc = pthread_mutex_lock (& __mf_biglock); } \ + assert (rc==0); } while (0) +#define UNLOCKTH() do { int rc = pthread_mutex_unlock (& __mf_biglock); \ + assert (rc==0); } while (0) +#else +#define LOCKTH() do {} while (0) +#define UNLOCKTH() do {} while (0) +#endif + +#ifdef LIBMUDFLAPTH +extern enum __mf_state_enum *__mf_state_perthread (); +#define __mf_state (* __mf_state_perthread ()) +#else +extern enum __mf_state_enum __mf_state; +#endif +extern int __mf_starting_p; + +extern struct __mf_options __mf_opts; + +/* ------------------------------------------------------------------------ */ +/* Utility macros. */ +/* ------------------------------------------------------------------------ */ + +#define UNLIKELY(e) (__builtin_expect (!!(e), 0)) +#define LIKELY(e) (__builtin_expect (!!(e), 1)) +#define STRINGIFY2(e) #e +#define STRINGIFY(e) STRINGIFY2(e) + +#ifdef LIBMUDFLAPTH +#define VERBOSE_TRACE(...) \ + do { if (UNLIKELY (__mf_opts.verbose_trace)) { \ + fprintf (stderr, "mf(%u): ", (unsigned) pthread_self ()); \ + fprintf (stderr, __VA_ARGS__); \ + } } while (0) +#define TRACE(...) \ + do { if (UNLIKELY (__mf_opts.trace_mf_calls)) { \ + fprintf (stderr, "mf(%u): ", (unsigned) pthread_self ()); \ + fprintf (stderr, __VA_ARGS__); \ + } } while (0) +#else +#define VERBOSE_TRACE(...) \ + do { if (UNLIKELY (__mf_opts.verbose_trace)) { \ + fprintf (stderr, "mf: "); \ + fprintf (stderr, __VA_ARGS__); \ + } } while (0) +#define TRACE(...) \ + do { if (UNLIKELY (__mf_opts.trace_mf_calls)) { \ + fprintf (stderr, "mf: "); \ + fprintf (stderr, __VA_ARGS__); \ + } } while (0) +#endif + + +#define __MF_PERSIST_MAX 256 +#define __MF_FREEQ_MAX 256 + +/* + Wrapping and redirection: + + Mudflap redirects a number of libc functions into itself, for "cheap" + verification (eg. strcpy, bzero, memcpy) and also to register / + unregister regions of memory as they are manipulated by the program + (eg. malloc/free, mmap/munmap). + + There are two methods of wrapping. + + (1) The static method involves a list of -wrap=foo flags being passed to + the linker, which then links references to "foo" to the symbol + "__wrap_foo", and links references to "__real_foo" to the symbol "foo". + When compiled without -DPIC, libmudflap.a contains such __wrap_foo + functions which delegate to __real_foo functions in libc to get their + work done. + + (2) The dynamic method involves providing a definition of symbol foo in + libmudflap.so and linking it earlier in the compiler command line, + before libc.so. The function "foo" in libmudflap must then call + dlsym(RTLD_NEXT, "foo") to acquire a pointer to the "real" libc foo, or + at least the "next" foo in the dynamic link resolution order. + + We switch between these two techniques by the presence of the -DPIC + #define passed in by libtool when building libmudflap. +*/ + + +#ifdef PIC + +extern void __mf_resolve_single_dynamic (struct __mf_dynamic_entry *); + +#define _GNU_SOURCE +#include <dlfcn.h> + +#define WRAPPER(ret, fname, ...) \ +ret __wrap_ ## fname (__VA_ARGS__) \ + __attribute__ (( alias (#fname) )); \ +ret __real_ ## fname (__VA_ARGS__) \ + __attribute__ (( alias (#fname) )); \ +ret fname (__VA_ARGS__) +#define DECLARE(ty, fname, ...) \ + typedef ty (*__mf_fn_ ## fname) (__VA_ARGS__); \ + extern ty __mf_0fn_ ## fname (__VA_ARGS__); +#define CALL_REAL(fname, ...) \ + ({__mf_starting_p \ + ? __mf_0fn_ ## fname (__VA_ARGS__) \ + : (__mf_resolve_single_dynamic (& __mf_dynamic[dyn_ ## fname]), \ + (((__mf_fn_ ## fname)(__mf_dynamic[dyn_ ## fname].pointer)) (__VA_ARGS__)));}) +#define CALL_BACKUP(fname, ...) \ + __mf_0fn_ ## fname(__VA_ARGS__) + +#else /* not PIC --> static library */ + +#define WRAPPER(ret, fname, ...) \ +ret __wrap_ ## fname (__VA_ARGS__) +#define DECLARE(ty, fname, ...) \ + extern ty __real_ ## fname (__VA_ARGS__) +#define CALL_REAL(fname, ...) \ + __real_ ## fname (__VA_ARGS__) +#define CALL_BACKUP(fname, ...) \ + __real_ ## fname(__VA_ARGS__) + +#endif /* PIC */ + +/* WRAPPER2 is for functions intercepted via macros at compile time. */ +#define WRAPPER2(ret, fname, ...) \ +ret __mfwrap_ ## fname (__VA_ARGS__) + + +/* Utility macros for mf-hooks*.c */ + +#define MF_VALIDATE_EXTENT(value,size,acc,context) \ + do { \ + if (UNLIKELY (size > 0 && __MF_CACHE_MISS_P (value, size))) \ + __mf_check ((void *) (value), (size), acc, "(" context ")"); \ + } while (0) +#define BEGIN_PROTECT(fname, ...) \ + if (UNLIKELY (__mf_starting_p)) \ + { \ + return CALL_BACKUP(fname, __VA_ARGS__); \ + } \ + else if (UNLIKELY (__mf_state == reentrant)) \ + { \ + extern unsigned long __mf_reentrancy; \ + if (UNLIKELY (__mf_opts.verbose_trace)) { \ + write (2, "mf: reentrancy detected in `", 28); \ + write (2, __PRETTY_FUNCTION__, strlen(__PRETTY_FUNCTION__)); \ + write (2, "'\n", 2); } \ + __mf_reentrancy ++; \ + return CALL_REAL(fname, __VA_ARGS__); \ + } \ + else \ + { \ + TRACE ("%s\n", __PRETTY_FUNCTION__); \ + } + + +/* Unlocked variants of main entry points from mf-runtime.h. */ +extern void __mfu_check (void *ptr, size_t sz, int type, const char *location); +extern void __mfu_register (void *ptr, size_t sz, int type, const char *name); +extern void __mfu_unregister (void *ptr, size_t sz); +extern void __mfu_report (); +extern int __mfu_set_options (const char *opts); + + +#endif /* __MF_IMPL_H */ |