ObjFW  Check-in [4c72b5544f]

SRCS_THREADS = threading.m	\
	       ../threading.m
INCLUDES = ObjFW_RT.h
includesubdir = ObjFW_RT

OBJS_EXTRA = ${LOOKUP_ASM_LOOKUP_ASM_A}
LIB_OBJS_EXTRA = ${LOOKUP_ASM_LOOKUP_ASM_LIB_A}
AMIGA_LIB_OBJS_EXTRA = amiga-glue.amigalib.o		\
		       amiga-library.amigalib.o		\
		       ${LOOKUP_ASM_LOOKUP_ASM_A}

include ../../buildsys.mk

ppcinline.h: ObjFW_RT.fd protos.h
	cvinclude.pl			\
		--root ObjFW_RT		\
		--fd ObjFW_RT.fd	\

##base _ObjFWRTBase
##bias 30
##public
* Functions for the glue code
objc_set_libc(libc)(A0)
* Used by the compiler - these need glue code
glue___objc_exec_class(module)(A0)
glue_objc_msg_lookup(obj, sel)(A0/A1)
glue_objc_msg_lookup_stret(obj, sel)(A0/A1)
glue_objc_msg_lookup_super(super, sel)(A0/A1)
glue_objc_msg_lookup_super_stret(super, sel)(A0/A1)
glue_objc_lookUpClass(name)(A0)
glue_objc_getClass(name)(A0)
glue_objc_getRequiredClass(name)(A0)
glue_objc_exception_throw(object)(A0)
glue_objc_sync_enter(object)(A0)
glue_objc_sync_exit(object)(A0)
glue_objc_getProperty(self, _cmd, offset, atomic)(A0/A1/D0/D1)
glue_objc_setProperty(self, _cmd, offset, value, atomic, copy)(A0/A1/D0/A2/D1/D2)
glue_objc_getPropertyStruct(dest, src, size, atomic, strong)(A0/A1/D0/D1/D2)
glue_objc_setPropertyStruct(dest, src, size, atomic, strong)(A0/A1/D0/D1/D2)
glue_objc_enumerationMutation(obj)(A0)
* Functions declared in ObjFW_RT.h
sel_registerName(name)(A0)
sel_getName(sel)(A0)
sel_isEqual(sel1, sel2)(A0/A1)
objc_allocateClassPair(superclass, name, extra_bytes)(A0/A1/D0)
objc_registerClassPair(cls)(A0)
objc_getClassList(buf, count)(A0/D0)
objc_copyClassList(len)(A0)
class_isMetaClass(cls)(A0)
class_getName(cls)(A0)
class_getSuperclass(cls)(A0)
class_getInstanceSize(cls)(A0)
class_respondsToSelector(cls, sel)(A0/A1)
class_conformsToProtocol(cls, p)(A0/A1)

#if defined(__amigaos__) && !defined(__MORPHOS__) && !defined(__amigaos4__)
# define OBJC_M68K_REG(reg) __asm__(reg)
#else
# define OBJC_M68K_REG(reg)
#endif
#if defined(__MORPHOS__) && defined(OBJC_AMIGA_LIBRARY)
# define OBJC_M68K_FUNC(name, ...) name(void)
# define OBJC_M68K_ARG(type, name, reg) type name = (type)reg;
#else
# define OBJC_M68K_FUNC(name, ...) name(__VA_ARGS__)
# define OBJC_M68K_ARG(type, name, reg)
#endif

typedef struct objc_class *Class;

# ifdef OF_AMIGAOS
extern struct Library *ObjFWRTBase;
# endif

/*
 * Used by the compiler, but can also be called manually.
 *


 * These declarations are also required to prevent Clang's implicit
 * declarations which include __declspec(dllimport) on Windows.
 */
struct objc_abi_module;
extern void __objc_exec_class(void *_Nonnull module);
extern IMP _Nonnull objc_msg_lookup(id _Nullable obj, SEL _Nonnull sel);
extern IMP _Nonnull objc_msg_lookup_stret(id _Nullable obj, SEL _Nonnull sel);
extern IMP _Nonnull objc_msg_lookup_super(struct objc_super *_Nonnull super,
    SEL _Nonnull sel);
extern IMP _Nonnull objc_msg_lookup_super_stret(
    struct objc_super *_Nonnull super, SEL _Nonnull sel);
extern id _Nullable objc_lookUpClass(const char *_Nonnull name);
extern id _Nullable objc_getClass(const char *_Nonnull name);
extern id _Nonnull objc_getRequiredClass(const char *_Nonnull name);
extern void objc_exception_throw(id _Nullable object);
extern int objc_sync_enter(id _Nullable object);
extern int objc_sync_exit(id _Nullable object);
extern id _Nullable objc_getProperty(id _Nonnull self, SEL _Nonnull _cmd,
    ptrdiff_t offset, bool atomic);
extern void objc_setProperty(id _Nonnull self, SEL _Nonnull _cmd,
    ptrdiff_t offset, id _Nullable value, bool atomic, signed char copy);
extern void objc_getPropertyStruct(void *_Nonnull dest,
    const void *_Nonnull src, ptrdiff_t size, bool atomic, bool strong);
extern void objc_setPropertyStruct(void *_Nonnull dest,
    const void *_Nonnull src, ptrdiff_t size, bool atomic, bool strong);
extern void objc_enumerationMutation(id _Nonnull obj);

# ifdef OBJC_AMIGA_LIBRARY
extern void glue___objc_exec_class(void *_Nonnull module OBJC_M68K_REG("a0"));
extern IMP _Nonnull glue_objc_msg_lookup(id _Nullable obj OBJC_M68K_REG("a0"),
    SEL _Nonnull sel OBJC_M68K_REG("a1"));
extern IMP _Nonnull glue_objc_msg_lookup_stret(
    id _Nullable obj OBJC_M68K_REG("a0"), SEL _Nonnull sel OBJC_M68K_REG("a1"));
extern IMP _Nonnull glue_objc_msg_lookup_super(
    struct objc_super *_Nonnull super OBJC_M68K_REG("a0"),
    SEL _Nonnull sel OBJC_M68K_REG("a1"));
extern IMP _Nonnull glue_objc_msg_lookup_super_stret(
    struct objc_super *_Nonnull super OBJC_M68K_REG("a0"),
    SEL _Nonnull sel OBJC_M68K_REG("a1"));
extern id _Nullable glue_objc_lookUpClass(
    const char *_Nonnull name OBJC_M68K_REG("a0"));
extern id _Nullable glue_objc_getClass(
    const char *_Nonnull name OBJC_M68K_REG("a0"));
extern id _Nonnull glue_objc_getRequiredClass(
    const char *_Nonnull name OBJC_M68K_REG("a0"));
extern void glue_objc_exception_throw(id _Nullable object OBJC_M68K_REG("a0"));
extern int glue_objc_sync_enter(id _Nullable object OBJC_M68K_REG("a0"));
extern int glue_objc_sync_exit(id _Nullable object OBJC_M68K_REG("a0"));
extern id _Nullable glue_objc_getProperty(id _Nonnull self OBJC_M68K_REG("a0"),
    SEL _Nonnull _cmd OBJC_M68K_REG("a1"), ptrdiff_t offset OBJC_M68K_REG("d0"),
    bool atomic OBJC_M68K_REG("d1"));
extern void glue_objc_setProperty(id _Nonnull self OBJC_M68K_REG("a0"),
    SEL _Nonnull _cmd OBJC_M68K_REG("a1"), ptrdiff_t offset OBJC_M68K_REG("d0"),
    id _Nullable value OBJC_M68K_REG("a2"), bool atomic OBJC_M68K_REG("d1"),
    signed char copy OBJC_M68K_REG("d2"));
extern void glue_objc_getPropertyStruct(void *_Nonnull dest OBJC_M68K_REG("a0"),
    const void *_Nonnull src OBJC_M68K_REG("a1"),
    ptrdiff_t size OBJC_M68K_REG("d0"), bool atomic OBJC_M68K_REG("d1"),
    bool strong OBJC_M68K_REG("d2"));
extern void glue_objc_setPropertyStruct(void *_Nonnull dest OBJC_M68K_REG("a0"),
    const void *_Nonnull src OBJC_M68K_REG("a1"),
    ptrdiff_t size OBJC_M68K_REG("d0"), bool atomic OBJC_M68K_REG("d1"),
    bool strong OBJC_M68K_REG("d2"));
extern void glue_objc_enumerationMutation(id _Nonnull obj OBJC_M68K_REG("a0"));
# endif
#ifdef __cplusplus
}
#endif

#endif

