OSDN Git Service

config:
[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 #if PIC
306 /* A special bootstrap variant. */
307 void *
308 __mf_0fn_mmap (void *start, size_t l, int prot, int f, int fd, off_t off)
309 {
310   return (void *) -1;
311 }
312 #endif
313
314
315 #undef mmap
316 WRAPPER(void *, mmap,
317         void  *start,  size_t length, int prot,
318         int flags, int fd, off_t offset)
319 {
320   DECLARE(void *, mmap, void *, size_t, int,
321                             int, int, off_t);
322   void *result;
323   BEGIN_PROTECT (mmap, start, length, prot, flags, fd, offset);
324
325   result = CALL_REAL (mmap, start, length, prot,
326                         flags, fd, offset);
327
328   /*
329   VERBOSE_TRACE ("mmap (%08lx, %08lx, ...) => %08lx\n",
330                  (uintptr_t) start, (uintptr_t) length,
331                  (uintptr_t) result);
332   */
333
334   if (result != (void *)-1)
335     {
336       /* Register each page as a heap object.  Why not register it all
337          as a single segment?  That's so that a later munmap() call
338          can unmap individual pages.  XXX: would __MF_TYPE_GUESS make
339          this more automatic?  */
340       size_t ps = getpagesize ();
341       uintptr_t base = (uintptr_t) result;
342       uintptr_t offset;
343
344       for (offset=0; offset<length; offset+=ps)
345         {
346           /* XXX: We could map PROT_NONE to __MF_TYPE_NOACCESS. */
347           /* XXX: Unaccessed HEAP pages are reported as leaks.  Is this
348              appropriate for unaccessed mmap pages? */
349           __mf_register ((void *) CLAMPADD (base, offset), ps,
350                          __MF_TYPE_HEAP_I, "mmap page");
351         }
352     }
353
354   return result;
355 }
356
357
358 #if PIC
359 /* A special bootstrap variant. */
360 int
361 __mf_0fn_munmap (void *start, size_t length)
362 {
363   return -1;
364 }
365 #endif
366
367
368 #undef munmap
369 WRAPPER(int , munmap, void *start, size_t length)
370 {
371   DECLARE(int, munmap, void *, size_t);
372   int result;
373   BEGIN_PROTECT (munmap, start, length);
374
375   result = CALL_REAL (munmap, start, length);
376
377   /*
378   VERBOSE_TRACE ("munmap (%08lx, %08lx, ...) => %08lx\n",
379                  (uintptr_t) start, (uintptr_t) length,
380                  (uintptr_t) result);
381   */
382
383   if (result == 0)
384     {
385       /* Unregister each page as a heap object.  */
386       size_t ps = getpagesize ();
387       uintptr_t base = (uintptr_t) start & (~ (ps - 1)); /* page align */
388       uintptr_t offset;
389
390       for (offset=0; offset<length; offset+=ps)
391         __mf_unregister ((void *) CLAMPADD (base, offset), ps, __MF_TYPE_HEAP_I);
392     }
393   return result;
394 }
395
396
397 /* This wrapper is a little different, as it's called indirectly from
398    __mf_fini also to clean up pending allocations.  */
399 void *
400 __mf_wrap_alloca_indirect (size_t c)
401 {
402   DECLARE (void *, malloc, size_t);
403   DECLARE (void, free, void *);
404
405   /* This struct, a linked list, tracks alloca'd objects.  The newest
406      object is at the head of the list.  If we detect that we've
407      popped a few levels of stack, then the listed objects are freed
408      as needed.  NB: The tracking struct is allocated with
409      real_malloc; the user data with wrap_malloc.
410   */
411   struct alloca_tracking { void *ptr; void *stack; struct alloca_tracking* next; };
412   static struct alloca_tracking *alloca_history = NULL;
413
414   void *stack = __builtin_frame_address (0);
415   void *result;
416   struct alloca_tracking *track;
417
418   TRACE ("%s\n", __PRETTY_FUNCTION__);
419   VERBOSE_TRACE ("alloca stack level %p\n", (void *) stack);
420
421   /* XXX: thread locking! */
422
423   /* Free any previously alloca'd blocks that belong to deeper-nested functions,
424      which must therefore have exited by now.  */
425
426 #define DEEPER_THAN < /* XXX: for x86; steal find_stack_direction() from libiberty/alloca.c */
427
428   while (alloca_history &&
429          ((uintptr_t) alloca_history->stack DEEPER_THAN (uintptr_t) stack))
430     {
431       struct alloca_tracking *next = alloca_history->next;
432       __mf_unregister (alloca_history->ptr, 0, __MF_TYPE_HEAP);
433       BEGIN_MALLOC_PROTECT ();
434       CALL_REAL (free, alloca_history->ptr);
435       CALL_REAL (free, alloca_history);
436       END_MALLOC_PROTECT ();
437       alloca_history = next;
438     }
439
440   /* Allocate new block.  */
441   result = NULL;
442   if (LIKELY (c > 0)) /* alloca(0) causes no allocation.  */
443     {
444       BEGIN_MALLOC_PROTECT ();
445       track = (struct alloca_tracking *) CALL_REAL (malloc,
446                                                     sizeof (struct alloca_tracking));
447       END_MALLOC_PROTECT ();
448       if (LIKELY (track != NULL))
449         {
450           BEGIN_MALLOC_PROTECT ();
451           result = CALL_REAL (malloc, c);
452           END_MALLOC_PROTECT ();
453           if (UNLIKELY (result == NULL))
454             {
455               BEGIN_MALLOC_PROTECT ();
456               CALL_REAL (free, track);
457               END_MALLOC_PROTECT ();
458               /* Too bad.  XXX: What about errno?  */
459             }
460           else
461             {
462               __mf_register (result, c, __MF_TYPE_HEAP, "alloca region");
463               track->ptr = result;
464               track->stack = stack;
465               track->next = alloca_history;
466               alloca_history = track;
467             }
468         }
469     }
470
471   return result;
472 }
473
474
475 #undef alloca
476 WRAPPER(void *, alloca, size_t c)
477 {
478   return __mf_wrap_alloca_indirect (c);
479 }
480