~ubuntu-branches/ubuntu/trusty/gnustep-base/trusty

   Copyright (C) 1994-2010 Free Software Foundation, Inc.

   $Date: 2010-04-26 15:32:22 -0600 (Mon, 26 Apr 2010) $ $Revision: 30239 $

#import "common.h"

#import "Foundation/NSMethodSignature.h"

#import "Foundation/NSInvocation.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSAutoreleasePool.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSException.h"

#import "Foundation/NSPortCoder.h"

#import "Foundation/NSDistantObject.h"

#import "Foundation/NSThread.h"

#import "Foundation/NSNotification.h"

#import "Foundation/NSMapTable.h"

#import "GNUstepBase/GSLocale.h"

#ifdef __FreeBSD__

#include <fenv.h>

#endif

#import "GSPrivate.h"

static SEL finalize_sel;

static IMP finalize_imp;

@interface GSContentAccessingProxy : NSProxy 

{

  NSObject<NSDiscardableContent> *object;

}

- (id) initWithObject: (id)anObject;

@end

 

 * protecting the map table of zombie information.

static NSLock *allocationLock;

static NSMapTable       *zombieMap;

#if     !GS_WITH_GC

      [allocationLock lock];

      [allocationLock unlock];

#endif

      [allocationLock lock];

      [allocationLock unlock];

      NSLog(@"Deallocated object (%p) sent %@",

      NSLog(@"Deallocated %@ (%p) sent %@",

        c, o, NSStringFromSelector(sel));

 *      Reference counts for object are stored

 *      with the object.

 *      The zone in which an object has been

 *      allocated is stored with the object.

#if     defined(__MINGW__)

 

#elif defined(__llvm__) || (defined(USE_ATOMIC_BUILDINS) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)))

/* Use the GCC atomic operations with recent GCC versions */

 

typedef int32_t volatile *gsatomic_t;

#define GSATOMICREAD(X) (*(X))

#define GSAtomicIncrement(X)    __sync_fetch_and_add(X, 1)

#define GSAtomicDecrement(X)    __sync_fetch_and_sub(X, 1)

#elif defined(__PPC__) || defined(__POWERPC__)

    "0:"

    "bne- 0b \n"

    "0:"

    "bne- 0b \n"

#elif defined(__m68k__)

 

typedef int32_t volatile *gsatomic_t;

 

#define GSATOMICREAD(X) (*(X))

 

static __inline__ int

GSAtomicIncrement(gsatomic_t X)

{

  __asm__ __volatile__ (

    "addq%.l %#1, %0"

    :"=m" (*X));

    return *X;

}

 

static __inline__ int

GSAtomicDecrement(gsatomic_t X)

{

  __asm__ __volatile__ (

    "subq%.l %#1, %0"

    :"=m" (*X));

    return *X;

}

 

#elif defined(__mips__)

 

typedef int32_t volatile *gsatomic_t;

 

#define GSATOMICREAD(X) (*(X))

 

static __inline__ int

GSAtomicIncrement(gsatomic_t X)

{

  int tmp;

 

  __asm__ __volatile__ (

    "   .set  mips2  \n"

    "0: ll    %0, %1 \n"

    "   addiu %0, 1  \n"

    "   sc    %0, %1 \n"

    "   beqz  %0, 0b  \n"

    :"=&r" (tmp), "=m" (*X));

    return *X;

}

 

static __inline__ int

GSAtomicDecrement(gsatomic_t X)

{

  int tmp;

 

  __asm__ __volatile__ (

    "   .set  mips2  \n"

    "0: ll    %0, %1 \n"

    "   addiu %0, -1 \n"

    "   sc    %0, %1 \n"

    "   beqz  %0, 0b  \n"

    :"=&r" (tmp), "=m" (*X));

    return *X;

}

#if     !defined(GSATOMICREAD)

 * To alleviate this, instead of a single

static NSLock *allocationLocks[LOCKCOUNT] = { 0 };

static inline NSLock *GSAllocationLockForObject(id p)

  NSUInteger i = ((((NSUInteger)(uintptr_t)p) >> ALIGNBITS) & LOCKMASK);

    NSUInteger  retained;

    NSUInteger  retained;

      NSUInteger release_count;

      NSUInteger retain_count = [anObject retainCount];

      NSLock *theLock = GSAllocationLockForObject(anObject);

      [theLock lock];

          [theLock unlock];

          [theLock unlock];

#endif /* !GS_WITH_GC */

inline NSUInteger

#endif /* GS_WITH_GC */

      NSLock *theLock = GSAllocationLockForObject(anObject);

      [theLock lock];

          [theLock unlock];

      [theLock unlock];

#ifndef NDEBUG

#define AADD(c, o) GSDebugAllocationAdd(c, o)

#define AREM(c, o) GSDebugAllocationRemove(c, o)

#else

#define AADD(c, o) 

#define AREM(c, o) 

#endif

  GSOnceFLog(@"GSObjCZone() is deprecated ... use -zone instead");

  /* MacOS-X 10.5 seems to return the default malloc zone if GC is enabled.

   */

  return NSDefaultMallocZone();

  [(id)object finalize];

  AREM(((id)object)->class_pointer, (id)object);

static BOOL

GSIsFinalizable(Class c)

{

  if (get_imp(c, finalize_sel) != finalize_imp)

    return YES;

  return NO;

}

 

inline id

NSAllocateObject(Class aClass, NSUInteger extraBytes, NSZone *zone)

  GC_descr      gc_type;

  gc_type = (GC_descr)aClass->gc_object_type;

  size = class_getInstanceSize(aClass) + extraBytes;

  if (size % sizeof(void*) != 0)

    {

      /* Size must be a multiple of pointer size for the garbage collector

       * to be able to allocate explicitly typed memory.

       */

      size += sizeof(void*) - size % sizeof(void*);

    }

 

  if (gc_type == 0)

    {

      new = NSZoneCalloc(zone, 1, size);

      NSLog(@"No garbage collection information for '%s'",

        class_getName(aClass));

      new = GC_calloc_explicitly_typed(1, size, gc_type);

      if (GSIsFinalizable(aClass))

          /* We only do allocation counting for objects that can be

           * finalised - for other objects we have no way of decrementing

           * the count when the object is collected.

          AADD(aClass, new);

NSDeallocateObject(id anObject)

  GSOnceFLog(@"GSObjCZone() is deprecated ... use -zone instead");

  if (object_getClass(object) == NSConstantStringClass)

inline id

NSAllocateObject (Class aClass, NSUInteger extraBytes, NSZone *zone)

{

  size = class_getInstanceSize(aClass) + extraBytes + sizeof(struct obj_layout);

      AADD(aClass, new);

NSDeallocateObject(id anObject)

      NSZone    *z = o->zone;

      AREM(((id)anObject)->class_pointer, (id)anObject);

#endif  /* GS_WITH_GC */

 

 

void

GSPrivateSwizzle(id o, Class c)

{

  if ((Class)o->class_pointer != c)

    {

#if     GS_WITH_GC

      /* We only do allocation counting for objects that can be

       * finalised - for other objects we have no way of decrementing

       * the count when the object is collected.

       */

      if (GSIsFinalizable(o->class_pointer))

        {

          /* Already finalizable, so we just need to do any allocation

           * accounting.

           */

          AREM(o->class_pointer, o);

          AADD(c, o);

        }

      else if (GSIsFinalizable(c))

        {

          /* New class is finalizable, so we must register the instance

           * for finalisation and do allocation acounting for it.

           */

          AADD(c, o);

          GC_REGISTER_FINALIZER (o, GSFinalize, NULL, NULL, NULL);

        }

      AREM(o->class_pointer, o);

      AADD(c, o);

      o->class_pointer = c;

    }

}

 

    || [anObject zone] == requestedZone);

/* FIXME ... the following code is a hack for the gnu runtime only

 */

 

/* Must have same layout as ivars of Protocol class

 */

struct protocol_class {

  Class isa;

  char  *protocol_name;

  struct objc_protocol_list *protocol_list;

  struct objc_method_description_list *instance_methods;

  struct objc_method_description_list *class_methods;

};

GSDescriptionForInstanceMethod(Protocol *self, SEL aSel)

  struct protocol_class *pcl = (struct protocol_class*)self;

  const char                    *name = sel_getName(aSel);

  if (pcl->instance_methods != 0)

      for (i = 0; i < pcl->instance_methods->count; i++)

          if (!strcmp ((char*)pcl->instance_methods->list[i].name, name))

            return &(pcl->instance_methods->list[i]);

  for (p_list = pcl->protocol_list; p_list != 0; p_list = p_list->next)

          result = GSDescriptionForInstanceMethod(p_list->list[i], aSel);

GSDescriptionForClassMethod(Protocol *self, SEL aSel)

  struct protocol_class *pcl = (struct protocol_class*)self;

  const char                    *name = sel_getName(aSel);

  if (pcl->class_methods != 0)

      for (i = 0; i < pcl->class_methods->count; i++)

          if (!strcmp ((char*)pcl->class_methods->list[i].name, name))

            return &(pcl->class_methods->list[i]);

  for (p_list = pcl->protocol_list; p_list != 0; p_list = p_list->next)

          result = GSDescriptionForClassMethod(p_list->list[i], aSel);

  return GSDescriptionForInstanceMethod(self, aSel);

  return GSDescriptionForClassMethod(self, aSel);

#if !defined(GSATOMICREAD)

      NSUInteger        i;

          allocationLocks[i] = [NSLock new];

      allocationLock = [NSLock new];

/* Function to log Boehm GC warnings

 * NB. This must not allocate any collectable memory as it may result

 * in a deadlock in the garbage collecting library.

 */

static void

GSGarbageCollectorLog(char *msg, GC_word arg)

{

  char  buf[strlen(msg)+1024];

  sprintf(buf, msg, (unsigned long)arg);

  fprintf(stderr, "Garbage collector: %s", buf);

}

#endif

 

/**

 * Semi-private function in libobjc2 that initialises the classes used for

 * blocks.

 */

#ifndef __MINGW__

BOOL 

objc_create_block_classes_as_subclasses_of(Class super) __attribute__((weak));

#endif

 

+ (void)load

{

#ifndef __MINGW__

  /* When NSObject is loaded, register it as the superclass of the block

   * classes */

  if (objc_create_block_classes_as_subclasses_of)

    objc_create_block_classes_as_subclasses_of(self);

#endif

}

 

#if     GS_WITH_GC

      /* Make sure that the garbage collection library is initialised.

       * This is not necessary on most platforms, but is good practice.

       */

      GC_init();

      GC_set_warn_proc(GSGarbageCollectorLog);

#endif

 

#ifdef __MINGW__

      {

        // See libgnustep-base-entry.m

        extern void gnustep_base_socket_init(void);     

        gnustep_base_socket_init();     

      }

#else /* __MINGW__ */

#else /* HAVE_SIGACTION */

        void    (*handler)(NSInteger);

#endif /* HAVE_SIGACTION */

#endif /* SIGPIPE */

#endif /* __MINGW__ */

 

#if     GS_WITH_GC

      finalize_sel = @selector(finalize);

      finalize_imp = get_imp(self, finalize_sel);

      fedisableexcept(FE_INVALID);

      // Behavior debugging

      GSObjCBehaviorDebug(GSPrivateEnvironmentFlag("GNUSTEP_BEHAVIOR_DEBUG",

        GSObjCBehaviorDebug(-1)));