[BACK]Return to malloc.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc

Diff for /OpenXM_contrib2/asir2000/gc/malloc.c between version 1.4 and 1.5

version 1.4, 2002/07/24 07:46:19 version 1.5, 2002/07/24 08:00:10
Line 182  register int k;
Line 182  register int k;
     ptr_t result;      ptr_t result;
     DCL_LOCK_STATE;      DCL_LOCK_STATE;
   
       if (GC_debugging_started) GC_print_all_smashed();
     GC_INVOKE_FINALIZERS();      GC_INVOKE_FINALIZERS();
     if (SMALL_OBJ(lb)) {      if (SMALL_OBJ(lb)) {
         DISABLE_SIGNALS();          DISABLE_SIGNALS();
Line 315  DCL_LOCK_STATE;
Line 316  DCL_LOCK_STATE;
     /* It might help to manually inline the GC_malloc call here.        */      /* It might help to manually inline the GC_malloc call here.        */
     /* But any decent compiler should reduce the extra procedure call   */      /* But any decent compiler should reduce the extra procedure call   */
     /* to at most a jump instruction in this case.                      */      /* to at most a jump instruction in this case.                      */
 #   if defined(I386) && defined(SOLARIS_THREADS)  #   if defined(I386) && defined(GC_SOLARIS_THREADS)
       /*        /*
        * Thread initialisation can call malloc before         * Thread initialisation can call malloc before
        * we're ready for it.         * we're ready for it.
Line 324  DCL_LOCK_STATE;
Line 325  DCL_LOCK_STATE;
        * inopportune times.         * inopportune times.
        */         */
       if (!GC_is_initialized) return sbrk(lb);        if (!GC_is_initialized) return sbrk(lb);
 #   endif /* I386 && SOLARIS_THREADS */  #   endif /* I386 && GC_SOLARIS_THREADS */
     return((GC_PTR)REDIRECT_MALLOC(lb));      return((GC_PTR)REDIRECT_MALLOC(lb));
   }    }
   
Line 337  DCL_LOCK_STATE;
Line 338  DCL_LOCK_STATE;
   {    {
     return((GC_PTR)REDIRECT_MALLOC(n*lb));      return((GC_PTR)REDIRECT_MALLOC(n*lb));
   }    }
   
   #ifndef strdup
   # include <string.h>
   # ifdef __STDC__
       char *strdup(const char *s)
   # else
       char *strdup(s)
       char *s;
   # endif
     {
       size_t len = strlen(s) + 1;
       char * result = ((char *)REDIRECT_MALLOC(len+1));
       BCOPY(s, result, len+1);
       return result;
     }
   #endif /* !defined(strdup) */
    /* If strdup is macro defined, we assume that it actually calls malloc, */
    /* and thus the right thing will happen even without overriding it.     */
    /* This seems to be true on most Linux systems.                         */
   
 # endif /* REDIRECT_MALLOC */  # endif /* REDIRECT_MALLOC */
   
 /* Explicitly deallocate an object p.                           */  /* Explicitly deallocate an object p.                           */
Line 360  DCL_LOCK_STATE;
Line 381  DCL_LOCK_STATE;
     h = HBLKPTR(p);      h = HBLKPTR(p);
     hhdr = HDR(h);      hhdr = HDR(h);
 #   if defined(REDIRECT_MALLOC) && \  #   if defined(REDIRECT_MALLOC) && \
         (defined(SOLARIS_THREADS) || defined(LINUX_THREADS) \          (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \
          || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */           || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */
         /* For Solaris, we have to redirect malloc calls during         */          /* For Solaris, we have to redirect malloc calls during         */
         /* initialization.  For the others, this seems to happen        */          /* initialization.  For the others, this seems to happen        */
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>