libobjc/accessors.m

   1 /* GNU Objective C Runtime accessors functions
   2    Copyright (C) 2010-2020 Free Software Foundation, Inc.
   3    Contributed by Nicola Pero
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under the
   8 terms of the GNU General Public License as published by the Free Software
   9 Foundation; either version 3, or (at your option) any later version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14 details.
  15
  16 Under Section 7 of GPL version 3, you are granted additional
  17 permissions described in the GCC Runtime Library Exception, version
  18 3.1, as published by the Free Software Foundation.
  19
  20 You should have received a copy of the GNU General Public License and
  21 a copy of the GCC Runtime Library Exception along with this program;
  22 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 #include "objc-private/common.h"
  26 #include "objc/objc.h"
  27 #include "objc/thr.h"
  28 #include <string.h>                    /* For memcpy */
  29
  30 /* This file contains functions that the compiler uses when
  31    synthesizing accessors (getters/setters) for properties.  The
  32    functions are part of the ABI, but are meant to be used by the
  33    compiler and not by users; for this reason, they are not declared
  34    in public header files.  The compiler automatically generates
  35    declarations for these functions.  */
  36
  37 /* Properties can be "atomic", which requires protecting them from
  38    concurrency issues using a lock.  Unfortunately, we can't have a
  39    lock for each property, so we'll go with a small pool of locks.
  40    Any time a property is accessed in an "atomic" way, we pick a
  41    random lock from the pool (random, but always the same one for the
  42    same property of the same object) and use it to protect access to
  43    the property.
  44
  45    The size of the pool is currently 16.  A bigger pool can help
  46    reduce contention, ie, reduce the chances that two threads,
  47    operating on unrelated properties, will have to wait for each other
  48    because the properties use the same lock.  16 seems big enough at
  49    the moment.  */
  50 #define ACCESSORS_NUMBER_OF_LOCKS 16
  51
  52 #define ACCESSORS_HASH(POINTER) ((((size_t)POINTER >> 8) ^ (size_t)POINTER) & (ACCESSORS_NUMBER_OF_LOCKS - 1))
  53
  54 static objc_mutex_t accessors_locks[ACCESSORS_NUMBER_OF_LOCKS];
  55
  56 /* This is called at startup to setup the locks.  */
  57 void
  58 __objc_accessors_init (void)
  59 {
  60   int i;
  61
  62   for (i = 0; i < ACCESSORS_NUMBER_OF_LOCKS; i++)
  63     accessors_locks[i] = objc_mutex_allocate ();
  64 }
  65
  66 /* The property accessors automatically call various methods from the
  67    Foundation library (eg, GNUstep-base).  These methods are not
  68    implemented here, but we need to declare them so we can compile the
  69    runtime.  The Foundation library will need to provide
  70    implementations of these methods (most likely in the root class,
  71    eg, NSObject) as the accessors only work with objects of classes
  72    that implement these methods.  */
  73 @interface _libobjcNSObject
  74 - (id) copyWithZone: (void *)zone;
  75 - (id) mutableCopyWithZone: (void *)zone;
  76 @end
  77 #define COPY(X)         [((_libobjcNSObject *)(X)) copyWithZone: NULL]
  78 #define MUTABLE_COPY(X) [((_libobjcNSObject *)(X)) mutableCopyWithZone: NULL]
  79
  80
  81 #if OBJC_WITH_GC
  82
  83 #  define AUTORELEASE(X)  (X)
  84 #  define RELEASE(X)
  85 #  define RETAIN(X)       (X)
  86
  87 #else
  88
  89 @interface _libobjcNSObject (RetainReleaseMethods)
  90 - (id) autorelease;
  91 - (oneway void) release;
  92 - (id) retain;
  93 @end
  94 #  define AUTORELEASE(X)  [((_libobjcNSObject *)(X)) autorelease]
  95 #  define RELEASE(X)      [((_libobjcNSObject *)(X)) release]
  96 #  define RETAIN(X)       [((_libobjcNSObject *)(X)) retain]
  97
  98 #endif
  99
 100 /* The compiler uses this function when implementing some synthesized
 101    getters for properties of type 'id'.  */
 102 id
 103 objc_getProperty (id self, SEL __attribute__((unused)) _cmd, ptrdiff_t offset, BOOL is_atomic)
 104 {
 105   if (self != nil)
 106     {
 107       id *pointer_to_ivar = (id *)((char *)self + offset);
 108
 109
 110       if (is_atomic == NO)
 111         {
 112           /* Note that in this case, we do not RETAIN/AUTORELEASE the
 113              returned value.  The programmer should do it if it is
 114              needed.  Since access is non-atomic, other threads can be
 115              ignored and the caller has full control of what happens
 116              to the object and whether it needs to be RETAINed or not,
 117              so it makes sense to leave the decision to him/her.  This
 118              is also what the Apple/NeXT runtime does.  */
 119           return *pointer_to_ivar;
 120         }
 121       else
 122         {
 123           objc_mutex_t lock = accessors_locks[ACCESSORS_HASH (pointer_to_ivar)];
 124           id result;
 125
 126           objc_mutex_lock (lock);
 127           result = RETAIN (*(pointer_to_ivar));
 128           objc_mutex_unlock (lock);
 129
 130           return AUTORELEASE (result);
 131         }
 132     }
 133
 134   return nil;
 135 }
 136
 137 /* The compiler uses this function when implementing some synthesized
 138    setters for properties of type 'id'.
 139
 140    PS: Note how 'should_copy' is declared 'BOOL' but then actually
 141    takes values from 0 to 2.  This hack was introduced by Apple; we
 142    do the same for compatibility reasons.  */
 143 void
 144 objc_setProperty (id self, SEL __attribute__((unused)) _cmd, ptrdiff_t offset, id new_value, BOOL is_atomic, BOOL should_copy)
 145 {
 146   if (self != nil)
 147     {
 148       id *pointer_to_ivar = (id *)((char *)self + offset);
 149       id retained_value;
 150 #if !OBJC_WITH_GC
 151       id old_value;
 152 #endif
 153
 154       switch (should_copy)
 155         {
 156         case 0: /* retain */
 157           {
 158             if (*pointer_to_ivar == new_value)
 159               return;
 160             retained_value = RETAIN (new_value);
 161             break;
 162           }
 163         case 2: /* mutable copy */
 164           {
 165             retained_value = MUTABLE_COPY (new_value);
 166             break;
 167           }
 168         case 1: /* copy */
 169         default:
 170           {
 171             retained_value = COPY (new_value);
 172             break;
 173           }
 174         }
 175
 176       if (is_atomic == NO)
 177         {
 178 #if !OBJC_WITH_GC
 179           old_value = *pointer_to_ivar;
 180 #endif
 181           *pointer_to_ivar = retained_value;
 182         }
 183       else
 184         {
 185           objc_mutex_t lock = accessors_locks[ACCESSORS_HASH (pointer_to_ivar)];
 186
 187           objc_mutex_lock (lock);
 188 #if !OBJC_WITH_GC
 189           old_value = *pointer_to_ivar;
 190 #endif
 191           *pointer_to_ivar = retained_value;
 192           objc_mutex_unlock (lock);
 193         }
 194 #if !OBJC_WITH_GC
 195       RELEASE (old_value);
 196 #endif
 197     }
 198 }
 199
 200 /* The compiler uses this function when implementing some synthesized
 201    getters for properties of arbitrary C types.  The data is just
 202    copied.  Compatibility Note: this function does not exist in the
 203    Apple/NeXT runtime.  */
 204 void
 205 objc_getPropertyStruct (void *destination, const void *source, ptrdiff_t size, BOOL is_atomic, BOOL __attribute__((unused)) has_strong)
 206 {
 207   if (is_atomic == NO)
 208     memcpy (destination, source, size);
 209   else
 210     {
 211       objc_mutex_t lock = accessors_locks[ACCESSORS_HASH (source)];
 212
 213       objc_mutex_lock (lock);
 214       memcpy (destination, source, size);
 215       objc_mutex_unlock (lock);
 216     }
 217 }
 218
 219 /* The compiler uses this function when implementing some synthesized
 220    setters for properties of arbitrary C types.  The data is just
 221    copied.  Compatibility Note: this function does not exist in the
 222    Apple/NeXT runtime.  */
 223 void
 224 objc_setPropertyStruct (void *destination, const void *source, ptrdiff_t size, BOOL is_atomic, BOOL __attribute__((unused)) has_strong)
 225 {
 226   if (is_atomic == NO)
 227     memcpy (destination, source, size);
 228   else
 229     {
 230       objc_mutex_t lock = accessors_locks[ACCESSORS_HASH (destination)];
 231
 232       objc_mutex_lock (lock);
 233       memcpy (destination, source, size);
 234       objc_mutex_unlock (lock);
 235     }
 236 }
 237
 238 /* This is the function that the Apple/NeXT runtime has instead of
 239    objc_getPropertyStruct and objc_setPropertyStruct.  We include it
 240    for API compatibility (just for people who may have used
 241    objc_copyStruct on the NeXT runtime thinking it was a public API);
 242    the compiler never generates calls to it with the GNU runtime.
 243    This function is clumsy because it requires two locks instead of
 244    one.  */
 245 void
 246 objc_copyStruct (void *destination, const void *source, ptrdiff_t size, BOOL is_atomic, BOOL __attribute__((unused)) has_strong)
 247 {
 248   if (is_atomic == NO)
 249     memcpy (destination, source, size);
 250   else
 251     {
 252       /* We don't know which one is the property, so we have to lock
 253          both.  One of them is most likely a temporary buffer in the
 254          local stack and we really wouldn't want to lock it (our
 255          objc_getPropertyStruct and objc_setPropertyStruct functions
 256          don't lock it).  Note that if we're locking more than one
 257          accessor lock at once, we need to always lock them in the
 258          same order to avoid deadlocks.  */
 259       objc_mutex_t first_lock;
 260       objc_mutex_t second_lock;
 261
 262       if (ACCESSORS_HASH (source) == ACCESSORS_HASH (destination))
 263         {
 264           /* A lucky collision.  */
 265           first_lock = accessors_locks[ACCESSORS_HASH (source)];
 266           objc_mutex_lock (first_lock);
 267           memcpy (destination, source, size);
 268           objc_mutex_unlock (first_lock);
 269           return;
 270         }
 271
 272       if (ACCESSORS_HASH (source) > ACCESSORS_HASH (destination))
 273         {
 274           first_lock = accessors_locks[ACCESSORS_HASH (source)];
 275           second_lock = accessors_locks[ACCESSORS_HASH (destination)];
 276         }
 277       else
 278         {
 279           first_lock = accessors_locks[ACCESSORS_HASH (destination)];
 280           second_lock = accessors_locks[ACCESSORS_HASH (source)];
 281         }
 282
 283       objc_mutex_lock (first_lock);
 284       objc_mutex_lock (second_lock);
 285       memcpy (destination, source, size);
 286       objc_mutex_unlock (second_lock);
 287       objc_mutex_unlock (first_lock);
 288     }
 289 }