[BACK]Return to gc_priv.h CVS log [TXT][DIR] Up to [local] / OpenXM_contrib / gc

Diff for /OpenXM_contrib/gc/Attic/gc_priv.h between version 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 1999/11/27 10:58:32 version 1.1.1.2, 2000/04/14 11:07:59
Line 1 
Line 1 
 /*  /*
  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers   * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.   * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
    * Copyright (c) 1996-1999 by Silicon Graphics.  All rights reserved.
    * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
  *   *
    *
  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED   * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.   * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
  *   *
Line 64  typedef char * ptr_t; /* A generic pointer to which we
Line 67  typedef char * ptr_t; /* A generic pointer to which we
 #       include <stddef.h>  #       include <stddef.h>
 #   endif  #   endif
 #   define VOLATILE volatile  #   define VOLATILE volatile
 #   define CONST const  
 #else  #else
 #   ifdef MSWIN32  #   ifdef MSWIN32
 #       include <stdlib.h>  #       include <stdlib.h>
 #   endif  #   endif
 #   define VOLATILE  #   define VOLATILE
 #   define CONST  
 #endif  #endif
   
 #ifdef AMIGA  #define CONST GC_CONST
   
   #if 0 /* was once defined for AMIGA */
 #   define GC_FAR __far  #   define GC_FAR __far
 #else  #else
 #   define GC_FAR  #   define GC_FAR
Line 350  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 353  void GC_print_callers (/* struct callinfo info[NFRAMES
                                     + GC_page_size) \                                      + GC_page_size) \
                                     + GC_page_size-1)                                      + GC_page_size-1)
 #   else  #   else
 #     if defined(AMIGA) || defined(NEXT) || defined(DOS4GW)  #     if defined(AMIGA) || defined(NEXT) || defined(MACOSX) || defined(DOS4GW)
 #       define GET_MEM(bytes) HBLKPTR((size_t) \  #       define GET_MEM(bytes) HBLKPTR((size_t) \
                                       calloc(1, (size_t)bytes + GC_page_size) \                                        calloc(1, (size_t)bytes + GC_page_size) \
                                       + GC_page_size-1)                                        + GC_page_size-1)
Line 436  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 439  void GC_print_callers (/* struct callinfo info[NFRAMES
 #  endif  #  endif
 #  ifdef LINUX_THREADS  #  ifdef LINUX_THREADS
 #    include <pthread.h>  #    include <pthread.h>
 #    ifdef __i386__  #    if defined(I386)
        inline static int GC_test_and_set(volatile unsigned int *addr) {         inline static int GC_test_and_set(volatile unsigned int *addr) {
           int oldval;            int oldval;
           /* Note: the "xchg" instruction does not need a "lock" prefix */            /* Note: the "xchg" instruction does not need a "lock" prefix */
Line 446  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 449  void GC_print_callers (/* struct callinfo info[NFRAMES
           return oldval;            return oldval;
        }         }
 #    else  #    else
        -- > Need implementation of GC_test_and_set()  #     if defined(POWERPC)
          inline static int GC_test_and_set(volatile unsigned int *addr) {
           int oldval;
           int temp = 1; // locked value
   
           __asm__ __volatile__(
                  "1:\tlwarx %0,0,%3\n"   // load and reserve
                  "\tcmpwi %0, 0\n"       // if load is
                  "\tbne 2f\n"            //   non-zero, return already set
                  "\tstwcx. %2,0,%1\n"    // else store conditional
                  "\tbne- 1b\n"           // retry if lost reservation
                  "2:\t\n"                // oldval is zero if we set
                 : "=&r"(oldval), "=p"(addr)
                 : "r"(temp), "1"(addr)
                 : "memory");
           return (int)oldval;
          }
   #     else
   #      ifdef ALPHA
            inline static int GC_test_and_set(volatile unsigned int *
   addr)
            {
              unsigned long oldvalue;
              unsigned long temp;
   
              __asm__ __volatile__(
                                   "1:     ldl_l %0,%1\n"
                                   "       and %0,%3,%2\n"
                                   "       bne %2,2f\n"
                                   "       xor %0,%3,%0\n"
                                   "       stl_c %0,%1\n"
                                   "       beq %0,3f\n"
                                   "       mb\n"
                                   "2:\n"
                                   ".section .text2,\"ax\"\n"
                                   "3:     br 1b\n"
                                   ".previous"
                                   :"=&r" (temp), "=m" (*addr), "=&r"
   (oldvalue)
                                   :"Ir" (1), "m" (*addr));
   
              return oldvalue;
            }
   #      else
            -- > Need implementation of GC_test_and_set()
   #      endif
   #     endif
 #    endif  #    endif
 #    define GC_clear(addr) (*(addr) = 0)       inline static void GC_clear(volatile unsigned int *addr) {
             *(addr) = 0;
        }
   
      extern volatile unsigned int GC_allocate_lock;       extern volatile unsigned int GC_allocate_lock;
         /* This is not a mutex because mutexes that obey the (optional)     */          /* This is not a mutex because mutexes that obey the (optional)     */
Line 462  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 513  void GC_print_callers (/* struct callinfo info[NFRAMES
 #    define NO_THREAD (pthread_t)(-1)  #    define NO_THREAD (pthread_t)(-1)
 #    define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD  #    define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
 #    define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))  #    define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))
 #    ifdef UNDEFINED  #    define LOCK() \
 #       define LOCK() pthread_mutex_lock(&GC_allocate_ml)  
 #       define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)  
 #    else  
 #       define LOCK() \  
                 { if (GC_test_and_set(&GC_allocate_lock)) GC_lock(); }                  { if (GC_test_and_set(&GC_allocate_lock)) GC_lock(); }
 #       define UNLOCK() \  #    define UNLOCK() \
                 GC_clear(&GC_allocate_lock)                  GC_clear(&GC_allocate_lock)
 #    endif  
      extern GC_bool GC_collecting;       extern GC_bool GC_collecting;
 #    define ENTER_GC() \  #    define ENTER_GC() \
                 { \                  { \
Line 478  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 524  void GC_print_callers (/* struct callinfo info[NFRAMES
                 }                  }
 #    define EXIT_GC() GC_collecting = 0;  #    define EXIT_GC() GC_collecting = 0;
 #  endif /* LINUX_THREADS */  #  endif /* LINUX_THREADS */
 #  if defined(IRIX_THREADS) || defined(IRIX_JDK_THREADS)  #  if defined(HPUX_THREADS)
 #    include <pthread.h>  #    include <pthread.h>
 #    include <mutex.h>       extern pthread_mutex_t GC_allocate_ml;
   #    define LOCK() pthread_mutex_lock(&GC_allocate_ml)
   #    define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
   #  endif
   #  if defined(IRIX_THREADS) || defined(IRIX_JDK_THREADS)
        /* This may also eventually be appropriate for HPUX_THREADS */
   #    include <pthread.h>
   #    ifndef HPUX_THREADS
           /* This probably should never be included, but I can't test     */
           /* on Irix anymore.                                             */
   #       include <mutex.h>
   #    endif
   
 #    if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) \  #    ifndef HPUX_THREADS
   #      if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) \
         || !defined(_COMPILER_VERSION) || _COMPILER_VERSION < 700          || !defined(_COMPILER_VERSION) || _COMPILER_VERSION < 700
 #        define GC_test_and_set(addr, v) test_and_set(addr,v)  #        define GC_test_and_set(addr, v) test_and_set(addr,v)
 #    else  #      else
 #        define GC_test_and_set(addr, v) __test_and_set(addr,v)  #        define GC_test_and_set(addr, v) __test_and_set(addr,v)
   #      endif
   #    else
          /* I couldn't find a way to do this inline on HP/UX      */
 #    endif  #    endif
      extern unsigned long GC_allocate_lock;       extern unsigned long GC_allocate_lock;
         /* This is not a mutex because mutexes that obey the (optional)         */          /* This is not a mutex because mutexes that obey the (optional)         */
Line 500  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 561  void GC_print_callers (/* struct callinfo info[NFRAMES
 #    define NO_THREAD (pthread_t)(-1)  #    define NO_THREAD (pthread_t)(-1)
 #    define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD  #    define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
 #    define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))  #    define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))
 #    ifdef UNDEFINED  #    ifdef HPUX_THREADS
 #       define LOCK() pthread_mutex_lock(&GC_allocate_ml)  #      define LOCK() { if (!GC_test_and_clear(&GC_allocate_lock)) GC_lock(); }
 #       define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)         /* The following is INCORRECT, since the memory model is too weak. */
   #      define UNLOCK() { GC_noop1(&GC_allocate_lock); \
                           *(volatile unsigned long *)(&GC_allocate_lock) = 1; }
 #    else  #    else
 #       define LOCK() { if (GC_test_and_set(&GC_allocate_lock, 1)) GC_lock(); }  #      define LOCK() { if (GC_test_and_set(&GC_allocate_lock, 1)) GC_lock(); }
 #       if __mips >= 3 && (defined (_ABIN32) || defined(_ABI64)) \  #      if __mips >= 3 && (defined (_ABIN32) || defined(_ABI64)) \
            && defined(_COMPILER_VERSION) && _COMPILER_VERSION >= 700             && defined(_COMPILER_VERSION) && _COMPILER_VERSION >= 700
 #           define UNLOCK() __lock_release(&GC_allocate_lock)  #           define UNLOCK() __lock_release(&GC_allocate_lock)
 #       else  #      else
             /* The function call in the following should prevent the    */              /* The function call in the following should prevent the    */
             /* compiler from moving assignments to below the UNLOCK.    */              /* compiler from moving assignments to below the UNLOCK.    */
             /* This is probably not necessary for ucode or gcc 2.8.     */              /* This is probably not necessary for ucode or gcc 2.8.     */
Line 516  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 579  void GC_print_callers (/* struct callinfo info[NFRAMES
             /* versions.                                                */              /* versions.                                                */
 #           define UNLOCK() { GC_noop1(&GC_allocate_lock); \  #           define UNLOCK() { GC_noop1(&GC_allocate_lock); \
                         *(volatile unsigned long *)(&GC_allocate_lock) = 0; }                          *(volatile unsigned long *)(&GC_allocate_lock) = 0; }
 #       endif  #      endif
 #    endif  #    endif
      extern GC_bool GC_collecting;       extern GC_bool GC_collecting;
 #    define ENTER_GC() \  #    define ENTER_GC() \
Line 607  void GC_print_callers (/* struct callinfo info[NFRAMES
Line 670  void GC_print_callers (/* struct callinfo info[NFRAMES
 # else  # else
 #   if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) \  #   if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) \
         || defined(IRIX_THREADS) || defined(LINUX_THREADS) \          || defined(IRIX_THREADS) || defined(LINUX_THREADS) \
         || defined(IRIX_JDK_THREADS)          || defined(IRIX_JDK_THREADS) || defined(HPUX_THREADS)
       void GC_stop_world();        void GC_stop_world();
       void GC_start_world();        void GC_start_world();
 #     define STOP_WORLD() GC_stop_world()  #     define STOP_WORLD() GC_stop_world()
Line 823  struct hblkhdr {
Line 886  struct hblkhdr {
     struct hblk * hb_next;      /* Link field for hblk free list         */      struct hblk * hb_next;      /* Link field for hblk free list         */
                                 /* and for lists of chunks waiting to be */                                  /* and for lists of chunks waiting to be */
                                 /* reclaimed.                            */                                  /* reclaimed.                            */
       struct hblk * hb_prev;      /* Backwards link for free list.        */
     word hb_descr;              /* object descriptor for marking.  See  */      word hb_descr;              /* object descriptor for marking.  See  */
                                 /* mark.h.                              */                                  /* mark.h.                              */
     char* hb_map;       /* A pointer to a pointer validity map of the block. */      char* hb_map;       /* A pointer to a pointer validity map of the block. */
Line 837  struct hblkhdr {
Line 901  struct hblkhdr {
 #       define IGNORE_OFF_PAGE  1       /* Ignore pointers that do not  */  #       define IGNORE_OFF_PAGE  1       /* Ignore pointers that do not  */
                                         /* point to the first page of   */                                          /* point to the first page of   */
                                         /* this object.                 */                                          /* this object.                 */
   #       define WAS_UNMAPPED 2   /* This is a free block, which has      */
                                   /* been unmapped from the address       */
                                   /* space.                               */
                                   /* GC_remap must be invoked on it       */
                                   /* before it can be reallocated.        */
                                   /* Only set with USE_MUNMAP.            */
     unsigned short hb_last_reclaimed;      unsigned short hb_last_reclaimed;
                                 /* Value of GC_gc_no when block was     */                                  /* Value of GC_gc_no when block was     */
                                 /* last allocated or swept. May wrap.   */                                  /* last allocated or swept. May wrap.   */
                                   /* For a free block, this is maintained */
                                   /* unly for USE_MUNMAP, and indicates   */
                                   /* when the header was allocated, or    */
                                   /* when the size of the block last      */
                                   /* changed.                             */
     word hb_marks[MARK_BITS_SZ];      word hb_marks[MARK_BITS_SZ];
                             /* Bit i in the array refers to the             */                              /* Bit i in the array refers to the             */
                             /* object starting at the ith word (header      */                              /* object starting at the ith word (header      */
                             /* INCLUDED) in the heap block.                 */                              /* INCLUDED) in the heap block.                 */
                             /* The lsb of word 0 is numbered 0.             */                              /* The lsb of word 0 is numbered 0.             */
                               /* Unused bits are invalid, and are             */
                               /* occasionally set, e.g for uncollectable      */
                               /* objects.                                     */
 };  };
   
 /*  heap block body */  /*  heap block body */
Line 959  struct _GC_arrays {
Line 1037  struct _GC_arrays {
   word _max_heapsize;    word _max_heapsize;
   ptr_t _last_heap_addr;    ptr_t _last_heap_addr;
   ptr_t _prev_heap_addr;    ptr_t _prev_heap_addr;
     word _large_free_bytes;
           /* Total bytes contained in blocks on large object free */
           /* list.                                                */
   word _words_allocd_before_gc;    word _words_allocd_before_gc;
                 /* Number of words allocated before this        */                  /* Number of words allocated before this        */
                 /* collection cycle.                            */                  /* collection cycle.                            */
Line 1005  struct _GC_arrays {
Line 1086  struct _GC_arrays {
                 /* Number of words in accessible atomic         */                  /* Number of words in accessible atomic         */
                 /* objects.                                     */                  /* objects.                                     */
 # endif  # endif
   # ifdef USE_MUNMAP
       word _unmapped_bytes;
   # endif
 # ifdef MERGE_SIZES  # ifdef MERGE_SIZES
     unsigned _size_map[WORDS_TO_BYTES(MAXOBJSZ+1)];      unsigned _size_map[WORDS_TO_BYTES(MAXOBJSZ+1)];
         /* Number of words to allocate for a given allocation request in */          /* Number of words to allocate for a given allocation request in */
Line 1022  struct _GC_arrays {
Line 1106  struct _GC_arrays {
                        /* to an object at                               */                         /* to an object at                               */
                        /* block_start+i&~3 - WORDS_TO_BYTES(j).         */                         /* block_start+i&~3 - WORDS_TO_BYTES(j).         */
                        /* (If ALL_INTERIOR_POINTERS is defined, then    */                         /* (If ALL_INTERIOR_POINTERS is defined, then    */
                        /* instead ((short *)(hbh_map[sz])[i] is j if    */                         /* instead ((short *)(hb_map[sz])[i] is j if     */
                        /* block_start+WORDS_TO_BYTES(i) is in the       */                         /* block_start+WORDS_TO_BYTES(i) is in the       */
                        /* interior of an object starting at             */                         /* interior of an object starting at             */
                        /* block_start+WORDS_TO_BYTES(i-j)).             */                         /* block_start+WORDS_TO_BYTES(i-j)).             */
Line 1135  GC_API GC_FAR struct _GC_arrays GC_arrays; 
Line 1219  GC_API GC_FAR struct _GC_arrays GC_arrays; 
 # define GC_prev_heap_addr GC_arrays._prev_heap_addr  # define GC_prev_heap_addr GC_arrays._prev_heap_addr
 # define GC_words_allocd GC_arrays._words_allocd  # define GC_words_allocd GC_arrays._words_allocd
 # define GC_words_wasted GC_arrays._words_wasted  # define GC_words_wasted GC_arrays._words_wasted
   # define GC_large_free_bytes GC_arrays._large_free_bytes
 # define GC_words_finalized GC_arrays._words_finalized  # define GC_words_finalized GC_arrays._words_finalized
 # define GC_non_gc_bytes_at_gc GC_arrays._non_gc_bytes_at_gc  # define GC_non_gc_bytes_at_gc GC_arrays._non_gc_bytes_at_gc
 # define GC_mem_freed GC_arrays._mem_freed  # define GC_mem_freed GC_arrays._mem_freed
Line 1144  GC_API GC_FAR struct _GC_arrays GC_arrays; 
Line 1229  GC_API GC_FAR struct _GC_arrays GC_arrays; 
 # define GC_words_allocd_before_gc GC_arrays._words_allocd_before_gc  # define GC_words_allocd_before_gc GC_arrays._words_allocd_before_gc
 # define GC_heap_sects GC_arrays._heap_sects  # define GC_heap_sects GC_arrays._heap_sects
 # define GC_last_stack GC_arrays._last_stack  # define GC_last_stack GC_arrays._last_stack
   # ifdef USE_MUNMAP
   #   define GC_unmapped_bytes GC_arrays._unmapped_bytes
   # endif
 # ifdef MSWIN32  # ifdef MSWIN32
 #   define GC_heap_bases GC_arrays._heap_bases  #   define GC_heap_bases GC_arrays._heap_bases
 # endif  # endif
Line 1236  extern char * GC_invalid_map;
Line 1324  extern char * GC_invalid_map;
                         /* Pointer to the nowhere valid hblk map */                          /* Pointer to the nowhere valid hblk map */
                         /* Blocks pointing to this map are free. */                          /* Blocks pointing to this map are free. */
   
 extern struct hblk * GC_hblkfreelist;  extern struct hblk * GC_hblkfreelist[];
                                 /* List of completely empty heap blocks */                                  /* List of completely empty heap blocks */
                                 /* Linked through hb_next field of      */                                  /* Linked through hb_next field of      */
                                 /* header structure associated with     */                                  /* header structure associated with     */
Line 1311  GC_bool GC_should_collect();
Line 1399  GC_bool GC_should_collect();
 void GC_apply_to_all_blocks(/*fn, client_data*/);  void GC_apply_to_all_blocks(/*fn, client_data*/);
                         /* Invoke fn(hbp, client_data) for each         */                          /* Invoke fn(hbp, client_data) for each         */
                         /* allocated heap block.                        */                          /* allocated heap block.                        */
 struct hblk * GC_next_block(/* struct hblk * h */);  struct hblk * GC_next_used_block(/* struct hblk * h */);
                           /* Return first in-use block >= h       */
   struct hblk * GC_prev_block(/* struct hblk * h */);
                           /* Return last block <= h.  Returned block      */
                           /* is managed by GC, but may or may not be in   */
                           /* use.                                         */
 void GC_mark_init();  void GC_mark_init();
 void GC_clear_marks();  /* Clear mark bits for all heap objects. */  void GC_clear_marks();  /* Clear mark bits for all heap objects. */
 void GC_invalidate_mark_state();        /* Tell the marker that marked     */  void GC_invalidate_mark_state();        /* Tell the marker that marked     */
Line 1384  extern void (*GC_start_call_back)(/* void */);
Line 1477  extern void (*GC_start_call_back)(/* void */);
                         /* lock held.                                   */                          /* lock held.                                   */
                         /* 0 by default.                                */                          /* 0 by default.                                */
 void GC_push_regs();    /* Push register contents onto mark stack.      */  void GC_push_regs();    /* Push register contents onto mark stack.      */
                           /* If NURSERY is defined, the default push      */
                           /* action can be overridden with GC_push_proc   */
 void GC_remark();       /* Mark from all marked objects.  Used  */  void GC_remark();       /* Mark from all marked objects.  Used  */
                         /* only if we had to drop something.    */                          /* only if we had to drop something.    */
   
   # ifdef NURSERY
       extern void (*GC_push_proc)(ptr_t);
   # endif
 # if defined(MSWIN32)  # if defined(MSWIN32)
   void __cdecl GC_push_one();    void __cdecl GC_push_one();
 # else  # else
Line 1608  extern void (*GC_print_heap_obj)(/* ptr_t p */);
Line 1707  extern void (*GC_print_heap_obj)(/* ptr_t p */);
                         /* detailed description of the object           */                          /* detailed description of the object           */
                         /* referred to by p.                            */                          /* referred to by p.                            */
   
   /* Memory unmapping: */
   #ifdef USE_MUNMAP
     void GC_unmap_old(void);
     void GC_merge_unmapped(void);
     void GC_unmap(ptr_t start, word bytes);
     void GC_remap(ptr_t start, word bytes);
     void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2);
   #endif
   
 /* Virtual dirty bit implementation:            */  /* Virtual dirty bit implementation:            */
 /* Each implementation exports the following:   */  /* Each implementation exports the following:   */
 void GC_read_dirty();   /* Retrieve dirty bits. */  void GC_read_dirty();   /* Retrieve dirty bits. */
Line 1640  void GC_print_heap_sects();
Line 1748  void GC_print_heap_sects();
 void GC_print_static_roots();  void GC_print_static_roots();
 void GC_dump();  void GC_dump();
   
   #ifdef KEEP_BACK_PTRS
      void GC_store_back_pointer(ptr_t source, ptr_t dest);
      void GC_marked_for_finalization(ptr_t dest);
   #  define GC_STORE_BACK_PTR(source, dest) GC_store_back_pointer(source, dest)
   #  define GC_MARKED_FOR_FINALIZATION(dest) GC_marked_for_finalization(dest)
   #else
   #  define GC_STORE_BACK_PTR(source, dest)
   #  define GC_MARKED_FOR_FINALIZATION(dest)
   #endif
   
 /* Make arguments appear live to compiler */  /* Make arguments appear live to compiler */
 # ifdef __WATCOMC__  # ifdef __WATCOMC__
   void GC_noop(void*, ...);    void GC_noop(void*, ...);
Line 1689  void GC_err_puts(/* char *s */);
Line 1807  void GC_err_puts(/* char *s */);
                         /* Write s to stderr, don't buffer, don't add   */                          /* Write s to stderr, don't buffer, don't add   */
                         /* newlines, don't ...                          */                          /* newlines, don't ...                          */
   
   
   #   ifdef GC_ASSERTIONS
   #       define GC_ASSERT(expr) if(!(expr)) {\
                   GC_err_printf2("Assertion failure: %s:%ld\n", \
                                   __FILE__, (unsigned long)__LINE__); \
                   ABORT("assertion failure"); }
   #   else
   #       define GC_ASSERT(expr)
   #   endif
   
 # endif /* GC_PRIVATE_H */  # endif /* GC_PRIVATE_H */
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>