VBoxTpG.cpp@ 84551

Last change on this file since 84551 was 82968, checked in by vboxsync, 5 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: 97.8 KB

Line
1	/* $Id: VBoxTpG.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* VBox Build Tool - VBox Tracepoint Generator.
4	*/
5
6	/*
7	* Copyright (C) 2012-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <VBox/VBoxTpG.h>
23
24	#include <iprt/alloca.h>
25	#include <iprt/assert.h>
26	#include <iprt/ctype.h>
27	#include <iprt/env.h>
28	#include <iprt/errcore.h>
29	#include <iprt/file.h>
30	#include <iprt/getopt.h>
31	#include <iprt/initterm.h>
32	#include <iprt/list.h>
33	#include <iprt/mem.h>
34	#include <iprt/message.h>
35	#include <iprt/path.h>
36	#include <iprt/process.h>
37	#include <iprt/stream.h>
38	#include <iprt/string.h>
39	#include <iprt/uuid.h>
40
41	#include "scmstream.h"
42
43
44	/*********************************************************************************************************************************
45	* Structures and Typedefs *
46	*********************************************************************************************************************************/
47
48	typedef struct VTGATTRS
49	{
50	kVTGStability enmCode;
51	kVTGStability enmData;
52	kVTGClass enmDataDep;
53	} VTGATTRS;
54	typedef VTGATTRS *PVTGATTRS;
55
56
57	typedef struct VTGARG
58	{
59	RTLISTNODE ListEntry;
60	/** The argument name. (heap) */
61	char *pszName;
62	/** The type presented to the tracer (in string table). */
63	const char *pszTracerType;
64	/** The argument type used in the probe method in that context. (heap) */
65	char *pszCtxType;
66	/** Argument passing format string. First and only argument is the name.
67	* (const string) */
68	const char *pszArgPassingFmt;
69	/** The type flags. */
70	uint32_t fType;
71	} VTGARG;
72	typedef VTGARG *PVTGARG;
73
74	typedef struct VTGPROBE
75	{
76	RTLISTNODE ListEntry;
77	char *pszMangledName;
78	const char *pszUnmangledName;
79	RTLISTANCHOR ArgHead;
80	uint32_t cArgs;
81	bool fHaveLargeArgs;
82	uint32_t offArgList;
83	uint32_t iProbe;
84	} VTGPROBE;
85	typedef VTGPROBE *PVTGPROBE;
86
87	typedef struct VTGPROVIDER
88	{
89	RTLISTNODE ListEntry;
90	const char *pszName;
91
92	uint16_t iFirstProbe;
93	uint16_t cProbes;
94
95	VTGATTRS AttrSelf;
96	VTGATTRS AttrModules;
97	VTGATTRS AttrFunctions;
98	VTGATTRS AttrName;
99	VTGATTRS AttrArguments;
100
101	RTLISTANCHOR ProbeHead;
102	} VTGPROVIDER;
103	typedef VTGPROVIDER *PVTGPROVIDER;
104
105	/**
106	* A string table string.
107	*/
108	typedef struct VTGSTRING
109	{
110	/** The string space core. */
111	RTSTRSPACECORE Core;
112	/** The string table offset. */
113	uint32_t offStrTab;
114	/** The actual string. */
115	char szString[1];
116	} VTGSTRING;
117	typedef VTGSTRING *PVTGSTRING;
118
119
120	/*********************************************************************************************************************************
121	* Global Variables *
122	*********************************************************************************************************************************/
123	/** The string space organizing the string table strings. Each node is a VTGSTRING. */
124	static RTSTRSPACE g_StrSpace = NULL;
125	/** Used by the string table enumerator to set VTGSTRING::offStrTab. */
126	static uint32_t g_offStrTab;
127	/** List of providers created by the parser. */
128	static RTLISTANCHOR g_ProviderHead;
129	/** The number of type errors. */
130	static uint32_t g_cTypeErrors = 0;
131
132
133	/** @name Options
134	* @{ */
135	static enum
136	{
137	kVBoxTpGAction_Nothing,
138	kVBoxTpGAction_GenerateHeader,
139	kVBoxTpGAction_GenerateWrapperHeader,
140	kVBoxTpGAction_GenerateObject
141	} g_enmAction = kVBoxTpGAction_Nothing;
142	static uint32_t g_cBits = HC_ARCH_BITS;
143	static uint32_t g_cHostBits = HC_ARCH_BITS;
144	static uint32_t g_fTypeContext = VTG_TYPE_CTX_R0;
145	static const char *g_pszContextDefine = "IN_RING0";
146	static const char *g_pszContextDefine2 = NULL;
147	static bool g_fApplyCpp = false;
148	static uint32_t g_cVerbosity = 0;
149	static const char *g_pszOutput = NULL;
150	static const char *g_pszScript = NULL;
151	static const char *g_pszTempAsm = NULL;
152	#ifdef RT_OS_DARWIN
153	static const char *g_pszAssembler = "yasm";
154	static const char *g_pszAssemblerFmtOpt = "-f";
155	static const char g_szAssemblerFmtVal32[] = "macho32";
156	static const char g_szAssemblerFmtVal64[] = "macho64";
157	static const char g_szAssemblerOsDef[] = "RT_OS_DARWIN";
158	#elif defined(RT_OS_OS2)
159	static const char *pszAssembler = "nasm.exe";
160	static const char *pszAssemblerFmtOpt = "-f";
161	static const char g_szAssemblerFmtVal32[] = "obj";
162	static const char g_szAssemblerFmtVal64[] = "elf64";
163	static const char g_szAssemblerOsDef[] = "RT_OS_OS2";
164	#elif defined(RT_OS_WINDOWS)
165	static const char *g_pszAssembler = "yasm.exe";
166	static const char *g_pszAssemblerFmtOpt = "-f";
167	static const char g_szAssemblerFmtVal32[] = "win32";
168	static const char g_szAssemblerFmtVal64[] = "win64";
169	static const char g_szAssemblerOsDef[] = "RT_OS_WINDOWS";
170	#else
171	static const char *g_pszAssembler = "yasm";
172	static const char *g_pszAssemblerFmtOpt = "-f";
173	static const char g_szAssemblerFmtVal32[] = "elf32";
174	static const char g_szAssemblerFmtVal64[] = "elf64";
175	# ifdef RT_OS_FREEBSD
176	static const char g_szAssemblerOsDef[] = "RT_OS_FREEBSD";
177	# elif defined(RT_OS_NETBSD)
178	static const char g_szAssemblerOsDef[] = "RT_OS_NETBSD";
179	# elif defined(RT_OS_OPENBSD)
180	static const char g_szAssemblerOsDef[] = "RT_OS_OPENBSD";
181	# elif defined(RT_OS_LINUX)
182	static const char g_szAssemblerOsDef[] = "RT_OS_LINUX";
183	# elif defined(RT_OS_SOLARIS)
184	static const char g_szAssemblerOsDef[] = "RT_OS_SOLARIS";
185	# else
186	# error "Port me!"
187	# endif
188	#endif
189	static const char *g_pszAssemblerFmtVal = RT_CONCAT(g_szAssemblerFmtVal, HC_ARCH_BITS);
190	static const char *g_pszAssemblerDefOpt = "-D";
191	static const char *g_pszAssemblerIncOpt = "-I";
192	static char g_szAssemblerIncVal[RTPATH_MAX];
193	static const char *g_pszAssemblerIncVal = __FILE__ "/../../../include/";
194	static const char *g_pszAssemblerOutputOpt = "-o";
195	static unsigned g_cAssemblerOptions = 0;
196	static const char *g_apszAssemblerOptions[32];
197	static const char *g_pszProbeFnName = "SUPR0TracerFireProbe";
198	static bool g_fProbeFnImported = true;
199	static bool g_fPic = false;
200	/** @} */
201
202
203
204
205	/**
206	* Inserts a string into the string table, reusing any matching existing string
207	* if possible.
208	*
209	* @returns Read only string.
210	* @param pch The string to insert (need not be terminated).
211	* @param cch The length of the string.
212	*/
213	static const char strtabInsertN(const char pch, size_t cch)
214	{
215	PVTGSTRING pStr = (PVTGSTRING)RTStrSpaceGetN(&g_StrSpace, pch, cch);
216	if (pStr)
217	return pStr->szString;
218
219	/*
220	* Create a new entry.
221	*/
222	pStr = (PVTGSTRING)RTMemAlloc(RT_UOFFSETOF_DYN(VTGSTRING, szString[cch + 1]));
223	if (!pStr)
224	return NULL;
225
226	pStr->Core.pszString = pStr->szString;
227	memcpy(pStr->szString, pch, cch);
228	pStr->szString[cch] = '\0';
229	pStr->offStrTab = UINT32_MAX;
230
231	bool fRc = RTStrSpaceInsert(&g_StrSpace, &pStr->Core);
232	Assert(fRc); NOREF(fRc);
233	return pStr->szString;
234	}
235
236
237	/**
238	* Retrieves the string table offset of the given string table string.
239	*
240	* @returns String table offset.
241	* @param pszStrTabString The string table string.
242	*/
243	static uint32_t strtabGetOff(const char *pszStrTabString)
244	{
245	PVTGSTRING pStr = RT_FROM_MEMBER(pszStrTabString, VTGSTRING, szString[0]);
246	Assert(pStr->Core.pszString == pszStrTabString);
247	return pStr->offStrTab;
248	}
249
250
251	/**
252	* Invokes the assembler.
253	*
254	* @returns Exit code.
255	* @param pszOutput The output file.
256	* @param pszTempAsm The source file.
257	*/
258	static RTEXITCODE generateInvokeAssembler(const char pszOutput, const char pszTempAsm)
259	{
260	const char *apszArgs[64];
261	unsigned iArg = 0;
262
263	apszArgs[iArg++] = g_pszAssembler;
264	apszArgs[iArg++] = g_pszAssemblerFmtOpt;
265	apszArgs[iArg++] = g_pszAssemblerFmtVal;
266	apszArgs[iArg++] = g_pszAssemblerDefOpt;
267	if (!strcmp(g_pszAssemblerFmtVal, "macho32") \|\| !strcmp(g_pszAssemblerFmtVal, "macho64"))
268	apszArgs[iArg++] = "ASM_FORMAT_MACHO";
269	else if (!strcmp(g_pszAssemblerFmtVal, "obj") \|\| !strcmp(g_pszAssemblerFmtVal, "omf"))
270	apszArgs[iArg++] = "ASM_FORMAT_OMF";
271	else if ( !strcmp(g_pszAssemblerFmtVal, "win32")
272	\|\| !strcmp(g_pszAssemblerFmtVal, "win64")
273	\|\| !strcmp(g_pszAssemblerFmtVal, "pe32")
274	\|\| !strcmp(g_pszAssemblerFmtVal, "pe64")
275	\|\| !strcmp(g_pszAssemblerFmtVal, "pe") )
276	apszArgs[iArg++] = "ASM_FORMAT_PE";
277	else if ( !strcmp(g_pszAssemblerFmtVal, "elf32")
278	\|\| !strcmp(g_pszAssemblerFmtVal, "elf64")
279	\|\| !strcmp(g_pszAssemblerFmtVal, "elf"))
280	apszArgs[iArg++] = "ASM_FORMAT_ELF";
281	else
282	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Unknown assembler format '%s'", g_pszAssemblerFmtVal);
283	apszArgs[iArg++] = g_pszAssemblerDefOpt;
284	if (g_cBits == 32)
285	apszArgs[iArg++] = "ARCH_BITS=32";
286	else
287	apszArgs[iArg++] = "ARCH_BITS=64";
288	apszArgs[iArg++] = g_pszAssemblerDefOpt;
289	if (g_cHostBits == 32)
290	apszArgs[iArg++] = "HC_ARCH_BITS=32";
291	else
292	apszArgs[iArg++] = "HC_ARCH_BITS=64";
293	apszArgs[iArg++] = g_pszAssemblerDefOpt;
294	if (g_cBits == 32)
295	apszArgs[iArg++] = "RT_ARCH_X86";
296	else
297	apszArgs[iArg++] = "RT_ARCH_AMD64";
298	apszArgs[iArg++] = g_pszAssemblerDefOpt;
299	apszArgs[iArg++] = g_pszContextDefine;
300	if (g_pszContextDefine2)
301	{
302	apszArgs[iArg++] = g_pszAssemblerDefOpt;
303	apszArgs[iArg++] = g_pszContextDefine2;
304	}
305	if (g_szAssemblerOsDef[0])
306	{
307	apszArgs[iArg++] = g_pszAssemblerDefOpt;
308	apszArgs[iArg++] = g_szAssemblerOsDef;
309	}
310	apszArgs[iArg++] = g_pszAssemblerIncOpt;
311	apszArgs[iArg++] = g_pszAssemblerIncVal;
312	apszArgs[iArg++] = g_pszAssemblerOutputOpt;
313	apszArgs[iArg++] = pszOutput;
314	for (unsigned i = 0; i < g_cAssemblerOptions; i++)
315	apszArgs[iArg++] = g_apszAssemblerOptions[i];
316	apszArgs[iArg++] = pszTempAsm;
317	apszArgs[iArg] = NULL;
318	Assert(iArg <= RT_ELEMENTS(apszArgs));
319
320	if (g_cVerbosity > 1)
321	{
322	RTMsgInfo("Starting assmbler '%s' with arguments:\n", g_pszAssembler);
323	for (unsigned i = 0; i < iArg; i++)
324	RTMsgInfo(" #%02u: '%s'\n", i, apszArgs[i]);
325	}
326
327	RTPROCESS hProc;
328	int rc = RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, RTPROC_FLAGS_SEARCH_PATH, &hProc);
329	if (RT_FAILURE(rc))
330	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to start '%s' (assembler): %Rrc", apszArgs[0], rc);
331
332	RTPROCSTATUS Status;
333	rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &Status);
334	if (RT_FAILURE(rc))
335	{
336	RTProcTerminate(hProc);
337	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTProcWait failed: %Rrc", rc);
338	}
339	if (Status.enmReason == RTPROCEXITREASON_SIGNAL)
340	return RTMsgErrorExit(RTEXITCODE_FAILURE, "The assembler failed: signal %d", Status.iStatus);
341	if (Status.enmReason != RTPROCEXITREASON_NORMAL)
342	return RTMsgErrorExit(RTEXITCODE_FAILURE, "The assembler failed: abend");
343	if (Status.iStatus != 0)
344	return RTMsgErrorExit((RTEXITCODE)Status.iStatus, "The assembler failed: exit code %d", Status.iStatus);
345
346	return RTEXITCODE_SUCCESS;
347	}
348
349
350	/**
351	* Worker that does the boring bits when generating a file.
352	*
353	* @returns Exit code.
354	* @param pszOutput The name of the output file.
355	* @param pszWhat What kind of file it is.
356	* @param pfnGenerator The callback function that provides the contents
357	* of the file.
358	*/
359	static RTEXITCODE generateFile(const char pszOutput, const char pszWhat,
360	RTEXITCODE (*pfnGenerator)(PSCMSTREAM))
361	{
362	SCMSTREAM Strm;
363	int rc = ScmStreamInitForWriting(&Strm, NULL);
364	if (RT_FAILURE(rc))
365	return RTMsgErrorExit(RTEXITCODE_FAILURE, "ScmStreamInitForWriting returned %Rrc when generating the %s file",
366	rc, pszWhat);
367
368	RTEXITCODE rcExit = pfnGenerator(&Strm);
369	if (RT_FAILURE(ScmStreamGetStatus(&Strm)))
370	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Stream error %Rrc generating the %s file",
371	ScmStreamGetStatus(&Strm), pszWhat);
372	if (rcExit == RTEXITCODE_SUCCESS)
373	{
374	rc = ScmStreamWriteToFile(&Strm, "%s", pszOutput);
375	if (RT_FAILURE(rc))
376	rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "ScmStreamWriteToFile returned %Rrc when writing '%s' (%s)",
377	rc, pszOutput, pszWhat);
378	if (rcExit == RTEXITCODE_SUCCESS)
379	{
380	if (g_cVerbosity > 0)
381	RTMsgInfo("Successfully generated '%s'.", pszOutput);
382	if (g_cVerbosity > 1)
383	{
384	RTMsgInfo("================ %s - start ================", pszWhat);
385	ScmStreamRewindForReading(&Strm);
386	const char *pszLine;
387	size_t cchLine;
388	SCMEOL enmEol;
389	while ((pszLine = ScmStreamGetLine(&Strm, &cchLine, &enmEol)) != NULL)
390	RTPrintf("%.*s\n", cchLine, pszLine);
391	RTMsgInfo("================ %s - end ================", pszWhat);
392	}
393	}
394	}
395	ScmStreamDelete(&Strm);
396	return rcExit;
397	}
398
399
400	/**
401	* @callback_method_impl{FNRTSTRSPACECALLBACK, Writes the string table strings.}
402	*/
403	static DECLCALLBACK(int) generateAssemblyStrTabCallback(PRTSTRSPACECORE pStr, void *pvUser)
404	{
405	PVTGSTRING pVtgStr = (PVTGSTRING)pStr;
406	PSCMSTREAM pStrm = (PSCMSTREAM)pvUser;
407
408	pVtgStr->offStrTab = g_offStrTab;
409	g_offStrTab += (uint32_t)pVtgStr->Core.cchString + 1;
410
411	ScmStreamPrintf(pStrm,
412	" db '%s', 0 ; off=%u len=%zu\n",
413	pVtgStr->szString, pVtgStr->offStrTab, pVtgStr->Core.cchString);
414	return VINF_SUCCESS;
415	}
416
417
418	/**
419	* Generate assembly source that can be turned into an object file.
420	*
421	* (This is a generateFile callback.)
422	*
423	* @returns Exit code.
424	* @param pStrm The output stream.
425	*/
426	static RTEXITCODE generateAssembly(PSCMSTREAM pStrm)
427	{
428	PVTGPROVIDER pProvider;
429	PVTGPROBE pProbe;
430	PVTGARG pArg;
431
432
433	if (g_cVerbosity > 0)
434	RTMsgInfo("Generating assembly code...");
435
436	/*
437	* Write the file header.
438	*/
439	ScmStreamPrintf(pStrm,
440	"; $Id: VBoxTpG.cpp 82968 2020-02-04 10:35:17Z vboxsync $ \n"
441	";; @file\n"
442	"; Automatically generated from %s. Do NOT edit!\n"
443	";\n"
444	"\n"
445	"%%include \"iprt/asmdefs.mac\"\n"
446	"\n"
447	"\n"
448	";"
449	"; We put all the data in a dedicated section / segment.\n"
450	";\n"
451	"; In order to find the probe location specifiers, we do the necessary\n"
452	"; trickery here, ASSUMING that this object comes in first in the link\n"
453	"; editing process.\n"
454	";\n"
455	"%%ifdef ASM_FORMAT_OMF\n"
456	" %%macro VTG_GLOBAL 2\n"
457	" global NAME(%%1)\n"
458	" NAME(%%1):\n"
459	" %%endmacro\n"
460	" segment VTG.Obj public CLASS=VTG align=4096 use32\n"
461	"\n"
462	"%%elifdef ASM_FORMAT_MACHO\n"
463	" %%macro VTG_GLOBAL 2\n"
464	" global NAME(%%1)\n"
465	" NAME(%%1):\n"
466	" %%endmacro\n"
467	" %%ifdef IN_RING3\n"
468	" %%define VTG_NEW_MACHO_LINKER\n"
469	" %%elif ARCH_BITS == 64\n"
470	" %%define VTG_NEW_MACHO_LINKER\n"
471	" %%elifdef IN_RING0_AGNOSTIC\n"
472	" %%define VTG_NEW_MACHO_LINKER\n"
473	" %%endif\n"
474	" %%ifdef VTG_NEW_MACHO_LINKER\n"
475	" ; Section order hack!\n"
476	" ; With the ld64-97.17 linker there was a problem with it determining the section\n"
477	" ; order based on symbol references. The references to the start and end of the\n"
478	" ; __VTGPrLc section forced it in front of __VTGObj, we want __VTGObj first.\n"
479	" extern section$start$__VTG$__VTGObj\n"
480	" extern section$end$__VTG$__VTGObj\n"
481	" %%else\n"
482	" ; Creating 32-bit kext of the type MH_OBJECT. No fancy section end/start symbols handy.\n"
483	" [section __VTG __VTGObj align=16]\n"
484	"VTG_GLOBAL g_aVTGObj_LinkerPleaseNoticeMe, data\n"
485	" [section __VTG __VTGPrLc.Begin align=16]\n"
486	" dq 0, 0 ; Paranoia, related to the fudge below.\n"
487	"VTG_GLOBAL g_aVTGPrLc, data\n"
488	" [section __VTG __VTGPrLc align=16]\n"
489	"VTG_GLOBAL g_aVTGPrLc_LinkerPleaseNoticeMe, data\n"
490	" [section __VTG __VTGPrLc.End align=16]\n"
491	"VTG_GLOBAL g_aVTGPrLc_End, data\n"
492	" dq 0, 0 ; Fudge to work around unidentified linker where it would otherwise generate\n"
493	" ; a fix up of the first dword in __VTGPrLc.Begin despite the fact that it were\n"
494	" ; an empty section with nothing whatsoever to fix up.\n"
495	" %%endif\n"
496	" [section __VTG __VTGObj]\n"
497	"\n"
498	"%%elifdef ASM_FORMAT_PE\n"
499	" %%macro VTG_GLOBAL 2\n"
500	" global NAME(%%1)\n"
501	" NAME(%%1):\n"
502	" %%endmacro\n"
503	" [section VTGPrLc.Begin data align=64]\n"
504	/" times 16 db 0xcc\n"/
505	"VTG_GLOBAL g_aVTGPrLc, data\n"
506	" [section VTGPrLc.Data data align=4]\n"
507	" [section VTGPrLc.End data align=4]\n"
508	"VTG_GLOBAL g_aVTGPrLc_End, data\n"
509	/" times 16 db 0xcc\n"/
510	" [section VTGObj data align=32]\n"
511	"\n"
512	"%%elifdef ASM_FORMAT_ELF\n"
513	" %%macro VTG_GLOBAL 2\n"
514	" global NAME(%%1):%%2 hidden\n"
515	" NAME(%%1):\n"
516	" %%endmacro\n"
517	" [section .VTGData progbits alloc noexec write align=4096]\n"
518	" [section .VTGPrLc.Begin progbits alloc noexec write align=32]\n"
519	" dd 0,0,0,0, 0,0,0,0\n"
520	"VTG_GLOBAL g_aVTGPrLc, data\n"
521	" [section .VTGPrLc progbits alloc noexec write align=1]\n"
522	" [section .VTGPrLc.End progbits alloc noexec write align=1]\n"
523	"VTG_GLOBAL g_aVTGPrLc_End, data\n"
524	" dd 0,0,0,0, 0,0,0,0\n"
525	" [section .VTGData]\n"
526	"\n"
527	"%%else\n"
528	" %%error \"ASM_FORMAT_XXX is not defined\"\n"
529	"%%endif\n"
530	"\n"
531	"\n"
532	"VTG_GLOBAL g_VTGObjHeader, data\n"
533	" ;0 1 2 3\n"
534	" ;012345678901234567890123456789012\n"
535	" db 'VTG Object Header v1.7', 0, 0\n"
536	" dd %u\n"
537	" dd NAME(g_acVTGProbeEnabled_End) - NAME(g_VTGObjHeader)\n"
538	" dd NAME(g_achVTGStringTable) - NAME(g_VTGObjHeader)\n"
539	" dd NAME(g_achVTGStringTable_End) - NAME(g_achVTGStringTable)\n"
540	" dd NAME(g_aVTGArgLists) - NAME(g_VTGObjHeader)\n"
541	" dd NAME(g_aVTGArgLists_End) - NAME(g_aVTGArgLists)\n"
542	" dd NAME(g_aVTGProbes) - NAME(g_VTGObjHeader)\n"
543	" dd NAME(g_aVTGProbes_End) - NAME(g_aVTGProbes)\n"
544	" dd NAME(g_aVTGProviders) - NAME(g_VTGObjHeader)\n"
545	" dd NAME(g_aVTGProviders_End) - NAME(g_aVTGProviders)\n"
546	" dd NAME(g_acVTGProbeEnabled) - NAME(g_VTGObjHeader)\n"
547	" dd NAME(g_acVTGProbeEnabled_End) - NAME(g_acVTGProbeEnabled)\n"
548	" dd 0\n"
549	" dd 0\n"
550	"%%ifdef VTG_NEW_MACHO_LINKER\n"
551	" extern section$start$__VTG$__VTGPrLc\n"
552	" RTCCPTR_DEF section$start$__VTG$__VTGPrLc\n"
553	" %%if ARCH_BITS == 32\n"
554	" dd 0\n"
555	" %%endif\n"
556	" extern section$end$__VTG$__VTGPrLc\n"
557	" RTCCPTR_DEF section$end$__VTG$__VTGPrLc\n"
558	" %%if ARCH_BITS == 32\n"
559	" dd 0\n"
560	" %%endif\n"
561	"%%else\n"
562	" RTCCPTR_DEF NAME(g_aVTGPrLc)\n"
563	" %%if ARCH_BITS == 32\n"
564	" dd 0\n"
565	" %%endif\n"
566	" RTCCPTR_DEF NAME(g_aVTGPrLc_End)\n"
567	" %%if ARCH_BITS == 32\n"
568	" dd 0\n"
569	" %%endif\n"
570	"%%endif\n"
571	,
572	g_pszScript, g_cBits);
573	RTUUID Uuid;
574	int rc = RTUuidCreate(&Uuid);
575	if (RT_FAILURE(rc))
576	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTUuidCreate failed: %Rrc", rc);
577	ScmStreamPrintf(pStrm,
578	" dd 0%08xh, 0%08xh, 0%08xh, 0%08xh\n"
579	"%%ifdef VTG_NEW_MACHO_LINKER\n"
580	" RTCCPTR_DEF section$start$__VTG$__VTGObj\n"
581	" %%if ARCH_BITS == 32\n"
582	" dd 0\n"
583	" %%endif\n"
584	"%%else\n"
585	" dd 0, 0\n"
586	"%%endif\n"
587	" dd 0, 0\n"
588	, Uuid.au32[0], Uuid.au32[1], Uuid.au32[2], Uuid.au32[3]);
589
590	/*
591	* Dump the string table before we start using the strings.
592	*/
593	ScmStreamPrintf(pStrm,
594	"\n"
595	";\n"
596	"; The string table.\n"
597	";\n"
598	"VTG_GLOBAL g_achVTGStringTable, data\n");
599	g_offStrTab = 0;
600	RTStrSpaceEnumerate(&g_StrSpace, generateAssemblyStrTabCallback, pStrm);
601	ScmStreamPrintf(pStrm,
602	"VTG_GLOBAL g_achVTGStringTable_End, data\n");
603
604	/*
605	* Write out the argument lists before we use them.
606	*/
607	ScmStreamPrintf(pStrm,
608	"\n"
609	";\n"
610	"; The argument lists.\n"
611	";\n"
612	"ALIGNDATA(16)\n"
613	"VTG_GLOBAL g_aVTGArgLists, data\n");
614	uint32_t off = 0;
615	RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
616	{
617	RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
618	{
619	if (pProbe->offArgList != UINT32_MAX)
620	continue;
621
622	/* Write it. */
623	pProbe->offArgList = off;
624	ScmStreamPrintf(pStrm,
625	" ; off=%u\n"
626	" db %2u ; Argument count\n"
627	" db %u ; fHaveLargeArgs\n"
628	" db 0, 0 ; Reserved\n"
629	, off, pProbe->cArgs, (int)pProbe->fHaveLargeArgs);
630	off += 4;
631	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
632	{
633	ScmStreamPrintf(pStrm,
634	" dd %8u ; type '%s' (name '%s')\n"
635	" dd 0%08xh ; type flags\n",
636	strtabGetOff(pArg->pszTracerType), pArg->pszTracerType, pArg->pszName,
637	pArg->fType);
638	off += 8;
639	}
640
641	/* Look for matching argument lists (lazy bird walks the whole list). */
642	PVTGPROVIDER pProv2;
643	RTListForEach(&g_ProviderHead, pProv2, VTGPROVIDER, ListEntry)
644	{
645	PVTGPROBE pProbe2;
646	RTListForEach(&pProvider->ProbeHead, pProbe2, VTGPROBE, ListEntry)
647	{
648	if (pProbe2->offArgList != UINT32_MAX)
649	continue;
650	if (pProbe2->cArgs != pProbe->cArgs)
651	continue;
652
653	PVTGARG pArg2;
654	pArg = RTListNodeGetNext(&pProbe->ArgHead, VTGARG, ListEntry);
655	pArg2 = RTListNodeGetNext(&pProbe2->ArgHead, VTGARG, ListEntry);
656	int32_t cArgs = pProbe->cArgs;
657	while ( cArgs-- > 0
658	&& pArg2->pszTracerType == pArg->pszTracerType
659	&& pArg2->fType == pArg->fType)
660	{
661	pArg = RTListNodeGetNext(&pArg->ListEntry, VTGARG, ListEntry);
662	pArg2 = RTListNodeGetNext(&pArg2->ListEntry, VTGARG, ListEntry);
663	}
664	if (cArgs >= 0)
665	continue;
666	pProbe2->offArgList = pProbe->offArgList;
667	}
668	}
669	}
670	}
671	ScmStreamPrintf(pStrm,
672	"VTG_GLOBAL g_aVTGArgLists_End, data\n");
673
674
675	/*
676	* Probe definitions.
677	*/
678	ScmStreamPrintf(pStrm,
679	"\n"
680	";\n"
681	"; Prob definitions.\n"
682	";\n"
683	"ALIGNDATA(16)\n"
684	"VTG_GLOBAL g_aVTGProbes, data\n"
685	"\n");
686	uint32_t iProvider = 0;
687	uint32_t iProbe = 0;
688	RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
689	{
690	pProvider->iFirstProbe = iProbe;
691	RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
692	{
693	ScmStreamPrintf(pStrm,
694	"VTG_GLOBAL g_VTGProbeData_%s_%s, data ; idx=#%4u\n"
695	" dd %6u ; offName\n"
696	" dd %6u ; offArgList\n"
697	" dw (NAME(g_cVTGProbeEnabled_%s_%s) - NAME(g_acVTGProbeEnabled)) / 4 ; idxEnabled\n"
698	" dw %6u ; idxProvider\n"
699	" dd NAME(g_VTGObjHeader) - NAME(g_VTGProbeData_%s_%s) ; offObjHdr\n"
700	,
701	pProvider->pszName, pProbe->pszMangledName, iProbe,
702	strtabGetOff(pProbe->pszUnmangledName),
703	pProbe->offArgList,
704	pProvider->pszName, pProbe->pszMangledName,
705	iProvider,
706	pProvider->pszName, pProbe->pszMangledName
707	);
708	pProbe->iProbe = iProbe;
709	iProbe++;
710	}
711	pProvider->cProbes = iProbe - pProvider->iFirstProbe;
712	iProvider++;
713	}
714	ScmStreamPrintf(pStrm, "VTG_GLOBAL g_aVTGProbes_End, data\n");
715
716	/*
717	* The provider data.
718	*/
719	ScmStreamPrintf(pStrm,
720	"\n"
721	";\n"
722	"; Provider data.\n"
723	";\n"
724	"ALIGNDATA(16)\n"
725	"VTG_GLOBAL g_aVTGProviders, data\n");
726	iProvider = 0;
727	RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
728	{
729	ScmStreamPrintf(pStrm,
730	" ; idx=#%4u - %s\n"
731	" dd %6u ; name\n"
732	" dw %6u ; index of first probe\n"
733	" dw %6u ; count of probes\n"
734	" db %d, %d, %d ; AttrSelf\n"
735	" db %d, %d, %d ; AttrModules\n"
736	" db %d, %d, %d ; AttrFunctions\n"
737	" db %d, %d, %d ; AttrName\n"
738	" db %d, %d, %d ; AttrArguments\n"
739	" db 0 ; reserved\n"
740	"VTG_GLOBAL g_cVTGProviderProbesEnabled_%s, data\n"
741	" dd 0\n"
742	"VTG_GLOBAL g_cVTGProviderSettingsSeqNo_%s, data\n"
743	" dd 0\n"
744	,
745	iProvider, pProvider->pszName,
746	strtabGetOff(pProvider->pszName),
747	pProvider->iFirstProbe,
748	pProvider->cProbes,
749	pProvider->AttrSelf.enmCode, pProvider->AttrSelf.enmData, pProvider->AttrSelf.enmDataDep,
750	pProvider->AttrModules.enmCode, pProvider->AttrModules.enmData, pProvider->AttrModules.enmDataDep,
751	pProvider->AttrFunctions.enmCode, pProvider->AttrFunctions.enmData, pProvider->AttrFunctions.enmDataDep,
752	pProvider->AttrName.enmCode, pProvider->AttrName.enmData, pProvider->AttrName.enmDataDep,
753	pProvider->AttrArguments.enmCode, pProvider->AttrArguments.enmData, pProvider->AttrArguments.enmDataDep,
754	pProvider->pszName,
755	pProvider->pszName);
756	iProvider++;
757	}
758	ScmStreamPrintf(pStrm, "VTG_GLOBAL g_aVTGProviders_End, data\n");
759
760	/*
761	* Declare the probe enable flags.
762	*
763	* These must be placed at the end so they'll end up adjacent to the probe
764	* locations. This is important for reducing the amount of memory we need
765	* to lock down for user mode modules.
766	*/
767	ScmStreamPrintf(pStrm,
768	";\n"
769	"; Probe enabled flags.\n"
770	";\n"
771	"ALIGNDATA(16)\n"
772	"VTG_GLOBAL g_acVTGProbeEnabled, data\n"
773	);
774	uint32_t cProbes = 0;
775	RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
776	{
777	RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
778	{
779	ScmStreamPrintf(pStrm,
780	"VTG_GLOBAL g_cVTGProbeEnabled_%s_%s, data\n"
781	" dd 0\n",
782	pProvider->pszName, pProbe->pszMangledName);
783	cProbes++;
784	}
785	}
786	ScmStreamPrintf(pStrm, "VTG_GLOBAL g_acVTGProbeEnabled_End, data\n");
787	if (cProbes >= _32K)
788	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Too many probes: %u (max %u)", cProbes, _32K - 1);
789
790
791	/*
792	* Emit code for the stub functions.
793	*/
794	bool const fWin64 = g_cBits == 64 && (!strcmp(g_pszAssemblerFmtVal, "win64") \|\| !strcmp(g_pszAssemblerFmtVal, "pe64"));
795	bool const fElf = !strcmp(g_pszAssemblerFmtVal, "elf32") \|\| !strcmp(g_pszAssemblerFmtVal, "elf64");
796	ScmStreamPrintf(pStrm,
797	"\n"
798	";\n"
799	"; Prob stubs.\n"
800	";\n"
801	"BEGINCODE\n"
802	);
803	if (g_fProbeFnImported)
804	ScmStreamPrintf(pStrm,
805	"EXTERN_IMP2 %s\n"
806	"BEGINCODE ; EXTERN_IMP2 changes section\n",
807	g_pszProbeFnName);
808	else
809	ScmStreamPrintf(pStrm, "extern NAME(%s)\n", g_pszProbeFnName);
810
811	RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)
812	{
813	RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)
814	{
815	ScmStreamPrintf(pStrm,
816	"\n"
817	"VTG_GLOBAL VTGProbeStub_%s_%s, function; (VBOXTPGPROBELOC pVTGProbeLoc",
818	pProvider->pszName, pProbe->pszMangledName);
819	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
820	{
821	ScmStreamPrintf(pStrm, ", %s %s", pArg->pszTracerType, pArg->pszName);
822	}
823	ScmStreamPrintf(pStrm,
824	");\n");
825
826	/*
827	* Check if the probe in question is enabled.
828	*/
829	if (g_cBits == 32)
830	ScmStreamPrintf(pStrm,
831	" mov eax, [esp + 4]\n"
832	" test byte [eax+3], 0x80 ; fEnabled == true?\n"
833	" jz .return ; jump on false\n");
834	else if (fWin64)
835	ScmStreamPrintf(pStrm,
836	" test byte [rcx+3], 0x80 ; fEnabled == true?\n"
837	" jz .return ; jump on false\n");
838	else
839	ScmStreamPrintf(pStrm,
840	" test byte [rdi+3], 0x80 ; fEnabled == true?\n"
841	" jz .return ; jump on false\n");
842
843	/*
844	* Jump to the fire-probe function.
845	*/
846	if (g_cBits == 32)
847	ScmStreamPrintf(pStrm, g_fPic && fElf ?
848	" jmp %s wrt ..plt\n"
849	: g_fProbeFnImported ?
850	" mov ecx, IMP2(%s)\n"
851	" jmp ecx\n"
852	:
853	" jmp NAME(%s)\n"
854	, g_pszProbeFnName);
855	else
856	ScmStreamPrintf(pStrm, g_fPic && fElf ?
857	" jmp [rel %s wrt ..got]\n"
858	: g_fProbeFnImported ?
859	" jmp IMP2(%s)\n"
860	:
861	" jmp NAME(%s)\n"
862	, g_pszProbeFnName);
863
864	ScmStreamPrintf(pStrm,
865	".return:\n"
866	" ret ; The probe was disabled, return\n"
867	"\n");
868	}
869	}
870
871	return RTEXITCODE_SUCCESS;
872	}
873
874
875	static RTEXITCODE generateObject(const char pszOutput, const char pszTempAsm)
876	{
877	if (!pszTempAsm)
878	{
879	size_t cch = strlen(pszOutput);
880	char psz = (char )alloca(cch + sizeof(".asm"));
881	memcpy(psz, pszOutput, cch);
882	memcpy(psz + cch, ".asm", sizeof(".asm"));
883	pszTempAsm = psz;
884	}
885
886	RTEXITCODE rcExit = generateFile(pszTempAsm, "assembly", generateAssembly);
887	if (rcExit == RTEXITCODE_SUCCESS)
888	rcExit = generateInvokeAssembler(pszOutput, pszTempAsm);
889	RTFileDelete(pszTempAsm);
890	return rcExit;
891	}
892
893
894	static RTEXITCODE generateProbeDefineName(char pszBuf, size_t cbBuf, const char pszProvider, const char *pszProbe)
895	{
896	size_t cbMax = strlen(pszProvider) + 1 + strlen(pszProbe) + 1;
897	if (cbMax > cbBuf \|\| cbMax > 80)
898	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Probe '%s' in provider '%s' ends up with a too long defined\n", pszProbe, pszProvider);
899
900	while (*pszProvider)
901	pszBuf++ = RT_C_TO_UPPER(pszProvider++);
902
903	*pszBuf++ = '_';
904
905	while (*pszProbe)
906	{
907	if (pszProbe[0] == '_' && pszProbe[1] == '_')
908	pszProbe++;
909	pszBuf++ = RT_C_TO_UPPER(pszProbe++);
910	}
911
912	*pszBuf = '\0';
913	return RTEXITCODE_SUCCESS;
914	}
915
916
917	static RTEXITCODE generateProviderDefineName(char pszBuf, size_t cbBuf, const char pszProvider)
918	{
919	size_t cbMax = strlen(pszProvider) + 1;
920	if (cbMax > cbBuf \|\| cbMax > 80)
921	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Provider '%s' ends up with a too long defined\n", pszProvider);
922
923	while (*pszProvider)
924	pszBuf++ = RT_C_TO_UPPER(pszProvider++);
925
926	*pszBuf = '\0';
927	return RTEXITCODE_SUCCESS;
928	}
929
930
931	/**
932	* Called via generateFile to generate the header file.
933	*
934	* @returns Exit code status.
935	* @param pStrm The output stream.
936	*/
937	static RTEXITCODE generateHeader(PSCMSTREAM pStrm)
938	{
939	/*
940	* Calc the double inclusion blocker define and then write the file header.
941	*/
942	char szTmp[4096];
943	const char *pszName = RTPathFilename(g_pszScript);
944	size_t cchName = strlen(pszName);
945	if (cchName >= sizeof(szTmp) - 64)
946	return RTMsgErrorExit(RTEXITCODE_FAILURE, "File name is too long '%s'", pszName);
947	szTmp[0] = '_';
948	szTmp[1] = '_';
949	szTmp[2] = '_';
950	memcpy(&szTmp[3], pszName, cchName);
951	szTmp[3 + cchName + 0] = '_';
952	szTmp[3 + cchName + 1] = '_';
953	szTmp[3 + cchName + 2] = '_';
954	szTmp[3 + cchName + 3] = '\0';
955	char *psz = &szTmp[3];
956	while (*psz)
957	{
958	if (!RT_C_IS_ALNUM(psz) && psz != '_')
959	*psz = '_';
960	psz++;
961	}
962
963	ScmStreamPrintf(pStrm,
964	"/* $Id: VBoxTpG.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */\n"
965	"/** @file\n"
966	" * Automatically generated from %s. Do NOT edit!\n"
967	" */\n"
968	"\n"
969	"#ifndef %s\n"
970	"#define %s\n"
971	"#ifndef RT_WITHOUT_PRAGMA_ONCE\n"
972	"# pragma once\n"
973	"#endif\n"
974	"\n"
975	"#include <VBox/VBoxTpG.h>\n"
976	"\n"
977	"#ifndef %s\n"
978	"# error \"Expected '%s' to be defined\"\n"
979	"#endif\n"
980	"\n"
981	"RT_C_DECLS_BEGIN\n"
982	"\n"
983	"#ifdef VBOX_WITH_DTRACE\n"
984	"\n"
985	"# ifdef _MSC_VER\n"
986	"# pragma data_seg(VTG_LOC_SECT)\n"
987	"# pragma data_seg()\n"
988	"# endif\n"
989	"\n"
990	,
991	g_pszScript,
992	szTmp,
993	szTmp,
994	g_pszContextDefine,
995	g_pszContextDefine);
996
997	/*
998	* Declare data, code and macros for each probe.
999	*/
1000	PVTGPROVIDER pProv;
1001	PVTGPROBE pProbe;
1002	PVTGARG pArg;
1003	RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
1004	{
1005	/* This macro is not available in ring-3 because we don't have
1006	anything similar available for native dtrace. */
1007	ScmStreamPrintf(pStrm, "\n\n");
1008	if (g_fTypeContext != VTG_TYPE_CTX_R3)
1009	{
1010	generateProviderDefineName(szTmp, sizeof(szTmp), pProv->pszName);
1011	ScmStreamPrintf(pStrm,
1012	"extern uint32_t const volatile g_cVTGProviderProbesEnabled_%s;\n"
1013	"# define %s_ANY_PROBES_ENABLED() \\\n"
1014	" (RT_UNLIKELY(g_cVTGProviderProbesEnabled_%s != 0))\n"
1015	"extern uint32_t const volatile g_cVTGProviderSettingsSeqNo_%s;\n"
1016	"# define %s_GET_SETTINGS_SEQ_NO() (g_cVTGProviderSettingsSeqNo_%s)\n"
1017	"\n",
1018	pProv->pszName,
1019	szTmp, pProv->pszName,
1020	pProv->pszName,
1021	szTmp, pProv->pszName);
1022	}
1023
1024	RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
1025	{
1026	ScmStreamPrintf(pStrm,
1027	"extern uint32_t const volatile g_cVTGProbeEnabled_%s_%s;\n"
1028	"extern VTGDESCPROBE g_VTGProbeData_%s_%s;\n"
1029	"DECLASM(void) VTGProbeStub_%s_%s(PVTGPROBELOC",
1030	pProv->pszName, pProbe->pszMangledName,
1031	pProv->pszName, pProbe->pszMangledName,
1032	pProv->pszName, pProbe->pszMangledName);
1033	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1034	{
1035	ScmStreamPrintf(pStrm, ", %s", pArg->pszCtxType);
1036	}
1037	generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
1038	ScmStreamPrintf(pStrm,
1039	");\n"
1040	"# define %s_ENABLED() (RT_UNLIKELY(g_cVTGProbeEnabled_%s_%s != 0))\n"
1041	"# define %s_ENABLED_RAW() (g_cVTGProbeEnabled_%s_%s)\n"
1042	"# define %s("
1043	,
1044	szTmp, pProv->pszName, pProbe->pszMangledName,
1045	szTmp, pProv->pszName, pProbe->pszMangledName,
1046	szTmp);
1047	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1048	{
1049	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1050	ScmStreamPrintf(pStrm, "%s", pArg->pszName);
1051	else
1052	ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
1053	}
1054	ScmStreamPrintf(pStrm,
1055	") \\\n"
1056	" do { \\\n"
1057	" if (RT_UNLIKELY(g_cVTGProbeEnabled_%s_%s)) \\\n"
1058	" { \\\n"
1059	" VTG_DECL_VTGPROBELOC(s_VTGProbeLoc) = \\\n"
1060	" { __LINE__, 0, 0, __FUNCTION__, &g_VTGProbeData_%s_%s }; \\\n"
1061	" VTGProbeStub_%s_%s(&s_VTGProbeLoc",
1062	pProv->pszName, pProbe->pszMangledName,
1063	pProv->pszName, pProbe->pszMangledName,
1064	pProv->pszName, pProbe->pszMangledName);
1065	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1066	{
1067	ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt, pArg->pszName);
1068	}
1069	ScmStreamPrintf(pStrm,
1070	"); \\\n"
1071	" } \\\n"
1072	" { \\\n" );
1073	uint32_t iArg = 0;
1074	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1075	{
1076	if ((pArg->fType & (VTG_TYPE_FIXED_SIZED \| VTG_TYPE_AUTO_CONV_PTR)) == VTG_TYPE_FIXED_SIZED)
1077	ScmStreamPrintf(pStrm,
1078	" AssertCompile(sizeof(%s) == %u); \\\n"
1079	" AssertCompile(sizeof(%s) <= %u); \\\n",
1080	pArg->pszTracerType, pArg->fType & VTG_TYPE_SIZE_MASK,
1081	pArg->pszName, pArg->fType & VTG_TYPE_SIZE_MASK);
1082	else if (pArg->fType & (VTG_TYPE_POINTER \| VTG_TYPE_HC_ARCH_SIZED))
1083	ScmStreamPrintf(pStrm,
1084	" AssertCompile(sizeof(%s) <= sizeof(uintptr_t)); \\\n"
1085	" AssertCompile(sizeof(%s) <= sizeof(uintptr_t)); \\\n",
1086	pArg->pszName,
1087	pArg->pszTracerType);
1088	iArg++;
1089	}
1090	ScmStreamPrintf(pStrm,
1091	" } \\\n"
1092	" } while (0)\n"
1093	"\n");
1094	}
1095	}
1096
1097	ScmStreamPrintf(pStrm,
1098	"\n"
1099	"#else\n"
1100	"\n");
1101	RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
1102	{
1103	if (g_fTypeContext != VTG_TYPE_CTX_R3)
1104	{
1105	generateProviderDefineName(szTmp, sizeof(szTmp), pProv->pszName);
1106	ScmStreamPrintf(pStrm,
1107	"# define %s_ANY_PROBES_ENABLED() (false)\n"
1108	"# define %s_GET_SETTINGS_SEQ_NO() UINT32_C(0)\n"
1109	"\n",
1110	szTmp, szTmp);
1111	}
1112
1113	RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
1114	{
1115	generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
1116	ScmStreamPrintf(pStrm,
1117	"# define %s_ENABLED() (false)\n"
1118	"# define %s_ENABLED_RAW() UINT32_C(0)\n"
1119	"# define %s("
1120	, szTmp, szTmp, szTmp);
1121	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1122	{
1123	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1124	ScmStreamPrintf(pStrm, "%s", pArg->pszName);
1125	else
1126	ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
1127	}
1128	ScmStreamPrintf(pStrm,
1129	") do { } while (0)\n");
1130	}
1131	}
1132
1133	ScmStreamWrite(pStrm, RT_STR_TUPLE("\n"
1134	"#endif\n"
1135	"\n"
1136	"RT_C_DECLS_END\n"
1137	"#endif\n"));
1138	return RTEXITCODE_SUCCESS;
1139	}
1140
1141
1142	/**
1143	* Called via generateFile to generate the wrapper header file.
1144	*
1145	* @returns Exit code status.
1146	* @param pStrm The output stream.
1147	*/
1148	static RTEXITCODE generateWrapperHeader(PSCMSTREAM pStrm)
1149	{
1150	/*
1151	* Calc the double inclusion blocker define and then write the file header.
1152	*/
1153	char szTmp[4096];
1154	const char *pszName = RTPathFilename(g_pszScript);
1155	size_t cchName = strlen(pszName);
1156	if (cchName >= sizeof(szTmp) - 64)
1157	return RTMsgErrorExit(RTEXITCODE_FAILURE, "File name is too long '%s'", pszName);
1158	szTmp[0] = '_';
1159	szTmp[1] = '_';
1160	szTmp[2] = '_';
1161	memcpy(&szTmp[3], pszName, cchName);
1162	strcpy(&szTmp[3 + cchName ], "___WRAPPER___");
1163	char *psz = &szTmp[3];
1164	while (*psz)
1165	{
1166	if (!RT_C_IS_ALNUM(psz) && psz != '_')
1167	*psz = '_';
1168	psz++;
1169	}
1170
1171	ScmStreamPrintf(pStrm,
1172	"/* $Id: VBoxTpG.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */\n"
1173	"/** @file\n"
1174	" * Automatically generated from %s. Do NOT edit!\n"
1175	" */\n"
1176	"\n"
1177	"#ifndef %s\n"
1178	"#define %s\n"
1179	"\n"
1180	"#include <VBox/VBoxTpG.h>\n"
1181	"\n"
1182	"#ifndef %s\n"
1183	"# error \"Expected '%s' to be defined\"\n"
1184	"#endif\n"
1185	"\n"
1186	"#ifdef VBOX_WITH_DTRACE\n"
1187	"\n"
1188	,
1189	g_pszScript,
1190	szTmp,
1191	szTmp,
1192	g_pszContextDefine,
1193	g_pszContextDefine);
1194
1195	/*
1196	* Declare macros for each probe.
1197	*/
1198	PVTGPROVIDER pProv;
1199	PVTGPROBE pProbe;
1200	PVTGARG pArg;
1201	RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
1202	{
1203	RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
1204	{
1205	generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
1206	ScmStreamPrintf(pStrm,
1207	"# define %s("
1208	, szTmp);
1209	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1210	{
1211	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1212	ScmStreamPrintf(pStrm, "%s", pArg->pszName);
1213	else
1214	ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
1215	}
1216	ScmStreamPrintf(pStrm,
1217	") \\\n"
1218	" do { \\\n"
1219	" if (RT_UNLIKELY(%s_ENABLED())) \\\n"
1220	" { \\\n"
1221	" %s_ORIGINAL("
1222	, szTmp, szTmp);
1223	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1224	{
1225	const char *pszFmt = pArg->pszArgPassingFmt;
1226	if (pArg->fType & VTG_TYPE_AUTO_CONV_PTR)
1227	{
1228	/* Casting is required. ASSUMES sizeof(RTR0PTR) == sizeof(RTR3PTR) - safe! */
1229	pszFmt += sizeof(", ") - 1;
1230	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1231	ScmStreamPrintf(pStrm, "(%s)%M", pArg->pszTracerType, pszFmt, pArg->pszName);
1232	else
1233	ScmStreamPrintf(pStrm, ", (%s)%M", pArg->pszTracerType, pszFmt, pArg->pszName);
1234	}
1235	else if (pArg->fType & VTG_TYPE_CONST_CHAR_PTR)
1236	{
1237	/* Casting from 'const char ' (probe) to 'char ' (dtrace) is required to shut up warnings. */
1238	pszFmt += sizeof(", ") - 1;
1239	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1240	ScmStreamPrintf(pStrm, "(char *)%M", pszFmt, pArg->pszName);
1241	else
1242	ScmStreamPrintf(pStrm, ", (char *)%M", pszFmt, pArg->pszName);
1243	}
1244	else
1245	{
1246	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1247	ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt + sizeof(", ") - 1, pArg->pszName);
1248	else
1249	ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt, pArg->pszName);
1250	}
1251	}
1252	ScmStreamPrintf(pStrm,
1253	"); \\\n"
1254	" } \\\n"
1255	" } while (0)\n"
1256	"\n");
1257	}
1258	}
1259
1260	ScmStreamPrintf(pStrm,
1261	"\n"
1262	"#else\n"
1263	"\n");
1264	RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
1265	{
1266	RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)
1267	{
1268	generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);
1269	ScmStreamPrintf(pStrm,
1270	"# define %s("
1271	, szTmp);
1272	RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)
1273	{
1274	if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))
1275	ScmStreamPrintf(pStrm, "%s", pArg->pszName);
1276	else
1277	ScmStreamPrintf(pStrm, ", %s", pArg->pszName);
1278	}
1279	ScmStreamPrintf(pStrm,
1280	") do { } while (0)\n");
1281	}
1282	}
1283
1284	ScmStreamWrite(pStrm, RT_STR_TUPLE("\n"
1285	"#endif\n"
1286	"\n"
1287	"#endif\n"));
1288	return RTEXITCODE_SUCCESS;
1289	}
1290
1291
1292	/**
1293	* Parser error with line and position.
1294	*
1295	* @returns RTEXITCODE_FAILURE.
1296	* @param pStrm The stream.
1297	* @param cb The offset from the current position to the
1298	* point of failure.
1299	* @param pszMsg The message to display.
1300	*/
1301	static RTEXITCODE parseError(PSCMSTREAM pStrm, size_t cb, const char *pszMsg)
1302	{
1303	if (cb)
1304	ScmStreamSeekRelative(pStrm, -(ssize_t)cb);
1305	size_t const off = ScmStreamTell(pStrm);
1306	size_t const iLine = ScmStreamTellLine(pStrm);
1307	ScmStreamSeekByLine(pStrm, iLine);
1308	size_t const offLine = ScmStreamTell(pStrm);
1309
1310	RTPrintf("%s:%d:%zd: error: %s.\n", g_pszScript, iLine + 1, off - offLine + 1, pszMsg);
1311
1312	size_t cchLine;
1313	SCMEOL enmEof;
1314	const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);
1315	if (pszLine)
1316	RTPrintf(" %.*s\n"
1317	" %*s^\n",
1318	cchLine, pszLine, off - offLine, "");
1319	return RTEXITCODE_FAILURE;
1320	}
1321
1322
1323	/**
1324	* Parser error with line and position.
1325	*
1326	* @returns RTEXITCODE_FAILURE.
1327	* @param pStrm The stream.
1328	* @param cb The offset from the current position to the
1329	* point of failure.
1330	* @param pszMsg The message to display.
1331	*/
1332	static RTEXITCODE parseErrorAbs(PSCMSTREAM pStrm, size_t off, const char *pszMsg)
1333	{
1334	ScmStreamSeekAbsolute(pStrm, off);
1335	return parseError(pStrm, 0, pszMsg);
1336	}
1337
1338
1339	/**
1340	* Handles a C++ one line comment.
1341	*
1342	* @returns Exit code.
1343	* @param pStrm The stream.
1344	*/
1345	static RTEXITCODE parseOneLineComment(PSCMSTREAM pStrm)
1346	{
1347	ScmStreamSeekByLine(pStrm, ScmStreamTellLine(pStrm) + 1);
1348	return RTEXITCODE_SUCCESS;
1349	}
1350
1351
1352	/**
1353	* Handles a multi-line C/C++ comment.
1354	*
1355	* @returns Exit code.
1356	* @param pStrm The stream.
1357	*/
1358	static RTEXITCODE parseMultiLineComment(PSCMSTREAM pStrm)
1359	{
1360	unsigned ch;
1361	while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)
1362	{
1363	if (ch == '*')
1364	{
1365	do
1366	ch = ScmStreamGetCh(pStrm);
1367	while (ch == '*');
1368	if (ch == '/')
1369	return RTEXITCODE_SUCCESS;
1370	}
1371	}
1372
1373	parseError(pStrm, 1, "Expected end of comment, got end of file");
1374	return RTEXITCODE_FAILURE;
1375	}
1376
1377
1378	/**
1379	* Skips spaces and comments.
1380	*
1381	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE.
1382	* @param pStrm The stream..
1383	*/
1384	static RTEXITCODE parseSkipSpacesAndComments(PSCMSTREAM pStrm)
1385	{
1386	unsigned ch;
1387	while ((ch = ScmStreamPeekCh(pStrm)) != ~(unsigned)0)
1388	{
1389	if (!RT_C_IS_SPACE(ch) && ch != '/')
1390	return RTEXITCODE_SUCCESS;
1391	unsigned ch2 = ScmStreamGetCh(pStrm); AssertBreak(ch == ch2); NOREF(ch2);
1392	if (ch == '/')
1393	{
1394	ch = ScmStreamGetCh(pStrm);
1395	RTEXITCODE rcExit;
1396	if (ch == '*')
1397	rcExit = parseMultiLineComment(pStrm);
1398	else if (ch == '/')
1399	rcExit = parseOneLineComment(pStrm);
1400	else
1401	rcExit = parseError(pStrm, 2, "Unexpected character");
1402	if (rcExit != RTEXITCODE_SUCCESS)
1403	return rcExit;
1404	}
1405	}
1406
1407	return parseError(pStrm, 0, "Unexpected end of file");
1408	}
1409
1410
1411	/**
1412	* Skips spaces and comments, returning the next character.
1413	*
1414	* @returns Next non-space-non-comment character. ~(unsigned)0 on EOF or
1415	* failure.
1416	* @param pStrm The stream.
1417	*/
1418	static unsigned parseGetNextNonSpaceNonCommentCh(PSCMSTREAM pStrm)
1419	{
1420	unsigned ch;
1421	while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)
1422	{
1423	if (!RT_C_IS_SPACE(ch) && ch != '/')
1424	return ch;
1425	if (ch == '/')
1426	{
1427	ch = ScmStreamGetCh(pStrm);
1428	RTEXITCODE rcExit;
1429	if (ch == '*')
1430	rcExit = parseMultiLineComment(pStrm);
1431	else if (ch == '/')
1432	rcExit = parseOneLineComment(pStrm);
1433	else
1434	rcExit = parseError(pStrm, 2, "Unexpected character");
1435	if (rcExit != RTEXITCODE_SUCCESS)
1436	return ~(unsigned)0;
1437	}
1438	}
1439
1440	parseError(pStrm, 0, "Unexpected end of file");
1441	return ~(unsigned)0;
1442	}
1443
1444
1445	/**
1446	* Get the next non-space-non-comment character on a preprocessor line.
1447	*
1448	* @returns The next character. On error message and ~(unsigned)0.
1449	* @param pStrm The stream.
1450	*/
1451	static unsigned parseGetNextNonSpaceNonCommentChOnPpLine(PSCMSTREAM pStrm)
1452	{
1453	size_t off = ScmStreamTell(pStrm) - 1;
1454	unsigned ch;
1455	while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)
1456	{
1457	if (RT_C_IS_SPACE(ch))
1458	{
1459	if (ch == '\n' \|\| ch == '\r')
1460	{
1461	parseErrorAbs(pStrm, off, "Invalid preprocessor statement");
1462	break;
1463	}
1464	}
1465	else if (ch == '\\')
1466	{
1467	size_t off2 = ScmStreamTell(pStrm) - 1;
1468	ch = ScmStreamGetCh(pStrm);
1469	if (ch == '\r')
1470	ch = ScmStreamGetCh(pStrm);
1471	if (ch != '\n')
1472	{
1473	parseErrorAbs(pStrm, off2, "Expected new line");
1474	break;
1475	}
1476	}
1477	else
1478	return ch;
1479	}
1480	return ~(unsigned)0;
1481	}
1482
1483
1484
1485	/**
1486	* Skips spaces and comments.
1487	*
1488	* @returns Same as ScmStreamCGetWord
1489	* @param pStrm The stream..
1490	* @param pcchWord Where to return the length.
1491	*/
1492	static const char parseGetNextCWord(PSCMSTREAM pStrm, size_t pcchWord)
1493	{
1494	if (parseSkipSpacesAndComments(pStrm) != RTEXITCODE_SUCCESS)
1495	return NULL;
1496	return ScmStreamCGetWord(pStrm, pcchWord);
1497	}
1498
1499
1500
1501	/**
1502	* Parses interface stability.
1503	*
1504	* @returns Interface stability if parsed correctly, otherwise error message and
1505	* kVTGStability_Invalid.
1506	* @param pStrm The stream.
1507	* @param ch The first character in the stability spec.
1508	*/
1509	static kVTGStability parseStability(PSCMSTREAM pStrm, unsigned ch)
1510	{
1511	switch (ch)
1512	{
1513	case 'E':
1514	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("External")))
1515	return kVTGStability_External;
1516	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Evolving")))
1517	return kVTGStability_Evolving;
1518	break;
1519	case 'I':
1520	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Internal")))
1521	return kVTGStability_Internal;
1522	break;
1523	case 'O':
1524	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Obsolete")))
1525	return kVTGStability_Obsolete;
1526	break;
1527	case 'P':
1528	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Private")))
1529	return kVTGStability_Private;
1530	break;
1531	case 'S':
1532	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Stable")))
1533	return kVTGStability_Stable;
1534	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Standard")))
1535	return kVTGStability_Standard;
1536	break;
1537	case 'U':
1538	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Unstable")))
1539	return kVTGStability_Unstable;
1540	break;
1541	}
1542	parseError(pStrm, 1, "Unknown stability specifier");
1543	return kVTGStability_Invalid;
1544	}
1545
1546
1547	/**
1548	* Parses data depndency class.
1549	*
1550	* @returns Data dependency class if parsed correctly, otherwise error message
1551	* and kVTGClass_Invalid.
1552	* @param pStrm The stream.
1553	* @param ch The first character in the stability spec.
1554	*/
1555	static kVTGClass parseDataDepClass(PSCMSTREAM pStrm, unsigned ch)
1556	{
1557	switch (ch)
1558	{
1559	case 'C':
1560	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Common")))
1561	return kVTGClass_Common;
1562	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Cpu")))
1563	return kVTGClass_Cpu;
1564	break;
1565	case 'G':
1566	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Group")))
1567	return kVTGClass_Group;
1568	break;
1569	case 'I':
1570	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Isa")))
1571	return kVTGClass_Isa;
1572	break;
1573	case 'P':
1574	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Platform")))
1575	return kVTGClass_Platform;
1576	break;
1577	case 'U':
1578	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Unknown")))
1579	return kVTGClass_Unknown;
1580	break;
1581	}
1582	parseError(pStrm, 1, "Unknown data dependency class specifier");
1583	return kVTGClass_Invalid;
1584	}
1585
1586	/**
1587	* Parses a pragma D attributes statement.
1588	*
1589	* @returns Suitable exit code, errors message already written on failure.
1590	* @param pStrm The stream.
1591	*/
1592	static RTEXITCODE parsePragmaDAttributes(PSCMSTREAM pStrm)
1593	{
1594	/*
1595	* "CodeStability/DataStability/DataDepClass" - no spaces allowed.
1596	*/
1597	unsigned ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
1598	if (ch == ~(unsigned)0)
1599	return RTEXITCODE_FAILURE;
1600
1601	kVTGStability enmCode = parseStability(pStrm, ch);
1602	if (enmCode == kVTGStability_Invalid)
1603	return RTEXITCODE_FAILURE;
1604	ch = ScmStreamGetCh(pStrm);
1605	if (ch != '/')
1606	return parseError(pStrm, 1, "Expected '/' following the code stability specifier");
1607
1608	kVTGStability enmData = parseStability(pStrm, ScmStreamGetCh(pStrm));
1609	if (enmData == kVTGStability_Invalid)
1610	return RTEXITCODE_FAILURE;
1611	ch = ScmStreamGetCh(pStrm);
1612	if (ch != '/')
1613	return parseError(pStrm, 1, "Expected '/' following the data stability specifier");
1614
1615	kVTGClass enmDataDep = parseDataDepClass(pStrm, ScmStreamGetCh(pStrm));
1616	if (enmDataDep == kVTGClass_Invalid)
1617	return RTEXITCODE_FAILURE;
1618
1619	/*
1620	* Expecting 'provider' followed by the name of an provider defined earlier.
1621	*/
1622	ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
1623	if (ch == ~(unsigned)0)
1624	return RTEXITCODE_FAILURE;
1625	if (ch != 'p' \|\| !ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("provider")))
1626	return parseError(pStrm, 1, "Expected 'provider'");
1627
1628	size_t cchName;
1629	const char *pszName = parseGetNextCWord(pStrm, &cchName);
1630	if (!pszName)
1631	return parseError(pStrm, 1, "Expected provider name");
1632
1633	PVTGPROVIDER pProv;
1634	RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)
1635	{
1636	if ( !strncmp(pProv->pszName, pszName, cchName)
1637	&& pProv->pszName[cchName] == '\0')
1638	break;
1639	}
1640	if (RTListNodeIsDummy(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry))
1641	return parseError(pStrm, cchName, "Provider not found");
1642
1643	/*
1644	* Which aspect of the provider?
1645	*/
1646	size_t cchAspect;
1647	const char *pszAspect = parseGetNextCWord(pStrm, &cchAspect);
1648	if (!pszAspect)
1649	return parseError(pStrm, 1, "Expected provider aspect");
1650
1651	PVTGATTRS pAttrs;
1652	if (cchAspect == 8 && !memcmp(pszAspect, "provider", 8))
1653	pAttrs = &pProv->AttrSelf;
1654	else if (cchAspect == 8 && !memcmp(pszAspect, "function", 8))
1655	pAttrs = &pProv->AttrFunctions;
1656	else if (cchAspect == 6 && !memcmp(pszAspect, "module", 6))
1657	pAttrs = &pProv->AttrModules;
1658	else if (cchAspect == 4 && !memcmp(pszAspect, "name", 4))
1659	pAttrs = &pProv->AttrName;
1660	else if (cchAspect == 4 && !memcmp(pszAspect, "args", 4))
1661	pAttrs = &pProv->AttrArguments;
1662	else
1663	return parseError(pStrm, cchAspect, "Unknown aspect");
1664
1665	if (pAttrs->enmCode != kVTGStability_Invalid)
1666	return parseError(pStrm, cchAspect, "You have already specified these attributes");
1667
1668	pAttrs->enmCode = enmCode;
1669	pAttrs->enmData = enmData;
1670	pAttrs->enmDataDep = enmDataDep;
1671	return RTEXITCODE_SUCCESS;
1672	}
1673
1674	/**
1675	* Parses a D pragma statement.
1676	*
1677	* @returns Suitable exit code, errors message already written on failure.
1678	* @param pStrm The stream.
1679	*/
1680	static RTEXITCODE parsePragma(PSCMSTREAM pStrm)
1681	{
1682	RTEXITCODE rcExit;
1683	unsigned ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
1684	if (ch == ~(unsigned)0)
1685	rcExit = RTEXITCODE_FAILURE;
1686	else if (ch == 'D' && ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("D")))
1687	{
1688	ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);
1689	if (ch == ~(unsigned)0)
1690	rcExit = RTEXITCODE_FAILURE;
1691	else if (ch == 'a' && ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("attributes")))
1692	rcExit = parsePragmaDAttributes(pStrm);
1693	else
1694	rcExit = parseError(pStrm, 1, "Unknown pragma D");
1695	}
1696	else
1697	rcExit = parseError(pStrm, 1, "Unknown pragma");
1698	return rcExit;
1699	}
1700
1701
1702	/**
1703	* Classifies the given type expression.
1704	*
1705	* @return Type flags.
1706	* @param pszType The type expression.
1707	*/
1708	static uint32_t parseTypeExpression(const char *pszType)
1709	{
1710	size_t cchType = strlen(pszType);
1711	#define MY_STRMATCH(a_sz) (cchType == sizeof(a_sz) - 1 && !memcmp(a_sz, pszType, sizeof(a_sz) - 1))
1712
1713	/*
1714	* Try detect pointers.
1715	*/
1716	if (pszType[cchType - 1] == '*')
1717	{
1718	if (MY_STRMATCH("const char *")) return VTG_TYPE_POINTER \| VTG_TYPE_CONST_CHAR_PTR;
1719	return VTG_TYPE_POINTER;
1720	}
1721	if (pszType[cchType - 1] == '&')
1722	{
1723	RTMsgWarning("Please avoid using references like '%s' for probe arguments!", pszType);
1724	return VTG_TYPE_POINTER;
1725	}
1726
1727	/*
1728	* Standard integer types and IPRT variants.
1729	* It's important that we catch all types larger than 32-bit here or we'll
1730	* screw up the probe argument handling.
1731	*/
1732	if (MY_STRMATCH("int")) return VTG_TYPE_FIXED_SIZED \| sizeof(int) \| VTG_TYPE_SIGNED;
1733	if (MY_STRMATCH("uintptr_t")) return VTG_TYPE_HC_ARCH_SIZED \| VTG_TYPE_UNSIGNED;
1734	if (MY_STRMATCH("intptr_t")) return VTG_TYPE_HC_ARCH_SIZED \| VTG_TYPE_SIGNED;
1735
1736	//if (MY_STRMATCH("uint128_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint128_t) \| VTG_TYPE_UNSIGNED;
1737	if (MY_STRMATCH("uint64_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint64_t) \| VTG_TYPE_UNSIGNED;
1738	if (MY_STRMATCH("uint32_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint32_t) \| VTG_TYPE_UNSIGNED;
1739	if (MY_STRMATCH("uint16_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint16_t) \| VTG_TYPE_UNSIGNED;
1740	if (MY_STRMATCH("uint8_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint8_t) \| VTG_TYPE_UNSIGNED;
1741
1742	//if (MY_STRMATCH("int128_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(int128_t) \| VTG_TYPE_SIGNED;
1743	if (MY_STRMATCH("int64_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(int64_t) \| VTG_TYPE_SIGNED;
1744	if (MY_STRMATCH("int32_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(int32_t) \| VTG_TYPE_SIGNED;
1745	if (MY_STRMATCH("int16_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(int16_t) \| VTG_TYPE_SIGNED;
1746	if (MY_STRMATCH("int8_t")) return VTG_TYPE_FIXED_SIZED \| sizeof(int8_t) \| VTG_TYPE_SIGNED;
1747
1748	if (MY_STRMATCH("RTUINT64U")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint64_t) \| VTG_TYPE_UNSIGNED;
1749	if (MY_STRMATCH("RTUINT32U")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint32_t) \| VTG_TYPE_UNSIGNED;
1750	if (MY_STRMATCH("RTUINT16U")) return VTG_TYPE_FIXED_SIZED \| sizeof(uint16_t) \| VTG_TYPE_UNSIGNED;
1751
1752	if (MY_STRMATCH("RTMSINTERVAL")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTMSINTERVAL) \| VTG_TYPE_UNSIGNED;
1753	if (MY_STRMATCH("RTTIMESPEC")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTTIMESPEC) \| VTG_TYPE_SIGNED;
1754	if (MY_STRMATCH("RTPROCESS")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTPROCESS) \| VTG_TYPE_UNSIGNED;
1755	if (MY_STRMATCH("RTHCPHYS")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTHCPHYS) \| VTG_TYPE_UNSIGNED \| VTG_TYPE_PHYS;
1756
1757	if (MY_STRMATCH("RTR3PTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3;
1758	if (MY_STRMATCH("RTR0PTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R0;
1759	if (MY_STRMATCH("RTRCPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_RC;
1760	if (MY_STRMATCH("RTHCPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_CTX_R0;
1761
1762	if (MY_STRMATCH("RTR3UINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_UNSIGNED;
1763	if (MY_STRMATCH("RTR0UINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R0 \| VTG_TYPE_UNSIGNED;
1764	if (MY_STRMATCH("RTRCUINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_RC \| VTG_TYPE_UNSIGNED;
1765	if (MY_STRMATCH("RTHCUINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_CTX_R0 \| VTG_TYPE_UNSIGNED;
1766
1767	if (MY_STRMATCH("RTR3INTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_SIGNED;
1768	if (MY_STRMATCH("RTR0INTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R0 \| VTG_TYPE_SIGNED;
1769	if (MY_STRMATCH("RTRCINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_RC \| VTG_TYPE_SIGNED;
1770	if (MY_STRMATCH("RTHCINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_CTX_R0 \| VTG_TYPE_SIGNED;
1771
1772	if (MY_STRMATCH("RTUINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_CTX_R0 \| VTG_TYPE_CTX_RC \| VTG_TYPE_UNSIGNED;
1773	if (MY_STRMATCH("RTINTPTR")) return VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R3 \| VTG_TYPE_CTX_R0 \| VTG_TYPE_CTX_RC \| VTG_TYPE_SIGNED;
1774
1775	if (MY_STRMATCH("RTHCUINTREG")) return VTG_TYPE_HC_ARCH_SIZED \| VTG_TYPE_CTX_R3 \| VTG_TYPE_CTX_R0 \| VTG_TYPE_UNSIGNED;
1776	if (MY_STRMATCH("RTR3UINTREG")) return VTG_TYPE_HC_ARCH_SIZED \| VTG_TYPE_CTX_R3 \| VTG_TYPE_UNSIGNED;
1777	if (MY_STRMATCH("RTR0UINTREG")) return VTG_TYPE_HC_ARCH_SIZED \| VTG_TYPE_CTX_R3 \| VTG_TYPE_UNSIGNED;
1778
1779	if (MY_STRMATCH("RTGCUINTREG")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCUINTREG) \| VTG_TYPE_UNSIGNED \| VTG_TYPE_CTX_GST;
1780	if (MY_STRMATCH("RTGCPTR")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCPTR) \| VTG_TYPE_UNSIGNED \| VTG_TYPE_CTX_GST;
1781	if (MY_STRMATCH("RTGCINTPTR")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCUINTPTR) \| VTG_TYPE_SIGNED \| VTG_TYPE_CTX_GST;
1782	if (MY_STRMATCH("RTGCPTR32")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCPTR32) \| VTG_TYPE_SIGNED \| VTG_TYPE_CTX_GST;
1783	if (MY_STRMATCH("RTGCPTR64")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCPTR64) \| VTG_TYPE_SIGNED \| VTG_TYPE_CTX_GST;
1784	if (MY_STRMATCH("RTGCPHYS")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCPHYS) \| VTG_TYPE_UNSIGNED \| VTG_TYPE_PHYS \| VTG_TYPE_CTX_GST;
1785	if (MY_STRMATCH("RTGCPHYS32")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCPHYS32) \| VTG_TYPE_UNSIGNED \| VTG_TYPE_PHYS \| VTG_TYPE_CTX_GST;
1786	if (MY_STRMATCH("RTGCPHYS64")) return VTG_TYPE_FIXED_SIZED \| sizeof(RTGCPHYS64) \| VTG_TYPE_UNSIGNED \| VTG_TYPE_PHYS \| VTG_TYPE_CTX_GST;
1787
1788	/*
1789	* The special VBox types.
1790	*/
1791	if (MY_STRMATCH("PVM")) return VTG_TYPE_POINTER;
1792	if (MY_STRMATCH("PVMCPU")) return VTG_TYPE_POINTER;
1793	if (MY_STRMATCH("PCPUMCTX")) return VTG_TYPE_POINTER;
1794
1795	/*
1796	* Preaching time.
1797	*/
1798	if ( MY_STRMATCH("unsigned long")
1799	\|\| MY_STRMATCH("unsigned long long")
1800	\|\| MY_STRMATCH("signed long")
1801	\|\| MY_STRMATCH("signed long long")
1802	\|\| MY_STRMATCH("long")
1803	\|\| MY_STRMATCH("long long")
1804	\|\| MY_STRMATCH("char")
1805	\|\| MY_STRMATCH("signed char")
1806	\|\| MY_STRMATCH("unsigned char")
1807	\|\| MY_STRMATCH("double")
1808	\|\| MY_STRMATCH("long double")
1809	\|\| MY_STRMATCH("float")
1810	)
1811	{
1812	RTMsgError("Please do NOT use the type '%s' for probe arguments!", pszType);
1813	g_cTypeErrors++;
1814	return 0;
1815	}
1816
1817	if ( MY_STRMATCH("unsigned")
1818	\|\| MY_STRMATCH("signed")
1819	\|\| MY_STRMATCH("signed int")
1820	\|\| MY_STRMATCH("unsigned int")
1821	\|\| MY_STRMATCH("short")
1822	\|\| MY_STRMATCH("signed short")
1823	\|\| MY_STRMATCH("unsigned short")
1824	)
1825	RTMsgWarning("Please avoid using the type '%s' for probe arguments!", pszType);
1826	if (MY_STRMATCH("unsigned")) return VTG_TYPE_FIXED_SIZED \| sizeof(int) \| VTG_TYPE_UNSIGNED;
1827	if (MY_STRMATCH("unsigned int")) return VTG_TYPE_FIXED_SIZED \| sizeof(int) \| VTG_TYPE_UNSIGNED;
1828	if (MY_STRMATCH("signed")) return VTG_TYPE_FIXED_SIZED \| sizeof(int) \| VTG_TYPE_SIGNED;
1829	if (MY_STRMATCH("signed int")) return VTG_TYPE_FIXED_SIZED \| sizeof(int) \| VTG_TYPE_SIGNED;
1830	if (MY_STRMATCH("short")) return VTG_TYPE_FIXED_SIZED \| sizeof(short) \| VTG_TYPE_SIGNED;
1831	if (MY_STRMATCH("signed short")) return VTG_TYPE_FIXED_SIZED \| sizeof(short) \| VTG_TYPE_SIGNED;
1832	if (MY_STRMATCH("unsigned short")) return VTG_TYPE_FIXED_SIZED \| sizeof(short) \| VTG_TYPE_UNSIGNED;
1833
1834	/*
1835	* What we haven't caught by now is either unknown to us or wrong.
1836	*/
1837	if (pszType[0] == 'P')
1838	{
1839	RTMsgError("Type '%s' looks like a pointer typedef, please do NOT use those "
1840	"but rather the non-pointer typedef or struct with '*'",
1841	pszType);
1842	g_cTypeErrors++;
1843	return VTG_TYPE_POINTER;
1844	}
1845
1846	RTMsgError("Don't know '%s' - please change or fix VBoxTpG", pszType);
1847	g_cTypeErrors++;
1848
1849	#undef MY_STRCMP
1850	return 0;
1851	}
1852
1853
1854	/**
1855	* Initializes the members of an argument.
1856	*
1857	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1858	* @param pProbe The probe.
1859	* @param pArg The argument.
1860	* @param pStrm The input stream (for errors).
1861	* @param pchType The type.
1862	* @param cchType The type length.
1863	* @param pchName The name.
1864	* @param cchName The name length.
1865	*/
1866	static RTEXITCODE parseInitArgument(PVTGPROBE pProbe, PVTGARG pArg, PSCMSTREAM pStrm,
1867	char pchType, size_t cchType, char pchName, size_t cchName)
1868	{
1869	Assert(!pArg->pszName); Assert(!pArg->pszTracerType); Assert(!pArg->pszCtxType); Assert(!pArg->fType);
1870
1871	pArg->pszArgPassingFmt = ", %s";
1872	pArg->pszName = RTStrDupN(pchName, cchName);
1873	pArg->pszTracerType = strtabInsertN(pchType, cchType);
1874	if (!pArg->pszTracerType \|\| !pArg->pszName)
1875	return parseError(pStrm, 1, "Out of memory");
1876	pArg->fType = parseTypeExpression(pArg->pszTracerType);
1877
1878	if ( (pArg->fType & VTG_TYPE_POINTER)
1879	&& !(g_fTypeContext & VTG_TYPE_CTX_R0) )
1880	{
1881	pArg->fType &= ~VTG_TYPE_POINTER;
1882	if ( !strcmp(pArg->pszTracerType, "struct VM *") \|\| !strcmp(pArg->pszTracerType, "PVM")
1883	\|\| !strcmp(pArg->pszTracerType, "struct VMCPU *") \|\| !strcmp(pArg->pszTracerType, "PVMCPU")
1884	\|\| !strcmp(pArg->pszTracerType, "struct CPUMCTX *") \|\| !strcmp(pArg->pszTracerType, "PCPUMCTX")
1885	)
1886	{
1887	pArg->fType \|= VTG_TYPE_CTX_POINTER \| VTG_TYPE_CTX_R0
1888	\| VTG_TYPE_FIXED_SIZED \| (g_cHostBits / 8)
1889	\| VTG_TYPE_AUTO_CONV_PTR;
1890	pArg->pszCtxType = RTStrDup("RTR0PTR");
1891
1892	if (!strcmp(pArg->pszTracerType, "struct VM *") \|\| !strcmp(pArg->pszTracerType, "PVM"))
1893	pArg->pszArgPassingFmt = ", VTG_VM_TO_R0(%s)";
1894	else if (!strcmp(pArg->pszTracerType, "struct VMCPU *") \|\| !strcmp(pArg->pszTracerType, "PVMCPU"))
1895	pArg->pszArgPassingFmt = ", VTG_VMCPU_TO_R0(%s)";
1896	else
1897	{
1898	PVTGARG pFirstArg = RTListGetFirst(&pProbe->ArgHead, VTGARG, ListEntry);
1899	if ( !pFirstArg
1900	\|\| pFirstArg == pArg
1901	\|\| strcmp(pFirstArg->pszName, "a_pVCpu")
1902	\|\| ( strcmp(pFirstArg->pszTracerType, "struct VMCPU *")
1903	&& strcmp(pFirstArg->pszTracerType, "PVMCPU *")) )
1904	return parseError(pStrm, 1, "The automatic ring-0 pointer conversion requires 'a_pVCpu' with type 'struct VMCPU *' as the first argument");
1905
1906	if (!strcmp(pArg->pszTracerType, "struct CPUMCTX *")\|\| !strcmp(pArg->pszTracerType, "PCPUMCTX"))
1907	pArg->pszArgPassingFmt = ", VTG_CPUMCTX_TO_R0(a_pVCpu, %s)";
1908	else
1909	pArg->pszArgPassingFmt = ", VBoxTpG-Is-Buggy!!";
1910	}
1911	}
1912	else
1913	{
1914	pArg->fType \|= VTG_TYPE_CTX_POINTER \| g_fTypeContext \| VTG_TYPE_FIXED_SIZED \| (g_cBits / 8);
1915	pArg->pszCtxType = RTStrDupN(pchType, cchType);
1916	}
1917	}
1918	else
1919	pArg->pszCtxType = RTStrDupN(pchType, cchType);
1920	if (!pArg->pszCtxType)
1921	return parseError(pStrm, 1, "Out of memory");
1922
1923	return RTEXITCODE_SUCCESS;
1924	}
1925
1926
1927	/**
1928	* Unmangles the probe name.
1929	*
1930	* This involves translating double underscore to dash.
1931	*
1932	* @returns Pointer to the unmangled name in the string table.
1933	* @param pszMangled The mangled name.
1934	*/
1935	static const char parseUnmangleProbeName(const char pszMangled)
1936	{
1937	size_t cchMangled = strlen(pszMangled);
1938	char pszTmp = (char )alloca(cchMangled + 2);
1939	const char *pszSrc = pszMangled;
1940	char *pszDst = pszTmp;
1941
1942	while (*pszSrc)
1943	{
1944	if (pszSrc[0] == '_' && pszSrc[1] == '_' && pszSrc[2] != '_')
1945	{
1946	*pszDst++ = '-';
1947	pszSrc += 2;
1948	}
1949	else
1950	pszDst++ = pszSrc++;
1951	}
1952	*pszDst = '\0';
1953
1954	return strtabInsertN(pszTmp, pszDst - pszTmp);
1955	}
1956
1957
1958	/**
1959	* Parses a D probe statement.
1960	*
1961	* @returns Suitable exit code, errors message already written on failure.
1962	* @param pStrm The stream.
1963	* @param pProv The provider being parsed.
1964	*/
1965	static RTEXITCODE parseProbe(PSCMSTREAM pStrm, PVTGPROVIDER pProv)
1966	{
1967	/*
1968	* Next up is a name followed by an opening parenthesis.
1969	*/
1970	size_t cchProbe;
1971	const char *pszProbe = parseGetNextCWord(pStrm, &cchProbe);
1972	if (!pszProbe)
1973	return parseError(pStrm, 1, "Expected a probe name starting with an alphabetical character");
1974	unsigned ch = parseGetNextNonSpaceNonCommentCh(pStrm);
1975	if (ch != '(')
1976	return parseError(pStrm, 1, "Expected '(' after the probe name");
1977
1978	/*
1979	* Create a probe instance.
1980	*/
1981	PVTGPROBE pProbe = (PVTGPROBE)RTMemAllocZ(sizeof(*pProbe));
1982	if (!pProbe)
1983	return parseError(pStrm, 0, "Out of memory");
1984	RTListInit(&pProbe->ArgHead);
1985	RTListAppend(&pProv->ProbeHead, &pProbe->ListEntry);
1986	pProbe->offArgList = UINT32_MAX;
1987	pProbe->pszMangledName = RTStrDupN(pszProbe, cchProbe);
1988	if (!pProbe->pszMangledName)
1989	return parseError(pStrm, 0, "Out of memory");
1990	pProbe->pszUnmangledName = parseUnmangleProbeName(pProbe->pszMangledName);
1991	if (!pProbe->pszUnmangledName)
1992	return parseError(pStrm, 0, "Out of memory");
1993
1994	/*
1995	* Parse loop for the argument.
1996	*/
1997	PVTGARG pArg = NULL;
1998	size_t cchName = 0;
1999	size_t cchArg = 0;
2000	char szArg[4096];
2001	for (;;)
2002	{
2003	ch = parseGetNextNonSpaceNonCommentCh(pStrm);
2004	switch (ch)
2005	{
2006	case ')':
2007	case ',':
2008	{
2009	/* commit the argument */
2010	if (pArg)
2011	{
2012	if (!cchName)
2013	return parseError(pStrm, 1, "Argument has no name");
2014	if (cchArg - cchName - 1 >= 128)
2015	return parseError(pStrm, 1, "Argument type too long");
2016	RTEXITCODE rcExit = parseInitArgument(pProbe, pArg, pStrm,
2017	szArg, cchArg - cchName - 1,
2018	&szArg[cchArg - cchName], cchName);
2019	if (rcExit != RTEXITCODE_SUCCESS)
2020	return rcExit;
2021	if (VTG_TYPE_IS_LARGE(pArg->fType))
2022	pProbe->fHaveLargeArgs = true;
2023	pArg = NULL;
2024	cchName = cchArg = 0;
2025	}
2026	if (ch == ')')
2027	{
2028	size_t off = ScmStreamTell(pStrm);
2029	ch = parseGetNextNonSpaceNonCommentCh(pStrm);
2030	if (ch != ';')
2031	return parseErrorAbs(pStrm, off, "Expected ';'");
2032	return RTEXITCODE_SUCCESS;
2033	}
2034	break;
2035	}
2036
2037	default:
2038	{
2039	size_t cchWord;
2040	const char *pszWord = ScmStreamCGetWordM1(pStrm, &cchWord);
2041	if (!pszWord)
2042	return parseError(pStrm, 0, "Expected argument");
2043	if (!pArg)
2044	{
2045	pArg = (PVTGARG)RTMemAllocZ(sizeof(*pArg));
2046	if (!pArg)
2047	return parseError(pStrm, 1, "Out of memory");
2048	RTListAppend(&pProbe->ArgHead, &pArg->ListEntry);
2049	pProbe->cArgs++;
2050
2051	if (cchWord + 1 > sizeof(szArg))
2052	return parseError(pStrm, 1, "Too long parameter declaration");
2053	memcpy(szArg, pszWord, cchWord);
2054	szArg[cchWord] = '\0';
2055	cchArg = cchWord;
2056	cchName = 0;
2057	}
2058	else
2059	{
2060	if (cchArg + 1 + cchWord + 1 > sizeof(szArg))
2061	return parseError(pStrm, 1, "Too long parameter declaration");
2062
2063	szArg[cchArg++] = ' ';
2064	memcpy(&szArg[cchArg], pszWord, cchWord);
2065	cchArg += cchWord;
2066	szArg[cchArg] = '\0';
2067	cchName = cchWord;
2068	}
2069	break;
2070	}
2071
2072	case '*':
2073	{
2074	if (!pArg)
2075	return parseError(pStrm, 1, "A parameter type does not start with an asterix");
2076	if (cchArg + sizeof(" *") >= sizeof(szArg))
2077	return parseError(pStrm, 1, "Too long parameter declaration");
2078	szArg[cchArg++] = ' ';
2079	szArg[cchArg++] = '*';
2080	szArg[cchArg ] = '\0';
2081	cchName = 0;
2082	break;
2083	}
2084
2085	case ~(unsigned)0:
2086	return parseError(pStrm, 0, "Missing closing ')' on probe");
2087	}
2088	}
2089	}
2090
2091	/**
2092	* Parses a D provider statement.
2093	*
2094	* @returns Suitable exit code, errors message already written on failure.
2095	* @param pStrm The stream.
2096	*/
2097	static RTEXITCODE parseProvider(PSCMSTREAM pStrm)
2098	{
2099	/*
2100	* Next up is a name followed by a curly bracket. Ignore comments.
2101	*/
2102	RTEXITCODE rcExit = parseSkipSpacesAndComments(pStrm);
2103	if (rcExit != RTEXITCODE_SUCCESS)
2104	return parseError(pStrm, 1, "Expected a provider name starting with an alphabetical character");
2105	size_t cchName;
2106	const char *pszName = ScmStreamCGetWord(pStrm, &cchName);
2107	if (!pszName)
2108	return parseError(pStrm, 0, "Bad provider name");
2109	if (RT_C_IS_DIGIT(pszName[cchName - 1]))
2110	return parseError(pStrm, 1, "A provider name cannot end with digit");
2111
2112	unsigned ch = parseGetNextNonSpaceNonCommentCh(pStrm);
2113	if (ch != '{')
2114	return parseError(pStrm, 1, "Expected '{' after the provider name");
2115
2116	/*
2117	* Create a provider instance.
2118	*/
2119	PVTGPROVIDER pProv = (PVTGPROVIDER)RTMemAllocZ(sizeof(*pProv));
2120	if (!pProv)
2121	return parseError(pStrm, 0, "Out of memory");
2122	RTListInit(&pProv->ProbeHead);
2123	RTListAppend(&g_ProviderHead, &pProv->ListEntry);
2124	pProv->pszName = strtabInsertN(pszName, cchName);
2125	if (!pProv->pszName)
2126	return parseError(pStrm, 0, "Out of memory");
2127
2128	/*
2129	* Parse loop.
2130	*/
2131	for (;;)
2132	{
2133	ch = parseGetNextNonSpaceNonCommentCh(pStrm);
2134	switch (ch)
2135	{
2136	case 'p':
2137	if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("probe")))
2138	rcExit = parseProbe(pStrm, pProv);
2139	else
2140	rcExit = parseError(pStrm, 1, "Unexpected character");
2141	break;
2142
2143	case '}':
2144	{
2145	size_t off = ScmStreamTell(pStrm);
2146	ch = parseGetNextNonSpaceNonCommentCh(pStrm);
2147	if (ch == ';')
2148	return RTEXITCODE_SUCCESS;
2149	rcExit = parseErrorAbs(pStrm, off, "Expected ';'");
2150	break;
2151	}
2152
2153	case ~(unsigned)0:
2154	rcExit = parseError(pStrm, 0, "Missing closing '}' on provider");
2155	break;
2156
2157	default:
2158	rcExit = parseError(pStrm, 1, "Unexpected character");
2159	break;
2160	}
2161	if (rcExit != RTEXITCODE_SUCCESS)
2162	return rcExit;
2163	}
2164	}
2165
2166
2167	static RTEXITCODE parseScript(const char *pszScript)
2168	{
2169	SCMSTREAM Strm;
2170	int rc = ScmStreamInitForReading(&Strm, pszScript);
2171	if (RT_FAILURE(rc))
2172	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open & read '%s' into memory: %Rrc", pszScript, rc);
2173	if (g_cVerbosity > 0)
2174	RTMsgInfo("Parsing '%s'...", pszScript);
2175
2176	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2177	unsigned ch;
2178	while ((ch = ScmStreamGetCh(&Strm)) != ~(unsigned)0)
2179	{
2180	if (RT_C_IS_SPACE(ch))
2181	continue;
2182	switch (ch)
2183	{
2184	case '/':
2185	ch = ScmStreamGetCh(&Strm);
2186	if (ch == '*')
2187	rcExit = parseMultiLineComment(&Strm);
2188	else if (ch == '/')
2189	rcExit = parseOneLineComment(&Strm);
2190	else
2191	rcExit = parseError(&Strm, 2, "Unexpected character");
2192	break;
2193
2194	case 'p':
2195	if (ScmStreamCMatchingWordM1(&Strm, RT_STR_TUPLE("provider")))
2196	rcExit = parseProvider(&Strm);
2197	else
2198	rcExit = parseError(&Strm, 1, "Unexpected character");
2199	break;
2200
2201	case '#':
2202	{
2203	ch = parseGetNextNonSpaceNonCommentChOnPpLine(&Strm);
2204	if (ch == ~(unsigned)0)
2205	rcExit = RTEXITCODE_FAILURE;
2206	else if (ch == 'p' && ScmStreamCMatchingWordM1(&Strm, RT_STR_TUPLE("pragma")))
2207	rcExit = parsePragma(&Strm);
2208	else
2209	rcExit = parseError(&Strm, 1, "Unsupported preprocessor directive");
2210	break;
2211	}
2212
2213	default:
2214	rcExit = parseError(&Strm, 1, "Unexpected character");
2215	break;
2216	}
2217	if (rcExit != RTEXITCODE_SUCCESS)
2218	return rcExit;
2219	}
2220
2221	ScmStreamDelete(&Strm);
2222	if (g_cVerbosity > 0 && rcExit == RTEXITCODE_SUCCESS)
2223	RTMsgInfo("Successfully parsed '%s'.", pszScript);
2224	return rcExit;
2225	}
2226
2227
2228	/**
2229	* Parses the arguments.
2230	*/
2231	static RTEXITCODE parseArguments(int argc, char **argv)
2232	{
2233	/*
2234	* Set / Adjust defaults.
2235	*/
2236	int rc = RTPathAbs(g_pszAssemblerIncVal, g_szAssemblerIncVal, sizeof(g_szAssemblerIncVal) - 1);
2237	if (RT_FAILURE(rc))
2238	return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed: %Rrc", rc);
2239	strcat(g_szAssemblerIncVal, "/");
2240	g_pszAssemblerIncVal = g_szAssemblerIncVal;
2241
2242	/*
2243	* Option config.
2244	*/
2245	enum
2246	{
2247	kVBoxTpGOpt_32Bit = 1000,
2248	kVBoxTpGOpt_64Bit,
2249	kVBoxTpGOpt_GenerateWrapperHeader,
2250	kVBoxTpGOpt_Assembler,
2251	kVBoxTpGOpt_AssemblerFmtOpt,
2252	kVBoxTpGOpt_AssemblerFmtVal,
2253	kVBoxTpGOpt_AssemblerOutputOpt,
2254	kVBoxTpGOpt_AssemblerOption,
2255	kVBoxTpGOpt_Pic,
2256	kVBoxTpGOpt_ProbeFnName,
2257	kVBoxTpGOpt_ProbeFnImported,
2258	kVBoxTpGOpt_ProbeFnNotImported,
2259	kVBoxTpGOpt_Host32Bit,
2260	kVBoxTpGOpt_Host64Bit,
2261	kVBoxTpGOpt_RawModeContext,
2262	kVBoxTpGOpt_Ring0Context,
2263	kVBoxTpGOpt_Ring0ContextAgnostic,
2264	kVBoxTpGOpt_Ring3Context,
2265	kVBoxTpGOpt_End
2266	};
2267
2268	static RTGETOPTDEF const s_aOpts[] =
2269	{
2270	/* dtrace w/ long options */
2271	{ "-32", kVBoxTpGOpt_32Bit, RTGETOPT_REQ_NOTHING },
2272	{ "-64", kVBoxTpGOpt_64Bit, RTGETOPT_REQ_NOTHING },
2273	{ "--apply-cpp", 'C', RTGETOPT_REQ_NOTHING },
2274	{ "--generate-obj", 'G', RTGETOPT_REQ_NOTHING },
2275	{ "--generate-header", 'h', RTGETOPT_REQ_NOTHING },
2276	{ "--output", 'o', RTGETOPT_REQ_STRING },
2277	{ "--script", 's', RTGETOPT_REQ_STRING },
2278	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
2279	/* our stuff */
2280	{ "--generate-wrapper-header", kVBoxTpGOpt_GenerateWrapperHeader, RTGETOPT_REQ_NOTHING },
2281	{ "--assembler", kVBoxTpGOpt_Assembler, RTGETOPT_REQ_STRING },
2282	{ "--assembler-fmt-opt", kVBoxTpGOpt_AssemblerFmtOpt, RTGETOPT_REQ_STRING },
2283	{ "--assembler-fmt-val", kVBoxTpGOpt_AssemblerFmtVal, RTGETOPT_REQ_STRING },
2284	{ "--assembler-output-opt", kVBoxTpGOpt_AssemblerOutputOpt, RTGETOPT_REQ_STRING },
2285	{ "--assembler-option", kVBoxTpGOpt_AssemblerOption, RTGETOPT_REQ_STRING },
2286	{ "--pic", kVBoxTpGOpt_Pic, RTGETOPT_REQ_NOTHING },
2287	{ "--probe-fn-name", kVBoxTpGOpt_ProbeFnName, RTGETOPT_REQ_STRING },
2288	{ "--probe-fn-imported", kVBoxTpGOpt_ProbeFnImported, RTGETOPT_REQ_NOTHING },
2289	{ "--probe-fn-not-imported", kVBoxTpGOpt_ProbeFnNotImported, RTGETOPT_REQ_NOTHING },
2290	{ "--host-32-bit", kVBoxTpGOpt_Host32Bit, RTGETOPT_REQ_NOTHING },
2291	{ "--host-64-bit", kVBoxTpGOpt_Host64Bit, RTGETOPT_REQ_NOTHING },
2292	{ "--raw-mode-context", kVBoxTpGOpt_RawModeContext, RTGETOPT_REQ_NOTHING },
2293	{ "--ring-0-context", kVBoxTpGOpt_Ring0Context, RTGETOPT_REQ_NOTHING },
2294	{ "--ring-0-context-agnostic", kVBoxTpGOpt_Ring0ContextAgnostic, RTGETOPT_REQ_NOTHING },
2295	{ "--ring-3-context", kVBoxTpGOpt_Ring3Context, RTGETOPT_REQ_NOTHING },
2296	/** @todo We're missing a bunch of assembler options! */
2297	};
2298
2299	RTGETOPTUNION ValueUnion;
2300	RTGETOPTSTATE GetOptState;
2301	rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2302	AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);
2303
2304	/*
2305	* Process the options.
2306	*/
2307	while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
2308	{
2309	switch (rc)
2310	{
2311	/*
2312	* DTrace compatible options.
2313	*/
2314	case kVBoxTpGOpt_32Bit:
2315	g_cHostBits = g_cBits = 32;
2316	g_pszAssemblerFmtVal = g_szAssemblerFmtVal32;
2317	break;
2318
2319	case kVBoxTpGOpt_64Bit:
2320	g_cHostBits = g_cBits = 64;
2321	g_pszAssemblerFmtVal = g_szAssemblerFmtVal64;
2322	break;
2323
2324	case 'C':
2325	g_fApplyCpp = true;
2326	RTMsgWarning("Ignoring the -C option - no preprocessing of the D script will be performed");
2327	break;
2328
2329	case 'G':
2330	if ( g_enmAction != kVBoxTpGAction_Nothing
2331	&& g_enmAction != kVBoxTpGAction_GenerateObject)
2332	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "-G does not mix with -h or --generate-wrapper-header");
2333	g_enmAction = kVBoxTpGAction_GenerateObject;
2334	break;
2335
2336	case 'h':
2337	if (!strcmp(GetOptState.pDef->pszLong, "--generate-header"))
2338	{
2339	if ( g_enmAction != kVBoxTpGAction_Nothing
2340	&& g_enmAction != kVBoxTpGAction_GenerateHeader)
2341	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "-h does not mix with -G or --generate-wrapper-header");
2342	g_enmAction = kVBoxTpGAction_GenerateHeader;
2343	}
2344	else
2345	{
2346	/* --help or similar */
2347	RTPrintf("VirtualBox Tracepoint Generator\n"
2348	"\n"
2349	"Usage: %s [options]\n"
2350	"\n"
2351	"Options:\n", RTProcShortName());
2352	for (size_t i = 0; i < RT_ELEMENTS(s_aOpts); i++)
2353	if ((unsigned)s_aOpts[i].iShort < 128)
2354	RTPrintf(" -%c,%s\n", s_aOpts[i].iShort, s_aOpts[i].pszLong);
2355	else
2356	RTPrintf(" %s\n", s_aOpts[i].pszLong);
2357	return RTEXITCODE_SUCCESS;
2358	}
2359	break;
2360
2361	case 'o':
2362	if (g_pszOutput)
2363	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Output file is already set to '%s'", g_pszOutput);
2364	g_pszOutput = ValueUnion.psz;
2365	break;
2366
2367	case 's':
2368	if (g_pszScript)
2369	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Script file is already set to '%s'", g_pszScript);
2370	g_pszScript = ValueUnion.psz;
2371	break;
2372
2373	case 'v':
2374	g_cVerbosity++;
2375	break;
2376
2377	case 'V':
2378	{
2379	/* The following is assuming that svn does it's job here. */
2380	static const char s_szRev[] = "$Revision: 82968 $";
2381	const char *psz = RTStrStripL(strchr(s_szRev, ' '));
2382	RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);
2383	return RTEXITCODE_SUCCESS;
2384	}
2385
2386	case VINF_GETOPT_NOT_OPTION:
2387	if (g_enmAction == kVBoxTpGAction_GenerateObject)
2388	break; /* object files, ignore them. */
2389	return RTGetOptPrintError(rc, &ValueUnion);
2390
2391
2392	/*
2393	* Our options.
2394	*/
2395	case kVBoxTpGOpt_GenerateWrapperHeader:
2396	if ( g_enmAction != kVBoxTpGAction_Nothing
2397	&& g_enmAction != kVBoxTpGAction_GenerateWrapperHeader)
2398	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "--generate-wrapper-header does not mix with -h or -G");
2399	g_enmAction = kVBoxTpGAction_GenerateWrapperHeader;
2400	break;
2401
2402	case kVBoxTpGOpt_Assembler:
2403	g_pszAssembler = ValueUnion.psz;
2404	break;
2405
2406	case kVBoxTpGOpt_AssemblerFmtOpt:
2407	g_pszAssemblerFmtOpt = ValueUnion.psz;
2408	break;
2409
2410	case kVBoxTpGOpt_AssemblerFmtVal:
2411	g_pszAssemblerFmtVal = ValueUnion.psz;
2412	break;
2413
2414	case kVBoxTpGOpt_AssemblerOutputOpt:
2415	g_pszAssemblerOutputOpt = ValueUnion.psz;
2416	break;
2417
2418	case kVBoxTpGOpt_AssemblerOption:
2419	if (g_cAssemblerOptions >= RT_ELEMENTS(g_apszAssemblerOptions))
2420	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Too many assembly options (max %u)", RT_ELEMENTS(g_apszAssemblerOptions));
2421	g_apszAssemblerOptions[g_cAssemblerOptions] = ValueUnion.psz;
2422	g_cAssemblerOptions++;
2423	break;
2424
2425	case kVBoxTpGOpt_Pic:
2426	g_fPic = true;
2427	break;
2428
2429	case kVBoxTpGOpt_ProbeFnName:
2430	g_pszProbeFnName = ValueUnion.psz;
2431	break;
2432
2433	case kVBoxTpGOpt_ProbeFnImported:
2434	g_fProbeFnImported = true;
2435	break;
2436
2437	case kVBoxTpGOpt_ProbeFnNotImported:
2438	g_fProbeFnImported = false;
2439	break;
2440
2441	case kVBoxTpGOpt_Host32Bit:
2442	g_cHostBits = 32;
2443	break;
2444
2445	case kVBoxTpGOpt_Host64Bit:
2446	g_cHostBits = 64;
2447	break;
2448
2449	case kVBoxTpGOpt_RawModeContext:
2450	g_fTypeContext = VTG_TYPE_CTX_RC;
2451	g_pszContextDefine = "IN_RC";
2452	g_pszContextDefine2 = NULL;
2453	break;
2454
2455	case kVBoxTpGOpt_Ring0Context:
2456	g_fTypeContext = VTG_TYPE_CTX_R0;
2457	g_pszContextDefine = "IN_RING0";
2458	g_pszContextDefine2 = NULL;
2459	break;
2460
2461	case kVBoxTpGOpt_Ring0ContextAgnostic:
2462	g_fTypeContext = VTG_TYPE_CTX_R0;
2463	g_pszContextDefine = "IN_RING0_AGNOSTIC";
2464	g_pszContextDefine2 = "IN_RING0";
2465	break;
2466
2467	case kVBoxTpGOpt_Ring3Context:
2468	g_fTypeContext = VTG_TYPE_CTX_R3;
2469	g_pszContextDefine = "IN_RING3";
2470	g_pszContextDefine2 = NULL;
2471	break;
2472
2473
2474	/*
2475	* Errors and bugs.
2476	*/
2477	default:
2478	return RTGetOptPrintError(rc, &ValueUnion);
2479	}
2480	}
2481
2482	/*
2483	* Check that we've got all we need.
2484	*/
2485	if (g_enmAction == kVBoxTpGAction_Nothing)
2486	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No action specified (-h, -G or --generate-wrapper-header)");
2487	if (!g_pszScript)
2488	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No script file specified (-s)");
2489	if (!g_pszOutput)
2490	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No output file specified (-o)");
2491
2492	return RTEXITCODE_SUCCESS;
2493	}
2494
2495
2496	int main(int argc, char **argv)
2497	{
2498	int rc = RTR3InitExe(argc, &argv, 0);
2499	if (RT_FAILURE(rc))
2500	return 1;
2501
2502	RTEXITCODE rcExit = parseArguments(argc, argv);
2503	if (rcExit == RTEXITCODE_SUCCESS)
2504	{
2505	/*
2506	* Parse the script.
2507	*/
2508	RTListInit(&g_ProviderHead);
2509	rcExit = parseScript(g_pszScript);
2510	if (rcExit == RTEXITCODE_SUCCESS)
2511	{
2512	/*
2513	* Take action.
2514	*/
2515	if (g_enmAction == kVBoxTpGAction_GenerateHeader)
2516	rcExit = generateFile(g_pszOutput, "header", generateHeader);
2517	else if (g_enmAction == kVBoxTpGAction_GenerateWrapperHeader)
2518	rcExit = generateFile(g_pszOutput, "wrapper header", generateWrapperHeader);
2519	else
2520	rcExit = generateObject(g_pszOutput, g_pszTempAsm);
2521	}
2522	}
2523
2524	if (rcExit == RTEXITCODE_SUCCESS && g_cTypeErrors > 0)
2525	rcExit = RTEXITCODE_FAILURE;
2526	return rcExit;
2527	}
2528

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

source: vbox/trunk/src/bldprogs/VBoxTpG.cpp@ 84551

Download in other formats: