#include <VBox/VBoxTpG.h>

#include <iprt/alloca.h>

#include <iprt/assert.h>

#include <iprt/ctype.h>

#include <iprt/env.h>

#include <iprt/err.h>

#include <iprt/file.h>

#include <iprt/getopt.h>

#include <iprt/initterm.h>

#include <iprt/list.h>

#include <iprt/mem.h>

#include <iprt/message.h>

#include <iprt/path.h>

#include <iprt/process.h>

#include <iprt/stream.h>

#include <iprt/string.h>

#include <iprt/uuid.h>

#include "scmstream.h"

typedef struct VTGATTRS

{

kVTGStability enmCode;

kVTGStability enmData;

kVTGClass enmDataDep;

} VTGATTRS;

typedef VTGATTRS *PVTGATTRS;

typedef struct VTGARG

{

RTLISTNODE ListEntry;

/** The argument name. (heap) */

char *pszName;

/** The type presented to the tracer (in string table). */

const char *pszTracerType;

/** The argument type used in the probe method in that context. (heap) */

char *pszCtxType;

/** Argument passing format string. First and only argument is the name.

const char *pszArgPassingFmt;

/** The type flags. */

uint32_t fType;

} VTGARG;

typedef VTGARG *PVTGARG;

typedef struct VTGPROBE

{

RTLISTNODE ListEntry;

char *pszMangledName;

const char *pszUnmangledName;

RTLISTANCHOR ArgHead;

uint32_t cArgs;

bool fHaveLargeArgs;

uint32_t offArgList;

uint32_t iProbe;

} VTGPROBE;

typedef VTGPROBE *PVTGPROBE;

typedef struct VTGPROVIDER

{

RTLISTNODE ListEntry;

const char *pszName;

uint16_t iFirstProbe;

uint16_t cProbes;

VTGATTRS AttrSelf;

VTGATTRS AttrModules;

VTGATTRS AttrFunctions;

VTGATTRS AttrName;

VTGATTRS AttrArguments;

RTLISTANCHOR ProbeHead;

} VTGPROVIDER;

typedef VTGPROVIDER *PVTGPROVIDER;

typedef struct VTGSTRING

{

/** The string space core. */

RTSTRSPACECORE Core;

/** The string table offset. */

uint32_t offStrTab;

/** The actual string. */

char szString[1];

} VTGSTRING;

typedef VTGSTRING *PVTGSTRING;

static RTSTRSPACE g_StrSpace = NULL;

static uint32_t g_offStrTab;

static RTLISTANCHOR g_ProviderHead;

static uint32_t g_cTypeErrors = 0;

static enum

{

kVBoxTpGAction_Nothing,

kVBoxTpGAction_GenerateHeader,

kVBoxTpGAction_GenerateObject

} g_enmAction = kVBoxTpGAction_Nothing;

static uint32_t g_cBits = HC_ARCH_BITS;

static uint32_t g_cHostBits = HC_ARCH_BITS;

static uint32_t g_fTypeContext = VTG_TYPE_CTX_R0;

static bool g_fApplyCpp = false;

static uint32_t g_cVerbosity = 0;

static const char *g_pszOutput = NULL;

static const char *g_pszScript = NULL;

static const char *g_pszTempAsm = NULL;

#ifdef RT_OS_DARWIN

static const char *g_pszAssembler = "yasm";

static const char *g_pszAssemblerFmtOpt = "-f";

static const char g_szAssemblerFmtVal32[] = "macho32";

static const char g_szAssemblerFmtVal64[] = "macho64";

static const char g_szAssemblerOsDef[] = "RT_OS_DARWIN";

#elif defined(RT_OS_OS2)

static const char *pszAssembler = "nasm.exe";

static const char *pszAssemblerFmtOpt = "-f";

static const char g_szAssemblerFmtVal32[] = "obj";

static const char g_szAssemblerFmtVal64[] = "elf64";

static const char g_szAssemblerOsDef[] = "RT_OS_OS2";

#elif defined(RT_OS_WINDOWS)

static const char *g_pszAssembler = "yasm.exe";

static const char *g_pszAssemblerFmtOpt = "-f";

static const char g_szAssemblerFmtVal32[] = "win32";

static const char g_szAssemblerFmtVal64[] = "win64";

static const char g_szAssemblerOsDef[] = "RT_OS_WINDOWS";

#else

static const char *g_pszAssembler = "yasm";

static const char *g_pszAssemblerFmtOpt = "-f";

static const char g_szAssemblerFmtVal32[] = "elf32";

static const char g_szAssemblerFmtVal64[] = "elf64";

# ifdef RT_OS_FREEBSD

static const char g_szAssemblerOsDef[] = "RT_OS_FREEBSD";

# elif defined(RT_OS_NETBSD)

static const char g_szAssemblerOsDef[] = "RT_OS_NETBSD";

# elif defined(RT_OS_OPENBSD)

static const char g_szAssemblerOsDef[] = "RT_OS_OPENBSD";

# elif defined(RT_OS_LINUX)

static const char g_szAssemblerOsDef[] = "RT_OS_LINUX";

# elif defined(RT_OS_SOLARIS)

static const char g_szAssemblerOsDef[] = "RT_OS_SOLARIS";

# else

# error "Port me!"

# endif

#endif

static const char *g_pszAssemblerFmtVal = RT_CONCAT(g_szAssemblerFmtVal, HC_ARCH_BITS);

static const char *g_pszAssemblerDefOpt = "-D";

static const char *g_pszAssemblerIncOpt = "-I";

static char g_szAssemblerIncVal[RTPATH_MAX];

static const char *g_pszAssemblerIncVal = __FILE__ "/../../../include/";

static const char *g_pszAssemblerOutputOpt = "-o";

static unsigned g_cAssemblerOptions = 0;

static const char *g_apszAssemblerOptions[32];

static const char *g_pszProbeFnName = "SUPR0TracerFireProbe";

static bool g_fProbeFnImported = true;

static bool g_fPic = false;

static const char *strtabInsertN(const char *pch, size_t cch)

{

PVTGSTRING pStr = (PVTGSTRING)RTStrSpaceGetN(&g_StrSpace, pch, cch);

if (pStr)

return pStr->szString;

/*

pStr = (PVTGSTRING)RTMemAlloc(RT_OFFSETOF(VTGSTRING, szString[cch + 1]));

if (!pStr)

return NULL;

pStr->Core.pszString = pStr->szString;

memcpy(pStr->szString, pch, cch);

pStr->szString[cch] = '\0';

pStr->offStrTab = UINT32_MAX;

bool fRc = RTStrSpaceInsert(&g_StrSpace, &pStr->Core);

Assert(fRc); NOREF(fRc);

return pStr->szString;

}

static uint32_t strtabGetOff(const char *pszStrTabString)

{

PVTGSTRING pStr = RT_FROM_MEMBER(pszStrTabString, VTGSTRING, szString[0]);

Assert(pStr->Core.pszString == pszStrTabString);

return pStr->offStrTab;

}

static RTEXITCODE generateInvokeAssembler(const char *pszOutput, const char *pszTempAsm)

{

const char *apszArgs[64];

unsigned iArg = 0;

apszArgs[iArg++] = g_pszAssembler;

apszArgs[iArg++] = g_pszAssemblerFmtOpt;

apszArgs[iArg++] = g_pszAssemblerFmtVal;

apszArgs[iArg++] = g_pszAssemblerDefOpt;

if (!strcmp(g_pszAssemblerFmtVal, "macho32") || !strcmp(g_pszAssemblerFmtVal, "macho64"))

apszArgs[iArg++] = "ASM_FORMAT_MACHO";

else if (!strcmp(g_pszAssemblerFmtVal, "obj") || !strcmp(g_pszAssemblerFmtVal, "omf"))

apszArgs[iArg++] = "ASM_FORMAT_OMF";

else if ( !strcmp(g_pszAssemblerFmtVal, "win32")

|| !strcmp(g_pszAssemblerFmtVal, "win64")

|| !strcmp(g_pszAssemblerFmtVal, "pe32")

|| !strcmp(g_pszAssemblerFmtVal, "pe64")

|| !strcmp(g_pszAssemblerFmtVal, "pe") )

apszArgs[iArg++] = "ASM_FORMAT_PE";

else if ( !strcmp(g_pszAssemblerFmtVal, "elf32")

|| !strcmp(g_pszAssemblerFmtVal, "elf64")

|| !strcmp(g_pszAssemblerFmtVal, "elf"))

apszArgs[iArg++] = "ASM_FORMAT_ELF";

else

return RTMsgErrorExit(RTEXITCODE_FAILURE, "Unknown assembler format '%s'", g_pszAssemblerFmtVal);

apszArgs[iArg++] = g_pszAssemblerDefOpt;

if (g_cBits == 32)

apszArgs[iArg++] = "ARCH_BITS=32";

else

apszArgs[iArg++] = "ARCH_BITS=64";

apszArgs[iArg++] = g_pszAssemblerDefOpt;

if (g_cHostBits == 32)

apszArgs[iArg++] = "HC_ARCH_BITS=32";

else

apszArgs[iArg++] = "HC_ARCH_BITS=64";

apszArgs[iArg++] = g_pszAssemblerDefOpt;

if (g_cBits == 32)

apszArgs[iArg++] = "RT_ARCH_X86";

else

apszArgs[iArg++] = "RT_ARCH_AMD64";

apszArgs[iArg++] = g_pszAssemblerDefOpt;

if (g_fTypeContext == VTG_TYPE_CTX_R0)

apszArgs[iArg++] = "IN_RING0";

else if (g_fTypeContext == VTG_TYPE_CTX_R3)

apszArgs[iArg++] = "IN_RING3";

else if (g_fTypeContext == VTG_TYPE_CTX_RC)

apszArgs[iArg++] = "IN_RC";

else

apszArgs[iArg++] = "IN_UNKNOWN";

if (g_szAssemblerOsDef[0])

{

apszArgs[iArg++] = g_pszAssemblerDefOpt;

apszArgs[iArg++] = g_szAssemblerOsDef;

}

apszArgs[iArg++] = g_pszAssemblerIncOpt;

apszArgs[iArg++] = g_pszAssemblerIncVal;

apszArgs[iArg++] = g_pszAssemblerOutputOpt;

apszArgs[iArg++] = pszOutput;

for (unsigned i = 0; i < g_cAssemblerOptions; i++)

apszArgs[iArg++] = g_apszAssemblerOptions[i];

apszArgs[iArg++] = pszTempAsm;

apszArgs[iArg] = NULL;

if (g_cVerbosity > 1)

{

RTMsgInfo("Starting assmbler '%s' with arguments:\n", g_pszAssembler);

for (unsigned i = 0; i < iArg; i++)

RTMsgInfo(" #%02u: '%s'\n", i, apszArgs[i]);

}

RTPROCESS hProc;

int rc = RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, RTPROC_FLAGS_SEARCH_PATH, &hProc);

if (RT_FAILURE(rc))

return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to start '%s' (assembler): %Rrc", apszArgs[0], rc);

RTPROCSTATUS Status;

rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &Status);

if (RT_FAILURE(rc))

{

RTProcTerminate(hProc);

return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTProcWait failed: %Rrc", rc);

}

if (Status.enmReason == RTPROCEXITREASON_SIGNAL)

return RTMsgErrorExit(RTEXITCODE_FAILURE, "The assembler failed: signal %d", Status.iStatus);

if (Status.enmReason != RTPROCEXITREASON_NORMAL)

return RTMsgErrorExit(RTEXITCODE_FAILURE, "The assembler failed: abend");

if (Status.iStatus != 0)

return RTMsgErrorExit((RTEXITCODE)Status.iStatus, "The assembler failed: exit code %d", Status.iStatus);

return RTEXITCODE_SUCCESS;

}

static RTEXITCODE generateFile(const char *pszOutput, const char *pszWhat,

RTEXITCODE (*pfnGenerator)(PSCMSTREAM))

{

SCMSTREAM Strm;

int rc = ScmStreamInitForWriting(&Strm, NULL);

if (RT_FAILURE(rc))

return RTMsgErrorExit(RTEXITCODE_FAILURE, "ScmStreamInitForWriting returned %Rrc when generating the %s file",

rc, pszWhat);

RTEXITCODE rcExit = pfnGenerator(&Strm);

if (RT_FAILURE(ScmStreamGetStatus(&Strm)))

rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "Stream error %Rrc generating the %s file",

ScmStreamGetStatus(&Strm), pszWhat);

if (rcExit == RTEXITCODE_SUCCESS)

{

rc = ScmStreamWriteToFile(&Strm, "%s", pszOutput);

if (RT_FAILURE(rc))

rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "ScmStreamWriteToFile returned %Rrc when writing '%s' (%s)",

rc, pszOutput, pszWhat);

if (rcExit == RTEXITCODE_SUCCESS)

{

if (g_cVerbosity > 0)

RTMsgInfo("Successfully generated '%s'.", pszOutput);

if (g_cVerbosity > 1)

{

RTMsgInfo("================ %s - start ================", pszWhat);

ScmStreamRewindForReading(&Strm);

const char *pszLine;

size_t cchLine;

SCMEOL enmEol;

while ((pszLine = ScmStreamGetLine(&Strm, &cchLine, &enmEol)) != NULL)

RTPrintf("%.*s\n", cchLine, pszLine);

RTMsgInfo("================ %s - end ================", pszWhat);

}

}

}

ScmStreamDelete(&Strm);

return rcExit;

}

static DECLCALLBACK(int) generateAssemblyStrTabCallback(PRTSTRSPACECORE pStr, void *pvUser)

{

PVTGSTRING pVtgStr = (PVTGSTRING)pStr;

PSCMSTREAM pStrm = (PSCMSTREAM)pvUser;

pVtgStr->offStrTab = g_offStrTab;

g_offStrTab += (uint32_t)pVtgStr->Core.cchString + 1;

ScmStreamPrintf(pStrm,

" db '%s', 0 ; off=%u len=%zu\n",

pVtgStr->szString, pVtgStr->offStrTab, pVtgStr->Core.cchString);

return VINF_SUCCESS;

}

static RTEXITCODE generateAssembly(PSCMSTREAM pStrm)

{

PVTGPROVIDER pProvider;

PVTGPROBE pProbe;

PVTGARG pArg;

if (g_cVerbosity > 0)

RTMsgInfo("Generating assembly code...");

/*

ScmStreamPrintf(pStrm,

"; $Id$ \n"

";; @file\n"

"; Automatically generated from %s. Do NOT edit!\n"

";\n"

"\n"

"%%include \"iprt/asmdefs.mac\"\n"

"\n"

"\n"

";"

"; We put all the data in a dedicated section / segment.\n"

";\n"

"; In order to find the probe location specifiers, we do the necessary\n"

"; trickery here, ASSUMING that this object comes in first in the link\n"

"; editing process.\n"

";\n"

"%%ifdef ASM_FORMAT_OMF\n"

" %%macro VTG_GLOBAL 2\n"

" global NAME(%%1)\n"

" NAME(%%1):\n"

" %%endmacro\n"

" segment VTG.Obj public CLASS=VTG align=4096 use32\n"

"\n"

"%%elifdef ASM_FORMAT_MACHO\n"

" %%macro VTG_GLOBAL 2\n"

" global NAME(%%1)\n"

" NAME(%%1):\n"

" %%endmacro\n"

" ; Section order hack!\n"

" ; With the ld64-97.17 linker there was a problem with it determin the section\n"

" ; order based on symbol references. The references to the start and end of the\n"

" ; __VTGPrLc section forced it in front of __VTGObj.\n"

" extern section$start$__VTG$__VTGObj\n"

" extern section$end$__VTG$__VTGObj\n"

" [section __VTG __VTGObj align=1024]\n"

"\n"

"%%elifdef ASM_FORMAT_PE\n"

" %%macro VTG_GLOBAL 2\n"

" global NAME(%%1)\n"

" NAME(%%1):\n"

" %%endmacro\n"

" [section VTGPrLc.Begin data align=64]\n"

/*" times 16 db 0xcc\n"*/

"VTG_GLOBAL g_aVTGPrLc, data\n"

" [section VTGPrLc.Data data align=4]\n"

" [section VTGPrLc.End data align=4]\n"

"VTG_GLOBAL g_aVTGPrLc_End, data\n"

/*" times 16 db 0xcc\n"*/

" [section VTGObj data align=32]\n"

"\n"

"%%elifdef ASM_FORMAT_ELF\n"

" %%macro VTG_GLOBAL 2\n"

" global NAME(%%1):%%2 hidden\n"

" NAME(%%1):\n"

" %%endmacro\n"

" [section .VTGData progbits alloc noexec write align=4096]\n"

" [section .VTGPrLc.Begin progbits alloc noexec write align=32]\n"

" dd 0,0,0,0, 0,0,0,0\n"

"VTG_GLOBAL g_aVTGPrLc, data\n"

" [section .VTGPrLc progbits alloc noexec write align=1]\n"

" [section .VTGPrLc.End progbits alloc noexec write align=1]\n"

"VTG_GLOBAL g_aVTGPrLc_End, data\n"

" dd 0,0,0,0, 0,0,0,0\n"

" [section .VTGData]\n"

"\n"

"%%else\n"

" %%error \"ASM_FORMAT_XXX is not defined\"\n"

"%%endif\n"

"\n"

"\n"

"VTG_GLOBAL g_VTGObjHeader, data\n"

" ;0 1 2 3\n"

" ;012345678901234567890123456789012\n"

" db 'VTG Object Header v1.5', 0, 0\n"

" dd %u\n"

" dd NAME(g_acVTGProbeEnabled_End) - NAME(g_VTGObjHeader)\n"

" dd NAME(g_achVTGStringTable) - NAME(g_VTGObjHeader)\n"

" dd NAME(g_achVTGStringTable_End) - NAME(g_achVTGStringTable)\n"

" dd NAME(g_aVTGArgLists) - NAME(g_VTGObjHeader)\n"

" dd NAME(g_aVTGArgLists_End) - NAME(g_aVTGArgLists)\n"

" dd NAME(g_aVTGProbes) - NAME(g_VTGObjHeader)\n"

" dd NAME(g_aVTGProbes_End) - NAME(g_aVTGProbes)\n"

" dd NAME(g_aVTGProviders) - NAME(g_VTGObjHeader)\n"

" dd NAME(g_aVTGProviders_End) - NAME(g_aVTGProviders)\n"

" dd NAME(g_acVTGProbeEnabled) - NAME(g_VTGObjHeader)\n"

" dd NAME(g_acVTGProbeEnabled_End) - NAME(g_acVTGProbeEnabled)\n"

" dd 0\n"

" dd 0\n"

"%%ifdef ASM_FORMAT_MACHO ; Apple has a real decent linker!\n"

"extern section$start$__VTG$__VTGPrLc\n"

" RTCCPTR_DEF section$start$__VTG$__VTGPrLc\n"

" %%if ARCH_BITS == 32\n"

" dd 0\n"

" %%endif\n"

"extern section$end$__VTG$__VTGPrLc\n"

" RTCCPTR_DEF section$end$__VTG$__VTGPrLc\n"

" %%if ARCH_BITS == 32\n"

" dd 0\n"

" %%endif\n"

"%%else\n"

" RTCCPTR_DEF NAME(g_aVTGPrLc)\n"

" %%if ARCH_BITS == 32\n"

" dd 0\n"

" %%endif\n"

" RTCCPTR_DEF NAME(g_aVTGPrLc_End)\n"

" %%if ARCH_BITS == 32\n"

" dd 0\n"

" %%endif\n"

"%%endif\n"

,

g_pszScript, g_cBits);

