ObjFW  Check-in [eeba79d088]

Overview
Comment:Add a generator for the linklib

This will eventually also generate the glue code and the function list
and make sfdc & cvinclude.pl entirely obsolete. It will also reduce the
maintenance burden because once everything is generated from
library.xml, there is a single file in which a function needs to be
added / changed instead of 5.

Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: eeba79d088a88c8fc31e64d5a31e6a6f32ae24f5090849da05cbc1d790d737c6
User & Date: js on 2020-12-27 18:50:37
Other Links: manifest | tags
Context
2020-12-27
19:13
Don't use sfdc / cvinclude.pl anymore check-in: bb25f8b0fe user: js tags: trunk
18:50
Add a generator for the linklib check-in: eeba79d088 user: js tags: trunk
2020-12-26
22:21
Adjust globs to changed paths check-in: 4d06c7359b user: js tags: trunk
Changes

Modified .fossil-settings/clean-glob from [2af3d87dad] to [bb09d91baf].

19
20
21
22
23
24
25

26
27
28
29
30
31
32
config.h
config.h.in
config.log
config.status
configure
docs
extra.mk

generators/unicode/gen_tables
src/Info.plist
src/bridge/Info.plist
src/objfw-defs.h
src/runtime/Info.plist
src/runtime/amiga-library-functable.inc
src/runtime/inline.h







>







19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
config.h
config.h.in
config.log
config.status
configure
docs
extra.mk
generators/library/gen_libraries
generators/unicode/gen_tables
src/Info.plist
src/bridge/Info.plist
src/objfw-defs.h
src/runtime/Info.plist
src/runtime/amiga-library-functable.inc
src/runtime/inline.h

Modified .fossil-settings/ignore-glob from [0cd037ae91] to [29372d00eb].

21
22
23
24
25
26
27

28
29
30
31
32
33
34
config.h
config.h.in
config.log
config.status
configure
docs
extra.mk

generators/unicode/gen_tables
src/Info.plist
src/bridge/Info.plist
src/objfw-defs.h
src/runtime/Info.plist
src/runtime/amiga-library-functable.inc
src/runtime/inline.h







>







21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
config.h
config.h.in
config.log
config.status
configure
docs
extra.mk
generators/library/gen_libraries
generators/unicode/gen_tables
src/Info.plist
src/bridge/Info.plist
src/objfw-defs.h
src/runtime/Info.plist
src/runtime/amiga-library-functable.inc
src/runtime/inline.h

Modified .gitignore from [79907f2092] to [2b99f69bad].

21
22
23
24
25
26
27

28
29
30
31
32
33
34
config.h
config.h.in
config.log
config.status
configure
docs
extra.mk

generators/unicode/gen_tables
src/Info.plist
src/bridge/Info.plist
src/objfw-defs.h
src/runtime/Info.plist
src/runtime/amiga-library-functable.inc
src/runtime/inline.h







>







21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
config.h
config.h.in
config.log
config.status
configure
docs
extra.mk
generators/library/gen_libraries
generators/unicode/gen_tables
src/Info.plist
src/bridge/Info.plist
src/objfw-defs.h
src/runtime/Info.plist
src/runtime/amiga-library-functable.inc
src/runtime/inline.h

Added generators/library/LibraryGenerator.m version [47058a7cb6].

































































































































































































































































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
 *               2018, 2019, 2020
 *   Jonathan Schleifer <js@nil.im>
 *
 * 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 "OFApplication.h"
#import "OFArray.h"
#import "OFFile.h"
#import "OFXMLAttribute.h"
#import "OFXMLElement.h"

#import "OFInvalidFormatException.h"
#import "OFUnsupportedVersionException.h"

#import "copyright.h"

@interface LibraryGenerator: OFObject <OFApplicationDelegate>
@end

OF_APPLICATION_DELEGATE(LibraryGenerator)

@implementation LibraryGenerator
- (void)applicationDidFinishLaunching
{
	[self generateLinkLibInDirectory: @"../../src/runtime"];

	[OFApplication terminate];
}

- (void)generateLinkLibInDirectory: (OFString *)directory
{
	OFXMLElement *library = [OFXMLElement elementWithFile:
	    [directory stringByAppendingPathComponent: @"library.xml"]];
	OFString *linklibPath = [[directory
	    stringByAppendingPathComponent: @"linklib"]
	    stringByAppendingPathComponent: @"linklib.m"];
	OFFile *linklib = [OFFile fileWithPath: linklibPath
					  mode: @"w"];
	OFArray OF_GENERIC(OFXMLElement *) *functions;
	size_t funcIndex = 0;
	OFString *libBase;

	if (![library.name isEqual: @"amiga-library"] ||
	    library.namespace != nil)
		@throw [OFInvalidFormatException exception];

	OFXMLAttribute *version = [library attributeForName: @"version"];
	if (version == nil)
		@throw [OFInvalidFormatException exception];

	if (![version.stringValue isEqual: @"1.0"])
		@throw [OFUnsupportedVersionException
		    exceptionWithVersion: version.stringValue];

	libBase = [library attributeForName: @"base"].stringValue;

	[linklib writeString: COPYRIGHT];
	[linklib writeString:
	    @"/* This file is automatically generated from library.xml */\n"
	    @"\n"
	    @"#include \"config.h\"\n"
	    @"\n"];

	for (OFXMLElement *include in [library elementsForName: @"include"])
		[linklib writeFormat: @"#import \"%@\"\n", include.stringValue];

	[linklib writeFormat: @"\n"
			      @"extern struct Library *%@;\n"
			      @"\n",
			      libBase];

	functions = [library elementsForName: @"function"];
	for (OFXMLElement *function in functions) {
		OFString *name =
		    [function attributeForName: @"name"].stringValue;
		OFString *returnType =
		    [function attributeForName: @"return-type"].stringValue;
		OFArray OF_GENERIC(OFXMLElement *) *arguments =
		    [function elementsForName: @"argument"];
		size_t argumentIndex;

		if (returnType == nil)
			returnType = @"void";

		[linklib writeFormat: @"%@\n%@(", returnType, name];

		argumentIndex = 0;
		for (OFXMLElement *argument in
		    [function elementsForName: @"argument"]) {
			OFString *argName =
			    [argument attributeForName: @"name"].stringValue;
			OFString *argType =
			    [argument attributeForName: @"type"].stringValue;

			if (argumentIndex++ > 0)
				[linklib writeString: @", "];

			[linklib writeString: argType];
			if (![argType hasSuffix: @"*"])
				[linklib writeString: @" "];
			[linklib writeString: argName];
		}

		[linklib writeFormat:
		    @")\n"
		    @"{\n"
		    @"#if defined(OF_AMIGAOS_M68K)\n"
		    @"\tregister struct Library *a6 __asm__(\"a6\") = %@;\n"
		    @"\t(void)a6;\n"
		    @"\t", libBase];

		if (![returnType isEqual: @"void"])
			[linklib writeString: @"return "];

		[linklib writeString: @"(("];
		[linklib writeString: returnType];
		if (![returnType hasSuffix: @"*"])
			[linklib writeString: @" "];
		[linklib writeString: @"(*)("];

		argumentIndex = 0;
		for (OFXMLElement *argument in arguments) {
			OFString *argType =
			    [argument attributeForName: @"type"].stringValue;
			OFString *m68kReg = [argument
			    attributeForName: @"m68k-reg"].stringValue;

			if (argumentIndex++ > 0)
				[linklib writeString: @", "];

			[linklib writeString: argType];
			if (![argType hasSuffix: @"*"])
				[linklib writeString: @" "];
			[linklib writeFormat: @"__asm__(\"%@\")", m68kReg];
		}

		[linklib writeFormat: @"))(((uintptr_t)%@) - %zu))(",
				      libBase, 30 + funcIndex * 6];

		argumentIndex = 0;
		for (OFXMLElement *argument in
		    [function elementsForName: @"argument"]) {
			OFString *argName =
			    [argument attributeForName: @"name"].stringValue;

			if (argumentIndex++ > 0)
				[linklib writeString: @", "];

			[linklib writeString: argName];
		}

		[linklib writeFormat:
		    @");\n"
		    @"#elif defined(OF_MORPHOS)\n"
		    @"\t__asm__ __volatile__ (\n"
		    @"\t    \"mr\t\t%%%%r12, %%0\"\n"
		    @"\t    :: \"r\"(%@) : \"r12\"\n"
		    @"\t);\n"
		    @"\n"
		    @"\t",
		    libBase, libBase];

		if (![returnType isEqual: @"void"])
			[linklib writeString: @"return "];

		[linklib writeString: @"(("];
		[linklib writeString: returnType];
		if (![returnType hasSuffix: @"*"])
			[linklib writeString: @" "];
		[linklib writeString: @"(*)("];

		argumentIndex = 0;
		for (OFXMLElement *argument in arguments) {
			OFString *argType =
			    [argument attributeForName: @"type"].stringValue;

			if (argumentIndex++ > 0)
				[linklib writeString: @", "];

			[linklib writeString: argType];
		}

		[linklib writeFormat: @"))*(void **)(((uintptr_t)%@) - %zu))(",
				      libBase, 28 + funcIndex * 6];

		argumentIndex = 0;
		for (OFXMLElement *argument in
		    [function elementsForName: @"argument"]) {
			OFString *argName =
			    [argument attributeForName: @"name"].stringValue;

			if (argumentIndex++ > 0)
				[linklib writeString: @", "];

			[linklib writeString: argName];
		}

		[linklib writeString: @");\n"
				      @"#endif\n"];

		if ([function attributeForName: @"noreturn"] != nil)
			[linklib writeString: @"\n\tOF_UNREACHABLE\n"];

		[linklib writeString: @"}\n"];

		if (++funcIndex < functions.count)
			[linklib writeString: @"\n"];
	}
}
@end

Added generators/library/Makefile version [f4bd961875].







































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
include ../../extra.mk

PROG_NOINST = gen_libraries${PROG_SUFFIX}
SRCS = LibraryGenerator.m