/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
 *               2018
 *   Jonathan Schleifer <js@heap.zone>
 *
 * All rights reserved.
 *
 * This file is part of ObjFW. It may be distributed under the terms of the
 * Q Public License 1.0, which can be found in the file LICENSE.QPL included in
 * the packaging of this file.
 *
 * Alternatively, it may be distributed under the terms of the GNU General
 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#import "ObjFW_RT.h"
#import "private.h"
#import "macros.h"

void
__objc_exec_class(void *module)
{
	glue___objc_exec_class(module);
}

IMP
objc_msg_lookup(id obj, SEL sel)
{
	return glue_objc_msg_lookup(obj, sel);
}

IMP
objc_msg_lookup_stret(id obj, SEL sel)
{
	return glue_objc_msg_lookup_stret(obj, sel);
}

IMP
objc_msg_lookup_super(struct objc_super *super, SEL sel)
{
	return glue_objc_msg_lookup_super(super, sel);
}

IMP
objc_msg_lookup_super_stret(struct objc_super *super, SEL sel)
{
	return glue_objc_msg_lookup_super_stret(super, sel);
}

id
objc_lookUpClass(const char *name)
{
	return glue_objc_lookUpClass(name);
}

id
objc_getClass(const char *name)
{
	return glue_objc_getClass(name);
}

id
objc_getRequiredClass(const char *name)
{
	return glue_objc_getRequiredClass(name);
}

void
objc_exception_throw(id object)
{
	glue_objc_exception_throw(object);

	OF_UNREACHABLE
}

int
objc_sync_enter(id object)
{
	return glue_objc_sync_enter(object);
}

int
objc_sync_exit(id object)
{
	return glue_objc_sync_exit(object);
}

id
objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, bool atomic)
{
	return glue_objc_getProperty(self, _cmd, offset, atomic);
}

void
objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id value, bool atomic,
    signed char copy)
{
	glue_objc_setProperty(self, _cmd, offset, value, atomic, copy);
}

void
objc_getPropertyStruct(void *dest, const void *src, ptrdiff_t size, bool atomic,
    bool strong)
{
	glue_objc_getPropertyStruct(dest, src, size, atomic, strong);
}

void
objc_setPropertyStruct(void *dest, const void *src, ptrdiff_t size, bool atomic,
    bool strong)
{
	glue_objc_setPropertyStruct(dest, src, size, atomic, strong);
}

void
objc_enumerationMutation(id obj)
{
	glue_objc_enumerationMutation(obj);
}

	(ULONG)lib_open,
	(ULONG)lib_close,
	(ULONG)lib_expunge,
	(ULONG)lib_null,
	/* Functions for the glue code */
	(ULONG)objc_set_libc,
	/* Used by the compiler - these need glue code */
	(ULONG)glue___objc_exec_class,
	(ULONG)glue_objc_msg_lookup,
	(ULONG)glue_objc_msg_lookup_stret,
	(ULONG)glue_objc_msg_lookup_super,
	(ULONG)glue_objc_msg_lookup_super_stret,
	(ULONG)glue_objc_lookUpClass,
	(ULONG)glue_objc_getClass,
	(ULONG)glue_objc_getRequiredClass,
	(ULONG)glue_objc_exception_throw,
	(ULONG)glue_objc_sync_enter,
	(ULONG)glue_objc_sync_exit,
	(ULONG)glue_objc_getProperty,
	(ULONG)glue_objc_setProperty,
	(ULONG)glue_objc_getPropertyStruct,
	(ULONG)glue_objc_setPropertyStruct,
	(ULONG)glue_objc_enumerationMutation,
	/* Functions declared in ObjFW_RT.h */
	(ULONG)sel_registerName,
	(ULONG)sel_getName,
	(ULONG)sel_isEqual,
	(ULONG)objc_allocateClassPair,
	(ULONG)objc_registerClassPair,
	(ULONG)objc_getClassList,

	process_load_queue();

	objc_global_mutex_unlock();
}

id
OBJC_GLUE(objc_lookUpClass, const char *name OBJC_GLUE_M68K_REG("a0"))
{
	Class cls;

	if ((cls = objc_classname_to_class(name, true)) == NULL)
		return Nil;

	if (cls->info & OBJC_CLASS_INFO_SETUP)

	if (!(cls->info & OBJC_CLASS_INFO_SETUP))
		return Nil;

	return cls;
}

id
OBJC_GLUE(objc_getClass, const char *name OBJC_GLUE_M68K_REG("a0"))
{
	return OBJC_GLUE(objc_lookUpClass, name);
}

id
OBJC_GLUE(objc_getRequiredClass, const char *name OBJC_GLUE_M68K_REG("a0"))
{
	Class cls;

	if ((cls = OBJC_GLUE(objc_getClass, name)) == Nil)
		OBJC_ERROR("Class %s not found!", name);

	return cls;
}

Class
objc_lookup_class(const char *name)

#ifdef OF_HAVE_THREADS
	if (!of_spinlock_unlock(&emergency_exceptions_spinlock))
		OBJC_ERROR("Cannot unlock spinlock!");
#endif
}

void
OBJC_GLUE(objc_exception_throw, id object OBJC_GLUE_M68K_REG("a0"))
{
	struct objc_exception *e = malloc(sizeof(*e));
	bool emergency = false;

	if (e == NULL) {
#ifdef OF_HAVE_THREADS
		if (!of_spinlock_lock(&emergency_exceptions_spinlock))

#include "config.h"

#import "ObjFW_RT.h"
#import "private.h"

void
OBJC_GLUE(__objc_exec_class, void *module_ OBJC_GLUE_M68K_REG("a0"))
{
	struct objc_abi_module *module = module_;

	objc_global_mutex_lock();

	objc_register_all_selectors(module->symtab);
	objc_register_all_classes(module->symtab);

	if (imp == (IMP)0)
		return not_found(obj, sel);

	return imp;
}

IMP
OBJC_GLUE(objc_msg_lookup, id obj OBJC_GLUE_M68K_REG("a0"),
    SEL sel OBJC_GLUE_M68K_REG("a1"))
{
	return common_lookup(obj, sel, objc_method_not_found);
}

IMP
OBJC_GLUE(objc_msg_lookup_stret, id obj OBJC_GLUE_M68K_REG("a0"),
    SEL sel OBJC_GLUE_M68K_REG("a1"))
{
	return common_lookup(obj, sel, objc_method_not_found_stret);
}

static OF_INLINE IMP
common_lookup_super(struct objc_super *super, SEL sel,
    IMP (*not_found)(id, SEL))

	if (imp == (IMP)0)
		return not_found(super->self, sel);

	return imp;
}

IMP
OBJC_GLUE(objc_msg_lookup_super,
    struct objc_super *super OBJC_GLUE_M68K_REG("a0"),
    SEL sel OBJC_GLUE_M68K_REG("a1"))
{
	return common_lookup_super(super, sel, objc_method_not_found);
}

IMP
OBJC_GLUE(objc_msg_lookup_super_stret,
    struct objc_super *super OBJC_GLUE_M68K_REG("a0"),
    SEL sel OBJC_GLUE_M68K_REG("a1"))
{
	return common_lookup_super(super, sel, objc_method_not_found_stret);
}
#endif

#include "ObjFW_RT.h"
#include "private.h"

static objc_enumeration_mutation_handler enumeration_mutation_handler = NULL;

void
OBJC_GLUE(objc_enumerationMutation, id obj OBJC_GLUE_M68K_REG("a0"))
{
	if (enumeration_mutation_handler != NULL)
		enumeration_mutation_handler(obj);
	else
		OBJC_ERROR("Object was mutated during enumeration!");
}

void
objc_setEnumerationMutationHandler(
    objc_enumeration_mutation_handler handler OBJC_M68K_REG("a0"))
{
	enumeration_mutation_handler = handler;
}

# ifndef _Nonnull
#  define _Nonnull
# endif
# ifndef _Nullable
#  define _Nullable
# endif
#endif

#ifdef OBJC_AMIGA_LIBRARY
# define OBJC_GLUE(name, ...) glue_##name(__VA_ARGS__)
# define OBJC_GLUE_M68K_REG(reg) OBJC_M68K_REG(reg)
#else
# define OBJC_GLUE(name, ...) name(__VA_ARGS__)
# define OBJC_GLUE_M68K_REG(reg)
#endif

struct objc_abi_class {
	struct objc_abi_class *_Nonnull metaclass;
	const char *_Nullable superclass;
	const char *_Nonnull name;
	unsigned long version;
	unsigned long info;

	for (size_t i = 0; i < NUM_SPINLOCKS; i++)
		if (!of_spinlock_new(&spinlocks[i]))
			OBJC_ERROR("Failed to initialize spinlocks!")
}
#endif

id
OBJC_GLUE(objc_getProperty, id self OBJC_GLUE_M68K_REG("a0"),
    SEL _cmd OBJC_GLUE_M68K_REG("a1"),
    ptrdiff_t offset OBJC_GLUE_M68K_REG("d0"),
    bool atomic OBJC_GLUE_M68K_REG("d1"))
{
	if (atomic) {
		id *ptr = (id *)(void *)((char *)self + offset);
#ifdef OF_HAVE_THREADS
		unsigned hash = SPINLOCK_HASH(ptr);

		OF_ENSURE(of_spinlock_lock(&spinlocks[hash]));

#endif
	}

	return *(id *)(void *)((char *)self + offset);
}

void
OBJC_GLUE(objc_setProperty, id self OBJC_GLUE_M68K_REG("a0"),
    SEL _cmd OBJC_GLUE_M68K_REG("a1"),
    ptrdiff_t offset OBJC_GLUE_M68K_REG("d0"),
    id value OBJC_GLUE_M68K_REG("a2"), bool atomic OBJC_GLUE_M68K_REG("d1"),
    signed char copy OBJC_GLUE_M68K_REG("d2"))
{
	if (atomic) {
		id *ptr = (id *)(void *)((char *)self + offset);
#ifdef OF_HAVE_THREADS
		unsigned hash = SPINLOCK_HASH(ptr);

		OF_ENSURE(of_spinlock_lock(&spinlocks[hash]));

	}

	[old release];
}

/* The following methods are only required for GCC >= 4.6 */
void
OBJC_GLUE(objc_getPropertyStruct, void *dest OBJC_GLUE_M68K_REG("a0"),
    const void *src OBJC_GLUE_M68K_REG("a1"),
    ptrdiff_t size OBJC_GLUE_M68K_REG("d0"),
    bool atomic OBJC_GLUE_M68K_REG("d1"), bool strong OBJC_GLUE_M68K_REG("d2"))
{
	if (atomic) {
#ifdef OF_HAVE_THREADS
		unsigned hash = SPINLOCK_HASH(src);

		OF_ENSURE(of_spinlock_lock(&spinlocks[hash]));
#endif
		memcpy(dest, src, size);
#ifdef OF_HAVE_THREADS
		OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]));
#endif

		return;
	}

	memcpy(dest, src, size);
}

void
OBJC_GLUE(objc_setPropertyStruct, void *dest OBJC_GLUE_M68K_REG("a0"),
    const void *src OBJC_GLUE_M68K_REG("a1"),
    ptrdiff_t size OBJC_GLUE_M68K_REG("d0"),
    bool atomic OBJC_GLUE_M68K_REG("d1"), bool strong OBJC_GLUE_M68K_REG("d2"))
{
	if (atomic) {
#ifdef OF_HAVE_THREADS
		unsigned hash = SPINLOCK_HASH(src);

		OF_ENSURE(of_spinlock_lock(&spinlocks[hash]));
#endif

void
objc_init_static_instances(struct objc_abi_symtab *symtab)
{
	struct objc_abi_static_instances **si;

	/* Check if the class for a static instance became available */
	for (size_t i = 0; i < static_instances_cnt; i++) {
		Class cls = OBJC_GLUE(objc_lookUpClass,
		    static_instances[i]->class_name);

		if (cls != Nil) {
			for (id *instances = static_instances[i]->instances;
			    *instances != nil; instances++)
				object_setClass(*instances, cls);

			static_instances_cnt--;

	si = (struct objc_abi_static_instances **)
	    symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt];

	if (si == NULL)
		return;

	for (; *si != NULL; si++) {
		Class cls = OBJC_GLUE(objc_lookUpClass, (*si)->class_name);

		if (cls != Nil) {
			for (id *instances = (*si)->instances;
			    *instances != nil; instances++)
				object_setClass(*instances, cls);
		} else {
			static_instances = realloc(static_instances,

{
	if (!of_mutex_new(&mutex))
		OBJC_ERROR("Failed to create mutex!")
}
#endif

int
OBJC_GLUE(objc_sync_enter, id object OBJC_GLUE_M68K_REG("a0"))
{
	if (object == nil)
		return 0;

#ifdef OF_HAVE_THREADS
	struct lock_s *lock;

		OBJC_ERROR("Failed to lock mutex!");
#endif

	return 0;
}

int
OBJC_GLUE(objc_sync_exit, id object OBJC_GLUE_M68K_REG("a0"))
{
	if (object == nil)
		return 0;

#ifdef OF_HAVE_THREADS
	struct lock_s *lock, *last = NULL;