//
// DxeIpl.efi - Full Decompilation
// Source: IDA Pro MCP port 13388
// Functions: 80
//
#include <Uefi.h>
#include <PiPei.h>
int DxeIplZeroMem()
{
unsigned __int32 v0; // eax
unsigned __int64 v1; // rax
_BYTE retaddr[8]; // [esp+0h] [ebp+0h]
_disable(); /*0xffc15298*/
*(_DWORD *)retaddr = &byte_FFC152BF; /*0xffc15299*/
v0 = __readcr4(); /*0xffc152a0*/
LOBYTE(v0) = v0 | 0x20; /*0xffc152a3*/
__writecr4(v0); /*0xffc152a5*/
v1 = __readmsr(0xC0000080); /*0xffc152ad*/
BYTE1(v1) |= 1u; /*0xffc152af*/
__writemsr(0xC0000080, v1); /*0xffc152b2*/
LODWORD(v1) = __readcr0(); /*0xffc152b4*/
__writecr0(v1 | 0x80000000); /*0xffc152bb*/
return MK_FP(*(_WORD *)retaddr, *(_DWORD *)retaddr)(-1073741696, HIDWORD(v1));
}
char *DxeIplCopyMem(char *dst, char *src, unsigned int count_1)
{
unsigned int count; // edx
char *dst_1; // edi
char *src_1; // esi
count = count_1; /*0xffc152f2*/
if ( src < dst && &src[count_1 - 1] >= dst ) /*0xffc15300*/
{
src_1 = &src[count_1 - 1]; /*0xffc15314*/
dst_1 = &dst[count_1 - 1]; /*0xffc15316*/
}
else
{
count = count_1 & 3; /*0xffc15304*/
qmemcpy(dst, src, 4 * (count_1 >> 2)); /*0xffc1530d*/
src_1 = &src[4 * (count_1 >> 2)]; /*0xffc1530d*/
dst_1 = &dst[4 * (count_1 >> 2)]; /*0xffc1530d*/
}
qmemcpy(dst_1, src_1, count); /*0xffc1531d*/
return dst; /*0xffc15324*/
}
void *DxeIplSetMem32(void *buf, unsigned int count)
{
memset(buf, 0, count); /*0xffc1533f*/
return buf; /*0xffc15346*/
}
void *DxeIplSetMem64(void *buf, unsigned int count, char value)
{
memset(buf, value, count); /*0xffc15355*/
return buf; /*0xffc1535b*/
}
int DxeIplGetNextHob(int a1, int a2, int a3, int a4)
{
do /*0xffc15381*/
{
*(_DWORD *)(a1 + 8 *a2 - 8) = a3; /*0xffc15379*/
*(_DWORD *)(a1 + 8 *a2-- - 4) = a4; /*0xffc1537d*/
}
while ( a2 ); /*0xffc15381*/
return a1; /*0xffc15385*/
}
void *DxeIplGetFirstHob(void *buf, unsigned int count, int value)
{
memset32(buf, value, count); /*0xffc15395*/
return buf; /*0xffc1539b*/
}
_WORD *DxeIplSetMem16(_WORD *a1, int a2, __int16 a3)
{
_WORD *v3; // edi
v3 = a1; /*0xffc1542d*/
while ( a2 ) /*0xffc15435*/
{
*v3++ = a3; /*0xffc15435*/
--a2; /*0xffc15435*/
}
return a1; /*0xffc1543c*/
}
EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
void *v2; // ecx
int v3; // ebp
void *v4; // ecx
void *v5; // ecx
int ModuleBase; // eax
bool v7; // zf
EFI_STATUS result; // eax
int v9; // [esp-14h] [ebp-1Ch]
_DWORD *v10; // [esp-14h] [ebp-1Ch]
_BYTE v11[6]; // [esp-Ch] [ebp-14h] BYREF
int v12; // [esp-4h] [ebp-Ch] BYREF
_BYTE *v13; // [esp+0h] [ebp-8h]
int v14; // [esp+4h] [ebp-4h]
if ( *(char *)(DxeIplGetModuleBase(v2) + 1024068) >= 0 ) /*0xffc1544f*/
{
DxeIplInitGlobalFlags(v4); /*0xffc15451*/
ModuleBase = DxeIplGetModuleBase(v5); /*0xffc15456*/
*(_BYTE *)(ModuleBase + 1024068) |= 0x80u; /*0xffc15462*/
}
DxeIplInstallPpi((char *)FvDeviceHandle, (int (*)())DxeIplPpiNotifyCallback, (int (*)())DxeIplPeiEndCallback); /*0xffc15473*/
DxeIplInstallPpi((char *)DxeIplPpi, (int (*)())DxeIplDxeIplPpiNotify, (int (*)())DxeIplEndOfPeiNotify); /*0xffc15489*/
off_FFC18DF8 = &unk_FFC18B10; /*0xffc15493*/
n64 = 64; /*0xffc1549d*/
v14 = v3; /*0xffc154ad*/
v7 = DxeIplGetPlatformBootMode() == 17; /*0xffc154bb*/
v13 = v11; /*0xffc154c1*/
if ( v7 ) /*0xffc154c4*/
{
__sidt(v13); /*0xffc15506*/
(*(void ( **)(_DWORD, void *))(**(_DWORD **)(*(_DWORD *)&v11[2] - 4) + 36))( /*0xffc15517*/
*(_DWORD *)(*(_DWORD *)&v11[2] - 4),
&unk_FFC18A64);
return DxeIplReportStatus(&unk_FFC18A7C); /*0xffc15517*/
}
__sidt(v13); /*0xffc154c9*/
result = (*(int ( **)(EFI_HANDLE))(**(_DWORD **)(*(_DWORD *)&v11[2] - 4) + 116))(ImageHandle); /*0xffc154d5*/
if ( result ) /*0xffc154db*/
{
result = DxeIplLocatePpiByGuid((int)&unk_FFC18D68, 0, v9, (int)&v12); /*0xffc154e9*/
if ( (result & 0x80000000) == 0 ) /*0xffc154f2*/
{
DxeIplDebugPrint(v10); /*0xffc154f9*/
return DxeIplReportStatus(&unk_FFC18A7C); /*0xffc1551c*/
}
}
return result; /*0xffc1552a*/
}
int __thiscall DxeIplDebugPrint(_DWORD *this)
{
int v1; // esi
int v2; // ebp
_DWORD *v3; // edi
int v4; // ebx
_DWORD *this_1; // [esp+0h] [ebp-4h] BYREF
this_1 = this; /*0xffc1552b*/
if ( DxeIplFvOpenDevice(&this_1) >= 0 ) /*0xffc15536*/
{
v1 = this_1[1]; /*0xffc1553d*/
v2 = this_1[2]; /*0xffc15540*/
if ( v1 ) /*0xffc15545*/
{
v3 = (_DWORD *)DxeIplAllocateZeroPages(12 *v1); /*0xffc15553*/
v4 = v2 + 16 *v1; /*0xffc15558*/
do /*0xffc1557a*/
{
v4 -= 16; /*0xffc1555a*/
*v3 = -2147483632; /*0xffc1555d*/
v3[2] = &off_FFC18A4C; /*0xffc15565*/
v3[1] = v4; /*0xffc1556c*/
DxeIplReportStatus(v3); /*0xffc1556f*/
v3 += 3; /*0xffc15574*/
--v1; /*0xffc15577*/
}
while ( v1 ); /*0xffc1557a*/
}
}
return DxeIplReportStatus(&unk_FFC18A54);
}
char DxeIplMeasureFv(int a1, unsigned int n128)
{
unsigned int n128_1; // eax
int v4; // eax
if ( !a1 ) /*0xffc15592*/
return 0; /*0xffc15592*/
n128_1 = 8 * (n128 >> 3); /*0xffc1559f*/
if ( n128_1 != n128 || *(_DWORD *)(n128_1 + a1 - 8) != 15 ) /*0xffc155ab*/
return 0; /*0xffc15597*/
v4 = 0; /*0xffc155ad*/
if ( n128 >> 3 != 1 ) /*0xffc155b2*/
{
while ( *(_DWORD *)(a1 + 8 *v4) < 0xFu ) /*0xffc155b8*/
{
if ( ++v4 >= (n128 >> 3) - 1 ) /*0xffc155bd*/
return 1; /*0xffc155bd*/
}
return 0; /*0xffc155b8*/
}
return 1; /*0xffc15596*/
}
int DxeIplFvReadSection(int a1, int a2, int *a3, unsigned int *a4, int a5)
{
int v5; // edi
int result; // eax
unsigned int v7; // esi
unsigned int v8; // ecx
int v9; // ecx
int v10; // eax
_BYTE v11[4]; // [esp+Ch] [ebp-14h] BYREF
_DWORD *v12; // [esp+10h] [ebp-10h] BYREF
unsigned int v13; // [esp+14h] [ebp-Ch] BYREF
unsigned int v14; // [esp+18h] [ebp-8h]
unsigned int v15; // [esp+1Ch] [ebp-4h] BYREF
v5 = 0; /*0xffc155d3*/
result = DxeIplFvOpenDevice(&v12); /*0xffc155d5*/
if ( result >= 0 ) /*0xffc155df*/
{
v7 = 0; /*0xffc155ef*/
v8 = v12[1]; /*0xffc15603*/
v14 = v8; /*0xffc15606*/
if ( v8 ) /*0xffc1560c*/
{
v8 = v12[2]; /*0xffc1560e*/
while ( !(unsigned __int8)DxeIplFvIsAddrValid(v8) ) /*0xffc15618*/
{
++v7; /*0xffc1561a*/
v8 = v9 + 16; /*0xffc1561b*/
if ( v7 >= v14 ) /*0xffc15622*/
goto LABEL_6; /*0xffc15622*/
}
result = (*(int ( **)(int, unsigned int *, unsigned int *, _BYTE *))(v12[4] + 4 *v7))(a2, &v13, &v15, v11); /*0xffc15675*/
}
else
{
LABEL_6:
result = -2147483645; /*0xffc15624*/
}
if ( result >= 0 ) /*0xffc1562b*/
{
if ( v15 ) /*0xffc15637*/
{
v5 = DxeIplAllocatePages(v8, (v15 >> 12) + ((v15 & 0xFFF) != 0)); /*0xffc15651*/
if ( !v5 ) /*0xffc15655*/
return -2147483639; /*0xffc15655*/
}
if ( (v11[0] & 1) != 0 && v13 ) /*0xffc1568d*/
{
v10 = DxeIplAllocatePages(v8, (v13 >> 12) + ((v13 & 0xFFF) != 0) + 1); /*0xffc156a0*/
*a3 = v10; /*0xffc156a5*/
if ( !v10 ) /*0xffc156a9*/
return -2147483639; /*0xffc1565c*/
*a3 = v10 + 4092; /*0xffc156b0*/
}
result = DxeIplDecompress(v5, a5); /*0xffc156ba*/
if ( result >= 0 ) /*0xffc156c3*/
{
*a4 = v13; /*0xffc156cc*/
return 0; /*0xffc156ce*/
}
}
}
return result; /*0xffc156d0*/
}
int DxeIplFvExtractSection(int FvHandle, unsigned int SrcSize_, int *DstBuffer, unsigned int *DstSize)
{
unsigned int SectionType; // ecx
unsigned int SectionStart; // eax
int TypeFlag; // ecx
unsigned int SectionType_2; // edi
int HeaderSize; // ecx
unsigned int CompSize; // edx
unsigned __int8 *src; // ebx
int Scratch; // ecx
unsigned __int8 **Pages; // ebp
int DstAlloc; // eax
int DstPtr; // esi
int BufAlloc; // eax
int SavedCtx; // [esp-14h] [ebp-18h]
unsigned int SectionType_1; // [esp+0h] [ebp-4h] BYREF
SectionType_1 = SectionType; /*0xffc156d7*/
SectionStart = SrcSize_; /*0xffc156d8*/
if ( *(_BYTE *)(SrcSize_ + 3) != 1 ) /*0xffc156e0*/
return -2147483646; /*0xffc156e8*/
TypeFlag = *(_DWORD *)SrcSize_ & 0xFFFFFF; /*0xffc156f0*/
if ( TypeFlag == 0xFFFFFF ) /*0xffc156f6*/
{
SectionType_2 = *(_DWORD *)(SrcSize_ + 8); /*0xffc156fe*/
HeaderSize = 13; /*0xffc15703*/
CompSize = *(_DWORD *)(SrcSize_ + 4) - 13; /*0xffc15704*/
LOBYTE(SrcSize_) = *(_BYTE *)(SrcSize_ + 12); /*0xffc15706*/
}
else
{
SectionType_2 = *(_DWORD *)(SrcSize_ + 4); /*0xffc1570c*/
CompSize = TypeFlag - 9; /*0xffc1570f*/
LOBYTE(SrcSize_) = *(_BYTE *)(SrcSize_ + 8); /*0xffc15717*/
HeaderSize = 9; /*0xffc1571b*/
}
src = (unsigned __int8 *)(HeaderSize + SectionStart); /*0xffc1571c*/
if ( (_BYTE)SrcSize_ ) /*0xffc15729*/
{
if ( (unsigned __int8)SrcSize_ != 1 || DxeIplLzmaGetProp(src, CompSize, &SectionType_1, &SrcSize_) < 0 ) /*0xffc15745*/
return -2147483634; /*0xffc15745*/
Pages = (unsigned __int8 **)DxeIplAllocatePages(SavedCtx, (SrcSize_ >> 12) + ((SrcSize_ & 0xFFF) != 0)); /*0xffc15764*/
if ( Pages ) /*0xffc15768*/
{
SectionType_2 = SectionType_1; /*0xffc1576a*/
DstAlloc = DxeIplAllocatePages(Scratch, (SectionType_1 >> 12) + ((SectionType_1 & 0xFFF) != 0) + 1); /*0xffc1577e*/
if ( DstAlloc ) /*0xffc15787*/
{
DstPtr = DstAlloc + 4092; /*0xffc15789*/
if ( (DxeIplLzmaDecodeProp(src, (unsigned __int8 *)(DstAlloc + 4092), Pages, 1) & 0x80000000) != 0 ) /*0xffc1579f*/
return -2147483634; /*0xffc157a6*/
goto LABEL_16; /*0xffc1579f*/
}
}
return -2147483639; /*0xffc157cc*/
}
BufAlloc = DxeIplAllocatePages(HeaderSize, (SectionType_2 >> 12) + ((SectionType_2 & 0xFFF) != 0) + 1); /*0xffc157bc*/
if ( !BufAlloc ) /*0xffc157c5*/
return -2147483639; /*0xffc157c5*/
DstPtr = BufAlloc + 4092; /*0xffc157ce*/
DxeIplFvFreePages((char *)(BufAlloc + 4092), (char *)src, SectionType_2); /*0xffc157d9*/
LABEL_16:
*DstSize = SectionType_2; /*0xffc157df*/
*DstBuffer = DstPtr; /*0xffc157e9*/
return 0; /*0xffc156e8*/
}
int DxeIplFvProcessSections(int a1, int a2)
{
int i; // edx
int result; // eax
int v4; // esi
for ( i = DxeIplGetPeiServices(); ; i = v4 + *(unsigned __int16 *)(v4 + 2) ) /*0xffc157f9*/
{
result = DxeIplLocatePpi(2, i); /*0xffc15817*/
v4 = result; /*0xffc1581c*/
if ( !result ) /*0xffc15820*/
break; /*0xffc15820*/
if ( (unsigned __int8)DxeIplFvIsAddrValid(&unk_FFC18CD8) ) /*0xffc15805*/
{
DxeIplFreePages(*(_DWORD *)(v4 + 24), *(_DWORD *)(v4 + 28), *(_DWORD *)(v4 + 32), *(_DWORD *)(v4 + 36)); /*0xffc15830*/
*(_DWORD *)(v4 + 36) = 0; /*0xffc1583c*/
*(_DWORD *)(v4 + 24) = a1; /*0xffc15840*/
*(_DWORD *)(v4 + 28) = a2; /*0xffc15847*/
*(_DWORD *)(v4 + 32) = 0x100000; /*0xffc1584a*/
return a2; /*0xffc15843*/
}
}
return result; /*0xffc15822*/
}
int __thiscall DxeIplCheckBootMode(void *this)
{
int v1; // esi
int v3; // [esp-4h] [ebp-Ch]
int ( **v4)(_DWORD); // [esp+4h] [ebp-4h] BYREF
v1 = DxeIplLocatePpiByGuid(this, &v4); /*0xffc1586b*/
if ( v1 >= 0 ) /*0xffc15872*/
{
DxeIplGetBootModeFromHob(v3, "DxeIpl"); /*0xffc1588f*/
return (*v4)(v4); /*0xffc1589b*/
}
else
{
DxeIplReportStatusCode(-2147483646, 50532354); /*0xffc1587e*/
return v1; /*0xffc15886*/
}
}
int __thiscall DxeIplGetNextFfsFile(void *this)
{
int i_1; // esi
int v2; // edi
int v3; // eax
int v4; // eax
int i; // ecx
int v6; // ecx
int v7; // eax
_BYTE v9[2]; // [esp+10h] [ebp-18h] BYREF
int v10; // [esp+12h] [ebp-16h]
int v11; // [esp+18h] [ebp-10h] BYREF
_BYTE *v12; // [esp+1Ch] [ebp-Ch] BYREF
_BYTE v13[6]; // [esp+20h] [ebp-8h] BYREF
i_1 = 0; /*0xffc158b8*/
v2 = DxeIplLocatePpiByGuid(this, &v12); /*0xffc158bf*/
if ( v2 >= 0 ) /*0xffc158ca*/
{
*(_DWORD *)v13 = v9; /*0xffc158e3*/
__sidt(v9); /*0xffc158e9*/
v2 = (*(int ( **)(_DWORD, _BYTE *))v12)(*(_DWORD *)(v10 - 4), v12); /*0xffc158fa*/
}
else
{
DxeIplReportStatusCode(-2147483646, 50532358); /*0xffc158d6*/
}
if ( v2 >= 0 /*0xffc1591d*/
&& (v3 = DxeIplGetPeiServices(), (v4 = DxeIplGetBootModeGuid(&unk_FFC18CB8, v3)) != 0)
&& !*(_BYTE *)(v4 + 32)
&& *(_QWORD *)(v4 + 24) )
{
DxeIplGetPlatformBootMode(); /*0xffc15925*/
for ( i = 0; DxeIplOpenFv(i, &v11) >= 0; i = i_1 ) /*0xffc1592a*/
++i_1; /*0xffc1592e*/
}
else
{
v12 = v9; /*0xffc15942*/
__sidt(v9); /*0xffc15948*/
v6 = *(_DWORD *)(v10 - 4); /*0xffc1594e*/
v12 = v13; /*0xffc15954*/
__sidt(v13); /*0xffc1595a*/
(*(void ( **)(int, int, int, _DWORD, _DWORD, _DWORD))(**(_DWORD **)(*(_DWORD *)&v13[2] - 4) + 88))( /*0xffc1596f*/
v6,
-2147483646,
50532359,
0,
0,
0);
v7 = DxeIplGetPeiBootMode(); /*0xffc15972*/
if ( (*(unsigned __int8 ( **)(int))(v7 + 24))(9) ) /*0xffc15979*/
{
v12 = v9; /*0xffc15986*/
__sidt(v9); /*0xffc1598c*/
(*(void ( **)(int, _DWORD, _DWORD, _DWORD))(**(_DWORD **)(v10 - 4) + 128))(2, 0, 0, 0); /*0xffc1599c*/
DxeIplNullStall(); /*0xffc159a5*/
}
}
return i_1; /*0xffc159aa*/
}
int __thiscall DxeIplDiscoverDxeCore(void *n32)
{
_WORD *i; // eax
int v3; // ecx
const __int16 *PreviousMemoryTypeInformation; // edi
int v5; // esi
int n64; // edx
unsigned int n128; // [esp+10h] [ebp-8Ch] BYREF
int ( **v9)(_DWORD, const __int16 *, void *, _DWORD, unsigned int *, _BYTE *); // [esp+14h] [ebp-88h] BYREF
_BYTE v10[132]; // [esp+18h] [ebp-84h] BYREF
for ( i = (_WORD *)DxeIplGetPeiServices(); ; *i = -2 ) /*0xffc159bf*/
{
i = (_WORD *)DxeIplGetBootModeGuid(&unk_FFC18CC8, i); /*0xffc159d7*/
if ( !i ) /*0xffc159de*/
break; /*0xffc159de*/
}
if ( DxeIplLocatePpiByGuid(v3, &v9) < 0 ) /*0xffc159fb*/
goto LABEL_13; /*0xffc159fb*/
n128 = 128; /*0xffc159fd*/
PreviousMemoryTypeInformation = L"PreviousMemoryTypeInformation"; /*0xffc15a05*/
if ( n32 != (void *)5 ) /*0xffc15a0d*/
PreviousMemoryTypeInformation = L"MemoryTypeInformation"; /*0xffc15a0f*/
v5 = (*v9)(v9, PreviousMemoryTypeInformation, &unk_FFC18DD8, 0, &n128, v10); /*0xffc15a29*/
if ( v5 == -2147483634 ) /*0xffc15a34*/
v5 = (*v9)(v9, PreviousMemoryTypeInformation, &unk_FFC18CC8, 0, &n128, v10); /*0xffc15a4e*/
if ( v5 < 0 ) /*0xffc15a52*/
goto LABEL_13; /*0xffc15a52*/
if ( !DxeIplMeasureFv((int)v10, n128) ) /*0xffc15a5c*/
v5 = -2147483645; /*0xffc15a6f*/
if ( v5 < 0 ) /*0xffc15a76*/
{
LABEL_13:
n64 = n64; /*0xffc15a78*/
n128 = n64; /*0xffc15a83*/
}
DxeIplAllocPagesBelow4G(n64); /*0xffc15a8c*/
return DxeIplAllocPagesBelow4G(16); /*0xffc15a9e*/
}
int DxeIplEntry(int PeiServicesPtr, int BootServices)
{
int Guid; // ecx
int Vol; // esi
int NextFfsFile; // edi
int PlatformBootMode; // eax
void *Status; // ecx
void *PlatformBootMode_1; // ebx
int FvSection; // eax
int PpiStatus; // ecx
int FvStatus; // eax
int DxeHandle; // ecx
int PpiStatus_1; // [esp-4h] [ebp-64h]
int DxeHandle_1; // [esp+Ch] [ebp-54h] BYREF
int v15; // [esp+10h] [ebp-50h] BYREF
_BYTE *v16; // [esp+14h] [ebp-4Ch]
int ( **v17)(_DWORD, int, int *, __int64 *, int *, _BYTE *); // [esp+18h] [ebp-48h] BYREF
_BYTE v18[4]; // [esp+1Ch] [ebp-44h] BYREF
_BYTE v19[2]; // [esp+20h] [ebp-40h] BYREF
int v20; // [esp+22h] [ebp-3Eh]
int v21[2]; // [esp+28h] [ebp-38h] BYREF
__int64 v22; // [esp+30h] [ebp-30h] BYREF
int v23[2]; // [esp+38h] [ebp-28h] BYREF
_BYTE v24[32]; // [esp+40h] [ebp-20h] BYREF
Vol = 0; /*0xffc15abd*/
NextFfsFile = 0; /*0xffc15abf*/
DxeIplDebugPrintGuid(Guid, "DxeIpl"); /*0xffc15ac1*/
(*(void ( **)(int, int, int, _DWORD, _DWORD, _DWORD))(*(_DWORD *)BootServices + 88))( /*0xffc15ad9*/
BootServices,
1,
50466817,
0,
0,
0);
PlatformBootMode = DxeIplGetPlatformBootMode(); /*0xffc15adf*/
PlatformBootMode_1 = (void *)PlatformBootMode; /*0xffc15ae4*/
if ( PlatformBootMode == 17 ) /*0xffc15ae9*/
{
if ( DxeIplCheckBootMode(Status) < 0 ) /*0xffc15af2*/
{
DxeIplReportStatusCode(2, 50532357); /*0xffc15b01*/
v16 = v19; /*0xffc15b0d*/
__sidt(v19); /*0xffc15b15*/
(*(void ( **)(_DWORD))(**(_DWORD **)(v20 - 4) + 92))(*(_DWORD *)(v20 - 4)); /*0xffc15b22*/
}
}
else if ( PlatformBootMode == 32 || PlatformBootMode == 18 ) /*0xffc15b30*/
{
NextFfsFile = DxeIplGetNextFfsFile(Status); /*0xffc15b37*/
PlatformBootMode_1 = (void *)DxeIplGetPlatformBootMode(); /*0xffc15b3e*/
}
DxeIplReportStatus(&unk_FFC18AC4); /*0xffc15b45*/
DxeIplDiscoverDxeCore(PlatformBootMode_1); /*0xffc15b4c*/
do /*0xffc15b68*/
{
FvStatus = DxeIplOpenFv(NextFfsFile++, (int)&v15); /*0xffc15b70*/
if ( FvStatus < 0 ) /*0xffc15b78*/
{
DxeIplReportStatusCode(2, 50466816); /*0xffc15b87*/
DxeIplGetBootModeFromHob(); /*0xffc15b91*/
return -2147483634; /*0xffc15ba4*/
}
DxeHandle_1 = 0; /*0xffc15b5c*/
FvSection = DxeIplReadFvSection(v15, (int)&DxeHandle_1); /*0xffc15b60*/
PpiStatus = PpiStatus_1; /*0xffc15b65*/
}
while ( FvSection < 0 ); /*0xffc15b68*/
do /*0xffc15bdc*/
DxeIplLocatePpiByGuid((int)&unk_FFC18D88, Vol++, PpiStatus, (int)&v17); /*0xffc15bb2*/
while ( (*v17)(v17, DxeHandle_1, v23, &v22, v21, v18) < 0 ); /*0xffc15bdc*/
DxeHandle = DxeHandle_1; /*0xffc15bde*/
v16 = v19; /*0xffc15be6*/
__sidt(v19); /*0xffc15bee*/
(*(void ( **)(int, _BYTE *))(**(_DWORD **)(v20 - 4) + 108))(DxeHandle, v24); /*0xffc15c00*/
DxeIplDecompressPages( /*0xffc15c2f*/
v23[0],
v23[1],
v22 + (-(int)v22 & 0xFFF),
(v22 + (unsigned __int64)(-(int)v22 & 0xFFF)) >> 32,
v21[0],
v21[1]);
DxeIplTransferToDxeCore(); /*0xffc15c3f*/
DxeIplNullStall(); /*0xffc15c47*/
return -2147483639; /*0xffc15b9e*/
}
int DxeIplTransferToDxeCore()
{
int v0; // ecx
int v1; // ecx
int v2; // ecx
__int64 v4; // [esp+Ch] [ebp-10h] BYREF
unsigned __int32 v5; // [esp+18h] [ebp-4h]
DxeIplFvGetFileSize(&v4); /*0xffc15c68*/
v5 = (unsigned __int64)(v4 + 1048544) >> 32; /*0xffc15c83*/
__lgdt("G"); /*0xffc15c90*/
v5 = DxeIplCreatePageTables(); /*0xffc15c9f*/
DxeIplDebugPrintGuid(v0, "PeiEnd"); /*0xffc15ca5*/
DxeIplReportStatus(&unk_FFC18A70); /*0xffc15cb2*/
DxeIplGetBootModeFromHob(v1, "PeiEnd"); /*0xffc15cbc*/
DxeIplGetBootModeFromHob(v2, "DxeIpl"); /*0xffc15cc6*/
__writecr3(v5); /*0xffc15cd1*/
DxeIplFvProcessSections(v4, SHIDWORD(v4)); /*0xffc15cdc*/
return DxeIplZeroMem(); /*0xffc15cf9*/
}
int __thiscall DxeIplCreatePageTables(void *this)
{
unsigned __int8 ( **PeiServices)(int); // eax
_WORD *i; // eax
_WORD *Ppi; // eax
int PhysAddrBits; // ecx
unsigned __int8 MaxPhysAddr; // bl
int result; // eax
int NumPml4Entries; // esi
__int64 v8; // rax
__int64 NumPdptEntries; // rax
int NumPml4Entries_2; // edx
int Pml4Table; // eax
unsigned int Index; // edx
_DWORD *Pml4Table_1; // edi
int *PdptTable_1; // eax
int NumPml4Entries_5; // ecx
int *PdptTable; // esi
bool v17; // zf
int v18; // eax
int PageAttr_1; // edi
int n512_5; // ecx
unsigned int Index_2; // kr00_4
_DWORD *Pml4Table_4; // edi
unsigned int n512_4; // edx
_DWORD *PdptTable_4; // edi
_DWORD *PdptTable_5; // edx
int v26; // eax
unsigned int Index_3; // ecx
int n512_3; // edi
unsigned __int64 Index_4; // kr08_8
unsigned int v30; // edi
int v31; // ebx
int PhysAddrBits_1; // [esp-4h] [ebp-54h]
int PhysAddrBits_2; // [esp-4h] [ebp-54h]
int Pml4Table_2; // [esp+14h] [ebp-3Ch]
int NumPml4Entries_4; // [esp+18h] [ebp-38h]
unsigned int n512_2; // [esp+1Ch] [ebp-34h]
int v37; // [esp+20h] [ebp-30h] BYREF
unsigned int NumPml4Entries_1; // [esp+24h] [ebp-2Ch]
int NumPml4Entries_3; // [esp+28h] [ebp-28h]
unsigned int n512_1; // [esp+2Ch] [ebp-24h]
int *PdptTable_2; // [esp+30h] [ebp-20h]
unsigned int n512; // [esp+34h] [ebp-1Ch]
_DWORD *PdptTable_3; // [esp+38h] [ebp-18h]
_DWORD *Pml4Table_3; // [esp+3Ch] [ebp-14h]
int PageAttr; // [esp+40h] [ebp-10h]
int Enable1GPages; // [esp+44h] [ebp-Ch]
unsigned int Index_1; // [esp+48h] [ebp-8h]
unsigned int p_n36; // [esp+4Ch] [ebp-4h] BYREF
LOBYTE(Enable1GPages) = 0; /*0xffc15d0b*/
PeiServices = (unsigned __int8 ( **)(int))DxeIplGetPeiBootMode(this); /*0xffc15d0e*/
if ( PeiServices[6](4) ) /*0xffc15d15*/
{
DxeIplGetBootMode(0x80000000, &p_n36, PhysAddrBits_1, PhysAddrBits_1, 0); /*0xffc15d2a*/
if ( p_n36 >= 0x80000001 ) /*0xffc15d38*/
{
DxeIplGetBootMode(-2147483647, 0, -2147483647, -2147483647, &v37); /*0xffc15d42*/
if ( (v37 & 0x4000000) != 0 ) /*0xffc15d51*/
LOBYTE(Enable1GPages) = 1; /*0xffc15d53*/
}
}
i = (_WORD *)DxeIplGetPeiServices(); /*0xffc15d57*/
Ppi = DxeIplLocatePpi(6, i); /*0xffc15d61*/
if ( Ppi ) /*0xffc15d68*/
{
MaxPhysAddr = *((_BYTE *)Ppi + 8); /*0xffc15d6a*/
}
else
{
DxeIplGetBootMode(0x80000000, &p_n36, PhysAddrBits, PhysAddrBits, 0); /*0xffc15d77*/
PhysAddrBits = -2147483640; /*0xffc15d7c*/
if ( p_n36 < 0x80000008 ) /*0xffc15d87*/
{
MaxPhysAddr = 36; /*0xffc15d9c*/
}
else
{
DxeIplGetBootMode(-2147483640, &p_n36, -2147483640, -2147483640, 0); /*0xffc15d8f*/
MaxPhysAddr = p_n36; /*0xffc15d94*/
}
}
LOBYTE(Index_1) = MaxPhysAddr; /*0xffc15d9e*/
if ( MaxPhysAddr > 0x30u ) /*0xffc15da4*/
{
MaxPhysAddr = 48; /*0xffc15da6*/
LOBYTE(Index_1) = 48; /*0xffc15da8*/
}
if ( dword_FFC18E48 ) /*0xffc15db2*/
{
result = dword_FFC18E48(Index_1, Enable1GPages); /*0xffc15dba*/
PhysAddrBits = PhysAddrBits_2; /*0xffc15dbd*/
if ( result ) /*0xffc15dc0*/
return result; /*0xffc15dc0*/
}
if ( MaxPhysAddr > 0x27u ) /*0xffc15dcc*/
{
NumPml4Entries_1 = MaxPhysAddr - 39; /*0xffc15e12*/
LOBYTE(PhysAddrBits) = MaxPhysAddr - 39; /*0xffc15e15*/
NumPdptEntries = 0x100000000LL; /*0xffc15e18*/
if ( ((MaxPhysAddr - 39) & 0x20) == 0 ) /*0xffc15e20*/
NumPdptEntries = 1; /*0xffc15e22*/
NumPml4Entries = NumPdptEntries << (PhysAddrBits & 0x1F); /*0xffc15e2c*/
NumPml4Entries_1 = NumPml4Entries; /*0xffc15e33*/
LODWORD(NumPdptEntries) = 512; /*0xffc15e36*/
n512 = 512; /*0xffc15e38*/
}
else
{
PhysAddrBits = 1; /*0xffc15dd3*/
NumPml4Entries_3 = MaxPhysAddr - 30; /*0xffc15dd4*/
NumPml4Entries = 1; /*0xffc15ddb*/
NumPml4Entries_1 = 1; /*0xffc15ddd*/
LOBYTE(PhysAddrBits) = MaxPhysAddr - 30; /*0xffc15de3*/
v8 = 0x100000000LL; /*0xffc15de6*/
if ( ((MaxPhysAddr - 30) & 0x20) == 0 ) /*0xffc15dee*/
v8 = 1; /*0xffc15df0*/
NumPdptEntries = v8 << (PhysAddrBits & 0x1F); /*0xffc15df8*/
n512 = NumPdptEntries; /*0xffc15dfa*/
}
if ( (_BYTE)Enable1GPages ) /*0xffc15e42*/
NumPml4Entries_2 = NumPml4Entries; /*0xffc15e4c*/
else
NumPml4Entries_2 = NumPml4Entries * (NumPdptEntries + 1); /*0xffc15e47*/
Pml4Table = DxeIplAllocatePages(PhysAddrBits, NumPml4Entries_2 + 1); /*0xffc15e4f*/
Index = 0; /*0xffc15e56*/
PageAttr = 0; /*0xffc15e58*/
Pml4Table_1 = (_DWORD *)Pml4Table; /*0xffc15e5b*/
Pml4Table_2 = Pml4Table; /*0xffc15e5d*/
PdptTable_1 = (int *)(Pml4Table + 4096); /*0xffc15e60*/
NumPml4Entries_5 = 0; /*0xffc15e65*/
Pml4Table_3 = (_DWORD *)Pml4Table_2; /*0xffc15e67*/
Index_1 = 0; /*0xffc15e6a*/
if ( !NumPml4Entries ) /*0xffc15e6f*/
{
LABEL_44:
v31 = 512 - NumPml4Entries_5; /*0xffc15f95*/
do /*0xffc15fa7*/
{
DxeIplSetMem32(Pml4Table_1, 8u); /*0xffc15f9a*/
Pml4Table_1 += 2; /*0xffc15fa0*/
--v31; /*0xffc15fa4*/
}
while ( v31 ); /*0xffc15fa7*/
return Pml4Table_2; /*0xffc15fa7*/
}
NumPml4Entries_3 = NumPml4Entries; /*0xffc15e75*/
NumPml4Entries_4 = NumPml4Entries; /*0xffc15e78*/
do /*0xffc15f87*/
{
Pml4Table_1[1] = 0; /*0xffc15e7b*/
PdptTable = PdptTable_1; /*0xffc15e7f*/
*Pml4Table_1 = PdptTable_1; /*0xffc15e86*/
*Pml4Table_1 |= 2u; /*0xffc15e88*/
*Pml4Table_1 |= 1u; /*0xffc15e8b*/
v17 = (_BYTE)Enable1GPages == 0; /*0xffc15e8e*/
PdptTable_3 = PdptTable_1 + 1024; /*0xffc15e92*/
v18 = Pml4Table_1[1]; /*0xffc15e95*/
PdptTable_2 = PdptTable; /*0xffc15e98*/
Pml4Table_1[1] = v18; /*0xffc15e9b*/
if ( v17 ) /*0xffc15e9e*/
{
n512_4 = 0; /*0xffc15edc*/
if ( n512 ) /*0xffc15ee0*/
{
PdptTable_4 = PdptTable_3; /*0xffc15ee2*/
n512_1 = n512; /*0xffc15ee5*/
n512_2 = n512; /*0xffc15ee8*/
do /*0xffc15f4c*/
{
PdptTable[1] = 0; /*0xffc15eeb*/
PdptTable_5 = PdptTable_4; /*0xffc15eef*/
v26 = PdptTable[1]; /*0xffc15ef1*/
Index_3 = Index_1; /*0xffc15efa*/
*PdptTable = (int)PdptTable_4; /*0xffc15efd*/
*PdptTable |= 2u; /*0xffc15eff*/
*PdptTable |= 1u; /*0xffc15f02*/
PdptTable_3 = PdptTable_4 + 1024; /*0xffc15f05*/
n512_3 = 512; /*0xffc15f08*/
PdptTable[1] = v26; /*0xffc15f0a*/
Index_4 = __PAIR64__(PageAttr, Index_3); /*0xffc15f0d*/
do /*0xffc15f34*/
{
*PdptTable_5 = Index_4 | 2; /*0xffc15f15*/
*PdptTable_5 |= 1u; /*0xffc15f19*/
*PdptTable_5 |= 0x80u; /*0xffc15f1c*/
PdptTable_5[1] = HIDWORD(Index_4); /*0xffc15f28*/
PdptTable_5 += 2; /*0xffc15f2b*/
Index_4 += 0x200000LL; /*0xffc15f2e*/
--n512_3; /*0xffc15f31*/
}
while ( n512_3 ); /*0xffc15f34*/
PdptTable_4 = PdptTable_3; /*0xffc15f36*/
PageAttr = HIDWORD(Index_4); /*0xffc15f39*/
PdptTable = PdptTable_2 + 2; /*0xffc15f3f*/
Index_1 = Index_4; /*0xffc15f42*/
v17 = n512_1-- == 1; /*0xffc15f45*/
PdptTable_2 += 2; /*0xffc15f49*/
}
while ( !v17 ); /*0xffc15f4c*/
Pml4Table_4 = Pml4Table_3; /*0xffc15f4e*/
if ( n512 >= 0x200 ) /*0xffc15f54*/
goto LABEL_40; /*0xffc15f54*/
n512_4 = n512_2; /*0xffc15f56*/
}
v30 = 512 - n512_4; /*0xffc15f60*/
do /*0xffc15f72*/
{
DxeIplSetMem32(PdptTable, 8u); /*0xffc15f65*/
PdptTable += 2; /*0xffc15f6b*/
--v30; /*0xffc15f6f*/
}
while ( v30 ); /*0xffc15f72*/
Pml4Table_4 = Pml4Table_3; /*0xffc15f74*/
LABEL_40:
Index = Index_1; /*0xffc15f77*/
goto LABEL_41; /*0xffc15f77*/
}
PageAttr_1 = PageAttr; /*0xffc15ea0*/
n512_5 = 512; /*0xffc15ea3*/
do /*0xffc15ec9*/
{
*PdptTable = Index | 2; /*0xffc15eaa*/
*PdptTable |= 1u; /*0xffc15eae*/
*PdptTable |= 0x80u; /*0xffc15eb1*/
PdptTable[1] = PageAttr_1; /*0xffc15ebd*/
PdptTable += 2; /*0xffc15ec0*/
Index_2 = Index + 0x40000000; /*0xffc15ec3*/
PageAttr_1 = (__PAIR64__(PageAttr_1, Index) + 0x40000000) >> 32; /*0xffc15ec3*/
Index += 0x40000000; /*0xffc15ec3*/
--n512_5; /*0xffc15ec6*/
}
while ( n512_5 ); /*0xffc15ec9*/
PageAttr = PageAttr_1; /*0xffc15ecb*/
Pml4Table_4 = Pml4Table_3; /*0xffc15ece*/
Index_1 = Index_2; /*0xffc15ed1*/
LABEL_41:
PdptTable_1 = PdptTable_3; /*0xffc15f7a*/
Pml4Table_1 = Pml4Table_4 + 2; /*0xffc15f7d*/
v17 = NumPml4Entries_3-- == 1; /*0xffc15f80*/
Pml4Table_3 = Pml4Table_1; /*0xffc15f84*/
}
while ( !v17 ); /*0xffc15f87*/
if ( NumPml4Entries_1 < 0x200 ) /*0xffc15f90*/
{
NumPml4Entries_5 = NumPml4Entries_4; /*0xffc15f92*/
goto LABEL_44; /*0xffc15f92*/
}
return Pml4Table_2; /*0xffc15fac*/
}
void DxeIplNullStall()
{
while ( 1 ) /*0xffc15fbe*/
; /*0xffc15fbe*/
}
int DxeIplGetBootMode(int _EAX, unsigned int *p_n36, int PhysAddrBits, int a4, _DWORD *a5)
{
_EAX = _EAX; /*0xffc15fdd*/
__asm { cpuid } /*0xffc15fe0*/
if ( p_n36 ) /*0xffc15fe6*/
*p_n36 = _EAX; /*0xffc15fe8*/
if ( a5 ) /*0xffc15ffc*/
*a5 = _EDX; /*0xffc15ffe*/
return _EAX; /*0xffc16003*/
}
int DxeIplGetPeiServices()
{
_BYTE v1[2]; // [esp+0h] [ebp-10h] BYREF
int v2; // [esp+2h] [ebp-Eh]
_DWORD v3[2]; // [esp+8h] [ebp-8h] BYREF
v3[1] = v1; /*0xffc16011*/
__sidt(v1); /*0xffc16017*/
(*(void ( **)(_DWORD, _DWORD *))(**(_DWORD **)(v2 - 4) + 48))(*(_DWORD *)(v2 - 4), v3); /*0xffc16027*/
return v3[0]; /*0xffc1602f*/
}
_WORD *DxeIplLocatePpi(__int16 n6, _WORD *i)
{
while ( 1 ) /*0xffc16046*/
{
if ( *i == 0xFFFF ) /*0xffc1604c*/
return 0; /*0xffc16051*/
if ( *i == n6 ) /*0xffc1603e*/
break; /*0xffc1603e*/
i = (_WORD *)((char *)i + (unsigned __int16)i[1]); /*0xffc16044*/
}
return i; /*0xffc16050*/
}
_WORD *DxeIplGetBootModeGuid(int a1, _WORD *i)
{
_WORD *v3; // esi
while ( 1 ) /*0xffc16079*/
{
v3 = DxeIplLocatePpi(4, i); /*0xffc16079*/
if ( !v3 || (unsigned __int8)DxeIplFvIsAddrValid(a1) ) /*0xffc16062*/
break; /*0xffc16062*/
i = (_WORD *)((char *)v3 + (unsigned __int16)v3[1]); /*0xffc1606f*/
}
return v3; /*0xffc1607f*/
}
int DxeIplGetPlatformBootMode()
{
_BYTE v1[2]; // [esp+0h] [ebp-10h] BYREF
int v2; // [esp+2h] [ebp-Eh]
_DWORD v3[2]; // [esp+8h] [ebp-8h] BYREF
v3[1] = v1; /*0xffc1608e*/
__sidt(v1); /*0xffc16094*/
(*(void ( **)(_DWORD, _DWORD *))(**(_DWORD **)(v2 - 4) + 40))(*(_DWORD *)(v2 - 4), v3); /*0xffc160a4*/
return v3[0]; /*0xffc160ac*/
}
int DxeIplSetBootMode(int n2, int n72)
{
_BYTE v3[2]; // [esp+8h] [ebp-10h] BYREF
int v4; // [esp+Ah] [ebp-Eh]
_DWORD v5[2]; // [esp+10h] [ebp-8h] BYREF
v5[1] = v3; /*0xffc160bb*/
__sidt(v3); /*0xffc160c1*/
if ( (*(int ( **)(_DWORD, int, int, _DWORD *))(**(_DWORD **)(v4 - 4) + 52))(*(_DWORD *)(v4 - 4), n2, n72, v5) >= 0 ) /*0xffc160dd*/
return v5[0]; /*0xffc160e3*/
else
return 0; /*0xffc160df*/
}
_DWORD *DxeIplDecompressPages(int a1, int a2, int a3, int a4, int a5, int a6)
{
int v6; // ecx
int v7; // edi
_DWORD *result; // eax
_DWORD *v9; // esi
v7 = v6; /*0xffc160f2*/
result = (_DWORD *)DxeIplSetBootMode(2, 72); /*0xffc160f7*/
v9 = result; /*0xffc160fc*/
if ( result ) /*0xffc16100*/
{
result[2] = dword_FFC18D28; /*0xffc16108*/
result[3] = dword_FFC18D2C; /*0xffc16111*/
result[4] = dword_FFC18D30; /*0xffc16119*/
result[5] = dword_FFC18D34; /*0xffc16121*/
result[6] = a1; /*0xffc16127*/
result[7] = a2; /*0xffc1612d*/
result[8] = a3; /*0xffc16133*/
result[9] = a4; /*0xffc16139*/
result[10] = 3; /*0xffc16142*/
DxeIplSetMem32(result + 11, 4u); /*0xffc16149*/
DxeIplFvSetError(v9 + 12, v7); /*0xffc16155*/
v9[16] = a5; /*0xffc1615d*/
v9[17] = a6; /*0xffc16163*/
return (_DWORD *)a6; /*0xffc16160*/
}
return result; /*0xffc16166*/
}
int DxeIplAllocPages(_DWORD *DxeIplPpi, int BufferSize)
{
int Status; // eax
int FvEntry; // esi
Status = DxeIplSetBootMode(4, BufferSize + 24); /*0xffc16175*/
FvEntry = Status; /*0xffc1617a*/
if ( Status ) /*0xffc1617e*/
{
DxeIplFvSetError((_DWORD *)(Status + 8), DxeIplPpi); /*0xffc16185*/
return FvEntry + 24; /*0xffc1618a*/
}
return Status; /*0xffc1618d*/
}
char *DxeIplAllocPagesBelow4G(_DWORD *DxeIplPpi, char *SourceData, int BufferSize)
{
char *Destination; // eax
Destination = (char *)DxeIplAllocPages(DxeIplPpi, BufferSize); /*0xffc16198*/
if ( Destination ) /*0xffc1619f*/
return DxeIplFvFreePages(Destination, SourceData, BufferSize); /*0xffc161ab*/
return Destination; /*0xffc161a1*/
}
_DWORD *DxeIplFreePages(int a1, int a2, int a3, int a4)
{
_DWORD *result; // eax
_DWORD *v5; // esi
result = (_DWORD *)DxeIplSetBootMode(2, 48); /*0xffc161ba*/
v5 = result; /*0xffc161bf*/
if ( result ) /*0xffc161c3*/
{
DxeIplSetMem32(result + 2, 0x10u); /*0xffc161cb*/
v5[7] = a2; /*0xffc161d8*/
v5[8] = a3; /*0xffc161df*/
v5[9] = a4; /*0xffc161e8*/
v5[10] = 4; /*0xffc161ed*/
v5[6] = a1; /*0xffc161f4*/
return DxeIplSetMem32(v5 + 11, 4u); /*0xffc161f7*/
}
return result; /*0xffc161ff*/
}
int __thiscall DxeIplReportStatus(void *this)
{
_BYTE v2[2]; // [esp+0h] [ebp-Ch] BYREF
int v3; // [esp+2h] [ebp-Ah]
_BYTE *v4; // [esp+8h] [ebp-4h]
v4 = v2; /*0xffc1620a*/
__sidt(v2); /*0xffc16210*/
return (*(int ( **)(_DWORD, void *))(**(_DWORD **)(v3 - 4) + 24))(*(_DWORD *)(v3 - 4), this); /*0xffc16222*/
}
int DxeIplLocatePpiByGuid(int a1, int a2, int a3, int a4)
{
_BYTE v5[2]; // [esp+4h] [ebp-Ch] BYREF
int v6; // [esp+6h] [ebp-Ah]
_BYTE *v7; // [esp+Ch] [ebp-4h]
v7 = v5; /*0xffc16230*/
__sidt(v5); /*0xffc16236*/
return (*(int ( **)(_DWORD, int, int, _DWORD, int))(**(_DWORD **)(v6 - 4) + 32))( /*0xffc1624f*/
*(_DWORD *)(v6 - 4),
a1,
a2,
0,
a4);
}
int DxeIplOpenFv(int i, int a2)
{
_BYTE v3[2]; // [esp+4h] [ebp-Ch] BYREF
int v4; // [esp+6h] [ebp-Ah]
_BYTE *v5; // [esp+Ch] [ebp-4h]
v5 = v3; /*0xffc1625e*/
__sidt(v3); /*0xffc16264*/
return (*(int ( **)(_DWORD, int, int))(**(_DWORD **)(v4 - 4) + 56))(*(_DWORD *)(v4 - 4), i, a2); /*0xffc16278*/
}
int __usercall DxeIplReadFvSection@<eax>(int a1@<edx>, int p_DxeHandle)
{
_BYTE v3[2]; // [esp+0h] [ebp-Ch] BYREF
int v4; // [esp+2h] [ebp-Ah]
_BYTE *v5; // [esp+8h] [ebp-4h]
v5 = v3; /*0xffc16286*/
__sidt(v3); /*0xffc1628c*/
return (*(int ( **)(_DWORD, int, int, int))(**(_DWORD **)(v4 - 4) + 60))( /*0xffc162a4*/
*(_DWORD *)(v4 - 4),
5,
a1,
p_DxeHandle);
}
int __usercall DxeIplFvGetFileSize@<eax>(int FfsHeader@<edx>, int p_FileSize)
{
_BYTE v3[2]; // [esp+0h] [ebp-Ch] BYREF
int v4; // [esp+2h] [ebp-Ah]
_BYTE *v5; // [esp+8h] [ebp-4h]
v5 = v3; /*0xffc162b1*/
__sidt(v3); /*0xffc162b7*/
return (*(int ( **)(_DWORD, int, int, int))(**(_DWORD **)(v4 - 4) + 72))( /*0xffc162cf*/
*(_DWORD *)(v4 - 4),
4,
FfsHeader,
p_FileSize);
}
char *DxeIplFvFreePages(char *dst, char *src, unsigned int n0x14)
{
if ( !n0x14 || dst == src ) /*0xffc162df*/
return dst; /*0xffc162da*/
else
return DxeIplCopyMem(dst, src, n0x14); /*0xffc162e7*/
}
_DWORD *DxeIplFvSetError(_DWORD *a1, _DWORD *DxeIplPpi)
{
*a1 = *DxeIplPpi; /*0xffc162f2*/
a1[1] = DxeIplPpi[1]; /*0xffc162f7*/
a1[2] = DxeIplPpi[2]; /*0xffc162fd*/
a1[3] = DxeIplPpi[3]; /*0xffc16303*/
return a1; /*0xffc16308*/
}
bool DxeIplFvIsAddrValid(_DWORD *a1, _DWORD *a2)
{
return *a1 == *a2 && a1[1] == a2[1] && a1[2] == a2[2] && a1[3] == a2[3]; /*0xffc16329*/
}
int DxeIplAllocatePages(int Buffer, int FfsHeader)
{
int FileSize; // [esp+0h] [ebp-8h] BYREF
if ( FfsHeader && DxeIplFvGetFileSize(FfsHeader, (int)&FileSize) >= 0 ) /*0xffc16346*/
return FileSize; /*0xffc16348*/
else
return 0; /*0xffc16336*/
}
int __thiscall DxeIplAllocateZeroPages(void *PeiServices)
{
_BYTE Idtr[2]; // [esp+4h] [ebp-10h] BYREF
int GdtBase; // [esp+6h] [ebp-Eh]
_DWORD Memory[2]; // [esp+Ch] [ebp-8h] BYREF
Memory[1] = Idtr; /*0xffc16359*/
__sidt(Idtr); /*0xffc1635f*/
if ( (*(int ( **)(_DWORD, void *, _DWORD *))(**(_DWORD **)(GdtBase - 4) + 76))( /*0xffc16379*/
*(_DWORD *)(GdtBase - 4),
PeiServices,
Memory) >= 0 )
return Memory[0]; /*0xffc1637f*/
else
return 0; /*0xffc1637b*/
}
void *__thiscall DxeIplGetPeiBootMode(void *this)
{
void *this_1; // [esp+0h] [ebp-4h] BYREF
this_1 = this; /*0xffc16389*/
DxeIplLocatePpiByGuid((int)&unk_FFC18DE8, 0, (int)this, (int)&this_1); /*0xffc16396*/
return this_1; /*0xffc163a2*/
}
int __thiscall DxeIplFvOpenDevice(_DWORD **p_this)
{
_WORD *i_1; // eax
_WORD *i; // eax
_DWORD *v4; // ecx
_WORD *i_2; // esi
int v6; // eax
int v8; // eax
int v9; // eax
i_1 = (_WORD *)DxeIplGetPeiServices(); /*0xffc163b0*/
for ( i = DxeIplLocatePpi(4, i_1); ; i = DxeIplLocatePpi(4, (_WORD *)((char *)i_2 + (unsigned __int16)i_2[1])) ) /*0xffc163ba*/
{
i_2 = i; /*0xffc163ee*/
if ( !i ) /*0xffc163f2*/
{
v6 = DxeIplAllocPages((int)dword_FFC18DB8, 404); /*0xffc163fb*/
v4 = (_DWORD *)v6; /*0xffc16400*/
if ( !v6 ) /*0xffc16404*/
{
*p_this = 0; /*0xffc16406*/
return -2147483639; /*0xffc1640d*/
}
*(_DWORD *)(v6 + 4) = 0; /*0xffc16419*/
v8 = v6 + 20; /*0xffc1641d*/
*v4 = 1229473104; /*0xffc16420*/
goto LABEL_11; /*0xffc16420*/
}
if ( DxeIplFvIsAddrValid((_DWORD *)i + 2, dword_FFC18DB8) ) /*0xffc163d0*/
{
v4 = i_2 + 12; /*0xffc163d9*/
if ( *((_DWORD *)i_2 + 6) == 1229473104 ) /*0xffc163de*/
break; /*0xffc163de*/
}
}
v8 = (int)(i_2 + 22); /*0xffc1640f*/
if ( *((_WORD **)i_2 + 8) == i_2 + 22 ) /*0xffc16415*/
goto LABEL_12; /*0xffc16415*/
LABEL_11:
v4[2] = v8; /*0xffc16422*/
v9 = v8 + 256; /*0xffc16425*/
v4[3] = v9; /*0xffc1642a*/
v4[4] = v9 + 64; /*0xffc16430*/
LABEL_12:
*p_this = v4; /*0xffc16433*/
return 0; /*0xffc16437*/
}
int DxeIplInstallPpi(char *DxeIplPpi, int (*DxeIplPeiEndCallback)(), int (*DxeIplPpiNotifyCallback)())
{
int Status; // eax
_DWORD *FvDevice; // esi
unsigned int Index; // edi
unsigned int NumEntries; // ebx
_DWORD *FvEntry; // ecx
char *PpiData; // edx
int v9; // ecx
_DWORD *DeviceHandle; // [esp+14h] [ebp-4h] BYREF
Status = DxeIplFvOpenDevice(&DeviceHandle); /*0xffc16457*/
if ( Status >= 0 ) /*0xffc1645e*/
{
FvDevice = DeviceHandle; /*0xffc16464*/
Index = 0; /*0xffc16468*/
NumEntries = DeviceHandle[1]; /*0xffc1646a*/
if ( NumEntries ) /*0xffc1646f*/
{
FvEntry = (_DWORD *)DeviceHandle[2]; /*0xffc16471*/
PpiData = DxeIplPpi; /*0xffc16474*/
while ( !DxeIplFvIsAddrValid(FvEntry, PpiData) ) /*0xffc1647f*/
{
++Index; /*0xffc16481*/
FvEntry = (_DWORD *)(v9 + 16); /*0xffc16482*/
if ( Index >= NumEntries ) /*0xffc16487*/
goto LABEL_6; /*0xffc16487*/
}
*(_DWORD *)(FvDevice[3] + 4 *Index) = DxeIplPpiNotifyCallback; /*0xffc1649f*/
*(_DWORD *)(FvDevice[4] + 4 *Index) = DxeIplPeiEndCallback; /*0xffc164a5*/
}
else
{
LABEL_6:
if ( NumEntries >= 0x10 ) /*0xffc1648c*/
return -2147483639; /*0xffc16493*/
DxeIplFvSetError((_DWORD *)(FvDevice[2] + 16 *NumEntries), DxeIplPpi); /*0xffc164b8*/
*(_DWORD *)(FvDevice[3] + 4 *FvDevice[1]) = DxeIplPpiNotifyCallback; /*0xffc164c8*/
*(_DWORD *)(FvDevice[4] + 4 *FvDevice[1]++) = DxeIplPeiEndCallback; /*0xffc164d5*/
DxeIplAllocPagesBelow4G(DxeIplPpi, DxeIplPpi, 16); /*0xffc164df*/
}
return 0; /*0xffc164e5*/
}
return Status; /*0xffc164e7*/
}
int DxeIplDecompress(_DWORD *a1, int a2, int a3, int a4)
{
int result; // eax
_DWORD *this_1; // ebx
unsigned int v7; // esi
_DWORD *v8; // edx
_DWORD *v9; // ecx
int v10; // ecx
_DWORD *this; // [esp+10h] [ebp-8h] BYREF
int v12; // [esp+14h] [ebp-4h]
v12 = a2; /*0xffc164fc*/
result = DxeIplFvOpenDevice(&this); /*0xffc16504*/
if ( result >= 0 )
{
this_1 = this; /*0xffc16512*/
v7 = 0; /*0xffc16523*/
v8 = (_DWORD *)((char *)a1 + ((*a1 & 0xFFFFFF) != 0xFFFFFF ? 0xFFFFFFFC : 0) + 8);
if ( this[1] ) /*0xffc1652b*/
{
v9 = (_DWORD *)this[2]; /*0xffc16530*/
while ( !DxeIplFvIsAddrValid(v9, v8) ) /*0xffc1653a*/
{
++v7; /*0xffc1653c*/
v9 = (_DWORD *)(v10 + 16); /*0xffc1653d*/
if ( v7 >= this_1[1] ) /*0xffc16543*/
return -2147483645; /*0xffc16543*/
}
return (*(int ( **)(_DWORD *, int, int, int))(this_1[3] + 4 *v7))(a1, v12, a3, a4); /*0xffc1655f*/
}
else
{
return -2147483645; /*0xffc16545*/
}
}
return result; /*0xffc1654a*/
}
int DxeIplDecompressLzma(int a1, unsigned __int16 n8_1)
{
unsigned __int16 n8; // di
char n8_2; // cl
__int64 v5; // rax
int v6; // eax
int v7; // eax
int v8; // ecx
int result; // eax
unsigned int v10; // [esp+Ch] [ebp-10h]
n8 = n8_1; /*0xffc16574*/
v10 = *(_DWORD *)(a1 + 20); /*0xffc16582*/
n8_2 = n8_1; /*0xffc16585*/
LODWORD(v5) = 0; /*0xffc16588*/
HIDWORD(v5) = v10; /*0xffc1658a*/
if ( (n8_2 & 0x20) == 0 ) /*0xffc16590*/
v5 = v10; /*0xffc16592*/
*(_DWORD *)(a1 + 20) = v5 << (n8_2 & 0x1F); /*0xffc1659f*/
if ( n8 > *(_WORD *)(a1 + 16) ) /*0xffc165a6*/
{
do /*0xffc1660a*/
{
n8 -= *(_WORD *)(a1 + 16); /*0xffc165ab*/
v6 = 0; /*0xffc165c2*/
if ( (n8 & 0x20) == 0 ) /*0xffc165ca*/
v6 = *(_DWORD *)(a1 + 24); /*0xffc165cc*/
*(_DWORD *)(a1 + 20) |= v6 << n8; /*0xffc165d6*/
v7 = *(_DWORD *)(a1 + 32); /*0xffc165d9*/
if ( v7 ) /*0xffc165e1*/
{
v8 = *(_DWORD *)(a1 + 12); /*0xffc165e3*/
*(_DWORD *)(a1 + 24) = 0; /*0xffc165e7*/
*(_DWORD *)(a1 + 32) = v7 - 1; /*0xffc165eb*/
*(_DWORD *)(a1 + 24) = *(unsigned __int8 *)(*(_DWORD *)a1 + v8); /*0xffc165f4*/
*(_DWORD *)(a1 + 12) = v8 + 1; /*0xffc165fa*/
}
else
{
*(_DWORD *)(a1 + 24) = 0; /*0xffc165ff*/
}
*(_WORD *)(a1 + 16) = 8; /*0xffc16603*/
}
while ( n8 > 8u ); /*0xffc1660a*/
}
*(_WORD *)(a1 + 16) -= n8; /*0xffc1660c*/
result = *(_DWORD *)(a1 + 24) >> *(_BYTE *)(a1 + 16); /*0xffc16616*/
*(_DWORD *)(a1 + 20) |= result; /*0xffc16618*/
return result; /*0xffc1661b*/
}
int DxeIplGetDecompressAlgo(int a1, unsigned __int16 n8)
{
int v2; // esi
v2 = *(_DWORD *)(a1 + 20) >> (32 - n8); /*0xffc1662d*/
DxeIplDecompressLzma(a1, n8); /*0xffc16631*/
return v2; /*0xffc16638*/
}
int DxeIplHuffmanBuildTable(
int HuffCtx,
unsigned __int16 NumSymbols,
int CodeLen,
unsigned __int16 MaxBits,
int InitBits)
{
unsigned __int16 v5; // si
unsigned __int8 n0x10; // al
int n15; // ecx
int v8; // edx
int n16; // esi
__int16 v10; // ax
__int16 v11; // ax
unsigned __int16 MaxBits_1; // bp
int MaxBits_3; // esi
char v14; // bl
char MaxBits_2; // al
int MaxBits_6; // edx
__int16 v17; // ax
int MaxBits_4; // edx
__int16 v19; // ax
unsigned __int16 v20; // ax
int v21; // edx
int v22; // eax
unsigned int v23; // eax
int NumSymbols_3; // esi
int InitBits_1; // edi
int CodeLen_1; // ecx
unsigned int MaxBits_5; // edx
unsigned int v28; // ecx
unsigned __int16 v29; // bx
unsigned __int16 v30; // di
unsigned __int16 v31; // dx
int v32; // ebx
_WORD *v33; // ecx
int NumSymbols_2; // ebp
unsigned __int16 v35; // si
int n0x3FB; // edx
int v37; // ecx
int v39; // eax
unsigned __int16 v42; // [esp+14h] [ebp-64h]
int NumSymbols_1; // [esp+18h] [ebp-60h]
int NumSymbols_4; // [esp+1Ch] [ebp-5Ch]
unsigned __int16 v45; // [esp+20h] [ebp-58h]
unsigned __int16 v46; // [esp+28h] [ebp-50h]
int v47; // [esp+2Ch] [ebp-4Ch]
_WORD buf[18]; // [esp+30h] [ebp-48h] BYREF
_DWORD v49[8]; // [esp+54h] [ebp-24h]
__int16 v50; // [esp+76h] [ebp-2h]
memset(buf, 0, 34); /*0xffc16652*/
v5 = 0; /*0xffc16656*/
if ( NumSymbols ) /*0xffc1665f*/
{
do /*0xffc16668*/
{
n0x10 = *(_BYTE *)(v5 + CodeLen); /*0xffc16668*/
if ( n0x10 > 0x10u ) /*0xffc1666d*/
return 0xFFFF; /*0xffc1666d*/
++buf[n0x10]; /*0xffc16676*/
}
while ( ++v5 < NumSymbols ); /*0xffc16668*/
}
n15 = 15; /*0xffc16681*/
v8 = 0; /*0xffc16686*/
v49[0] = 0; /*0xffc1668b*/
n16 = 16; /*0xffc1668f*/
do /*0xffc166aa*/
{
v10 = buf[++v8]; /*0xffc16691*/
v11 = *(_WORD *)((char *)v49 + v8 *2) + (v10 << n15--); /*0xffc1669c*/
*(_WORD *)((char *)v49 + v8 *2 + 2) = v11; /*0xffc166a2*/
--n16; /*0xffc166a7*/
}
while ( n16 ); /*0xffc166aa*/
if ( v50 ) /*0xffc166b1*/
return 0xFFFF; /*0xffc1687f*/
MaxBits_1 = MaxBits; /*0xffc166bc*/
MaxBits_3 = 1; /*0xffc166c6*/
v14 = 16 - MaxBits; /*0xffc166c8*/
buf[0] = 0; /*0xffc166cd*/
if ( !MaxBits ) /*0xffc166d5*/
goto LABEL_45; /*0xffc166d5*/
MaxBits_2 = MaxBits; /*0xffc166d7*/
do /*0xffc166ff*/
{
MaxBits_6 = (unsigned __int16)MaxBits_3; /*0xffc166de*/
*((_WORD *)v49 + (unsigned __int16)MaxBits_3) >>= v14; /*0xffc166e4*/
v17 = 1 << (MaxBits_2 - MaxBits_3++); /*0xffc166ef*/
buf[MaxBits_6] = v17; /*0xffc166f3*/
MaxBits_2 = MaxBits; /*0xffc166f8*/
}
while ( (unsigned __int16)MaxBits_3 <= MaxBits ); /*0xffc166ff*/
if ( (unsigned __int16)MaxBits_3 <= 0x10u ) /*0xffc16707*/
{
LABEL_45:
do /*0xffc16721*/
{
MaxBits_4 = (unsigned __int16)MaxBits_3; /*0xffc1670c*/
v19 = 1 << (16 - MaxBits_3++); /*0xffc16715*/
buf[MaxBits_4] = v19; /*0xffc16719*/
}
while ( (unsigned __int16)MaxBits_3 <= 0x10u ); /*0xffc16721*/
MaxBits_1 = MaxBits; /*0xffc16723*/
}
v20 = *((_WORD *)v49 + MaxBits_1 + 1) >> v14; /*0xffc16735*/
v21 = v20; /*0xffc16738*/
if ( v20 ) /*0xffc1673e*/
{
v22 = (unsigned __int16)(1 << MaxBits_1); /*0xffc16747*/
if ( (unsigned __int16)v21 < (unsigned __int16)v22 ) /*0xffc1674d*/
{
v23 = 2 * (v22 - v21); /*0xffc16753*/
if ( v23 ) /*0xffc16755*/
DxeIplSetMem16((_WORD *)(InitBits + 2 *v21), v23 >> 1, 0); /*0xffc16767*/
}
}
NumSymbols_1 = NumSymbols; /*0xffc16774*/
NumSymbols_3 = 0; /*0xffc16787*/
v42 = 1 << (15 - MaxBits_1); /*0xffc1678c*/
v45 = 1 << MaxBits_1; /*0xffc16793*/
NumSymbols_4 = 0; /*0xffc16799*/
if ( NumSymbols ) /*0xffc167a2*/
{
InitBits_1 = InitBits; /*0xffc167a8*/
CodeLen_1 = CodeLen; /*0xffc167b1*/
do /*0xffc168e2*/
{
MaxBits_5 = *(unsigned __int8 *)((unsigned __int16)NumSymbols_3 + CodeLen_1); /*0xffc167bf*/
if ( *(_BYTE *)((unsigned __int16)NumSymbols_3 + CodeLen_1) && MaxBits_5 < 0x11 ) /*0xffc167cf*/
{
v47 = 2 *MaxBits_5; /*0xffc167d9*/
v28 = *((unsigned __int16 *)v49 + MaxBits_5); /*0xffc167dd*/
v29 = v28 + buf[MaxBits_5]; /*0xffc167ea*/
v46 = v29; /*0xffc167ed*/
if ( (unsigned __int16)MaxBits_5 <= MaxBits_1 ) /*0xffc167f4*/
{
while ( (unsigned __int16)v28 < v29 ) /*0xffc16893*/
{
if ( (unsigned __int16)v28 >= v45 ) /*0xffc16886*/
return 0xFFFF; /*0xffc168f2*/
v39 = (unsigned __int16)v28; /*0xffc16888*/
LOWORD(v28) = v28 + 1; /*0xffc1688b*/
*(_WORD *)(InitBits_1 + 2 *v39) = NumSymbols_3; /*0xffc1688c*/
}
}
else
{
v30 = *((_WORD *)v49 + MaxBits_5); /*0xffc167fa*/
v31 = MaxBits_5 - MaxBits_1; /*0xffc167fc*/
v32 = v31; /*0xffc1680d*/
v33 = (_WORD *)(InitBits + 2 * (v28 >> (16 - MaxBits))); /*0xffc16810*/
if ( v31 ) /*0xffc16816*/
{
NumSymbols_2 = NumSymbols_1; /*0xffc1681c*/
v35 = v42; /*0xffc16820*/
do /*0xffc168a5*/
{
if ( !*v33 && (unsigned __int16)NumSymbols_2 < 0x3FBu ) /*0xffc16833*/
{
*(_WORD *)(HuffCtx + 2 * (unsigned __int16)NumSymbols_2 + 42) = 0; /*0xffc1683e*/
*(_WORD *)(HuffCtx + 2 * (unsigned __int16)NumSymbols_2 + 2080) = 0; /*0xffc16843*/
v35 = v42; /*0xffc1684b*/
*v33 = NumSymbols_2++; /*0xffc1684f*/
}
n0x3FB = (unsigned __int16)*v33; /*0xffc16853*/
if ( (unsigned __int16)n0x3FB < 0x3FBu ) /*0xffc1685e*/
{
v37 = HuffCtx + 2 *n0x3FB; /*0xffc1686d*/
if ( (v30 & v35) != 0 ) /*0xffc16870*/
v33 = (_WORD *)(v37 + 2080); /*0xffc16872*/
else
v33 = (_WORD *)(v37 + 42); /*0xffc16897*/
}
v32 += 0xFFFF; /*0xffc1689a*/
v30 *= 2; /*0xffc168a0*/
}
while ( (_WORD)v32 ); /*0xffc168a5*/
NumSymbols_3 = NumSymbols_4; /*0xffc168ab*/
NumSymbols_1 = NumSymbols_2; /*0xffc168af*/
MaxBits_1 = MaxBits; /*0xffc168b3*/
}
v29 = v46; /*0xffc168ba*/
InitBits_1 = InitBits; /*0xffc168be*/
*v33 = NumSymbols_3; /*0xffc168c5*/
}
CodeLen_1 = CodeLen; /*0xffc168cc*/
*(_WORD *)((char *)v49 + v47) = v29; /*0xffc168d3*/
}
NumSymbols_4 = ++NumSymbols_3; /*0xffc168d9*/
}
while ( (unsigned __int16)NumSymbols_3 < NumSymbols ); /*0xffc168e2*/
}
return 0; /*0xffc168eb*/
}
int DxeIplLzmaDecodeCore1(
_DWORD *LzmaCtx,
unsigned __int16 count,
unsigned __int16 NumBits,
__int16 ShiftBits)
{
unsigned __int16 DecompressAlgo; // di
unsigned __int16 v7; // ax
int n0x1F; // esi
int n7; // eax
bool v11; // cf
unsigned int n0x10000000; // ecx
unsigned __int16 n3; // dx
int v14; // eax
__int16 i; // cx
int v16; // eax
int n0x1F_1; // eax
char n7_1; // [esp+14h] [ebp-8h]
DecompressAlgo = DxeIplGetDecompressAlgo((int)LzmaCtx, NumBits); /*0xffc16911*/
if ( !DecompressAlgo ) /*0xffc16917*/
{
v7 = DxeIplGetDecompressAlgo((int)LzmaCtx, NumBits); /*0xffc1691f*/
memset32(LzmaCtx + 3213, (v7 << 16) | v7, 0x80u); /*0xffc16939*/
DxeIplSetMem64(LzmaCtx + 1157, count, 0); /*0xffc16948*/
return 0; /*0xffc16952*/
}
n0x1F = 0; /*0xffc16959*/
while ( (unsigned __int16)n0x1F < 0x1Fu ) /*0xffc1696f*/
{
n7 = LzmaCtx[5] >> 29; /*0xffc16978*/
n7_1 = n7; /*0xffc1697b*/
v11 = (unsigned __int16)n7 < 7u; /*0xffc1697f*/
if ( (_WORD)n7 == 7 ) /*0xffc16982*/
{
n0x10000000 = 0x10000000; /*0xffc16984*/
if ( (LzmaCtx[5] & 0x10000000) == 0 ) /*0xffc1698c*/
goto LABEL_11; /*0xffc1698c*/
do /*0xffc16994*/
{
n0x10000000 >>= 1; /*0xffc1698e*/
LOWORD(n7) = n7 + 1; /*0xffc16990*/
}
while ( (n0x10000000 & LzmaCtx[5]) != 0 ); /*0xffc16994*/
n7_1 = n7; /*0xffc16996*/
v11 = (unsigned __int16)n7 < 7u; /*0xffc1699a*/
}
if ( !v11 ) /*0xffc1699d*/
{
LABEL_11:
n3 = n7 - 3; /*0xffc169a4*/
goto LABEL_12; /*0xffc169a7*/
}
n3 = 3; /*0xffc169a1*/
LABEL_12:
DxeIplDecompressLzma((int)LzmaCtx, n3); /*0xffc169aa*/
v14 = (unsigned __int16)n0x1F++; /*0xffc169b5*/
*((_BYTE *)LzmaCtx + v14 + 4628) = n7_1; /*0xffc169b9*/
if ( (_WORD)n0x1F == ShiftBits ) /*0xffc169c5*/
{
for ( i = DxeIplGetDecompressAlgo((int)LzmaCtx, 2u) - 1; i >= 0 && (unsigned __int16)n0x1F < 0x1Fu; --i ) /*0xffc169d2*/
{
v16 = (unsigned __int16)n0x1F++; /*0xffc169dc*/
*((_BYTE *)LzmaCtx + v16 + 4628) = 0; /*0xffc169e6*/
}
}
if ( (unsigned __int16)n0x1F >= DecompressAlgo ) /*0xffc169f9*/
break; /*0xffc169f9*/
}
while ( (unsigned __int16)n0x1F < count && (unsigned __int16)n0x1F < 0x1Fu ) /*0xffc16a0b*/
{
n0x1F_1 = (unsigned __int16)n0x1F; /*0xffc16a0d*/
LOWORD(n0x1F) = n0x1F + 1; /*0xffc16a10*/
*((_BYTE *)LzmaCtx + n0x1F_1 + 4628) = 0; /*0xffc16a11*/
}
return DxeIplHuffmanBuildTable((int)LzmaCtx, count, (int)(LzmaCtx + 1157), 8u, (int)(LzmaCtx + 3213)); /*0xffc16a3a*/
}
int __thiscall DxeIplLzmaDecodeCore2(_DWORD *LzmaCtx)
{
unsigned __int16 DecompressAlgo; // bp
unsigned __int16 v3; // si
int value; // eax
int n0x1FE; // esi
unsigned __int16 n0x13; // bx
unsigned int n0x800000; // ecx
int v8; // ebx
unsigned __int16 v9; // ax
int i; // ebx
int n0x1FE_1; // eax
int v12; // eax
DecompressAlgo = DxeIplGetDecompressAlgo((int)LzmaCtx, 9u); /*0xffc16a51*/
if ( DecompressAlgo )
{
n0x1FE = 0; /*0xffc16a9c*/
do
{
if ( (unsigned __int16)n0x1FE >= 0x1FEu ) /*0xffc16ab2*/
break; /*0xffc16ab2*/
n0x13 = *((_WORD *)LzmaCtx + HIBYTE(*(LzmaCtx + 5)) + 6426); /*0xffc16abe*/
if ( n0x13 >= 0x13u ) /*0xffc16ac9*/
{
n0x800000 = 0x800000; /*0xffc16acb*/
do /*0xffc16aec*/
{
if ( (n0x800000 & *(LzmaCtx + 5)) != 0 ) /*0xffc16ad6*/
n0x13 = *((_WORD *)LzmaCtx + n0x13 + 1040); /*0xffc16ad8*/
else
n0x13 = *((_WORD *)LzmaCtx + n0x13 + 21); /*0xffc16ae2*/
n0x800000 >>= 1; /*0xffc16ae7*/
}
while ( n0x13 >= 0x13u ); /*0xffc16aec*/
}
DxeIplDecompressLzma((int)LzmaCtx, *((unsigned __int8 *)LzmaCtx + n0x13 + 4628)); /*0xffc16afb*/
if ( n0x13 > 2u )
{
v12 = (unsigned __int16)n0x1FE++; /*0xffc16b6c*/
*((_BYTE *)LzmaCtx + v12 + 4118) = n0x13 - 2; /*0xffc16b73*/
}
else
{
if ( n0x13 )
{
v9 = n0x13 == 1
? DxeIplGetDecompressAlgo((int)LzmaCtx, 4u) + 3
: DxeIplGetDecompressAlgo((int)LzmaCtx, 9u) + 20;
v8 = v9; /*0xffc16b3b*/
}
else
{
v8 = 1; /*0xffc16b0f*/
}
for ( i = v8 + 0xFFFF; (i & 0x8000u) == 0; *((_BYTE *)LzmaCtx + n0x1FE_1 + 4118) = 0 ) /*0xffc16b47*/
{
if ( (unsigned __int16)n0x1FE >= 0x1FEu ) /*0xffc16b51*/
break; /*0xffc16b51*/
n0x1FE_1 = (unsigned __int16)n0x1FE; /*0xffc16b53*/
i += 0xFFFF; /*0xffc16b56*/
++n0x1FE; /*0xffc16b5c*/
}
}
}
while ( (unsigned __int16)n0x1FE < DecompressAlgo );
if ( (unsigned __int16)n0x1FE != 510 ) /*0xffc16b92*/
DxeIplSetMem64((char *)LzmaCtx + (unsigned __int16)n0x1FE + 4118, 510 - (unsigned __int16)n0x1FE, 0); /*0xffc16ba0*/
return DxeIplHuffmanBuildTable((int)LzmaCtx, 0x1FEu, (int)LzmaCtx + 4118, 0xCu, (int)(LzmaCtx + 1165)); /*0xffc16bbc*/
}
else
{
v3 = DxeIplGetDecompressAlgo((int)LzmaCtx, 9u); /*0xffc16a6b*/
DxeIplSetMem64((char *)LzmaCtx + 4118, 0x1FEu, 0); /*0xffc16a74*/
value = (v3 << 16) | v3; /*0xffc16a91*/
memset32(LzmaCtx + 1165, value, 0x800u); /*0xffc16a93*/
}
return value; /*0xffc16bc4*/
}
unsigned __int16 __thiscall DxeIplLzmaRangeDecode(int this)
{
__int16 v2; // ax
__int16 v4; // ax
unsigned int v5; // eax
unsigned __int16 n0x1FE; // di
unsigned int n0x80000; // ecx
if ( !*(_WORD *)(this + 28) ) /*0xffc16bd4*/
{
*(_WORD *)(this + 28) = DxeIplGetDecompressAlgo(this, 0x10u); /*0xffc16bec*/
v2 = DxeIplLzmaDecodeCore1((_DWORD *)this, 0x13u, 5u, 3); /*0xffc16bf0*/
*(_WORD *)(this + 40) = v2; /*0xffc16bf5*/
if ( v2 ) /*0xffc16bfe*/
return 0; /*0xffc16bfe*/
DxeIplLzmaDecodeCore2((_DWORD *)this); /*0xffc16c06*/
v4 = DxeIplLzmaDecodeCore1((_DWORD *)this, 0x1Fu, *(unsigned __int8 *)(this + 13364), 0xFFFF); /*0xffc16c19*/
*(_WORD *)(this + 40) = v4; /*0xffc16c1e*/
if ( v4 ) /*0xffc16c27*/
return 0; /*0xffc16c00*/
}
v5 = *(_DWORD *)(this + 20); /*0xffc16c29*/
--*(_WORD *)(this + 28); /*0xffc16c31*/
n0x1FE = *(_WORD *)(this + 2 * (v5 >> 20) + 4660); /*0xffc16c38*/
if ( n0x1FE >= 0x1FEu ) /*0xffc16c43*/
{
n0x80000 = 0x80000; /*0xffc16c45*/
do /*0xffc16c66*/
{
if ( (n0x80000 & *(_DWORD *)(this + 20)) != 0 ) /*0xffc16c50*/
n0x1FE = *(_WORD *)(this + 2 *n0x1FE + 2080); /*0xffc16c52*/
else
n0x1FE = *(_WORD *)(this + 2 *n0x1FE + 42); /*0xffc16c5c*/
n0x80000 >>= 1; /*0xffc16c61*/
}
while ( n0x1FE >= 0x1FEu ); /*0xffc16c66*/
}
DxeIplDecompressLzma(this, *(unsigned __int8 *)(n0x1FE + this + 4118)); /*0xffc16c75*/
return n0x1FE; /*0xffc16c7d*/
}
char DxeIplLzmaBitDecode(int i)
{
int j; // esi
unsigned __int16 n0x100; // cx
unsigned int DecompressAlgo; // eax
unsigned int v4; // edx
int v5; // ebx
unsigned __int16 n0x1F; // di
unsigned int n0x800000; // ecx
unsigned int n0x1F_1; // ebp
unsigned int k; // edx
unsigned int v10; // edi
int v11; // ecx
for ( j = i; ; i = j ) /*0xffc16c8b*/
{
n0x100 = DxeIplLzmaRangeDecode(i); /*0xffc16c92*/
LOBYTE(DecompressAlgo) = 0; /*0xffc16c95*/
if ( *(_WORD *)(j + 40) ) /*0xffc16c97*/
break; /*0xffc16c97*/
LOBYTE(DecompressAlgo) = 0; /*0xffc16ca1*/
if ( n0x100 >= 0x100u ) /*0xffc16cac*/
{
v5 = (unsigned __int16)(n0x100 - 253); /*0xffc16cce*/
n0x1F = *(_WORD *)(j + 2 *HIBYTE(*(_DWORD *)(j + 20)) + 12852); /*0xffc16cd7*/
if ( n0x1F >= 0x1Fu ) /*0xffc16ce2*/
{
n0x800000 = 0x800000; /*0xffc16ce4*/
do /*0xffc16d05*/
{
if ( (n0x800000 & *(_DWORD *)(j + 20)) != 0 ) /*0xffc16cef*/
n0x1F = *(_WORD *)(j + 2 *n0x1F + 2080); /*0xffc16cf1*/
else
n0x1F = *(_WORD *)(j + 2 *n0x1F + 42); /*0xffc16cfb*/
n0x800000 >>= 1; /*0xffc16d00*/
}
while ( n0x1F >= 0x1Fu ); /*0xffc16d05*/
}
n0x1F_1 = n0x1F; /*0xffc16d07*/
DxeIplDecompressLzma(j, *(unsigned __int8 *)(j + n0x1F + 4628)); /*0xffc16d14*/
LOBYTE(DecompressAlgo) = 1; /*0xffc16d1b*/
if ( n0x1F > 1u ) /*0xffc16d1f*/
{
DecompressAlgo = DxeIplGetDecompressAlgo(j, n0x1F - 1); /*0xffc16d26*/
n0x1F_1 = DecompressAlgo + (1 << (n0x1F - 1)); /*0xffc16d35*/
}
for ( k = *(_DWORD *)(j + 8) - n0x1F_1 - 1; ; ++k ) /*0xffc16d41*/
{
v5 += 0xFFFF; /*0xffc16d5e*/
if ( (v5 & 0x8000u) != 0 ) /*0xffc16d63*/
break; /*0xffc16d63*/
v10 = *(_DWORD *)(j + 8); /*0xffc16d44*/
if ( v10 >= *(_DWORD *)(j + 36) ) /*0xffc16d4a*/
return DecompressAlgo; /*0xffc16d4a*/
if ( k >= *(_DWORD *)(j + 36) ) /*0xffc16d4f*/
{
*(_WORD *)(j + 40) = -1; /*0xffc16d74*/
return DecompressAlgo; /*0xffc16d74*/
}
v11 = *(_DWORD *)(j + 4); /*0xffc16d51*/
LOBYTE(DecompressAlgo) = *(_BYTE *)(v11 + k); /*0xffc16d54*/
*(_BYTE *)(v11 + v10) = DecompressAlgo; /*0xffc16d57*/
++*(_DWORD *)(j + 8); /*0xffc16d5a*/
}
DecompressAlgo = *(_DWORD *)(j + 8); /*0xffc16d65*/
if ( DecompressAlgo >= *(_DWORD *)(j + 36) ) /*0xffc16d6b*/
return DecompressAlgo; /*0xffc16d6b*/
}
else
{
v4 = *(_DWORD *)(j + 8); /*0xffc16cae*/
if ( v4 >= *(_DWORD *)(j + 36) ) /*0xffc16cb4*/
return DecompressAlgo; /*0xffc16cb4*/
*(_BYTE *)(v4 + *(_DWORD *)(j + 4)) = n0x100; /*0xffc16cbd*/
++*(_DWORD *)(j + 8); /*0xffc16cc0*/
}
}
return DecompressAlgo; /*0xffc16d78*/
}
int DxeIplLzmaGetProp(_DWORD *src, unsigned int n8, _DWORD *DestSize, _DWORD *SrcSize)
{
unsigned int n8_1; // eax
if ( n8 < 8 ) /*0xffc16d83*/
return -2147483646; /*0xffc16d83*/
n8_1 = *src + 8; /*0xffc16d87*/
if ( n8 < n8_1 || n8_1 < 8 ) /*0xffc16d91*/
return -2147483646; /*0xffc16da9*/
*SrcSize = 13368; /*0xffc16d97*/
*DestSize = src[1]; /*0xffc16da4*/
return 0; /*0xffc16da8*/
}
unsigned int DxeIplLzmaDecodeProp(unsigned __int8 *src, unsigned __int8 *a2, unsigned __int8 **buf, int n2)
{
unsigned __int8 *v4; // edi
unsigned __int8 *v5; // ebx
unsigned __int8 *v7; // ebp
v4 = (unsigned __int8 *)(*src + ((src[1] + ((src[2] + (src[3] << 8)) << 8)) << 8)); /*0xffc16ddb*/
v5 = (unsigned __int8 *)(src[4] + ((src[5] + ((src[6] + (src[7] << 8)) << 8)) << 8)); /*0xffc16df3*/
if ( !v5 ) /*0xffc16df5*/
return 0; /*0xffc16df7*/
v7 = src + 8; /*0xffc16dff*/
DxeIplSetMem64(buf, 0x3438u, 0); /*0xffc16e0a*/
if ( n2 == 1 ) /*0xffc16e19*/
{
*((_BYTE *)buf + 13364) = 4; /*0xffc16e29*/
}
else if ( n2 == 2 ) /*0xffc16e1e*/
{
*((_BYTE *)buf + 13364) = 5; /*0xffc16e20*/
}
*buf = v7; /*0xffc16e39*/
buf[1] = a2; /*0xffc16e3b*/
buf[8] = v4; /*0xffc16e3e*/
buf[9] = v5; /*0xffc16e41*/
DxeIplDecompressLzma((int)buf, 0x20u); /*0xffc16e44*/
DxeIplLzmaBitDecode((int)buf); /*0xffc16e4b*/
return *((_WORD *)buf + 20) != 0 ? 0x80000002 : 0;
}
int DxeIplPpiNotifyCallback(int FfsHeader, _DWORD *DestSize, _DWORD *SrcSize, _WORD *PropFlags)
{
int DataOffset; // eax
int DataSize; // edx
if ( !FfsHeader ) /*0xffc16e70*/
return -2147483646; /*0xffc16e70*/
if ( (*(_DWORD *)FfsHeader & 0xFFFFFF) != 0xFFFFFF ) /*0xffc16e89*/
{
if ( DxeIplFvIsAddrValid(dword_FFC18D18, (_DWORD *)(FfsHeader + 4)) ) /*0xffc16ead*/
{
*PropFlags = *(_WORD *)(FfsHeader + 22); /*0xffc16ebd*/
DataOffset = *(unsigned __int16 *)(FfsHeader + 20); /*0xffc16ec2*/
DataSize = *(_DWORD *)FfsHeader & 0xFFFFFF; /*0xffc16ec6*/
return DxeIplLzmaGetProp((_DWORD *)(DataOffset + FfsHeader), DataSize - DataOffset, DestSize, SrcSize); /*0xffc16ec6*/
}
return -2147483646; /*0xffc16e77*/
}
if ( !DxeIplFvIsAddrValid(dword_FFC18D18, (_DWORD *)(FfsHeader + 8)) ) /*0xffc16e95*/
return -2147483646; /*0xffc16e95*/
*PropFlags = *(_WORD *)(FfsHeader + 26); /*0xffc16e9e*/
DataOffset = *(unsigned __int16 *)(FfsHeader + 24); /*0xffc16ea1*/
DataSize = *(_DWORD *)(FfsHeader + 4); /*0xffc16ea5*/
return DxeIplLzmaGetProp((_DWORD *)(DataOffset + FfsHeader), DataSize - DataOffset, DestSize, SrcSize); /*0xffc16eda*/
}
unsigned int DxeIplPeiEndCallback(
int FfsHeader,
unsigned __int8 **SrcData,
unsigned __int8 **DestData,
_DWORD *DestSize)
{
int DataOffset; // ecx
if ( (*(_DWORD *)FfsHeader & 0xFFFFFF) == 0xFFFFFF ) /*0xffc16efb*/
{
if ( !DxeIplFvIsAddrValid(dword_FFC18D18, (_DWORD *)(FfsHeader + 8)) ) /*0xffc16f00*/
return -2147483646; /*0xffc16f0e*/
*DestSize = 0; /*0xffc16f13*/
DataOffset = *(unsigned __int16 *)(FfsHeader + 24); /*0xffc16f16*/
}
else
{
if ( !DxeIplFvIsAddrValid(dword_FFC18D18, (_DWORD *)(FfsHeader + 4)) ) /*0xffc16f26*/
return -2147483646; /*0xffc16f26*/
*DestSize = 0; /*0xffc16f2b*/
DataOffset = *(unsigned __int16 *)(FfsHeader + 20); /*0xffc16f2e*/
}
return DxeIplLzmaDecodeProp((unsigned __int8 *)(FfsHeader + DataOffset), *SrcData, DestData, 2); /*0xffc16f45*/
}
int DxeIplReportStatusCode(char n2, int n50532357)
{
int v3; // eax
_BYTE v4[2]; // [esp+4h] [ebp-Ch] BYREF
int v5; // [esp+6h] [ebp-Ah]
_BYTE *v6; // [esp+Ch] [ebp-4h]
if ( n2 != 2 && n2 != 3 ) /*0xffc16f60*/
return -2147483645; /*0xffc16f62*/
v6 = v4; /*0xffc16f6c*/
__sidt(v4); /*0xffc16f72*/
v3 = (*(int ( **)(_DWORD, char, int, _DWORD, _DWORD *, _DWORD))(**(_DWORD **)(v5 - 4) + 88))( /*0xffc16f89*/
*(_DWORD *)(v5 - 4),
n2,
n50532357,
0,
dword_FFC18DB8,
0);
return v3 != -1610612734 ? v3 : 0;
}
_WORD *DxeIplGetFvFromHob(_DWORD *a1, _DWORD *a2)
{
_WORD *i; // eax
_WORD *v5; // eax
_WORD *i_1; // eax
_WORD *result; // eax
void *buf; // eax
void *buf_1; // eax
i = (_WORD *)DxeIplGetPeiServices(); /*0xffc16fab*/
v5 = DxeIplGetBootModeGuid((int)&unk_FFC18DA8, i); /*0xffc16fb9*/
if ( v5 ) /*0xffc16fc0*/
{
*a1 = v5 + 12; /*0xffc16fc5*/
i_1 = (_WORD *)DxeIplGetPeiServices(); /*0xffc16fc7*/
result = DxeIplGetBootModeGuid((int)&unk_FFC18CF8, i_1) + 12; /*0xffc16fd8*/
}
else
{
buf = (void *)DxeIplAllocPages((int)&unk_FFC18DA8, 40008); /*0xffc16fe6*/
*a1 = buf; /*0xffc16fed*/
*a1 = DxeIplSetMem32(buf, 0x9C48u); /*0xffc16ff4*/
buf_1 = (void *)DxeIplAllocPages((int)&unk_FFC18CF8, 4000); /*0xffc17002*/
*a2 = buf_1; /*0xffc17009*/
result = DxeIplSetMem32(buf_1, 0xFA0u); /*0xffc1700b*/
}
*a2 = result; /*0xffc17014*/
return result; /*0xffc17013*/
}
int __thiscall DxeIplGetPeiProtocol(_DWORD *this)
{
int v2; // esi
int v3; // ebx
v2 = 0; /*0xffc17030*/
if ( *this ) /*0xffc17032*/
{
while ( 1 ) /*0xffc1703c*/
{
v3 = *this - v2 - 1; /*0xffc1703c*/
if ( !*((_QWORD *)this + 5 *v3 + 5) && !*((_QWORD *)this + 5 *v3 + 1) && !DxeIplLzmaGetBit(7) && !DxeIplLzmaGetBit(7) ) /*0xffc17071*/
break; /*0xffc17071*/
if ( (unsigned int)++v2 >= *this ) /*0xffc1707e*/
return v2; /*0xffc1707e*/
}
return v3; /*0xffc17086*/
}
return v2; /*0xffc1708a*/
}
int DxeIplDebugPrintGuid(int Guid, char *DxeIpl)
{
_DWORD *v2; // esi
int v3; // ebp
int v4; // edi
int v5; // ebx
char *DxeIpl_2; // eax
int v7; // eax
_DWORD *v9; // [esp+14h] [ebp-Ch] BYREF
char *DxeIpl_1; // [esp+18h] [ebp-8h]
int v11; // [esp+1Ch] [ebp-4h] BYREF
DxeIpl_1 = DxeIpl; /*0xffc17095*/
DxeIplGetFvFromHob(&v9, &v11); /*0xffc170a2*/
v2 = v9; /*0xffc170a7*/
v3 = *v9; /*0xffc170ab*/
if ( *v9 >= 0x3E8u ) /*0xffc170b3*/
return -2147483639; /*0xffc170b5*/
v5 = 10 *v3; /*0xffc170bc*/
*v9 = v3 + 1; /*0xffc170c2*/
v4 = 0; /*0xffc170c4*/
DxeIpl_2 = DxeIpl_1; /*0xffc170c6*/
v2[v5 + 2] = 0; /*0xffc170ca*/
v2[v5 + 3] = 0; /*0xffc170ce*/
if ( DxeIpl_2 ) /*0xffc170d4*/
DxeIplLzmaDecodeSymbol(DxeIpl_2); /*0xffc170dd*/
v7 = v11; /*0xffc170e4*/
v2[v5 + 10] = 0; /*0xffc170e8*/
v2[v5 + 11] = 0; /*0xffc170ec*/
*(_DWORD *)(v7 + 4 *v3) = 0; /*0xffc170f0*/
*(_QWORD *)&v2[v5 + 8] = __rdtsc(); /*0xffc170f5*/
return v4; /*0xffc170ff*/
}
int DxeIplGetBootModeFromHob()
{
unsigned __int64 v2; // rax
unsigned int v3; // ebx
unsigned int v4; // edi
unsigned int *v5; // esi
unsigned int v6; // eax
int v8; // eax
int v9; // [esp+Ch] [ebp-8h] BYREF
unsigned int *v10; // [esp+10h] [ebp-4h] BYREF
v2 = __rdtsc(); /*0xffc17111*/
v3 = HIDWORD(v2); /*0xffc17113*/
v4 = v2; /*0xffc1711b*/
DxeIplGetFvFromHob(&v10, &v9); /*0xffc1711d*/
v5 = v10; /*0xffc17125*/
v6 = DxeIplGetPeiProtocol(v10); /*0xffc1712b*/
if ( v6 >= *v5 ) /*0xffc17135*/
return -2147483634; /*0xffc17137*/
v8 = 10 * (v6 + 1); /*0xffc1713f*/
v5[v8] = v4; /*0xffc17142*/
v5[v8 + 1] = v3; /*0xffc17145*/
return 0; /*0xffc1714b*/
}
int DxeIplDxeIplPpiNotify(int a1, _DWORD *a2, _DWORD *a3, _WORD *a4)
{
int v5; // ecx
if ( (*(_DWORD *)a1 & 0xFFFFFF) == 0xFFFFFF ) /*0xffc1716d*/
{
if ( !DxeIplFvIsAddrValid(dword_FFC18D58, (_DWORD *)(a1 + 8)) ) /*0xffc17172*/
return -2147483646; /*0xffc17180*/
*a4 = *(_WORD *)(a1 + 26); /*0xffc17189*/
v5 = *(unsigned __int16 *)(a1 + 24); /*0xffc1718c*/
}
else
{
if ( !DxeIplFvIsAddrValid(dword_FFC18D58, (_DWORD *)(a1 + 4)) ) /*0xffc1719c*/
return -2147483646; /*0xffc1719c*/
*a4 = *(_WORD *)(a1 + 22); /*0xffc171a5*/
v5 = *(unsigned __int16 *)(a1 + 20); /*0xffc171a8*/
}
*a2 = DxeIplLzmaInitState(a1 + v5); /*0xffc171b6*/
*a3 = 0x10000; /*0xffc171bb*/
return 0; /*0xffc171c3*/
}
int DxeIplEndOfPeiNotify(_DWORD *a1, _DWORD *a2, int a3, _DWORD *a4)
{
if ( (*a1 & 0xFFFFFF) == 0xFFFFFF ) /*0xffc171e3*/
{
if ( !DxeIplFvIsAddrValid(dword_FFC18D58, a1 + 2) ) /*0xffc171e8*/
return -2147483646; /*0xffc171f6*/
*a4 = 0; /*0xffc171fb*/
}
else
{
if ( !DxeIplFvIsAddrValid(dword_FFC18D58, a1 + 1) ) /*0xffc17211*/
return -2147483646; /*0xffc17211*/
*a4 = 0; /*0xffc17216*/
}
return DxeIplLzmaInitRange(*a2, a3); /*0xffc17234*/
}
int DxeIplGetPpiPtr(int a1, unsigned int a2)
{
unsigned int v2; // esi
int result; // eax
v2 = *(_DWORD *)(a1 + 12); /*0xffc17244*/
if ( v2 < a2 ) /*0xffc17249*/
return 0; /*0xffc1725b*/
result = *(_DWORD *)(a1 + 8); /*0xffc1724b*/
*(_DWORD *)(a1 + 12) = v2 - a2; /*0xffc17250*/
*(_DWORD *)(a1 + 8) = result + a2; /*0xffc17256*/
return result; /*0xffc1725d*/
}
void nullsub_2()
{
; /*0xffc17260*/
}
int __thiscall DxeIplLzmaInitState(unsigned __int8 *this)
{
int i; // edi
__int64 v2; // rax
__int64 v4; // [esp+Ch] [ebp-8h]
v4 = 0; /*0xffc17266*/
for ( i = 12; i >= 5; --i ) /*0xffc17275*/
{
v2 = (v4 << 8) + *(this + i); /*0xffc17295*/
v4 = v2; /*0xffc1729a*/
}
return v2; /*0xffc172a5*/
}
unsigned int DxeIplLzmaInitRange(unsigned __int8 *a1, int a2, int a3, int a4)
{
int v6; // ecx
_DWORD v8[4]; // [esp+8h] [ebp-18h] BYREF
int v9; // [esp+18h] [ebp-8h] BYREF
int v10; // [esp+1Ch] [ebp-4h] BYREF
v8[0] = DxeIplGetPpiPtr; /*0xffc172b9*/
v8[1] = nullsub_2; /*0xffc172c2*/
v8[2] = a4; /*0xffc172c9*/
v8[3] = 0x10000; /*0xffc172cc*/
v10 = DxeIplLzmaInitState(a1); /*0xffc172d8*/
a4 = a2 - 13; /*0xffc172e1*/
return DxeIplDecodeData(a3, (unsigned int *)&v10, a1 + 13, (unsigned int *)&a4, (int)a1, v6, v6, &v9, (int)v8) != 0
? 0x80000002
: 0;
}
char DxeIplLzmaDecodeLiteral(_DWORD *StreamCtx, unsigned int n0x112)
{
unsigned int n0x112_2; // edi
unsigned int v4; // edx
int v5; // ebp
unsigned int n0x112_1; // esi
unsigned int v7; // ebx
int v9; // [esp+8h] [ebp-4h]
n0x112_2 = StreamCtx[18]; /*0xffc17e2c*/
if ( n0x112_2 && n0x112_2 < 0x112 )
{
v4 = StreamCtx[9]; /*0xffc17e3d*/
n0x112 -= v4; /*0xffc17e40*/
v5 = StreamCtx[5]; /*0xffc17e47*/
n0x112_1 = StreamCtx[18]; /*0xffc17e4b*/
v9 = StreamCtx[10]; /*0xffc17e4d*/
v7 = StreamCtx[14]; /*0xffc17e51*/
if ( n0x112 < n0x112_2 ) /*0xffc17e5a*/
n0x112_1 = n0x112; /*0xffc17e5c*/
if ( !StreamCtx[12] ) /*0xffc17e5e*/
{
n0x112 = StreamCtx[3] - StreamCtx[11]; /*0xffc17e69*/
if ( n0x112 <= n0x112_1 ) /*0xffc17e6e*/
StreamCtx[12] = StreamCtx[3]; /*0xffc17e70*/
}
StreamCtx[11] += n0x112_1; /*0xffc17e77*/
for ( StreamCtx[18] = n0x112_2 - n0x112_1; n0x112_1; --n0x112_1 )
{
LOBYTE(n0x112) = *(_BYTE *)(v4 + (v4 < v7 ? v9 : 0) - v7 + v5);
*(_BYTE *)(v4 + v5) = n0x112; /*0xffc17e94*/
++v4; /*0xffc17e97*/
}
StreamCtx[9] = v4; /*0xffc17e9f*/
}
return n0x112; /*0xffc17ea3*/
}
int DxeIplLzmaDecodeMatch(int *StreamCtx, unsigned int n0x112, unsigned int src)
{
unsigned int n0x112_1; // edx
int v6; // ebx
unsigned int v7; // ecx
int result; // eax
unsigned int v9; // eax
while ( 1 ) /*0xffc17eb7*/
{
n0x112_1 = n0x112; /*0xffc17eb7*/
if ( !StreamCtx[12] ) /*0xffc17eb3*/
{
v6 = StreamCtx[9]; /*0xffc17ec0*/
v7 = StreamCtx[3] - StreamCtx[11]; /*0xffc17ec5*/
if ( n0x112 - v6 > v7 ) /*0xffc17eca*/
n0x112_1 = v6 + v7; /*0xffc17ecc*/
}
result = DxeIplLzmaDecodeRange(StreamCtx, n0x112_1, src); /*0xffc17ed2*/
if ( result ) /*0xffc17ed9*/
break; /*0xffc17ed9*/
if ( !StreamCtx[12] ) /*0xffc17edb*/
{
v9 = StreamCtx[3]; /*0xffc17ee0*/
if ( StreamCtx[11] >= v9 ) /*0xffc17ee6*/
StreamCtx[12] = v9; /*0xffc17ee8*/
}
DxeIplLzmaDecodeLiteral(StreamCtx, n0x112); /*0xffc17eef*/
if ( StreamCtx[9] >= n0x112 || StreamCtx[6] >= src || (unsigned int)StreamCtx[18] >= 0x112 ) /*0xffc17f05*/
{
if ( (unsigned int)StreamCtx[18] > 0x112 ) /*0xffc17f0e*/
StreamCtx[18] = 274; /*0xffc17f10*/
return 0; /*0xffc17f17*/
}
}
return result; /*0xffc17f19*/
}
int DxeIplLzmaDecodeStream(
int StreamCtx,
unsigned int NumBits,
unsigned __int8 *src,
unsigned int *DstData,
int DstSize,
_DWORD *a6)
{
unsigned int *DstData_1; // edi
unsigned int n0x14; // ebx
unsigned __int8 *src_1; // edx
unsigned int n5; // ecx
int v12; // ecx
int v13; // eax
unsigned int n0x14_2; // edi
unsigned __int8 *src_2; // edi
unsigned __int8 *src_3; // eax
int n2; // eax
int v18; // eax
unsigned int n0x14_1; // ecx
int n2_1; // eax
unsigned int n0x14_4; // eax
unsigned int n0x14_5; // edi
unsigned int v23; // eax
int v25; // ecx
unsigned int n0x14_3; // [esp+14h] [ebp-4h]
int v28; // [esp+28h] [ebp+10h]
DstData_1 = DstData; /*0xffc1849c*/
n0x14 = *DstData; /*0xffc184a8*/
*DstData = 0; /*0xffc184aa*/
DxeIplLzmaDecodeLiteral((_DWORD *)StreamCtx, NumBits); /*0xffc184ad*/
*a6 = 0; /*0xffc184b9*/
if ( *(_DWORD *)(StreamCtx + 72) == 274 ) /*0xffc184c4*/
{
LABEL_52:
v25 = *(_DWORD *)(StreamCtx + 32); /*0xffc1870f*/
if ( !v25 ) /*0xffc18714*/
*a6 = 1; /*0xffc18716*/
return v25 != 0; /*0xffc18721*/
}
src_1 = src; /*0xffc184ca*/
while ( 1 ) /*0xffc184ce*/
{
if ( *(_DWORD *)(StreamCtx + 76) ) /*0xffc184ce*/
{
if ( n0x14 ) /*0xffc184d6*/
{
do /*0xffc184ef*/
{
n5 = *(_DWORD *)(StreamCtx + 88); /*0xffc184d8*/
if ( n5 >= 5 ) /*0xffc184de*/
break; /*0xffc184de*/
*(_BYTE *)(n5 + StreamCtx + 92) = *src_1; /*0xffc184e2*/
++*(_DWORD *)(StreamCtx + 88); /*0xffc184e6*/
++src_1; /*0xffc184e9*/
++*DstData_1; /*0xffc184ea*/
--n0x14; /*0xffc184ec*/
}
while ( n0x14 ); /*0xffc184ef*/
src = src_1; /*0xffc184f3*/
}
if ( *(_DWORD *)(StreamCtx + 88) < 5u ) /*0xffc184fc*/
goto LABEL_42; /*0xffc184fc*/
if ( *(_BYTE *)(StreamCtx + 92) ) /*0xffc18502*/
return 1; /*0xffc18506*/
v12 = *(unsigned __int8 *)(StreamCtx + 95) /*0xffc18522*/
| ((*(unsigned __int8 *)(StreamCtx + 94) | (*(unsigned __int8 *)(StreamCtx + 93) << 8)) << 8);
v13 = *(unsigned __int8 *)(StreamCtx + 96); /*0xffc18524*/
*(_DWORD *)(StreamCtx + 28) = -1; /*0xffc18528*/
*(_DWORD *)(StreamCtx + 76) = 0; /*0xffc18531*/
*(_DWORD *)(StreamCtx + 32) = v13 | (v12 << 8); /*0xffc18534*/
*(_DWORD *)(StreamCtx + 88) = 0; /*0xffc18539*/
}
v28 = 0; /*0xffc18545*/
if ( *(_DWORD *)(StreamCtx + 36) >= NumBits ) /*0xffc1854c*/
{
if ( *(_DWORD *)(StreamCtx + 72) ) /*0xffc1854e*/
{
*a6 = 2; /*0xffc186d4*/
return 1; /*0xffc186dd*/
}
if ( !*(_DWORD *)(StreamCtx + 32) ) /*0xffc1855a*/
{
*a6 = 4; /*0xffc186cb*/
return 0; /*0xffc186d2*/
}
v28 = 1; /*0xffc18560*/
}
if ( *(_DWORD *)(StreamCtx + 80) ) /*0xffc18564*/
{
memset32( /*0xffc18585*/
*(void **)(StreamCtx + 16),
67109888,
(unsigned int)((768 << (*(_BYTE *)StreamCtx + *(_BYTE *)(StreamCtx + 4))) + 1846) >> 1);
*(_DWORD *)(StreamCtx + 68) = 1; /*0xffc1858f*/
*(_DWORD *)(StreamCtx + 64) = 1; /*0xffc18592*/
*(_DWORD *)(StreamCtx + 60) = 1; /*0xffc18595*/
*(_DWORD *)(StreamCtx + 56) = 1; /*0xffc18598*/
*(_DWORD *)(StreamCtx + 52) = 0; /*0xffc1859b*/
*(_DWORD *)(StreamCtx + 80) = 0; /*0xffc1859f*/
}
n0x14_2 = *(_DWORD *)(StreamCtx + 88); /*0xffc185a3*/
if ( !n0x14_2 ) /*0xffc185a8*/
{
if ( n0x14 >= 0x14 && !v28 ) /*0xffc185b3*/
{
src_2 = src; /*0xffc185b5*/
src_3 = &src[n0x14 - 20]; /*0xffc185bc*/
LABEL_25:
*(_DWORD *)(StreamCtx + 24) = src_2; /*0xffc185eb*/
if ( DxeIplLzmaDecodeMatch((int *)StreamCtx, NumBits, (unsigned int)src_3) ) /*0xffc185f5*/
return 1; /*0xffc185fc*/
src_1 = *(unsigned __int8 **)(StreamCtx + 24); /*0xffc18605*/
v18 = src_1 - src_2; /*0xffc18608*/
DstData_1 = DstData; /*0xffc1860a*/
src = src_1; /*0xffc1860e*/
*DstData += v18; /*0xffc18612*/
n0x14 -= v18; /*0xffc18614*/
goto LABEL_40; /*0xffc18616*/
}
src_2 = src; /*0xffc185c0*/
n2 = DxeIplLzmaDecodeBitTree((_DWORD *)StreamCtx, src, n0x14); /*0xffc185c9*/
if ( n2 ) /*0xffc185d1*/
{
if ( v28 && n2 != 2 ) /*0xffc185e3*/
break; /*0xffc185e3*/
src_3 = src; /*0xffc185e9*/
goto LABEL_25; /*0xffc185e9*/
}
DxeIplFvFreePages((char *)(StreamCtx + 92), (char *)src, n0x14); /*0xffc186ed*/
*(_DWORD *)(StreamCtx + 88) = n0x14; /*0xffc186f7*/
*DstData += n0x14; /*0xffc186fa*/
LABEL_42:
*a6 = 3; /*0xffc186c0*/
return 0; /*0xffc186c9*/
}
n0x14_1 = 0; /*0xffc1861b*/
n0x14_3 = 0; /*0xffc1861d*/
if ( n0x14_2 < 0x14 ) /*0xffc18624*/
{
do /*0xffc18636*/
{
if ( n0x14_1 >= n0x14 ) /*0xffc18628*/
break; /*0xffc18628*/
*(_BYTE *)(n0x14_2 + StreamCtx + 92) = src_1[n0x14_1]; /*0xffc1862d*/
++n0x14_2; /*0xffc18631*/
++n0x14_1; /*0xffc18632*/
}
while ( n0x14_2 < 0x14 ); /*0xffc18636*/
n0x14_3 = n0x14_1; /*0xffc18638*/
}
*(_DWORD *)(StreamCtx + 88) = n0x14_2; /*0xffc1863c*/
if ( n0x14_2 < 0x14 || v28 ) /*0xffc18649*/
{
n2_1 = DxeIplLzmaDecodeBitTree((_DWORD *)StreamCtx, (unsigned __int8 *)(StreamCtx + 92), n0x14_2); /*0xffc18651*/
if ( !n2_1 ) /*0xffc18659*/
{
*DstData += n0x14_3; /*0xffc1870b*/
goto LABEL_42; /*0xffc1870d*/
}
if ( v28 && n2_1 != 2 ) /*0xffc1866b*/
break; /*0xffc1866b*/
}
*(_DWORD *)(StreamCtx + 24) = StreamCtx + 92; /*0xffc18677*/
if ( DxeIplLzmaDecodeMatch((int *)StreamCtx, NumBits, StreamCtx + 92) ) /*0xffc1867a*/
return 1; /*0xffc18681*/
n0x14_4 = *(_DWORD *)(StreamCtx + 24) - StreamCtx - 92; /*0xffc18688*/
if ( n0x14_2 < n0x14_4 ) /*0xffc1868d*/
return 11; /*0xffc1868d*/
n0x14_5 = n0x14_2 - n0x14_4; /*0xffc1868f*/
if ( n0x14_3 < n0x14_5 ) /*0xffc18697*/
return 11; /*0xffc18701*/
v23 = n0x14_3 - n0x14_5; /*0xffc18699*/
DstData_1 = DstData; /*0xffc1869b*/
src += v23; /*0xffc1869f*/
n0x14 -= v23; /*0xffc186a3*/
src_1 = src; /*0xffc186a5*/
*DstData += v23; /*0xffc186a9*/
*(_DWORD *)(StreamCtx + 88) = 0; /*0xffc186ab*/
LABEL_40:
if ( *(_DWORD *)(StreamCtx + 72) == 274 ) /*0xffc186b6*/
goto LABEL_52; /*0xffc186b6*/
}
*a6 = 2; /*0xffc186df*/
return 1; /*0xffc18724*/
}
int DxeIplDecodeSetup(int *a1, char *DstEnd)
{
unsigned int n4096; // esi
unsigned __int8 n0xE1; // al
int v5; // edx
n4096 = (unsigned __int8)DstEnd[1] | (((unsigned __int8)DstEnd[2] | (*(unsigned __int16 *)(DstEnd + 3) << 8)) << 8); /*0xffc18749*/
if ( n4096 < 0x1000 ) /*0xffc18752*/
n4096 = 4096; /*0xffc18754*/
n0xE1 = *DstEnd; /*0xffc18756*/
a1[3] = n4096; /*0xffc18758*/
if ( n0xE1 >= 0xE1u ) /*0xffc1875d*/
return 4; /*0xffc18761*/
*a1 = n0xE1 % 9; /*0xffc18772*/
v5 = n0xE1 / 9 % 5; /*0xffc18776*/
a1[2] = n0xE1 / 9 / 5; /*0xffc18779*/
a1[1] = v5; /*0xffc1877e*/
return 0; /*0xffc18762*/
}
int DxeIplDecodeCleanup(int a1, _BYTE *a2, int a3)
{
int v4; // edi
int v5; // eax
v4 = (768 << (*a2 + a2[4])) + 1846; /*0xffc18792*/
if ( *(_DWORD *)(a1 + 16) && v4 == *(_DWORD *)(a1 + 84) ) /*0xffc187a1*/
return 0; /*0xffc187a1*/
(*(void ( **)(int, _DWORD))(a3 + 4))(a3, *(_DWORD *)(a1 + 16)); /*0xffc187ac*/
*(_DWORD *)(a1 + 16) = 0; /*0xffc187af*/
v5 = (*(int ( **)(int, int))a3)(a3, 2 *v4); /*0xffc187b8*/
*(_DWORD *)(a1 + 16) = v5; /*0xffc187bd*/
*(_DWORD *)(a1 + 84) = v4; /*0xffc187c0*/
if ( v5 ) /*0xffc187c6*/
return 0; /*0xffc187cd*/
else
return 2; /*0xffc187ca*/
}
int DxeIplDecodeData(
int DecodeCtx,
unsigned int *SrcData,
unsigned __int8 *src,
unsigned int *DstData,
char *DstEnd,
int Status,
int a7,
_DWORD *a8,
int a9)
{
int result; // eax
_BYTE *v10; // ecx
int n6; // esi
unsigned int n5; // [esp+10h] [ebp-90h]
unsigned int n0x112; // [esp+18h] [ebp-88h]
int v16[4]; // [esp+20h] [ebp-80h] BYREF
_DWORD v17[4]; // [esp+30h] [ebp-70h] BYREF
int v18; // [esp+40h] [ebp-60h]
int DecodeCtx_1; // [esp+44h] [ebp-5Ch]
unsigned int v20; // [esp+54h] [ebp-4Ch]
unsigned int n0x112_1; // [esp+58h] [ebp-48h]
int v22; // [esp+5Ch] [ebp-44h]
int v23; // [esp+60h] [ebp-40h]
int v24; // [esp+78h] [ebp-28h]
int v25; // [esp+7Ch] [ebp-24h]
int v26; // [esp+80h] [ebp-20h]
int v27; // [esp+88h] [ebp-18h]
n0x112 = *SrcData; /*0xffc187fb*/
n5 = *DstData; /*0xffc187ff*/
*DstData = 0; /*0xffc18803*/
*SrcData = 0; /*0xffc18806*/
*a8 = 0; /*0xffc18808*/
if ( n5 < 5 ) /*0xffc1880d*/
return 6; /*0xffc18811*/
DecodeCtx_1 = 0; /*0xffc1881e*/
v18 = 0; /*0xffc18822*/
result = DxeIplDecodeSetup(v16, DstEnd); /*0xffc1882a*/
if ( !result ) /*0xffc18838*/
{
result = DxeIplDecodeCleanup((int)v17, v10, a9); /*0xffc18845*/
if ( !result ) /*0xffc1884d*/
{
v17[0] = v16[0]; /*0xffc1885b*/
v17[1] = v16[1]; /*0xffc1885c*/
v17[2] = v16[2]; /*0xffc1885d*/
v17[3] = v16[3]; /*0xffc1885e*/
v20 = 0; /*0xffc18874*/
v24 = 0; /*0xffc1887a*/
v27 = 0; /*0xffc1887f*/
v22 = 0; /*0xffc18887*/
v23 = 0; /*0xffc1888c*/
DecodeCtx_1 = DecodeCtx; /*0xffc18893*/
v25 = 1; /*0xffc188a5*/
v26 = 1; /*0xffc188ac*/
n0x112_1 = n0x112; /*0xffc188b7*/
*DstData = n5; /*0xffc188bb*/
n6 = DxeIplLzmaDecodeStream((int)v17, n0x112, src, DstData, 1, a8); /*0xffc188c7*/
*SrcData = v20; /*0xffc188d0*/
if ( !n6 && *a8 == 3 ) /*0xffc188d9*/
n6 = 6; /*0xffc188dd*/
(*(void ( **)(int, int))(a9 + 4))(a9, v18); /*0xffc188e3*/
return n6; /*0xffc188e8*/
}
}
return result; /*0xffc188ea*/
}
int DxeIplLzmaGetBit(char *a1, _BYTE *a2, unsigned int n7)
{
char i; // al
for ( i = *a1; *a1; i = *a1 ) /*0xffc188f5*/
{
if ( !*a2 ) /*0xffc18901*/
break; /*0xffc18905*/
if ( i != *a2 ) /*0xffc18909*/
break; /*0xffc18909*/
if ( n7 <= 1 ) /*0xffc1890e*/
break; /*0xffc1890e*/
++a1; /*0xffc18910*/
++a2; /*0xffc18911*/
--n7; /*0xffc18912*/
}
return *a1 - (char)*a2; /*0xffc18923*/
}
char DxeIplLzmaGetNumBits(unsigned int DxeIpl, int a2)
{
unsigned int DxeIpl_1; // ecx
if ( DxeIpl > DxeIpl_1 ) /*0xffc1892a*/
goto LABEL_4; /*0xffc1892a*/
if ( DxeIpl_1 < DxeIpl + a2 ) /*0xffc18934*/
return 1; /*0xffc18943*/
if ( DxeIpl >= DxeIpl_1 ) /*0xffc18938*/
{
LABEL_4:
if ( DxeIpl < DxeIpl_1 + 8 ) /*0xffc1893f*/
return 1; /*0xffc1893f*/
}
return 0; /*0xffc18943*/
}
unsigned int __thiscall DxeIplLzmaNormalize(_BYTE *this)
{
unsigned int n7; // eax
n7 = 0; /*0xffc18947*/
if ( this && *this ) /*0xffc1894d*/
{
while ( n7 < 7 ) /*0xffc18954*/
{
if ( !*(this + ++n7) ) /*0xffc18957*/
return n7; /*0xffc1895b*/
}
return 8; /*0xffc18960*/
}
return n7; /*0xffc1895d*/
}
int DxeIplLzmaDecodeSymbol(char *DxeIpl)
{
_BYTE *v1; // ecx
_BYTE *v2; // esi
unsigned int n7; // ebx
char v5; // al
char *v6; // edi
v2 = v1; /*0xffc18963*/
if ( !v1 ) /*0xffc18967*/
return -2147483646; /*0xffc18969*/
if ( !DxeIpl ) /*0xffc18977*/
return -2147483646; /*0xffc18979*/
n7 = DxeIplLzmaNormalize(DxeIpl); /*0xffc18988*/
if ( n7 > 7 ) /*0xffc1898d*/
n7 = 7; /*0xffc18991*/
if ( DxeIplLzmaGetNumBits((unsigned int)DxeIpl, n7 + 1) ) /*0xffc18999*/
return -2147483633; /*0xffc189a5*/
v5 = *DxeIpl; /*0xffc189ac*/
if ( *DxeIpl ) /*0xffc189ac*/
{
v6 = (char *)(DxeIpl - v2); /*0xffc189b2*/
do /*0xffc189c1*/
{
if ( !n7 ) /*0xffc189b6*/
break; /*0xffc189b6*/
*v2++ = v5; /*0xffc189b8*/
--n7; /*0xffc189bb*/
v5 = v2[(_DWORD)v6]; /*0xffc189bc*/
}
while ( v5 ); /*0xffc189c1*/
}
*v2 = 0; /*0xffc189c3*/
return 0; /*0xffc1896e*/
}
int __thiscall DxeIplGetModuleBase(void *this)
{
int ( **v1)(int); // eax
v1 = (int ( **)(int))DxeIplGetPeiBootMode(this); /*0xffc189e9*/
return v1[4](5); /*0xffc189f4*/
}
__int16 __thiscall DxeIplInitGlobalFlags(void *this)
{
*(_WORD *)(DxeIplGetModuleBase(this) + 1024064) = 1280; /*0xffc189ff*/
return 1280; /*0xffc18a09*/
}
Ajax Dong