* change in mulle_objc_object_get_property_value where now a strategy value is passed as an int, containing multiple bits (like atomicity)

* the impcache gained a lot of callbacks, and the Objective-C methods were changed to use them. The callbacks were also renamed to make them a bit more telling
* protocolclasses `+inititalize` is now run on each adopting class and subclass (this is freaky and useful)
* slightly improved method search traces
* -release and -retain are no long fast methods, since they are usually inlined anyway this frees up two slots that are put to other use
* new `for` functions for methodlists, propertylists etc. (still experimental)
* functions that use method calls (like `mulle_objc_object_call_dealloc` now)
* add support for the `noautorelease` @Property attribute
fixes for tagged pointer float/double code

Author: mulle-nat

.gitignore

@@ -72,6 +72,6 @@ build-*
 coverage*.html
 *.gcda
 *.gcno
+/demo/
 cola/wilted/
-demo/
 *.executable

src/mulle-objc-builtin.h

@@ -145,6 +145,16 @@ static inline void   assert_same_mulle_allocator( struct _mulle_objc_object *sel
 # define assert_same_mulle_allocator( self, value)
 #endif
 
+enum mulle_objc_property_accessor_strategy
+{
+   mulle_objc_property_accessor_autorelease   = 0x0,   // default
+   mulle_objc_property_accessor_noautorelease = 0x1,   // getter
+   mulle_objc_property_accessor_atomic        = 0x2,   // getter + setter
+   mulle_objc_property_accessor_copy          = 0x4,   // setter
+   mulle_objc_property_accessor_mutable_copy  = 0x8    // setter
+};
+
+
 //
 // this is called by the compiler for retain or copy of objects only
 // TODO: conceivably move this out of the runtime. This should optimize
@@ -155,30 +165,30 @@ static inline void
                                          mulle_objc_methodid_t _cmd,
                                          ptrdiff_t offset,
                                          struct _mulle_objc_object *value,
-                                         char is_atomic,
-                                         char is_copy)
+                                         int strategy)
 {
    void   **p_ivar;
    void   *old;
 
    if( ! self)
       return;
 
-   if( is_copy)
+   if( strategy & mulle_objc_property_accessor_copy)
    {
-      if( is_copy == 2)  // da apple way
+      if( strategy & mulle_objc_property_accessor_mutable_copy)  // da apple way
          value = mulle_objc_object_call_mutablecopy( value);
       else
          value = mulle_objc_object_call_copy( value);
    }
    else
-      mulle_objc_object_retain( value);
+      mulle_objc_object_call_retain( value);
 
    assert_same_mulle_allocator( self, value);
 
    p_ivar = (void **) &((char *) self)[ offset];
-   if( is_atomic)
+   if( strategy & mulle_objc_property_accessor_atomic)
    {
+      // TODO: old and wrong (fix)
       old = _mulle_atomic_pointer_set( (mulle_atomic_pointer_t *) p_ivar, value);
       mulle_objc_object_call_autorelease( old);
    }
@@ -189,22 +199,40 @@ static inline void
    }
 }
 
-
+MULLE_C_ALWAYS_INLINE
 static inline void   *
    mulle_objc_object_get_property_value( void *self,
                                          mulle_objc_methodid_t _cmd,
                                          ptrdiff_t offset,
-                                         char is_atomic)
+                                         int strategy)
 {
-   void  **p_ivar;
+   void                            **p_ivar;
+   void                            *value;
+   struct _mulle_objc_foundation   *foundation;
+   struct _mulle_objc_universe     *universe;
 
    if( ! self)
       return( NULL);
 
    p_ivar = (void **) &((char *) self)[ offset];
-   if( is_atomic)
-      return( _mulle_atomic_pointer_read( (mulle_atomic_pointer_t *) p_ivar));
-   return( *p_ivar);
+   if( strategy & mulle_objc_property_accessor_atomic)
+   {
+      // TODO: wrong (fix!) can race with autorelease
+      value = _mulle_atomic_pointer_read( (mulle_atomic_pointer_t *) p_ivar);
+   }
+   else
+      value = *p_ivar;
+
+   if( strategy & mulle_objc_property_accessor_noautorelease)
+      return( value);
+
+   if( value)
+   {
+      universe   = _mulle_objc_object_get_universe( value);
+      foundation = _mulle_objc_universe_get_foundation( universe);
+      value      = (*foundation->retain_autorelease)( value);
+   }
+   return( value);
 }
 
 

