Class.c File Reference

#include "Config.h"
#include <assert.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <link.h>
#include "Class.h"
#include "Object.h"

Go to the source code of this file.

Macros
#define	MAX_CLASS_IMAGES   8
	The registered images providing Classes.

Functions
ident	_alloc (Class *clazz)
	Instantiate a type through the given Class.
ident	_cast (const Class *clazz, const ident obj)
	Perform a type-checking cast.
Class *	_initialize (const ClassDef *def)
	Initializes the given Class.
void	addClassImage (ident handle)
	Registers an image that provides Classes, e.g. a plugin.
Class *	classForName (const char *name)
static const ident	imageForAddress (const ident address)
static ident	imageForHandle (ident handle)
ident	release (ident obj)
	Atomically decrement the given Object's reference count. If the resulting reference count is 0, the Object is deallocated.
void	removeClassImage (ident handle)
	Unregisters an image, and every Class it declared.
ident	retain (ident obj)
	Atomically increment the given Object's reference count.
static void	setup (void)
	Called when initializing Object to setup Objectively.
static void	teardown (void)
	Called atexit to teardown Objectively.

Variables
static Class *	_classes
static size_t	_classImageCount
static ident	_classImages [MAX_CLASS_IMAGES]
size_t	_pageSize

Macro Definition Documentation

MAX_CLASS_IMAGES

#define MAX_CLASS_IMAGES   8

The registered images providing Classes.

Remarks

This is a plain array rather than a MutableArray because Class is beneath the collections: initializing one here would reenter _initialize. Images are added and removed as they are loaded and closed, not per lookup.

Definition at line 57 of file Class.c.

Function Documentation

_alloc()

ident _alloc

(

Class *

clazz

)

Instantiate a type through the given Class.

Definition at line 170 of file Class.c.

                           {
 
  ident obj = calloc(1, clazz->def.instanceSize);
  assert(obj);
 
  Object *object = (Object *) obj;
 
  object->magic = OBJECTIVELY_MAGIC;
  object->clazz = clazz;
  object->referenceCount = 1;
 
  ident interface = clazz->interface;
  do {
    *(ident *) (obj + clazz->def.interfaceOffset) = interface;
  } while ((clazz = clazz->def.superclass));
 
  return obj;
}

_cast()

ident _cast	(	const Class *	clazz,
		const ident	obj
	)

Perform a type-checking cast.

Definition at line 189 of file Class.c.

                                                 {
 
  if (obj) {
    const Class *c = ((Object *) obj)->clazz;
    while (c) {
 
      // as a special case, we optimize for _Object
      if (c == clazz || clazz == _Object()) {
        break;
      }
 
      c = c->def.superclass;
    }
    assert(c);
  }
 
  return (ident) obj;
}

_initialize()

Class * _initialize

(

const ClassDef *

clazz

)

Initializes the given Class.

Parameters

clazz

The Class descriptor.

Returns

The initialized Class.

Definition at line 129 of file Class.c.

                                        {
 
  static Once once;
  do_once(&once, setup());
 
  assert(def);
  assert(def->name);
  assert(def->instanceSize);
  assert(def->interfaceSize);
  assert(def->interfaceOffset);
 
  Class *clazz = calloc(1, sizeof(Class));
  assert(clazz);
 
  clazz->def = *def;
 
  clazz->interface = calloc(1, def->interfaceSize);
  assert(clazz->interface);
 
  Class *superclass = clazz->def.superclass;
  if (superclass) {
 
    assert(superclass->def.instanceSize <= def->instanceSize);
    assert(superclass->def.interfaceSize <= def->interfaceSize);
 
    memcpy(clazz->interface, superclass->interface, superclass->def.interfaceSize);
  }
 
  if (clazz->def.initialize) {
    clazz->def.initialize(clazz);
  }
 
  /* def.name is a literal in the declaring image, where the ClassDef itself is
   * a compound literal with automatic storage. */
  clazz->image = imageForAddress((ident) def->name);
 
  clazz->next = __sync_lock_test_and_set(&_classes, clazz);
 
  return clazz;
}

addClassImage()

void addClassImage

(

ident

handle

)

Registers an image that provides Classes, e.g. a plugin.

Parameters

handle

A handle from dlopen.

classForName resolves a name it has not yet initialized through the process-wide namespace, which holds only images loaded RTLD_GLOBAL, and which Windows does not have at all. An application that loads Classes from a plugin registers it here instead, and may then load it RTLD_LOCAL - which is how it keeps two plugins exporting the same symbols from coalescing.

Remarks

Registered images are searched most recently added first, so a newly loaded plugin answers ahead of the one it replaced.

Resolution is by Objectively's own convention, the Class name prefixed with an underscore, so nothing about the image has to be declared.

Definition at line 284 of file Class.c.

                                 {
 
  assert(handle);
  assert(_classImageCount < MAX_CLASS_IMAGES);
 
  _classImages[_classImageCount++] = handle;
}

classForName()

Class * classForName

(

const char *

name

)

Returns

The Class with the given name, or NULL if no such Class has been initialized.

Remarks

Classes already initialized are answered first, then each registered image, then the process-wide namespace.

Definition at line 292 of file Class.c.

                                      {
 
  if (name) {
    Class *c = _classes;
    while (c) {
      if (strcmp(name, c->def.name) == 0) {
        return c;
      }
      c = c->next;
    }
 
    char *s;
    if (asprintf(&s, "_%s", name) > 0) {
      Class *clazz = NULL;
      Class *(*archetype)(void) = NULL;
 
      for (size_t i = _classImageCount; i > 0 && archetype == NULL; i--) {
        archetype = dlsym(_classImages[i - 1], s);
      }
 
      if (archetype == NULL) {
#if defined(_WIN32)
        static Once once;
        static ident handle;
        do_once(&once, { handle = dlopen(NULL, RTLD_LAZY); });
        archetype = handle ? dlsym(handle, s) : NULL;
#else
        archetype = dlsym(RTLD_DEFAULT, s);
#endif
      }
 
      if (archetype) {
        clazz = archetype();
      }
 
      free(s);
      return clazz;
    }
  }
 
  return NULL;
}

imageForAddress()

static const ident imageForAddress ( const ident  address )

static

Returns

The base address of the image containing address, or NULL.

Remarks

The Windows dlfcn shim has no dladdr. UNCHANGED_REFCOUNT matters: without it this would pin the very module the caller is about to release.

Definition at line 109 of file Class.c.

                                                        {
 
  assert(address);
 
#if defined(_WIN32)
  HMODULE module;
  if (GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
      GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCSTR) address, &module)) {
    return module;
  }
#else
  Dl_info info;
  if (dladdr(address, &info)) {
    return info.dli_fbase;
  }
#endif
 
  return NULL;
}

imageForHandle()

static ident imageForHandle ( ident  handle )

static

Returns

The base address of the image behind handle, or NULL.

Remarks

There is no one call for this. Windows hands out the module itself as the handle, which GetModuleFileName confirms rather than assumes; glibc answers from the link map; and macOS, which has neither, is left with matching the handle against the loaded images.

Definition at line 215 of file Class.c.

                                          {
 
  assert(handle);
 
#if defined(_WIN32)
  char path[MAX_PATH];
  if (GetModuleFileNameA((HMODULE) handle, path, sizeof(path))) {
    return handle;
  }
#elif defined(__APPLE__)
  for (uint32_t i = 0; i < _dyld_image_count(); i++) {
 
    /* RTLD_LOCAL is not the default on macOS, and dlopen of an image already
     * loaded promotes it to the global namespace, which would put every image in
     * the process there - undoing the isolation the caller loaded it for. */
    ident image = dlopen(_dyld_get_image_name(i), RTLD_LAZY | RTLD_NOLOAD | RTLD_LOCAL);
    if (image == NULL) {
      continue;
    }
 
    dlclose(image);
 
    if (image == handle) {
      return (ident) _dyld_get_image_header(i);
    }
  }
#else
  struct link_map *map;
  if (dlinfo(handle, RTLD_DI_LINKMAP, &map) == 0 && map) {
    return (ident) map->l_addr;
  }
#endif
 
  return NULL;
}

