/* 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>
+ Mudflap: narrow-pointer bounds-checking by tree rewriting.
+ Copyright (C) 2002, 2003, 2004, 2009, 2011 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
+Software Foundation; either version 3, 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. */
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
#ifndef __MF_IMPL_H
#define __MF_IMPL_H
#error "Cannot build libmudflapth without pthread.h."
#endif
+#if HAVE_STDINT_H
+#include <stdint.h>
+#else
+typedef __mf_uintptr_t uintptr_t;
+#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_CEM __MF_TYPE_STACK /* largest type# for the cemetery */
#define __MF_TYPE_MAX __MF_TYPE_GUESS
-/* Private functions. */
+/* Private functions. */
-extern void __mf_violation (void *ptr, size_t sz,
- uintptr_t pc, const char *location,
+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. */
+/* The mf_state type codes describe recursion and initialization order.
-enum __mf_state_enum { active, reentrant };
+ reentrant means we are inside a mf-runtime support routine, such as
+ __mf_register, and thus there should be no calls to any wrapped functions,
+ such as the wrapped malloc. This indicates a bug if it occurs.
+ in_malloc means we are inside a real malloc call inside a wrapped malloc
+ call, and thus there should be no calls to any wrapped functions like the
+ wrapped mmap. This happens on some systems due to how the system libraries
+ are constructed. */
+
+enum __mf_state_enum { active, reentrant, in_malloc };
/* The __mf_options structure records optional or tunable aspects of the
mudflap library's behavior. There is a single global instance of this
unsigned adapt_cache;
/* Print list of leaked heap objects on shutdown. */
- unsigned print_leaks;
+ unsigned print_leaks;
+
+#ifdef HAVE___LIBC_FREERES
+ /* Call __libc_freeres before leak analysis. */
+ unsigned call_libc_freeres;
+#endif
/* Detect reads of uninitialized objects. */
- unsigned check_initialization;
+ unsigned check_initialization;
/* Print verbose description of violations. */
unsigned verbose_violations;
/* 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,
+ /* Maintain a queue of this many deferred free()s,
to trap use of freed memory. */
unsigned free_queue_length;
/* Maintain this many stack frames for contexts. */
unsigned backtrace;
+ /* Ignore read operations even if mode_check is in effect. */
+ unsigned ignore_reads;
+
+ /* Collect register/unregister timestamps. */
+ unsigned timestamps;
+
#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;
-
+#define mode_nop 0 /* Do nothing. */
+#define mode_populate 1 /* Populate tree but do not check for violations. */
+#define mode_check 2 /* Populate and check for violations (normal). */
+#define mode_violate 3 /* Trigger a violation on every call (diagnostic). */
+ unsigned 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;
+#define viol_nop 0 /* Return control to application. */
+#define viol_segv 1 /* Signal self with segv. */
+#define viol_abort 2 /* Call abort (). */
+#define viol_gdb 3 /* Fork a debugger on self */
+ unsigned violation_mode;
/* Violation heuristics selection. */
unsigned heur_stack_bound; /* allow current stack region */
/* 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,
+#ifdef HAVE_MMAP64
+ dyn_mmap64,
+#endif
+ dyn_munmap, dyn_realloc,
dyn_INITRESOLVE, /* Marker for last init-time resolution. */
-#ifdef LIBMUDFLAPTH
- dyn_pthread_create,
- dyn_pthread_join,
- dyn_pthread_exit
+#ifdef LIBMUDFLAPTH
+ dyn_pthread_create
#endif
};
#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;
+#if defined(LIBMUDFLAPTH) && (!defined(HAVE_TLS) || defined(USE_EMUTLS))
+extern enum __mf_state_enum __mf_get_state (void);
+extern void __mf_set_state (enum __mf_state_enum);
+#else
+# ifdef LIBMUDFLAPTH
+extern __thread enum __mf_state_enum __mf_state_1;
+# else
+extern enum __mf_state_enum __mf_state_1;
+# endif
+static inline enum __mf_state_enum __mf_get_state (void)
+{
+ return __mf_state_1;
+}
+static inline void __mf_set_state (enum __mf_state_enum s)
+{
+ __mf_state_1 = s;
+}
#endif
-extern int __mf_starting_p;
+extern int __mf_starting_p;
extern struct __mf_options __mf_opts;
/* ------------------------------------------------------------------------ */
#define __MF_PERSIST_MAX 256
#define __MF_FREEQ_MAX 256
-/*
+/*
Wrapping and redirection:
Mudflap redirects a number of libc functions into itself, for "cheap"
unregister regions of memory as they are manipulated by the program
(eg. malloc/free, mmap/munmap).
- There are two methods of wrapping.
+ 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
#define MF_VALIDATE_EXTENT(value,size,acc,context) \
do { \
if (UNLIKELY (size > 0 && __MF_CACHE_MISS_P (value, size))) \
+ if (acc == __MF_CHECK_WRITE || ! __mf_opts.ignore_reads) \
__mf_check ((void *) (value), (size), acc, "(" context ")"); \
} while (0)
#define BEGIN_PROTECT(fname, ...) \
{ \
return CALL_BACKUP(fname, __VA_ARGS__); \
} \
- else if (UNLIKELY (__mf_state == reentrant)) \
+ else if (UNLIKELY (__mf_get_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 if (UNLIKELY (__mf_get_state () == in_malloc)) \
+ { \
+ return CALL_REAL(fname, __VA_ARGS__); \
+ } \
else \
{ \
TRACE ("%s\n", __PRETTY_FUNCTION__); \
}
+/* There is an assumption here that these will only be called in routines
+ that call BEGIN_PROTECT at the start, and hence the state must always
+ be active when BEGIN_MALLOC_PROTECT is called. */
+#define BEGIN_MALLOC_PROTECT() \
+ __mf_set_state (in_malloc)
+
+#define END_MALLOC_PROTECT() \
+ __mf_set_state (active)
/* 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_unregister (void *ptr, size_t sz, int type);
extern void __mfu_report ();
extern int __mfu_set_options (const char *opts);