RTUUID Uuid;

int rc = RTUuidCreate(&Uuid);

if (RT_FAILURE(rc))

return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTUuidCreate failed: %Rrc", rc);

ScmStreamPrintf(pStrm,

" dd 0%08xh, 0%08xh, 0%08xh, 0%08xh\n"

"%%ifdef ASM_FORMAT_MACHO\n"

" RTCCPTR_DEF section$start$__VTG$__VTGObj\n"

" %%if ARCH_BITS == 32\n"

" dd 0\n"

" %%endif\n"

"%%else\n"

" dd 0, 0\n"

"%%endif\n"

" dd 0, 0\n"

, Uuid.au32[0], Uuid.au32[1], Uuid.au32[2], Uuid.au32[3]);

/*

ScmStreamPrintf(pStrm,

"\n"

";\n"

"; The string table.\n"

";\n"

"VTG_GLOBAL g_achVTGStringTable, data\n");

g_offStrTab = 0;

RTStrSpaceEnumerate(&g_StrSpace, generateAssemblyStrTabCallback, pStrm);

ScmStreamPrintf(pStrm,

"VTG_GLOBAL g_achVTGStringTable_End, data\n");

/*

ScmStreamPrintf(pStrm,

"\n"

";\n"

"; The argument lists.\n"

";\n"

"ALIGNDATA(16)\n"

"VTG_GLOBAL g_aVTGArgLists, data\n");

uint32_t off = 0;

RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)

{

RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)

{

if (pProbe->offArgList != UINT32_MAX)

continue;

/* Write it. */

pProbe->offArgList = off;

ScmStreamPrintf(pStrm,

" ; off=%u\n"

" db %2u ; Argument count\n"

" db %u ; fHaveLargeArgs\n"

" db 0, 0 ; Reserved\n"

, off, pProbe->cArgs, (int)pProbe->fHaveLargeArgs);

off += 4;

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

ScmStreamPrintf(pStrm,

" dd %8u ; type '%s' (name '%s')\n"

" dd 0%08xh ; type flags\n",

strtabGetOff(pArg->pszTracerType), pArg->pszTracerType, pArg->pszName,

pArg->fType);

off += 8;

}

/* Look for matching argument lists (lazy bird walks the whole list). */

PVTGPROVIDER pProv2;

RTListForEach(&g_ProviderHead, pProv2, VTGPROVIDER, ListEntry)

{

PVTGPROBE pProbe2;

RTListForEach(&pProvider->ProbeHead, pProbe2, VTGPROBE, ListEntry)

{

if (pProbe2->offArgList != UINT32_MAX)

continue;

if (pProbe2->cArgs != pProbe->cArgs)

continue;

PVTGARG pArg2;

pArg = RTListNodeGetNext(&pProbe->ArgHead, VTGARG, ListEntry);

pArg2 = RTListNodeGetNext(&pProbe2->ArgHead, VTGARG, ListEntry);

int32_t cArgs = pProbe->cArgs;

while ( cArgs-- > 0

&& pArg2->pszTracerType == pArg->pszTracerType

&& pArg2->fType == pArg->fType)

{

pArg = RTListNodeGetNext(&pArg->ListEntry, VTGARG, ListEntry);

pArg2 = RTListNodeGetNext(&pArg2->ListEntry, VTGARG, ListEntry);

}

if (cArgs >= 0)

continue;

pProbe2->offArgList = pProbe->offArgList;

}

}

}

}

ScmStreamPrintf(pStrm,

"VTG_GLOBAL g_aVTGArgLists_End, data\n");

/*

ScmStreamPrintf(pStrm,

"\n"

";\n"

"; Prob definitions.\n"

";\n"

"ALIGNDATA(16)\n"

"VTG_GLOBAL g_aVTGProbes, data\n"

"\n");

uint32_t iProvider = 0;

uint32_t iProbe = 0;

RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)

{

pProvider->iFirstProbe = iProbe;

RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)

{

ScmStreamPrintf(pStrm,

"VTG_GLOBAL g_VTGProbeData_%s_%s, data ; idx=#%4u\n"

" dd %6u ; offName\n"

" dd %6u ; offArgList\n"

" dw (NAME(g_cVTGProbeEnabled_%s_%s) - NAME(g_acVTGProbeEnabled)) / 4 ; idxEnabled\n"

" dw %6u ; idxProvider\n"

" dd NAME(g_VTGObjHeader) - NAME(g_VTGProbeData_%s_%s) ; offObjHdr\n"

,

pProvider->pszName, pProbe->pszMangledName, iProbe,

strtabGetOff(pProbe->pszUnmangledName),

pProbe->offArgList,

pProvider->pszName, pProbe->pszMangledName,

iProvider,

pProvider->pszName, pProbe->pszMangledName

);

pProbe->iProbe = iProbe;

iProbe++;

}

pProvider->cProbes = iProbe - pProvider->iFirstProbe;

iProvider++;

}

ScmStreamPrintf(pStrm, "VTG_GLOBAL g_aVTGProbes_End, data\n");

/*

ScmStreamPrintf(pStrm,

"\n"

";\n"

"; Provider data.\n"

";\n"

"ALIGNDATA(16)\n"

"VTG_GLOBAL g_aVTGProviders, data\n");

iProvider = 0;

RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)

{

ScmStreamPrintf(pStrm,

" ; idx=#%4u - %s\n"

" dd %6u ; name\n"

" dw %6u ; index of first probe\n"

" dw %6u ; count of probes\n"

" db %d, %d, %d ; AttrSelf\n"

" db %d, %d, %d ; AttrModules\n"

" db %d, %d, %d ; AttrFunctions\n"

" db %d, %d, %d ; AttrName\n"

" db %d, %d, %d ; AttrArguments\n"

" db 0 ; reserved\n"

,

iProvider, pProvider->pszName,

strtabGetOff(pProvider->pszName),

pProvider->iFirstProbe,

pProvider->cProbes,

pProvider->AttrSelf.enmCode, pProvider->AttrSelf.enmData, pProvider->AttrSelf.enmDataDep,

pProvider->AttrModules.enmCode, pProvider->AttrModules.enmData, pProvider->AttrModules.enmDataDep,

pProvider->AttrFunctions.enmCode, pProvider->AttrFunctions.enmData, pProvider->AttrFunctions.enmDataDep,

pProvider->AttrName.enmCode, pProvider->AttrName.enmData, pProvider->AttrName.enmDataDep,

pProvider->AttrArguments.enmCode, pProvider->AttrArguments.enmData, pProvider->AttrArguments.enmDataDep);

iProvider++;

}

ScmStreamPrintf(pStrm, "VTG_GLOBAL g_aVTGProviders_End, data\n");

/*

ScmStreamPrintf(pStrm,

";\n"

"; Probe enabled flags.\n"

";\n"

"ALIGNDATA(16)\n"

"VTG_GLOBAL g_acVTGProbeEnabled, data\n"

);

uint32_t cProbes = 0;

RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)

{

RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)

{

ScmStreamPrintf(pStrm,

"VTG_GLOBAL g_cVTGProbeEnabled_%s_%s, data\n"

" dd 0\n",

pProvider->pszName, pProbe->pszMangledName);

cProbes++;

}

}

ScmStreamPrintf(pStrm, "VTG_GLOBAL g_acVTGProbeEnabled_End, data\n");

if (cProbes >= _32K)

return RTMsgErrorExit(RTEXITCODE_FAILURE, "Too many probes: %u (max %u)", cProbes, _32K - 1);

/*

bool const fWin64 = g_cBits == 64 && (!strcmp(g_pszAssemblerFmtVal, "win64") || !strcmp(g_pszAssemblerFmtVal, "pe64"));

bool const fMachO64 = g_cBits == 64 && !strcmp(g_pszAssemblerFmtVal, "macho64");

bool const fMachO32 = g_cBits == 32 && !strcmp(g_pszAssemblerFmtVal, "macho32");

ScmStreamPrintf(pStrm,

"\n"

";\n"

"; Prob stubs.\n"

";\n"

"BEGINCODE\n"

"extern %sNAME(%s)\n",

g_fProbeFnImported ? "IMP" : "",

g_pszProbeFnName);

if (fMachO64 && g_fProbeFnImported && !g_fPic)

ScmStreamPrintf(pStrm,

"g_pfnVtgProbeFn:\n"

" dq NAME(%s)\n",

g_pszProbeFnName);

RTListForEach(&g_ProviderHead, pProvider, VTGPROVIDER, ListEntry)

{

RTListForEach(&pProvider->ProbeHead, pProbe, VTGPROBE, ListEntry)

{

ScmStreamPrintf(pStrm,

"\n"

"VTG_GLOBAL VTGProbeStub_%s_%s, function; (VBOXTPGPROBELOC pVTGProbeLoc",

pProvider->pszName, pProbe->pszMangledName);

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

ScmStreamPrintf(pStrm, ", %s %s", pArg->pszTracerType, pArg->pszName);

}

ScmStreamPrintf(pStrm,

");\n");

/*

if (g_cBits == 32)

ScmStreamPrintf(pStrm,

" mov eax, [esp + 4]\n"

" test byte [eax+3], 0x80 ; fEnabled == true?\n"

" jz .return ; jump on false\n");

else if (fWin64)

ScmStreamPrintf(pStrm,

" test byte [rcx+3], 0x80 ; fEnabled == true?\n"

" jz .return ; jump on false\n");

else

ScmStreamPrintf(pStrm,

" test byte [rdi+3], 0x80 ; fEnabled == true?\n"

" jz .return ; jump on false\n");

/*

if (g_cBits == 32)

ScmStreamPrintf(pStrm, g_fPic ?

" call .mov_ecx_eip_plus_5\n"

".got_eip:\n"

" add ecx, _GLOBAL_OFFSET_TABLE + ($$ - .got_eip) wrt ..gotpc\n"

" mov ecx, [%s@GOT + ecx]\n"

" jmp ecx\n"

".mov_ecx_eip_plus_5:\n"

" pop ecx\n"

" jmp ecx\n"

: g_fProbeFnImported ?

" mov ecx, IMP2(%s)\n"

" jmp ecx\n"

:

" jmp NAME(%s)\n"

, g_pszProbeFnName);

else if (fWin64)

ScmStreamPrintf(pStrm, g_fProbeFnImported ?

" mov rax, IMP2(%s)\n"

" jmp rax\n"

:

" jmp NAME(%s)\n"

, g_pszProbeFnName);

else if (fMachO64 && g_fProbeFnImported)

ScmStreamPrintf(pStrm,

" jmp [g_pfnVtgProbeFn wrt rip]\n");

else

ScmStreamPrintf(pStrm, g_fPic ?

" jmp [rel %s wrt ..got]\n"

: g_fProbeFnImported ?

" lea rax, [IMP2(%s)]\n"

" jmp rax\n"

:

" jmp NAME(%s)\n"

, g_pszProbeFnName);

ScmStreamPrintf(pStrm,

".return:\n"

" ret ; The probe was disabled, return\n"

"\n");

}

}

return RTEXITCODE_SUCCESS;

}

static RTEXITCODE generateObject(const char *pszOutput, const char *pszTempAsm)

{

if (!pszTempAsm)

{

size_t cch = strlen(pszOutput);

char *psz = (char *)alloca(cch + sizeof(".asm"));

memcpy(psz, pszOutput, cch);

memcpy(psz + cch, ".asm", sizeof(".asm"));

pszTempAsm = psz;

}

RTEXITCODE rcExit = generateFile(pszTempAsm, "assembly", generateAssembly);

if (rcExit == RTEXITCODE_SUCCESS)

rcExit = generateInvokeAssembler(pszOutput, pszTempAsm);

RTFileDelete(pszTempAsm);

return rcExit;

}

static RTEXITCODE generateProbeDefineName(char *pszBuf, size_t cbBuf, const char *pszProvider, const char *pszProbe)

{

size_t cbMax = strlen(pszProvider) + 1 + strlen(pszProbe) + 1;

if (cbMax > cbBuf || cbMax > 80)

return RTMsgErrorExit(RTEXITCODE_FAILURE, "Probe '%s' in provider '%s' ends up with a too long defined\n", pszProbe, pszProvider);

while (*pszProvider)

*pszBuf++ = RT_C_TO_UPPER(*pszProvider++);

*pszBuf++ = '_';

while (*pszProbe)

{

if (pszProbe[0] == '_' && pszProbe[1] == '_')

pszProbe++;

*pszBuf++ = RT_C_TO_UPPER(*pszProbe++);

}

*pszBuf = '\0';

return RTEXITCODE_SUCCESS;

}

static RTEXITCODE generateHeaderInner(PSCMSTREAM pStrm)

{

/*

char szTmp[4096];

const char *pszName = RTPathFilename(g_pszScript);

size_t cchName = strlen(pszName);

if (cchName >= sizeof(szTmp) - 64)

return RTMsgErrorExit(RTEXITCODE_FAILURE, "File name is too long '%s'", pszName);

szTmp[0] = '_';

szTmp[1] = '_';

szTmp[2] = '_';

memcpy(&szTmp[3], pszName, cchName);

szTmp[3 + cchName + 0] = '_';

szTmp[3 + cchName + 1] = '_';

szTmp[3 + cchName + 2] = '_';

szTmp[3 + cchName + 3] = '\0';

char *psz = &szTmp[3];

while (*psz)

{

if (!RT_C_IS_ALNUM(*psz) && *psz != '_')

*psz = '_';

psz++;

}

const char *pszCtxDefine = "UNKNOWN_DEFINE";

if (g_fTypeContext == VTG_TYPE_CTX_R0)

pszCtxDefine = "IN_RING0";

else if (g_fTypeContext == VTG_TYPE_CTX_R3)

pszCtxDefine = "IN_RING3";

else if (g_fTypeContext == VTG_TYPE_CTX_RC)

pszCtxDefine = "IN_RC";

else

AssertFailed();

ScmStreamPrintf(pStrm,

"/* $Id$ */\n"

"/** @file\n"

" * Automatically generated from %s. Do NOT edit!\n"

" */\n"

"\n"

"#ifndef %s\n"

"#define %s\n"

"\n"

"#include <VBox/VBoxTpG.h>\n"

"\n"

"#ifndef %s\n"

"# error \"Expected '%s' to be defined\"\n"

"#endif\n"

"\n"

"RT_C_DECLS_BEGIN\n"

"\n"

"#ifdef VBOX_WITH_DTRACE\n"

"\n"

"# ifdef _MSC_VER\n"

"# pragma data_seg(VTG_LOC_SECT)\n"

"# pragma data_seg()\n"

"# endif\n"

"\n"

,

g_pszScript,

szTmp,

szTmp,

pszCtxDefine);

/*

PVTGPROVIDER pProv;

PVTGPROBE pProbe;

PVTGARG pArg;

RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)

{

RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)

{

PVTGARG const pFirstArg = RTListGetFirst(&pProbe->ArgHead, VTGARG, ListEntry);

ScmStreamPrintf(pStrm,

"extern uint32_t g_cVTGProbeEnabled_%s_%s;\n"

"extern VTGDESCPROBE g_VTGProbeData_%s_%s;\n"

"DECLASM(void) VTGProbeStub_%s_%s(PVTGPROBELOC",

pProv->pszName, pProbe->pszMangledName,

pProv->pszName, pProbe->pszMangledName,

pProv->pszName, pProbe->pszMangledName);

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

ScmStreamPrintf(pStrm, ", %s", pArg->pszCtxType);

}

generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);

ScmStreamPrintf(pStrm,

");\n"

"# define %s_ENABLED() \\\n"

" (RT_UNLIKELY(g_cVTGProbeEnabled_%s_%s)) \n"

"# define %s("

, szTmp,

pProv->pszName, pProbe->pszMangledName,

szTmp);

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))

ScmStreamPrintf(pStrm, "%s", pArg->pszName);

else

ScmStreamPrintf(pStrm, ", %s", pArg->pszName);

}

ScmStreamPrintf(pStrm,

") \\\n"

" do { \\\n"

" if (RT_UNLIKELY(g_cVTGProbeEnabled_%s_%s)) \\\n"

" { \\\n"

" VTG_DECL_VTGPROBELOC(s_VTGProbeLoc) = \\\n"

" { __LINE__, 0, 0, __FUNCTION__, &g_VTGProbeData_%s_%s }; \\\n"

" VTGProbeStub_%s_%s(&s_VTGProbeLoc",

pProv->pszName, pProbe->pszMangledName,

pProv->pszName, pProbe->pszMangledName,

pProv->pszName, pProbe->pszMangledName);

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

ScmStreamPrintf(pStrm, pArg->pszArgPassingFmt, pArg->pszName);

}

ScmStreamPrintf(pStrm,

"); \\\n"

" } \\\n"

" { \\\n" );

uint32_t iArg = 0;

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

if ((pArg->fType & (VTG_TYPE_FIXED_SIZED | VTG_TYPE_AUTO_CONV_PTR)) == VTG_TYPE_FIXED_SIZED)

ScmStreamPrintf(pStrm,

" AssertCompile(sizeof(%s) == %u); \\\n"

" AssertCompile(sizeof(%s) <= %u); \\\n",

pArg->pszTracerType, pArg->fType & VTG_TYPE_SIZE_MASK,

pArg->pszName, pArg->fType & VTG_TYPE_SIZE_MASK);

else if (pArg->fType & (VTG_TYPE_POINTER | VTG_TYPE_HC_ARCH_SIZED))

ScmStreamPrintf(pStrm,

" AssertCompile(sizeof(%s) <= sizeof(uintptr_t)); \\\n"

" AssertCompile(sizeof(%s) <= sizeof(uintptr_t)); \\\n",

pArg->pszName,

pArg->pszTracerType);

iArg++;

}

ScmStreamPrintf(pStrm,

" } \\\n"

" } while (0)\n"

"\n");

}

}

ScmStreamPrintf(pStrm,

"\n"

"#else\n"

"\n");

RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)

{

RTListForEach(&pProv->ProbeHead, pProbe, VTGPROBE, ListEntry)

{

generateProbeDefineName(szTmp, sizeof(szTmp), pProv->pszName, pProbe->pszMangledName);

ScmStreamPrintf(pStrm,

"# define %s_ENABLED() (false)\n"

"# define %s("

, szTmp, szTmp);

RTListForEach(&pProbe->ArgHead, pArg, VTGARG, ListEntry)

{

if (RTListNodeIsFirst(&pProbe->ArgHead, &pArg->ListEntry))

ScmStreamPrintf(pStrm, "%s", pArg->pszName);

else

ScmStreamPrintf(pStrm, ", %s", pArg->pszName);

}

ScmStreamPrintf(pStrm,

") do { } while (0)\n");

}

}

ScmStreamWrite(pStrm, RT_STR_TUPLE("\n"

"#endif\n"

"\n"

"RT_C_DECLS_END\n"

"#endif\n"));

return RTEXITCODE_SUCCESS;

}

static RTEXITCODE generateHeader(const char *pszHeader)

{

return generateFile(pszHeader, "header", generateHeaderInner);

}

static RTEXITCODE parseError(PSCMSTREAM pStrm, size_t cb, const char *pszMsg)

{

if (cb)

ScmStreamSeekRelative(pStrm, -(ssize_t)cb);

size_t const off = ScmStreamTell(pStrm);

size_t const iLine = ScmStreamTellLine(pStrm);

ScmStreamSeekByLine(pStrm, iLine);

size_t const offLine = ScmStreamTell(pStrm);

RTPrintf("%s:%d:%zd: error: %s.\n", g_pszScript, iLine + 1, off - offLine + 1, pszMsg);

size_t cchLine;

SCMEOL enmEof;

const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);

if (pszLine)

RTPrintf(" %.*s\n"

" %*s^\n",

cchLine, pszLine, off - offLine, "");

return RTEXITCODE_FAILURE;

}

static RTEXITCODE parseErrorAbs(PSCMSTREAM pStrm, size_t off, const char *pszMsg)

{

ScmStreamSeekAbsolute(pStrm, off);

return parseError(pStrm, 0, pszMsg);

}

static RTEXITCODE parseOneLineComment(PSCMSTREAM pStrm)

{

ScmStreamSeekByLine(pStrm, ScmStreamTellLine(pStrm) + 1);

return RTEXITCODE_SUCCESS;

}

static RTEXITCODE parseMultiLineComment(PSCMSTREAM pStrm)

{

unsigned ch;

while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)

{

if (ch == '*')

{

do

ch = ScmStreamGetCh(pStrm);

while (ch == '*');

if (ch == '/')

return RTEXITCODE_SUCCESS;

}

}

parseError(pStrm, 1, "Expected end of comment, got end of file");

return RTEXITCODE_FAILURE;

}

static RTEXITCODE parseSkipSpacesAndComments(PSCMSTREAM pStrm)

{

unsigned ch;

while ((ch = ScmStreamPeekCh(pStrm)) != ~(unsigned)0)

{

if (!RT_C_IS_SPACE(ch) && ch != '/')

return RTEXITCODE_SUCCESS;

unsigned ch2 = ScmStreamGetCh(pStrm); AssertBreak(ch == ch2); NOREF(ch2);

if (ch == '/')

{

ch = ScmStreamGetCh(pStrm);

RTEXITCODE rcExit;

if (ch == '*')

rcExit = parseMultiLineComment(pStrm);

else if (ch == '/')

rcExit = parseOneLineComment(pStrm);

else

rcExit = parseError(pStrm, 2, "Unexpected character");

if (rcExit != RTEXITCODE_SUCCESS)

return rcExit;

}

}

return parseError(pStrm, 0, "Unexpected end of file");

}

static unsigned parseGetNextNonSpaceNonCommentCh(PSCMSTREAM pStrm)

{

unsigned ch;

while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)

{

if (!RT_C_IS_SPACE(ch) && ch != '/')

return ch;

if (ch == '/')

{

ch = ScmStreamGetCh(pStrm);

RTEXITCODE rcExit;

if (ch == '*')

rcExit = parseMultiLineComment(pStrm);

else if (ch == '/')

rcExit = parseOneLineComment(pStrm);

else

rcExit = parseError(pStrm, 2, "Unexpected character");

if (rcExit != RTEXITCODE_SUCCESS)

return ~(unsigned)0;

}

}

parseError(pStrm, 0, "Unexpected end of file");

return ~(unsigned)0;

}

static unsigned parseGetNextNonSpaceNonCommentChOnPpLine(PSCMSTREAM pStrm)

{

size_t off = ScmStreamTell(pStrm) - 1;

unsigned ch;

while ((ch = ScmStreamGetCh(pStrm)) != ~(unsigned)0)

{

if (RT_C_IS_SPACE(ch))

{

if (ch == '\n' || ch == '\r')

{

parseErrorAbs(pStrm, off, "Invalid preprocessor statement");

break;

}

}

else if (ch == '\\')

{

size_t off2 = ScmStreamTell(pStrm) - 1;

ch = ScmStreamGetCh(pStrm);

if (ch == '\r')

ch = ScmStreamGetCh(pStrm);

if (ch != '\n')

{

parseErrorAbs(pStrm, off2, "Expected new line");

break;

}

}

else

return ch;

}

return ~(unsigned)0;

}

static const char *parseGetNextCWord(PSCMSTREAM pStrm, size_t *pcchWord)

{

if (parseSkipSpacesAndComments(pStrm) != RTEXITCODE_SUCCESS)

return NULL;

return ScmStreamCGetWord(pStrm, pcchWord);

}

static kVTGStability parseStability(PSCMSTREAM pStrm, unsigned ch)

{

switch (ch)

{

case 'E':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("External")))

return kVTGStability_External;

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Evolving")))

return kVTGStability_Evolving;

break;

case 'I':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Internal")))

return kVTGStability_Internal;

break;

case 'O':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Obsolete")))

return kVTGStability_Obsolete;

break;

case 'P':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Private")))

return kVTGStability_Private;

break;

case 'S':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Stable")))

return kVTGStability_Stable;

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Standard")))

return kVTGStability_Standard;

break;

case 'U':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Unstable")))

return kVTGStability_Unstable;

break;

}

parseError(pStrm, 1, "Unknown stability specifier");

return kVTGStability_Invalid;

}

static kVTGClass parseDataDepClass(PSCMSTREAM pStrm, unsigned ch)

{

switch (ch)

{

case 'C':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Common")))

return kVTGClass_Common;

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Cpu")))

return kVTGClass_Cpu;

break;

case 'G':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Group")))

return kVTGClass_Group;

break;

case 'I':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Isa")))

return kVTGClass_Isa;

break;

case 'P':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Platform")))

return kVTGClass_Platform;

break;

case 'U':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("Unknown")))

return kVTGClass_Unknown;

break;

}

parseError(pStrm, 1, "Unknown data dependency class specifier");

return kVTGClass_Invalid;

}

static RTEXITCODE parsePragmaDAttributes(PSCMSTREAM pStrm)

{

/*

unsigned ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);

if (ch == ~(unsigned)0)

return RTEXITCODE_FAILURE;

kVTGStability enmCode = parseStability(pStrm, ch);

if (enmCode == kVTGStability_Invalid)

return RTEXITCODE_FAILURE;

ch = ScmStreamGetCh(pStrm);

if (ch != '/')

return parseError(pStrm, 1, "Expected '/' following the code stability specifier");

kVTGStability enmData = parseStability(pStrm, ScmStreamGetCh(pStrm));

if (enmData == kVTGStability_Invalid)

return RTEXITCODE_FAILURE;

ch = ScmStreamGetCh(pStrm);

if (ch != '/')

return parseError(pStrm, 1, "Expected '/' following the data stability specifier");

kVTGClass enmDataDep = parseDataDepClass(pStrm, ScmStreamGetCh(pStrm));

if (enmDataDep == kVTGClass_Invalid)

return RTEXITCODE_FAILURE;

/*

ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);

if (ch == ~(unsigned)0)

return RTEXITCODE_FAILURE;

if (ch != 'p' || !ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("provider")))

return parseError(pStrm, 1, "Expected 'provider'");

size_t cchName;

const char *pszName = parseGetNextCWord(pStrm, &cchName);

if (!pszName)

return parseError(pStrm, 1, "Expected provider name");

PVTGPROVIDER pProv;

RTListForEach(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry)

{

if ( !strncmp(pProv->pszName, pszName, cchName)

&& pProv->pszName[cchName] == '\0')

break;

}

if (RTListNodeIsDummy(&g_ProviderHead, pProv, VTGPROVIDER, ListEntry))

return parseError(pStrm, cchName, "Provider not found");

/*

size_t cchAspect;

const char *pszAspect = parseGetNextCWord(pStrm, &cchAspect);

if (!pszAspect)

return parseError(pStrm, 1, "Expected provider aspect");

PVTGATTRS pAttrs;

if (cchAspect == 8 && !memcmp(pszAspect, "provider", 8))

pAttrs = &pProv->AttrSelf;

else if (cchAspect == 8 && !memcmp(pszAspect, "function", 8))

pAttrs = &pProv->AttrFunctions;

else if (cchAspect == 6 && !memcmp(pszAspect, "module", 6))

pAttrs = &pProv->AttrModules;

else if (cchAspect == 4 && !memcmp(pszAspect, "name", 4))

pAttrs = &pProv->AttrName;

else if (cchAspect == 4 && !memcmp(pszAspect, "args", 4))

pAttrs = &pProv->AttrArguments;

else

return parseError(pStrm, cchAspect, "Unknown aspect");

if (pAttrs->enmCode != kVTGStability_Invalid)

return parseError(pStrm, cchAspect, "You have already specified these attributes");

pAttrs->enmCode = enmCode;

pAttrs->enmData = enmData;

pAttrs->enmDataDep = enmDataDep;

return RTEXITCODE_SUCCESS;

}

static RTEXITCODE parsePragma(PSCMSTREAM pStrm)

{

RTEXITCODE rcExit;

unsigned ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);

if (ch == ~(unsigned)0)

rcExit = RTEXITCODE_FAILURE;

else if (ch == 'D' && ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("D")))

{

ch = parseGetNextNonSpaceNonCommentChOnPpLine(pStrm);

if (ch == ~(unsigned)0)

rcExit = RTEXITCODE_FAILURE;

else if (ch == 'a' && ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("attributes")))

rcExit = parsePragmaDAttributes(pStrm);

else

rcExit = parseError(pStrm, 1, "Unknown pragma D");

}

else

rcExit = parseError(pStrm, 1, "Unknown pragma");

return rcExit;

}

static uint32_t parseTypeExpression(const char *pszType)

{

size_t cchType = strlen(pszType);

#define MY_STRMATCH(a_sz) (cchType == sizeof(a_sz) - 1 && !memcmp(a_sz, pszType, sizeof(a_sz) - 1))

/*

if (pszType[cchType - 1] == '*') return VTG_TYPE_POINTER;

if (pszType[cchType - 1] == '&')

{

RTMsgWarning("Please avoid using references like '%s' for probe arguments!", pszType);

return VTG_TYPE_POINTER;

}

/*

if (MY_STRMATCH("int")) return VTG_TYPE_FIXED_SIZED | sizeof(int) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("uintptr_t")) return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("intptr_t")) return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_SIGNED;

//if (MY_STRMATCH("uint128_t")) return VTG_TYPE_FIXED_SIZED | sizeof(uint128_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("uint64_t")) return VTG_TYPE_FIXED_SIZED | sizeof(uint64_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("uint32_t")) return VTG_TYPE_FIXED_SIZED | sizeof(uint32_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("uint16_t")) return VTG_TYPE_FIXED_SIZED | sizeof(uint16_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("uint8_t")) return VTG_TYPE_FIXED_SIZED | sizeof(uint8_t) | VTG_TYPE_UNSIGNED;

//if (MY_STRMATCH("int128_t")) return VTG_TYPE_FIXED_SIZED | sizeof(int128_t) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("int64_t")) return VTG_TYPE_FIXED_SIZED | sizeof(int64_t) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("int32_t")) return VTG_TYPE_FIXED_SIZED | sizeof(int32_t) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("int16_t")) return VTG_TYPE_FIXED_SIZED | sizeof(int16_t) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("int8_t")) return VTG_TYPE_FIXED_SIZED | sizeof(int8_t) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTUINT64U")) return VTG_TYPE_FIXED_SIZED | sizeof(uint64_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTUINT32U")) return VTG_TYPE_FIXED_SIZED | sizeof(uint32_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTUINT16U")) return VTG_TYPE_FIXED_SIZED | sizeof(uint16_t) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTMSINTERVAL")) return VTG_TYPE_FIXED_SIZED | sizeof(RTMSINTERVAL) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTTIMESPEC")) return VTG_TYPE_FIXED_SIZED | sizeof(RTTIMESPEC) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTPROCESS")) return VTG_TYPE_FIXED_SIZED | sizeof(RTPROCESS) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTHCPHYS")) return VTG_TYPE_FIXED_SIZED | sizeof(RTHCPHYS) | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS;

if (MY_STRMATCH("RTR3PTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3;

if (MY_STRMATCH("RTR0PTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0;

if (MY_STRMATCH("RTRCPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_RC;

if (MY_STRMATCH("RTHCPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0;

if (MY_STRMATCH("RTR3UINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTR0UINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0 | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTRCUINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_RC | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTHCUINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTR3INTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTR0INTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0 | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTRCINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_RC | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTHCINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTUINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_CTX_RC | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTINTPTR")) return VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_CTX_RC | VTG_TYPE_SIGNED;

if (MY_STRMATCH("RTHCUINTREG")) return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_CTX_R3 | VTG_TYPE_CTX_R0 | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTR3UINTREG")) return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_CTX_R3 | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTR0UINTREG")) return VTG_TYPE_HC_ARCH_SIZED | VTG_TYPE_CTX_R3 | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("RTGCUINTREG")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCUINTREG) | VTG_TYPE_UNSIGNED | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCPTR")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPTR) | VTG_TYPE_UNSIGNED | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCINTPTR")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCUINTPTR) | VTG_TYPE_SIGNED | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCPTR32")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPTR32) | VTG_TYPE_SIGNED | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCPTR64")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPTR64) | VTG_TYPE_SIGNED | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCPHYS")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPHYS) | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCPHYS32")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPHYS32) | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS | VTG_TYPE_CTX_GST;

if (MY_STRMATCH("RTGCPHYS64")) return VTG_TYPE_FIXED_SIZED | sizeof(RTGCPHYS64) | VTG_TYPE_UNSIGNED | VTG_TYPE_PHYS | VTG_TYPE_CTX_GST;

/*

if (MY_STRMATCH("PVM")) return VTG_TYPE_POINTER;

if (MY_STRMATCH("PVMCPU")) return VTG_TYPE_POINTER;

if (MY_STRMATCH("PCPUMCTX")) return VTG_TYPE_POINTER;

/*

if ( MY_STRMATCH("unsigned long")

|| MY_STRMATCH("unsigned long long")

|| MY_STRMATCH("signed long")

|| MY_STRMATCH("signed long long")

|| MY_STRMATCH("long")

|| MY_STRMATCH("long long")

|| MY_STRMATCH("char")

|| MY_STRMATCH("signed char")

|| MY_STRMATCH("unsigned char")

|| MY_STRMATCH("double")

|| MY_STRMATCH("long double")

|| MY_STRMATCH("float")

)

{

RTMsgError("Please do NOT use the type '%s' for probe arguments!", pszType);

g_cTypeErrors++;

return 0;

}

if ( MY_STRMATCH("unsigned")

|| MY_STRMATCH("signed")

|| MY_STRMATCH("signed int")

|| MY_STRMATCH("unsigned int")

|| MY_STRMATCH("short")

|| MY_STRMATCH("signed short")

|| MY_STRMATCH("unsigned short")

)

RTMsgWarning("Please avoid using the type '%s' for probe arguments!", pszType);

if (MY_STRMATCH("unsigned")) return VTG_TYPE_FIXED_SIZED | sizeof(int) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("unsigned int")) return VTG_TYPE_FIXED_SIZED | sizeof(int) | VTG_TYPE_UNSIGNED;

if (MY_STRMATCH("signed")) return VTG_TYPE_FIXED_SIZED | sizeof(int) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("signed int")) return VTG_TYPE_FIXED_SIZED | sizeof(int) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("short")) return VTG_TYPE_FIXED_SIZED | sizeof(short) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("signed short")) return VTG_TYPE_FIXED_SIZED | sizeof(short) | VTG_TYPE_SIGNED;

if (MY_STRMATCH("unsigned short")) return VTG_TYPE_FIXED_SIZED | sizeof(short) | VTG_TYPE_UNSIGNED;

/*

if (pszType[0] == 'P')

{

RTMsgError("Type '%s' looks like a pointer typedef, please do NOT use those "

"but rather the non-pointer typedef or struct with '*'",

pszType);

g_cTypeErrors++;

return VTG_TYPE_POINTER;

}

RTMsgError("Don't know '%s' - please change or fix VBoxTpG", pszType);

g_cTypeErrors++;

#undef MY_STRCMP

return 0;

}

static RTEXITCODE parseInitArgument(PVTGPROBE pProbe, PVTGARG pArg, PSCMSTREAM pStrm,

char *pchType, size_t cchType, char *pchName, size_t cchName)

{

Assert(!pArg->pszName); Assert(!pArg->pszTracerType); Assert(!pArg->pszCtxType); Assert(!pArg->fType);

pArg->pszArgPassingFmt = ", %s";

pArg->pszName = RTStrDupN(pchName, cchName);

pArg->pszTracerType = strtabInsertN(pchType, cchType);

if (!pArg->pszTracerType || !pArg->pszName)

return parseError(pStrm, 1, "Out of memory");

pArg->fType = parseTypeExpression(pArg->pszTracerType);

if ( (pArg->fType & VTG_TYPE_POINTER)

&& !(g_fTypeContext & VTG_TYPE_CTX_R0) )

{

pArg->fType &= ~VTG_TYPE_POINTER;

if ( !strcmp(pArg->pszTracerType, "struct VM *") || !strcmp(pArg->pszTracerType, "PVM")

|| !strcmp(pArg->pszTracerType, "struct VMCPU *") || !strcmp(pArg->pszTracerType, "PVMCPU")

|| !strcmp(pArg->pszTracerType, "struct CPUMCTX *") || !strcmp(pArg->pszTracerType, "PCPUMCTX")

)

{

pArg->fType |= VTG_TYPE_CTX_POINTER | VTG_TYPE_CTX_R0

| VTG_TYPE_FIXED_SIZED | (g_cHostBits / 8)

| VTG_TYPE_AUTO_CONV_PTR;

pArg->pszCtxType = RTStrDup("RTR0PTR");

if (!strcmp(pArg->pszTracerType, "struct VM *") || !strcmp(pArg->pszTracerType, "PVM"))

pArg->pszArgPassingFmt = ", VTG_VM_TO_R0(%s)";

else if (!strcmp(pArg->pszTracerType, "struct VMCPU *") || !strcmp(pArg->pszTracerType, "PVMCPU"))

pArg->pszArgPassingFmt = ", VTG_VMCPU_TO_R0(%s)";

else

{

PVTGARG pFirstArg = RTListGetFirst(&pProbe->ArgHead, VTGARG, ListEntry);

if ( !pFirstArg

|| pFirstArg == pArg

|| strcmp(pFirstArg->pszName, "a_pVCpu")

|| ( strcmp(pFirstArg->pszTracerType, "struct VMCPU *")

&& strcmp(pFirstArg->pszTracerType, "PVMCPU *")) )

return parseError(pStrm, 1, "The automatic ring-0 pointer conversion requires 'a_pVCpu' with type 'struct VMCPU *' as the first argument");

if (!strcmp(pArg->pszTracerType, "struct CPUMCTX *")|| !strcmp(pArg->pszTracerType, "PCPUMCTX"))

pArg->pszArgPassingFmt = ", VTG_CPUMCTX_TO_R0(a_pVCpu, %s)";

else

pArg->pszArgPassingFmt = ", VBoxTpG-Is-Buggy!!";

}

}

else

{

pArg->fType |= VTG_TYPE_CTX_POINTER | g_fTypeContext | VTG_TYPE_FIXED_SIZED | (g_cBits / 8);

pArg->pszCtxType = RTStrDupN(pchType, cchType);

}

}

else

pArg->pszCtxType = RTStrDupN(pchType, cchType);

if (!pArg->pszCtxType)

return parseError(pStrm, 1, "Out of memory");

return RTEXITCODE_SUCCESS;

}

static const char *parseUnmangleProbeName(const char *pszMangled)

{

size_t cchMangled = strlen(pszMangled);

char *pszTmp = (char *)alloca(cchMangled + 2);

const char *pszSrc = pszMangled;

char *pszDst = pszTmp;

while (*pszSrc)

{

if (pszSrc[0] == '_' && pszSrc[1] == '_' && pszSrc[2] != '_')

{

*pszDst++ = '-';

pszSrc += 2;

}

else

*pszDst++ = *pszSrc++;

}

*pszDst = '\0';

return strtabInsertN(pszTmp, pszDst - pszTmp);

}

static RTEXITCODE parseProbe(PSCMSTREAM pStrm, PVTGPROVIDER pProv)

{

/*

size_t cchProbe;

const char *pszProbe = parseGetNextCWord(pStrm, &cchProbe);

if (!pszProbe)

return parseError(pStrm, 1, "Expected a probe name starting with an alphabetical character");

unsigned ch = parseGetNextNonSpaceNonCommentCh(pStrm);

if (ch != '(')

return parseError(pStrm, 1, "Expected '(' after the probe name");

/*

PVTGPROBE pProbe = (PVTGPROBE)RTMemAllocZ(sizeof(*pProbe));

if (!pProbe)

return parseError(pStrm, 0, "Out of memory");

RTListInit(&pProbe->ArgHead);

RTListAppend(&pProv->ProbeHead, &pProbe->ListEntry);

pProbe->offArgList = UINT32_MAX;

pProbe->pszMangledName = RTStrDupN(pszProbe, cchProbe);

if (!pProbe->pszMangledName)

return parseError(pStrm, 0, "Out of memory");

pProbe->pszUnmangledName = parseUnmangleProbeName(pProbe->pszMangledName);

if (!pProbe->pszUnmangledName)

return parseError(pStrm, 0, "Out of memory");

/*

PVTGARG pArg = NULL;

size_t cchName = 0;

size_t cchArg = 0;

char szArg[4096];

for (;;)

{

ch = parseGetNextNonSpaceNonCommentCh(pStrm);

switch (ch)

{

case ')':

case ',':

{

/* commit the argument */

if (pArg)

{

if (!cchName)

return parseError(pStrm, 1, "Argument has no name");

if (cchArg - cchName - 1 >= 128)

return parseError(pStrm, 1, "Argument type too long");

RTEXITCODE rcExit = parseInitArgument(pProbe, pArg, pStrm,

szArg, cchArg - cchName - 1,

&szArg[cchArg - cchName], cchName);

if (rcExit != RTEXITCODE_SUCCESS)

return rcExit;

if (VTG_TYPE_IS_LARGE(pArg->fType))

pProbe->fHaveLargeArgs = true;

pArg = NULL;

cchName = cchArg = 0;

}

if (ch == ')')

{

size_t off = ScmStreamTell(pStrm);

ch = parseGetNextNonSpaceNonCommentCh(pStrm);

if (ch != ';')

return parseErrorAbs(pStrm, off, "Expected ';'");

return RTEXITCODE_SUCCESS;

}

break;

}

default:

{

size_t cchWord;

const char *pszWord = ScmStreamCGetWordM1(pStrm, &cchWord);

if (!pszWord)

return parseError(pStrm, 0, "Expected argument");

if (!pArg)

{

pArg = (PVTGARG)RTMemAllocZ(sizeof(*pArg));

if (!pArg)

return parseError(pStrm, 1, "Out of memory");

RTListAppend(&pProbe->ArgHead, &pArg->ListEntry);

pProbe->cArgs++;

if (cchWord + 1 > sizeof(szArg))

return parseError(pStrm, 1, "Too long parameter declaration");

memcpy(szArg, pszWord, cchWord);

szArg[cchWord] = '\0';

cchArg = cchWord;

cchName = 0;

}

else

{

if (cchArg + 1 + cchWord + 1 > sizeof(szArg))

return parseError(pStrm, 1, "Too long parameter declaration");

szArg[cchArg++] = ' ';

memcpy(&szArg[cchArg], pszWord, cchWord);

cchArg += cchWord;

szArg[cchArg] = '\0';

cchName = cchWord;

}

break;

}

