//----------------------------------------------------------------------
//
// RegmonLogHash
//
// Logs the key and associated fullpath in the hash table.
//
//----------------------------------------------------------------------
VOID
RegmonLogHash(
HKEY hkey,
PCHAR fullname
)
{
PHASH_ENTRY newEntry;
Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
//
// Find or allocate an entry to use
//
newEntry = HeapAllocate( sizeof(HASH_ENTRY) + strlen(fullname)+1, 0 );
//
// Initialize the new entry.
//
if( newEntry ) {
newEntry->hkey = hkey;
newEntry->Next = HashTable[ HASHOBJECT(hkey) ];
HashTable[ HASHOBJECT(hkey) ] = newEntry;
strcpy( newEntry->FullName, fullname );
}
Signal_Semaphore( HashMutex );
}
/* 初始化符号表 */
void InitSymbolTable (void)
{
/* 初始化符号表 */
GlobalTags.buckets = GlobalIDs.buckets = NULL;
GlobalTags.outer = GlobalIDs.outer = NULL;
GlobalTags.level = GlobalIDs.level = 0;
/* Tags 和Identifiers 分别指向两个符号表 */
Tags = &GlobalTags;
Identifiers = &GlobalIDs;
/* 给常量符号表分配存储空间 */
int size = sizeof (Symbol) * (SYM_HASH_MASK + 1);
Constants.buckets = HeapAllocate (CurrentHeap, size);
memset (Constants.buckets, 0, size);
Constants.outer = NULL;
Constants.level = 0;
Functions = Globals = Strings = FloatConstants = NULL;
FunctionTail = &Functions;
GlobalTail = &Globals;
StringTail = &Strings;
FloatTail = &FloatConstants;
TempNum = LabelNum = StringNum = 0;
}
PVOID
NTAPI
ExAllocatePool(
IN POOL_TYPE PoolType,
IN SIZE_T NumberOfBytes)
{
return HeapAllocate(FrLdrDefaultHeap, NumberOfBytes, 0);
}
PVOID
NTAPI
ExAllocatePoolWithTag(
IN POOL_TYPE PoolType,
IN SIZE_T NumberOfBytes,
IN ULONG Tag)
{
return HeapAllocate(FrLdrDefaultHeap, NumberOfBytes, Tag);
}
//----------------------------------------------------------------------
//
// MakeFilterArray
//
// Takes a filter string and splits into components (a component
// is seperated with a ';')
//
//----------------------------------------------------------------------
VOID
MakeFilterArray(
PCHAR FilterString,
PCHAR FilterArray[],
PULONG NumFilters
)
{
PCHAR filterStart;
ULONG filterLength;
CHAR saveChar;
//
// Scan through the process filters
//
filterStart = FilterString;
while( *filterStart ) {
filterLength = 0;
while( filterStart[filterLength] &&
filterStart[filterLength] != ';' ) {
filterLength++;
}
//
// Ignore zero-length components
//
if( filterLength ) {
FilterArray[ *NumFilters ] =
HeapAllocate( filterLength + 1 + 2*sizeof('*'), 0 );
saveChar = *(filterStart + filterLength );
*(filterStart + filterLength) = 0;
sprintf( FilterArray[ *NumFilters ], "%s%s%s",
*filterStart == '*' ? "" : "*",
filterStart,
*(filterStart + filterLength - 1 ) == '*' ? "" : "*" );
*(filterStart + filterLength) = saveChar;
(*NumFilters)++;
}
//
// Are we done?
//
if( !filterStart[filterLength] ) break;
//
// Move to the next component (skip over ';')
//
filterStart += filterLength + 1;
}
}
/* 折半查找 */
static void TranslateSwitchBuckets (SwitchBucket *bucketArray, int left, int right, Symbol choice, BBlock currBB, BBlock defBB)
{
int mid, len, i;
AstCaseStatement p;
BBlock lhalfBB, rhalfBB;
BBlock *dstBBs;
Symbol index;
if (left > right)
return;
mid = (left + right) / 2;
lhalfBB = (left > mid - 1) ? defBB : CreateBBlock();
rhalfBB = (mid + 1 > right) ? defBB : CreateBBlock();
len = bucketArray[mid]->maxVal - bucketArray[mid]->minVal + 1;
dstBBs = HeapAllocate (CurrentHeap, (len + 1)* sizeof(BBlock));
for (i = 0; i < len; ++i)
dstBBs[i] = defBB;
dstBBs[len] = NULL;
for (p = bucketArray[mid]->cases; p; p = p->nextCase) {
i = p->expr->val.i[0] - bucketArray[mid]->minVal;
dstBBs[i] = p->respBB;
}
if (currBB != NULL) {
StartBBlock (currBB);
}
GenerateBranch (choice->ty, lhalfBB, JL, choice, IntConstant (bucketArray[mid]->minVal));
StartBBlock (CreateBBlock());
GenerateBranch (choice->ty, rhalfBB, JG, choice, IntConstant (bucketArray[mid]->maxVal));
StartBBlock (CreateBBlock());
if (len != 1) {
index = CreateTemp (choice->ty);
GenerateAssign (choice->ty, index, SUB, choice, IntConstant (bucketArray[mid]->minVal));
GenerateIndirectJump (dstBBs, len, index);
} else {
GenerateJump (dstBBs[0]);
}
StartBBlock (CreateBBlock ());
/* 二分递归 */
TranslateSwitchBuckets (bucketArray, left, mid - 1, choice, lhalfBB, defBB);
TranslateSwitchBuckets (bucketArray, mid + 1, right, choice, rhalfBB, defBB);
}
PVOID
NTAPI
RtlAllocateHeap(
IN PVOID HeapHandle,
IN ULONG Flags,
IN SIZE_T Size)
{
PVOID ptr;
ptr = HeapAllocate(FrLdrDefaultHeap, Size, ' ltR');
if (ptr && (Flags & HEAP_ZERO_MEMORY))
{
RtlZeroMemory(ptr, Size);
}
return ptr;
}
/* 将某个符号插入到某个符号表中 */
static Symbol AddSymbol (Table tbl, Symbol sym)
{
/* 计算一个哈希值 */
unsigned int h = (unsigned long long)sym->name & SYM_HASH_MASK;
if (NULL == tbl->buckets) {
/* 给该符号表申请一段存放空间 */
int size = sizeof (Symbol) * (SYM_HASH_MASK + 1);
tbl->buckets = HeapAllocate (CurrentHeap, size);
memset (tbl->buckets, 0, size);
}
/* 头插 */
sym->link = tbl->buckets[h];
tbl->buckets[h] = sym;
/* 此时表的层次(范围)就是符号的范围 */
sym->level = tbl->level;
INFO (5, "add Symbol %s \n", sym->name);
return sym;
}
void Dominator(int nbbs)
{
CFGEdge e = PreOrder;
CFGEdge pred;
int update = 1;
int n = (nbbs + 31) / 32;
int i;
while (e != NULL)
{
e->bb->dom = HeapAllocate(CurrentHeap, n * sizeof(int));
for (i = 0; i < n; ++i)
e->bb->dom[i] = -1;
e = e->next;
}
for (i = 0; i < n; ++i)
PreOrder->bb->dom[i] = 0;
PreOrder->bb->dom[0] = 1;
while (update)
{
update = 0;
e = PreOrder;
i = 0;
while (e != NULL)
{
pred = e->bb->preds;
while (pred != NULL)
{
if (pred->bb->dom)
update |= Join(e->bb->dom, pred->bb->dom, n, i);
pred = pred->next;
}
e = e->next;
i++;
}
}
}
PVOID
MmHeapAlloc(SIZE_T MemorySize)
{
return HeapAllocate(FrLdrDefaultHeap, MemorySize, 'pHmM');
}
// Init "phase 1"
VOID
WinLdrInitializePhase1(PLOADER_PARAMETER_BLOCK LoaderBlock,
LPCSTR Options,
LPCSTR SystemRoot,
LPCSTR BootPath,
USHORT VersionToBoot)
{
/* Examples of correct options and paths */
//CHAR Options[] = "/DEBUGPORT=COM1 /BAUDRATE=115200";
//CHAR Options[] = "/NODEBUG";
//CHAR SystemRoot[] = "\\WINNT\\";
//CHAR ArcBoot[] = "multi(0)disk(0)rdisk(0)partition(1)";
LPSTR LoadOptions, NewLoadOptions;
CHAR HalPath[] = "\\";
CHAR ArcBoot[256];
CHAR MiscFiles[256];
ULONG i;
ULONG_PTR PathSeparator;
PLOADER_PARAMETER_EXTENSION Extension;
/* Construct SystemRoot and ArcBoot from SystemPath */
PathSeparator = strstr(BootPath, "\\") - BootPath;
strncpy(ArcBoot, BootPath, PathSeparator);
ArcBoot[PathSeparator] = 0;
TRACE("ArcBoot: %s\n", ArcBoot);
TRACE("SystemRoot: %s\n", SystemRoot);
TRACE("Options: %s\n", Options);
/* Fill Arc BootDevice */
LoaderBlock->ArcBootDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
strncpy(LoaderBlock->ArcBootDeviceName, ArcBoot, MAX_PATH);
LoaderBlock->ArcBootDeviceName = PaToVa(LoaderBlock->ArcBootDeviceName);
/* Fill Arc HalDevice, it matches ArcBoot path */
LoaderBlock->ArcHalDeviceName = WinLdrSystemBlock->ArcBootDeviceName;
LoaderBlock->ArcHalDeviceName = PaToVa(LoaderBlock->ArcHalDeviceName);
/* Fill SystemRoot */
LoaderBlock->NtBootPathName = WinLdrSystemBlock->NtBootPathName;
strncpy(LoaderBlock->NtBootPathName, SystemRoot, MAX_PATH);
LoaderBlock->NtBootPathName = PaToVa(LoaderBlock->NtBootPathName);
/* Fill NtHalPathName */
LoaderBlock->NtHalPathName = WinLdrSystemBlock->NtHalPathName;
strncpy(LoaderBlock->NtHalPathName, HalPath, MAX_PATH);
LoaderBlock->NtHalPathName = PaToVa(LoaderBlock->NtHalPathName);
/* Fill LoadOptions and strip the '/' commutator symbol in front of each option */
NewLoadOptions = LoadOptions = LoaderBlock->LoadOptions = WinLdrSystemBlock->LoadOptions;
strncpy(LoaderBlock->LoadOptions, Options, MAX_OPTIONS_LENGTH);
do
{
while (*LoadOptions == '/')
++LoadOptions;
*NewLoadOptions++ = *LoadOptions;
} while (*LoadOptions++);
LoaderBlock->LoadOptions = PaToVa(LoaderBlock->LoadOptions);
/* Arc devices */
LoaderBlock->ArcDiskInformation = &WinLdrSystemBlock->ArcDiskInformation;
InitializeListHead(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
/* Convert ARC disk information from freeldr to a correct format */
for (i = 0; i < reactos_disk_count; i++)
{
PARC_DISK_SIGNATURE_EX ArcDiskSig;
/* Allocate the ARC structure */
ArcDiskSig = HeapAllocate(FrLdrDefaultHeap,
sizeof(ARC_DISK_SIGNATURE_EX),
'giSD');
/* Copy the data over */
ArcDiskSig->DiskSignature.Signature = reactos_arc_disk_info[i].Signature;
ArcDiskSig->DiskSignature.CheckSum = reactos_arc_disk_info[i].CheckSum;
/* Copy the ARC Name */
strncpy(ArcDiskSig->ArcName, reactos_arc_disk_info[i].ArcName, MAX_PATH);
ArcDiskSig->DiskSignature.ArcName = PaToVa(ArcDiskSig->ArcName);
/* Mark partition table as valid */
ArcDiskSig->DiskSignature.ValidPartitionTable = TRUE;
/* Insert into the list */
InsertTailList(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead,
&ArcDiskSig->DiskSignature.ListEntry);
}
/* Convert all list's to Virtual address */
/* Convert the ArcDisks list to virtual address */
List_PaToVa(&LoaderBlock->ArcDiskInformation->DiskSignatureListHead);
LoaderBlock->ArcDiskInformation = PaToVa(LoaderBlock->ArcDiskInformation);
/* Convert configuration entries to VA */
ConvertConfigToVA(LoaderBlock->ConfigurationRoot);
LoaderBlock->ConfigurationRoot = PaToVa(LoaderBlock->ConfigurationRoot);
/* Convert all DTE into virtual addresses */
List_PaToVa(&LoaderBlock->LoadOrderListHead);
/* this one will be converted right before switching to
virtual paging mode */
//List_PaToVa(&LoaderBlock->MemoryDescriptorListHead);
/* Convert list of boot drivers */
List_PaToVa(&LoaderBlock->BootDriverListHead);
/* Initialize Extension now */
Extension = &WinLdrSystemBlock->Extension;
Extension->Size = sizeof(LOADER_PARAMETER_EXTENSION);
Extension->MajorVersion = (VersionToBoot & 0xFF00) >> 8;
Extension->MinorVersion = VersionToBoot & 0xFF;
Extension->Profile.Status = 2;
/* Check if ACPI is present */
if (AcpiPresent)
{
/* See KiRosFrldrLpbToNtLpb for details */
Extension->AcpiTable = (PVOID)1;
}
#ifdef _M_IX86
/* Set headless block pointer */
if (WinLdrTerminalConnected)
{
Extension->HeadlessLoaderBlock = &WinLdrSystemBlock->HeadlessLoaderBlock;
RtlCopyMemory(Extension->HeadlessLoaderBlock,
&LoaderRedirectionInformation,
sizeof(HEADLESS_LOADER_BLOCK));
Extension->HeadlessLoaderBlock = PaToVa(Extension->HeadlessLoaderBlock);
}
#endif
/* Load drivers database */
strcpy(MiscFiles, BootPath);
strcat(MiscFiles, "AppPatch\\drvmain.sdb");
Extension->DrvDBImage = PaToVa(WinLdrLoadModule(MiscFiles,
&Extension->DrvDBSize,
LoaderRegistryData));
/* Convert extension and setup block pointers */
LoaderBlock->Extension = PaToVa(Extension);
if (LoaderBlock->SetupLdrBlock)
LoaderBlock->SetupLdrBlock = PaToVa(LoaderBlock->SetupLdrBlock);
TRACE("WinLdrInitializePhase1() completed\n");
}
/* 翻译switch 语句
* 创建case default 基本块 */
static void TranslateSwitchStatement (AstStatement stmt)
{
AstSwitchStatement swtchStmt = AsSwitch(stmt);
AstCaseStatement p, q;
SwitchBucket bucket, b;
SwitchBucket *bucketArray;
int i, val;
Symbol sym;
/* 翻译switch 的表达式 */
sym = TranslateExpression (swtchStmt->expr);
bucket = b = NULL;
p = swtchStmt->cases;
/* 创建基本块, 并给case 语句排序 */
while ( p ) {
q = p;
p = p->nextCase;
/* 给case 创建基本块 */
q->respBB = CreateBBlock ();
/* case 的表达式 */
val = q->expr->val.i[0];
if (bucket && (bucket->ncase + 1) * 2 > (val - bucket->minVal)) {
bucket->ncase++;
bucket->maxVal = val;
*bucket->tail = q;
bucket->tail = &(q->nextCase);
swtchStmt->nbucket -= MergeSwitchBucket (&bucket);
} else {
CALLOC(b);
b->cases = q;
b->ncase = 1;
/* 初始化最小大值 */
b->minVal = b->maxVal = val;
b->tail = &(q->nextCase);
b->prev = bucket;
bucket = b;
swtchStmt->nbucket++;
}
}
swtchStmt->buckets = bucket;
bucketArray = HeapAllocate (CurrentHeap, swtchStmt->nbucket * sizeof (SwitchBucket));
for (i = swtchStmt->nbucket - 1; i >= 0; i--) {
bucketArray[i] = bucket;
*bucket->tail = NULL;
bucket = bucket->prev;
}
/* default 语句 */
swtchStmt->defBB = CreateBBlock();
if (swtchStmt->defStmt) {
swtchStmt->defStmt->respBB = swtchStmt->defBB;
swtchStmt->nextBB = CreateBBlock();
} else {
swtchStmt->nextBB = swtchStmt->defBB;
}
TranslateSwitchBuckets (bucketArray, 0, swtchStmt->nbucket - 1, sym, NULL, swtchStmt->defBB);
TranslateStatement (swtchStmt->stmt);
StartBBlock (swtchStmt->nextBB);
}
