OSDN Git Service

We can only wrap mmap if it exists.
[pf3gnuchains/gcc-fork.git] / libmudflap / mf-hooks1.c
1 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
3    Contributed by Frank Ch. Eigler <fche@redhat.com>
4    and Graydon Hoare <graydon@redhat.com>
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file.  (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combine
20 executable.)
21
22 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
23 WARRANTY; without even the implied warranty of MERCHANTABILITY or
24 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
25 for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with GCC; see the file COPYING.  If not, write to the Free
29 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
30 02110-1301, USA.  */
31
32
33 #include "config.h"
34
35 #ifndef HAVE_SOCKLEN_T
36 #define socklen_t int
37 #endif
38
39
40 /* These attempt to coax various unix flavours to declare all our
41    needed tidbits in the system headers.  */
42 #if !defined(__FreeBSD__)  && !defined(__APPLE__)
43 #define _POSIX_SOURCE
44 #endif /* Some BSDs break <sys/socket.h> if this is defined. */
45 #define _GNU_SOURCE
46 #define _XOPEN_SOURCE
47 #define _BSD_TYPES
48 #define __EXTENSIONS__
49 #define _ALL_SOURCE
50 #define _LARGE_FILE_API
51 #define _XOPEN_SOURCE_EXTENDED 1
52
53 #include <string.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <sys/time.h>
57 #include <sys/types.h>
58 #include <unistd.h>
59 #include <assert.h>
60 #include <errno.h>
61 #include <limits.h>
62 #include <time.h>
63
64 #include "mf-runtime.h"
65 #include "mf-impl.h"
66
67 #ifdef _MUDFLAP
68 #error "Do not compile this file with -fmudflap!"
69 #endif
70
71
72 /* Memory allocation related hook functions.  Some of these are
73    intercepted via linker wrapping or symbol interposition.  Others
74    use plain macros in mf-runtime.h.  */
75
76
77 #if PIC
78 /* A special bootstrap variant. */
79 void *
80 __mf_0fn_malloc (size_t c)
81 {
82   enum foo { BS = 4096, NB=10 };
83   static char bufs[NB][BS];
84   static unsigned bufs_used[NB];
85   unsigned i;
86
87   for (i=0; i<NB; i++)
88     {
89       if (! bufs_used[i] && c < BS)
90         {
91           bufs_used[i] = 1;
92           return & bufs[i][0];
93         }
94     }
95   return NULL;
96 }
97 #endif
98
99
100 #undef malloc
101 WRAPPER(void *, malloc, size_t c)
102 {
103   size_t size_with_crumple_zones;
104   DECLARE(void *, malloc, size_t c);
105   void *result;
106   BEGIN_PROTECT (malloc, c);
107
108   size_with_crumple_zones =
109     CLAMPADD(c,CLAMPADD(__mf_opts.crumple_zone,
110                         __mf_opts.crumple_zone));
111   BEGIN_MALLOC_PROTECT ();
112   result = (char *) CALL_REAL (malloc, size_with_crumple_zones);
113   END_MALLOC_PROTECT ();
114
115   if (LIKELY(result))
116     {
117       result += __mf_opts.crumple_zone;
118       __mf_register (result, c, __MF_TYPE_HEAP, "malloc region");
119       /* XXX: register __MF_TYPE_NOACCESS for crumple zones.  */
120     }
121
122   return result;
123 }
124
125
126 #ifdef PIC
127 /* A special bootstrap variant. */
128 void *
129 __mf_0fn_calloc (size_t c, size_t n)
130 {
131   return __mf_0fn_malloc (c * n);
132 }
133 #endif
134
135
136 #undef calloc
137 WRAPPER(void *, calloc, size_t c, size_t n)
138 {
139   size_t size_with_crumple_zones;
140   DECLARE(void *, calloc, size_t, size_t);
141   DECLARE(void *, malloc, size_t);
142   DECLARE(void *, memset, void *, int, size_t);
143   char *result;
144   BEGIN_PROTECT (calloc, c, n);
145
146   size_with_crumple_zones =
147     CLAMPADD((c * n), /* XXX: CLAMPMUL */
148              CLAMPADD(__mf_opts.crumple_zone,
149                       __mf_opts.crumple_zone));
150   BEGIN_MALLOC_PROTECT ();
151   result = (char *) CALL_REAL (malloc, size_with_crumple_zones);
152   END_MALLOC_PROTECT ();
153
154   if (LIKELY(result))
155     memset (result, 0, size_with_crumple_zones);
156
157   if (LIKELY(result))
158     {
159       result += __mf_opts.crumple_zone;
160       __mf_register (result, c*n /* XXX: clamp */, __MF_TYPE_HEAP_I, "calloc region");
161       /* XXX: register __MF_TYPE_NOACCESS for crumple zones.  */
162     }
163
164   return result;
165 }
166
167
168 #if PIC
169 /* A special bootstrap variant. */
170 void *
171 __mf_0fn_realloc (void *buf, size_t c)
172 {
173   return NULL;
174 }
175 #endif
176
177
178 #undef realloc
179 WRAPPER(void *, realloc, void *buf, size_t c)
180 {
181   DECLARE(void * , realloc, void *, size_t);
182   size_t size_with_crumple_zones;
183   char *base = buf;
184   unsigned saved_wipe_heap;
185   char *result;
186   BEGIN_PROTECT (realloc, buf, c);
187
188   if (LIKELY(buf))
189     base -= __mf_opts.crumple_zone;
190
191   size_with_crumple_zones =
192     CLAMPADD(c, CLAMPADD(__mf_opts.crumple_zone,
193                          __mf_opts.crumple_zone));
194   BEGIN_MALLOC_PROTECT ();
195   result = (char *) CALL_REAL (realloc, base, size_with_crumple_zones);
196   END_MALLOC_PROTECT ();
197
198   /* Ensure heap wiping doesn't occur during this peculiar
199      unregister/reregister pair.  */
200   LOCKTH ();
201   __mf_set_state (reentrant);
202   saved_wipe_heap = __mf_opts.wipe_heap;
203   __mf_opts.wipe_heap = 0;
204
205   if (LIKELY(buf))
206     __mfu_unregister (buf, 0, __MF_TYPE_HEAP_I);
207   /* NB: underlying region may have been __MF_TYPE_HEAP. */
208
209   if (LIKELY(result))
210     {
211       result += __mf_opts.crumple_zone;
212       __mfu_register (result, c, __MF_TYPE_HEAP_I, "realloc region");
213       /* XXX: register __MF_TYPE_NOACCESS for crumple zones.  */
214     }
215
216   /* Restore previous setting.  */
217   __mf_opts.wipe_heap = saved_wipe_heap;
218
219   __mf_set_state (active);
220   UNLOCKTH ();
221
222   return result;
223 }
224
225
226 #if PIC
227 /* A special bootstrap variant. */
228 void
229 __mf_0fn_free (void *buf)
230 {
231   return;
232 }
233 #endif
234
235 #undef free
236 WRAPPER(void, free, void *buf)
237 {
238   /* Use a circular queue to delay some number (__mf_opts.free_queue_length) of free()s.  */
239   static void *free_queue [__MF_FREEQ_MAX];
240   static unsigned free_ptr = 0;
241   static int freeq_initialized = 0;
242   DECLARE(void, free, void *);
243
244   BEGIN_PROTECT (free, buf);
245
246   if (UNLIKELY(buf == NULL))
247     return;
248
249   LOCKTH ();
250   if (UNLIKELY(!freeq_initialized))
251     {
252       memset (free_queue, 0,
253                      __MF_FREEQ_MAX * sizeof (void *));
254       freeq_initialized = 1;
255     }
256   UNLOCKTH ();
257
258   __mf_unregister (buf, 0, __MF_TYPE_HEAP_I);
259   /* NB: underlying region may have been __MF_TYPE_HEAP. */
260
261   if (UNLIKELY(__mf_opts.free_queue_length > 0))
262     {
263       char *freeme = NULL;
264       LOCKTH ();
265       if (free_queue [free_ptr] != NULL)
266         {
267           freeme = free_queue [free_ptr];
268           freeme -= __mf_opts.crumple_zone;
269         }
270       free_queue [free_ptr] = buf;
271       free_ptr = (free_ptr == (__mf_opts.free_queue_length-1) ? 0 : free_ptr + 1);
272       UNLOCKTH ();
273       if (freeme)
274         {
275           if (__mf_opts.trace_mf_calls)
276             {
277               VERBOSE_TRACE ("freeing deferred pointer %p (crumple %u)\n",
278                              (void *) freeme,
279                              __mf_opts.crumple_zone);
280             }
281           BEGIN_MALLOC_PROTECT ();
282           CALL_REAL (free, freeme);
283           END_MALLOC_PROTECT ();
284         }
285     }
286   else
287     {
288       /* back pointer up a bit to the beginning of crumple zone */
289       char *base = (char *)buf;
290       base -= __mf_opts.crumple_zone;
291       if (__mf_opts.trace_mf_calls)
292         {
293           VERBOSE_TRACE ("freeing pointer %p = %p - %u\n",
294                          (void *) base,
295                          (void *) buf,
296                          __mf_opts.crumple_zone);
297         }
298       BEGIN_MALLOC_PROTECT ();
299       CALL_REAL (free, base);
300       END_MALLOC_PROTECT ();
301     }
302 }
303
304
305 /* We can only wrap mmap if the target supports it.  Likewise for munmap.
306    We assume we have both if we have mmap.  */
307 #ifdef HAVE_MMAP
308
309 #if PIC
310 /* A special bootstrap variant. */
311 void *
312 __mf_0fn_mmap (void *start, size_t l, int prot, int f, int fd, off_t off)
313 {
314   return (void *) -1;
315 }
316 #endif
317
318
319 #undef mmap
320 WRAPPER(void *, mmap,
321         void  *start,  size_t length, int prot,
322         int flags, int fd, off_t offset)
323 {
324   DECLARE(void *, mmap, void *, size_t, int,
325                             int, int, off_t);
326   void *result;
327   BEGIN_PROTECT (mmap, start, length, prot, flags, fd, offset);
328
329   result = CALL_REAL (mmap, start, length, prot,
330                         flags, fd, offset);
331
332   /*
333   VERBOSE_TRACE ("mmap (%08lx, %08lx, ...) => %08lx\n",
334                  (uintptr_t) start, (uintptr_t) length,
335                  (uintptr_t) result);
336   */
337
338   if (result != (void *)-1)
339     {
340       /* Register each page as a heap object.  Why not register it all
341          as a single segment?  That's so that a later munmap() call
342          can unmap individual pages.  XXX: would __MF_TYPE_GUESS make
343          this more automatic?  */
344       size_t ps = getpagesize ();
345       uintptr_t base = (uintptr_t) result;
346       uintptr_t offset;
347
348       for (offset=0; offset<length; offset+=ps)
349         {
350           /* XXX: We could map PROT_NONE to __MF_TYPE_NOACCESS. */
351           /* XXX: Unaccessed HEAP pages are reported as leaks.  Is this
352              appropriate for unaccessed mmap pages? */
353           __mf_register ((void *) CLAMPADD (base, offset), ps,
354                          __MF_TYPE_HEAP_I, "mmap page");
355         }
356     }
357
358   return result;
359 }
360
361
362 #if PIC
363 /* A special bootstrap variant. */
364 int
365 __mf_0fn_munmap (void *start, size_t length)
366 {
367   return -1;
368 }
369 #endif
370
371
372 #undef munmap
373 WRAPPER(int , munmap, void *start, size_t length)
374 {
375   DECLARE(int, munmap, void *, size_t);
376   int result;
377   BEGIN_PROTECT (munmap, start, length);
378
379   result = CALL_REAL (munmap, start, length);
380
381   /*
382   VERBOSE_TRACE ("munmap (%08lx, %08lx, ...) => %08lx\n",
383                  (uintptr_t) start, (uintptr_t) length,
384                  (uintptr_t) result);
385   */
386
387   if (result == 0)
388     {
389       /* Unregister each page as a heap object.  */
390       size_t ps = getpagesize ();
391       uintptr_t base = (uintptr_t) start & (~ (ps - 1)); /* page align */
392       uintptr_t offset;
393
394       for (offset=0; offset<length; offset+=ps)
395         __mf_unregister ((void *) CLAMPADD (base, offset), ps, __MF_TYPE_HEAP_I);
396     }
397   return result;
398 }
399 #endif /* HAVE_MMAP */
400
401
402 /* This wrapper is a little different, as it's called indirectly from
403    __mf_fini also to clean up pending allocations.  */
404 void *
405 __mf_wrap_alloca_indirect (size_t c)
406 {
407   DECLARE (void *, malloc, size_t);
408   DECLARE (void, free, void *);
409
410   /* This struct, a linked list, tracks alloca'd objects.  The newest
411      object is at the head of the list.  If we detect that we've
412      popped a few levels of stack, then the listed objects are freed
413      as needed.  NB: The tracking struct is allocated with
414      real_malloc; the user data with wrap_malloc.
415   */
416   struct alloca_tracking { void *ptr; void *stack; struct alloca_tracking* next; };
417   static struct alloca_tracking *alloca_history = NULL;
418
419   void *stack = __builtin_frame_address (0);
420   void *result;
421   struct alloca_tracking *track;
422
423   TRACE ("%s\n", __PRETTY_FUNCTION__);
424   VERBOSE_TRACE ("alloca stack level %p\n", (void *) stack);
425
426   /* XXX: thread locking! */
427
428   /* Free any previously alloca'd blocks that belong to deeper-nested functions,
429      which must therefore have exited by now.  */
430
431 #define DEEPER_THAN < /* XXX: for x86; steal find_stack_direction() from libiberty/alloca.c */
432
433   while (alloca_history &&
434          ((uintptr_t) alloca_history->stack DEEPER_THAN (uintptr_t) stack))
435     {
436       struct alloca_tracking *next = alloca_history->next;
437       __mf_unregister (alloca_history->ptr, 0, __MF_TYPE_HEAP);
438       BEGIN_MALLOC_PROTECT ();
439       CALL_REAL (free, alloca_history->ptr);
440       CALL_REAL (free, alloca_history);
441       END_MALLOC_PROTECT ();
442       alloca_history = next;
443     }
444
445   /* Allocate new block.  */
446   result = NULL;
447   if (LIKELY (c > 0)) /* alloca(0) causes no allocation.  */
448     {
449       BEGIN_MALLOC_PROTECT ();
450       track = (struct alloca_tracking *) CALL_REAL (malloc,
451                                                     sizeof (struct alloca_tracking));
452       END_MALLOC_PROTECT ();
453       if (LIKELY (track != NULL))
454         {
455           BEGIN_MALLOC_PROTECT ();
456           result = CALL_REAL (malloc, c);
457           END_MALLOC_PROTECT ();
458           if (UNLIKELY (result == NULL))
459             {
460               BEGIN_MALLOC_PROTECT ();
461               CALL_REAL (free, track);
462               END_MALLOC_PROTECT ();
463               /* Too bad.  XXX: What about errno?  */
464             }
465           else
466             {
467               __mf_register (result, c, __MF_TYPE_HEAP, "alloca region");
468               track->ptr = result;
469               track->stack = stack;
470               track->next = alloca_history;
471               alloca_history = track;
472             }
473         }
474     }
475
476   return result;
477 }
478
479
480 #undef alloca
481 WRAPPER(void *, alloca, size_t c)
482 {
483   return __mf_wrap_alloca_indirect (c);
484 }
485