Back to index

plt-scheme  4.2.1
Defines | Functions
malloc.c File Reference
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "private/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_alloc_large (word lw, int k, unsigned flags)
ptr_t GC_alloc_large_and_clear (word lw, int k, unsigned flags)
ptr_t GC_generic_malloc_inner (word lb, int k)
ptr_t GC_generic_malloc_inner_ignore_off_page (size_t lb, int k)
ptr_t GC_generic_malloc (word lb, int k)
GC_PTR GC_malloc_atomic (size_t lb)
char * GC_strdup (char *s)
GC_PTR GC_malloc (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 236 of file malloc.c.


Function Documentation

ptr_t GC_alloc_large ( word  lw,
int  k,
unsigned  flags 
)

Definition at line 42 of file malloc.c.

{
    struct hblk * h;
    word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
    ptr_t result;
       
    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);
    h = GC_allochblk(lw, k, flags);
#   ifdef USE_MUNMAP
       if (0 == h) {
           GC_merge_unmapped();
           h = GC_allochblk(lw, k, flags);
       }
#   endif
    while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) {
       h = GC_allochblk(lw, k, flags);
    }
    if (h == 0) {
       result = 0;
    } else {
       int total_bytes = n_blocks * HBLKSIZE;
       if (n_blocks > 1) {
           GC_large_allocd_bytes += total_bytes;
           if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
               GC_max_large_allocd_bytes = GC_large_allocd_bytes;
       }
       result = (ptr_t) (h -> hb_body);
       GC_words_wasted += BYTES_TO_WORDS(total_bytes) - lw;
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ptr_t GC_alloc_large_and_clear ( word  lw,
int  k,
unsigned  flags 
)

Definition at line 83 of file malloc.c.

{
    ptr_t result = GC_alloc_large(lw, k, flags);
    word n_blocks = OBJ_SZ_TO_BLOCKS(lw);

    if (0 == result) return 0;
    if (GC_debugging_started || GC_obj_kinds[k].ok_init) {
       /* Clear the whole block, in case of GC_realloc call. */
       BZERO(result, n_blocks * HBLKSIZE);
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 27 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 415 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);
    GC_ASSERT(GC_base(p) == p);
#   if defined(REDIRECT_MALLOC) && \
       (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \
        || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */
       /* For Solaris, we have to redirect malloc calls during        */
       /* initialization.  For the others, this seems to happen       */
       /* implicitly.                                                 */
       /* 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 (EXPECT((sz <= MAXOBJSZ), 1)) {
#      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 182 of file malloc.c.

{
    ptr_t result;
    DCL_LOCK_STATE;

    if (GC_have_errors) GC_print_all_errors();
    GC_INVOKE_FINALIZERS();
    if (SMALL_OBJ(lb)) {
       DISABLE_SIGNALS();
       LOCK();
        result = GC_generic_malloc_inner((word)lb, k);
       UNLOCK();
       ENABLE_SIGNALS();
    } else {
       word lw;
       word n_blocks;
       GC_bool init;
       lw = ROUNDED_UP_WORDS(lb);
       n_blocks = OBJ_SZ_TO_BLOCKS(lw);
       init = GC_obj_kinds[k].ok_init;
       DISABLE_SIGNALS();
       LOCK();
       result = (ptr_t)GC_alloc_large(lw, k, 0);
       if (0 != result) {
         if (GC_debugging_started) {
           BZERO(result, n_blocks * HBLKSIZE);
         } else {
#           ifdef THREADS
             /* Clear any memory that might be used for GC descriptors */
             /* before we release the lock.                          */
               ((word *)result)[0] = 0;
               ((word *)result)[1] = 0;
               ((word *)result)[lw-1] = 0;
               ((word *)result)[lw-2] = 0;
#          endif
         }
       }
       GC_words_allocd += lw;
       UNLOCK();
       ENABLE_SIGNALS();
       if (init && !GC_debugging_started && 0 != result) {
           BZERO(result, n_blocks * HBLKSIZE);
        }
    }
    if (0 == result) {
        return((*GC_oom_fn)(lb));
    } else {
        return(result);
    }
}   

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 105 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 = MIN_WORDS;
#       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.*/
       /* If we only execute the second of the   */
       /* following assignments, we lose the free       */
       /* list, but that should still be OK, at least   */
       /* for garbage collected memory.          */
        *opp = obj_link(op);
        obj_link(op) = 0;
    } else {
       lw = ROUNDED_UP_WORDS(lb);
       op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0);
    }
    GC_words_allocd += lw;
    
out:
    return op;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 167 of file malloc.c.

{
    register word lw;
    ptr_t op;

    if (lb <= HBLKSIZE)
        return(GC_generic_malloc_inner((word)lb, k));
    lw = ROUNDED_UP_WORDS(lb);
    op = (ptr_t)GC_alloc_large_and_clear(lw, k, IGNORE_OFF_PAGE);
    GC_words_allocd += lw;
    return op;
}

Here is the call graph for this function:

GC_PTR GC_malloc ( size_t  lb)

Definition at line 300 of file malloc.c.

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

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

Definition at line 245 of file malloc.c.

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

    if( EXPECT(SMALL_OBJ(lb), 1) ) {
#       ifdef MERGE_SIZES
         lw = GC_size_map[lb];
#      else
         lw = ALIGNED_WORDS(lb);
#       endif
       opp = &(GC_aobjfreelist[lw]);
       FASTLOCK();
        if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 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));
   }
}
char* GC_strdup ( char *  s)

Definition at line 281 of file malloc.c.

{
  char *copy;

  if (s == NULL) return NULL;
  if ((copy = GC_malloc_atomic(strlen(s) + 1)) == NULL) {
    errno = ENOMEM;
    return NULL;
  }
  strcpy(copy, s);
  return copy;
}