VBoxDef2LazyLoad.cpp@ 98409

Last change on this file since 98409 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 58.8 KB

Line
1	/* $Id: VBoxDef2LazyLoad.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VBoxDef2LazyLoad - Lazy Library Loader Generator.
4	*
5	* @note Only tested on win.amd64 & darwin.amd64.
6	*/
7
8	/*
9	* Copyright (C) 2013-2023 Oracle and/or its affiliates.
10	*
11	* This file is part of VirtualBox base platform packages, as
12	* available from https://www.virtualbox.org.
13	*
14	* This program is free software; you can redistribute it and/or
15	* modify it under the terms of the GNU General Public License
16	* as published by the Free Software Foundation, in version 3 of the
17	* License.
18	*
19	* This program is distributed in the hope that it will be useful, but
20	* WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22	* General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with this program; if not, see <https://www.gnu.org/licenses>.
26	*
27	* SPDX-License-Identifier: GPL-3.0-only
28	*/
29
30
31	/*********************************************************************************************************************************
32	* Header Files *
33	*********************************************************************************************************************************/
34	#include <ctype.h>
35	#include <stdio.h>
36	#include <string.h>
37	#include <stdlib.h>
38	#include <iprt/types.h>
39	#include <iprt/ldr.h> /* For RTLDRARCH. */
40
41
42	/*********************************************************************************************************************************
43	* Structures and Typedefs *
44	*********************************************************************************************************************************/
45	typedef struct MYEXPORT
46	{
47	struct MYEXPORT *pNext;
48	/** Pointer to unmangled name for stdcall (after szName), NULL if not. */
49	char *pszUnstdcallName;
50	/** Pointer to the exported name. */
51	char const *pszExportedNm;
52	unsigned uOrdinal;
53	bool fNoName;
54	char szName[1];
55	} MYEXPORT;
56	typedef MYEXPORT *PMYEXPORT;
57
58
59	/*********************************************************************************************************************************
60	* Global Variables *
61	*********************************************************************************************************************************/
62	/** @name Options
63	* @{ */
64	static const char *g_pszOutput = NULL;
65	static const char *g_pszLibrary = NULL;
66	static const char *g_apszInputs[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
67	static unsigned g_cInputs = 0;
68	static bool g_fIgnoreData = true;
69	static bool g_fWithExplictLoadFunction = false;
70	static bool g_fSystemLibrary = false;
71	#if defined(RT_ARCH_AMD64)
72	static RTLDRARCH g_enmTarget = RTLDRARCH_AMD64;
73	#elif defined(RT_ARCH_X86)
74	static RTLDRARCH g_enmTarget = RTLDRARCH_X86_32;
75	#elif defined(RT_ARCH_ARM64)
76	static RTLDRARCH g_enmTarget = RTLDRARCH_ARM64;
77	#else
78	# error "Port me!"
79	#endif
80	/** @} */
81
82	/** Pointer to the export name list head. */
83	static PMYEXPORT g_pExpHead = NULL;
84	/** Pointer to the next pointer for insertion. */
85	static PMYEXPORT *g_ppExpNext = &g_pExpHead;
86
87
88
89	#if 0 /* unused */
90	static const char leftStrip(const char psz)
91	{
92	while (isspace(*psz))
93	psz++;
94	return psz;
95	}
96	#endif
97
98
99	static char leftStrip(char psz)
100	{
101	while (isspace(*psz))
102	psz++;
103	return psz;
104	}
105
106
107	static unsigned wordLength(const char *pszWord)
108	{
109	unsigned off = 0;
110	char ch;
111	while ( (ch = pszWord[off]) != '\0'
112	&& ch != '='
113	&& ch != ','
114	&& ch != ':'
115	&& !isspace(ch) )
116	off++;
117	return off;
118	}
119
120
121	/**
122	* Parses the module definition file, collecting export information.
123	*
124	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
125	* details has been displayed.
126	* @param pInput The input stream.
127	*/
128	static RTEXITCODE parseInputInner(FILE pInput, const char pszInput)
129	{
130	/*
131	* Process the file line-by-line.
132	*/
133	bool fInExports = false;
134	unsigned iLine = 0;
135	char szLine[16384];
136	while (fgets(szLine, sizeof(szLine), pInput))
137	{
138	iLine++;
139
140	/*
141	* Strip leading and trailing spaces from the line as well as
142	* trailing comments.
143	*/
144	char *psz = leftStrip(szLine);
145	if (*psz == ';')
146	continue; /* comment line. */
147
148	char *pszComment = strchr(psz, ';');
149	if (pszComment)
150	*pszComment = '\0';
151
152	unsigned cch = (unsigned)strlen(psz);
153	while (cch > 0 && (isspace(psz[cch - 1]) \|\| psz[cch - 1] == '\r' \|\| psz[cch - 1] == '\n'))
154	psz[--cch] = '\0';
155
156	if (!cch)
157	continue;
158
159	/*
160	* Check for known directives.
161	*/
162	size_t cchWord0 = wordLength(psz);
163	#define WORD_CMP(pszWord1, cchWord1, szWord2) \
164	( (cchWord1) == sizeof(szWord2) - 1 && memcmp(pszWord1, szWord2, sizeof(szWord2) - 1) == 0 )
165	if (WORD_CMP(psz, cchWord0, "EXPORTS"))
166	{
167	fInExports = true;
168
169	/* In case there is an export on the same line. (Really allowed?) */
170	psz = leftStrip(psz + sizeof("EXPORTS") - 1);
171	if (!*psz)
172	continue;
173	}
174	/* Directives that we don't care about, but need to catch in order to
175	terminate the EXPORTS section in a timely manner. */
176	else if ( WORD_CMP(psz, cchWord0, "NAME")
177	\|\| WORD_CMP(psz, cchWord0, "LIBRARY")
178	\|\| WORD_CMP(psz, cchWord0, "DESCRIPTION")
179	\|\| WORD_CMP(psz, cchWord0, "STACKSIZE")
180	\|\| WORD_CMP(psz, cchWord0, "SECTIONS")
181	\|\| WORD_CMP(psz, cchWord0, "SEGMENTS")
182	\|\| WORD_CMP(psz, cchWord0, "VERSION")
183	)
184	{
185	fInExports = false;
186	}
187
188	/*
189	* Process exports:
190	* entryname[=internalname] [@ordinal[ ][NONAME]] [DATA] [PRIVATE]
191	*/
192	if (fInExports)
193	{
194	const char *pchName = psz;
195	unsigned cchName = wordLength(psz);
196
197	psz = leftStrip(psz + cchName);
198	if (*psz == '=')
199	{
200	psz = leftStrip(psz + 1);
201	psz = leftStrip(psz + wordLength(psz));
202	}
203
204	bool fNoName = false;
205	unsigned uOrdinal = ~0U;
206	if (*psz == '@')
207	{
208	psz++;
209	if (!isdigit(*psz))
210	{
211	fprintf(stderr, "%s:%u: error: Invalid ordinal spec.\n", pszInput, iLine);
212	return RTEXITCODE_FAILURE;
213	}
214	uOrdinal = *psz++ - '0';
215	while (isdigit(*psz))
216	{
217	uOrdinal *= 10;
218	uOrdinal += *psz++ - '0';
219	}
220	psz = leftStrip(psz);
221	cch = wordLength(psz);
222	if (WORD_CMP(psz, cch, "NONAME"))
223	{
224	fNoName = true;
225	psz = leftStrip(psz + cch);
226	}
227	}
228
229	while (*psz)
230	{
231	cch = wordLength(psz);
232	if (WORD_CMP(psz, cch, "DATA"))
233	{
234	if (!g_fIgnoreData)
235	{
236	fprintf(stderr, "%s:%u: error: Cannot wrap up DATA export '%.*s'.\n",
237	pszInput, iLine, cchName, pchName);
238	return RTEXITCODE_SUCCESS;
239	}
240	}
241	else if (!WORD_CMP(psz, cch, "PRIVATE"))
242	{
243	fprintf(stderr, "%s:%u: error: Cannot wrap up DATA export '%.*s'.\n",
244	pszInput, iLine, cchName, pchName);
245	return RTEXITCODE_SUCCESS;
246	}
247	psz = leftStrip(psz + cch);
248	}
249
250	/*
251	* Check for stdcall mangling.
252	*/
253	size_t cbExp = sizeof(MYEXPORT) + cchName;
254	unsigned cchStdcall = 0;
255	if (cchName > 3 && *pchName == '_' && isdigit(pchName[cchName - 1]))
256	{
257	if (cchName > 3 && pchName[cchName - 2] == '@')
258	cchStdcall = 2;
259	else if (cchName > 4 && pchName[cchName - 3] == '@' && isdigit(pchName[cchName - 2]))
260	cchStdcall = 3;
261	if (cchStdcall)
262	cbExp += cchName - 1 - cchStdcall;
263	}
264
265	/*
266	* Add the export.
267	*/
268
269	PMYEXPORT pExp = (PMYEXPORT)malloc(cbExp);
270	if (!pExp)
271	{
272	fprintf(stderr, "%s:%u: error: Out of memory.\n", pszInput, iLine);
273	return RTEXITCODE_SUCCESS;
274	}
275	memcpy(pExp->szName, pchName, cchName);
276	pExp->szName[cchName] = '\0';
277	if (!cchStdcall)
278	{
279	pExp->pszUnstdcallName = NULL;
280	pExp->pszExportedNm = pExp->szName;
281	}
282	else
283	{
284	pExp->pszUnstdcallName = &pExp->szName[cchName + 1];
285	memcpy(pExp->pszUnstdcallName, pchName + 1, cchName - 1 - cchStdcall);
286	pExp->pszUnstdcallName[cchName - 1 - cchStdcall] = '\0';
287	pExp->pszExportedNm = pExp->pszUnstdcallName;
288	}
289	pExp->uOrdinal = uOrdinal;
290	pExp->fNoName = fNoName;
291	pExp->pNext = NULL;
292	*g_ppExpNext = pExp;
293	g_ppExpNext = &pExp->pNext;
294	}
295	}
296
297	/*
298	* Why did we quit the loop, EOF or error?
299	*/
300	if (feof(pInput))
301	return RTEXITCODE_SUCCESS;
302	fprintf(stderr, "error: Read while reading '%s' (iLine=%u).\n", pszInput, iLine);
303	return RTEXITCODE_FAILURE;
304	}
305
306
307	/**
308	* Parses a_apszInputs, populating the list pointed to by g_pExpHead.
309	*
310	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
311	* details has been displayed.
312	*/
313	static RTEXITCODE parseInputs(void)
314	{
315	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
316	for (unsigned i = 0; i < g_cInputs; i++)
317	{
318	FILE *pInput = fopen(g_apszInputs[i], "r");
319	if (pInput)
320	{
321	RTEXITCODE rcExit2 = parseInputInner(pInput, g_apszInputs[i]);
322	fclose(pInput);
323	if (rcExit2 == RTEXITCODE_SUCCESS && !g_pExpHead)
324	{
325	fprintf(stderr, "error: Found no exports in '%s'.\n", g_apszInputs[i]);
326	rcExit2 = RTEXITCODE_FAILURE;
327	}
328	if (rcExit2 != RTEXITCODE_SUCCESS)
329	rcExit = rcExit2;
330	}
331	else
332	{
333	fprintf(stderr, "error: Failed to open '%s' for reading.\n", g_apszInputs[i]);
334	rcExit = RTEXITCODE_FAILURE;
335	}
336	}
337	return rcExit;
338	}
339
340
341	/**
342	* Generates the assembly source code for AMD64 and x86, writing it
343	* to @a pOutput.
344	*
345	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
346	* details has been displayed.
347	* @param pOutput The output stream (caller checks it for errors
348	* when closing).
349	*/
350	static RTEXITCODE generateOutputInnerX86AndAMD64(FILE *pOutput)
351	{
352	fprintf(pOutput, ";;\n");
353	for (unsigned i = 0; i < g_cInputs; i++)
354	fprintf(pOutput, ";; Autogenerated from '%s'.\n", g_apszInputs[i]);
355
356	fprintf(pOutput,
357	";; DO NOT EDIT!\n"
358	";;\n"
359	"\n"
360	"\n"
361	"%%include \"iprt/asmdefs.mac\"\n"
362	"\n"
363	"\n");
364
365	/*
366	* Put the thunks first for alignment and other reasons. It's the hot part of the code.
367	*/
368	fprintf(pOutput,
369	";\n"
370	"; Thunks.\n"
371	";\n"
372	"BEGINCODE\n");
373	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
374	if (!pExp->pszUnstdcallName)
375	fprintf(pOutput,
376	"BEGINPROC %s\n"
377	" jmp RTCCPTR_PRE [g_pfn%s xWrtRIP]\n"
378	"ENDPROC %s\n",
379	pExp->szName, pExp->szName, pExp->szName);
380	else
381	fprintf(pOutput,
382	"%%ifdef RT_ARCH_X86\n"
383	"global %s\n"
384	"%s:\n"
385	" jmp RTCCPTR_PRE [g_pfn%s xWrtRIP]\n"
386	"%%else\n"
387	"BEGINPROC %s\n"
388	" jmp RTCCPTR_PRE [g_pfn%s xWrtRIP]\n"
389	"ENDPROC %s\n"
390	"%%endif\n",
391	pExp->szName, pExp->szName, pExp->pszUnstdcallName,
392	pExp->pszUnstdcallName, pExp->pszUnstdcallName, pExp->pszUnstdcallName);
393
394	fprintf(pOutput,
395	"\n"
396	"\n");
397
398	/*
399	* Import pointers
400	*/
401	fprintf(pOutput,
402	";\n"
403	"; Import pointers. Initialized to point a lazy loading stubs.\n"
404	";\n"
405	"BEGINDATA\n"
406	"g_apfnImports:\n");
407	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
408	if (pExp->pszUnstdcallName)
409	fprintf(pOutput,
410	"%%ifdef ASM_FORMAT_PE\n"
411	" %%ifdef RT_ARCH_X86\n"
412	"global __imp_%s\n"
413	"__imp_%s:\n"
414	" %%else\n"
415	"global __imp_%s\n"
416	"__imp_%s:\n"
417	" %%endif\n"
418	"%%endif\n"
419	"g_pfn%s RTCCPTR_DEF ___LazyLoad___%s\n"
420	"\n",
421	pExp->szName,
422	pExp->szName,
423	pExp->pszUnstdcallName,
424	pExp->pszUnstdcallName,
425	pExp->pszExportedNm,
426	pExp->pszExportedNm);
427	else
428	fprintf(pOutput,
429	"%%ifdef ASM_FORMAT_PE\n"
430	"global __imp_%s\n"
431	"__imp_%s:\n"
432	"%%endif\n"
433	"g_pfn%s RTCCPTR_DEF ___LazyLoad___%s\n"
434	"\n",
435	pExp->szName,
436	pExp->szName,
437	pExp->pszExportedNm,
438	pExp->pszExportedNm);
439	fprintf(pOutput,
440	"RTCCPTR_DEF 0 ; Terminator entry for traversal.\n"
441	"\n"
442	"\n");
443
444	/*
445	* Now for the less important stuff, starting with the names.
446	*
447	* We keep the names separate so we can traverse them in parallel to
448	* g_apfnImports in the load-everything routine further down.
449	*/
450	fprintf(pOutput,
451	";\n"
452	"; Imported names.\n"
453	";\n"
454	"BEGINCODE\n"
455	"g_szLibrary: db '%s',0\n"
456	"\n"
457	"g_szzNames:\n",
458	g_pszLibrary);
459	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
460	if (!pExp->fNoName)
461	fprintf(pOutput, " g_sz%s:\n db '%s',0\n", pExp->pszExportedNm, pExp->pszExportedNm);
462	else
463	fprintf(pOutput, " g_sz%s:\n db '#%u',0\n", pExp->pszExportedNm, pExp->uOrdinal);
464	fprintf(pOutput,
465	"g_EndOfNames: db 0\n"
466	"\n"
467	"g_szFailLoadFmt: db 'Lazy loader failed to load \"%%s\": %%Rrc', 10, 0\n"
468	"g_szFailResolveFmt: db 'Lazy loader failed to resolve symbol \"%%s\" in \"%%s\": %%Rrc', 10, 0\n"
469	"\n"
470	"\n");
471
472	/*
473	* The per import lazy load code.
474	*/
475	fprintf(pOutput,
476	";\n"
477	"; Lazy load+resolve stubs.\n"
478	";\n"
479	"BEGINCODE\n");
480	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
481	{
482	if (!pExp->fNoName)
483	fprintf(pOutput,
484	"___LazyLoad___%s:\n"
485	/* "int3\n" */
486	"%%ifdef RT_ARCH_AMD64\n"
487	" lea rax, [g_sz%s wrt rip]\n"
488	" lea r10, [g_pfn%s wrt rip]\n"
489	" call LazyLoadResolver\n"
490	"%%elifdef RT_ARCH_X86\n"
491	" push g_sz%s\n"
492	" push g_pfn%s\n"
493	" call LazyLoadResolver\n"
494	" add esp, 8h\n"
495	"%%else\n"
496	" %%error \"Unsupported architecture\"\n"
497	"%%endif\n"
498	,
499	pExp->pszExportedNm,
500	pExp->pszExportedNm,
501	pExp->pszExportedNm,
502	pExp->pszExportedNm,
503	pExp->pszExportedNm);
504	else
505	fprintf(pOutput,
506	"___LazyLoad___%s:\n"
507	/* "int3\n" */
508	"%%ifdef RT_ARCH_AMD64\n"
509	" mov eax, %u\n"
510	" lea r10, [g_pfn%s wrt rip]\n"
511	" call LazyLoadResolver\n"
512	"%%elifdef RT_ARCH_X86\n"
513	" push %u\n"
514	" push g_pfn%s\n"
515	" call LazyLoadResolver\n"
516	" add esp, 8h\n"
517	"%%else\n"
518	" %%error \"Unsupported architecture\"\n"
519	"%%endif\n"
520	,
521	pExp->pszExportedNm,
522	pExp->uOrdinal,
523	pExp->pszExportedNm,
524	pExp->uOrdinal,
525	pExp->pszExportedNm);
526	if (!pExp->pszUnstdcallName)
527	fprintf(pOutput, " jmp NAME(%s)\n", pExp->szName);
528	else
529	fprintf(pOutput,
530	"%%ifdef RT_ARCH_X86\n"
531	" jmp %s\n"
532	"%%else\n"
533	" jmp NAME(%s)\n"
534	"%%endif\n"
535	,
536	pExp->szName, pExp->pszUnstdcallName);
537	fprintf(pOutput, "\n");
538	}
539	fprintf(pOutput,
540	"\n"
541	"\n"
542	"\n");
543
544	/*
545	* The code that does the loading and resolving.
546	*/
547	fprintf(pOutput,
548	";\n"
549	"; The module handle.\n"
550	";\n"
551	"BEGINDATA\n"
552	"g_hMod RTCCPTR_DEF 0\n"
553	"\n"
554	"\n"
555	"\n");
556
557	/*
558	* How we load the module needs to be selectable later on.
559	*
560	* The LazyLoading routine returns the module handle in RCX/ECX, caller
561	* saved all necessary registers.
562	*/
563	if (!g_fSystemLibrary)
564	fprintf(pOutput,
565	";\n"
566	";SUPR3DECL(int) SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod,\n"
567	"; uint32_t fFlags, PRTERRINFO pErrInfo);\n"
568	";\n"
569	"EXTERN_IMP2 SUPR3HardenedLdrLoadAppPriv\n"
570	"%%ifdef IN_RT_R3\n"
571	"extern NAME(RTAssertMsg2Weak)\n"
572	"%%else\n"
573	"EXTERN_IMP2 RTAssertMsg2Weak\n"
574	"%%endif\n"
575	"BEGINCODE\n"
576	"\n"
577	"LazyLoading:\n"
578	" mov xCX, [g_hMod xWrtRIP]\n"
579	" or xCX, xCX\n"
580	" jnz .return\n"
581	"\n"
582	"%%ifdef ASM_CALL64_GCC\n"
583	" xor rcx, rcx ; pErrInfo\n"
584	" xor rdx, rdx ; fFlags (local load)\n"
585	" lea rsi, [g_hMod wrt rip] ; phLdrMod\n"
586	" lea rdi, [g_szLibrary wrt rip] ; pszFilename\n"
587	" sub rsp, 08h\n"
588	" call IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
589	" add rsp, 08h\n"
590	"\n"
591	"%%elifdef ASM_CALL64_MSC\n"
592	" xor r9, r9 ; pErrInfo\n"
593	" xor r8, r8 ; fFlags (local load)\n"
594	" lea rdx, [g_hMod wrt rip] ; phLdrMod\n"
595	" lea rcx, [g_szLibrary wrt rip] ; pszFilename\n"
596	" sub rsp, 28h\n"
597	" call IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
598	" add rsp, 28h\n"
599	"\n"
600	"%%elifdef RT_ARCH_X86\n"
601	" sub xSP, 0ch\n"
602	" push 0 ; pErrInfo\n"
603	" push 0 ; fFlags (local load)\n"
604	" push g_hMod ; phLdrMod\n"
605	" push g_szLibrary ; pszFilename\n"
606	" call IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
607	" add esp, 1ch\n"
608	"%%else\n"
609	" %%error \"Unsupported architecture\"\n"
610	"%%endif\n");
611	else
612	fprintf(pOutput,
613	";\n"
614	"; RTDECL(int) RTLdrLoadSystem(const char *pszFilename, bool fNoUnload, PRTLDRMOD phLdrMod);\n"
615	";\n"
616	"%%ifdef IN_RT_R3\n"
617	"extern NAME(RTLdrLoadSystem)\n"
618	"extern NAME(RTAssertMsg2Weak)\n"
619	"%%else\n"
620	"EXTERN_IMP2 RTLdrLoadSystem\n"
621	"EXTERN_IMP2 RTAssertMsg2Weak\n"
622	"%%endif\n"
623	"BEGINCODE\n"
624	"\n"
625	"LazyLoading:\n"
626	" mov xCX, [g_hMod xWrtRIP]\n"
627	" or xCX, xCX\n"
628	" jnz .return\n"
629	"\n"
630	"%%ifdef ASM_CALL64_GCC\n"
631	" lea rdx, [g_hMod wrt rip] ; phLdrMod\n"
632	" mov esi, 1 ; fNoUnload=true\n"
633	" lea rdi, [g_szLibrary wrt rip] ; pszFilename\n"
634	" sub rsp, 08h\n"
635	" %%ifdef IN_RT_R3\n"
636	" call NAME(RTLdrLoadSystem)\n"
637	" %%else\n"
638	" call IMP2(RTLdrLoadSystem)\n"
639	" %%endif\n"
640	" add rsp, 08h\n"
641	"\n"
642	"%%elifdef ASM_CALL64_MSC\n"
643	" lea r8, [g_hMod wrt rip] ; phLdrMod\n"
644	" mov edx, 1 ; fNoUnload=true\n"
645	" lea rcx, [g_szLibrary wrt rip] ; pszFilename\n"
646	" sub rsp, 28h\n"
647	" %%ifdef IN_RT_R3\n"
648	" call NAME(RTLdrLoadSystem)\n"
649	" %%else\n"
650	" call IMP2(RTLdrLoadSystem)\n"
651	" %%endif\n"
652	" add rsp, 28h\n"
653	"\n"
654	"%%elifdef RT_ARCH_X86\n"
655	" push g_hMod ; phLdrMod\n"
656	" push 1 ; fNoUnload=true\n"
657	" push g_szLibrary ; pszFilename\n"
658	" %%ifdef IN_RT_R3\n"
659	" call NAME(RTLdrLoadSystem)\n"
660	" %%else\n"
661	" call IMP2(RTLdrLoadSystem)\n"
662	" %%endif\n"
663	" add esp, 0ch\n"
664	"%%else\n"
665	" %%error \"Unsupported architecture\"\n"
666	"%%endif\n");
667	fprintf(pOutput,
668	" or eax, eax\n"
669	" jnz .badload\n"
670	" mov xCX, [g_hMod xWrtRIP]\n"
671	".return:\n"
672	" ret\n"
673	"\n"
674	".badload:\n"
675	"%%ifdef ASM_CALL64_GCC\n"
676	" mov edx, eax\n"
677	" lea rsi, [g_szLibrary wrt rip]\n"
678	" lea rdi, [g_szFailLoadFmt wrt rip]\n"
679	" sub rsp, 08h\n"
680	"%%elifdef ASM_CALL64_MSC\n"
681	" mov r8d, eax\n"
682	" lea rdx, [g_szLibrary wrt rip]\n"
683	" lea rcx, [g_szFailLoadFmt wrt rip]\n"
684	" sub rsp, 28h\n"
685	"%%elifdef RT_ARCH_X86\n"
686	" push eax\n"
687	" push g_szLibrary\n"
688	" push g_szFailLoadFmt\n"
689	"%%endif\n"
690	"%%ifdef IN_RT_R3\n"
691	" call NAME(RTAssertMsg2Weak)\n"
692	"%%else\n"
693	" call IMP2(RTAssertMsg2Weak)\n"
694	"%%endif\n"
695	".badloadloop:\n"
696	" int3\n"
697	" jmp .badloadloop\n"
698	"LazyLoading_End:\n"
699	"\n"
700	"\n");
701
702
703	fprintf(pOutput,
704	";\n"
705	";RTDECL(int) RTLdrGetSymbol(RTLDRMOD hLdrMod, const char pszSymbol, void *ppvValue);\n"
706	";\n"
707	"%%ifdef IN_RT_R3\n"
708	"extern NAME(RTLdrGetSymbol)\n"
709	"%%else\n"
710	"EXTERN_IMP2 RTLdrGetSymbol\n"
711	"%%endif\n"
712	"BEGINCODE\n"
713	"LazyLoadResolver:\n"
714	"%%ifdef RT_ARCH_AMD64\n"
715	" push rbp\n"
716	" mov rbp, rsp\n"
717	" push r15\n"
718	" push r14\n"
719	" mov r15, rax ; name\n"
720	" mov r14, r10 ; ppfn\n"
721	" push r9\n"
722	" push r8\n"
723	" push rcx\n"
724	" push rdx\n"
725	" push r12\n"
726	" %%ifdef ASM_CALL64_GCC\n"
727	" push rsi\n"
728	" push rdi\n"
729	" mov r12, rsp\n"
730	" %%else\n"
731	" mov r12, rsp\n"
732	" sub rsp, 20h\n"
733	" %%endif\n"
734	" and rsp, 0fffffff0h ; Try make sure the stack is aligned\n"
735	"\n"
736	" call LazyLoading ; returns handle in rcx\n"
737	" %%ifdef ASM_CALL64_GCC\n"
738	" mov rdi, rcx ; hLdrMod\n"
739	" mov rsi, r15 ; pszSymbol\n"
740	" mov rdx, r14 ; ppvValue\n"
741	" %%else\n"
742	" mov rdx, r15 ; pszSymbol\n"
743	" mov r8, r14 ; ppvValue\n"
744	" %%endif\n"
745	" %%ifdef IN_RT_R3\n"
746	" call NAME(RTLdrGetSymbol)\n"
747	" %%else\n"
748	" call IMP2(RTLdrGetSymbol)\n"
749	" %%endif\n"
750	" or eax, eax\n"
751	" jnz .badsym\n"
752	"\n"
753	" mov rsp, r12\n"
754	" %%ifdef ASM_CALL64_GCC\n"
755	" pop rdi\n"
756	" pop rsi\n"
757	" %%endif\n"
758	" pop r12\n"
759	" pop rdx\n"
760	" pop rcx\n"
761	" pop r8\n"
762	" pop r9\n"
763	" pop r14\n"
764	" pop r15\n"
765	" leave\n"
766	"\n"
767	"%%elifdef RT_ARCH_X86\n"
768	" push ebp\n"
769	" mov ebp, esp\n"
770	" push eax\n"
771	" push ecx\n"
772	" push edx\n"
773	" and esp, 0fffffff0h\n"
774	"\n"
775	".loaded:\n"
776	" call LazyLoading ; returns handle in ecx\n"
777	" push dword [ebp + 8] ; value addr\n"
778	" push dword [ebp + 12] ; symbol name\n"
779	" push ecx\n"
780	" %%ifdef IN_RT_R3\n"
781	" call NAME(RTLdrGetSymbol)\n"
782	" %%else\n"
783	" call IMP2(RTLdrGetSymbol)\n"
784	" %%endif\n"
785	" or eax, eax\n"
786	" jnz .badsym\n"
787	" lea esp, [ebp - 0ch]\n"
788	" pop edx\n"
789	" pop ecx\n"
790	" pop eax\n"
791	" leave\n"
792	"%%else\n"
793	" %%error \"Unsupported architecture\"\n"
794	"%%endif\n"
795	" ret\n"
796	"\n"
797	".badsym:\n"
798	"%%ifdef ASM_CALL64_GCC\n"
799	" mov ecx, eax\n"
800	" lea rdx, [g_szLibrary wrt rip]\n"
801	" mov rsi, r15\n"
802	" lea rdi, [g_szFailResolveFmt wrt rip]\n"
803	" sub rsp, 08h\n"
804	"%%elifdef ASM_CALL64_MSC\n"
805	" mov r9d, eax\n"
806	" mov r8, r15\n"
807	" lea rdx, [g_szLibrary wrt rip]\n"
808	" lea rcx, [g_szFailResolveFmt wrt rip]\n"
809	" sub rsp, 28h\n"
810	"%%elifdef RT_ARCH_X86\n"
811	" push eax\n"
812	" push dword [ebp + 12]\n"
813	" push g_szLibrary\n"
814	" push g_szFailResolveFmt\n"
815	"%%endif\n"
816	"%%ifdef IN_RT_R3\n"
817	" call NAME(RTAssertMsg2Weak)\n"
818	"%%else\n"
819	" call IMP2(RTAssertMsg2Weak)\n"
820	"%%endif\n"
821	".badsymloop:\n"
822	" int3\n"
823	" jmp .badsymloop\n"
824	"\n"
825	"LazyLoadResolver_End:\n"
826	"\n"
827	"\n"
828	);
829
830
831
832	/*
833	* C callable method for explicitly loading the library and optionally
834	* resolving all the imports.
835	*/
836	if (g_fWithExplictLoadFunction)
837	{
838	if (g_fSystemLibrary) /* Lazy bird. */
839	{
840	fprintf(stderr, "error: cannot use --system with --explicit-load-function, sorry\n");
841	return RTEXITCODE_FAILURE;
842	}
843
844	int cchLibBaseName = (int)(strchr(g_pszLibrary, '.') ? strchr(g_pszLibrary, '.') - g_pszLibrary : strlen(g_pszLibrary));
845	fprintf(pOutput,
846	";;\n"
847	"; ExplicitlyLoad%.*s(bool fResolveAllImports, pErrInfo);\n"
848	";\n"
849	"EXTERN_IMP2 RTErrInfoSet\n"
850	"BEGINCODE\n"
851	"BEGINPROC ExplicitlyLoad%.*s\n"
852	" push xBP\n"
853	" mov xBP, xSP\n"
854	" push xBX\n"
855	"%%ifdef ASM_CALL64_GCC\n"
856	" %%define pszCurStr r14\n"
857	" push r14\n"
858	"%%else\n"
859	" %%define pszCurStr xDI\n"
860	" push xDI\n"
861	"%%endif\n"
862	" sub xSP, 40h\n"
863	"\n"
864	" ;\n"
865	" ; Save parameters on stack (64-bit only).\n"
866	" ;\n"
867	"%%ifdef ASM_CALL64_GCC\n"
868	" mov [xBP - xCB * 3], rdi ; fResolveAllImports\n"
869	" mov [xBP - xCB * 4], rsi ; pErrInfo\n"
870	"%%elifdef ASM_CALL64_MSC\n"
871	" mov [xBP - xCB * 3], rcx ; fResolveAllImports\n"
872	" mov [xBP - xCB * 4], rdx ; pErrInfo\n"
873	"%%endif\n"
874	"\n"
875	" ;\n"
876	" ; Is the module already loaded?\n"
877	" ;\n"
878	" cmp RTCCPTR_PRE [g_hMod xWrtRIP], 0\n"
879	" jnz .loaded\n"
880	"\n"
881	" ;\n"
882	" ; Load the module.\n"
883	" ;\n"
884	"%%ifdef ASM_CALL64_GCC\n"
885	" mov rcx, [xBP - xCB * 4] ; pErrInfo\n"
886	" xor rdx, rdx ; fFlags (local load)\n"
887	" lea rsi, [g_hMod wrt rip] ; phLdrMod\n"
888	" lea rdi, [g_szLibrary wrt rip] ; pszFilename\n"
889	" call IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
890	"\n"
891	"%%elifdef ASM_CALL64_MSC\n"
892	" mov r9, [xBP - xCB * 4] ; pErrInfo\n"
893	" xor r8, r8 ; fFlags (local load)\n"
894	" lea rdx, [g_hMod wrt rip] ; phLdrMod\n"
895	" lea rcx, [g_szLibrary wrt rip] ; pszFilename\n"
896	" call IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
897	"\n"
898	"%%elifdef RT_ARCH_X86\n"
899	" sub xSP, 0ch\n"
900	" push dword [xBP + 12] ; pErrInfo\n"
901	" push 0 ; fFlags (local load)\n"
902	" push g_hMod ; phLdrMod\n"
903	" push g_szLibrary ; pszFilename\n"
904	" call IMP2(SUPR3HardenedLdrLoadAppPriv)\n"
905	" add esp, 1ch\n"
906	"%%else\n"
907	" %%error \"Unsupported architecture\"\n"
908	"%%endif\n"
909	" or eax, eax\n"
910	" jnz .return\n"
911	"\n"
912	" ;\n"
913	" ; Resolve the imports too if requested to do so.\n"
914	" ;\n"
915	".loaded:\n"
916	"%%ifdef ASM_ARCH_X86\n"
917	" cmp byte [xBP + 8], 0\n"
918	"%%else\n"
919	" cmp byte [xBP - xCB * 3], 0\n"
920	"%%endif\n"
921	" je .return\n"
922	"\n"
923	" lea pszCurStr, [g_szzNames xWrtRIP]\n"
924	" lea xBX, [g_apfnImports xWrtRIP]\n"
925	".next_import:\n"
926	" cmp RTCCPTR_PRE [xBX], 0\n"
927	" je .return\n"
928	"%%ifdef ASM_CALL64_GCC\n"
929	" mov rdx, xBX ; ppvValue\n"
930	" mov rsi, pszCurStr ; pszSymbol\n"
931	" mov rdi, [g_hMod wrt rip] ; hLdrMod\n"
932	" call IMP2(RTLdrGetSymbol)\n"
933	"%%elifdef ASM_CALL64_MSC\n"
934	" mov r8, xBX ; ppvValue\n"
935	" mov rdx, pszCurStr ; pszSymbol\n"
936	" mov rcx, [g_hMod wrt rip] ; pszSymbol\n"
937	" call IMP2(RTLdrGetSymbol)\n"
938	"%%else\n"
939	" push xBX ; ppvValue\n"
940	" push pszCurStr ; pszSymbol\n"
941	" push RTCCPTR_PRE [g_hMod] ; hLdrMod\n"
942	" call IMP2(RTLdrGetSymbol)\n"
943	" add xSP, 0ch\n"
944	"%%endif\n"
945	" or eax, eax\n"
946	" jnz .symbol_error\n"
947	"\n"
948	" ; Advance.\n"
949	" add xBX, RTCCPTR_CB\n"
950	" xor eax, eax\n"
951	" mov xCX, 0ffffffffh\n"
952	"%%ifdef ASM_CALL64_GCC\n"
953	" mov xDI, pszCurStr\n"
954	" repne scasb\n"
955	" mov pszCurStr, xDI\n"
956	"%%else\n"
957	" repne scasb\n"
958	"%%endif\n"
959	" jmp .next_import\n"
960	"\n"
961	" ;\n"
962	" ; Error loading a symbol. Call RTErrInfoSet on pErrInfo (preserves eax).\n"
963	" ;\n"
964	".symbol_error:\n"
965	"%%ifdef ASM_CALL64_GCC\n"
966	" mov rdx, pszCurStr ; pszMsg\n"
967	" mov esi, eax ; rc\n"
968	" mov rdi, [xBP - xCB * 4] ; pErrInfo\n"
969	" call IMP2(RTErrInfoSet)\n"
970	"%%elifdef ASM_CALL64_MSC\n"
971	" mov r8, pszCurStr ; pszMsg\n"
972	" mov edx, eax ; rc\n"
973	" mov rcx, [xBP - xCB * 4] ; pErrInfo\n"
974	" call IMP2(RTErrInfoSet)\n"
975	"%%else\n"
976	" push pszCurStr ; pszMsg\n"
977	" push eax ; pszSymbol\n"
978	" push dword [xBP + 0ch] ; pErrInfo\n"
979	" call IMP2(RTErrInfoSet)\n"
980	" add xSP, 0ch\n"
981	"%%endif\n"
982	" "
983	"\n"
984	".return:\n"
985	" mov pszCurStr, [xBP - xCB * 2]\n"
986	" mov xBX, [xBP - xCB * 1]\n"
987	" leave\n"
988	" ret\n"
989	"ENDPROC ExplicitlyLoad%.*s\n"
990	"\n"
991	"\n"
992	,
993	cchLibBaseName, g_pszLibrary,
994	cchLibBaseName, g_pszLibrary,
995	cchLibBaseName, g_pszLibrary
996	);
997	}
998
999
1000	return RTEXITCODE_SUCCESS;
1001	}
1002
1003
1004	/**
1005	* Generates the assembly source code for ARM64, writing it
1006	* to @a pOutput.
1007	*
1008	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
1009	* details has been displayed.
1010	* @param pOutput The output stream (caller checks it for errors
1011	* when closing).
1012	*/
1013	static RTEXITCODE generateOutputInnerArm64(FILE *pOutput)
1014	{
1015	// bool fMachO = true;
1016	// bool fDarwin = true;
1017	const char *pszNmPfx = "_";
1018
1019	fprintf(pOutput, ";;\n");
1020	for (unsigned i = 0; i < g_cInputs; i++)
1021	fprintf(pOutput, ";; Autogenerated from '%s'.\n", g_apszInputs[i]);
1022
1023	fprintf(pOutput,
1024	";; DO NOT EDIT!\n"
1025	";;\n"
1026	"\n"
1027	"\n"
1028	/"%%include \"iprt/asmdefs.mac\"\n"/
1029	"\n"
1030	"\n");
1031
1032	/*
1033	* Put the thunks first for alignment and other reasons. It's the hot part of the code.
1034	*/
1035	fprintf(pOutput,
1036	";\n"
1037	"; Thunks.\n"
1038	";\n"
1039	".section __TEXT,__text,regular,pure_instructions\n");
1040	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
1041	fprintf(pOutput,
1042	".p2align 3\n"
1043	".globl %s%s\n"
1044	"%s%s:\n"
1045	" adrp x9, %sg_pfn%s@PAGE\n"
1046	" ldr x9, [x9, %sg_pfn%s@PAGEOFF]\n"
1047	" br x9\n",
1048	pszNmPfx, pExp->szName, pszNmPfx, pExp->szName, pszNmPfx, pExp->szName, pszNmPfx, pExp->szName);
1049	fprintf(pOutput,
1050	"\n"
1051	"\n");
1052
1053	/*
1054	* Import pointers
1055	*/
1056	fprintf(pOutput,
1057	";\n"
1058	"; Import pointers. Initialized to point a lazy loading stubs.\n"
1059	";\n"
1060	".section __DATA,__data\n"
1061	".p2align 3\n"
1062	"g_apfnImports:\n");
1063	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
1064	fprintf(pOutput,
1065	".globl __imp_%s\n"
1066	"__imp_%s:\n"
1067	".globl %sg_pfn%s\n"
1068	"%sg_pfn%s:\n"
1069	" .quad ___LazyLoad___%s\n"
1070	"\n",
1071	pExp->szName, pExp->szName,
1072	pszNmPfx, pExp->szName, pszNmPfx, pExp->szName,
1073	pExp->pszExportedNm);
1074	fprintf(pOutput,
1075	" .quad 0 ; Terminator entry for traversal.\n"
1076	"\n"
1077	"\n");
1078
1079	/*
1080	* Now for the less important stuff, starting with the names.
1081	*
1082	* We keep the names separate so we can traverse them in parallel to
1083	* g_apfnImports in the load-everything routine further down.
1084	*/
1085	fprintf(pOutput,
1086	";\n"
1087	"; Imported names.\n"
1088	";\n"
1089	".section __TEXT,__cstring,cstring_literals\n"
1090	"g_szLibrary:\n"
1091	" .asciz \"%s\"\n"
1092	"\n"
1093	"g_szzNames:\n",
1094	g_pszLibrary);
1095	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
1096	if (!pExp->fNoName)
1097	fprintf(pOutput, " g_sz%s:\n .asciz \"%s\"\n", pExp->pszExportedNm, pExp->pszExportedNm);
1098	else
1099	fprintf(pOutput, " g_sz%s:\n .asciz \"#%u\"\n", pExp->pszExportedNm, pExp->uOrdinal);
1100	fprintf(pOutput,
1101	"g_EndOfNames: .byte 0\n"
1102	"\n"
1103	"g_szFailLoadFmt: .asciz \"Lazy loader failed to load \\\"%%s\\\": %%Rrc\\n\"\n"
1104	"g_szFailResolveFmt: .asciz \"Lazy loader failed to resolve symbol \\\"%%s\\\" in \\\"%%s\\\": %%Rrc\\n\"\n"
1105	"\n"
1106	"\n");
1107
1108	/*
1109	* The per import lazy load code.
1110	*/
1111	fprintf(pOutput,
1112	";\n"
1113	"; Lazy load+resolve stubs.\n"
1114	";\n"
1115	".section __TEXT,__text,regular,pure_instructions\n"
1116	".p2align 3\n");
1117	for (PMYEXPORT pExp = g_pExpHead; pExp; pExp = pExp->pNext)
1118	{
1119	if (!pExp->fNoName)
1120	fprintf(pOutput,
1121	"___LazyLoad___%s:\n"
1122	" adrp x9, g_sz%s@PAGE\n"
1123	" add x9, x9, g_sz%s@PAGEOFF\n"
1124	" adrp x10, %sg_pfn%s@PAGE\n"
1125	" add x10, x10, %sg_pfn%s@PAGEOFF\n"
1126	" bl LazyLoadResolver\n"
1127	, pExp->pszExportedNm,
1128	pExp->pszExportedNm, pExp->pszExportedNm,
1129	pszNmPfx, pExp->pszExportedNm, pszNmPfx, pExp->pszExportedNm);
1130	else
1131	fprintf(pOutput,
1132	"___LazyLoad___%s:\n"
1133	" movk w9, #%u\n"
1134	" adrp x10, %sg_pfn%s@PAGE\n"
1135	" add x10, x10, %sg_pfn%s@PAGEOFF\n"
1136	, pExp->pszExportedNm,
1137	pExp->uOrdinal,
1138	pszNmPfx, pExp->pszExportedNm, pszNmPfx, pExp->pszExportedNm);
1139	fprintf(pOutput, " b %s%s\n", pszNmPfx, pExp->szName);
1140	fprintf(pOutput, "\n");
1141	}
1142	fprintf(pOutput,
1143	"\n"
1144	"\n"
1145	"\n");
1146
1147	/*
1148	* The code that does the loading and resolving.
1149	*/
1150	fprintf(pOutput,
1151	";\n"
1152	"; The module handle.\n"
1153	";\n"
1154	".section __DATA,__data\n"
1155	"g_hMod:\n"
1156	" .quad 0\n"
1157	"\n"
1158	"\n"
1159	"\n");
1160
1161	/*
1162	* Common lazy loader and resolved.
1163	*/
1164	fprintf(pOutput,
1165	";\n"
1166	"; The resolver code.\n"
1167	";\n"
1168	".section __TEXT,__text,regular,pure_instructions\n"
1169	".p2align 3\n"
1170	"LazyLoadResolver:\n"
1171	" .cfi_startproc\n"
1172	" ; Create frame.\n"
1173	" sub sp, sp, #(16 + 192)\n"
1174	" stp x29, x30, [sp, #192]\n"
1175	" add x29, sp, #192\n"
1176	" .cfi_def_cfa x29, 16\n"
1177	" .cfi_offset x30, -8\n"
1178	" .cfi_offset x29, -16\n"
1179	" ; Save all argument registers and a handful of preserved ones.\n"
1180	" stp x0, x1, [sp, #(192 - 16)]\n"
1181	" .cfi_offset x0, -32\n"
1182	" .cfi_offset x1, -24\n"
1183	" stp x2, x3, [sp, #(192 - 32)]\n"
1184	" .cfi_offset x3, -40\n"
1185	" .cfi_offset x2, -48\n"
1186	" stp x4, x5, [sp, #(192 - 48)]\n"
1187	" .cfi_offset x6, -56\n"
1188	" .cfi_offset x5, -64\n"
1189	" stp x6, x7, [sp, #(192 - 64)]\n"
1190	" .cfi_offset x7, -72\n"
1191	" .cfi_offset x6, -80\n"
1192	" stp x16, x17, [sp, #(192 - 80)]\n"
1193	" .cfi_offset x17, -88\n"
1194	" .cfi_offset x16, -96\n"
1195	" stp x18, x19, [sp, #(192 - 96)]\n"
1196	" .cfi_offset x19, -104\n"
1197	" .cfi_offset x18, -112\n"
1198	" stp x20, x21, [sp, #(192 - 112)]\n"
1199	" .cfi_offset x21, -120\n"
1200	" .cfi_offset x20, -128\n"
1201	" stp x22, x23, [sp, #(192 - 128)]\n"
1202	" .cfi_offset x23, -136\n"
1203	" .cfi_offset x22, -144\n"
1204	" str x8, [sp, #(192 - 144)]\n"
1205	"\n"
1206	" ; Shift the symbol name to x19 and g_pfnXXXX pointer to x20 as these are preserved registers\n"
1207	" ; (in case we need to call LazyLoadModule/RTLdrLoad)\n"
1208	" mov x19, x9\n"
1209	" mov x20, x10\n"
1210	"\n"
1211	" ; Get the module handle and call RTLdrGetSymbol(RTLDRMOD hLdrMod, const char pszSymbol, void *ppvValue)\n"
1212	" adrp x0, g_hMod@PAGE\n"
1213	" ldr x0, [x0, g_hMod@PAGEOFF]\n"
1214	" cmp x0, #0\n"
1215	" b.eq LazyLoading\n"
1216	" mov x1, x19\n"
1217	" mov x2, x20\n"
1218	" bl %sRTLdrGetSymbol\n"
1219	"\n"
1220	" cmp w0, #0\n"
1221	" b.eq Lreturn\n"
1222	"\n"
1223	"Lbadsym: ; Call sRTAssertMsg2Weak. Variadic (...) arguments are passed on the stack it seems.\n"
1224	" mov x3, x0\n"
1225	" adrp x2, g_szLibrary@PAGE\n"
1226	" add x2, x2, g_szLibrary@PAGEOFF\n"
1227	" mov x1, x19\n"
1228	" adrp x0, g_szFailLoadFmt@PAGE\n"
1229	" add x0, x0, g_szFailLoadFmt@PAGEOFF\n"
1230	" stp x1, x2, [sp]\n"
1231	" str x3, [sp, #16]\n"
1232	" bl %sRTAssertMsg2Weak\n"
1233	"Lbadsymloop:\n"
1234	" brk #0x1\n"
1235	" b Lbadsymloop\n"
1236
1237	"Lreturn:\n"
1238	" ; Restore saved register\n"
1239	" ldr x8, [sp, #(192 - 144)]\n"
1240	" .cfi_restore x8\n"
1241	" ldp x22, x23, [sp, #(192 - 128)]\n"
1242	" .cfi_restore x23\n"
1243	" .cfi_restore x22\n"
1244	" ldp x20, x21, [sp, #(192 - 112)]\n"
1245	" .cfi_restore x21\n"
1246	" .cfi_restore x20\n"
1247	" ldp x18, x19, [sp, #(192 - 96)]\n"
1248	" .cfi_restore x19\n"
1249	" .cfi_restore x18\n"
1250	" ldp x16, x17, [sp, #(192 - 80)]\n"
1251	" .cfi_restore x17\n"
1252	" .cfi_restore x18\n"
1253	" ldp x6, x7, [sp, #(192 - 64)]\n"
1254	" .cfi_restore x7\n"
1255	" .cfi_restore x6\n"
1256	" ldp x4, x5, [sp, #(192 - 48)]\n"
1257	" .cfi_restore x5\n"
1258	" .cfi_restore x4\n"
1259	" ldp x2, x3, [sp, #(192 - 32)]\n"
1260	" .cfi_restore x3\n"
1261	" .cfi_restore x2\n"
1262	" ldp x0, x1, [sp, #(192 - 16)]\n"
1263	" .cfi_restore x1\n"
1264	" .cfi_restore x0\n"
1265	"\n"
1266	" ldp x29, x30, [sp, #192]\n"
1267	" .cfi_restore x29\n"
1268	" .cfi_restore x30\n"
1269	" add sp, sp, #(16 + 192)\n"
1270	" ret\n"
1271	" .cfi_endproc\n"
1272	"\n"
1273	"\n"
1274	, pszNmPfx, pszNmPfx);
1275
1276	fprintf(pOutput,
1277	";\n"
1278	"; Loads the module.\n"
1279	"; ASSUMES called from LazyLoadResolver where all relevant registers are already saved.\n"
1280	";\n"
1281	"LazyLoading:\n"
1282	" .cfi_startproc\n"
1283	" ; Create frame.\n"
1284	" sub sp, sp, #(16 + 48)\n"
1285	" stp x29, x30, [sp, #48]\n"
1286	" add x29, sp, #48\n"
1287	" .cfi_def_cfa x29, 16\n"
1288	" .cfi_offset x30, -8\n"
1289	" .cfi_offset x29, -16\n"
1290	"\n");
1291
1292	if (!g_fSystemLibrary)
1293	fprintf(pOutput,
1294	" ; Call SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);\n"
1295	" mov x3, #0\n"
1296	" mov x2, #0\n"
1297	" adrp x1, g_hMod@PAGE\n"
1298	" add x1, x1, g_hMod@PAGEOFF\n"
1299	" adrp x0, g_szLibrary@PAGE\n"
1300	" add x0, x0, g_szLibrary@PAGEOFF\n"
1301	" bl %sSUPR3HardenedLdrLoadAppPriv\n"
1302	, pszNmPfx);
1303	else
1304	fprintf(pOutput,
1305	" ; Call RTLdrLoadSystem(const char *pszFilename, bool fNoUnload, PRTLDRMOD phLdrMod);\n"
1306	" adrp x2, g_hMod@PAGE\n"
1307	" add x2, x2, g_hMod@PAGEOFF\n"
1308	" mov x1, #1\n"
1309	" adrp x0, g_szLibrary@PAGE\n"
1310	" add x0, x0, g_szLibrary@PAGEOFF\n"
1311	" bl %sRTLdrLoadSystem\n"
1312	, pszNmPfx);
1313
1314	fprintf(pOutput,
1315	" cmp w0, #0\n"
1316	" b.eq Lload_return\n"
1317	"\n"
1318	"Lbadload: ; Call sRTAssertMsg2Weak. Variadic (...) arguments are passed on the stack it seems.\n"
1319	" mov x2, x0\n"
1320	" adrp x1, g_szLibrary@PAGE\n"
1321	" add x1, x1, g_szLibrary@PAGEOFF\n"
1322	" adrp x0, g_szFailResolveFmt@PAGE\n"
1323	" add x0, x0, g_szFailResolveFmt@PAGEOFF\n"
1324	" stp x1, x2, [sp]\n"
1325	" bl %sRTAssertMsg2Weak\n"
1326	"Lbadloadloop:\n"
1327	" brk #0x1\n"
1328	" b Lbadloadloop\n"
1329	"Lload_return:\n"
1330	" adrp x0, g_hMod@PAGE\n"
1331	" ldr x0, [x0, g_hMod@PAGEOFF]\n"
1332	" ldp x29, x30, [sp, #48]\n"
1333	" .cfi_restore x29\n"
1334	" .cfi_restore x30\n"
1335	" add sp, sp, #(16 + 48)\n"
1336	" ret\n"
1337	" .cfi_endproc\n"
1338	"\n"
1339	"\n"
1340	, pszNmPfx);
1341
1342	/*
1343	* C callable method for explicitly loading the library and optionally
1344	* resolving all the imports.
1345	*/
1346	if (g_fWithExplictLoadFunction)
1347	{
1348	if (g_fSystemLibrary) /* Lazy bird. */
1349	{
1350	fprintf(stderr, "error: cannot use --system with --explicit-load-function, sorry\n");
1351	return RTEXITCODE_FAILURE;
1352	}
1353
1354	int cchLibBaseName = (int)(strchr(g_pszLibrary, '.') ? strchr(g_pszLibrary, '.') - g_pszLibrary : strlen(g_pszLibrary));
1355	fprintf(pOutput,
1356	";;\n"
1357	"; ExplicitlyLoad%.*s(bool fResolveAllImports, pErrInfo);\n"
1358	";\n"
1359	".section __TEXT,__text,regular,pure_instructions\n"
1360	".p2align 3\n"
1361	".globl %sExplicitlyLoad%.*s\n"
1362	"%sExplicitlyLoad%.*s:\n"
1363	" .cfi_startproc\n"
1364	" ; Create frame.\n"
1365	" sub sp, sp, #(16 + 96)\n"
1366	" stp x29, x30, [sp, #96]\n"
1367	" add x29, sp, #96\n"
1368	" .cfi_def_cfa x29, 16\n"
1369	" .cfi_offset x30, -8\n"
1370	" .cfi_offset x29, -16\n"
1371	"\n"
1372	" stp x20, x21, [sp, #(96 - 16)]\n"
1373	" .cfi_offset x21, -24\n"
1374	" .cfi_offset x20, -32\n"
1375	" stp x22, x23, [sp, #(96 - 32)]\n"
1376	" .cfi_offset x23, -40\n"
1377	" .cfi_offset x22, -48\n"
1378
1379	" ; Save the input parameters.\n"
1380	" mov x20, x0\n"
1381	" mov x21, x1\n"
1382	"\n"
1383	" ;\n"
1384	" ; Is the module already loaded?\n"
1385	" ;\n"
1386	" adrp x0, g_hMod@PAGE\n"
1387	" ldr x0, [x0, g_hMod@PAGEOFF]\n"
1388	" cmp x0, #0\n"
1389	" b.ne Lexplicit_loaded_module\n"
1390	"\n"
1391	,
1392	cchLibBaseName, g_pszLibrary,
1393	pszNmPfx, cchLibBaseName, g_pszLibrary,
1394	pszNmPfx, cchLibBaseName, g_pszLibrary);
1395	fprintf(pOutput,
1396	"Lexplicit_load_module:\n"
1397	" ; Call SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo);\n"
1398	" mov x3, #0\n"
1399	" mov x2, #0\n"
1400	" adrp x1, g_hMod@PAGE\n"
1401	" add x1, x1, g_hMod@PAGEOFF\n"
1402	" adrp x0, g_szLibrary@PAGE\n"
1403	" add x0, x0, g_szLibrary@PAGEOFF\n"
1404	" bl %sSUPR3HardenedLdrLoadAppPriv\n"
1405	" cmp x0, #0\n"
1406	" b.ne Lexplicit_load_return\n"
1407	"\n"
1408	, pszNmPfx);
1409
1410	fprintf(pOutput,
1411	" ;\n"
1412	" ; Resolve the imports too if requested to do so.\n"
1413	" ;\n"
1414	"Lexplicit_loaded_module:\n"
1415	" cmp w20, #0\n"
1416	" b.eq Lexplicit_load_return\n"
1417	"\n"
1418	" adrp x22, g_szzNames@PAGE\n"
1419	" add x22, x22, g_szzNames@PAGEOFF\n"
1420	" adrp x23, g_apfnImports@PAGE\n"
1421	" add x23, x23, g_apfnImports@PAGEOFF\n"
1422	"Lexplicit_load_next_import:\n"
1423	" ldr x0, [x23]\n"
1424	" cmp x0, #0\n"
1425	" b.eq Lexplicit_load_return\n"
1426	"\n"
1427	" ; Get the module handle and call RTLdrGetSymbol(RTLDRMOD hLdrMod, const char pszSymbol, void *ppvValue)\n"
1428	" adrp x0, g_hMod@PAGE\n"
1429	" ldr x0, [x0, g_hMod@PAGEOFF]\n"
1430	" mov x1, x22\n"
1431	" mov x2, x23\n"
1432	" bl %sRTLdrGetSymbol\n"
1433	" cmp x0, #0\n"
1434	" b.ne Lexplicit_load_symbol_error\n"
1435	"\n"
1436	" ; Advance.\n"
1437	" add x23, x23, #8\n"
1438	"Lexplict_load_advance_string:\n"
1439	" ldrb w0, [x22]\n"
1440	" add x22, x22, #1\n"
1441	" cmp w0, #0\n"
1442	" b.ne Lexplict_load_advance_string\n"
1443	" b Lexplicit_load_next_import\n"
1444	"\n"
1445	" ;\n"
1446	" ; Error loading a symbol. Call RTErrInfoSet(PRTERRINFO pErrInfo, int rc, const char *pszMsg) on pErrInfo (preserves x0).\n"
1447	" ;\n"
1448	"Lexplicit_load_symbol_error:\n"
1449	" mov x2, x22\n"
1450	" mov x1, x0\n"
1451	" mov x0, x21\n"
1452	" bl %sRTErrInfoSet\n"
1453	" b Lexplicit_load_return"
1454	" "
1455	"\n"
1456	"Lexplicit_load_return:\n"
1457	" ldp x22, x23, [sp, #(96 - 32)]\n"
1458	" .cfi_restore x23\n"
1459	" .cfi_restore x22\n"
1460	" ldp x20, x21, [sp, #(96 - 16)]\n"
1461	" .cfi_restore x21\n"
1462	" .cfi_restore x20\n"
1463	"\n"
1464	" ldp x29, x30, [sp, #96]\n"
1465	" .cfi_restore x29\n"
1466	" .cfi_restore x30\n"
1467	" add sp, sp, #(16 + 96)\n"
1468	" ret\n"
1469	" .cfi_endproc\n"
1470	"\n"
1471	"\n"
1472	, pszNmPfx, pszNmPfx);
1473	}
1474
1475	return RTEXITCODE_SUCCESS;
1476	}
1477
1478
1479	/**
1480	* Generates the assembly source code, writing it to g_pszOutput.
1481	*
1482	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE, in the latter case full
1483	* details has been displayed.
1484	*/
1485	static RTEXITCODE generateOutput(void)
1486	{
1487	RTEXITCODE rcExit = RTEXITCODE_FAILURE;
1488	FILE *pOutput = fopen(g_pszOutput, "w");
1489	if (pOutput)
1490	{
1491	switch (g_enmTarget)
1492	{
1493	case RTLDRARCH_AMD64:
1494	case RTLDRARCH_X86_32:
1495	rcExit = generateOutputInnerX86AndAMD64(pOutput);
1496	break;
1497	case RTLDRARCH_ARM64:
1498	rcExit = generateOutputInnerArm64(pOutput);
1499	break;
1500	default:
1501	rcExit = RTEXITCODE_FAILURE;
1502	break;
1503	}
1504	if (fclose(pOutput))
1505	{
1506	fprintf(stderr, "error: Error closing '%s'.\n", g_pszOutput);
1507	rcExit = RTEXITCODE_FAILURE;
1508	}
1509	}
1510	else
1511	fprintf(stderr, "error: Failed to open '%s' for writing.\n", g_pszOutput);
1512	return rcExit;
1513	}
1514
1515
1516	/**
1517	* Displays usage information.
1518	*
1519	* @returns RTEXITCODE_SUCCESS.
1520	* @param pszArgv0 The argv[0] string.
1521	*/
1522	static int usage(const char *pszArgv0)
1523	{
1524	printf("usage: %s [options] --libary <loadname> --output <lazyload.asm> <input.def>\n"
1525	"\n"
1526	"Options:\n"
1527	" --explicit-load-function, --no-explicit-load-function\n"
1528	" Whether to include the explicit load function, default is not to.\n"
1529	"\n"
1530	"Copyright (C) 2013-2016 Oracle Corporation\n"
1531	, pszArgv0);
1532
1533	return RTEXITCODE_SUCCESS;
1534	}
1535
1536
1537	int main(int argc, char **argv)
1538	{
1539	/*
1540	* Parse options.
1541	*/
1542	for (int i = 1; i < argc; i++)
1543	{
1544	const char *psz = argv[i];
1545	if (*psz == '-')
1546	{
1547	if (!strcmp(psz, "--output") \|\| !strcmp(psz, "-o"))
1548	{
1549	if (++i >= argc)
1550	{
1551	fprintf(stderr, "syntax error: File name expected after '%s'.\n", psz);
1552	return RTEXITCODE_SYNTAX;
1553	}
1554	g_pszOutput = argv[i];
1555	}
1556	else if (!strcmp(psz, "--library") \|\| !strcmp(psz, "-l"))
1557	{
1558	if (++i >= argc)
1559	{
1560	fprintf(stderr, "syntax error: Library name expected after '%s'.\n", psz);
1561	return RTEXITCODE_SYNTAX;
1562	}
1563	g_pszLibrary = argv[i];
1564	}
1565	else if (!strcmp(psz, "--explicit-load-function"))
1566	g_fWithExplictLoadFunction = true;
1567	else if (!strcmp(psz, "--no-explicit-load-function"))
1568	g_fWithExplictLoadFunction = false;
1569	else if (!strcmp(psz, "--system"))
1570	g_fSystemLibrary = true;
1571	/** @todo Support different load methods so this can be used on system libs and
1572	* such if we like. */
1573	else if ( !strcmp(psz, "--help")
1574	\|\| !strcmp(psz, "-help")
1575	\|\| !strcmp(psz, "-h")
1576	\|\| !strcmp(psz, "-?") )
1577	return usage(argv[0]);
1578	else if ( !strcmp(psz, "--version")
1579	\|\| !strcmp(psz, "-V"))
1580	{
1581	printf("$Revision: 98103 $\n");
1582	return RTEXITCODE_SUCCESS;
1583	}
1584	else
1585	{
1586	fprintf(stderr, "syntax error: Unknown option '%s'.\n", psz);
1587	return RTEXITCODE_SYNTAX;
1588	}
1589	}
1590	else
1591	{
1592	if (g_cInputs >= RT_ELEMENTS(g_apszInputs))
1593	{
1594	fprintf(stderr, "syntax error: Too many input files, max is %d.\n", (int)RT_ELEMENTS(g_apszInputs));
1595	return RTEXITCODE_SYNTAX;
1596	}
1597	g_apszInputs[g_cInputs++] = argv[i];
1598	}
1599	}
1600	if (g_cInputs == 0)
1601	{
1602	fprintf(stderr, "syntax error: No input file specified.\n");
1603	return RTEXITCODE_SYNTAX;
1604	}
1605	if (!g_pszOutput)
1606	{
1607	fprintf(stderr, "syntax error: No output file specified.\n");
1608	return RTEXITCODE_SYNTAX;
1609	}
1610	if (!g_pszLibrary)
1611	{
1612	fprintf(stderr, "syntax error: No library name specified.\n");
1613	return RTEXITCODE_SYNTAX;
1614	}
1615
1616	/*
1617	* Do the job.
1618	*/
1619	RTEXITCODE rcExit = parseInputs();
1620	if (rcExit == RTEXITCODE_SUCCESS)
1621	rcExit = generateOutput();
1622	return rcExit;
1623	}
1624

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/bldprogs/VBoxDef2LazyLoad.cpp@ 98409

Download in other formats: