1 | /* $Id: VBoxTpG.cpp 103275 2024-02-08 11:56:18Z 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 103275 2024-02-08 11:56:18Z 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 103275 2024-02-08 11:56:18Z 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 103275 2024-02-08 11:56:18Z 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: 103275 $";
|
---|
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 |
|
---|