.PHONY: run
run: all
	rm -f libobjfw.so.${OBJFW_LIB_MAJOR}
	rm -f libobjfw.so.${OBJFW_LIB_MAJOR_MINOR}
	rm -f objfw.dll libobjfw.${OBJFW_LIB_MAJOR}.dylib
	rm -f libobjfwrt.so.${OBJFWRT_LIB_MAJOR}
	rm -f libobjfwrt.so.${OBJFWRT_LIB_MAJOR_MINOR}
	rm -f objfwrt.dll libobjfwrt.${OBJFWRT_LIB_MAJOR}.dylib
	rm -f ${OBJFWRT_AMIGA_LIB}
	if test -f ../../src/libobjfw.so; then \
		${LN_S} ../../src/libobjfw.so libobjfw.so.${OBJFW_LIB_MAJOR}; \
		${LN_S} ../../src/libobjfw.so \
		    libobjfw.so.${OBJFW_LIB_MAJOR_MINOR}; \
	elif test -f ../../src/libobjfw.so.${OBJFW_LIB_MAJOR_MINOR}; then \
		${LN_S} ../../src/libobjfw.so.${OBJFW_LIB_MAJOR_MINOR} \
		    libobjfw.so.${OBJFW_LIB_MAJOR_MINOR}; \
	fi
	if test -f ../../src/objfw.dll; then \
		${LN_S} ../src/objfw.dll objfw.dll; \
	fi
	if test -f ../../src/libobjfw.dylib; then \
		${LN_S} ../src/libobjfw.dylib \
		    libobjfw.${OBJFW_LIB_MAJOR}.dylib; \
	fi
	if test -f ../../src/runtime/libobjfwrt.so; then \
		${LN_S} ../../src/runtime/libobjfwrt.so \
		    libobjfwrt.so.${OBJFWRT_LIB_MAJOR}; \
		${LN_S} ../../src/runtime/libobjfwrt.so \
		    libobjfwrt.so.${OBJFWRT_LIB_MAJOR_MINOR}; \
	elif test -f ../../src/runtime/libobjfwrt.so.${OBJFWRT_LIB_MAJOR_MINOR}; then \
		${LN_S} ../../src/runtime/libobjfwrt.so.${OBJFWRT_LIB_MAJOR_MINOR} libobjfwrt.so.${OBJFWRT_LIB_MAJOR_MINOR}; \
	fi
	if test -f ../../src/runtime/objfwrt.dll; then \
		${LN_S} ../../src/runtime/objfwrt.dll objfwrt.dll; \
	fi
	if test -f ../../src/runtime/libobjfwrt.dylib; then \
		${LN_S} ../../src/runtime/libobjfwrt.dylib \
		    libobjfwrt.${OBJFWRT_LIB_MAJOR}.dylib; \
	fi
	if test -f ../../src/runtime/${OBJFWRT_AMIGA_LIB}; then \
		${LN_S} ../../src/runtime/${OBJFWRT_AMIGA_LIB} \
		    ${OBJFWRT_AMIGA_LIB}; \
	fi
	LD_LIBRARY_PATH=.$${LD_LIBRARY_PATH+:}$$LD_LIBRARY_PATH \
	DYLD_FRAMEWORK_PATH=../../src:../../src/runtime$${DYLD_FRAMEWORK_PATH+:}$$DYLD_FRAMEWORK_PATH \
	DYLD_LIBRARY_PATH=.$${DYLD_LIBRARY_PATH+:}$$DYLD_LIBRARY_PATH \
	LIBRARY_PATH=.$${LIBRARY_PATH+:}$$LIBRARY_PATH \
	ASAN_OPTIONS=allocator_may_return_null=1 \
	${WRAPPER} ./${PROG_NOINST}; EXIT=$$?; \
	rm -f libobjfw.so.${OBJFW_LIB_MAJOR}; \
	rm -f objfw.so.${OBJFW_LIB_MAJOR_MINOR} objfw.dll; \
	rm -f libobjfw.${OBJFW_LIB_MAJOR}.dylib; \
	rm -f libobjfwrt.so.${OBJFWRT_LIB_MAJOR}; \
	rm -f objfwrt.so.${OBJFWRT_LIB_MAJOR_MINOR} objfwrt.dll; \
	rm -f libobjfwrt.${OBJFWRT_LIB_MAJOR}.dylib; \
	exit $$EXIT

include ../../buildsys.mk

CPPFLAGS += -I../../src -I../../src/exceptions -I../../src/runtime -I../..
LIBS := -L../../src -lobjfw -L../../src/runtime ${RUNTIME_LIBS} ${LIBS}
LD = ${OBJC}

Added generators/library/copyright.h version [5f052aece5].























































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
 *               2018, 2019, 2020
 *   Jonathan Schleifer <js@nil.im>
 *
 * 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.
 */

#import "OFString.h"

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

Added src/runtime/library.xml version [99fa55d924].



















































































































































































































































































































































































































































































































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
<amiga-library version='1.0' base='ObjFWRTBase'>
  <include>ObjFWRT.h</include>
  <include>private.h</include>
  <!-- The following function is only for the linklib. -->
  <function name='objc_init' return-type='bool'>
    <argument name='version' type='unsigned int' m68k-reg='d0'/>
    <argument name='libc' type='struct objc_libc *' m68k-reg='a0'/>
  </function>
  <function name='__objc_exec_class'>
    <argument name='module' type='struct objc_module *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_msg_lookup' return-type='IMP _Nonnull'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_msg_lookup_stret' return-type='IMP _Nonnull'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_msg_lookup_super' return-type='IMP _Nonnull'>
    <argument name='super' type='struct objc_super *_Nonnull' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_msg_lookup_super_stret' return-type='IMP _Nonnull'>
    <argument name='super' type='struct objc_super *_Nonnull' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_lookUpClass' return-type='Class _Nullable'>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_getClass' return-type='Class _Nullable'>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_getRequiredClass' return-type='Class _Nonnull'>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_lookup_class' return-type='Class _Nullable'>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_get_class' return-type='Class _Nonnull'>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_exception_throw' noreturn='1'>
    <argument name='object' type='id _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_sync_enter' return-type='int'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_sync_exit' return-type='int'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_getProperty' return-type='id _Nullable'>
    <argument name='self' type='id _Nonnull' m68k-reg='a0'/>
    <argument name='_cmd' type='SEL _Nonnull' m68k-reg='a1'/>
    <argument name='offset' type='ptrdiff_t' m68k-reg='d0'/>
    <argument name='atomic' type='bool' m68k-reg='d1'/>
  </function>
  <function name='objc_setProperty'>
    <argument name='self' type='id _Nonnull' m68k-reg='a0'/>
    <argument name='_cmd' type='SEL _Nonnull' m68k-reg='a1'/>
    <argument name='offset' type='ptrdiff_t' m68k-reg='d0'/>
    <argument name='value' type='id _Nullable' m68k-reg='a2'/>
    <argument name='atomic' type='bool' m68k-reg='d1'/>
    <argument name='copy' type='signed char' m68k-reg='d2'/>
  </function>
  <function name='objc_getPropertyStruct'>
    <argument name='dest' type='void *_Nonnull' m68k-reg='a0'/>
    <argument name='src' type='const void *_Nonnull' m68k-reg='a1'/>
    <argument name='size' type='ptrdiff_t' m68k-reg='d0'/>
    <argument name='atomic' type='bool' m68k-reg='d1'/>
    <argument name='strong' type='bool' m68k-reg='d2'/>
  </function>
  <function name='objc_setPropertyStruct'>
    <argument name='dest' type='void *_Nonnull' m68k-reg='a0'/>
    <argument name='src' type='const void *_Nonnull' m68k-reg='a1'/>
    <argument name='size' type='ptrdiff_t' m68k-reg='d0'/>
    <argument name='atomic' type='bool' m68k-reg='d1'/>
    <argument name='strong' type='bool' m68k-reg='d2'/>
  </function>
  <function name='objc_enumerationMutation'>
    <argument name='object' type='id _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='__gnu_objc_personality' return-type='int'>
    <argument name='version' type='int' m68k-reg='d0'/>
    <argument name='actions' type='int' m68k-reg='d1'/>
    <argument name='exClass' type='uint64_t *_Nonnull' m68k-reg='d2'/>
    <argument name='ex' type='void *_Nonnull' m68k-reg='a0'/>
    <argument name='ctx' type='void *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_retain' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_retainBlock' return-type='id _Nullable'>
    <argument name='block' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_retainAutorelease' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_release'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_autorelease' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_autoreleaseReturnValue' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_retainAutoreleaseReturnValue' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_retainAutoreleasedReturnValue'
            return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_storeStrong' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
    <argument name='value' type='id _Nullable' m68k-reg='a1'/>
  </function>
  <function name='objc_storeWeak' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
    <argument name='value' type='id _Nullable' m68k-reg='a1'/>
  </function>
  <function name='objc_loadWeakRetained' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_initWeak' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
    <argument name='value' type='id _Nullable' m68k-reg='a1'/>
  </function>
  <function name='objc_destroyWeak'>
    <argument name='object' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_loadWeak' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_copyWeak'>
    <argument name='dest' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
    <argument name='src' type='id _Nullable *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_moveWeak'>
    <argument name='dest' type='id _Nullable *_Nonnull' m68k-reg='a0'/>
    <argument name='src' type='id _Nullable *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='sel_registerName' return-type='SEL _Nonnull'>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='sel_getName' return-type='const char *_Nonnull'>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='sel_isEqual' return-type='bool'>
    <argument name='selector1' type='SEL _Nonnull' m68k-reg='a0'/>
    <argument name='selector2' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_allocateClassPair' return-type='Class _Nonnull'>
    <argument name='superclass' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a1'/>
    <argument name='extraBytes' type='size_t' m68k-reg='d0'/>
  </function>
  <function name='objc_registerClassPair'>
    <argument name='class' type='Class _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_getClassList' return-type='unsigned int'>
    <argument name='buffer' type='Class _Nonnull *_Nullable' m68k-reg='a0'/>
    <argument name='count' type='unsigned int' m68k-reg='d0'/>
  </function>
  <function name='objc_copyClassList' return-type='Class _Nonnull *_Nonnull'>
    <argument name='length' type='unsigned int *_Nullable' m68k-reg='a0'/>
  </function>
  <function name='class_isMetaClass' return-type='bool'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
  </function>
  <function name='class_getName' return-type='const char *_Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
  </function>
  <function name='class_getSuperclass' return-type='Class _Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
  </function>
  <function name='class_getInstanceSize' return-type='unsigned long'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
  </function>
  <function name='class_respondsToSelector' return-type='bool'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='class_conformsToProtocol' return-type='bool'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='p' type='Protocol *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='class_getMethodImplementation' return-type='IMP _Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='class_getMethodImplementation_stret'
            return-type='IMP _Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='class_getInstanceMethod' return-type='Method _Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='class_addMethod' return-type='bool'>
    <argument name='class' type='Class _Nonnull' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
    <argument name='implementation' type='IMP _Nonnull' m68k-reg='a2'/>
    <argument name='typeEncoding' type='const char *_Nullable' m68k-reg='a3'/>
  </function>
  <function name='class_replaceMethod' return-type='IMP _Nullable'>
    <argument name='class' type='Class _Nonnull' m68k-reg='a0'/>
    <argument name='selector' type='SEL _Nonnull' m68k-reg='a1'/>
    <argument name='implementation' type='IMP _Nonnull' m68k-reg='a2'/>
    <argument name='typeEncoding' type='const char *_Nullable' m68k-reg='a3'/>
  </function>
  <function name='object_getClass' return-type='Class _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='object_setClass' return-type='Class _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
    <argument name='class' type='Class _Nonnull' m68k-reg='a1'/>
  </function>
  <function name='object_getClassName' return-type='const char *_Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='protocol_getName' return-type='const char *_Nonnull'>
    <argument name='protocol' type='Protocol *_Nonnull' m68k-reg='a0'/>
  </function>
  <function name='protocol_isEqual' return-type='bool'>
    <argument name='protocol1' type='Protocol *_Nonnull' m68k-reg='a0'/>
    <argument name='protocol2' type='Protocol *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='protocol_conformsToProtocol' return-type='bool'>
    <argument name='protocol1' type='Protocol *_Nonnull' m68k-reg='a0'/>
    <argument name='protocol2' type='Protocol *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_setUncaughtExceptionHandler'
            return-type='_Nullable objc_uncaught_exception_handler_t'>
    <argument name='handler' type='objc_uncaught_exception_handler_t _Nullable'
              m68k-reg='a0'/>
  </function>
  <function name='objc_setForwardHandler'>
    <argument name='forward' type='IMP _Nullable' m68k-reg='a0'/>
    <argument name='stretForward' type='IMP _Nullable' m68k-reg='a1'/>
  </function>
  <function name='objc_setEnumerationMutationHandler'>
    <argument name='hadler' type='objc_enumeration_mutation_handler_t _Nullable'
              m68k-reg='a0'/>
  </function>
  <function name='objc_constructInstance' return-type='id _Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='bytes' type='void *_Nullable' m68k-reg='a1'/>
  </function>
  <function name='objc_exit'/>
  <function name='class_copyIvarList' return-type='Ivar _Nullable *_Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='outCount' type='unsigned int *_Nullable' m68k-reg='a1'/>
  </function>
  <function name='ivar_getName' return-type='const char *_Nonnull'>
    <argument name='ivar' type='Ivar _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='ivar_getTypeEncoding' return-type='const char *_Nonnull'>
    <argument name='ivar' type='Ivar _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='ivar_getOffset' return-type='ptrdiff_t'>
    <argument name='ivar' type='Ivar _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='class_copyMethodList'
            return-type='Method _Nullable *_Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='outCount' type='unsigned int *_Nullable' m68k-reg='a1'/>
  </function>
  <function name='method_getName' return-type='SEL _Nonnull'>
    <argument name='method' type='Method _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='method_getTypeEncoding' return-type='const char *_Nullable'>
    <argument name='method' type='Method _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='class_copyPropertyList'
            return-type='objc_property_t _Nullable *_Nullable'>
    <argument name='class' type='Class _Nullable' m68k-reg='a0'/>
    <argument name='outCount' type='unsigned int *_Nullable' m68k-reg='a1'/>
  </function>
  <function name='property_getName' return-type='const char *_Nonnull'>
    <argument name='property' type='objc_property_t _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='property_copyAttributeValue' return-type='char *_Nullable'>
    <argument name='property' type='objc_property_t _Nonnull' m68k-reg='a0'/>
    <argument name='name' type='const char *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_destructInstance' return-type='void *_Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='objc_autoreleasePoolPush'
            return-type='void *_Null_unspecified'>
  </function>
  <function name='objc_autoreleasePoolPop'>
    <argument name='pool' type='void *_Null_unspecified' m68k-reg='a0'/>
  </function>
  <function name='_objc_rootAutorelease' return-type='id _Nullable'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <!-- The following functions are private! Don't use! -->
  <function name='objc_hashtable_new'
            return-type='struct objc_hashtable *_Nonnull'>
    <argument name='hash' type='objc_hashtable_hash_func' m68k-reg='a0'/>
    <argument name='equal' type='objc_hashtable_equal_func' m68k-reg='a1'/>
    <argument name='size' type='uint32_t' m68k-reg='d0'/>
  </function>
  <function name='objc_hashtable_set'>
    <argument name='table' type='struct objc_hashtable *_Nonnull'
              m68k-reg='a0'/>
    <argument name='key' type='const void *_Nonnull' m68k-reg='a1'/>
    <argument name='object' type='const void *_Nonnull' m68k-reg='a2'/>
  </function>
  <function name='objc_hashtable_get' return-type='void *_Nullable'>
    <argument name='table' type='struct objc_hashtable *_Nonnull'
              m68k-reg='a0'/>
    <argument name='key' type='const void *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_hashtable_delete'>
    <argument name='table' type='struct objc_hashtable *_Nonnull'
              m68k-reg='a0'/>
    <argument name='key' type='const void *_Nonnull' m68k-reg='a1'/>
  </function>
  <function name='objc_hashtable_free'>
    <argument name='table' type='struct objc_hashtable *_Nonnull'
              m68k-reg='a0'/>
  </function>
  <!-- Public functions again -->
  <function name='objc_setTaggedPointerSecret'>
    <argument name='secret' type='uintptr_t' m68k-reg='d0'/>
  </function>
  <function name='objc_registerTaggedPointerClass' return-type='int'>
    <argument name='class' type='Class _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='object_isTaggedPointer' return-type='bool'>
    <argument name='object' type='id _Nullable' m68k-reg='a0'/>
  </function>
  <function name='object_getTaggedPointerValue' return-type='uintptr_t'>
    <argument name='object' type='id _Nonnull' m68k-reg='a0'/>
  </function>
  <function name='objc_createTaggedPointer' return-type='id _Nullable'>
    <argument name='class' type='int' m68k-reg='d0'/>
    <argument name='value' type='uintptr_t' m68k-reg='d1'/>
  </function>
</amiga-library>

Modified src/runtime/linklib/Makefile from [90ff5bb4a5] to [dc27346920].

1
2
3

4
5
6
7
8
9
10
11
12
include ../../../extra.mk

STATIC_LIB = libobjfwrt.library.a

SRCS = linklib.m

include ../../../buildsys.mk

CPPFLAGS += -I..  -I../..  -I../../..				\
	    -DOBJC_COMPILING_AMIGA_LINKLIB			\
	    -DOBJFWRT_AMIGA_LIB=\"${OBJFWRT_AMIGA_LIB}\"	\
	    -DOBJFWRT_LIB_MINOR=${OBJFWRT_LIB_MINOR}
LD = ${OBJC}



>
|








1
2
3
4
5
6
7
8
9
10
11
12
13
include ../../../extra.mk

STATIC_LIB = libobjfwrt.library.a
SRCS = init.m		\
       linklib.m

include ../../../buildsys.mk

CPPFLAGS += -I..  -I../..  -I../../..				\
	    -DOBJC_COMPILING_AMIGA_LINKLIB			\
	    -DOBJFWRT_AMIGA_LIB=\"${OBJFWRT_AMIGA_LIB}\"	\
	    -DOBJFWRT_LIB_MINOR=${OBJFWRT_LIB_MINOR}
LD = ${OBJC}

Added src/runtime/linklib/init.m version [5647624db4].





























































































































































































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
/*
 * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
 *               2018, 2019, 2020
 *   Jonathan Schleifer <js@nil.im>
 *
 * 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 "ObjFWRT.h"
#import "private.h"
#import "macros.h"

#include <proto/exec.h>
#include <proto/intuition.h>

struct ObjFWRTBase;

#import "inline.h"

#include <stdio.h>
#include <stdlib.h>

#if defined(OF_AMIGAOS_M68K)
# include <stabs.h>
#elif defined(OF_MORPHOS)
# include <constructor.h>
#endif

#ifdef HAVE_SJLJ_EXCEPTIONS
extern int _Unwind_SjLj_RaiseException(void *);
#else
extern int _Unwind_RaiseException(void *);
#endif
extern void _Unwind_DeleteException(void *);
extern void *_Unwind_GetLanguageSpecificData(void *);
extern uintptr_t _Unwind_GetRegionStart(void *);
extern uintptr_t _Unwind_GetDataRelBase(void *);
extern uintptr_t _Unwind_GetTextRelBase(void *);
extern uintptr_t _Unwind_GetIP(void *);
extern uintptr_t _Unwind_GetGR(void *, int);
extern void _Unwind_SetIP(void *, uintptr_t);
extern void _Unwind_SetGR(void *, int, uintptr_t);
#ifdef HAVE_SJLJ_EXCEPTIONS
extern void _Unwind_SjLj_Resume(void *);
#else
extern void _Unwind_Resume(void *);
#endif
#ifdef OF_AMIGAOS_M68K
extern void __register_frame_info(const void *, void *);
extern void *__deregister_frame_info(const void *);
#endif
#ifdef OF_MORPHOS
extern void __register_frame(void *);
extern void __deregister_frame(void *);
#endif

struct Library *ObjFWRTBase;
void *__objc_class_name_Protocol;

static void
error(const char *string, ULONG arg)
{
	struct Library *IntuitionBase = OpenLibrary("intuition.library", 0);

	if (IntuitionBase != NULL) {
		struct EasyStruct easy = {
			.es_StructSize = sizeof(easy),
			.es_Flags = 0,
			.es_Title = (void *)NULL,
			.es_TextFormat = (void *)string,
			(void *)"OK"
		};

		EasyRequest(NULL, &easy, NULL, arg);

		CloseLibrary(IntuitionBase);
	}

	exit(EXIT_FAILURE);
}

static void __attribute__((__used__))
ctor(void)
{
	static bool initialized = false;
	struct objc_libc libc = {
		.malloc = malloc,
		.calloc = calloc,
		.realloc = realloc,
		.free = free,
#ifdef HAVE_SJLJ_EXCEPTIONS
		._Unwind_SjLj_RaiseException = _Unwind_SjLj_RaiseException,
#else
		._Unwind_RaiseException = _Unwind_RaiseException,
#endif
		._Unwind_DeleteException = _Unwind_DeleteException,
		._Unwind_GetLanguageSpecificData =
		    _Unwind_GetLanguageSpecificData,
		._Unwind_GetRegionStart = _Unwind_GetRegionStart,
		._Unwind_GetDataRelBase = _Unwind_GetDataRelBase,
		._Unwind_GetTextRelBase = _Unwind_GetTextRelBase,
		._Unwind_GetIP = _Unwind_GetIP,
		._Unwind_GetGR = _Unwind_GetGR,
		._Unwind_SetIP = _Unwind_SetIP,
		._Unwind_SetGR = _Unwind_SetGR,
#ifdef HAVE_SJLJ_EXCEPTIONS
		._Unwind_SjLj_Resume = _Unwind_SjLj_Resume,
#else
		._Unwind_Resume = _Unwind_Resume,
#endif
#ifdef OF_AMIGAOS_M68K
		.__register_frame_info = __register_frame_info,
		.__deregister_frame_info = __deregister_frame_info,
#endif
#ifdef OF_MORPHOS
		.__register_frame = __register_frame,
		.__deregister_frame = __deregister_frame,
#endif
#ifdef OF_AMIGAOS_M68K
		.vsnprintf = vsnprintf,
#endif
		.atexit = atexit,
		.exit = exit,
	};

	if (initialized)
		return;

	if ((ObjFWRTBase = OpenLibrary(OBJFWRT_AMIGA_LIB,
	    OBJFWRT_LIB_MINOR)) == NULL)
		error("Failed to open " OBJFWRT_AMIGA_LIB " version %lu!",
		    OBJFWRT_LIB_MINOR);

	if (!glue_objc_init(1, &libc))
		error("Failed to initialize " OBJFWRT_AMIGA_LIB "!", 0);

	initialized = true;
}

static void __attribute__((__used__))
dtor(void)
{
	CloseLibrary(ObjFWRTBase);
}

#if defined(OF_AMIGAOS_M68K)
ADD2INIT(ctor, -5);
ADD2EXIT(dtor, -5);
#elif defined(OF_MORPHOS)
CONSTRUCTOR_P(ObjFWRT, 4000)
{
	ctor();

	return 0;
}

DESTRUCTOR_P(ObjFWRT, 4000)
{
	dtor();
}
#endif

extern int __gnu_objc_personality(int version, int actions, uint64_t *exClass,
    void *ex, void *ctx);

int
#ifdef HAVE_SJLJ_EXCEPTIONS
__gnu_objc_personality_sj0(
#else
__gnu_objc_personality_v0(
#endif
    int version, int actions, uint64_t exClass, void *ex, void *ctx)
{
#ifdef OF_AMIGAOS_M68K
	return glue___gnu_objc_personality(version, actions, &exClass, ex, ctx);
#else
	return glue___gnu_objc_personality(version, actions, exClass, ex, ctx);
#endif
}

Modified src/runtime/linklib/linklib.m from [32b1f9e0eb] to [4d91f29e72].

11
12
13
14
15
16
17


18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

33
34
35
36


37




38
39

40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


61
62
63
64

65
66



67

68
69
70
71
72
73
74


75

76
77

78

79
80
81

82
83
84
85
86
87
88
89

90
91
92
93


94
95


96






97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

112
113
114
115
116
117
118
119
120
121
122
123


124
125
126
127

128
129



130

131
132
133
134
135
136
137
138
139
140

141









142
143
144
145
146

147
148
149
150
151
152
153
154

155
156
157
158
159
160
161



162


163
164
165
166
167

168
169
170


171








172
173

174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201







202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217

218
219
220
221
222
223
224
225



226
227

228
229
230
231
232
233
234
235
236
237





238
239

240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

260




261

262
263
264
265
266
267
268
269









270


271
272
273
274
275



276





277


278
279

280
281









282


283
284
285
286
287
288
289
290









291




292
293









294
295
296

297
298
299
300
301
302



303
304





305




306
307
308
309








310
311



312
313
314
315
316
317
318
319



320







321



322





323

324




325

326
327
328
329
330
331
332
333
334
335
336



337


338

339

340
341
342
343
344
345
346
347
348



349
350
351




352

353
354

355
356
357









358


359
360
361
362
363









364


365
366
367
368
369









370


371









372
373

374

375
376


377
378
379
380
381
382
383
384

385
386





387
388

389
390
391
392

393
394
395

396
397
398





399
400


401
402
403
404
405
406
407
408

409
410






411
412

413
414
415
416
417









418


419
420

















421
422
423









424


425













426




427
428
429









430


431
432
433
434
435
436
437




438
439
440


441
442

443
444





445
446






447
448


449





450
451

452





453
454

455
456
457
458
459









460


461


462
463
464
465
466
467
468

469
470





471
472

473
474
475
476
477









478


479
480
481
482
483









484


485
486
487
488
489









490


491
492
493
494
495









496


497
498
499
500
501









502


503
504
505
506
507









508


509
510
511
512
513









514


515
516
517
518
519









520


521
522
523
524
525
526
527









528




529
530
531









532


533
534
535
536
537



538





539


540

541
542
543









544


545
546
547
548
549
550









551

552
553



554
555
556
557






558
559
560
561
562
563
564
565









566


567













568



569

570
571









572


573
574
575
576
577








578
579

580
581
582
583
584
585
586
587
588
589









590


591
592
593
594
595









596


597




598


599
600





601
602


603
604
605
606
607









608


609










610
611

612
613
614

615
616
617
618
619









620


621
622
623
624
625









626



627


628


629
630





631
632

633
634
635
636
637









638


639






640
641
642




643
644

645
646
647
648
649









650


651












652
653
654
655
656

657
658
659
660
661









662


663
664
665
666
667









668


669
670
671
672
673









674


675
676
677
678
679









680


681













682



683
684


685









686


687
688
689
690
691

692







693
694
695
696
697
698
699
700
701
702
703









704


705
706
707
708
709









710


711



712

713

714
715





716
717

718
719
720
721



722






723
724

725









726
727
728

729
730

731
732
733
734
735









736


737
738
739
740
741









742


743
744
745
746
747









748


749
750
751
752
753









754


755
756
757
758
759









760


761
762
763
764
765









766


767
768
769
770
771









772


773
 *
 * 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 "ObjFWRT.h"
#import "private.h"
#import "macros.h"

#include <proto/exec.h>
#include <proto/intuition.h>

struct ObjFWRTBase;

#import "inline.h"

#include <stdio.h>
#include <stdlib.h>


#if defined(OF_AMIGAOS_M68K)
# include <stabs.h>
# define SYM(name) __asm__("_" name)


#elif defined(OF_MORPHOS)




# include <constructor.h>
# define SYM(name) __asm__(name)

#endif

#ifdef HAVE_SJLJ_EXCEPTIONS
extern int _Unwind_SjLj_RaiseException(void *);
#else
extern int _Unwind_RaiseException(void *);
#endif
extern void _Unwind_DeleteException(void *);
extern void *_Unwind_GetLanguageSpecificData(void *);
extern uintptr_t _Unwind_GetRegionStart(void *);
extern uintptr_t _Unwind_GetDataRelBase(void *);
extern uintptr_t _Unwind_GetTextRelBase(void *);
extern uintptr_t _Unwind_GetIP(void *);
extern uintptr_t _Unwind_GetGR(void *, int);
extern void _Unwind_SetIP(void *, uintptr_t);
extern void _Unwind_SetGR(void *, int, uintptr_t);
#ifdef HAVE_SJLJ_EXCEPTIONS
extern void _Unwind_SjLj_Resume(void *);
#else
extern void _Unwind_Resume(void *);
#endif


#ifdef OF_AMIGAOS_M68K
extern void __register_frame_info(const void *, void *);
extern void *__deregister_frame_info(const void *);
#endif

#ifdef OF_MORPHOS
extern void __register_frame(void *);



extern void __deregister_frame(void *);

#endif

struct Library *ObjFWRTBase;
void *__objc_class_name_Protocol;

static void
error(const char *string, ULONG arg)


{

	struct Library *IntuitionBase = OpenLibrary("intuition.library", 0);


	if (IntuitionBase != NULL) {

		struct EasyStruct easy = {
			.es_StructSize = sizeof(easy),
			.es_Flags = 0,

			.es_Title = (void *)NULL,
			.es_TextFormat = (void *)string,
			(void *)"OK"
		};

		EasyRequest(NULL, &easy, NULL, arg);

		CloseLibrary(IntuitionBase);

	}

	exit(EXIT_FAILURE);
}



static void __attribute__((__used__))


ctor(void)






{
	static bool initialized = false;
	struct objc_libc libc = {
		.malloc = malloc,
		.calloc = calloc,
		.realloc = realloc,
		.free = free,
#ifdef HAVE_SJLJ_EXCEPTIONS
		._Unwind_SjLj_RaiseException = _Unwind_SjLj_RaiseException,
#else
		._Unwind_RaiseException = _Unwind_RaiseException,
#endif
		._Unwind_DeleteException = _Unwind_DeleteException,
		._Unwind_GetLanguageSpecificData =
		    _Unwind_GetLanguageSpecificData,

		._Unwind_GetRegionStart = _Unwind_GetRegionStart,
		._Unwind_GetDataRelBase = _Unwind_GetDataRelBase,
		._Unwind_GetTextRelBase = _Unwind_GetTextRelBase,
		._Unwind_GetIP = _Unwind_GetIP,
		._Unwind_GetGR = _Unwind_GetGR,
		._Unwind_SetIP = _Unwind_SetIP,
		._Unwind_SetGR = _Unwind_SetGR,
#ifdef HAVE_SJLJ_EXCEPTIONS
		._Unwind_SjLj_Resume = _Unwind_SjLj_Resume,
#else
		._Unwind_Resume = _Unwind_Resume,
#endif


#ifdef OF_AMIGAOS_M68K
		.__register_frame_info = __register_frame_info,
		.__deregister_frame_info = __deregister_frame_info,
#endif

#ifdef OF_MORPHOS
		.__register_frame = __register_frame,



		.__deregister_frame = __deregister_frame,

#endif
#ifdef OF_AMIGAOS_M68K
		.vsnprintf = vsnprintf,
#endif
		.atexit = atexit,
		.exit = exit,
	};

	if (initialized)
		return;











	if ((ObjFWRTBase = OpenLibrary(OBJFWRT_AMIGA_LIB,
	    OBJFWRT_LIB_MINOR)) == NULL)
		error("Failed to open " OBJFWRT_AMIGA_LIB " version %lu!",
		    OBJFWRT_LIB_MINOR);


	if (!glue_objc_init(1, &libc))
		error("Failed to initialize " OBJFWRT_AMIGA_LIB "!", 0);

	initialized = true;
}

static void __attribute__((__used__))
dtor(void)

{
	CloseLibrary(ObjFWRTBase);
}

#if defined(OF_AMIGAOS_M68K)
ADD2INIT(ctor, -2);
ADD2EXIT(dtor, -2);



#elif defined(OF_MORPHOS)


CONSTRUCTOR_P(ObjFWRT, 4000)
{
	ctor();

	return 0;

}

DESTRUCTOR_P(ObjFWRT, 4000)


{








	dtor();
}

#endif

void
__objc_exec_class(struct objc_module *module)
{
	/*
	 * The compiler generates constructors that call into this, so it is
	 * possible that we are not set up yet when we get called.
	 */
	ctor();

	glue___objc_exec_class(module);
}

IMP
objc_msg_lookup(id object, SEL selector)
{
	return glue_objc_msg_lookup(object, selector);
}

IMP
objc_msg_lookup_stret(id object, SEL selector)
{
	return glue_objc_msg_lookup_stret(object, selector);
}

IMP
objc_msg_lookup_super(struct objc_super *super, SEL selector)







{
	return glue_objc_msg_lookup_super(super, selector);
}

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

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


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

Class
objc_getRequiredClass(const char *name)



{
	return glue_objc_getRequiredClass(name);

}

Class
objc_lookup_class(const char *name)
{
	return glue_objc_lookup_class(name);
}

Class
objc_get_class(const char *name)





{
	return glue_objc_get_class(name);

}

void
objc_exception_throw(id object)
{
#ifdef OF_AMIGAOS_M68K
	/*
	 * This does not use the glue code to hack around a compiler bug.
	 *
	 * When using the generated inline stubs, the compiler does not emit
	 * any frame information, making the unwind fail. As unwind always
	 * starts from objc_exception_throw(), this means exceptions would
	 * never work. If, however, we're using a function pointer instead of
	 * the inline stub, the compiler does generate a frame and everything
	 * works fine.
	 */
	register void *a6 __asm__("a6") = ObjFWRTBase;
	uintptr_t throw = (((uintptr_t)ObjFWRTBase) - 0x60);
	((void (*)(id __asm__("a0")))throw)(object);
	(void)a6;

#else




	glue_objc_exception_throw(object);

#endif

	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 object)
{
#ifdef OF_AMIGAOS_M68K








	/*
	 * This does not use the glue code to hack around a compiler bug.



	 *
	 * When using the generated inline stubs, the compiler does not emit
	 * any frame information, making the unwind fail. As a result
	 * objc_enumerationMutation() might throw an exception that could never
	 * be caught. If, however, we're using a function pointer instead of
	 * the inline stub, the compiler does generate a frame and everything
	 * works fine.
	 */



	register void *a6 __asm__("a6") = ObjFWRTBase;







	uintptr_t enumerationMutation = (((uintptr_t)ObjFWRTBase) - 0x8A);



	((void (*)(id __asm__("a0")))enumerationMutation)(object);





	(void)a6;

#else




	glue_objc_enumerationMutation(object);

#endif

	OF_UNREACHABLE
}

#ifdef HAVE_SJLJ_EXCEPTIONS
int
__gnu_objc_personality_sj0(int version, int actions, uint64_t exClass,
    void *ex, void *ctx)
{
# ifdef OF_AMIGAOS_M68K



	return glue___gnu_objc_personality(version, actions, &exClass, ex, ctx);


# else

	return glue___gnu_objc_personality(version, actions, exClass, ex, ctx);

# endif
}
#else
int
__gnu_objc_personality_v0(int version, int actions, uint64_t exClass,
    void *ex, void *ctx)
{
# ifdef OF_AMIGAOS_M68K
	return glue___gnu_objc_personality(version, actions, &exClass, ex, ctx);



# else
	return glue___gnu_objc_personality(version, actions, exClass, ex, ctx);
# endif




}

#endif


id
objc_retain(id object)
{









	return glue_objc_retain(object);


}

id
objc_retainBlock(id block)
{









	return glue_objc_retainBlock(block);


}

id
objc_retainAutorelease(id object)
{









	return glue_objc_retainAutorelease(object);


}










void

objc_release(id object)

{
	glue_objc_release(object);


}

id
objc_autorelease(id object)
{
	return glue_objc_autorelease(object);
}


id
objc_autoreleaseReturnValue(id object)





{
	return glue_objc_autoreleaseReturnValue(object);

}

id
objc_retainAutoreleaseReturnValue(id object)

{
	return glue_objc_retainAutoreleaseReturnValue(object);
}


id
objc_retainAutoreleasedReturnValue(id object)





{
	return glue_objc_retainAutoreleasedReturnValue(object);


}

id
objc_storeStrong(id *object, id value)
{
	return glue_objc_storeStrong(object, value);
}


id
objc_storeWeak(id *object, id value)






{
	return glue_objc_storeWeak(object, value);

}

id
objc_loadWeakRetained(id *object)
{









	return glue_objc_loadWeakRetained(object);


}


















id
objc_initWeak(id *object, id value)
{









	return glue_objc_initWeak(object, value);


}


















void
objc_destroyWeak(id *object)
{









	glue_objc_destroyWeak(object);


}

id
objc_loadWeak(id *object)
{
	return glue_objc_loadWeak(object);
}





void
objc_copyWeak(id *dest, id *src)


{
	glue_objc_copyWeak(dest, src);

}






void
objc_moveWeak(id *dest, id *src)






{
	glue_objc_moveWeak(dest, src);


}






SEL

sel_registerName(const char *name)





{
	return glue_sel_registerName(name);

}

const char *
sel_getName(SEL selector)
{









	return glue_sel_getName(selector);


}



bool
sel_isEqual(SEL selector1, SEL selector2)
{
	return glue_sel_isEqual(selector1, selector2);
}


Class
objc_allocateClassPair(Class superclass, const char *name, size_t extraBytes)





{
	return glue_objc_allocateClassPair(superclass, name, extraBytes);

}

void
objc_registerClassPair(Class class)
{









	glue_objc_registerClassPair(class);


}

unsigned int
objc_getClassList(Class *buffer, unsigned int count)
{









	return glue_objc_getClassList(buffer, count);


}

Class *
objc_copyClassList(unsigned int *length)
{









	return glue_objc_copyClassList(length);


}

bool
class_isMetaClass(Class class)
{









	return glue_class_isMetaClass(class);


}

const char *
class_getName(Class class)
{









	return glue_class_getName(class);


}

Class
class_getSuperclass(Class class)
{









	return glue_class_getSuperclass(class);


}

unsigned long
class_getInstanceSize(Class class)
{









	return glue_class_getInstanceSize(class);


}

bool
class_respondsToSelector(Class class, SEL selector)
{









	return glue_class_respondsToSelector(class, selector);


}

bool
class_conformsToProtocol(Class class, Protocol *protocol)
{
	return glue_class_conformsToProtocol(class, protocol);
}














IMP
class_getMethodImplementation(Class class, SEL selector)
{









	return glue_class_getMethodImplementation(class, selector);


}

IMP
class_getMethodImplementation_stret(Class class, SEL selector)
{



	return glue_class_getMethodImplementation_stret(class, selector);





}




Method
class_getInstanceMethod(Class class, SEL selector)
{









	return glue_class_getInstanceMethod(class, selector);


}

bool
class_addMethod(Class class, SEL selector, IMP implementation,
    const char *typeEncoding)
{









	return glue_class_addMethod(class, selector, implementation,

	    typeEncoding);
}




IMP
class_replaceMethod(Class class, SEL selector, IMP implementation,
    const char *typeEncoding)






{
	return glue_class_replaceMethod(class, selector, implementation,
	    typeEncoding);
}

Class
object_getClass(id object)
{









	return glue_object_getClass(object);


}

















Class

object_setClass(id object, Class class)
{









	return glue_object_setClass(object, class);


}

const char *
object_getClassName(id object)
{








	return glue_object_getClassName(object);
}


const char *
protocol_getName(Protocol *protocol)
{
	return glue_protocol_getName(protocol);
}

bool
protocol_isEqual(Protocol *protocol1, Protocol *protocol2)
{









	return glue_protocol_isEqual(protocol1, protocol2);


}

bool
protocol_conformsToProtocol(Protocol *protocol1, Protocol *protocol2)
{









	return glue_protocol_conformsToProtocol(protocol1, protocol2);


}







objc_uncaught_exception_handler_t
objc_setUncaughtExceptionHandler(objc_uncaught_exception_handler_t handler)





{
	return glue_objc_setUncaughtExceptionHandler(handler);


}

void
objc_setForwardHandler(IMP forward, IMP stretForward)
{









	glue_objc_setForwardHandler(forward, stretForward);


}











void

objc_setEnumerationMutationHandler(objc_enumeration_mutation_handler_t handler)
{
	glue_objc_setEnumerationMutationHandler(handler);

}

id
objc_constructInstance(Class class, void *_Nullable bytes)
{









	return glue_objc_constructInstance(class, bytes);


}

void
objc_exit(void)
{









	glue_objc_exit();



}





Ivar *
class_copyIvarList(Class class, unsigned int *outCount)





{
	return glue_class_copyIvarList(class, outCount);

}

const char *
ivar_getName(Ivar ivar)
{









	return glue_ivar_getName(ivar);


}







const char *
ivar_getTypeEncoding(Ivar ivar)




{
	return glue_ivar_getTypeEncoding(ivar);

}

ptrdiff_t
ivar_getOffset(Ivar ivar)
{









	return glue_ivar_getOffset(ivar);


}













Method *
class_copyMethodList(Class class, unsigned int *outCount)
{
	return glue_class_copyMethodList(class, outCount);

}

SEL
method_getName(Method method)
{









	return glue_method_getName(method);


}

const char *
method_getTypeEncoding(Method method)
{









	return glue_method_getTypeEncoding(method);


}

objc_property_t *
class_copyPropertyList(Class class, unsigned int *outCount)
{









	return glue_class_copyPropertyList(class, outCount);


}

const char *
property_getName(objc_property_t property)
{









	return glue_property_getName(property);


}

















char *
property_copyAttributeValue(objc_property_t property, const char *name)


{









	return glue_property_copyAttributeValue(property, name);


}

void *
objc_destructInstance(id object)
{

	return glue_objc_destructInstance(object);







}

void *
objc_autoreleasePoolPush(void)
{
	return glue_objc_autoreleasePoolPush();
}

void
objc_autoreleasePoolPop(void *pool)
{









	glue_objc_autoreleasePoolPop(pool);


}

id
_objc_rootAutorelease(id object)
{









	return glue__objc_rootAutorelease(object);


}





struct objc_hashtable *

objc_hashtable_new(objc_hashtable_hash_func hash,
    objc_hashtable_equal_func equal, uint32_t size)





{
	return glue_objc_hashtable_new(hash, equal, size);

}

void
objc_hashtable_set(struct objc_hashtable *table, const void *key,



    const void *object)






{
	glue_objc_hashtable_set(table, key, object);

}










void *
objc_hashtable_get(struct objc_hashtable *table, const void *key)

{
	return glue_objc_hashtable_get(table, key);

}

void
objc_hashtable_delete(struct objc_hashtable *table, const void *key)
{









	glue_objc_hashtable_delete(table, key);


}

void
objc_hashtable_free(struct objc_hashtable *table)
{









	glue_objc_hashtable_free(table);


}

void
objc_setTaggedPointerSecret(uintptr_t secret)
{









	glue_objc_setTaggedPointerSecret(secret);


}

int
objc_registerTaggedPointerClass(Class class)
{









	return glue_objc_registerTaggedPointerClass(class);


}

bool
object_isTaggedPointer(id object)
{









	return glue_object_isTaggedPointer(object);


}

uintptr_t
object_getTaggedPointerValue(id object)
{









	return glue_object_getTaggedPointerValue(object);


}

id
objc_createTaggedPointer(int class, uintptr_t value)
{









	return glue_objc_createTaggedPointer(class, value);


}







>
>




<

<
<
<
|

<
|
<
<
>
|

<
|
>
>

>
>
>
>
|
<
>

|
<
<
<
<
<
<
<
<
<
<
|
<
<
<
<
<
<
|
<
>
>
|
<
|
|
>
|
|
>
>
>
|
>

|
<
<

<
<
>
>

>
|
|
>
|
>
|
|
<
>
<
<
<
<

<
|
<
>
|

<
<
>
>
|
<
>
>
|
>
>
>
>
>
>
|
<
<
|
<
<
<
<
<
<
<

<
<
<
>
|
<
<
<
<
<
<
<
<
|
<
<
>
>
|
|
<
|
>
|
|
>
>
>
|
>

<
<
<
<
<
<
|
|
|
>
|
>
>
>
>
>
>
>
>
>
<
<
<
<

>
|
<
|
<
|
|
<
<
>

<
<
<

<
<
>
>
>

>
>
|
<
|

|
>


<
>
>

>
>
>
>
>
>
>
>
|
|
>

|
<
<
|
<
<
<
<
<
|
<
<
|
<
<

<
<
|
<
<
<
<
<
|
<
<
>
>
>
>
>
>
>
|
|
<
|
<
<
<
<


|
|

<
<
|
>
|
|
<
<
<
|
|
<
>
>
>
|
|
>


|
|

|
<
|
|
|
>
>
>
>
>
|
|
>



|

|
<
<
<
<
<
<
<
<
<
<
|
<
<

>
|
>
>
>
>
|
>






|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
|
>
>
>
>
>
|
>
>
|
|
>
|

>
>
>
>
>
>
>
>
>
|
>
>



|
<

<
<
>
>
>
>
>
>
>
>
>

>
>
>
>

|
>
>
>
>
>
>
>
>
>
|
|
|
>



|
<

>
>
>
|
<
>
>
>
>
>

>
>
>
>

|

|
>
>
>
>
>
>
>
>
|
<
>
>
>
|
<
<
<
<
<
|
<
>
>
>
|
>
>
>
>
>
>
>
|
>
>
>
|
>
>
>
>
>

>
|
>
>
>
>
|
>

|
<
|
|
<
<
<
|

|
>
>
>
|
>
>
|
>
|
>
|

|
|
<
|

|
<
>
>
>
|
<
<
>
>
>
>
|
>

|
>
|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
>
>
>
|
<
>
|
>
|
<
>
>


|
|

<
<
|
>
|
|
>
>
>
>
>
|
|
>


|
<
>

<
<
>
|
|
|
>
>
>
>
>
|
<
>
>


|
|

<
<
|
>
|
<
>
>
>
>
>
>
|
|
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>


>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
>
>
>
>
>
>
>

>
>
>
>

|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

<
<
>
>
>
>
|
|
|
>
>
|
|
>


>
>
>
>
>
|
<
>
>
>
>
>
>
|
<
>
>

>
>
>
>
>
|
<
>
|
>
>
>
>
>
|
|
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
|
<
<

<
<
|
>
|
|
>
>
>
>
>
|
|
>



|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>



|

<
<
>
>
>
>
>
>
>
>
>

>
>
>
>
|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
|
>
>
>
>
>
|
>
>
|
>
|
|

>
>
>
>
>
>
>
>
>
|
>
>



|
<

>
>
>
>
>
>
>
>
>
|
>
|

>
>
>
|
|
|
|
>
>
>
>
>
>
|
|
|


|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
>
>
>
>
>
>
>

>
>
>
|
>
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
|
|
>
|
<
<
<
<



|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
|
>
>
|
<
>
>
>
>
>
|
<
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
>
>
>
>
|
<
>
|
|
|
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>
>
|
>
>
|
>
>
|
|
>
>
>
>
>
|
|
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
|
|
|
>
>
>
>
|
|
>



|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
>
>
>
>
>
>
|
<
<
|
|
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
>
>
>
>
>
>
>
>
>
>

>
>
>
|
<
>
>

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
|
>
>
>
>
>
>
>
|
|
|
<
<
<



|

>
>
>
>
>
>
>
>
>
|
>
>


|
|

>
>
>
>
>
>
>
>
>
|
>
>

>
>
>
|
>
|
>
|
<
>
>
>
>
>
|
|
>



|
>
>
>
|
>
>
>
>
>
>
|
|
>

>
>
>
>
>
>
>
>
>
|
|
|
>
|
|
>



|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>





>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>



|

>
>
>
>
>
>
>
>
>
|
>
>


|


>
>
>
>
>
>
>
>
>
|
>
>

11
12
13
14
15
16
17
18
19
20
21
22
23

24



25
26

27


28
29
30

31
32
33
34
35
36
37
38
39

40
41
42










43






44

45
46
47

48
49
50
51
52
53
54
55
56
57
58
59


60


61
62
63
64
65
66
67
68
69
70
71

72




73

74

75
76
77


78
79
80

81
82
83
84
85
86
87
88
89
90


91







92



93
94








95


96
97
98
99

100
101
102
103
104
105
106
107
108
109






110
111
112
113
114
115
116
117
118
119
120
121
122
123




124
125
126

127

128
129


130
131



132


133
134
135
136
137
138
139

140
141
142
143
144
145

146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161


162





163


164


165


166





167


168
169
170
171
172
173
174
175
176

177




178
179
180
181
182


183
184
185
186



187
188

189
190
191
192
193
194
195
196
197
198
199
200

201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217










218


219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285

286


287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319

320
321
322
323
324

325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347

348
349
350
351





352

353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384

385
386



387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403

404
405
406

407
408
409
410


411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479

480
481
482
483

484
485
486
487
488
489
490


491
492
493
494
495
496
497
498
499
500
501
502
503
504
505

506
507


508
509
510
511
512
513
514
515
516
517

518
519
520
521
522
523
524


525
526
527

528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626


627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646

647
648
649
650
651
652
653

654
655
656
657
658
659
660
661
662

663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693


694


695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847


848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914

915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012




1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055

1056
1057
1058
1059
1060
1061

1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092

1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213


1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303

1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335



1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378

1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
 *
 * 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.
 */

/* This file is automatically generated from library.xml */

#include "config.h"

#import "ObjFWRT.h"
#import "private.h"





extern struct Library *ObjFWRTBase;


bool


objc_init(unsigned int version, struct objc_libc *libc)
{
#if defined(OF_AMIGAOS_M68K)

	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(unsigned int __asm__("d0"), struct objc_libc *__asm__("a0")))(((uintptr_t)ObjFWRTBase) - 30))(version, libc);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);


	return ((bool (*)(unsigned int, struct objc_libc *))*(void **)(((uintptr_t)ObjFWRTBase) - 28))(version, libc);
#endif
}

















void

__objc_exec_class(struct objc_module *_Nonnull module)
{
#if defined(OF_AMIGAOS_M68K)

	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(struct objc_module *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 36))(module);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(struct objc_module *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 34))(module);
#endif
}





IMP _Nonnull
objc_msg_lookup(id _Nullable object, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((IMP _Nonnull (*)(id _Nullable __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 42))(object, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"

	);






	return ((IMP _Nonnull (*)(id _Nullable, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 40))(object, selector);

#endif
}



IMP _Nonnull
objc_msg_lookup_stret(id _Nullable object, SEL _Nonnull selector)
{

#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((IMP _Nonnull (*)(id _Nullable __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 48))(object, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);



	return ((IMP _Nonnull (*)(id _Nullable, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 46))(object, selector);







#endif



}









IMP _Nonnull


objc_msg_lookup_super(struct objc_super *_Nonnull super, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;

	(void)a6;
	return ((IMP _Nonnull (*)(struct objc_super *_Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 54))(super, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((IMP _Nonnull (*)(struct objc_super *_Nonnull, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 52))(super, selector);
#endif






}

IMP _Nonnull
objc_msg_lookup_super_stret(struct objc_super *_Nonnull super, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((IMP _Nonnull (*)(struct objc_super *_Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 60))(super, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);





	return ((IMP _Nonnull (*)(struct objc_super *_Nonnull, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 58))(super, selector);
#endif

}


Class _Nullable


objc_lookUpClass(const char *_Nonnull name)
{



#if defined(OF_AMIGAOS_M68K)


	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nullable (*)(const char *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 66))(name);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"

	);

	return ((Class _Nullable (*)(const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 64))(name);
#endif
}


Class _Nullable
objc_getClass(const char *_Nonnull name)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nullable (*)(const char *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 72))(name);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nullable (*)(const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 70))(name);
#endif
}








Class _Nonnull


objc_getRequiredClass(const char *_Nonnull name)


{


#if defined(OF_AMIGAOS_M68K)





	register struct Library *a6 __asm__("a6") = ObjFWRTBase;


	(void)a6;
	return ((Class _Nonnull (*)(const char *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 78))(name);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nonnull (*)(const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 76))(name);

#endif




}

Class _Nullable
objc_lookup_class(const char *_Nonnull name)
{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nullable (*)(const char *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 84))(name);



#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (

	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nullable (*)(const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 82))(name);
#endif
}

Class _Nonnull
objc_get_class(const char *_Nonnull name)
{
#if defined(OF_AMIGAOS_M68K)

	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nonnull (*)(const char *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 90))(name);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nonnull (*)(const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 88))(name);
#endif
}