case '*':

{

if (!pArg)

return parseError(pStrm, 1, "A parameter type does not start with an asterix");

if (cchArg + sizeof(" *") >= sizeof(szArg))

return parseError(pStrm, 1, "Too long parameter declaration");

szArg[cchArg++] = ' ';

szArg[cchArg++] = '*';

szArg[cchArg ] = '\0';

cchName = 0;

break;

}

case ~(unsigned)0:

return parseError(pStrm, 0, "Missing closing ')' on probe");

}

}

}

static RTEXITCODE parseProvider(PSCMSTREAM pStrm)

{

/*

RTEXITCODE rcExit = parseSkipSpacesAndComments(pStrm);

if (rcExit != RTEXITCODE_SUCCESS)

return parseError(pStrm, 1, "Expected a provider name starting with an alphabetical character");

size_t cchName;

const char *pszName = ScmStreamCGetWord(pStrm, &cchName);

if (!pszName)

return parseError(pStrm, 0, "Bad provider name");

if (RT_C_IS_DIGIT(pszName[cchName - 1]))

return parseError(pStrm, 1, "A provider name cannot end with digit");

unsigned ch = parseGetNextNonSpaceNonCommentCh(pStrm);

if (ch != '{')

return parseError(pStrm, 1, "Expected '{' after the provider name");

/*

PVTGPROVIDER pProv = (PVTGPROVIDER)RTMemAllocZ(sizeof(*pProv));

if (!pProv)

return parseError(pStrm, 0, "Out of memory");

RTListInit(&pProv->ProbeHead);

RTListAppend(&g_ProviderHead, &pProv->ListEntry);

pProv->pszName = strtabInsertN(pszName, cchName);

if (!pProv->pszName)

return parseError(pStrm, 0, "Out of memory");

/*

for (;;)

{

ch = parseGetNextNonSpaceNonCommentCh(pStrm);

switch (ch)

{

case 'p':

if (ScmStreamCMatchingWordM1(pStrm, RT_STR_TUPLE("probe")))

rcExit = parseProbe(pStrm, pProv);

else

rcExit = parseError(pStrm, 1, "Unexpected character");

break;

case '}':

{

size_t off = ScmStreamTell(pStrm);

ch = parseGetNextNonSpaceNonCommentCh(pStrm);

if (ch == ';')

return RTEXITCODE_SUCCESS;

rcExit = parseErrorAbs(pStrm, off, "Expected ';'");

break;

}

case ~(unsigned)0:

rcExit = parseError(pStrm, 0, "Missing closing '}' on provider");

break;

default:

rcExit = parseError(pStrm, 1, "Unexpected character");

break;

}

if (rcExit != RTEXITCODE_SUCCESS)

return rcExit;

}

}

static RTEXITCODE parseScript(const char *pszScript)

{

SCMSTREAM Strm;

int rc = ScmStreamInitForReading(&Strm, pszScript);

if (RT_FAILURE(rc))

return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open & read '%s' into memory: %Rrc", pszScript, rc);

if (g_cVerbosity > 0)

RTMsgInfo("Parsing '%s'...", pszScript);

RTEXITCODE rcExit = RTEXITCODE_SUCCESS;

unsigned ch;

while ((ch = ScmStreamGetCh(&Strm)) != ~(unsigned)0)

{

if (RT_C_IS_SPACE(ch))

continue;

switch (ch)

{

case '/':

ch = ScmStreamGetCh(&Strm);

if (ch == '*')

rcExit = parseMultiLineComment(&Strm);

else if (ch == '/')

rcExit = parseOneLineComment(&Strm);

else

rcExit = parseError(&Strm, 2, "Unexpected character");

break;

case 'p':

if (ScmStreamCMatchingWordM1(&Strm, RT_STR_TUPLE("provider")))

rcExit = parseProvider(&Strm);

else

rcExit = parseError(&Strm, 1, "Unexpected character");

break;

case '#':

{

ch = parseGetNextNonSpaceNonCommentChOnPpLine(&Strm);

if (ch == ~(unsigned)0)

rcExit = RTEXITCODE_FAILURE;

else if (ch == 'p' && ScmStreamCMatchingWordM1(&Strm, RT_STR_TUPLE("pragma")))

rcExit = parsePragma(&Strm);

else

rcExit = parseError(&Strm, 1, "Unsupported preprocessor directive");

break;

}

default:

rcExit = parseError(&Strm, 1, "Unexpected character");

break;

}

if (rcExit != RTEXITCODE_SUCCESS)

return rcExit;

}

ScmStreamDelete(&Strm);

if (g_cVerbosity > 0 && rcExit == RTEXITCODE_SUCCESS)

RTMsgInfo("Successfully parsed '%s'.", pszScript);

return rcExit;

}

static RTEXITCODE parseArguments(int argc, char **argv)

{

/*

int rc = RTPathAbs(g_pszAssemblerIncVal, g_szAssemblerIncVal, sizeof(g_szAssemblerIncVal) - 1);

if (RT_FAILURE(rc))

return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTPathAbs failed: %Rrc", rc);

strcat(g_szAssemblerIncVal, "/");

g_pszAssemblerIncVal = g_szAssemblerIncVal;

/*

enum

{

kVBoxTpGOpt_32Bit = 1000,

kVBoxTpGOpt_64Bit,

kVBoxTpGOpt_Assembler,

kVBoxTpGOpt_AssemblerFmtOpt,

kVBoxTpGOpt_AssemblerFmtVal,

kVBoxTpGOpt_AssemblerOutputOpt,

kVBoxTpGOpt_AssemblerOption,

kVBoxTpGOpt_Pic,

kVBoxTpGOpt_ProbeFnName,

kVBoxTpGOpt_ProbeFnImported,

kVBoxTpGOpt_ProbeFnNotImported,

kVBoxTpGOpt_Host32Bit,

kVBoxTpGOpt_Host64Bit,

kVBoxTpGOpt_RawModeContext,

kVBoxTpGOpt_Ring0Context,

kVBoxTpGOpt_Ring3Context,

kVBoxTpGOpt_End

};

static RTGETOPTDEF const s_aOpts[] =

{

/* dtrace w/ long options */

{ "-32", kVBoxTpGOpt_32Bit, RTGETOPT_REQ_NOTHING },

{ "-64", kVBoxTpGOpt_64Bit, RTGETOPT_REQ_NOTHING },

{ "--apply-cpp", 'C', RTGETOPT_REQ_NOTHING },

{ "--generate-obj", 'G', RTGETOPT_REQ_NOTHING },

{ "--generate-header", 'h', RTGETOPT_REQ_NOTHING },

{ "--output", 'o', RTGETOPT_REQ_STRING },

{ "--script", 's', RTGETOPT_REQ_STRING },

{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },

/* our stuff */

{ "--assembler", kVBoxTpGOpt_Assembler, RTGETOPT_REQ_STRING },

{ "--assembler-fmt-opt", kVBoxTpGOpt_AssemblerFmtOpt, RTGETOPT_REQ_STRING },

{ "--assembler-fmt-val", kVBoxTpGOpt_AssemblerFmtVal, RTGETOPT_REQ_STRING },

{ "--assembler-output-opt", kVBoxTpGOpt_AssemblerOutputOpt, RTGETOPT_REQ_STRING },

{ "--assembler-option", kVBoxTpGOpt_AssemblerOption, RTGETOPT_REQ_STRING },

{ "--pic", kVBoxTpGOpt_Pic, RTGETOPT_REQ_NOTHING },

{ "--probe-fn-name", kVBoxTpGOpt_ProbeFnName, RTGETOPT_REQ_STRING },

{ "--probe-fn-imported", kVBoxTpGOpt_ProbeFnImported, RTGETOPT_REQ_NOTHING },

{ "--probe-fn-not-imported", kVBoxTpGOpt_ProbeFnNotImported, RTGETOPT_REQ_NOTHING },

{ "--host-32-bit", kVBoxTpGOpt_Host32Bit, RTGETOPT_REQ_NOTHING },

{ "--host-64-bit", kVBoxTpGOpt_Host64Bit, RTGETOPT_REQ_NOTHING },

{ "--raw-mode-context", kVBoxTpGOpt_RawModeContext, RTGETOPT_REQ_NOTHING },

{ "--ring-0-context", kVBoxTpGOpt_Ring0Context, RTGETOPT_REQ_NOTHING },

{ "--ring-3-context", kVBoxTpGOpt_Ring3Context, RTGETOPT_REQ_NOTHING },

/** @todo We're missing a bunch of assembler options! */

};

RTGETOPTUNION ValueUnion;

RTGETOPTSTATE GetOptState;

rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);

AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);

/*

while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)

{

switch (rc)

{

/*

case kVBoxTpGOpt_32Bit:

g_cHostBits = g_cBits = 32;

g_pszAssemblerFmtVal = g_szAssemblerFmtVal32;

break;

case kVBoxTpGOpt_64Bit:

g_cHostBits = g_cBits = 64;

g_pszAssemblerFmtVal = g_szAssemblerFmtVal64;

break;

case 'C':

g_fApplyCpp = true;

RTMsgWarning("Ignoring the -C option - no preprocessing of the D script will be performed");

break;

case 'G':

if ( g_enmAction != kVBoxTpGAction_Nothing

&& g_enmAction != kVBoxTpGAction_GenerateObject)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "-G and -h does not mix");

g_enmAction = kVBoxTpGAction_GenerateObject;

break;

case 'h':

if (!strcmp(GetOptState.pDef->pszLong, "--generate-header"))

{

if ( g_enmAction != kVBoxTpGAction_Nothing

&& g_enmAction != kVBoxTpGAction_GenerateHeader)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "-h and -G does not mix");

g_enmAction = kVBoxTpGAction_GenerateHeader;

}

else

{

/* --help or similar */

RTPrintf("VirtualBox Tracepoint Generator\n"

"\n"

"Usage: %s [options]\n"

"\n"

"Options:\n", RTProcShortName());

for (size_t i = 0; i < RT_ELEMENTS(s_aOpts); i++)

if ((unsigned)s_aOpts[i].iShort < 128)

RTPrintf(" -%c,%s\n", s_aOpts[i].iShort, s_aOpts[i].pszLong);

else

RTPrintf(" %s\n", s_aOpts[i].pszLong);

return RTEXITCODE_SUCCESS;

}

break;

case 'o':

if (g_pszOutput)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Output file is already set to '%s'", g_pszOutput);

g_pszOutput = ValueUnion.psz;

break;

case 's':

if (g_pszScript)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Script file is already set to '%s'", g_pszScript);

g_pszScript = ValueUnion.psz;

break;

case 'v':

g_cVerbosity++;

break;

case 'V':

{

/* The following is assuming that svn does it's job here. */

static const char s_szRev[] = "$Revision$";

const char *psz = RTStrStripL(strchr(s_szRev, ' '));

RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);

return RTEXITCODE_SUCCESS;

}

case VINF_GETOPT_NOT_OPTION:

if (g_enmAction == kVBoxTpGAction_GenerateObject)

break; /* object files, ignore them. */

return RTGetOptPrintError(rc, &ValueUnion);

/*

case kVBoxTpGOpt_Assembler:

g_pszAssembler = ValueUnion.psz;

break;

case kVBoxTpGOpt_AssemblerFmtOpt:

g_pszAssemblerFmtOpt = ValueUnion.psz;

break;

case kVBoxTpGOpt_AssemblerFmtVal:

g_pszAssemblerFmtVal = ValueUnion.psz;

break;

case kVBoxTpGOpt_AssemblerOutputOpt:

g_pszAssemblerOutputOpt = ValueUnion.psz;

break;

case kVBoxTpGOpt_AssemblerOption:

if (g_cAssemblerOptions >= RT_ELEMENTS(g_apszAssemblerOptions))

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Too many assembly options (max %u)", RT_ELEMENTS(g_apszAssemblerOptions));

g_apszAssemblerOptions[g_cAssemblerOptions] = ValueUnion.psz;

g_cAssemblerOptions++;

break;

case kVBoxTpGOpt_Pic:

g_fPic = true;

break;

case kVBoxTpGOpt_ProbeFnName:

g_pszProbeFnName = ValueUnion.psz;

break;

case kVBoxTpGOpt_ProbeFnImported:

g_fProbeFnImported = true;

break;

case kVBoxTpGOpt_ProbeFnNotImported:

g_fProbeFnImported = false;

break;

case kVBoxTpGOpt_Host32Bit:

g_cHostBits = 32;

break;

case kVBoxTpGOpt_Host64Bit:

g_cHostBits = 64;

break;

case kVBoxTpGOpt_RawModeContext:

g_fTypeContext = VTG_TYPE_CTX_RC;

break;

case kVBoxTpGOpt_Ring0Context:

g_fTypeContext = VTG_TYPE_CTX_R0;

break;

case kVBoxTpGOpt_Ring3Context:

g_fTypeContext = VTG_TYPE_CTX_R3;

break;

/*

default:

return RTGetOptPrintError(rc, &ValueUnion);

}

}

/*

if (g_enmAction == kVBoxTpGAction_Nothing)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No action specified (-h or -G)");

if (!g_pszScript)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No script file specified (-s)");

if (!g_pszOutput)

return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No output file specified (-o)");

return RTEXITCODE_SUCCESS;

}

int main(int argc, char **argv)

{

int rc = RTR3InitExe(argc, &argv, 0);

if (RT_FAILURE(rc))

return 1;

RTEXITCODE rcExit = parseArguments(argc, argv);

if (rcExit == RTEXITCODE_SUCCESS)

{

/*

RTListInit(&g_ProviderHead);

rcExit = parseScript(g_pszScript);

if (rcExit == RTEXITCODE_SUCCESS)

{

/*

if (g_enmAction == kVBoxTpGAction_GenerateHeader)

rcExit = generateHeader(g_pszOutput);

else

rcExit = generateObject(g_pszOutput, g_pszTempAsm);

}

}

if (rcExit == RTEXITCODE_SUCCESS && g_cTypeErrors > 0)

rcExit = RTEXITCODE_FAILURE;

return rcExit;

}