release()

ident release

(

ident

obj

)

Atomically decrement the given Object's reference count. If the resulting reference count is 0, the Object is deallocated.

Returns

This function always returns NULL.

Definition at line 335 of file Class.c.

                         {
 
  if (obj) {
    Object *object = cast(Object, obj);
 
    assert(object);
 
    if (__sync_add_and_fetch(&object->referenceCount, -1) == 0) {
      $(object, dealloc);
    }
  }
 
  return NULL;
}

removeClassImage()

void removeClassImage

(

ident

handle

)

Unregisters an image, and every Class it declared.

Parameters

handle

The handle given to addClassImage.

Remarks

Classes initialized from an image outlive it otherwise: they are cached by name, and classForName answers from that cache ahead of any image. On a platform where closing an image really unmaps it - which dlclose does on Linux and FreeLibrary does on Windows - the next lookup would then read a ClassDef that is no longer mapped. classForName compares the name of every Class it walks, so one left behind breaks every lookup, not only its own.

The Classes are not destroyed, and this is not an oversight. dlclose does not unmap on macOS, so an archetype that has already run keeps answering from its own static Class * for as long as the process lives, and would hand back whatever this freed. Unregistering is the only thing that is safe whether the image goes away or stays: the Class becomes unreachable by name, and remains valid for the archetype that owns it. The cost is the Class and its interface, which are not reclaimed.

MUST be called while the handle is still open, and only once nothing instantiated from that image survives.

Definition at line 251 of file Class.c.

                                    {
 
  assert(handle);
 
  for (size_t i = 0; i < _classImageCount; i++) {
    if (_classImages[i] == handle) {
 
      memmove(_classImages + i, _classImages + i + 1,
          (_classImageCount - i - 1) * sizeof(ident));
 
      _classImages[--_classImageCount] = NULL;
      break;
    }
  }
 
  const ident image = imageForHandle(handle);
  if (image == NULL) {
    return;
  }
 
  Class **link = &_classes;
  while (*link) {
    Class *clazz = *link;
 
    if (clazz->image == image) {
      *link = clazz->next;
      clazz->next = NULL;
    } else {
      link = &clazz->next;
    }
  }
}

retain()

ident retain

(

ident

obj

)

Atomically increment the given Object's reference count.

Returns

The Object.

Remarks

By calling this, the caller is expressing ownership of the Object, and preventing it from being released. Be sure to balance calls to retain with calls to release.

Definition at line 350 of file Class.c.

                        {
 
  Object *object = cast(Object, obj);
 
  assert(object);
 
  __sync_add_and_fetch(&object->referenceCount, 1);
 
  return obj;
}

setup()

static void setup ( void  )

static

Called when initializing Object to setup Objectively.

Definition at line 91 of file Class.c.

                        {
 
  _classes = NULL;
 
#if !defined(_SC_PAGESIZE)
  _pageSize = 4096;
#else
  _pageSize = sysconf(_SC_PAGESIZE);
#endif
 
  atexit(teardown);
}

teardown()

static void teardown ( void  )

static

Called atexit to teardown Objectively.

Definition at line 64 of file Class.c.

                           {
  Class *c;
 
  c = _classes;
  while (c) {
    if (c->def.destroy) {
      c->def.destroy(c);
    }
 
    c = c->next;
  }
 
  c = _classes;
  while (c) {
 
    Class *next = c->next;
 
    free(c->interface);
    free(c);
 
    c = next;
  }
}

Variable Documentation

_classes

Class* _classes

static

Definition at line 49 of file Class.c.

_classImageCount

size_t _classImageCount

static

Definition at line 59 of file Class.c.

_classImages

ident _classImages[MAX_CLASS_IMAGES]

static

Definition at line 58 of file Class.c.

_pageSize

size_t _pageSize

Definition at line 47 of file Class.c.