Back to index

lightning-sunbird  0.9+nobinonly
Defines | Functions
malloc.c File Reference
#include <stdio.h>
#include <signal.h>
#include "gc_priv.h"

Go to the source code of this file.

Defines

#define GENERAL_MALLOC(lb, k)   (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))

Functions

ptr_t GC_clear_stack ()
void GC_extend_size_map ()
GC_bool GC_alloc_reclaim_list (struct obj_kind *kind)
ptr_t GC_generic_malloc_inner (word lb, int k)
ptr_t GC_generic_malloc (word lb, int k)
GC_PTR GC_malloc_atomic (size_t lb)
GC_PTR GC_malloc (size_t lb)
GC_PTR GC_generic_or_special_malloc (word lb, int knd)
GC_PTR GC_realloc (GC_PTR p, size_t lb)
void GC_free (GC_PTR p)

Define Documentation

#define GENERAL_MALLOC (   lb,
 
)    (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))

Definition at line 134 of file malloc.c.


Function Documentation

Definition at line 26 of file malloc.c.

{
    struct hblk ** result = (struct hblk **)
              GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
    if (result == 0) return(FALSE);
    BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
    kind -> ok_reclaim_list = result;
    return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Here is the caller graph for this function:

Here is the caller graph for this function:

Definition at line 367 of file malloc.c.

{
    register struct hblk *h;
    register hdr *hhdr;
    register signed_word sz;
    register ptr_t * flh;
    register int knd;
    register struct obj_kind * ok;
    DCL_LOCK_STATE;

    if (p == 0) return;
       /* Required by ANSI.  It's not my fault ...      */
    h = HBLKPTR(p);
    hhdr = HDR(h);
#   if defined(REDIRECT_MALLOC) && \
       (defined(SOLARIS_THREADS) || defined(LINUX_THREADS))
       /* We have to redirect malloc calls during initialization.     */
       /* Don't try to deallocate that memory.                        */
       if (0 == hhdr) return;
#   endif
    knd = hhdr -> hb_obj_kind;
    sz = hhdr -> hb_sz;
    ok = &GC_obj_kinds[knd];
    if (sz <= MAXOBJSZ) {
#      ifdef THREADS
           DISABLE_SIGNALS();
           LOCK();
#      endif
       GC_mem_freed += sz;
       /* A signal here can make GC_mem_freed and GC_non_gc_bytes     */
       /* inconsistent.  We claim this is benign.                     */
       if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
              /* Its unnecessary to clear the mark bit.  If the       */
              /* object is reallocated, it doesn't matter.  O.w. the  */
              /* collector will do it, since it's on a free list.     */
       if (ok -> ok_init) {
           BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
       }
       flh = &(ok -> ok_freelist[sz]);
       obj_link(p) = *flh;
       *flh = (ptr_t)p;
#      ifdef THREADS
           UNLOCK();
           ENABLE_SIGNALS();
#      endif
    } else {
       DISABLE_SIGNALS();
        LOCK();
        GC_mem_freed += sz;
       if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
        GC_freehblk(h);
        UNLOCK();
        ENABLE_SIGNALS();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ptr_t GC_generic_malloc ( word  lb,
int  k 
)

Definition at line 113 of file malloc.c.

{
    ptr_t result;
    DCL_LOCK_STATE;

    GC_INVOKE_FINALIZERS();
    DISABLE_SIGNALS();
    LOCK();
    result = GC_generic_malloc_inner(lb, k);
    UNLOCK();
    ENABLE_SIGNALS();
    if (0 == result) {
        return((*GC_oom_fn)(lb));
    } else {
        return(result);
    }
}   

Here is the call graph for this function:

Definition at line 43 of file malloc.c.

{
register word lw;
register ptr_t op;
register ptr_t *opp;

    if( SMALL_OBJ(lb) ) {
        register struct obj_kind * kind = GC_obj_kinds + k;
#       ifdef MERGE_SIZES
         lw = GC_size_map[lb];
#      else
         lw = ALIGNED_WORDS(lb);
         if (lw == 0) lw = 1;
#       endif
       opp = &(kind -> ok_freelist[lw]);
        if( (op = *opp) == 0 ) {
#          ifdef MERGE_SIZES
             if (GC_size_map[lb] == 0) {
               if (!GC_is_initialized)  GC_init_inner();
               if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
               return(GC_generic_malloc_inner(lb, k));
             }
#          else
             if (!GC_is_initialized) {
               GC_init_inner();
               return(GC_generic_malloc_inner(lb, k));
             }
#          endif
           if (kind -> ok_reclaim_list == 0) {
              if (!GC_alloc_reclaim_list(kind)) goto out;
           }
           op = GC_allocobj(lw, k);
           if (op == 0) goto out;
        }
        /* Here everything is in a consistent state.    */
        /* We assume the following assignment is */
        /* atomic.  If we get aborted                   */
        /* after the assignment, we lose an object,     */
        /* but that's benign.                           */
        /* Volatile declarations may need to be added   */
        /* to prevent the compiler from breaking things.*/
        *opp = obj_link(op);
        obj_link(op) = 0;
    } else {
       register struct hblk * h;
       register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
                                      + HDR_BYTES + HBLKSIZE-1);
       
       if (!GC_is_initialized) GC_init_inner();
       /* Do our share of marking work */
          if(GC_incremental && !GC_dont_gc)
              GC_collect_a_little_inner((int)n_blocks);
       lw = ROUNDED_UP_WORDS(lb);
       while ((h = GC_allochblk(lw, k, 0)) == 0
              && GC_collect_or_expand(n_blocks, FALSE));
       if (h == 0) {
           op = 0;
       } else {
           op = (ptr_t) (h -> hb_body);
           GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
       }
    }
    GC_words_allocd += lw;
    
out:
    return((ptr_t)op);
}

Here is the call graph for this function:

Definition at line 245 of file malloc.c.

{
    switch(knd) {
#     ifdef STUBBORN_ALLOC
       case STUBBORN:
           return(GC_malloc_stubborn((size_t)lb));
#     endif
       case PTRFREE:
           return(GC_malloc_atomic((size_t)lb));
       case NORMAL:
           return(GC_malloc((size_t)lb));
       case UNCOLLECTABLE:
           return(GC_malloc_uncollectable((size_t)lb));
#       ifdef ATOMIC_UNCOLLECTABLE
         case AUNCOLLECTABLE:
           return(GC_malloc_atomic_uncollectable((size_t)lb));
#      endif /* ATOMIC_UNCOLLECTABLE */
       default:
           return(GC_generic_malloc(lb,knd));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GC_PTR GC_malloc ( size_t  lb)

Definition at line 178 of file malloc.c.

{
register ptr_t op;
register ptr_t *opp;
register word lw;
DCL_LOCK_STATE;

    if( SMALL_OBJ(lb) ) {
#       ifdef MERGE_SIZES
         lw = GC_size_map[lb];
#      else
         lw = ALIGNED_WORDS(lb);
#       endif
       opp = &(GC_objfreelist[lw]);
       FASTLOCK();
        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
            FASTUNLOCK();
            return(GENERAL_MALLOC((word)lb, NORMAL));
        }
        /* See above comment on signals.  */
        *opp = obj_link(op);
        obj_link(op) = 0;
        GC_words_allocd += lw;
        FASTUNLOCK();
        return((GC_PTR) op);
   } else {
       return(GENERAL_MALLOC((word)lb, NORMAL));
   }
}

Here is the caller graph for this function:

GC_PTR GC_malloc_atomic ( size_t  lb)

Definition at line 143 of file malloc.c.

{
register ptr_t op;
register ptr_t * opp;
register word lw;
DCL_LOCK_STATE;

    if( SMALL_OBJ(lb) ) {
#       ifdef MERGE_SIZES
         lw = GC_size_map[lb];
#      else
         lw = ALIGNED_WORDS(lb);
#       endif
       opp = &(GC_aobjfreelist[lw]);
       FASTLOCK();
        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
            FASTUNLOCK();
            return(GENERAL_MALLOC((word)lb, PTRFREE));
        }
        /* See above comment on signals.  */
        *opp = obj_link(op);
        GC_words_allocd += lw;
        FASTUNLOCK();
        return((GC_PTR) op);
   } else {
       return(GENERAL_MALLOC((word)lb, PTRFREE));
   }
}

Here is the caller graph for this function:

GC_PTR GC_realloc ( GC_PTR  p,
size_t  lb 
)

Definition at line 277 of file malloc.c.

{
register struct hblk * h;
register hdr * hhdr;
register word sz;     /* Current size in bytes   */
register word orig_sz;       /* Original sz in bytes    */
int obj_kind;

    if (p == 0) return(GC_malloc(lb));    /* Required by ANSI */
    h = HBLKPTR(p);
    hhdr = HDR(h);
    sz = hhdr -> hb_sz;
    obj_kind = hhdr -> hb_obj_kind;
    sz = WORDS_TO_BYTES(sz);
    orig_sz = sz;

    if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
       /* Round it up to the next whole heap block */
         register word descr;
         
         sz = (sz+HDR_BYTES+HBLKSIZE-1)
              & (~HBLKMASK);
         sz -= HDR_BYTES;
         hhdr -> hb_sz = BYTES_TO_WORDS(sz);
         descr = GC_obj_kinds[obj_kind].ok_descriptor;
          if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
          hhdr -> hb_descr = descr;
         if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
         /* Extra area is already cleared by allochblk. */
    }
    if (ADD_SLOP(lb) <= sz) {
       if (lb >= (sz >> 1)) {
#          ifdef STUBBORN_ALLOC
               if (obj_kind == STUBBORN) GC_change_stubborn(p);
#          endif
           if (orig_sz > lb) {
             /* Clear unneeded part of object to avoid bogus pointer */
             /* tracing.                                      */
             /* Safe for stubborn objects.                           */
               BZERO(((ptr_t)p) + lb, orig_sz - lb);
           }
           return(p);
       } else {
           /* shrink */
             GC_PTR result =
                     GC_generic_or_special_malloc((word)lb, obj_kind);

             if (result == 0) return(0);
                 /* Could also return original object.  But this      */
                 /* gives the client warning of imminent disaster.    */
             BCOPY(p, result, lb);
#            ifndef IGNORE_FREE
               GC_free(p);
#            endif
             return(result);
       }
    } else {
       /* grow */
         GC_PTR result =
              GC_generic_or_special_malloc((word)lb, obj_kind);

         if (result == 0) return(0);
         BCOPY(p, result, sz);
#        ifndef IGNORE_FREE
           GC_free(p);
#        endif
         return(result);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: