VBoxTpG.cpp@ 99391

Last change on this file since 99391 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: 102.4 KB

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

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

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

Download in other formats: