* simplify mulle_objc_object_call for debugging

Author: Nat!

src/mulle-objc-call.c

@@ -57,17 +57,45 @@
 
 #pragma mark - non-inline API calls
 
-
-// we can't do the FCS code here, because its just super slow if
+//
+// mulle_objc_object_call is what objc_msgSend is on other runtimes
+// (at least in -O0)
+//
+// MEMO: this has been rewritten for 0.24. The main advantage is, that this
+//       function will not explode a stack trace as much with non-inlined
+//       functions in DEBUG configuration. The second major advantage is
+//       that in a C debugger, once you go into mulle_objc_object_call you
+//       can just step over _mulle_objc_object_get_imp_inline_full_no_fcs and
+//       then step into (*f)( obj, methodid, parameter) in most cases.
+//
+// We don't do the FCS code here, because its just super slow if
 // the constant isn't known.
-// 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,
                                 void *parameter)
 {
-   return( mulle_objc_object_call_inline_full( obj, methodid, parameter));
+   mulle_objc_implementation_t   f;
+
+   if( MULLE_C_UNLIKELY( ! obj))
+      return( obj);
+
+   // INFO: in a C debugger, 'next' over this function call
+   f = _mulle_objc_object_get_imp_inline_full_no_fcs( obj, methodid);
+
+   // INFO: in a C debugger, 'step' into this to reach the Objective-C method
+   //       when the `f` has been cached. Otherwise:
+   //
+   //       if `f` is _mulle_objc_object_call2_needcache you will need to
+   //       step to _mulle_objc_object_call_class_slow. This will happen once
+   //       per class on the very first method.
+   //
+   //       if `f` is _mulle_objc_object_callback_cache_miss, the call to the
+   //       Objective-C method will be at the end of the function
+   //
+
+   return( (*f)( obj, methodid, parameter));
 }
 
 
@@ -77,7 +105,11 @@ void   *_mulle_objc_object_call( void *obj,
                                  mulle_objc_methodid_t methodid,
                                  void *parameter)
 {
-   return( _mulle_objc_object_call_inline_full( obj, methodid, parameter));
+   mulle_objc_implementation_t   f;
+
+   f = _mulle_objc_object_get_imp_inline_full_no_fcs( obj, methodid);
+   // don't use invoke, because the checking will have been done in icache->call_cache_miss
+   return( (*f)( obj, methodid, parameter));
 }
 
 

src/mulle-objc-call.h

@@ -103,6 +103,17 @@ void   mulle_objc_implementation_debug( mulle_objc_implementation_t imp,
 }
 
 
+MULLE_C_ALWAYS_INLINE
+static inline void  *
+   _mulle_objc_implementation_invoke( mulle_objc_implementation_t imp,
+                                      void *self,
+                                      mulle_objc_methodid_t sel,
+                                      void *parameter)
+{
+   return( (*imp)( self, sel, parameter));
+}
+
+
 
 MULLE_C_ALWAYS_INLINE
 static inline void  *
@@ -119,6 +130,7 @@ static inline void  *
 }
 
 
+
 //
 // calls are always "nofail", whereas lookup can fail (and return nil)
 // calls can return nil too, often, do but that's not a fail
@@ -163,6 +175,18 @@ MULLE_C_ALWAYS_INLINE static inline void  *
 
 #ifdef __MULLE_OBJC_FCS__
 
+MULLE_C_ALWAYS_INLINE
+static inline void   *
+   _mulle_objc_fastmethodtable_get_imp( struct _mulle_objc_fastmethodtable *table,
+                                        unsigned int index)
+{
+   mulle_objc_implementation_t   imp;
+
+   imp = (mulle_objc_implementation_t) _mulle_atomic_pointer_read( &table->methods[ index].pointer);
+   return( imp);
+}
+
+
 MULLE_C_ALWAYS_INLINE
 static inline void   *
    _mulle_objc_fastmethodtable_invoke( void *obj,
@@ -297,6 +321,59 @@ static inline void  *
 }
 
 
+MULLE_C_ALWAYS_INLINE
+static inline void  *
+   _mulle_objc_object_get_imp_inline_full_no_fcs( void *obj,
+                                                  mulle_objc_methodid_t methodid)
+{
+   mulle_objc_implementation_t     f;
+   struct _mulle_objc_cache        *cache;
+   struct _mulle_objc_impcache     *icache;
+   struct _mulle_objc_cacheentry   *entries;
+   struct _mulle_objc_cacheentry   *entry;
+   struct _mulle_objc_class        *cls;
+   mulle_objc_cache_uint_t         mask;
+   mulle_objc_cache_uint_t         offset;
+
+   //
+   // with tagged pointers inlining starts to become useless, because this
+   // _mulle_objc_object_get_isa function produces too much code IMO
+   //
+   cls = _mulle_objc_object_get_isa( obj);
+
+   assert( methodid);
+
+   // MEMO: When inlining, we are "fine" if the cache is stale
+   entries = _mulle_objc_cachepivot_get_entries_atomic( &cls->cachepivot.pivot);
+   cache   = _mulle_objc_cacheentry_get_cache_from_entries( entries);
+   mask    = cache->mask;  // preshifted so we can just AND it to entries
+   offset  = (mulle_objc_cache_uint_t) methodid;
+   for(;;)
+   {
+      offset  = (mulle_objc_cache_uint_t) offset & mask;
+      entry   = (void *) &((char *) entries)[ offset];
+
+      if( MULLE_C_LIKELY( entry->key.uniqueid == methodid))
+      {
+         f = (mulle_objc_implementation_t) _mulle_atomic_pointer_read_nonatomic( &entry->value.pointer);
+         break;
+      }
+
+      if( ! entry->key.uniqueid)
+      {
+         icache = _mulle_objc_cache_get_impcache_from_cache( cache);
+         f      = icache->callback.call_cache_miss;
+         break;
+      }
+      offset += sizeof( struct _mulle_objc_cacheentry);
+   }
+
+   // don't use invoke, because the checking will be done in icache->call_cache_miss
+   return( f);
+}
+
+
+
 //
 // same as above, but we don't stop at the first miss. This adds some looping
 // code to the inlined function, you might or might not deep acceptable. So

src/mulle-objc-class-initialize.c

@@ -191,9 +191,9 @@ static void
    struct _mulle_objc_universe          *universe;
    struct _mulle_objc_searcharguments   search;
    struct _mulle_objc_searchresult      result;
+   mulle_objc_implementation_t          imp;
    int                                  preserve;
    int                                  is_initialize;
-   mulle_objc_implementation_t          imp;
 
    preserve = errno;
 
@@ -523,10 +523,12 @@ static void   *_mulle_objc_object_call_class_slow( void *obj,
 {
    struct _mulle_objc_method     *method;
    mulle_objc_implementation_t   imp;
+   void                          *result;
 
    method = mulle_objc_class_search_method_nofail( cls, methodid);
    imp    = _mulle_objc_method_get_implementation( method);
-   return( mulle_objc_implementation_invoke( imp, obj, methodid, parameter));
+   result = mulle_objc_implementation_invoke( imp, obj, methodid, parameter);
+   return( result);
 }
 
 
@@ -537,11 +539,13 @@ static void   *_mulle_objc_object_call2_slow( void *obj,
    struct _mulle_objc_class      *cls;
    struct _mulle_objc_method     *method;
    mulle_objc_implementation_t   imp;
+   void                          *result;
 
    cls    = _mulle_objc_object_get_isa( obj);
    method = mulle_objc_class_search_method_nofail( cls, methodid);
    imp    = _mulle_objc_method_get_implementation( method);
-   return( mulle_objc_implementation_invoke( imp, obj, methodid, parameter));
+   result = mulle_objc_implementation_invoke( imp, obj, methodid, parameter);
+   return( result);
 }
 
 
@@ -554,12 +558,14 @@ static void *
 {
    struct _mulle_objc_method     *method;
    mulle_objc_implementation_t   imp;
+   void                          *result;
 
    MULLE_C_UNUSED( obj);
 
    method = _mulle_objc_class_supersearch_method_nofail( cls, superid);
    imp    = _mulle_objc_method_get_implementation( method);
-   return( mulle_objc_implementation_invoke( imp, obj, methodid, parameter));
+   result = mulle_objc_implementation_invoke( imp, obj, methodid, parameter);
+   return( result);
 }
 
 
@@ -583,8 +589,11 @@ static void   *_mulle_objc_object_call_class_needcache( void *obj,
                                                         void *parameter,
                                                         struct _mulle_objc_class *cls)
 {
+   void   *result;
+
    _mulle_objc_class_setup( cls);
-   return( _mulle_objc_object_call_class_slow( obj, methodid, parameter, cls));
+   result = _mulle_objc_object_call_class_slow( obj, methodid, parameter, cls);
+   return( result);
 }
 
 
@@ -594,29 +603,33 @@ static void   *_mulle_objc_object_call2_needcache( void *obj,
                                                    void *parameter)
 {
    struct _mulle_objc_class   *cls;
+   void                       *result;
 
-   cls = _mulle_objc_object_get_isa( (struct _mulle_objc_object *) obj);
-   return( _mulle_objc_object_call_class_needcache( obj, methodid, parameter, cls));
+   cls    = _mulle_objc_object_get_isa( (struct _mulle_objc_object *) obj);
+   result = _mulle_objc_object_call_class_needcache( obj, methodid, parameter, cls);
+   return( result);
 }
 
 
 static void *
    _mulle_objc_object_call_super_needcache( void *obj,
-                                           mulle_objc_methodid_t methodid,
-                                           void *parameter,
-                                           mulle_objc_superid_t superid,
-                                           struct _mulle_objc_class *cls)
+                                            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_method     *method;
+   void                          *result;
 
    // happens when we do +[super initialize] in +initialize
    _mulle_objc_class_setup( cls);
 
    // this is slow and uncached as we need it
    method = _mulle_objc_class_search_supermethod_nofail( cls, superid);
    imp    = _mulle_objc_method_get_implementation( method);
-   return( mulle_objc_implementation_invoke( imp, obj, methodid, parameter));
+   result = mulle_objc_implementation_invoke( imp, obj, methodid, parameter);
+   return( result);
 }
 
 

src/mulle-objc-load.c

@@ -1434,17 +1434,17 @@ void    mulle_objc_universe_assert_loadinfo( struct _mulle_objc_universe *univer
    {
       mulle_objc_loadinfo_dump( info, "loadinfo:   ", universe);
       mulle_objc_universe_fail_inconsistency( universe,
-         "mulle_objc_universe %p: the universe is configured for "
-         "thread affine objects, but classes are compiled differently",
+         "mulle_objc_universe %p: the runtime is compiled for "
+         "thread affine objects -fobjc-tao, but classes are compiled -fno-objc-tao",
              universe);
    }
 #else
    if( load_tao)
    {
       mulle_objc_loadinfo_dump( info, "loadinfo:   ", universe);
       mulle_objc_universe_fail_inconsistency( universe,
-         "mulle_objc_universe %p: the universe is not configured for "
-         "thread affine objects, but classes are compiled differently",
+         "mulle_objc_universe %p: the runtime is compiled for "
+         "no thread affine objects -fno-objc-tao, but classes are compiled -fobjc-tao",
              universe);
    }
 #endif