src/mulle-objc-cache.c

@@ -67,7 +67,7 @@ struct _mulle_objc_cache   *mulle_objc_cache_new( mulle_objc_cache_uint_t size,
    cache    = _mulle_allocator_calloc( allocator, 1, s_cache);
    errno    = preserve;
 
-   mulle_objc_cache_init( cache, size);
+   _mulle_objc_cache_init( cache, size);
 
    return( cache);
 }
@@ -233,7 +233,7 @@ unsigned int   mulle_objc_cache_calculate_fillpercentage( struct _mulle_objc_cac
       return( 0);
 
    n = (intptr_t) _mulle_atomic_pointer_read( &cache->n);
-   return( (unsigned int)  (n * 100 + (cache->size / 2)) / cache->size);
+   return( (unsigned int) (n * 100 + (cache->size / 2)) / cache->size);
 }
 
 

src/mulle-objc-cache.h

@@ -106,7 +106,7 @@ struct _mulle_objc_cache
 
 
 // incoming cache must have been zero filled already
-static inline void   mulle_objc_cache_init( struct _mulle_objc_cache *cache,
+static inline void   _mulle_objc_cache_init( struct _mulle_objc_cache *cache,
                                             mulle_objc_cache_uint_t size)
 {
    assert( ! (sizeof( struct _mulle_objc_cacheentry) & (sizeof( struct _mulle_objc_cacheentry) - 1)));

src/mulle-objc-call.c

@@ -60,8 +60,8 @@
 
 // we can't do the FCS code here, because its just super slow if
 // the constant isn't known.
-// This is like call2, except that we need do check the first
-// cache entry.
+// This is like call_cache_collision, except that we still need do check the
+// first cache entry.
 MULLE_C_NEVER_INLINE
 void   *mulle_objc_object_call( void *obj,
                                 mulle_objc_methodid_t methodid,
@@ -169,29 +169,6 @@ void   mulle_objc_implementation_trace( mulle_objc_implementation_t imp,
 
 
 
-static void   mulle_objc_object_fail_thread_affinity( struct _mulle_objc_object *obj,
-                                                      mulle_thread_t affinity_thread,
-                                                      char *name)
-{
-   struct _mulle_objc_universe   *universe;
-   struct _mulle_objc_class      *cls;
-   int                           ismeta;
-
-   cls      = _mulle_objc_object_get_isa( obj);
-   ismeta   = _mulle_objc_class_is_metaclass( cls);
-   universe = _mulle_objc_class_get_universe( cls);
-
-   mulle_objc_universe_fail_generic( universe,
-                                     "%s <%s %p> with affinity to thread %p gets a -%s call from thread %p",
-                                     ismeta ? "Class" : "Object",
-                                     _mulle_objc_class_get_name( cls),
-                                     obj,
-                                     affinity_thread,
-                                     name,
-                                     mulle_thread_self());
-}
-
-
 // MEMO: TAO and the Cache
 //
 // When we do TAO, we need to call this often. The idea is that all methods
@@ -278,9 +255,11 @@ void   mulle_objc_object_taocheck_call( void *obj,
    case _mulle_objc_methodfamily_init    :
    case _mulle_objc_methodfamily_dealloc :
       return;
+   default :
+      break;
    }
 
-   // forward: is not "methodid", that's what we foward to
+   // forward: is not "methodid", that's what we forward to
    if( method->descriptor.methodid == MULLE_OBJC_FORWARD_METHODID)
       return;
 
@@ -291,7 +270,7 @@ void   mulle_objc_object_taocheck_call( void *obj,
    if( _mulle_objc_universe_is_deinitializing( universe))
       return;
 
-   mulle_objc_object_fail_thread_affinity( obj, object_thread, _mulle_objc_descriptor_get_name( desc));
+   mulle_objc_universe_fail_wrongthread( universe, obj, object_thread, desc);
 }
 
 
@@ -310,6 +289,7 @@ static void   *_mulle_objc_object_callback_class( void *obj,
    mulle_objc_implementation_t      imp;
    mulle_functionpointer_t          p;
    struct _mulle_objc_cache         *cache;
+   struct _mulle_objc_impcache      *icache;
    struct _mulle_objc_cacheentry    *entries;
    struct _mulle_objc_cacheentry    *entry;
    struct _mulle_objc_method        *method;
@@ -339,7 +319,8 @@ static void   *_mulle_objc_object_callback_class( void *obj,
 
       if( ! entry->key.uniqueid)
       {
-         method = _mulle_objc_class_refresh_method_nofail( cls, methodid);
+         icache = _mulle_objc_cache_get_impcache_from_cache( cache);
+         method = (*icache->callback.refresh_method_nofail)( cls, methodid);
          imp    = _mulle_objc_method_get_implementation( method);
          imp    = _mulle_objc_implementation_debug( imp, obj, methodid, parameter, cls);
          break;
@@ -358,13 +339,14 @@ static void   *_mulle_objc_object_callback_class( void *obj,
 // collision, it skips the first found entry. This method is put into
 // the method cache, you don't call it directly.
 //
-static void   *_mulle_objc_object_callback2( void *obj,
-                                             mulle_objc_methodid_t methodid,
-                                             void *parameter)
+static void   *_mulle_objc_object_callback_cache_collision( void *obj,
+                                                            mulle_objc_methodid_t methodid,
+                                                            void *parameter)
 {
    mulle_objc_implementation_t     imp;
    mulle_functionpointer_t         p;
    struct _mulle_objc_cache        *cache;
+   struct _mulle_objc_impcache      *icache;
    struct _mulle_objc_cacheentry   *entries;
    struct _mulle_objc_cacheentry   *entry;
    struct _mulle_objc_method       *method;
@@ -395,7 +377,8 @@ static void   *_mulle_objc_object_callback2( void *obj,
 
       if( ! entry->key.uniqueid)
       {
-         method = _mulle_objc_class_refresh_method_nofail( cls, methodid);
+         icache = _mulle_objc_cache_get_impcache_from_cache( cache);
+         method = (*icache->callback.refresh_method_nofail)( cls, methodid);
          imp    = _mulle_objc_method_get_implementation( method);
          imp    = _mulle_objc_implementation_debug( imp, obj, methodid, parameter, cls);
          break;
@@ -407,20 +390,48 @@ static void   *_mulle_objc_object_callback2( void *obj,
 }
 
 
+//
+// this function is called, when there is no entry in the cache
+//
+static void   *_mulle_objc_object_callback_cache_miss( void *obj,
+                                                       mulle_objc_methodid_t methodid,
+                                                       void *parameter)
+{
+   mulle_objc_implementation_t     imp;
+   struct _mulle_objc_method       *method;
+   struct _mulle_objc_class        *cls;
+   struct _mulle_objc_impcache     *icache;
+   struct _mulle_objc_cache        *cache;
+   struct _mulle_objc_cacheentry   *entries;
+
+   assert( mulle_objc_uniqueid_is_sane( methodid));
+
+   cls     = _mulle_objc_object_get_isa( obj);
+   entries = _mulle_objc_cachepivot_get_entries_atomic( &cls->cachepivot.pivot);
+   cache   = _mulle_objc_cacheentry_get_cache_from_entries( entries);
+   icache  = _mulle_objc_cache_get_impcache_from_cache( cache);
+   method  = (*icache->callback.refresh_method_nofail)( cls, methodid);
+   imp     = _mulle_objc_method_get_implementation( method);
+   imp     = _mulle_objc_implementation_debug( imp, obj, methodid, parameter, cls);
+   return( (*imp)( obj, methodid, parameter));
+}
+
+
 //
 // This function is called, when the first inline cache check gave a
 // collision, it skips the first found entry. This is not called directly
 // but placed into the method cache.
 //
 static void *
-   _mulle_objc_object_call_superback( void *obj,
+   _mulle_objc_object_callback_super( void *obj,
                                      mulle_objc_methodid_t methodid,
                                      void *parameter,
                                      mulle_objc_superid_t superid,
                                      struct _mulle_objc_class *cls)
 {
    mulle_objc_implementation_t     imp;
    struct _mulle_objc_cache        *cache;
+   struct _mulle_objc_impcache     *icache;
    struct _mulle_objc_cacheentry   *entries;
    struct _mulle_objc_cacheentry   *entry;
    struct _mulle_objc_method       *method;
@@ -445,7 +456,8 @@ static void *
       }
       if( ! entry->key.uniqueid)
       {
-         method = _mulle_objc_class_refresh_supermethod_nofail( cls, superid);
+         icache = _mulle_objc_cache_get_impcache_from_cache( cache);
+         method = (*icache->callback.refresh_supermethod_nofail)( cls, superid);
          imp    = _mulle_objc_method_get_implementation( method);
          imp    = _mulle_objc_implementation_debug( imp, obj, methodid, parameter, cls);
          break;
@@ -458,14 +470,15 @@ static void *
 
 
 static void *
-   _mulle_objc_object_call_superback2( void *obj,
-                                      mulle_objc_methodid_t methodid,
-                                      void *parameter,
-                                      mulle_objc_superid_t superid,
-                                      struct _mulle_objc_class *cls)
+   _mulle_objc_object_callback_super_cache_collision( void *obj,
+                                                      mulle_objc_methodid_t methodid,
+                                                      void *parameter,
+                                                      mulle_objc_superid_t superid,
+                                                      struct _mulle_objc_class *cls)
 {
    mulle_objc_implementation_t     imp;
    struct _mulle_objc_cache        *cache;
+   struct _mulle_objc_impcache     *icache;
    struct _mulle_objc_cacheentry   *entries;
    struct _mulle_objc_cacheentry   *entry;
    struct _mulle_objc_method       *method;
@@ -492,7 +505,8 @@ static void *
 
       if( ! entry->key.uniqueid)
       {
-         method = _mulle_objc_class_refresh_supermethod_nofail( cls, superid);
+         icache = _mulle_objc_cache_get_impcache_from_cache( cache);
+         method = (*icache->callback.refresh_supermethod_nofail)( cls, superid);
          imp    = _mulle_objc_method_get_implementation( method);
          imp    = _mulle_objc_implementation_debug( imp, obj, methodid, parameter, cls);
          break;
@@ -502,15 +516,43 @@ static void *
 }
 
 
-void  _mulle_objc_impcache_init_normal_callbacks( struct _mulle_objc_impcache *p)
+static void *
+   _mulle_objc_object_callback_super_cache_miss( void *obj,
+                                                 mulle_objc_methodid_t methodid,
+                                                 void *parameter,
+                                                 mulle_objc_superid_t superid,
+                                                 struct _mulle_objc_class *cls)
 {
-   p->call       = _mulle_objc_object_callback_class;
-   p->call2      = _mulle_objc_object_callback2;
-   p->supercall  = _mulle_objc_object_call_superback;  // public actually
-   p->supercall2 = _mulle_objc_object_call_superback2;
+   mulle_objc_implementation_t     imp;
+   struct _mulle_objc_method       *method;
+   struct _mulle_objc_impcache     *icache;
+   struct _mulle_objc_cache        *cache;
+   struct _mulle_objc_cacheentry   *entries;
+
+   entries = _mulle_objc_cachepivot_get_entries_atomic( &cls->cachepivot.pivot);
+   cache   = _mulle_objc_cacheentry_get_cache_from_entries( entries);
+   icache  = _mulle_objc_cache_get_impcache_from_cache( cache);
+   method  = (*icache->callback.refresh_supermethod_nofail)( cls, superid);
+   imp     = _mulle_objc_method_get_implementation( method);
+   imp     = _mulle_objc_implementation_debug( imp, obj, methodid, parameter, cls);
+   return( (*imp)( obj, methodid, parameter));
 }
 
 
+struct _mulle_objc_impcache_callback   _mulle_objc_impcache_callback_normal =
+{
+   .call                       = _mulle_objc_object_callback_class,
+   .call_cache_collision       = _mulle_objc_object_callback_cache_collision,
+   .call_cache_miss            = _mulle_objc_object_callback_cache_miss,
+   .supercall                  = _mulle_objc_object_callback_super,  // public actually
+   .supercall_cache_collision  = _mulle_objc_object_callback_super_cache_collision,
+   .supercall_cache_miss       = _mulle_objc_object_callback_super_cache_miss,
+
+   .refresh_method_nofail      = _mulle_objc_class_refresh_method_nofail,
+   .refresh_supermethod_nofail = _mulle_objc_class_refresh_supermethod_nofail
+};
+
+
 // need to call cls->call to prepare caches
 
 #pragma mark - multiple objects call
@@ -557,7 +599,6 @@ void   mulle_objc_objects_call( void **objects,
          assert( imp);
       }
 
-      // this should use mulle_objc_implementation_invoke
       mulle_objc_implementation_invoke( lastSelIMP[ i], p, methodid, params);
    }
 }