boehm-gc/malloc.c

   1 /*
   2  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
   3  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
   4  * Copyright (c) 2000 by Hewlett-Packard Company.  All rights reserved.
   5  *
   6  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   7  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   8  *
   9  * Permission is hereby granted to use or copy this program
  10  * for any purpose,  provided the above notices are retained on all copies.
  11  * Permission to modify the code and to distribute modified code is granted,
  12  * provided the above notices are retained, and a notice that the code was
  13  * modified is included with the above copyright notice.
  14  */
  15 /* Boehm, February 7, 1996 4:32 pm PST */
  16
  17 #include <stdio.h>
  18 #include "private/gc_priv.h"
  19
  20 extern ptr_t GC_clear_stack();  /* in misc.c, behaves like identity */
  21 void GC_extend_size_map();      /* in misc.c. */
  22
  23 /* Allocate reclaim list for kind:      */
  24 /* Return TRUE on success               */
  25 GC_bool GC_alloc_reclaim_list(kind)
  26 register struct obj_kind * kind;
  27 {
  28     struct hblk ** result = (struct hblk **)
  29                 GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
  30     if (result == 0) return(FALSE);
  31     BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
  32     kind -> ok_reclaim_list = result;
  33     return(TRUE);
  34 }
  35
  36 /* Allocate a large block of size lw words.     */
  37 /* The block is not cleared.                    */
  38 /* Flags is 0 or IGNORE_OFF_PAGE.               */
  39 ptr_t GC_alloc_large(lw, k, flags)
  40 word lw;
  41 int k;
  42 unsigned flags;
  43 {
  44     struct hblk * h;
  45     word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
  46     ptr_t result;
  47
  48     if (!GC_is_initialized) GC_init_inner();
  49     /* Do our share of marking work */
  50         if(GC_incremental && !GC_dont_gc)
  51             GC_collect_a_little_inner((int)n_blocks);
  52     h = GC_allochblk(lw, k, flags);
  53 #   ifdef USE_MUNMAP
  54         if (0 == h) {
  55             GC_merge_unmapped();
  56             h = GC_allochblk(lw, k, flags);
  57         }
  58 #   endif
  59     while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) {
  60         h = GC_allochblk(lw, k, flags);
  61     }
  62     if (h == 0) {
  63         result = 0;
  64     } else {
  65         int total_bytes = BYTES_TO_WORDS(n_blocks * HBLKSIZE);
  66         if (n_blocks > 1) {
  67             GC_large_allocd_bytes += n_blocks * HBLKSIZE;
  68             if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
  69                 GC_max_large_allocd_bytes = GC_large_allocd_bytes;
  70         }
  71         result = (ptr_t) (h -> hb_body);
  72         GC_words_wasted += total_bytes - lw;
  73     }
  74     return result;
  75 }
  76
  77
  78 /* Allocate a large block of size lb bytes.  Clear if appropriate.      */
  79 ptr_t GC_alloc_large_and_clear(lw, k, flags)
  80 word lw;
  81 int k;
  82 unsigned flags;
  83 {
  84     ptr_t result = GC_alloc_large(lw, k, flags);
  85     word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
  86
  87     if (0 == result) return 0;
  88     if (GC_debugging_started || GC_obj_kinds[k].ok_init) {
  89         /* Clear the whole block, in case of GC_realloc call. */
  90         BZERO(result, n_blocks * HBLKSIZE);
  91     }
  92     return result;
  93 }
  94
  95 /* allocate lb bytes for an object of kind k.   */
  96 /* Should not be used to directly to allocate   */
  97 /* objects such as STUBBORN objects that        */
  98 /* require special handling on allocation.      */
  99 /* First a version that assumes we already      */
 100 /* hold lock:                                   */
 101 ptr_t GC_generic_malloc_inner(lb, k)
 102 register word lb;
 103 register int k;
 104 {
 105 register word lw;
 106 register ptr_t op;
 107 register ptr_t *opp;
 108
 109     if( SMALL_OBJ(lb) ) {
 110         register struct obj_kind * kind = GC_obj_kinds + k;
 111 #       ifdef MERGE_SIZES
 112           lw = GC_size_map[lb];
 113 #       else
 114           lw = ALIGNED_WORDS(lb);
 115           if (lw == 0) lw = MIN_WORDS;
 116 #       endif
 117         opp = &(kind -> ok_freelist[lw]);
 118         if( (op = *opp) == 0 ) {
 119 #           ifdef MERGE_SIZES
 120               if (GC_size_map[lb] == 0) {
 121                 if (!GC_is_initialized)  GC_init_inner();
 122                 if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
 123                 return(GC_generic_malloc_inner(lb, k));
 124               }
 125 #           else
 126               if (!GC_is_initialized) {
 127                 GC_init_inner();
 128                 return(GC_generic_malloc_inner(lb, k));
 129               }
 130 #           endif
 131             if (kind -> ok_reclaim_list == 0) {
 132                 if (!GC_alloc_reclaim_list(kind)) goto out;
 133             }
 134             op = GC_allocobj(lw, k);
 135             if (op == 0) goto out;
 136         }
 137         /* Here everything is in a consistent state.    */
 138         /* We assume the following assignment is        */
 139         /* atomic.  If we get aborted                   */
 140         /* after the assignment, we lose an object,     */
 141         /* but that's benign.                           */
 142         /* Volatile declarations may need to be added   */
 143         /* to prevent the compiler from breaking things.*/
 144         /* If we only execute the second of the         */
 145         /* following assignments, we lose the free      */
 146         /* list, but that should still be OK, at least  */
 147         /* for garbage collected memory.                */
 148         *opp = obj_link(op);
 149         obj_link(op) = 0;
 150     } else {
 151         lw = ROUNDED_UP_WORDS(lb);
 152         op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0);
 153     }
 154     GC_words_allocd += lw;
 155
 156 out:
 157     return op;
 158 }
 159
 160 /* Allocate a composite object of size n bytes.  The caller guarantees  */
 161 /* that pointers past the first page are not relevant.  Caller holds    */
 162 /* allocation lock.                                                     */
 163 ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k)
 164 register size_t lb;
 165 register int k;
 166 {
 167     register word lw;
 168     ptr_t op;
 169
 170     if (lb <= HBLKSIZE)
 171         return(GC_generic_malloc_inner((word)lb, k));
 172     lw = ROUNDED_UP_WORDS(lb);
 173     op = (ptr_t)GC_alloc_large_and_clear(lw, k, IGNORE_OFF_PAGE);
 174     GC_words_allocd += lw;
 175     return op;
 176 }
 177
 178 ptr_t GC_generic_malloc(lb, k)
 179 register word lb;
 180 register int k;
 181 {
 182     ptr_t result;
 183     DCL_LOCK_STATE;
 184
 185     if (GC_have_errors) GC_print_all_errors();
 186     GC_INVOKE_FINALIZERS();
 187     if (SMALL_OBJ(lb)) {
 188         DISABLE_SIGNALS();
 189         LOCK();
 190         result = GC_generic_malloc_inner((word)lb, k);
 191         UNLOCK();
 192         ENABLE_SIGNALS();
 193     } else {
 194         word lw;
 195         word n_blocks;
 196         GC_bool init;
 197         lw = ROUNDED_UP_WORDS(lb);
 198         n_blocks = OBJ_SZ_TO_BLOCKS(lw);
 199         init = GC_obj_kinds[k].ok_init;
 200         DISABLE_SIGNALS();
 201         LOCK();
 202         result = (ptr_t)GC_alloc_large(lw, k, 0);
 203         if (0 != result) {
 204           if (GC_debugging_started) {
 205             BZERO(result, n_blocks * HBLKSIZE);
 206           } else {
 207 #           ifdef THREADS
 208               /* Clear any memory that might be used for GC descriptors */
 209               /* before we release the lock.                          */
 210                 ((word *)result)[0] = 0;
 211                 ((word *)result)[1] = 0;
 212                 ((word *)result)[lw-1] = 0;
 213                 ((word *)result)[lw-2] = 0;
 214 #           endif
 215           }
 216         }
 217         GC_words_allocd += lw;
 218         UNLOCK();
 219         ENABLE_SIGNALS();
 220         if (init && !GC_debugging_started && 0 != result) {
 221             BZERO(result, n_blocks * HBLKSIZE);
 222         }
 223     }
 224     if (0 == result) {
 225         return((*GC_oom_fn)(lb));
 226     } else {
 227         return(result);
 228     }
 229 }
 230
 231
 232 #define GENERAL_MALLOC(lb,k) \
 233     (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
 234 /* We make the GC_clear_stack_call a tail call, hoping to get more of   */
 235 /* the stack.                                                           */
 236
 237 /* Allocate lb bytes of atomic (pointerfree) data */
 238 # ifdef __STDC__
 239     GC_PTR GC_malloc_atomic(size_t lb)
 240 # else
 241     GC_PTR GC_malloc_atomic(lb)
 242     size_t lb;
 243 # endif
 244 {
 245 register ptr_t op;
 246 register ptr_t * opp;
 247 register word lw;
 248 DCL_LOCK_STATE;
 249
 250     if( EXPECT(SMALL_OBJ(lb), 1) ) {
 251 #       ifdef MERGE_SIZES
 252           lw = GC_size_map[lb];
 253 #       else
 254           lw = ALIGNED_WORDS(lb);
 255 #       endif
 256         opp = &(GC_aobjfreelist[lw]);
 257         FASTLOCK();
 258         if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) {
 259             FASTUNLOCK();
 260             return(GENERAL_MALLOC((word)lb, PTRFREE));
 261         }
 262         /* See above comment on signals.        */
 263         *opp = obj_link(op);
 264         GC_words_allocd += lw;
 265         FASTUNLOCK();
 266         return((GC_PTR) op);
 267    } else {
 268        return(GENERAL_MALLOC((word)lb, PTRFREE));
 269    }
 270 }
 271
 272 /* Allocate lb bytes of composite (pointerful) data */
 273 # ifdef __STDC__
 274     GC_PTR GC_malloc(size_t lb)
 275 # else
 276     GC_PTR GC_malloc(lb)
 277     size_t lb;
 278 # endif
 279 {
 280 register ptr_t op;
 281 register ptr_t *opp;
 282 register word lw;
 283 DCL_LOCK_STATE;
 284
 285     if( EXPECT(SMALL_OBJ(lb), 1) ) {
 286 #       ifdef MERGE_SIZES
 287           lw = GC_size_map[lb];
 288 #       else
 289           lw = ALIGNED_WORDS(lb);
 290 #       endif
 291         opp = &(GC_objfreelist[lw]);
 292         FASTLOCK();
 293         if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) {
 294             FASTUNLOCK();
 295             return(GENERAL_MALLOC((word)lb, NORMAL));
 296         }
 297         /* See above comment on signals.        */
 298         GC_ASSERT(0 == obj_link(op)
 299                   || (word)obj_link(op)
 300                         <= (word)GC_greatest_plausible_heap_addr
 301                      && (word)obj_link(op)
 302                         >= (word)GC_least_plausible_heap_addr);
 303         *opp = obj_link(op);
 304         obj_link(op) = 0;
 305         GC_words_allocd += lw;
 306         FASTUNLOCK();
 307         return((GC_PTR) op);
 308    } else {
 309        return(GENERAL_MALLOC((word)lb, NORMAL));
 310    }
 311 }
 312
 313 # ifdef REDIRECT_MALLOC
 314 # ifdef __STDC__
 315     GC_PTR malloc(size_t lb)
 316 # else
 317     GC_PTR malloc(lb)
 318     size_t lb;
 319 # endif
 320   {
 321     /* It might help to manually inline the GC_malloc call here.        */
 322     /* But any decent compiler should reduce the extra procedure call   */
 323     /* to at most a jump instruction in this case.                      */
 324 #   if defined(I386) && defined(GC_SOLARIS_THREADS)
 325       /*
 326        * Thread initialisation can call malloc before
 327        * we're ready for it.
 328        * It's not clear that this is enough to help matters.
 329        * The thread implementation may well call malloc at other
 330        * inopportune times.
 331        */
 332       if (!GC_is_initialized) return sbrk(lb);
 333 #   endif /* I386 && GC_SOLARIS_THREADS */
 334     return((GC_PTR)REDIRECT_MALLOC(lb));
 335   }
 336
 337 # ifdef __STDC__
 338     GC_PTR calloc(size_t n, size_t lb)
 339 # else
 340     GC_PTR calloc(n, lb)
 341     size_t n, lb;
 342 # endif
 343   {
 344     return((GC_PTR)REDIRECT_MALLOC(n*lb));
 345   }
 346
 347 #ifndef strdup
 348 # include <string.h>
 349 # ifdef __STDC__
 350     char *strdup(const char *s)
 351 # else
 352     char *strdup(s)
 353     char *s;
 354 # endif
 355   {
 356     size_t len = strlen(s) + 1;
 357     char * result = ((char *)REDIRECT_MALLOC(len+1));
 358     BCOPY(s, result, len+1);
 359     return result;
 360   }
 361 #endif /* !defined(strdup) */
 362  /* If strdup is macro defined, we assume that it actually calls malloc, */
 363  /* and thus the right thing will happen even without overriding it.     */
 364  /* This seems to be true on most Linux systems.                         */
 365
 366 # endif /* REDIRECT_MALLOC */
 367
 368 /* Explicitly deallocate an object p.                           */
 369 # ifdef __STDC__
 370     void GC_free(GC_PTR p)
 371 # else
 372     void GC_free(p)
 373     GC_PTR p;
 374 # endif
 375 {
 376     register struct hblk *h;
 377     register hdr *hhdr;
 378     register signed_word sz;
 379     register ptr_t * flh;
 380     register int knd;
 381     register struct obj_kind * ok;
 382     DCL_LOCK_STATE;
 383
 384     if (p == 0) return;
 385         /* Required by ANSI.  It's not my fault ...     */
 386     h = HBLKPTR(p);
 387     hhdr = HDR(h);
 388     GC_ASSERT(GC_base(p) == p);
 389 #   if defined(REDIRECT_MALLOC) && \
 390         (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \
 391          || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */
 392         /* For Solaris, we have to redirect malloc calls during         */
 393         /* initialization.  For the others, this seems to happen        */
 394         /* implicitly.                                                  */
 395         /* Don't try to deallocate that memory.                         */
 396         if (0 == hhdr) return;
 397 #   endif
 398     knd = hhdr -> hb_obj_kind;
 399     sz = hhdr -> hb_sz;
 400     ok = &GC_obj_kinds[knd];
 401     if (EXPECT((sz <= MAXOBJSZ), 1)) {
 402 #       ifdef THREADS
 403             DISABLE_SIGNALS();
 404             LOCK();
 405 #       endif
 406         GC_mem_freed += sz;
 407         /* A signal here can make GC_mem_freed and GC_non_gc_bytes      */
 408         /* inconsistent.  We claim this is benign.                      */
 409         if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
 410                 /* Its unnecessary to clear the mark bit.  If the       */
 411                 /* object is reallocated, it doesn't matter.  O.w. the  */
 412                 /* collector will do it, since it's on a free list.     */
 413         if (ok -> ok_init) {
 414             BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
 415         }
 416         flh = &(ok -> ok_freelist[sz]);
 417         obj_link(p) = *flh;
 418         *flh = (ptr_t)p;
 419 #       ifdef THREADS
 420             UNLOCK();
 421             ENABLE_SIGNALS();
 422 #       endif
 423     } else {
 424         DISABLE_SIGNALS();
 425         LOCK();
 426         GC_mem_freed += sz;
 427         if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
 428         GC_freehblk(h);
 429         UNLOCK();
 430         ENABLE_SIGNALS();
 431     }
 432 }
 433
 434 /* Explicitly deallocate an object p when we already hold lock.         */
 435 /* Only used for internally allocated objects, so we can take some      */
 436 /* shortcuts.                                                           */
 437 #ifdef THREADS
 438 void GC_free_inner(GC_PTR p)
 439 {
 440     register struct hblk *h;
 441     register hdr *hhdr;
 442     register signed_word sz;
 443     register ptr_t * flh;
 444     register int knd;
 445     register struct obj_kind * ok;
 446     DCL_LOCK_STATE;
 447
 448     h = HBLKPTR(p);
 449     hhdr = HDR(h);
 450     knd = hhdr -> hb_obj_kind;
 451     sz = hhdr -> hb_sz;
 452     ok = &GC_obj_kinds[knd];
 453     if (sz <= MAXOBJSZ) {
 454         GC_mem_freed += sz;
 455         if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
 456         if (ok -> ok_init) {
 457             BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
 458         }
 459         flh = &(ok -> ok_freelist[sz]);
 460         obj_link(p) = *flh;
 461         *flh = (ptr_t)p;
 462     } else {
 463         GC_mem_freed += sz;
 464         if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
 465         GC_freehblk(h);
 466     }
 467 }
 468 #endif /* THREADS */
 469
 470 # if defined(REDIRECT_MALLOC) && !defined(REDIRECT_FREE)
 471 #   define REDIRECT_FREE GC_free
 472 # endif
 473 # ifdef REDIRECT_FREE
 474 #   ifdef __STDC__
 475       void free(GC_PTR p)
 476 #   else
 477       void free(p)
 478       GC_PTR p;
 479 #   endif
 480   {
 481 #   ifndef IGNORE_FREE
 482       REDIRECT_FREE(p);
 483 #   endif
 484   }
 485 # endif  /* REDIRECT_MALLOC */