void
objc_exception_throw(id _Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)










	register struct Library *a6 __asm__("a6") = ObjFWRTBase;


	(void)a6;
	((void (*)(id _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 96))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(id _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 94))(object);
#endif

	OF_UNREACHABLE
}

int
objc_sync_enter(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((int (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 102))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((int (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 100))(object);
#endif
}

int
objc_sync_exit(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((int (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 108))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((int (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 106))(object);
#endif
}

id _Nullable
objc_getProperty(id _Nonnull self, SEL _Nonnull _cmd, ptrdiff_t offset, bool atomic)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1"), ptrdiff_t __asm__("d0"), bool __asm__("d1")))(((uintptr_t)ObjFWRTBase) - 114))(self, _cmd, offset, atomic);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nonnull, SEL _Nonnull, ptrdiff_t, bool))*(void **)(((uintptr_t)ObjFWRTBase) - 112))(self, _cmd, offset, atomic);
#endif
}

void
objc_setProperty(id _Nonnull self, SEL _Nonnull _cmd, ptrdiff_t offset, id _Nullable value, bool atomic, signed char copy)

{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(id _Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1"), ptrdiff_t __asm__("d0"), id _Nullable __asm__("a2"), bool __asm__("d1"), signed char __asm__("d2")))(((uintptr_t)ObjFWRTBase) - 120))(self, _cmd, offset, value, atomic, copy);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(id _Nonnull, SEL _Nonnull, ptrdiff_t, id _Nullable, bool, signed char))*(void **)(((uintptr_t)ObjFWRTBase) - 118))(self, _cmd, offset, value, atomic, copy);
#endif
}

void
objc_getPropertyStruct(void *_Nonnull dest, const void *_Nonnull src, ptrdiff_t size, bool atomic, bool strong)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(void *_Nonnull __asm__("a0"), const void *_Nonnull __asm__("a1"), ptrdiff_t __asm__("d0"), bool __asm__("d1"), bool __asm__("d2")))(((uintptr_t)ObjFWRTBase) - 126))(dest, src, size, atomic, strong);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(void *_Nonnull, const void *_Nonnull, ptrdiff_t, bool, bool))*(void **)(((uintptr_t)ObjFWRTBase) - 124))(dest, src, size, atomic, strong);
#endif
}

void
objc_setPropertyStruct(void *_Nonnull dest, const void *_Nonnull src, ptrdiff_t size, bool atomic, bool strong)

{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(void *_Nonnull __asm__("a0"), const void *_Nonnull __asm__("a1"), ptrdiff_t __asm__("d0"), bool __asm__("d1"), bool __asm__("d2")))(((uintptr_t)ObjFWRTBase) - 132))(dest, src, size, atomic, strong);

#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(void *_Nonnull, const void *_Nonnull, ptrdiff_t, bool, bool))*(void **)(((uintptr_t)ObjFWRTBase) - 130))(dest, src, size, atomic, strong);
#endif
}

void
objc_enumerationMutation(id _Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(id _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 138))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);


	((void (*)(id _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 136))(object);
#endif
}






int

__gnu_objc_personality(int version, int actions, uint64_t *_Nonnull exClass, void *_Nonnull ex, void *_Nonnull ctx)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((int (*)(int __asm__("d0"), int __asm__("d1"), uint64_t *_Nonnull __asm__("d2"), void *_Nonnull __asm__("a0"), void *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 144))(version, actions, exClass, ex, ctx);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((int (*)(int, int, uint64_t *_Nonnull, void *_Nonnull, void *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 142))(version, actions, exClass, ex, ctx);
#endif
}

id _Nullable
objc_retain(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 150))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 148))(object);
#endif
}


id _Nullable



objc_retainBlock(id _Nullable block)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 156))(block);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 154))(block);
#endif
}

id _Nullable

objc_retainAutorelease(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)

	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 162))(object);
#elif defined(OF_MORPHOS)


	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 160))(object);
#endif
}

void
objc_release(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 168))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 166))(object);
#endif
}

id _Nullable
objc_autorelease(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 174))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 172))(object);
#endif
}

id _Nullable
objc_autoreleaseReturnValue(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 180))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 178))(object);
#endif
}

id _Nullable
objc_retainAutoreleaseReturnValue(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 186))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (

	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);


	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 184))(object);
#endif
}

id _Nullable
objc_retainAutoreleasedReturnValue(id _Nullable object)
{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 192))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 190))(object);
#endif
}

id _Nullable

objc_storeStrong(id _Nullable *_Nonnull object, id _Nullable value)
{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable *_Nonnull __asm__("a0"), id _Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 198))(object, value);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);


	return ((id _Nullable (*)(id _Nullable *_Nonnull, id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 196))(object, value);
#endif
}

id _Nullable
objc_storeWeak(id _Nullable *_Nonnull object, id _Nullable value)
{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;

	return ((id _Nullable (*)(id _Nullable *_Nonnull __asm__("a0"), id _Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 204))(object, value);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable *_Nonnull, id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 202))(object, value);
#endif
}

id _Nullable
objc_loadWeakRetained(id _Nullable *_Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 210))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 208))(object);
#endif
}

id _Nullable
objc_initWeak(id _Nullable *_Nonnull object, id _Nullable value)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable *_Nonnull __asm__("a0"), id _Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 216))(object, value);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable *_Nonnull, id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 214))(object, value);
#endif
}

void
objc_destroyWeak(id _Nullable *_Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(id _Nullable *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 222))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(id _Nullable *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 220))(object);
#endif
}

id _Nullable
objc_loadWeak(id _Nullable *_Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 228))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 226))(object);
#endif
}

void
objc_copyWeak(id _Nullable *_Nonnull dest, id _Nullable *_Nonnull src)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(id _Nullable *_Nonnull __asm__("a0"), id _Nullable *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 234))(dest, src);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(id _Nullable *_Nonnull, id _Nullable *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 232))(dest, src);
#endif
}

void
objc_moveWeak(id _Nullable *_Nonnull dest, id _Nullable *_Nonnull src)
{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(id _Nullable *_Nonnull __asm__("a0"), id _Nullable *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 240))(dest, src);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(id _Nullable *_Nonnull, id _Nullable *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 238))(dest, src);
#endif
}

SEL _Nonnull
sel_registerName(const char *_Nonnull name)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;

	return ((SEL _Nonnull (*)(const char *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 246))(name);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);


	return ((SEL _Nonnull (*)(const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 244))(name);
#endif
}

const char *_Nonnull
sel_getName(SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;

	(void)a6;
	return ((const char *_Nonnull (*)(SEL _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 252))(selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nonnull (*)(SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 250))(selector);
#endif
}

bool
sel_isEqual(SEL _Nonnull selector1, SEL _Nonnull selector2)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(SEL _Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 258))(selector1, selector2);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(SEL _Nonnull, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 256))(selector1, selector2);
#endif
}

Class _Nonnull
objc_allocateClassPair(Class _Nullable superclass, const char *_Nonnull name, size_t extraBytes)


{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nonnull (*)(Class _Nullable __asm__("a0"), const char *_Nonnull __asm__("a1"), size_t __asm__("d0")))(((uintptr_t)ObjFWRTBase) - 264))(superclass, name, extraBytes);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nonnull (*)(Class _Nullable, const char *_Nonnull, size_t))*(void **)(((uintptr_t)ObjFWRTBase) - 262))(superclass, name, extraBytes);
#endif
}

void
objc_registerClassPair(Class _Nonnull class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(Class _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 270))(class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(Class _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 268))(class);
#endif
}

unsigned int
objc_getClassList(Class _Nonnull *_Nullable buffer, unsigned int count)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((unsigned int (*)(Class _Nonnull *_Nullable __asm__("a0"), unsigned int __asm__("d0")))(((uintptr_t)ObjFWRTBase) - 276))(buffer, count);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((unsigned int (*)(Class _Nonnull *_Nullable, unsigned int))*(void **)(((uintptr_t)ObjFWRTBase) - 274))(buffer, count);
#endif
}

Class _Nonnull *_Nonnull
objc_copyClassList(unsigned int *_Nullable length)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nonnull *_Nonnull (*)(unsigned int *_Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 282))(length);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nonnull *_Nonnull (*)(unsigned int *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 280))(length);
#endif
}

bool
class_isMetaClass(Class _Nullable class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(Class _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 288))(class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(Class _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 286))(class);
#endif
}

const char *_Nullable
class_getName(Class _Nullable class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nullable (*)(Class _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 294))(class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nullable (*)(Class _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 292))(class);
#endif
}

Class _Nullable
class_getSuperclass(Class _Nullable class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nullable (*)(Class _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 300))(class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nullable (*)(Class _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 298))(class);
#endif
}

unsigned long
class_getInstanceSize(Class _Nullable class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((unsigned long (*)(Class _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 306))(class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((unsigned long (*)(Class _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 304))(class);
#endif
}

bool
class_respondsToSelector(Class _Nullable class, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(Class _Nullable __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 312))(class, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(Class _Nullable, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 310))(class, selector);
#endif
}

bool
class_conformsToProtocol(Class _Nullable class, Protocol *_Nonnull p)
{


#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(Class _Nullable __asm__("a0"), Protocol *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 318))(class, p);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(Class _Nullable, Protocol *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 316))(class, p);
#endif
}

IMP _Nullable
class_getMethodImplementation(Class _Nullable class, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((IMP _Nullable (*)(Class _Nullable __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 324))(class, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((IMP _Nullable (*)(Class _Nullable, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 322))(class, selector);
#endif
}

IMP _Nullable
class_getMethodImplementation_stret(Class _Nullable class, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((IMP _Nullable (*)(Class _Nullable __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 330))(class, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((IMP _Nullable (*)(Class _Nullable, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 328))(class, selector);
#endif
}

Method _Nullable
class_getInstanceMethod(Class _Nullable class, SEL _Nonnull selector)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Method _Nullable (*)(Class _Nullable __asm__("a0"), SEL _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 336))(class, selector);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Method _Nullable (*)(Class _Nullable, SEL _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 334))(class, selector);
#endif
}

bool
class_addMethod(Class _Nonnull class, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding)

{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(Class _Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1"), IMP _Nonnull __asm__("a2"), const char *_Nullable __asm__("a3")))(((uintptr_t)ObjFWRTBase) - 342))(class, selector, implementation, typeEncoding);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(Class _Nonnull, SEL _Nonnull, IMP _Nonnull, const char *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 340))(class, selector, implementation, typeEncoding);
#endif
}

IMP _Nullable
class_replaceMethod(Class _Nonnull class, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((IMP _Nullable (*)(Class _Nonnull __asm__("a0"), SEL _Nonnull __asm__("a1"), IMP _Nonnull __asm__("a2"), const char *_Nullable __asm__("a3")))(((uintptr_t)ObjFWRTBase) - 348))(class, selector, implementation, typeEncoding);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((IMP _Nullable (*)(Class _Nonnull, SEL _Nonnull, IMP _Nonnull, const char *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 346))(class, selector, implementation, typeEncoding);
#endif
}

Class _Nullable
object_getClass(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 354))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 352))(object);
#endif
}

Class _Nullable
object_setClass(id _Nullable object, Class _Nonnull class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Class _Nullable (*)(id _Nullable __asm__("a0"), Class _Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 360))(object, class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Class _Nullable (*)(id _Nullable, Class _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 358))(object, class);
#endif
}

const char *_Nullable
object_getClassName(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 366))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 364))(object);
#endif
}

const char *_Nonnull
protocol_getName(Protocol *_Nonnull protocol)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nonnull (*)(Protocol *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 372))(protocol);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nonnull (*)(Protocol *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 370))(protocol);
#endif




}

bool
protocol_isEqual(Protocol *_Nonnull protocol1, Protocol *_Nonnull protocol2)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(Protocol *_Nonnull __asm__("a0"), Protocol *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 378))(protocol1, protocol2);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(Protocol *_Nonnull, Protocol *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 376))(protocol1, protocol2);
#endif
}

bool
protocol_conformsToProtocol(Protocol *_Nonnull protocol1, Protocol *_Nonnull protocol2)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(Protocol *_Nonnull __asm__("a0"), Protocol *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 384))(protocol1, protocol2);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(Protocol *_Nonnull, Protocol *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 382))(protocol1, protocol2);
#endif
}

_Nullable objc_uncaught_exception_handler_t
objc_setUncaughtExceptionHandler(objc_uncaught_exception_handler_t _Nullable handler)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((_Nullable objc_uncaught_exception_handler_t (*)(objc_uncaught_exception_handler_t _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 390))(handler);

#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);


	return ((_Nullable objc_uncaught_exception_handler_t (*)(objc_uncaught_exception_handler_t _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 388))(handler);
#endif
}

void
objc_setForwardHandler(IMP _Nullable forward, IMP _Nullable stretForward)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(IMP _Nullable __asm__("a0"), IMP _Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 396))(forward, stretForward);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(IMP _Nullable, IMP _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 394))(forward, stretForward);
#endif
}

void
objc_setEnumerationMutationHandler(objc_enumeration_mutation_handler_t _Nullable hadler)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(objc_enumeration_mutation_handler_t _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 402))(hadler);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"

	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(objc_enumeration_mutation_handler_t _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 400))(hadler);
#endif
}

id _Nullable
objc_constructInstance(Class _Nullable class, void *_Nullable bytes)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(Class _Nullable __asm__("a0"), void *_Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 408))(class, bytes);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(Class _Nullable, void *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 406))(class, bytes);
#endif
}

void
objc_exit()
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)())(((uintptr_t)ObjFWRTBase) - 414))();
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)())*(void **)(((uintptr_t)ObjFWRTBase) - 412))();
#endif
}

Ivar _Nullable *_Nullable
class_copyIvarList(Class _Nullable class, unsigned int *_Nullable outCount)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Ivar _Nullable *_Nullable (*)(Class _Nullable __asm__("a0"), unsigned int *_Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 420))(class, outCount);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((Ivar _Nullable *_Nullable (*)(Class _Nullable, unsigned int *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 418))(class, outCount);
#endif
}

const char *_Nonnull
ivar_getName(Ivar _Nonnull ivar)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nonnull (*)(Ivar _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 426))(ivar);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nonnull (*)(Ivar _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 424))(ivar);
#endif
}

const char *_Nonnull
ivar_getTypeEncoding(Ivar _Nonnull ivar)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nonnull (*)(Ivar _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 432))(ivar);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nonnull (*)(Ivar _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 430))(ivar);
#endif
}

ptrdiff_t
ivar_getOffset(Ivar _Nonnull ivar)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((ptrdiff_t (*)(Ivar _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 438))(ivar);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((ptrdiff_t (*)(Ivar _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 436))(ivar);
#endif
}

Method _Nullable *_Nullable
class_copyMethodList(Class _Nullable class, unsigned int *_Nullable outCount)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((Method _Nullable *_Nullable (*)(Class _Nullable __asm__("a0"), unsigned int *_Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 444))(class, outCount);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);



	return ((Method _Nullable *_Nullable (*)(Class _Nullable, unsigned int *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 442))(class, outCount);
#endif
}

SEL _Nonnull
method_getName(Method _Nonnull method)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((SEL _Nonnull (*)(Method _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 450))(method);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((SEL _Nonnull (*)(Method _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 448))(method);
#endif
}

const char *_Nullable
method_getTypeEncoding(Method _Nonnull method)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nullable (*)(Method _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 456))(method);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nullable (*)(Method _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 454))(method);
#endif
}

objc_property_t _Nullable *_Nullable
class_copyPropertyList(Class _Nullable class, unsigned int *_Nullable outCount)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((objc_property_t _Nullable *_Nullable (*)(Class _Nullable __asm__("a0"), unsigned int *_Nullable __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 462))(class, outCount);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((objc_property_t _Nullable *_Nullable (*)(Class _Nullable, unsigned int *_Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 460))(class, outCount);
#endif
}

const char *_Nonnull
property_getName(objc_property_t _Nonnull property)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((const char *_Nonnull (*)(objc_property_t _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 468))(property);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((const char *_Nonnull (*)(objc_property_t _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 466))(property);
#endif
}

char *_Nullable
property_copyAttributeValue(objc_property_t _Nonnull property, const char *_Nonnull name)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((char *_Nullable (*)(objc_property_t _Nonnull __asm__("a0"), const char *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 474))(property, name);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((char *_Nullable (*)(objc_property_t _Nonnull, const char *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 472))(property, name);
#endif
}


void *_Nullable
objc_destructInstance(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((void *_Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 480))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((void *_Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 478))(object);
#endif
}

void *_Null_unspecified
objc_autoreleasePoolPush()
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((void *_Null_unspecified (*)())(((uintptr_t)ObjFWRTBase) - 486))();
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((void *_Null_unspecified (*)())*(void **)(((uintptr_t)ObjFWRTBase) - 484))();
#endif



}

void
objc_autoreleasePoolPop(void *_Null_unspecified pool)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(void *_Null_unspecified __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 492))(pool);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(void *_Null_unspecified))*(void **)(((uintptr_t)ObjFWRTBase) - 490))(pool);
#endif
}

id _Nullable
_objc_rootAutorelease(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 498))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 496))(object);
#endif
}

struct objc_hashtable *_Nonnull
objc_hashtable_new(objc_hashtable_hash_func hash, objc_hashtable_equal_func equal, uint32_t size)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((struct objc_hashtable *_Nonnull (*)(objc_hashtable_hash_func __asm__("a0"), objc_hashtable_equal_func __asm__("a1"), uint32_t __asm__("d0")))(((uintptr_t)ObjFWRTBase) - 504))(hash, equal, size);

#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((struct objc_hashtable *_Nonnull (*)(objc_hashtable_hash_func, objc_hashtable_equal_func, uint32_t))*(void **)(((uintptr_t)ObjFWRTBase) - 502))(hash, equal, size);
#endif
}

void
objc_hashtable_set(struct objc_hashtable *_Nonnull table, const void *_Nonnull key, const void *_Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(struct objc_hashtable *_Nonnull __asm__("a0"), const void *_Nonnull __asm__("a1"), const void *_Nonnull __asm__("a2")))(((uintptr_t)ObjFWRTBase) - 510))(table, key, object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(struct objc_hashtable *_Nonnull, const void *_Nonnull, const void *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 508))(table, key, object);
#endif
}

void *_Nullable
objc_hashtable_get(struct objc_hashtable *_Nonnull table, const void *_Nonnull key)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((void *_Nullable (*)(struct objc_hashtable *_Nonnull __asm__("a0"), const void *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 516))(table, key);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((void *_Nullable (*)(struct objc_hashtable *_Nonnull, const void *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 514))(table, key);
#endif
}

void
objc_hashtable_delete(struct objc_hashtable *_Nonnull table, const void *_Nonnull key)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(struct objc_hashtable *_Nonnull __asm__("a0"), const void *_Nonnull __asm__("a1")))(((uintptr_t)ObjFWRTBase) - 522))(table, key);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(struct objc_hashtable *_Nonnull, const void *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 520))(table, key);
#endif
}

void
objc_hashtable_free(struct objc_hashtable *_Nonnull table)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(struct objc_hashtable *_Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 528))(table);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(struct objc_hashtable *_Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 526))(table);
#endif
}

void
objc_setTaggedPointerSecret(uintptr_t secret)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	((void (*)(uintptr_t __asm__("d0")))(((uintptr_t)ObjFWRTBase) - 534))(secret);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	((void (*)(uintptr_t))*(void **)(((uintptr_t)ObjFWRTBase) - 532))(secret);
#endif
}

int
objc_registerTaggedPointerClass(Class _Nonnull class)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((int (*)(Class _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 540))(class);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((int (*)(Class _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 538))(class);
#endif
}

bool
object_isTaggedPointer(id _Nullable object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((bool (*)(id _Nullable __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 546))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((bool (*)(id _Nullable))*(void **)(((uintptr_t)ObjFWRTBase) - 544))(object);
#endif
}

uintptr_t
object_getTaggedPointerValue(id _Nonnull object)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((uintptr_t (*)(id _Nonnull __asm__("a0")))(((uintptr_t)ObjFWRTBase) - 552))(object);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((uintptr_t (*)(id _Nonnull))*(void **)(((uintptr_t)ObjFWRTBase) - 550))(object);
#endif
}

id _Nullable
objc_createTaggedPointer(int class, uintptr_t value)
{
#if defined(OF_AMIGAOS_M68K)
	register struct Library *a6 __asm__("a6") = ObjFWRTBase;
	(void)a6;
	return ((id _Nullable (*)(int __asm__("d0"), uintptr_t __asm__("d1")))(((uintptr_t)ObjFWRTBase) - 558))(class, value);
#elif defined(OF_MORPHOS)
	__asm__ __volatile__ (
	    "mr		%%r12, %0"
	    :: "r"(ObjFWRTBase) : "r12"
	);

	return ((id _Nullable (*)(int, uintptr_t))*(void **)(((uintptr_t)ObjFWRTBase) - 556))(class, value);
#endif
}