#include "ReFlash.h"
//
// ReFlash - UEFI Module
// Total functions: 191
//
// Function: InternalCopyMem @ 0x2e0 (0x42 bytes)
char *__fastcall InternalCopyMem(char *DestinationBuffer, char *SourceBuffer, UINTN Length)
{
char *DestinationBuffer_1; // rax
UINTN Length_1; // rcx
char *dst; // rdi
char *src; // rsi
DestinationBuffer_1 = DestinationBuffer; /*0x2f0*/
if ( SourceBuffer < DestinationBuffer && &SourceBuffer[Length - 1] >= DestinationBuffer ) /*0x2f8*/
{
src = &SourceBuffer[Length - 1]; /*0x310*/
dst = &DestinationBuffer[Length - 1]; /*0x313*/
}
else
{
Length_1 = Length; /*0x2fa*/
Length &= 7u; /*0x2fd*/
Length_1 >>= 3; /*0x304*/
qmemcpy(DestinationBuffer, SourceBuffer, 8 * Length_1); /*0x308*/
src = &SourceBuffer[8 * Length_1]; /*0x308*/
dst = &DestinationBuffer[8 * Length_1]; /*0x308*/
}
qmemcpy(dst, src, Length); /*0x31c*/
return DestinationBuffer_1; /*0x31f*/
}
// Function: InternalSetMem @ 0x330 (0x11 bytes)
void *__fastcall InternalSetMem(void *buf, unsigned __int64 count, char value)
{
memset(buf, value, count); /*0x33a*/
return buf; /*0x33f*/
}
// Function: InternalCompareMem @ 0x350 (0x1d bytes)
unsigned __int64 __fastcall InternalCompareMem(char *DestinationBuffer, char *SourceBuffer, __int64 n40)
{
bool v6; // zf
do /*0x35b*/
{
if ( !n40 ) /*0x35b*/
break; /*0x35b*/
v6 = *DestinationBuffer++ == *SourceBuffer++; /*0x35b*/
--n40; /*0x35b*/
}
while ( v6 ); /*0x35b*/
return (unsigned __int8)*(DestinationBuffer - 1) - (unsigned __int64)(unsigned __int8)*(SourceBuffer - 1); /*0x36a*/
}
// Function: InternalIsZeroBuffer @ 0x3b0 (0x20 bytes)
char *__fastcall InternalIsZeroBuffer(char *Buffer, UINTN Length, UINT8 Value)
{
memset(Buffer, 0, 8 * (Length >> 3)); /*0x3c6*/
memset(&Buffer[8 * (Length >> 3)], 0, Length & 7); /*0x3cb*/
return Buffer; /*0x3ce*/
}
// Function: _ModuleEntryPoint @ 0x420 (0x2b bytes)
EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
ReFlashDriverEntryPoint((__int64)ImageHandle, (__int64)SystemTable); /*0x430*/
return ReFlashEntry((__int64)ImageHandle, SystemTable); /*0x445*/
}
// Function: ReFlashDriverEntryPoint @ 0x44c (0x4d7 bytes)
char *__fastcall ReFlashDriverEntryPoint(__int64 ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
__int64 DxeStatus; // rax
__int64 DxeStatus_1; // rbx
__int64 LocateStatus; // rax
__int64 PciHandle; // rax
EFI_SYSTEM_TABLE *SystemTable_1; // rdx
__int64 ImageHandle_1; // rcx
_WORD *PcdVal; // rax
_BYTE *PcdDest; // rax
__int16 callerseflags_w; // bx
bool IfEnabled; // bl
unsigned __int32 StartTick; // edi
__int64 HiiDbStatus; // rax
__int64 HiiPkgStatus; // rax
__int64 StrPkgStatus; // rax
__int64 SegBusTable; // rax
const void *SourceBuffer; // rbx
__int64 SegBusPtr; // rax
__int64 SegBusSize; // rax
UINTN Length; // rax
char *p_DestinationBuffer_2; // rax
EFI_SYSTEM_TABLE *SystemTable_2; // rdx
char *p_DestinationBuffer_5; // rbp
char *p_DestinationBuffer_1; // rdi
unsigned __int64 RegionCount; // rcx
int EntrySize; // ebx
unsigned int RegionStride; // edx
char *p_DestinationBuffer_3; // rsi
unsigned __int64 p_DestinationBuffer_4;... [9298 chars total]
// Function: ReFlashReadHiiString @ 0x924 (0x9b bytes)
__int64 __fastcall ReFlashReadHiiString(__int64 a1, __int64 n48, __int64 *p_n29, __int64 *p_DmiVar%02x%04x%02x%02x)
{
unsigned __int16 n48_1; // si
__int64 result; // rax
n48_1 = n48; /*0x942*/
if ( !*p_DmiVar%02x%04x%02x%02x ) /*0x938*/
*p_n29 = 0; /*0x94a*/
result = ReFlashInternalGetHiiString(a1, (unsigned __int16)n48, p_n29, *p_DmiVar%02x%04x%02x%02x); /*0x954*/
if ( result == 0x8000000000000005uLL ) /*0x95c*/
{
if ( *p_DmiVar%02x%04x%02x%02x ) /*0x96d*/
(*(void (**)(void))(BootServices + 72))(); /*0x97c*/
result = (*(__int64 (__fastcall **)(__int64, _QWORD, __int64 *))(BootServices + 64))( /*0x991*/
4,
*p_n29,
p_DmiVar%02x%04x%02x%02x);
if ( result >= 0 ) /*0x997*/
return ReFlashInternalGetHiiString(a1, n48_1, p_n29, *p_DmiVar%02x%04x%02x%02x); /*0x9a5*/
}
return result; /*0x9b9*/
}
// Function: ReFlashParseVarStore @ 0x9c0 (0xb2 bytes)
char __fastcall ReFlashParseVarStore(char a1, __int64 FuncIdx, __int64 n100, __int64 TotalBlocks)
{
__int64 RegionIdx; // rbx
__int64 VarStoreStatus; // rax
__int64 RegionBase; // rdx
__int64 EntryOffset; // rcx
char SetFlag; // al
__int64 v10; // [rsp+48h] [rbp+10h] BYREF
__int64 p_n7; // [rsp+50h] [rbp+18h] BYREF
LODWORD(RegionIdx) = 0; /*0x9c6*/
p_n7 = 7; /*0x9c8*/
if ( a1 ) /*0x9d3*/
VarStoreStatus = ReFlashReadHiiConfig(&p_n7, (__int64)&v10, n100, TotalBlocks); /*0x9df*/
else
VarStoreStatus = (*(__int64 (__fastcall **)(const wchar_t *, void *, _QWORD, __int64 *, __int64 *))(RuntimeServices + 72))( /*0xa0d*/
L"Setup",
&unk_C8F0,
0,
&p_n7,
&v10);
if ( VarStoreStatus >= 0 && BYTE6(v10) ) /*0xa19*/
{
RegionBase = RegionBase; /*0xa1b*/
if ( *(_DWORD *)(RegionBase + 36) != 5 ) /*0xa26*/
{
EntryOffset = 0; /*0xa28*/
while ( *(_DWORD *)(EntryOffset + RegionBase + 36) != 1 ) /*0xa34*/
{
if ( *(_DWORD *)(EntryOffset + RegionBase + 36) == 2 ) /*0xa3a*/
{
SetFlag = BYTE3(v10); /*0xa3c*/
LABEL_12:
*(_BYTE *)(EntryOffset + RegionBase + 40) = SetFlag; /*0xa46*/
RegionBase = RegionBase; /*0xa4a*/
}
RegionIdx = (unsigned int)(RegionIdx + 1); /*0xa51*/
EntryOffset = 72 * RegionIdx; /*0xa57*/
if ( *(_DWORD *)(72 * RegionIdx + RegionBase + 36) == 5 ) /*0xa60*/
goto LABEL_14; /*0xa60*/
}
SetFlag = BYTE4(v10); /*0xa42*/
goto LABEL_12; /*0xa42*/
}
LABEL_14:
::SetFlag = BYTE3(v10); /*0xa62*/
LOBYTE(VarStoreStatus) = BYTE3(v10); /*0xa62*/
}
return VarStoreStatus; /*0xa6c*/
}
// Function: ReFlashUpdateBootSettings @ 0xa74 (0x12f bytes)
__int64 __fastcall ReFlashUpdateBootSettings(__int64 a1, int *p_n0x1000000)
{
__int64 v2; // rbx
__int64 v4; // rcx
__int64 n23; // rdx
__int64 n17; // rdx
__int64 result; // rax
wchar_t ________________[112]; // [rsp+20h] [rbp-89h] BYREF
wchar_t *DmiVar%02x%04x%02x%02x; // [rsp+110h] [rbp+67h] BYREF
__int64 DmiVar%02x%04x%02x%02x_1; // [rsp+118h] [rbp+6Fh] BYREF
__int64 n29; // [rsp+120h] [rbp+77h] BYREF
v2 = qword_D158; /*0xa88*/
DmiVar%02x%04x%02x%02x = 0; /*0xa93*/
DmiVar%02x%04x%02x%02x_1 = 0; /*0xa9c*/
ReFlashReadHiiString(qword_D158, 20, &n29, (__int64 *)&DmiVar%02x%04x%02x%02x); /*0xaac*/
switch ( *((_BYTE *)p_n0x1000000 + 2) ) /*0xab8*/
{
case 1: /*0xab8*/
n23 = 23; /*0xaf0*/
goto LABEL_10; /*0xaf0*/
case 2: /*0xab8*/
n23 = 24; /*0xae9*/
goto LABEL_10; /*0xaee*/
case 3: /*0xab8*/
n23 = 25; /*0xae2*/
LABEL_10:
v4 = v2; /*0xaf5*/
goto LABEL_11; /*0xaf9*/
}
v4 = v2; /*0xacb*/
if ( *((_BYTE *)p_n0x1000000 + 2) == 4 ) /*0xad2*/
n23 = 26; /*0xadb*/
else
n23 = 27; /*0xad4*/
LABEL_11:
ReFlashReadHiiString(v4, n23, &n29, &DmiVar%02x%04x%02x%02x_1); /*0xb00*/
if ( DmiVar%02x%04x%02x%02x && DmiVar%02x%04x%02x%02x_1 ) /*0xb15*/
{
HiiConstructConfigAltString(________________, (const CHAR8 *)DmiVar%02x%04x%02x%02x); /*0xb1c*/
ReFlashSetProgress(v2, 0x12u, ________________); /*0xb2e*/
(*(void (__fastcall **)(wchar_t *))(BootServices + 72))(DmiVar%02x%04x%02x%02x); /*0xb3e*/
(*(void (__fastcall **)(__int64))(BootServices + 72))(DmiVar%02x%04x%02x%02x_1); /*0xb4c*/
DmiVar%02x%04x%02x%02x = 0; /*0xb4f*/
}
n17 = 17; /*0xb63*/
if ( *((_BYTE *)p_n0x1000000 + 1) ) /*0xb54*/
n17 = 16; /*0xb6a*/
result = ReFlashReadHiiString(v2, n17, &n29, (__int64 *)&DmiVar%02x%04x%02x%02x); /*0xb6f*/
if ( DmiVar%02x%04x%02x%02x ) /*0xb7b*/
{
ReFlashSetProgress(v2, 0x13u, DmiVar%02x%04x%02x%02x); /*0xb85*/
return (*(__int64 (__fastcall **)(wchar_t *))(BootServices + 72))(DmiVar%02x%04x%02x%02x); /*0xb95*/
}
return result; /*0xb98*/
}
// Function: ReFlashGetBootDevice @ 0xba4 (0x117 bytes)
__int64 ReFlashGetBootDevice()
{
__int64 ImageHandle; // rbx
__int64 v1; // r8
unsigned __int64 i; // rdx
__int64 (__fastcall **v4)(_QWORD, __int64, _QWORD, __int64 *); // [rsp+30h] [rbp-18h] BYREF
__int64 v5; // [rsp+38h] [rbp-10h] BYREF
__int64 v6; // [rsp+68h] [rbp+20h] BYREF
__int64 v7; // [rsp+70h] [rbp+28h]
__int64 v8; // [rsp+78h] [rbp+30h] BYREF
ImageHandle = ImageHandle; /*0xbae*/
if ( (*(__int64 (__fastcall **)(__int64, void *, __int64 *))(BootServices + 152))(ImageHandle, &unk_CAB0, &v8) >= 0 /*0xc2b*/
&& (*(__int64 (__fastcall **)(__int64, void *, __int64 *, __int64, _QWORD, int))(BootServices + 280))(
ImageHandle,
&unk_CB68,
&v6,
ImageHandle,
0,
2) >= 0
&& (*(__int64 (__fastcall **)(void *, _QWORD, __int64 (__fastcall ***)(_QWORD, __int64, _QWORD, __int64 *)))(BootServices + 320))(
&unk_CA20,
0,
&v4) >= 0 )
{
v7 = 0; /*0xc36*/
for ( i = v6 + 20; /*0xc3e*/
i < v6 + (unsigned __int64)*(unsigned int *)(v6 + 16) && *(_BYTE *)(i + 3) != 2;
i += *(_DWORD *)i & 0xFFFFFF )
{
; /*0xc54*/
}
ReFlashInstallProtocol(v8, i + 4, v1); /*0xc76*/
if ( (*v4)(v4, v6, 0, &v5) >= 0 && v7 ) /*0xc9c*/
*(_QWORD *)(v7 + 24) = v5; /*0xca2*/
}
qword_D158 = qword_C8E8; /*0xcad*/
return qword_C8E8; /*0xcb4*/
}
// Function: ReFlashEntry @ 0xcbc (0x2fe bytes)
__int64 __fastcall ReFlashEntry(__int64 ImageHandle, EFI_SYSTEM_TABLE *SystemTable, double a3)
{
int n18; // ebx
__int64 v4; // rdx
__int64 v5; // rcx
EFI_SYSTEM_TABLE *SystemTable_1; // rdx
__int64 v7; // rax
_WORD *FlashDescriptor; // rax
EFI_SYSTEM_TABLE *SystemTable_2; // rdx
int v10; // ecx
__int64 v11; // rax
__int64 ImageHandle_1; // rcx
EFI_SYSTEM_TABLE *SystemTable_3; // rdx
__int64 result; // rax
__int64 v15; // rcx
__int64 n48; // rdx
int n0x1000000; // [rsp+30h] [rbp-40h] BYREF
__int16 n257; // [rsp+34h] [rbp-3Ch]
bool v19; // [rsp+36h] [rbp-3Ah]
__int64 n29; // [rsp+38h] [rbp-38h] BYREF
wchar_t *________________; // [rsp+40h] [rbp-30h] BYREF
char v22; // [rsp+48h] [rbp-28h] BYREF
int v23; // [rsp+49h] [rbp-27h]
char v24; // [rsp+90h] [rbp+20h] BYREF
int n2; // [rsp+A0h] [rbp+30h] BYREF
int v26; // [rsp+A8h] [rbp+38h] BYREF
________________ = 0; /*0xcc7*/
n2 = 2; /*0xcd9*/
n0x1000000 = 0x1000000; /*0xce0*/
n257 = 257; /*0xce7*/
v19 = 0; /*0xced*/
v24 = 0; /*0xcf1*/
::ImageHandle = ImageHandle; /*0xcf5*/
if ( !::SystemTable ) /*0xcfc*/
{
::SystemTable = (__int64)SystemTable; /*0xcfe*/
BootServices = (__int64)SystemTable->BootServices; /*0xd09*/
RuntimeServices = (__int64)SystemTable->RuntimeServices; /*0xd14*/
}
n18 = *(_DWORD *)(HobLibGetHobList(ImageHandle, SystemTable) + 12); /*0xd2c*/
(*(void (__fastcall **)(__int64, __int64, __int64 *))(BootServices + 64))(6, 72, &qword_D150); /*0xd39*/
if ( n18 != 32 ) /*0xd3f*/
{
if ( n18 != 18 ) /*0xd44*/
{
ReFlashBootFlow(v5, v4, a3); /*0xd46*/
return 0; /*0xfb0*/
}
n29 = 29; /*0xd54*/
if ( (*(__int64 (__fastcall **)(const wchar_t *, void *, _QWORD, __int64 *, char *))(RuntimeServices + 72))( /*0xd83*/
L"AmiFlashUpd",
&unk_C900,
0,
&n29,
&v22) >= 0 )
{
HIBYTE(n0x1000000) = (v23 & 4) != 0; /*0xd90*/
LOBYTE(n257) = v23 & 1; /*0xd9d*/
HIBYTE(n257) = (v23 & 2) != 0; /*0xda0*/
}
}
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_C870, 0, &qword_F698) < 0 ) /*0xdc3*/
{
v7 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_C870, 0, &qword_F698); /*0xddc*/
DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v7); /*0xdf1*/
DebugAssert( /*0xe09*/
"e:\\hs\\AmiModulePkg\\Recovery\\ReFlash\\ReFlash.c",
0x136u,
"!EFI_ERROR (pBS->LocateProtocol(&gAmiFlashProtocolGuid, ((void *) 0), &Flash))");
}
FlashDescriptor = ReFlashFindFlashDescriptor(&ImageHandle__0, SystemTable_1); /*0xe15*/
::FlashDescriptor = (__int64)FlashDescriptor; /*0xe1a*/
if ( !FlashDescriptor ) /*0xe24*/
{
LOBYTE(v10) = 0; /*0xe5c*/
v11 = 0x8000000000000015uLL; /*0xe5e*/
goto LABEL_14; /*0xe5e*/
}
Guid2_0 = (GUID *)*((_QWORD *)FlashDescriptor + 3); /*0xe2a*/
dword_D140 = *(_DWORD *)((char *)FlashDescriptor + 37); /*0xe34*/
v10 = *(_DWORD *)((char *)FlashDescriptor + 33); /*0xe3a*/
v11 = *((unsigned __int8 *)FlashDescriptor + 32); /*0xe3d*/
qword_D160 = v11; /*0xe41*/
if ( v11 ) /*0xe4b*/
{
SystemTable_2 = (EFI_SYSTEM_TABLE *)0x8000000000000000LL; /*0xe4d*/
v11 |= 0x8000000000000000uLL; /*0xe57*/
LABEL_14:
qword_D160 = v11; /*0xe68*/
}
BYTE1(n0x1000000) = v11; /*0xe6f*/
BYTE2(n0x1000000) = v10; /*0xe72*/
if ( (_BYTE)v10 || (LOBYTE(n0x1000000) = 0, (_BYTE)v11) ) /*0xe7e*/
LOBYTE(n0x1000000) = 1; /*0xe80*/
v19 = v11 >= 0 && ReFlashCheckFlashState(&v26, SystemTable_2); /*0xe97*/
n29 = 7; /*0xec1*/
(*(void (__fastcall **)(const wchar_t *, void *, __int64, __int64, int *))(RuntimeServices + 88))( /*0xec8*/
L"Setup",
&unk_C8F0,
7,
7,
&n0x1000000);
n29 = 1; /*0xecf*/
(*(void (__fastcall **)(const wchar_t *, void *, __int64, __int64, char *))(RuntimeServices + 88))( /*0xef3*/
L"Setup2",
&unk_C8F0,
7,
1,
&v24);
LOBYTE(ImageHandle_1) = qword_D160 < 0; /*0xefe*/
result = ReFlashCheckAndDispatch(ImageHandle_1, SystemTable_3, a3); /*0xf01*/
if ( result && result != 0xA000000000000001uLL ) /*0xf1c*/
{
ReFlashGetBootDevice(); /*0xf22*/
(*(void (__fastcall **)(const wchar_t *, void *, __int64, __int64, int *))(RuntimeServices + 88))( /*0xf4d*/
L"BootFlow",
&unk_C8B0,
2,
4,
&n2);
if ( (_BYTE)n0x1000000 == 1 ) /*0xf54*/
ReFlashUpdateBootSettings(v15, &n0x1000000); /*0xf5a*/
if ( v26 ) /*0xf64*/
{
n48 = 48; /*0xf75*/
if ( v26 != 1 ) /*0xf7c*/
n48 = 49; /*0xf7e*/
ReFlashReadHiiString(qword_D158, n48, &n29, (__int64 *)&________________); /*0xf83*/
if ( ________________ ) /*0xf8f*/
{
ReFlashSetProgress(qword_D158, 0x2Fu, ________________); /*0xf9d*/
(*(void (__fastcall **)(wchar_t *))(BootServices + 72))(________________); /*0xfad*/
}
}
return 0; /*0xfad*/
}
return result; /*0xfb2*/
}
// Function: ReFlashShowErrorDialog @ 0xfbc (0x77 bytes)
__int64 __fastcall ReFlashShowErrorDialog(
wchar_t *Flash_update,
wchar_t *Flash_update_completed._Press_any_key_to_reset_the_system)
{
__int64 result; // rax
__int64 PopupResult; // [rsp+40h] [rbp+18h] BYREF
PopupResult = 0; /*0xfc6*/
if ( byte_D188 ) /*0xfd9*/
{
(*(void (__fastcall **)(__int64, void *))(qword_D198 + 16))(qword_D198, &unk_A640); /*0xfec*/
result = (**(__int64 (__fastcall ***)(_QWORD, _QWORD))(SystemTable + 48))(*(_QWORD *)(SystemTable + 48), 0); /*0xfff*/
}
if ( byte_C948 ) /*0x1009*/
{
result = qword_D1A8; /*0x100b*/
if ( qword_D1A8 ) /*0x1015*/
return (*(__int64 (__fastcall **)(wchar_t *, wchar_t *, _QWORD, __int64 *))(qword_D1A8 + 88))( /*0x1025*/
Flash_update,
Flash_update_completed._Press_any_key_to_reset_the_system,
0,
&PopupResult);
}
return result; /*0x102d*/
}
// Function: ReFlashShowHiiPopup @ 0x1034 (0x57 bytes)
__int64 __fastcall ReFlashShowHiiPopup(wchar_t *ERROR____, const wchar_t *Image_is_not_selected)
{
__int64 result; // rax
__int64 PopupResult; // [rsp+40h] [rbp+18h] BYREF
__int64 HiiHandle; // [rsp+48h] [rbp+20h] BYREF
PopupResult = 0; /*0x104a*/
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_C928, 0, &HiiHandle); /*0x105f*/
if ( !result ) /*0x1068*/
return (*(__int64 (__fastcall **)(wchar_t *, const wchar_t *, _QWORD, __int64 *))(HiiHandle + 88))( /*0x107d*/
ERROR____,
Image_is_not_selected,
0,
&PopupResult);
return result; /*0x1085*/
}
// Function: ReFlashInitCallback @ 0x108c (0x18b bytes)
__int64 __fastcall ReFlashInitCallback(char a1, char a2)
{
__int64 result; // rax
__int64 FuncIdx; // rdx
__int64 n100; // r8
__int64 TotalBlocks; // r9
int FuncIndex; // ebx
void (__fastcall *i)(); // rax
int RegionEndPtr; // r10d
__int64 v10; // r8
__int64 RegionBase; // rax
__int64 v12; // rax
if ( byte_D1A4 ) /*0x109b*/
return qword_D190; /*0x120a*/
byte_D1A4 = 1; /*0x10a9*/
if ( !Guid2_0 ) /*0x10b0*/
return 0x8000000000000015uLL; /*0x10bc*/
if ( !a2 ) /*0x10c3*/
qword_D190 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_C928, 0, &qword_D1A8); /*0x10e2*/
result = ReFlashEnumerateRegions(); /*0x10e9*/
qword_D190 = result; /*0x10ee*/
if ( result >= 0 ) /*0x10f8*/
{
ReFlashParseVarStore(a1, FuncIdx, n100, TotalBlocks); /*0x1100*/
qword_D190 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_C750, 0, &qword_D198); /*0x1122*/
if ( qword_D190 >= 0 ) /*0x112c*/
{
(*(void (__fastcall **)(__int64, void *))(qword_D198 + 16))(qword_D198, &unk_A640); /*0x113f*/
byte_D188 = 1; /*0x1142*/
}
if ( !a1 ) /*0x114b*/
{
if ( qword_D160 < 0 ) /*0x1155*/
{
(*(void (__fastcall **)(__int64))(BootServices + 248))(5000000); /*0x1163*/
return 0x8000000000000015uLL; /*0x1169*/
}
byte_C948 = 0; /*0x116e*/
}
FuncIndex = 0; /*0x1175*/
for ( i = (void (__fastcall *)())ReFlashCheckSmbiosPreserve; i; i = (void (__fastcall *)())funcs_1180[FuncIndex] ) /*0x1177*/
{
i(); /*0x1180*/
++FuncIndex; /*0x1182*/
}
RegionEndPtr = 0; /*0x119b*/
v10 = 0; /*0x119e*/
if ( *(_DWORD *)(RegionBase + 36) == 1 ) /*0x11a6*/
{
RegionBase = RegionBase; /*0x11a8*/
do /*0x11cf*/
{
if ( *(_BYTE *)(RegionBase + 40) ) /*0x11ab*/
RegionEndPtr += *(_QWORD *)(RegionBase + 24) / (unsigned __int64)*(unsigned int *)(RegionBase + 32); /*0x11bd*/
v10 = (unsigned int)(v10 + 1); /*0x11c0*/
RegionBase = RegionBase + 72 * v10; /*0x11c7*/
}
while ( *(_DWORD *)(RegionBase + 36) == 1 ); /*0x11cf*/
}
while ( 1 ) /*0x11ef*/
{
v12 = RegionBase + 72 * v10; /*0x11ef*/
if ( *(_DWORD *)(v12 + 36) == 5 ) /*0x11f7*/
break; /*0x11f7*/
if ( *(_BYTE *)(v12 + 40) ) /*0x11d3*/
RegionEndPtr += *(_QWORD *)(v12 + 24) / (unsigned __int64)*(unsigned int *)(v12 + 32); /*0x11e5*/
v10 = (unsigned int)(v10 + 1); /*0x11e8*/
}
::RegionEndPtr = RegionEndPtr; /*0x1200*/
(*(void (**)(void))(qword_F698 + 32))(); /*0x1207*/
return qword_D190; /*0x1207*/
}
return result; /*0x1211*/
}
// Function: ReFlashBootCompleteReset @ 0x1218 (0x66 bytes)
unsigned __int64 ReFlashBootCompleteReset()
{
int FuncIdx; // ebx
void (__fastcall *i)(); // rax
(*(void (**)(void))(qword_F698 + 40))(); /*0x1225*/
FuncIdx = 0; /*0x1228*/
for ( i = (void (__fastcall *)())ReFlashSaveSmbiosIfNeeded; i; i = (void (__fastcall *)())funcs_1233[FuncIdx] ) /*0x122a*/
{
i(); /*0x1233*/
++FuncIdx; /*0x1235*/
}
ReFlashShowErrorDialog( /*0x1255*/
(wchar_t *)L"Flash update",
(wchar_t *)L"Flash update completed. Press any key to reset the system");
(*(void (__fastcall **)(_QWORD, _QWORD, _QWORD, _QWORD))(RuntimeServices + 104))(0, 0, 0, 0); /*0x126b*/
return 0x8000000000000007uLL; /*0x1278*/
}
// Function: ReFlashIterateRegions @ 0x1280 (0x121 bytes)
__int64 __fastcall ReFlashIterateRegions(__int64 CtxPtr, __int64 a2)
{
__int64 RegionBase; // r8
__int64 RegionIdx; // rsi
__int64 BlockOffset; // rdi
__int64 BlockIdx; // rbp
unsigned __int64 BlockCount; // r15
__int64 result; // rax
unsigned int ProgressPct; // r14d
__int64 FlashOp; // rcx
if ( !RegionEndPtr_0 ) /*0x12a2*/
(*(void (__fastcall **)(__int64))a2)(a2); /*0x12a7*/
RegionBase = ::RegionBase; /*0x12a9*/
RegionIdx = 0; /*0x12b0*/
if ( *(_DWORD *)(::RegionBase + 36) == 5 ) /*0x12b7*/
{
LABEL_12:
if ( byte_DA00 ) /*0x1356*/
{
FlashOp = 2; /*0x1358*/
}
else
{
if ( !SetFlag ) /*0x1366*/
{
LABEL_17:
if ( RegionEndPtr_0 == RegionEndPtr ) /*0x137e*/
(*(void (__fastcall **)(__int64))(a2 + 16))(a2); /*0x1383*/
return 0; /*0x1386*/
}
FlashOp = 1; /*0x1368*/
}
ReFlashSetBootFlag(FlashOp); /*0x136d*/
goto LABEL_17; /*0x136d*/
}
BlockOffset = 0; /*0x12bd*/
while ( 1 ) /*0x12bf*/
{
if ( *(_BYTE *)(BlockOffset + RegionBase + 40) ) /*0x12bf*/
{
BlockIdx = 0; /*0x12d3*/
BlockCount = *(_QWORD *)(BlockOffset + RegionBase + 24) /*0x12d8*/
/ (unsigned __int64)*(unsigned int *)(BlockOffset + RegionBase + 32);
if ( BlockCount ) /*0x12de*/
break; /*0x12de*/
}
LABEL_11:
++RegionIdx; /*0x1338*/
BlockOffset = 72 * RegionIdx; /*0x133f*/
if ( *(_DWORD *)(72 * RegionIdx + RegionBase + 36) == 5 ) /*0x1349*/
goto LABEL_12; /*0x1349*/
}
while ( 1 ) /*0x12e7*/
{
result = (*(__int64 (__fastcall **)(__int64, __int64))(BlockOffset + RegionBase + 56))( /*0x12e7*/
BlockOffset + RegionBase,
BlockIdx);
if ( result < 0 ) /*0x12ef*/
return result; /*0x1397*/
++RegionEndPtr_0; /*0x12ff*/
ProgressPct = 100 * RegionEndPtr_0 / (unsigned int)RegionEndPtr; /*0x1314*/
if ( ProgressPct > ::ProgressPct ) /*0x1317*/
{
(*(void (__fastcall **)(__int64, _QWORD))(a2 + 8))(a2, ProgressPct); /*0x131f*/
::ProgressPct = ProgressPct; /*0x1322*/
}
RegionBase = ::RegionBase; /*0x1329*/
if ( ++BlockIdx >= BlockCount ) /*0x1336*/
goto LABEL_11; /*0x1336*/
}
}
// Function: ReFlashCallbackDispatcher @ 0x13a4 (0x1bb bytes)
unsigned __int64 __fastcall ReFlashCallbackDispatcher(
__int64 CtxPtr,
__int64 a2,
__int64 n100,
__int64 TotalBlocks,
int a5,
_QWORD *a6)
{
__int64 InitStatus; // rax
_WORD *i; // r8
__int64 v9; // r9
const char *FilePath; // rax
__int64 FlashResult; // rax
const wchar_t *Image_is_not_selected; // rdx
__int64 VarStoreId; // [rsp+38h] [rbp+10h] BYREF
if ( a6 ) /*0x13b0*/
*a6 = 0; /*0x13b2*/
if ( a2 ) /*0x13b9*/
return 0x8000000000000003uLL; /*0x13c9*/
switch ( (_WORD)n100 ) /*0x13cf*/
{
case 'e': /*0x13cf*/
InitStatus = ReFlashInitCallback(1, 0); /*0x13d5*/
if ( qword_D160 >= 0 && InitStatus >= 0 ) /*0x13e7*/
return 0; /*0x13e7*/
ReFlashShowErrorDialog( /*0x13f7*/
(wchar_t *)L"ERROR!!!!",
(wchar_t *)L"Flash update failed to initialize. Press any key to reset system");
goto LABEL_9; /*0x13f7*/
case 'f': /*0x13cf*/
VarStoreId = 7; /*0x1423*/
if ( ReFlashReadHiiConfig(&VarStoreId, (__int64)&a6, n100, TotalBlocks) >= 0 ) /*0x1439*/
{
LOBYTE(a6) = 0; /*0x1445*/
ReFlashWriteHiiConfig(VarStoreId, (__int64)&a6, i, v9); /*0x144a*/
}
return 0; /*0x144f*/
case 'g': /*0x13cf*/
if ( !Assert_0(CtxPtr, 0, n100, TotalBlocks) ) /*0x1458*/
{
FilePath = (const char *)ReFlashGetImageFilePath(); /*0x1462*/
ReFlashLogImageInfo(FilePath); /*0x146a*/
}
return 0; /*0x146f*/
case 'i': /*0x13cf*/
FlashResult = ReFlashLoadFirmwareImage(0); /*0x147e*/
if ( FlashResult ) /*0x1486*/
{
switch ( FlashResult ) /*0x1495*/
{
case 0x8000000000000002LL: /*0x1495*/
Image_is_not_selected = L"Image is not selected"; /*0x14f2*/
break;
case 0x8000000000000003LL: /*0x1495*/
Image_is_not_selected = L"Platform doesn't support firmware update"; /*0x14da*/
break;
case 0x800000000000000ELL: /*0x1495*/
Image_is_not_selected = L"Image is not compatible with platform"; /*0x14d1*/
break;
case 0x800000000000001ALL: /*0x1495*/
Image_is_not_selected = L"Image validation failed"; /*0x14c8*/
break;
default:
return 0; /*0x14c2*/
}
ReFlashShowHiiPopup((wchar_t *)L"ERROR!!!!", Image_is_not_selected); /*0x14e8*/
return 0; /*0x14ed*/
}
ReFlashShowHiiPopup((wchar_t *)L"Flash update", L"Flash update completed. Press any key to reset the system"); /*0x1509*/
LABEL_9:
(*(void (__fastcall **)(_QWORD, _QWORD, _QWORD, _QWORD))(RuntimeServices + 104))(0, 0, 0, 0); /*0x13fc*/
return 0; /*0x1416*/
}
if ( (_WORD)n100 != 100 ) /*0x1518*/
return 0; /*0x1518*/
if ( ReFlashIterateRegions(CtxPtr, (__int64)&off_C9D0) < 0 ) /*0x152d*/
{
ReFlashShowErrorDialog((wchar_t *)L"ERROR!!!!", (wchar_t *)L"Flash update failed. Press any key to reset system"); /*0x153d*/
(*(void (__fastcall **)(_QWORD, _QWORD, _QWORD, _QWORD))(RuntimeServices + 104))(0, 0, 0, 0); /*0x1553*/
}
return ReFlashBootCompleteReset(); /*0x13c5*/
}
// Function: ReFlashRegionRead @ 0x1560 (0x104 bytes)
__int64 __fastcall ReFlashRegionRead(__int64 a1, __int64 a2)
{
__int64 result; // rax
__int64 ByteOffset; // rcx
__int64 FlashSrcPtr; // rbx
__int64 FlashDstPtr; // rsi
__int64 EraseWriteStatus; // rbx
__int64 TimerEvent; // rbx
__int64 ReadStatus; // rdi
__int64 DmaHandle; // [rsp+30h] [rbp+8h] BYREF
result = (*(__int64 (__fastcall **)(__int64, _QWORD, __int64 *))(BootServices + 64))( /*0x1589*/
4,
*(unsigned int *)(a1 + 32),
&DmaHandle);
if ( result >= 0 ) /*0x158f*/
{
ByteOffset = a2 * *(unsigned int *)(a1 + 32); /*0x159c*/
FlashSrcPtr = ByteOffset + *(_QWORD *)a1; /*0x15a3*/
FlashDstPtr = ByteOffset + *(_QWORD *)(a1 + 8); /*0x15a6*/
if ( *(_DWORD *)(a1 + 36) == 1 && byte_C960 ) /*0x15b6*/
{
byte_C960 = 0; /*0x15cb*/
(*(void (__fastcall **)(__int64, __int64, void *))(qword_F698 + 16))(4279304232LL, 4, &unk_D1B0); /*0x15d7*/
}
EraseWriteStatus = (*(__int64 (__fastcall **)(__int64, _QWORD, __int64))qword_F698)( /*0x15ee*/
FlashSrcPtr,
*(unsigned int *)(a1 + 32),
DmaHandle);
if ( EraseWriteStatus >= 0 ) /*0x15f4*/
{
TimerEvent = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(31); /*0x1626*/
ReadStatus = (*(__int64 (__fastcall **)(__int64, _QWORD, __int64))(qword_F698 + 24))( /*0x163c*/
FlashDstPtr,
*(unsigned int *)(a1 + 32),
DmaHandle);
(*(void (__fastcall **)(__int64))(BootServices + 32))(TimerEvent); /*0x163f*/
(*(void (__fastcall **)(__int64))(BootServices + 72))(DmaHandle); /*0x164e*/
return ReadStatus; /*0x1651*/
}
else
{
(*(void (__fastcall **)(__int64))(BootServices + 72))(DmaHandle); /*0x1602*/
return EraseWriteStatus; /*0x1605*/
}
}
return result; /*0x165e*/
}
// Function: ReFlashRegionWrite @ 0x1664 (0x83 bytes)
__int64 __fastcall ReFlashRegionWrite(__int64 a1, __int64 a2)
{
__int64 ByteOffset; // r9
__int64 SrcPtr; // rbx
char *DstPtr; // rsi
__int64 TimerEvent; // rdi
__int64 WriteStatus; // rbx
ByteOffset = a2 * *(unsigned int *)(a1 + 32); /*0x1692*/
SrcPtr = ByteOffset + *(_QWORD *)a1; /*0x1699*/
DstPtr = (char *)Guid2_0 + ByteOffset + *(unsigned int *)(a1 + 16); /*0x169c*/
TimerEvent = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(31); /*0x16b7*/
WriteStatus = (*(__int64 (__fastcall **)(__int64, _QWORD, char *))(qword_F698 + 24))( /*0x16c8*/
SrcPtr,
*(unsigned int *)(a1 + 32),
DstPtr);
(*(void (__fastcall **)(__int64))(BootServices + 32))(TimerEvent); /*0x16cb*/
return WriteStatus; /*0x16e0*/
}
// Function: ReFlashRegionEraseWrite @ 0x16e8 (0xa4 bytes)
__int64 __fastcall ReFlashRegionEraseWrite(__int64 a1, __int64 a2)
{
__int64 ByteOffset; // r9
__int64 FlashAddr; // r14
char *VerifyAddr; // rsi
__int64 TimerEvent; // rbp
__int64 OpStatus; // rbx
ByteOffset = a2 * *(unsigned int *)(a1 + 32); /*0x171a*/
FlashAddr = ByteOffset + *(_QWORD *)a1; /*0x1721*/
VerifyAddr = (char *)Guid2_0 + ByteOffset + *(unsigned int *)(a1 + 16); /*0x1724*/
TimerEvent = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(31); /*0x173b*/
OpStatus = (*(__int64 (__fastcall **)(__int64, _QWORD))(qword_F698 + 8))(FlashAddr, *(unsigned int *)(a1 + 32)); /*0x1742*/
if ( OpStatus >= 0 ) /*0x1748*/
OpStatus = (*(__int64 (__fastcall **)(__int64, _QWORD, char *))(qword_F698 + 16))( /*0x175e*/
FlashAddr,
*(unsigned int *)(a1 + 32),
VerifyAddr);
(*(void (__fastcall **)(__int64))(BootServices + 32))(TimerEvent); /*0x176b*/
return OpStatus; /*0x1785*/
}
// Function: ReFlashInitFlashRegion @ 0x178c (0x18e bytes)
__int64 __fastcall ReFlashInitFlashRegion(GUID *Guid1, unsigned int EnabledCount, int n3)
{
__int64 RegionSlot; // rbx
__int64 RegionBase; // rax
__int64 SlotIdx; // rdx
__int64 (__fastcall *ReFlashRegionEraseWrite_1)(__int64, __int64); // rcx
__int16 FlashDevId; // cx
__int64 TotalSize; // r8
__int64 ImageBase; // rcx
__int64 AdjustedBase; // rcx
if ( n3 == 5 ) /*0x179b*/
{
RegionSlot = 9LL * EnabledCount; /*0x179d*/
InternalSetMem16((int *)(RegionBase + 72LL * EnabledCount), 0x48u, 0); /*0x17b3*/
RegionBase = RegionBase; /*0x17b8*/
*(_DWORD *)(RegionBase + 8 * RegionSlot + 36) = 5; /*0x17bf*/
}
else
{
SlotIdx = 9LL * EnabledCount; /*0x17d0*/
*(_QWORD *)(RegionBase + 8 * SlotIdx) = *(_QWORD *)&Guid1[1].Data1; /*0x17e8*/
*(_DWORD *)(RegionBase + 8 * SlotIdx + 16) = *(_DWORD *)Guid1[1].Data4; /*0x17f7*/
*(_QWORD *)(RegionBase + 8 * SlotIdx + 24) = *(unsigned int *)&Guid1[1].Data4[4]; /*0x1806*/
*(_DWORD *)(RegionBase + 8 * SlotIdx + 32) = 4096; /*0x1812*/
*(_DWORD *)(RegionBase + 8 * SlotIdx + 36) = n3; /*0x1821*/
*(_BYTE *)(RegionBase + 8 * SlotIdx + 40) = 1; /*0x182d*/
*(_BYTE *)(RegionBase + 8 * SlotIdx + 41) = 0; /*0x1839*/
if ( *(_QWORD *)&Guid1[1].Data1 + *(unsigned int *)&Guid1[1].Data4[4] == 0x100000000LL /*0x1856*/
|| (ReFlashRegionEraseWrite_1 = ReFlashRegionWrite, n3 == 3) )
{
ReFlashRegionEraseWrite_1 = ReFlashRegionEraseWrite; /*0x1858*/
}
*(_QWORD *)(RegionBase + 8 * SlotIdx + 56) = ReFlashRegionEraseWrite_1; /*0x186a*/
FlashDevId = 22; /*0x186f*/
if ( n3 == 2 ) /*0x1877*/
FlashDevId = 43; /*0x1877*/
if ( !n3 ) /*0x1883*/
FlashDevId = 42; /*0x1883*/
if ( n3 == 1 ) /*0x1890*/
FlashDevId = 41; /*0x1890*/
*(_WORD *)(RegionBase + 8 * SlotIdx + 66) = FlashDevId; /*0x189b*/
if ( n3 == 1 ) /*0x18a0*/
{
TotalSize = *(unsigned int *)&Guid1[1].Data4[4]; /*0x18a2*/
ImageBase = *(_QWORD *)&Guid1[1].Data1; /*0x18a6*/
if ( TotalSize + ImageBase == 0x100000000LL ) /*0x18b1*/
AdjustedBase = ImageBase - TotalSize; /*0x18b3*/
else
AdjustedBase = 4279369728LL; /*0x18b8*/
*(_QWORD *)(RegionBase + 8 * SlotIdx + 8) = AdjustedBase; /*0x18c4*/
*(_WORD *)(RegionBase + 8 * SlotIdx + 64) = 40; /*0x18d5*/
RegionBase = RegionBase; /*0x18e1*/
*(_QWORD *)(RegionBase + 8 * SlotIdx + 48) = ReFlashRegionRead; /*0x18e8*/
}
else
{
*(_QWORD *)(RegionBase + 8 * SlotIdx + 8) = 0; /*0x18f6*/
*(_WORD *)(RegionBase + 8 * SlotIdx + 64) = 0; /*0x1902*/
RegionBase = RegionBase; /*0x1908*/
*(_QWORD *)(RegionBase + 8 * SlotIdx + 48) = 0; /*0x190f*/
}
}
return RegionBase; /*0x1914*/
}
// Function: ReFlashEnumerateRegions @ 0x191c (0x1b7 bytes)
__int64 ReFlashEnumerateRegions()
{
unsigned int EnabledCount; // r14d
unsigned int RegionIdx; // r15d
char FirstRegion; // r12
GUID *Guid1; // rbx
__int64 result; // rax
__int64 RegionSize; // rbp
GUID *Guid1_1; // rcx
__int64 TotalRegionCount; // rsi
__int64 TotalRegionCount_1; // rax
unsigned int ActiveIdx; // edi
GUID *Guid1_2; // rcx
int n2; // r8d
BOOLEAN IsBootRegion; // al
BOOLEAN IsFlashRegion; // al
EnabledCount = 0; /*0x1939*/
RegionIdx = 0; /*0x193c*/
FirstRegion = 1; /*0x193f*/
byte_DA00 = ReFlashCheckBootRegion(); /*0x1947*/
ReFlashCopyGuidData(); /*0x194d*/
Guid1 = Guid1; /*0x1952*/
result = 0; /*0x1959*/
if ( !Guid1 ) /*0x195e*/
{
if ( Guid2_0 ) /*0x196a*/
{
result = ReFlashReadRomLayout(Guid2_0, &Guid1); /*0x1973*/
Guid1 = Guid1; /*0x1978*/
}
else
{
result = 0x8000000000000002uLL; /*0x1981*/
}
}
RegionSize = (unsigned int)::RegionSize; /*0x198b*/
if ( result >= 0 ) /*0x1994*/
{
Guid1_1 = Guid1; /*0x19a4*/
TotalRegionCount = (unsigned int)n40 / ::RegionSize; /*0x19a7*/
if ( (unsigned int)n40 / ::RegionSize ) /*0x19a2*/
{
TotalRegionCount_1 = (unsigned int)TotalRegionCount; /*0x19ad*/
do /*0x19c8*/
{
if ( !Guid1_1[2].Data1 || (*(_DWORD *)&Guid1_1[2].Data2 & 0x200) != 0 ) /*0x19bc*/
++EnabledCount; /*0x19be*/
Guid1_1 = (GUID *)((char *)Guid1_1 + (unsigned int)::RegionSize); /*0x19c1*/
--TotalRegionCount_1; /*0x19c4*/
}
while ( TotalRegionCount_1 ); /*0x19c8*/
}
result = (*(__int64 (__fastcall **)(__int64, __int64, __int64 *))(BootServices + 64))( /*0x19e9*/
4,
72LL * (EnabledCount + 1),
&RegionBase);
if ( result >= 0 ) /*0x19ef*/
{
ActiveIdx = EnabledCount - 2; /*0x19fb*/
ReFlashInitFlashRegion(0, EnabledCount, 5); /*0x1a04*/
if ( (_DWORD)TotalRegionCount ) /*0x1a0b*/
{
while ( 1 ) /*0x1a11*/
{
if ( Guid1[2].Data1 && (*(_DWORD *)&Guid1[2].Data2 & 0x200) == 0 ) /*0x1a1e*/
goto LABEL_26; /*0x1a1e*/
Guid1_2 = Guid1; /*0x1a2b*/
if ( (*(_DWORD *)&Guid1[2].Data2 & 0x83E) == 0 ) /*0x1a2e*/
break; /*0x1a2e*/
if ( (*(_DWORD *)&Guid1[2].Data2 & 0x400) != 0 ) /*0x1a37*/
{
ReFlashInitFlashRegion(Guid1, RegionIdx++, 1); /*0x1a42*/
}
else
{
n2 = 0; /*0x1a4c*/
if ( !FirstRegion ) /*0x1a52*/
goto LABEL_25; /*0x1a52*/
ReFlashInitFlashRegion(Guid1, EnabledCount - 1, 0); /*0x1a58*/
FirstRegion = 0; /*0x1a5d*/
}
LABEL_26:
Guid1 = (GUID *)((char *)Guid1 + RegionSize); /*0x1aa5*/
if ( !--TotalRegionCount ) /*0x1aac*/
return 0; /*0x1aac*/
}
IsBootRegion = CompareGuid(Guid1, &Guid2); /*0x1a69*/
Guid1_2 = Guid1; /*0x1a6e*/
if ( IsBootRegion ) /*0x1a73*/
{
n2 = 2; /*0x1a75*/
}
else
{
IsFlashRegion = CompareGuid(Guid1, &Guid2__1); /*0x1a84*/
Guid1_2 = Guid1; /*0x1a89*/
n2 = 3; /*0x1a8c*/
if ( !IsFlashRegion ) /*0x1a94*/
n2 = 4; /*0x1a96*/
}
LABEL_25:
ReFlashInitFlashRegion(Guid1_2, ActiveIdx--, n2); /*0x1a9c*/
goto LABEL_26; /*0x1aa3*/
}
return 0; /*0x1ab2*/
}
}
return result; /*0x1ac8*/
}
// Function: ReFlashGetImageFilePath @ 0x1ad4 (0x54 bytes)
__int64 ReFlashGetImageFilePath()
{
__int64 CurrentNode; // rbx
__int64 NodeIter; // rcx
CurrentNode = i_0; /*0x1ada*/
if ( i_0 ) /*0x1ae4*/
{
for ( NodeIter = i_0; !Assert_29(NodeIter); NodeIter = CurrentNode ) /*0x1ae6*/
{
if ( Assert_38(CurrentNode) == 4 && Assert_35(CurrentNode) == 4 ) /*0x1b08*/
return CurrentNode + 4; /*0x1b1e*/
CurrentNode = Assert_31(CurrentNode); /*0x1b12*/
}
}
return 0; /*0x1b22*/
}
// Function: ReFlashLogImageInfo @ 0x1b28 (0x71 bytes)
__int64 __fastcall ReFlashLogImageInfo(const char *FilePath)
{
const char *FilePath_1; // rcx
CHAR16 StartOfBuffer[260]; // [rsp+20h] [rbp-208h] BYREF
if ( byte_C961 ) /*0x1b3b*/
{
Assert_5(FilePath, 3u, (wchar_t *)L"Firmware Update"); /*0x1b49*/
byte_C961 = 0; /*0x1b4e*/
}
if ( FilePath )
UnicodeSPrint(StartOfBuffer, 0x100u, "Image file: %s", FilePath);
else
UnicodeSPrint(StartOfBuffer, 0x100u, "Image file: Not defined");
return Assert_5(FilePath_1, 0x36u, StartOfBuffer); /*0x1b90*/
}
// Function: ReFlashGetFlashInfo @ 0x1b9c (0xa3 bytes)
__int64 ReFlashGetFlashInfo()
{
__int64 result; // rax
__int64 FlashHdrPtr; // rdx
__int64 ProtocolHandle; // [rsp+30h] [rbp+8h] BYREF
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C7F0, 0, &ProtocolHandle); /*0x1bb5*/
if ( !result ) /*0x1bbe*/
{
FlashHdrPtr = FwInfoPtr; /*0x1bc5*/
*(_QWORD *)FwInfoPtr = *(_QWORD *)(*(_QWORD *)(ProtocolHandle + 24) + 24LL); /*0x1bd4*/
*(_DWORD *)(FlashHdrPtr + 8) = *(_DWORD *)(*(_QWORD *)(ProtocolHandle + 24) + 32LL); /*0x1be3*/
*(_WORD *)(FlashHdrPtr + 12) = *(_WORD *)(*(_QWORD *)(*(_QWORD *)(ProtocolHandle + 24) + 8LL) + 4LL); /*0x1bf7*/
*(_WORD *)(FlashHdrPtr + 14) = *(_WORD *)(*(_QWORD *)(*(_QWORD *)(ProtocolHandle + 24) + 8LL) + 8LL); /*0x1c0c*/
*(_WORD *)(FlashHdrPtr + 16) = *(_WORD *)(*(_QWORD *)(*(_QWORD *)(ProtocolHandle + 24) + 8LL) + 32LL); /*0x1c21*/
result = *(_QWORD *)(*(_QWORD *)(ProtocolHandle + 24) + 8LL); /*0x1c2e*/
*(_WORD *)(FlashHdrPtr + 18) = *(_WORD *)(result + 12); /*0x1c36*/
}
return result; /*0x1c3a*/
}
// Function: ReFlashLoadFirmwareImage @ 0x1c40 (0x12d bytes)
__int64 __fastcall ReFlashLoadFirmwareImage(void *FwImage)
{
void *FwImage_1; // rbx
UINTN n0x1000000; // rdi
__int64 FwInfoPtr; // rcx
__int64 UpdateStatus; // rbx
int p_ImageType; // [rsp+30h] [rbp+8h] BYREF
UINTN p_n0x1000000; // [rsp+38h] [rbp+10h] BYREF
FwImage_1 = FwImage; /*0x1c4a*/
if ( FwImage ) /*0x1c50*/
{
n0x1000000 = 0x1000000; /*0x1c52*/
}
else
{
if ( !i_0 ) /*0x1c63*/
return 0x8000000000000002uLL; /*0x1c6f*/
FwImage_1 = ReFlashParseFirmwareImage(i_0, &p_n0x1000000, &p_ImageType); /*0x1c83*/
if ( !FwImage_1 || (n0x1000000 = p_n0x1000000, p_n0x1000000 != 0x1000000) ) /*0x1c9b*/
{
DebugPrint(0xFFFFFFFFFFFFFFFFuLL, "can't find file or file is of wrong size\n"); /*0x1d53*/
return 0x800000000000000EuLL; /*0x1d58*/
}
}
ReFlashGetFlashInfo(); /*0x1ca1*/
FwInfoPtr = ::FwInfoPtr; /*0x1cad*/
*(_QWORD *)(qword_D150 + 40) = FwImage_1; /*0x1cb4*/
*(_QWORD *)(qword_D150 + 48) = n0x1000000; /*0x1cbf*/
*(_QWORD *)(qword_D150 + 56) = FwInfoPtr; /*0x1cca*/
if ( *(_QWORD *)FwInfoPtr ) /*0x1cce*/
{
SourceBuffer = AllocatePool(*(unsigned int *)(FwInfoPtr + 8)); /*0x1ce6*/
CopyMem(SourceBuffer, *(const void **)::FwInfoPtr, *(unsigned int *)(::FwInfoPtr + 8)); /*0x1cf4*/
ZeroMem(*(_QWORD *)::FwInfoPtr, *(unsigned int *)(::FwInfoPtr + 8)); /*0x1d06*/
}
UpdateStatus = ReFlashSubProcessor(4u); /*0x1d1c*/
if ( *(_QWORD *)::FwInfoPtr ) /*0x1d1f*/
{
CopyMem(*(void **)::FwInfoPtr, SourceBuffer, *(unsigned int *)(::FwInfoPtr + 8)); /*0x1d32*/
AllocatePoolWithAssert(); /*0x1d3e*/
}
return UpdateStatus; /*0x1d67*/
}
// Function: ReFlashGetDefaultFwVersion @ 0x1d70 (0x11e bytes)
__int64 __fastcall ReFlashGetDefaultFwVersion(void *DestinationBuffer, __int64 a2, double a3)
{
__int64 result; // rax
__int64 v5; // rbx
__int64 v6; // r8
__int64 v7; // [rsp+40h] [rbp-20h] BYREF
__int64 v8; // [rsp+48h] [rbp-18h] BYREF
__int64 v9; // [rsp+50h] [rbp-10h] BYREF
char v10; // [rsp+88h] [rbp+28h] BYREF
char *SourceBuffer; // [rsp+90h] [rbp+30h] BYREF
unsigned __int64 v12; // [rsp+98h] [rbp+38h] BYREF
result = (*(__int64 (__fastcall **)(__int64, void *, _QWORD, unsigned __int64 *, __int64 *))(BootServices_0 + 312))( /*0x1da0*/
2,
&unk_C790,
0,
&v12,
&v7);
if ( result >= 0 ) /*0x1da9*/
{
v5 = 0; /*0x1daf*/
if ( v12 ) /*0x1db5*/
{
while ( 1 ) /*0x1dd1*/
{
if ( (*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices_0 + 152))( /*0x1dda*/
*(_QWORD *)(v7 + 8 * v5),
&unk_C790,
&v9) >= 0 )
{
SourceBuffer = 0; /*0x1ddc*/
v8 = 0; /*0x1de5*/
LOBYTE(v6) = 24; /*0x1dfd*/
if ( (*(__int64 (__fastcall **)(__int64, void *, __int64, _QWORD, char **, __int64 *, char *))(v9 + 24))( /*0x1e1b*/
v9,
&unk_C9B8,
v6,
0,
&SourceBuffer,
&v8,
&v10) >= 0 )
break; /*0x1e1b*/
}
if ( ++v5 >= v12 ) /*0x1e24*/
goto LABEL_6; /*0x1e24*/
}
DebugPrintErrorLevel(-1, "extracted section with guid %g\n", a3); /*0x1e55*/
SourceBuffer += 16; /*0x1e6b*/
CopyMem(DestinationBuffer, SourceBuffer, 0x78u); /*0x1e6f*/
SourceBuffer -= 16; /*0x1e83*/
(*(void (**)(void))(BootServices_0 + 72))(); /*0x1e87*/
return 0; /*0x1e8a*/
}
else
{
LABEL_6:
(*(void (__fastcall **)(__int64))(BootServices_0 + 72))(v7); /*0x1e26*/
return 0x800000000000000EuLL; /*0x1e34*/
}
}
return result; /*0x1e3e*/
}
// Function: ReFlashGetFwVersion @ 0x1e90 (0xd3 bytes)
__int64 __fastcall ReFlashGetFwVersion(const GUID *Guid2, __int64 a2, double a3)
{
__int64 DefaultFwVersion; // rax
unsigned int Data1; // esi
const GUID *Guid2_2; // rbx
unsigned __int64 Guid2_1; // rax
unsigned __int8 FormatString[2]; // [rsp+20h] [rbp-49h] BYREF
__int16 v10; // [rsp+22h] [rbp-47h]
__int16 v11; // [rsp+24h] [rbp-45h]
__int16 v12; // [rsp+26h] [rbp-43h]
__int16 v13; // [rsp+28h] [rbp-41h]
_BYTE DestinationBuffer[128]; // [rsp+30h] [rbp-39h] BYREF
unsigned __int64 v15; // [rsp+D0h] [rbp+67h] BYREF
if ( Guid2 ) /*0x1eb3*/
{
Data1 = Guid1_.Data1; /*0x1ec0*/
Guid2_2 = Guid2 + 0xFFFFF; /*0x1ec6*/
while ( Guid2_2->Data1 != Data1 || !CompareGuid(&Guid1_, Guid2_2) ) /*0x1ee2*/
{
Guid2_1 = (unsigned __int64)Guid2_2; /*0x1ee4*/
Guid2_2 = (const GUID *)((char *)Guid2_2 - 4); /*0x1ee7*/
if ( Guid2_1 < (unsigned __int64)Guid2 ) /*0x1eee*/
{
DefaultFwVersion = 0x800000000000000EuLL; /*0x1ef0*/
goto LABEL_8; /*0x1ef0*/
}
}
CopyMem(DestinationBuffer, &Guid2_2[1], 0x78u); /*0x1f11*/
}
else
{
DefaultFwVersion = ReFlashGetDefaultFwVersion(DestinationBuffer, a2, a3); /*0x1eb9*/
LABEL_8:
if ( DefaultFwVersion < 0 ) /*0x1efd*/
return 0; /*0x1f01*/
}
*(_WORD *)FormatString = DestinationBuffer[38]; /*0x1f1e*/
v10 = DestinationBuffer[39]; /*0x1f2a*/
v11 = DestinationBuffer[41]; /*0x1f32*/
v12 = DestinationBuffer[42]; /*0x1f3a*/
v13 = 0; /*0x1f3e*/
ReFlashParseVersionString(FormatString, a2, &v15); /*0x1f43*/
return (unsigned int)v15; /*0x1f5b*/
}
// Function: ReFlashBootFlow @ 0x1f64 (0x173 bytes)
__int64 __fastcall ReFlashBootFlow(__int64 a1, __int64 a2, double a3)
{
__int64 result; // rax
__int64 v4; // rdx
__int64 v5; // rbx
GUID SourceBuffer; // [rsp+30h] [rbp-50h] BYREF
int v8; // [rsp+40h] [rbp-40h]
int FwVersion; // [rsp+44h] [rbp-3Ch]
int FwVersion_1; // [rsp+48h] [rbp-38h]
int n327680; // [rsp+4Ch] [rbp-34h]
int FwVersion_2; // [rsp+50h] [rbp-30h]
int n4; // [rsp+54h] [rbp-2Ch]
_BYTE DestinationBuffer[40]; // [rsp+58h] [rbp-28h] BYREF
__int64 v15; // [rsp+90h] [rbp+10h] BYREF
int FwVersion_3; // [rsp+98h] [rbp+18h] BYREF
int v17; // [rsp+9Ch] [rbp+1Ch]
__int64 n8; // [rsp+A0h] [rbp+20h] BYREF
n8 = 8; /*0x1f7b*/
if ( CompareGuid(&Guid1__0, &Guid2_) ) /*0x1f8a*/
return 0x8000000000000003uLL; /*0x1f9d*/
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C7D0, 0, &v15); /*0x1fb6*/
if ( result >= 0 ) /*0x1fbf*/
{
v8 = 1; /*0x1fd3*/
SourceBuffer = Guid2_; /*0x1fd6*/
FwVersion = ReFlashGetFwVersion(0, v4, a3); /*0x1fe0*/
FwVersion_1 = FwVersion; /*0x1fe7*/
n327680 = 327680; /*0x1ff5*/
if ( (*(__int64 (__fastcall **)(const wchar_t *, void *, _QWORD, __int64 *, int *))(RuntimeServices_0 + 72))( /*0x2018*/
L"AmiFwVersion",
&unk_C880,
0,
&n8,
&FwVersion_3) < 0 )
{
n4 = 0; /*0x2070*/
FwVersion_2 = FwVersion; /*0x2074*/
}
else
{
FwVersion_2 = FwVersion_3; /*0x201d*/
switch ( v17 ) /*0x2025*/
{
case 1: /*0x2025*/
n4 = 4; /*0x2064*/
break;
case 2: /*0x2025*/
case 3: /*0x2025*/
n4 = 5; /*0x205b*/
break;
case 4: /*0x2025*/
n4 = 3; /*0x2052*/
break;
case 5: /*0x2025*/
n4 = 6; /*0x2049*/
break;
case 6: /*0x2025*/
n4 = 7; /*0x2040*/
break;
default:
n4 = 1; /*0x203b*/
break;
}
}
v5 = (*(__int64 (__fastcall **)(GUID *, _BYTE *))v15)(&Guid2_, DestinationBuffer); /*0x2088*/
if ( v5 < 0 ) /*0x208e*/
return (*(__int64 (__fastcall **)(GUID *))(v15 + 16))(&SourceBuffer); /*0x2098*/
if ( !CompareMem(DestinationBuffer, &SourceBuffer, 0x28u) ) /*0x20b3*/
return v5; /*0x20c3*/
return (*(__int64 (__fastcall **)(GUID *))(v15 + 8))(&SourceBuffer); /*0x20c0*/
}
return result; /*0x20ce*/
}
// Function: ReFlashCheckAndDispatch @ 0x20d8 (0x13f bytes)
__int64 __fastcall ReFlashCheckAndDispatch(__int64 ImageHandle, EFI_SYSTEM_TABLE *SystemTable, double a3)
{
char ImageHandle_1; // si
_WORD *HobList; // rbx
bool i; // zf
_WORD *NextHob; // rax
const GUID *Guid1; // rdi
__int64 v8; // rdx
__int64 v9; // rdx
__int64 v10; // rcx
__int64 v11; // rbx
int v13; // [rsp+64h] [rbp+1Ch]
__int64 v14; // [rsp+68h] [rbp+20h] BYREF
v14 = 0; /*0x20e0*/
ImageHandle_1 = ImageHandle; /*0x20e6*/
HobList = (_WORD *)HobLibGetHobList(ImageHandle, SystemTable); /*0x20f6*/
for ( i = HobList == 0; ; i = HobList == 0 ) /*0x20f9*/
{
if ( i ) /*0x20fc*/
return 0x800000000000000EuLL; /*0x2205*/
NextHob = HobLibGetNextHob(11, HobList); /*0x210a*/
HobList = NextHob; /*0x210f*/
if ( NextHob ) /*0x2115*/
break; /*0x2115*/
LABEL_6:
; /*0x2135*/
}
Guid1 = (const GUID *)*((_QWORD *)NextHob + 1); /*0x2117*/
if ( !CompareGuid(Guid1, &Guid2__0) ) /*0x2125*/
{
HobList = (_WORD *)((char *)HobList + (unsigned __int16)HobList[1]); /*0x2132*/
goto LABEL_6; /*0x2132*/
}
ReFlashGetFwVersion(Guid2_0, v8, a3); /*0x2141*/
v13 = *(_DWORD *)(FlashDescriptor + 33); /*0x216a*/
(*(void (__fastcall **)(const wchar_t *, void *, __int64))(RuntimeServices_0 + 88))(L"AmiFwVersion", &unk_C880, 3); /*0x2181*/
if ( ImageHandle_1 || v13 ) /*0x218e*/
{
ReFlashBootFlow(v10, v9, a3); /*0x21f4*/
return 0xA000000000000001uLL; /*0x21f9*/
}
else
{
Guid1_0 = (__int64)Guid1; /*0x21a1*/
v11 = (*(__int64 (__fastcall **)(__int64 *, void *, __int64 (__fastcall **)(), _QWORD))(BootServices_0 + 328))( /*0x21ba*/
&v14,
&unk_C7B0,
off_C978,
0);
if ( v11 >= 0 ) /*0x21c0*/
(*(void (__fastcall **)(const wchar_t *, void *, __int64))(RuntimeServices_0 + 88))(L"BootFlow", &unk_C998, 2); /*0x21eb*/
return v11; /*0x21ef*/
}
}
// Function: ReFlashSubInit @ 0x2218 (0x37 bytes)
unsigned __int64 __fastcall ReFlashSubInit(__int64 a1, _QWORD *a2, _QWORD *a3, _QWORD *a4)
{
__int64 GuidPtr; // rcx
if ( !a2 || !a3 || !a4 ) /*0x2225*/
return 0x8000000000000002uLL; /*0x2244*/
GuidPtr = Guid1_0; /*0x2227*/
*a2 = *(unsigned int *)(Guid1_0 + 36); /*0x2231*/
*a3 = *(unsigned int *)(GuidPtr + 40); /*0x2237*/
*a4 = GuidPtr + 44; /*0x223e*/
return 0; /*0x2243*/
}
// Function: ReFlashSubDispatch @ 0x2250 (0x56 bytes)
unsigned __int64 ReFlashSubDispatch()
{
__int64 InitStatus; // rax
__int64 CtxPtr; // rcx
__int64 IterStatus; // rax
InitStatus = ReFlashInitCallback(0, 1); /*0x2258*/
if ( InitStatus < 0 ) /*0x2260*/
(*(void (__fastcall **)(_QWORD, __int64, _QWORD, _QWORD))(RuntimeServices_0 + 104))(0, InitStatus, 0, 0); /*0x2274*/
IterStatus = ReFlashIterateRegions(CtxPtr, (__int64)off_C9F0); /*0x227e*/
if ( IterStatus < 0 ) /*0x2286*/
(*(void (__fastcall **)(_QWORD, __int64, _QWORD, _QWORD))(RuntimeServices_0 + 104))(0, IterStatus, 0, 0); /*0x229a*/
return ReFlashBootCompleteReset(); /*0x229d*/
}
// Function: ReFlashFindGuidInLayout @ 0x22a8 (0xa3 bytes)
const GUID *__fastcall ReFlashFindGuidInLayout(GUID *Guid2)
{
const GUID *Guid1; // rbx
__int64 LayoutStatus; // rax
unsigned int EntryIdx; // edi
unsigned int EntryIdx_1; // esi
Guid1 = Guid1; /*0x22bc*/
if ( !Guid1 ) /*0x22c9*/
{
if ( Guid2_0 ) /*0x22d5*/
{
LayoutStatus = ReFlashReadRomLayout(Guid2_0, &Guid1); /*0x22de*/
Guid1 = Guid1; /*0x22e3*/
}
else
{
LayoutStatus = 0x8000000000000002uLL; /*0x22ec*/
}
if ( LayoutStatus < 0 ) /*0x22f9*/
return 0; /*0x22f9*/
}
EntryIdx = 0; /*0x2309*/
EntryIdx_1 = (unsigned int)n40 / RegionSize; /*0x230b*/
if ( !((unsigned int)n40 / RegionSize) ) /*0x230b*/
return 0; /*0x232f*/
while ( !CompareGuid(Guid1, Guid2) ) /*0x231e*/
{
++EntryIdx; /*0x2326*/
Guid1 = (const GUID *)((char *)Guid1 + (unsigned int)RegionSize); /*0x2328*/
if ( EntryIdx >= EntryIdx_1 ) /*0x232d*/
return 0; /*0x232d*/
}
return Guid1; /*0x2340*/
}
// Function: ReFlashGuidLookup @ 0x234c (0x73 bytes)
const GUID *__fastcall ReFlashGuidLookup(GUID *Guid2)
{
const GUID *DestinationBuffer; // rbx
unsigned int EntryIdx; // edi
unsigned int EntryIdx_1; // esi
DestinationBuffer = DestinationBuffer; /*0x2360*/
if ( !DestinationBuffer ) /*0x236d*/
return 0; /*0x236d*/
EntryIdx = 0; /*0x237d*/
EntryIdx_1 = n40_0 / (unsigned int)RegionSize_0; /*0x237f*/
if ( !(n40_0 / (unsigned int)RegionSize_0) ) /*0x237f*/
return 0; /*0x23a3*/
while ( !CompareGuid(DestinationBuffer, Guid2) ) /*0x2392*/
{
++EntryIdx; /*0x239a*/
DestinationBuffer = (const GUID *)((char *)DestinationBuffer + (unsigned int)RegionSize_0); /*0x239c*/
if ( EntryIdx >= EntryIdx_1 ) /*0x23a1*/
return 0; /*0x23a1*/
}
return DestinationBuffer; /*0x23b4*/
}
// Function: ReFlashSubProcessor @ 0x23c0 (0x8d bytes)
__int64 __fastcall ReFlashSubProcessor(unsigned int n4)
{
__int64 result; // rax
__int64 DescSize; // [rsp+38h] [rbp+10h] BYREF
void (__fastcall **ProtocolPtr)(_QWORD, __int64, __int64 *); // [rsp+40h] [rbp+18h] BYREF
DescSize = 72; /*0x23d7*/
*(_OWORD *)qword_D150 = xmmword_A9C0; /*0x23e4*/
*(_QWORD *)(qword_D150 + 16) = 48; /*0x23ef*/
*(_QWORD *)(qword_D150 + 24) = n4; /*0x23fe*/
*(_QWORD *)(qword_D150 + 32) = 0; /*0x2410*/
result = (*(__int64 (__fastcall **)(void *, _QWORD, _QWORD))(BootServices_0 + 320))(&unk_C6D0, 0, &ProtocolPtr); /*0x241c*/
if ( result >= 0 ) /*0x2425*/
{
(*ProtocolPtr)(ProtocolPtr, qword_D150, &DescSize); /*0x243b*/
return *(_QWORD *)(qword_D150 + 32); /*0x2444*/
}
return result; /*0x2448*/
}
// Function: ReFlashSetBootFlag @ 0x2450 (0x82 bytes)
const GUID *__fastcall ReFlashSetBootFlag(__int64 n2)
{
unsigned int BootMode; // ebx
const GUID *result; // rax
__int64 DestPtr; // rcx
BootMode = n2; /*0x2456*/
result = ReFlashFindGuidInLayout(&Guid2__2); /*0x245f*/
if ( result ) /*0x246a*/
{
if ( BootMode >= 2 ) /*0x246f*/
{
*(_QWORD *)(qword_D150 + 40) = *(_QWORD *)&result[1].Data1; /*0x2497*/
*(_QWORD *)(qword_D150 + 56) = *(unsigned int *)&result[1].Data4[4]; /*0x24a6*/
DestPtr = *(_QWORD *)&ReFlashFindGuidInLayout(&Guid2__3)[1].Data1; /*0x24b6*/
}
else
{
*(_QWORD *)(qword_D150 + 40) = (char *)Guid2_0 + *(unsigned int *)result[1].Data4; /*0x2483*/
DestPtr = *(unsigned int *)&result[1].Data4[4]; /*0x2487*/
}
*(_QWORD *)(qword_D150 + 48) = DestPtr; /*0x24c1*/
return (const GUID *)ReFlashSubProcessor(BootMode); /*0x24c7*/
}
return result; /*0x24cc*/
}
// Function: ReFlashCheckBootRegion @ 0x24d4 (0xa8 bytes)
char ReFlashCheckBootRegion()
{
const GUID *GuidEntry1; // rbp
const GUID *GuidEntry2; // rsi
const GUID *RomEntry1; // rdi
const GUID *RomEntry2; // rax
char NeedsUpdate; // bl
GuidEntry1 = ReFlashGuidLookup(&Guid2__2); /*0x24fb*/
GuidEntry2 = ReFlashGuidLookup(&Guid2__3); /*0x250a*/
RomEntry1 = ReFlashFindGuidInLayout(&Guid2__2); /*0x2519*/
RomEntry2 = ReFlashFindGuidInLayout(&Guid2__3); /*0x251c*/
NeedsUpdate = 0; /*0x2521*/
if ( GuidEntry1 /*0x253f*/
&& GuidEntry2
&& *(_QWORD *)&GuidEntry1[1].Data1 == *(_QWORD *)&RomEntry1[1].Data1
&& *(_QWORD *)&GuidEntry2[1].Data1 == *(_QWORD *)&RomEntry2[1].Data1 )
{
RomEntry1[2].Data1 = 1; /*0x2546*/
*(_DWORD *)&RomEntry1[2].Data2 &= ~0x200u; /*0x254d*/
*(_DWORD *)&RomEntry2[2].Data2 &= ~0x200u; /*0x2550*/
RomEntry2[2].Data1 = 1; /*0x2553*/
}
else
{
NeedsUpdate = 1; /*0x255e*/
ReFlashSetBootFlag(0); /*0x2560*/
}
return NeedsUpdate; /*0x2576*/
}
// Function: ReFlashCheckFlashState @ 0x257c (0xd2 bytes)
bool __fastcall ReFlashCheckFlashState(_DWORD *a1, EFI_SYSTEM_TABLE *SystemTable)
{
INTN v3; // rax
bool result; // al
void *SourceBuffer; // [rsp+30h] [rbp+8h] BYREF
if ( *(_DWORD *)(ReFlashFindFlashDescriptor((__int64)&ImageHandle_, SystemTable) + 36) ) /*0x2591*/
{
LODWORD(v3) = 1; /*0x2597*/
}
else
{
if ( DestinationBuffer_0 ) /*0x25ab*/
{
DestinationBuffer = (GUID *)DestinationBuffer_0; /*0x25ad*/
RegionSize_0 = EntrySize; /*0x25ba*/
n40_0 = n40_1; /*0x25c6*/
}
if ( Guid2_0 ) /*0x25d6*/
ReFlashReadRomLayout((_DWORD *)Guid2_0, &SourceBuffer); /*0x25dd*/
Guid1 = (GUID *)AllocatePool((unsigned int)n40); /*0x25fc*/
CopyMem(Guid1, SourceBuffer, (unsigned int)n40); /*0x2603*/
if ( n40_0 != (_DWORD)n40 || (v3 = CompareMem(DestinationBuffer, Guid1, (unsigned int)n40)) != 0 ) /*0x262f*/
LODWORD(v3) = 2; /*0x2631*/
}
if ( a1 ) /*0x2639*/
*a1 = v3; /*0x263b*/
result = (_DWORD)v3 == 0; /*0x263f*/
byte_D1F0 = result; /*0x2642*/
return result; /*0x2648*/
}
// Function: ReFlashParseFlashRegions @ 0x2650 (0x1ec bytes)
char *__fastcall ReFlashParseFlashRegions(char IsSecondary)
{
char IsSecondary_1; // r13
GUID *DestinationBuffer; // rsi
_QWORD *RegionTable; // r14
unsigned int RegionSize; // edi
unsigned int n40; // eax
unsigned int RegionCount; // eax
__int64 RegionCount_1; // r12
unsigned int RegionCount_2; // ebx
char *result; // rax
unsigned __int8 *Data4; // rbp
__int64 ListIdx; // r15
char *EntryPtr; // rcx
unsigned int SubRegCount; // esi
__int64 FfsPtr; // rbx
unsigned __int16 ExtHdrLen; // dx
unsigned int SectionOffset; // ecx
unsigned int SectionOffset_1; // edi
unsigned __int64 SectionOffset_2; // r13
int SectionLen; // edx
_QWORD *Pool; // rdx
__int64 CompressInfo; // rax
int SectionType; // ecx
__int64 CurrentPtr; // [rsp+68h] [rbp+10h]
__int64 RegionSize_1; // [rsp+70h] [rbp+18h]
IsSecondary_1 = IsSecondary; /*0x266a*/
if ( IsSecondary ) /*0x266f*/
{
DestinationBuffer = DestinationBuffer; /*0x2671*/
RegionTable = &unk_DA30; /*0x2678*/
RegionSize = RegionSize_0; /*0x267f*/
n40 = n40_0; /*0x2685*/
}
else
{
DestinationBuffer = Guid1; /*0x268d*/
RegionTable = &unk_DA10; /*0x2694*/
RegionSize = RegionSize; /*0x269b*/
n40 = n40; /*0x26a1*/
}
RegionCount = n40 / RegionSize; /*0x26a7*/
RegionCount_1 = RegionCount; /*0x26a9*/
RegionCount_2 = RegionCount; /*0x26ac*/
*(_DWORD *)RegionTable = RegionCount; /*0x26ae*/
result = (char *)AllocatePool(24LL * RegionCount); /*0x26b9*/
RegionTable[1] = result; /*0x26c1*/
if ( RegionCount_2 )
{
Data4 = DestinationBuffer[1].Data4; /*0x26cf*/
RegionSize_1 = RegionSize; /*0x26d3*/
ListIdx = 0; /*0x26d8*/
do
{
if ( IsSecondary_1 ) /*0x26de*/
EntryPtr = (char *)*((_QWORD *)Data4 - 1); /*0x26e0*/
else
EntryPtr = (char *)Guid2_0 + *(unsigned int *)Data4; /*0x26e9*/
SubRegCount = 0; /*0x26f4*/
*(_QWORD *)(ListIdx + RegionTable[1]) = EntryPtr; /*0x26f7*/
CurrentPtr = RegionTable[1]; /*0x26ff*/
FfsPtr = *(_QWORD *)(ListIdx + CurrentPtr); /*0x2704*/
if ( *(_DWORD *)(FfsPtr + 40) == 1213613663 )
{
ExtHdrLen = *(_WORD *)(FfsPtr + 52); /*0x2715*/
SectionOffset = *(unsigned __int16 *)(FfsPtr + 48); /*0x2719*/
if ( ExtHdrLen ) /*0x2720*/
SectionOffset = *(_DWORD *)(ExtHdrLen + FfsPtr + 16) + ExtHdrLen; /*0x2728*/
if ( (SectionOffset & 7) != 0 ) /*0x2731*/
SectionOffset += 8 - (SectionOffset & 7); /*0x273a*/
SectionOffset_1 = SectionOffset; /*0x273c*/
SectionOffset_2 = SectionOffset; /*0x273e*/
while ( (unsigned __int64)SectionOffset < *(_QWORD *)(FfsPtr + 32) /*0x2758*/
&& (*(_QWORD *)(SectionOffset + FfsPtr) != -1
|| *(_QWORD *)(SectionOffset + FfsPtr + 8) != -1
|| *(_QWORD *)(SectionOffset + FfsPtr + 16) != -1) )
{
++SubRegCount; /*0x275a*/
if ( (*(_BYTE *)(SectionOffset + FfsPtr + 19) & 1) != 0 ) /*0x2761*/
SectionLen = *(_DWORD *)(SectionOffset + FfsPtr + 24); /*0x2763*/
else
SectionLen = *(_DWORD *)(SectionOffset + FfsPtr + 20) & 0xFFFFFF; /*0x276d*/
SectionOffset += SectionLen; /*0x2773*/
if ( (SectionOffset & 7) != 0 ) /*0x277a*/
SectionOffset += 8 - (SectionOffset & 7); /*0x2783*/
}
Pool = AllocatePool(8LL * SubRegCount); /*0x279b*/
if ( Pool )
{
*(_QWORD *)(ListIdx + CurrentPtr + 16) = Pool; /*0x27ad*/
if ( SectionOffset_2 < *(_QWORD *)(FfsPtr + 32) )
{
do
{
CompressInfo = FfsPtr + SectionOffset_1; /*0x27ba*/
if ( *(_QWORD *)CompressInfo == -1 /*0x27cf*/
&& *(_QWORD *)(CompressInfo + 8) == -1
&& *(_QWORD *)(CompressInfo + 16) == -1 )
{
break; /*0x27cf*/
}
*Pool++ = CompressInfo; /*0x27d1*/
SectionType = (*(_BYTE *)(CompressInfo + 19) & 1) != 0
? *(_DWORD *)(CompressInfo + 24)
: *(_DWORD *)(CompressInfo + 20) & 0xFFFFFF;
SectionOffset_1 += SectionType; /*0x27ec*/
if ( (SectionOffset_1 & 7) != 0 ) /*0x27f3*/
SectionOffset_1 += 8 - (SectionOffset_1 & 7); /*0x27fc*/
}
while ( (unsigned __int64)SectionOffset_1 < *(_QWORD *)(FfsPtr + 32) );
}
}
else
{
SubRegCount = 0; /*0x27a3*/
}
IsSecondary_1 = IsSecondary; /*0x2806*/
}
result = (char *)RegionTable[1]; /*0x280b*/
Data4 += RegionSize_1; /*0x280f*/
*(_DWORD *)&result[ListIdx + 8] = SubRegCount; /*0x2814*/
ListIdx += 24; /*0x2819*/
--RegionCount_1; /*0x281d*/
}
while ( RegionCount_1 );
}
return result; /*0x282c*/
}
// Function: ReFlashFindGuidInTable @ 0x283c (0xc1 bytes)
const GUID *__fastcall ReFlashFindGuidInTable(GUID *Guid1, char a2)
{
_QWORD *TablePtr; // rbx
__int64 EntryIdx; // rdi
__int64 TableEntry; // rax
unsigned int GuidCount; // esi
const GUID **p_Guid2; // r14
const GUID *Guid2; // rbp
if ( byte_C9C8 ) /*0x2866*/
{
ReFlashParseFlashRegions(1); /*0x286a*/
ReFlashParseFlashRegions(0); /*0x2871*/
byte_C9C8 = 0; /*0x2876*/
}
TablePtr = &unk_DA10; /*0x2887*/
if ( a2 ) /*0x288e*/
TablePtr = &unk_DA30; /*0x288e*/
EntryIdx = 0; /*0x2892*/
if ( !*(_DWORD *)TablePtr ) /*0x2894*/
return 0; /*0x28d7*/
while ( 1 ) /*0x2898*/
{
TableEntry = TablePtr[1]; /*0x2898*/
GuidCount = 0; /*0x28a0*/
p_Guid2 = *(const GUID ***)(TableEntry + 24 * EntryIdx + 16); /*0x28a2*/
if ( *(_DWORD *)(TableEntry + 24 * EntryIdx + 8) ) /*0x28a7*/
break; /*0x28a7*/
LABEL_9:
EntryIdx = (unsigned int)(EntryIdx + 1); /*0x28d1*/
if ( (unsigned int)EntryIdx >= *(_DWORD *)TablePtr ) /*0x28d5*/
return 0; /*0x28d5*/
}
while ( 1 ) /*0x28ae*/
{
Guid2 = *p_Guid2; /*0x28ae*/
if ( CompareGuid(Guid1, *p_Guid2) ) /*0x28b7*/
return Guid2; /*0x28ed*/
++GuidCount; /*0x28c4*/
++p_Guid2; /*0x28c6*/
if ( GuidCount >= *(_DWORD *)(TablePtr[1] + 24 * EntryIdx + 8) ) /*0x28cf*/
goto LABEL_9; /*0x28cf*/
}
}
// Function: ReFlashCopyGuidData @ 0x2900 (0xe1 bytes)
unsigned __int64 ReFlashCopyGuidData()
{
unsigned __int64 i; // rax
unsigned int RegionIdx; // edi
const GUID *GuidEntry; // rsi
__int64 FfsHeaderSize; // rdx
unsigned int Length; // ecx
const void *SourceBuffer; // r9
__int64 FfsHdrSize; // rdx
i = (unsigned int)i_1; /*0x290f*/
if ( i_1 ) /*0x2917*/
{
if ( byte_D1F0 ) /*0x2924*/
{
for ( RegionIdx = 0; RegionIdx < i_1; ++RegionIdx ) /*0x292e*/
{
GuidEntry = ReFlashFindGuidInTable((GUID *)&unk_D170 + RegionIdx, 0); /*0x2953*/
i = (unsigned __int64)ReFlashFindGuidInTable((GUID *)&unk_D170 + RegionIdx, 1); /*0x2956*/
if ( i && GuidEntry ) /*0x2963*/
{
if ( (*(_BYTE *)(i + 19) & 1) != 0 ) /*0x2969*/
{
FfsHeaderSize = 32; /*0x296e*/
Length = *(_DWORD *)(i + 24) - 32; /*0x2973*/
}
else
{
FfsHeaderSize = 24; /*0x297b*/
Length = (*(_DWORD *)(i + 20) & 0xFFFFFF) - 24; /*0x2986*/
}
SourceBuffer = (const void *)(FfsHeaderSize + i); /*0x298d*/
if ( (GuidEntry[1].Data1 & 0x1000000) != 0 ) /*0x2991*/
{
FfsHdrSize = 32; /*0x2996*/
i = (unsigned int)(*(_DWORD *)GuidEntry[1].Data4 - 32); /*0x299b*/
}
else
{
FfsHdrSize = 24; /*0x29a3*/
i = (*(_DWORD *)&GuidEntry[1].Data2 & 0xFFFFFFu) - 24; /*0x29ad*/
}
if ( Length <= (unsigned int)i ) /*0x29b2*/
i = (unsigned __int64)CopyMem((char *)GuidEntry + FfsHdrSize, SourceBuffer, Length); /*0x29be*/
}
}
}
}
return i; /*0x29db*/
}
// Function: ReFlashShowProgress @ 0x29e8 (0x12a bytes)
__int64 __fastcall ReFlashShowProgress(__int64 a1, unsigned __int64 n3)
{
__int64 ProgressProto; // rax
__int64 ProgressStatus; // rax
__int64 Remaining; // rdi
DebugPrint(0xFFFFFFFFFFFFFFFFuLL, "AmiShowProgress: %d% \n", n3);
ProgressProto = ::ProgressProto; /*0x2a0d*/
if ( !::ProgressProto ) /*0x2a17*/
{
ProgressStatus = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))( /*0x2a30*/
&unk_C830,
0,
&::ProgressProto);
if ( ProgressStatus < 0 ) /*0x2a39*/
return ProgressStatus; /*0x2a39*/
ProgressProto = ::ProgressProto; /*0x2a3f*/
}
ProgressStatus = (*(__int64 (**)(void))(ProgressProto + 80))(); /*0x2a46*/
if ( (int)ProgressStatus <= 3 ) /*0x2a4c*/
{
if ( !n3 ) /*0x2a55*/
{
(*(void (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C7F0, 0, &qword_DA50); /*0x2a72*/
if ( qword_DA50 ) /*0x2a82*/
(*(void (__fastcall **)(unsigned __int64, __int64, unsigned __int64))(::ProgressProto + 64))( /*0x2ad9*/
*(unsigned int *)(*(_QWORD *)(*(_QWORD *)(qword_DA50 + 24) + 8LL) + 4LL) / 5uLL,
*(unsigned int *)(*(_QWORD *)(*(_QWORD *)(qword_DA50 + 24) + 8LL) + 8LL) - 10LL,
3 * (unsigned __int64)*(unsigned int *)(*(_QWORD *)(*(_QWORD *)(qword_DA50 + 24) + 8LL) + 4LL) / 5);
}
ProgressStatus = n3_0; /*0x2adc*/
if ( n3_0 < n3 ) /*0x2ae6*/
{
Remaining = n3 - n3_0; /*0x2ae8*/
do /*0x2b00*/
{
ProgressStatus = (*(__int64 (**)(void))(::ProgressProto + 72))(); /*0x2af2*/
++n3_0; /*0x2af5*/
--Remaining; /*0x2afc*/
}
while ( Remaining ); /*0x2b00*/
}
}
return ProgressStatus; /*0x2b0c*/
}
// Function: ReFlashSubCleanup @ 0x2b14 (0x70 bytes)
__int64 __fastcall ReFlashSubCleanup(__int64 a1)
{
__int64 BdsProto; // r10
__int64 result; // rax
char *CallData; // rcx
char LocalFlag; // [rsp+58h] [rbp+10h] BYREF
BdsProto = ::BdsProto; /*0x2b1a*/
if ( ::BdsProto /*0x2b50*/
|| (result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(
&unk_CA10,
0,
&::BdsProto),
(BdsProto = ::BdsProto) != 0) )
{
CallData = &LocalFlag; /*0x2b52*/
LOBYTE(CallData) = 1; /*0x2b78*/
return (*(__int64 (__fastcall **)(char *, const wchar_t *, _QWORD, _QWORD, _QWORD, __int64, char *))(BdsProto + 120))( /*0x2b7a*/
CallData,
L"Flash Update",
0,
0,
0,
a1 + 24,
&LocalFlag);
}
return result; /*0x2b7e*/
}
// Function: ReFlashSubTeardown @ 0x2b84 (0x43 bytes)
__int64 __fastcall ReFlashSubTeardown(__int64 a1, __int64 a2)
{
__int64 DataOffset; // rax
__int64 *ResultPtr; // rcx
__int64 result; // rax
__int64 LocalResult; // [rsp+60h] [rbp+18h] BYREF
if ( BdsProto ) /*0x2b95*/
{
DataOffset = a1 + 24; /*0x2b97*/
ResultPtr = &LocalResult; /*0x2b9e*/
LOBYTE(ResultPtr) = 2; /*0x2bb1*/
return (*(__int64 (__fastcall **)(__int64 *, const wchar_t *, const wchar_t *, _QWORD, __int64, __int64, __int64 *))(BdsProto + 120))( /*0x2bbe*/
ResultPtr,
L"Flash Update",
L"Updating main firmware",
0,
a2,
DataOffset,
&LocalResult);
}
return result; /*0x2bc2*/
}
// Function: ReFlashUpdateProgress @ 0x2bc8 (0x40 bytes)
__int64 __fastcall ReFlashUpdateProgress(__int64 a1)
{
__int64 v1; // rax
__int64 *v2; // rcx
__int64 result; // rax
__int64 v4; // [rsp+58h] [rbp+10h] BYREF
if ( BdsProto ) /*0x2bd9*/
{
v1 = a1 + 24; /*0x2bdb*/
v2 = &v4; /*0x2be2*/
LOBYTE(v2) = 3; /*0x2bf8*/
return (*(__int64 (__fastcall **)(__int64 *, const wchar_t *, _QWORD, _QWORD, _QWORD, __int64, __int64 *))(BdsProto + 120))( /*0x2bff*/
v2,
L"Flash Update",
0,
0,
0,
v1,
&v4);
}
return result; /*0x2c03*/
}
// Function: DriverEntryPoint @ 0x2c08 (0x273 bytes)
__int64 DriverEntryPoint()
{
__int64 result; // rax
unsigned __int8 v1; // [rsp+20h] [rbp-158h]
unsigned int v2; // [rsp+24h] [rbp-154h]
int v3; // [rsp+30h] [rbp-148h] BYREF
__int16 n8853; // [rsp+34h] [rbp-144h]
__int16 n16686; // [rsp+36h] [rbp-142h]
char v6; // [rsp+38h] [rbp-140h]
char n109; // [rsp+39h] [rbp-13Fh]
char v8; // [rsp+3Ah] [rbp-13Eh]
char v9; // [rsp+3Bh] [rbp-13Dh]
char v10; // [rsp+3Ch] [rbp-13Ch]
char n32; // [rsp+3Dh] [rbp-13Bh]
char v12; // [rsp+3Eh] [rbp-13Ah]
char n49; // [rsp+3Fh] [rbp-139h]
int v14; // [rsp+40h] [rbp-138h] BYREF
__int16 n22215; // [rsp+44h] [rbp-134h]
__int16 n19164; // [rsp+46h] [rbp-132h]
char v17; // [rsp+48h] [rbp-130h]
char v18; // [rsp+49h] [rbp-12Fh]
char n28; // [rsp+4Ah] [rbp-12Eh]
char n44; // [rsp+4Bh] [rbp-12Dh]
char v21; // [rsp+4Ch] [rbp-12Ch]
char n114; // [rsp+4Dh] [rbp-12Bh]
char v23; // [rsp+4Eh] [rbp-12Ah]
char v24; // [rsp+4Fh] [rbp-129h]
_WORD *v25; // [rsp+50h] [rbp-128h] BYREF
_QWORD v26[2]; // [rsp+58h] [rbp-120h] BYREF
_BYTE v27[8]; // [rsp+68h] [rbp-110h] BYREF
char dst[128]; // [rsp+70h] [rbp-108h] BYREF
char dst_1[136]; // [rsp+F0h] [rbp-88h] BYREF
v26[0] = 0; /*0x2c11*/
memset(dst, 0, 120); /*0x2c1a*/
v3 = -624702568; /*0x2c30*/
n8853 = 8853; /*0x2c3d*/
n16686 = 16686; /*0x2c47*/
v6 = -126; /*0x2c4c*/
n109 = 109; /*0x2c51*/
v8 = -3; /*0x2c56*/
v9 = -18; /*0x2c5b*/
v10 = -93; /*0x2c60*/
n32 = 32; /*0x2c65*/
v12 = -49; /*0x2c6a*/
n49 = 49; /*0x2c6f*/
v14 = -1970163231; /*0x2c74*/
n22215 = 22215; /*0x2c81*/
n19164 = 19164; /*0x2c8b*/
v17 = -85; /*0x2c90*/
v18 = -21; /*0x2c95*/
n28 = 28; /*0x2c9a*/
n44 = 44; /*0x2c9f*/
v21 = -95; /*0x2ca4*/
n114 = 114; /*0x2ca9*/
v23 = -98; /*0x2cae*/
v24 = -1; /*0x2cb3*/
v25 = (_WORD *)DriverEntryPoint_0(SystemTable, &ImageHandle__2); /*0x2ccb*/
if ( v25 && DevicePathFindAcpiNode(&v3, &v25) >= 0 ) /*0x2cea*/
ReFlashScanFlashSignature(dst, *((_QWORD *)v25 + 3)); /*0x2cfa*/
ReFlashReadFlashLayoutFromBlockIo(dst_1); /*0x2d07*/
v2 = 10 * (dst_1[41] - 48) + dst_1[42] - 48; /*0x2d73*/
result = v2; /*0x2de2*/
if ( 10 * (dst[41] - 48) + dst[42] - 48 < v2 )
{
v1 = ReFlashExecuteUpdate(); /*0x2df5*/
result = v1; /*0x2df9*/
if ( v1 == 1 )
{
result = (*(__int64 (__fastcall **)(int *, _QWORD, _QWORD *))(BootServices + 320))(&v14, 0, v26); /*0x2e16*/
v26[1] = result; /*0x2e1c*/
if ( result >= 0 )
{
if ( v26[0] )
{
(*(void (__fastcall **)(const wchar_t *, const wchar_t *, __int64, _BYTE *, unsigned __int8))(v26[0] + 88LL))(
L"TPM CLEAR",
L"Caution: A Reset is required to Clear the TPM for Flash Update. Enable Recovery after reset",
20,
v27,
v1);
Assert_49(1000000); /*0x2e59*/
}
return (*(__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD, _QWORD))(RuntimeServices + 104))(0, 0, 0, 0); /*0x2e6f*/
}
}
}
return result; /*0x2e72*/
}
// Function: DebugLibIsDebugEnabled @ 0x2e7c (0x7f bytes)
__int64 DebugLibIsDebugEnabled()
{
__int64 result; // rax
unsigned __int64 n0x10; // rbx
__int64 v2; // rax
__int64 v3; // rcx
result = qword_D228; /*0x2e86*/
if ( !qword_D228 ) /*0x2e92*/
{
n0x10 = (*(__int64 (__fastcall **)(__int64))(BootServices_0 + 24))(31); /*0x2eab*/
(*(void (__fastcall **)(unsigned __int64))(BootServices_0 + 32))(n0x10); /*0x2eae*/
if ( n0x10 <= 0x10 ) /*0x2eb5*/
{
v2 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C6C0, 0, &qword_D228); /*0x2ed2*/
v3 = qword_D228; /*0x2ed8*/
if ( v2 < 0 ) /*0x2ee2*/
v3 = 0; /*0x2ee2*/
qword_D228 = v3; /*0x2ee6*/
return v3; /*0x2eed*/
}
else
{
return 0; /*0x2eb7*/
}
}
return result; /*0x2ef5*/
}
// Function: DebugPrint @ 0x2efc (0x47 bytes)
void DebugPrint(UINTN ErrorLevel, const CHAR8 *Format, ...)
{
void (__fastcall **v3)(UINTN, const CHAR8 *, __int64 *); // r10
va_list va; // [rsp+40h] [rbp+18h] BYREF
va_start(va, Format);
if ( DebugLibIsDebugEnabled() ) /*0x2f13*/
{
if ( ((unsigned int)DebugLibGetDebugMask() & (unsigned int)ErrorLevel) != 0 ) /*0x2f2b*/
(*v3)(ErrorLevel, Format, (__int64 *)va); /*0x2f3a*/
}
}
// Function: DebugAssert @ 0x2f44 (0x3e bytes)
void __cdecl DebugAssert(const CHAR8 *FileName, UINTN LineNumber, const CHAR8 *Description)
{
__int64 IsDebugEnabled; // rax
IsDebugEnabled = DebugLibIsDebugEnabled(); /*0x2f5c*/
if ( IsDebugEnabled ) /*0x2f64*/
(*(void (__fastcall **)(const CHAR8 *, UINTN, const CHAR8 *))(IsDebugEnabled + 8))( /*0x2f6f*/
FileName,
LineNumber,
Description);
}
// Function: Assert_46 @ 0x2f84 (0x46 bytes)
char *__fastcall Assert_46(char *ZeroPool, __int64 a2)
{
__int64 v4; // rax
__int64 v5; // rax
v4 = Assert_34(a2); /*0x2f97*/
Assert_26(ZeroPool, v4); /*0x2fa2*/
v5 = Assert_34(a2 + 8); /*0x2fab*/
Assert_26((_QWORD *)ZeroPool + 1, v5); /*0x2fb7*/
return ZeroPool; /*0x2fc4*/
}
// Function: CompareGuid @ 0x2fcc (0x67 bytes)
BOOLEAN __cdecl CompareGuid(const GUID *Guid1, const GUID *Guid2)
{
__int128 v4; // rdi
__int64 v5; // rbx
*((_QWORD *)&v4 + 1) = Assert_34((__int64)Guid1); /*0x2fee*/
v5 = Assert_34((__int64)Guid2); /*0x2ffa*/
*(_QWORD *)&v4 = Assert_34((__int64)Guid1->Data4); /*0x3006*/
return v4 == __PAIR128__(v5, Assert_34((__int64)Guid2->Data4)); /*0x302d*/
}
// Function: CopyMem @ 0x3034 (0x99 bytes)
void *__cdecl CopyMem(void *DestinationBuffer, const void *SourceBuffer, UINTN Length)
{
void *DestinationBuffer_1; // rax
unsigned __int64 v7; // rbp
DestinationBuffer_1 = DestinationBuffer; /*0x3051*/
if ( Length ) /*0x3057*/
{
v7 = Length - 1; /*0x3059*/
if ( Length - 1 > ~(unsigned __int64)DestinationBuffer ) /*0x3063*/
DebugAssert( /*0x3078*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
0x38u,
"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)DestinationBuffer)");
if ( v7 > ~(unsigned __int64)SourceBuffer ) /*0x3086*/
DebugAssert( /*0x309b*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
0x39u,
"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)SourceBuffer)");
if ( DestinationBuffer == SourceBuffer ) /*0x30a3*/
return DestinationBuffer; /*0x30a5*/
else
return InternalCopyMem((char *)DestinationBuffer, (char *)SourceBuffer, Length); /*0x30b3*/
}
return DestinationBuffer_1; /*0x30c7*/
}
// Function: ZeroMem @ 0x30d0 (0x55 bytes)
void *__fastcall ZeroMem(unsigned __int64 buf, unsigned __int64 count)
{
void *buf_1; // rax
buf_1 = (void *)buf; /*0x30e0*/
if ( count ) /*0x30e6*/
{
if ( count - 1 > ~buf ) /*0x30f2*/
DebugAssert( /*0x3107*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\SetMemWrapper.c",
0x36u,
"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)Buffer)");
return InternalSetMem((void *)buf, count, 0); /*0x3115*/
}
return buf_1; /*0x311f*/
}
// Function: CompareMem @ 0x3128 (0xd6 bytes)
INTN __cdecl CompareMem(const void *DestinationBuffer, const void *SourceBuffer, UINTN Length)
{
if ( !Length || DestinationBuffer == SourceBuffer ) /*0x3151*/
return 0; /*0x31e7*/
if ( !DestinationBuffer ) /*0x315a*/
DebugAssert( /*0x316d*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
0x3Cu,
"DestinationBuffer != ((void *) 0)");
if ( !SourceBuffer ) /*0x3175*/
DebugAssert( /*0x3188*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
0x3Du,
"SourceBuffer != ((void *) 0)");
if ( Length - 1 > ~(unsigned __int64)DestinationBuffer ) /*0x319a*/
DebugAssert( /*0x31af*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
0x3Eu,
"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)DestinationBuffer)");
if ( Length - 1 > ~(unsigned __int64)SourceBuffer ) /*0x31bd*/
DebugAssert( /*0x31d2*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
0x3Fu,
"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)SourceBuffer)");
return InternalCompareMem((char *)DestinationBuffer, (char *)SourceBuffer, Length); /*0x31f8*/
}
// Function: StrLen @ 0x3200 (0x93 bytes)
UINTN __cdecl StrLen(const CHAR16 *String)
{
const CHAR16 *v1; // rbx
UINTN n0xF4240; // rdi
v1 = String; /*0x3211*/
if ( !String ) /*0x3217*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0xACu, "String != ((void *) 0)"); /*0x322c*/
if ( ((unsigned __int8)v1 & 1) != 0 ) /*0x3234*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0xADu, "((UINTN) String & 0x00000001) == 0"); /*0x3249*/
n0xF4240 = 0; /*0x324e*/
while ( *v1 ) /*0x327e*/
{
if ( n0xF4240 >= 0xF4240 ) /*0x325a*/
DebugAssert( /*0x326f*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
0xB5u,
"Length < _gPcd_FixedAtBuild_PcdMaximumUnicodeStringLength");
++v1; /*0x3274*/
++n0xF4240; /*0x3278*/
}
return n0xF4240; /*0x328d*/
}
// Function: StrCpyS @ 0x3294 (0x11c bytes)
RETURN_STATUS __cdecl StrCpyS(CHAR16 *Destination, UINTN DestMax, const CHAR16 *Source)
{
CHAR16 *v5; // rbx
CHAR16 v6; // ax
UINTN v7; // rdi
v5 = &Destination[StrLen(Destination)]; /*0x32c2*/
if ( !v5 ) /*0x32c9*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x38u, "Destination != ((void *) 0)"); /*0x32d8*/
if ( ((unsigned __int8)v5 & 1) != 0 ) /*0x32e0*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x39u, "((UINTN) Destination & 0x00000001) == 0"); /*0x32f1*/
if ( (__int64)((__int64)v5 - DestMax) >> 1 <= StrLen((const CHAR16 *)DestMax) ) /*0x330a*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x3Eu, "(UINTN)(Destination - Source) > StrLen (Source)"); /*0x331b*/
if ( (__int64)(DestMax - (_QWORD)v5) >> 1 <= StrLen((const CHAR16 *)DestMax) ) /*0x3334*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x3Fu, "(UINTN)(Source - Destination) > StrLen (Source)"); /*0x3345*/
v6 = *(_WORD *)DestMax; /*0x334a*/
if ( *(_WORD *)DestMax ) /*0x334a*/
{
v7 = DestMax - (_QWORD)v5; /*0x3352*/
do /*0x3363*/
{
*v5++ = v6; /*0x3355*/
v6 = *(CHAR16 *)((char *)v5 + v7); /*0x335c*/
}
while ( v6 ); /*0x3363*/
}
*v5 = 0; /*0x3368*/
if ( 2 * StrLen(Destination) == -2 ) /*0x337c*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x17Au, "StrSize (Destination) != 0"); /*0x338d*/
return (RETURN_STATUS)Destination; /*0x33a9*/
}
// Function: Assert_10 @ 0x33b0 (0xcc bytes)
CHAR16 *__fastcall Assert_10(__int64 a1, const CHAR16 *Pool)
{
CHAR16 *String; // rbx
const CHAR16 *Pool_1; // rcx
CHAR16 *v6; // rdx
CHAR16 v7; // ax
String = String; /*0x33bf*/
if ( 2 * StrLen(String) == -2 ) /*0x33de*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x1E5u, "StrSize (String) != 0"); /*0x33f3*/
if ( 2 * StrLen(Pool) == -2 ) /*0x340b*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x1E6u, "StrSize (SearchString) != 0"); /*0x3420*/
if ( !*Pool ) /*0x3425*/
return String; /*0x342a*/
while ( 1 ) /*0x345d*/
{
v7 = *String; /*0x345d*/
if ( !*String ) /*0x345d*/
return 0; /*0x3465*/
Pool_1 = Pool; /*0x342f*/
v6 = String; /*0x3432*/
if ( v7 == *Pool ) /*0x3438*/
{
do /*0x344d*/
{
if ( !v7 ) /*0x343d*/
break; /*0x343d*/
++String; /*0x343f*/
++Pool_1; /*0x3443*/
v7 = *String; /*0x3447*/
}
while ( *String == *Pool_1 ); /*0x344d*/
}
if ( !*Pool_1 ) /*0x344f*/
break; /*0x344f*/
if ( !*String ) /*0x3457*/
return 0; /*0x3457*/
String = v6 + 1; /*0x3459*/
}
return v6; /*0x3471*/
}
// Function: Assert_21 @ 0x347c (0x6b bytes)
unsigned __int64 __fastcall Assert_21(_BYTE *x_UEFI)
{
_BYTE *x_UEFI_1; // rbx
unsigned __int64 i; // rdi
x_UEFI_1 = x_UEFI; /*0x3486*/
if ( !x_UEFI ) /*0x348c*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x43Au, "String != ((void *) 0)"); /*0x34a1*/
for ( i = 0; *x_UEFI_1; ++i ) /*0x34a8*/
{
if ( i >= 0xF4240 ) /*0x34b4*/
DebugAssert( /*0x34c9*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
0x442u,
"Length < _gPcd_FixedAtBuild_PcdMaximumAsciiStringLength");
++x_UEFI_1; /*0x34ce*/
}
return i; /*0x34e1*/
}
// Function: Assert_8 @ 0x34e8 (0xcd bytes)
__int64 __fastcall Assert_8(_BYTE *x_UEFI, __int64 a2, unsigned __int64 n0xF4240)
{
_BYTE *x_UEFI_1; // rsi
unsigned __int64 n0xF4240_1; // rdi
_BYTE *x_UEFI_2; // rbx
x_UEFI_1 = "x-UEFI"; /*0x34f7*/
n0xF4240_1 = n0xF4240; /*0x34fe*/
x_UEFI_2 = x_UEFI; /*0x3501*/
if ( !n0xF4240 ) /*0x3507*/
return 0; /*0x3509*/
if ( Assert_21(x_UEFI) == -1 ) /*0x3519*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x528u, "AsciiStrSize (FirstString)"); /*0x352e*/
if ( Assert_21("x-UEFI") == -1 ) /*0x353f*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 0x529u, "AsciiStrSize (SecondString)"); /*0x3554*/
if ( n0xF4240_1 > 0xF4240 ) /*0x3560*/
DebugAssert( /*0x3575*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
0x52Cu,
"Length <= _gPcd_FixedAtBuild_PcdMaximumAsciiStringLength");
while ( *x_UEFI_2 && *x_UEFI_1 && *x_UEFI_2 == *x_UEFI_1 && n0xF4240_1 > 1 ) /*0x3589*/
{
++x_UEFI_2; /*0x358b*/
++x_UEFI_1; /*0x358e*/
--n0xF4240_1; /*0x3591*/
}
return (char)*x_UEFI_2 - (char)*x_UEFI_1; /*0x35af*/
}
// Function: Assert_37 @ 0x35b8 (0x2d bytes)
__int64 __fastcall Assert_37(unsigned __int16 *a1)
{
if ( !a1 ) /*0x35c4*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 0x26u, "Buffer != ((void *) 0)"); /*0x35d7*/
return *a1; /*0x35df*/
}
// Function: Assert_28 @ 0x35e8 (0x3c bytes)
__int64 __fastcall Assert_28(unsigned __int16 *a1, unsigned __int16 AllocationSize)
{
if ( !a1 ) /*0x35fb*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 0x41u, "Buffer != ((void *) 0)"); /*0x360e*/
*a1 = AllocationSize; /*0x3613*/
return AllocationSize; /*0x361e*/
}
// Function: Assert_36 @ 0x3624 (0x2e bytes)
__int64 __fastcall Assert_36(unsigned int *FormatString, unsigned __int8 *a2, unsigned __int8 *a3)
{
if ( !FormatString ) /*0x3630*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 0x8Du, "Buffer != ((void *) 0)"); /*0x3645*/
return *FormatString; /*0x364c*/
}
// Function: Assert_34 @ 0x3654 (0x2f bytes)
__int64 __fastcall Assert_34(__int64 a1)
{
if ( !a1 ) /*0x3660*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 0xC0u, "Buffer != ((void *) 0)"); /*0x3675*/
return *(_QWORD *)a1; /*0x367d*/
}
// Function: Assert_26 @ 0x3684 (0x3e bytes)
__int64 __fastcall Assert_26(_QWORD *ZeroPool, __int64 a2)
{
if ( !ZeroPool ) /*0x3697*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 0xDBu, "Buffer != ((void *) 0)"); /*0x36ac*/
*ZeroPool = a2; /*0x36b1*/
return a2; /*0x36bc*/
}
// Function: Assert_23 @ 0x36c4 (0x56 bytes)
unsigned __int64 __fastcall Assert_23(unsigned __int8 *FormatString)
{
unsigned __int64 n0xF4240; // rax
if ( ((unsigned __int8)FormatString & 1) != 0 ) /*0x36d0*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c", 0x80u, "((UINTN) String & 0x00000001) == 0"); /*0x36e5*/
if ( !FormatString ) /*0x36ef*/
return 0; /*0x3712*/
n0xF4240 = 0; /*0x36f1*/
if ( *(_WORD *)FormatString ) /*0x36f3*/
{
while ( n0xF4240 < 0xF4240 ) /*0x36fe*/
{
++n0xF4240; /*0x3700*/
if ( !*(_WORD *)&FormatString[2 * n0xF4240] ) /*0x3703*/
return n0xF4240; /*0x3707*/
}
return 1000001; /*0x370b*/
}
return n0xF4240; /*0x3714*/
}
// Function: ReFlashParseVersionString @ 0x371c (0x12f bytes)
unsigned __int64 __fastcall ReFlashParseVersionString(unsigned __int8 *FormatString, __int64 a2, unsigned __int64 *a3)
{
unsigned __int8 *FormatString_1; // rbx
const CHAR8 *(String____((void__)_0)); // r8
UINTN n645; // rdx
__int64 v8; // r9
FormatString_1 = FormatString; /*0x3729*/
if ( ((unsigned __int8)FormatString & 1) != 0 ) /*0x372f*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c", 0x280u, "((UINTN) String & 0x00000001) == 0"); /*0x3744*/
if ( !FormatString_1 ) /*0x374c*/
{
(String____((void__)_0)) = "(String != ((void *) 0))"; /*0x374e*/
n645 = 645; /*0x3755*/
LABEL_5:
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c", n645, (String____((void__)_0))); /*0x375a*/
return 0x8000000000000002uLL; /*0x3770*/
}
if ( !a3 ) /*0x3778*/
{
(String____((void__)_0)) = "(Data != ((void *) 0))"; /*0x377a*/
n645 = 646; /*0x3781*/
goto LABEL_5; /*0x3786*/
}
if ( Assert_23(FormatString_1) > 0xF4240 ) /*0x3796*/
DebugAssert( /*0x37ab*/
"e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c",
0x28Cu,
"(StrnLenS (String, (_gPcd_FixedAtBuild_PcdMaximumUnicodeStringLength) + 1) <= (_gPcd_FixedAtBuild_PcdMaximumUnicodeStringLength))");
if ( Assert_23(FormatString_1) > 0xF4240 ) /*0x37be*/
return 0x8000000000000002uLL; /*0x37be*/
while ( *(_WORD *)FormatString_1 == 32 || *(_WORD *)FormatString_1 == 9 ) /*0x37ca*/
FormatString_1 += 2; /*0x37cc*/
while ( *(_WORD *)FormatString_1 == 48 ) /*0x37e2*/
FormatString_1 += 2; /*0x37da*/
*a3 = 0; /*0x37e4*/
while ( (unsigned __int16)(*(_WORD *)FormatString_1 - 48) <= 9u ) /*0x37f3*/
{
v8 = *(unsigned __int16 *)FormatString_1 - 48; /*0x37fe*/
if ( *a3 > ~v8 / 0xAuLL ) /*0x381b*/
{
*a3 = -1; /*0x382e*/
return 0x8000000000000003uLL; /*0x383c*/
}
FormatString_1 += 2; /*0x3821*/
*a3 = v8 + 10 * *a3; /*0x3829*/
}
return 0; /*0x3845*/
}
// Function: AsciiStrLen @ 0x384c (0x23 bytes)
unsigned __int64 __fastcall AsciiStrLen(unsigned __int8 *FormatString)
{
unsigned __int64 n0xF4240; // rax
n0xF4240 = 0; /*0x384c*/
if ( FormatString && *FormatString ) /*0x3853*/
{
while ( n0xF4240 < 0xF4240 ) /*0x385d*/
{
if ( !FormatString[++n0xF4240] ) /*0x3862*/
return n0xF4240; /*0x3866*/
}
return 1000001; /*0x3869*/
}
return n0xF4240; /*0x3868*/
}
// Function: Assert_27 @ 0x3870 (0x3e bytes)
unsigned __int64 __fastcall Assert_27(unsigned __int64 RegionCount, unsigned int RegionStride)
{
unsigned __int64 RegionStride_1; // rbx
RegionStride_1 = RegionStride; /*0x387a*/
if ( !RegionStride ) /*0x3881*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\DivU64x32.c", 0x2Bu, "Divisor != 0"); /*0x3896*/
return RegionCount / RegionStride_1; /*0x38a8*/
}
// Function: AllocatePool @ 0x38b0 (0x31 bytes)
void *__cdecl AllocatePool(UINTN AllocationSize)
{
__int64 v1; // rax
void *v2; // rcx
void *v4; // [rsp+38h] [rbp+10h] BYREF
v1 = (*(__int64 (__fastcall **)(__int64, UINTN, void **))(BootServices_0 + 64))(4, AllocationSize, &v4); /*0x38c8*/
v2 = v4; /*0x38cb*/
if ( v1 < 0 ) /*0x38d5*/
return 0; /*0x38d5*/
return v2; /*0x38dc*/
}
// Function: AllocateZeroPool @ 0x38e4 (0x44 bytes)
void *__cdecl AllocateZeroPool(UINTN AllocationSize)
{
UINTN Length_1; // rdx
UINTN Length; // rbx
__int64 v3; // rax
UINT8 Value; // r8
void *Buffer; // rcx
void *Buffer_1; // [rsp+40h] [rbp+18h] BYREF
Length = Length_1; /*0x38f6*/
v3 = (*(__int64 (__fastcall **)(UINTN, UINTN, void **))(BootServices_0 + 64))(AllocationSize, Length_1, &Buffer_1); /*0x38f9*/
Buffer = Buffer_1; /*0x38fc*/
if ( v3 < 0 ) /*0x3906*/
Buffer = 0; /*0x3906*/
Buffer_1 = Buffer; /*0x390a*/
if ( Buffer ) /*0x3912*/
return SetMem(Buffer, Length, Value); /*0x391c*/
return Buffer; /*0x3922*/
}
// Function: AllocateCopyPool @ 0x3928 (0xa5 bytes)
void *__fastcall AllocateCopyPool(__int64 a1, UINTN Length, __int64 SourceBuffer)
{
__int64 v5; // rax
void *DestinationBuffer; // rcx
void *DestinationBuffer_1; // [rsp+48h] [rbp+20h] BYREF
if ( !SourceBuffer ) /*0x3942*/
DebugAssert( /*0x3957*/
"e:\\hs\\MdePkg\\Library\\UefiMemoryAllocationLib\\MemoryAllocationLib.c",
0x239u,
"Buffer != ((void *) 0)");
if ( Length > -SourceBuffer ) /*0x3965*/
DebugAssert( /*0x397a*/
"e:\\hs\\MdePkg\\Library\\UefiMemoryAllocationLib\\MemoryAllocationLib.c",
0x23Au,
"AllocationSize <= (0xFFFFFFFFFFFFFFFFULL - (UINTN) Buffer + 1)");
v5 = (*(__int64 (__fastcall **)(__int64, UINTN, void **))(BootServices_0 + 64))(4, Length, &DestinationBuffer_1); /*0x3993*/
DestinationBuffer = DestinationBuffer_1; /*0x3996*/
if ( v5 < 0 ) /*0x399e*/
DestinationBuffer = 0; /*0x399e*/
DestinationBuffer_1 = DestinationBuffer; /*0x39a2*/
if ( DestinationBuffer ) /*0x39aa*/
return CopyMem(DestinationBuffer, (const void *)SourceBuffer, Length); /*0x39b7*/
return DestinationBuffer; /*0x39c7*/
}
// Function: AllocatePoolWithAssert @ 0x39d0 (0x44 bytes)
void AllocatePoolWithAssert()
{
__int64 v0; // rax
v0 = (*(__int64 (**)(void))(BootServices_0 + 72))(); /*0x39db*/
if ( v0 < 0 ) /*0x39e1*/
{
DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v0); /*0x39f2*/
DebugAssert( /*0x3a0a*/
"e:\\hs\\MdePkg\\Library\\UefiMemoryAllocationLib\\MemoryAllocationLib.c",
0x333u,
"!EFI_ERROR (Status)");
}
}
// Function: UnicodeSPrint @ 0x3a14 (0x60 bytes)
UINTN UnicodeSPrint(CHAR16 *StartOfBuffer, UINTN BufferSize, const CHAR16 *FormatString, ...)
{
va_list va; // [rsp+68h] [rbp+20h] BYREF
va_start(va, FormatString);
if ( ((unsigned __int8)StartOfBuffer & 1) != 0 ) /*0x3a31*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BasePrintLib\\PrintLib.c", 0xF0u, "(((UINTN) (StartOfBuffer)) & 0x01) == 0"); /*0x3a46*/
return BasePrintLibSPrintMarker( /*0x3a6c*/
(unsigned __int64)StartOfBuffer,
BufferSize >> 1,
64,
(unsigned __int8 *)FormatString,
va);
}
// Function: StrPad @ 0x3a74 (0x33 bytes)
_BYTE *__fastcall StrPad(_BYTE *StartOfBuffer, _BYTE *StartOfBuffer_1, __int64 i, __int16 n32, __int64 n2)
{
__int64 j; // r10
for ( j = 0; j < i; ++j ) /*0x3a7a*/
{
if ( StartOfBuffer >= StartOfBuffer_1 ) /*0x3a7f*/
break; /*0x3a7f*/
*StartOfBuffer = n32; /*0x3a87*/
if ( n2 != 1 ) /*0x3a8a*/
StartOfBuffer[1] = HIBYTE(n32); /*0x3a93*/
StartOfBuffer += n2; /*0x3a96*/
}
return StartOfBuffer; /*0x3aa6*/
}
// Function: Assert_19 @ 0x3aa8 (0x76 bytes)
_BYTE *__fastcall Assert_19(_BYTE *_r_n, unsigned __int64 a2, __int64 n16)
{
int n16_1; // edi
unsigned __int64 n16_2; // rbp
_BYTE *_r_n_1; // rbx
unsigned __int64 v7; // rtt
n16_1 = n16; /*0x3abc*/
*_r_n = 0; /*0x3abf*/
n16_2 = (unsigned int)n16; /*0x3ac5*/
_r_n_1 = _r_n; /*0x3ac8*/
do /*0x3b04*/
{
if ( !n16_1 ) /*0x3acd*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseLib\\DivU64x32Remainder.c", 0x2Fu, "Divisor != 0"); /*0x3ae0*/
++_r_n_1; /*0x3af1*/
v7 = a2; /*0x3af4*/
a2 /= n16_2; /*0x3af7*/
*_r_n_1 = a0123456789abcd[(unsigned int)(v7 % n16_2)]; /*0x3aff*/
}
while ( a2 ); /*0x3b04*/
return _r_n_1; /*0x3b18*/
}
// Function: BasePrintLibSPrintMarker @ 0x3b20 (0xe0f bytes)
unsigned __int64 __fastcall BasePrintLibSPrintMarker(
unsigned __int64 StartOfBuffer,
unsigned __int64 n0xF4240,
__int16 n64,
unsigned __int8 *FormatString,
va_list va)
{
unsigned __int8 *FormatString_2; // r14
__int64 v6; // r12
unsigned __int64 StartOfBuffer_1; // r13
__int64 v9; // rdi
const CHAR8 *(Buffer____((void__)_0)); // r8
UINTN n578; // rdx
__int64 n0xFFFF; // rdx
_BYTE *StartOfBuffera_1; // rbx
unsigned __int64 v15; // r10
__int64 n2_3; // rsi
int v17; // eax
bool v18; // zf
unsigned __int64 n10; // rcx
unsigned __int8 *FormatString_3; // rdx
unsigned __int8 *FormatString_4; // r8
unsigned __int64 v22; // r9
char v23; // r11
__int64 v24; // rdi
const char *_r_n_1; // rbx
va_list va_1; // r10
unsigned __int8 *FormatString_5; // rdx
int v28; // eax
unsigned __int64 n13_1; // rcx
unsigned __int16 *v30; // rax
int v31; // eax
unsigned __int8 *FormatString_6; // rdx
unsigned __int64 v33... [32067 chars total]
// Function: AsciiSPrint @ 0x4930 (0x22 bytes)
unsigned __int64 AsciiSPrint(_BYTE *_r_n, unsigned __int64 n38, __int16 n64, char *%02d_%02d_%04d__%02d:%02d, ...)
{
va_list va; // [rsp+60h] [rbp+28h] BYREF
va_start(va, %02d_%02d_%04d__%02d:%02d);
return BasePrintLibSPrintMarker((unsigned __int64)_r_n, n38, n64, (unsigned __int8 *)%02d_%02d_%04d__%02d:%02d, va); /*0x494d*/
}
// Function: Assert_17 @ 0x4954 (0x86 bytes)
bool __fastcall Assert_17(__int64 i)
{
__int64 i_1; // rbx
unsigned __int64 v2; // rdi
__int64 j; // rcx
unsigned __int64 n4; // rax
i_1 = i; /*0x495e*/
if ( !i ) /*0x4964*/
DebugAssert( /*0x4977*/
"e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c",
0x3Eu,
"DevicePath != ((void *) 0)");
v2 = 0; /*0x497c*/
for ( j = i_1; ; j = i_1 ) /*0x497e*/
{
if ( Assert_24(j) ) /*0x49b3*/
return Assert_30(i_1) == 4; /*0x49c8*/
n4 = Assert_30(i_1); /*0x4986*/
if ( n4 < 4 ) /*0x498f*/
break; /*0x498f*/
if ( n4 > ~v2 ) /*0x499a*/
break; /*0x499a*/
v2 += n4; /*0x499c*/
if ( v2 > 0xFFFFFFFFFFFFFFFBuLL ) /*0x49a3*/
break; /*0x49a3*/
i_1 = Assert_31(i_1); /*0x49ad*/
}
return 0; /*0x49d0*/
}
// Function: Assert_38 @ 0x49dc (0x2c bytes)
char __fastcall Assert_38(__int64 i)
{
if ( !i ) /*0x49e8*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0x7Eu, "Node != ((void *) 0)"); /*0x49fb*/
return *(_BYTE *)i; /*0x4a02*/
}
// Function: Assert_35 @ 0x4a08 (0x2f bytes)
char __fastcall Assert_35(__int64 i)
{
if ( !i ) /*0x4a14*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0x94u, "Node != ((void *) 0)"); /*0x4a29*/
return *(_BYTE *)(i + 1); /*0x4a31*/
}
// Function: Assert_30 @ 0x4a38 (0x38 bytes)
__int64 __fastcall Assert_30(__int64 i)
{
if ( !i ) /*0x4a44*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0xADu, "Node != ((void *) 0)"); /*0x4a59*/
return (unsigned __int16)Assert_37((unsigned __int16 *)(i + 2)); /*0x4a6a*/
}
// Function: Assert_31 @ 0x4a70 (0x37 bytes)
__int64 __fastcall Assert_31(__int64 i)
{
if ( !i ) /*0x4a7c*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0xC5u, "Node != ((void *) 0)"); /*0x4a91*/
return i + Assert_30(i); /*0x4aa1*/
}
// Function: Assert_29 @ 0x4aa8 (0x39 bytes)
bool __fastcall Assert_29(__int64 i)
{
if ( !i ) /*0x4ab4*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0xE3u, "Node != ((void *) 0)"); /*0x4ac9*/
return Assert_38(i) == 127; /*0x4adb*/
}
// Function: Assert_24 @ 0x4ae4 (0x53 bytes)
char __fastcall Assert_24(__int64 i)
{
char v1; // bl
v1 = 0; /*0x4aee*/
if ( !i ) /*0x4af6*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0xFEu, "Node != ((void *) 0)"); /*0x4b0b*/
if ( Assert_29(i) && Assert_35(i) == -1 ) /*0x4b26*/
return 1; /*0x4b28*/
return v1; /*0x4b31*/
}
// Function: Assert_22 @ 0x4b38 (0x67 bytes)
__int64 __fastcall Assert_22(_WORD *Pool, UINTN AllocationSize)
{
if ( !Pool ) /*0x4b4b*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0x136u, "Node != ((void *) 0)"); /*0x4b60*/
if ( AllocationSize - 4 > 0xFFFB ) /*0x4b6f*/
DebugAssert( /*0x4b84*/
"e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c",
0x137u,
"(Length >= sizeof (EFI_DEVICE_PATH_PROTOCOL)) && (Length < 0x00010000)");
return Assert_28(Pool + 1, AllocationSize); /*0x4b95*/
}
// Function: Assert_25 @ 0x4ba0 (0x40 bytes)
void *__fastcall Assert_25(void *DestinationBuffer)
{
if ( !DestinationBuffer ) /*0x4bac*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiDevicePathLib\\DevicePathUtilities.c", 0x151u, "Node != ((void *) 0)"); /*0x4bc1*/
return CopyMem(DestinationBuffer, &SourceBuffer_, 4u); /*0x4bd6*/
}
// Function: Assert_44 @ 0x4be0 (0x60 bytes)
__int64 __fastcall Assert_44(__int64 i)
{
__int64 v1; // rbx
__int64 i_1; // rsi
__int64 j; // rcx
v1 = 0; /*0x4bef*/
i_1 = i; /*0x4bf4*/
if ( i && Assert_17(i) ) /*0x4bfc*/
{
for ( j = i_1; !Assert_24(j); j = i_1 ) /*0x4c05*/
i_1 = Assert_31(i_1); /*0x4c0f*/
return Assert_30(i_1) + i_1 - i; /*0x4c29*/
}
return v1; /*0x4c3a*/
}
// Function: Assert_42 @ 0x4c40 (0xd6 bytes)
char *__fastcall Assert_42(const void *SourceBuffer, void *SourceBuffer_2)
{
__int64 v2; // rbx
const void *SourceBuffer_1; // rdi
UINTN Length; // rax
__int64 v6; // rcx
UINTN Length_1; // r14
UINTN Length_2; // r15
char *Pool; // rax
char *Pool_1; // rbp
v2 = 0; /*0x4c58*/
SourceBuffer_1 = SourceBuffer; /*0x4c5d*/
if ( !SourceBuffer ) /*0x4c63*/
{
SourceBuffer_1 = &SourceBuffer_; /*0x4c68*/
if ( SourceBuffer_2 ) /*0x4c6f*/
SourceBuffer_1 = SourceBuffer_2; /*0x4c6f*/
SourceBuffer = SourceBuffer_1; /*0x4c73*/
goto LABEL_5; /*0x4c73*/
}
if ( !SourceBuffer_2 ) /*0x4c93*/
{
LABEL_5:
Length = Assert_44((__int64)SourceBuffer); /*0x4c76*/
if ( Length ) /*0x4c7e*/
return (char *)AllocateCopyPool(v6, Length, (__int64)SourceBuffer_1); /*0x4c8b*/
return (char *)v2; /*0x4c8e*/
}
if ( Assert_17((__int64)SourceBuffer) && Assert_17((__int64)SourceBuffer_2) ) /*0x4ca1*/
{
Length_1 = Assert_44((__int64)SourceBuffer_1); /*0x4cb5*/
Length_2 = Assert_44((__int64)SourceBuffer_2); /*0x4cbd*/
Pool = (char *)AllocatePool(Length_1 + Length_2 - 4); /*0x4cc7*/
Pool_1 = Pool; /*0x4ccc*/
if ( Pool ) /*0x4cd2*/
{
Pool_1 = (char *)CopyMem(Pool, SourceBuffer_1, Length_1); /*0x4cef*/
CopyMem(&Pool_1[Length_1 - 4], SourceBuffer_2, Length_2); /*0x4cf2*/
}
return Pool_1; /*0x4cf7*/
}
return (char *)v2; /*0x4d0c*/
}
// Function: Assert_12 @ 0x4d18 (0xb4 bytes)
char *__fastcall Assert_12(const void *SourceBuffer, const void *i)
{
char *v2; // rdi
void *SourceBuffer_1; // rbx
UINTN Length_1; // rax
__int64 v7; // rcx
UINTN Length; // rbp
void *Pool; // rax
void *i_1; // rbx
void *DestinationBuffer; // rax
v2 = 0; /*0x4d2c*/
if ( i ) /*0x4d37*/
{
Length = Assert_30((__int64)i); /*0x4d6c*/
Pool = AllocatePool(Length + 4); /*0x4d73*/
if ( Pool ) /*0x4d7b*/
{
i_1 = CopyMem(Pool, i, Length); /*0x4d8e*/
DestinationBuffer = (void *)Assert_31((__int64)i_1); /*0x4d91*/
Assert_25(DestinationBuffer); /*0x4d99*/
v2 = Assert_42(SourceBuffer, i_1); /*0x4dac*/
AllocatePoolWithAssert(); /*0x4daf*/
}
}
else
{
SourceBuffer_1 = &SourceBuffer_; /*0x4d3c*/
if ( SourceBuffer ) /*0x4d43*/
SourceBuffer_1 = (void *)SourceBuffer; /*0x4d43*/
Length_1 = Assert_44((__int64)SourceBuffer_1); /*0x4d4a*/
if ( Length_1 ) /*0x4d52*/
return (char *)AllocateCopyPool(v7, Length_1, (__int64)SourceBuffer_1); /*0x4d5f*/
}
return v2; /*0x4dc6*/
}
// Function: UefiLibGetConfigTable @ 0x4dcc (0xc4 bytes)
unsigned __int64 __fastcall UefiLibGetConfigTable(GUID *ImageHandle, _QWORD *p_DestinationBuffer)
{
__int64 SystemTable; // rdi
__int64 v5; // rbx
__int64 i; // r14
if ( !ImageHandle ) /*0x4dee*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiLib\\UefiLib.c", 0x61u, "TableGuid != ((void *) 0)"); /*0x4e01*/
if ( !p_DestinationBuffer ) /*0x4e09*/
DebugAssert("e:\\hs\\MdePkg\\Library\\UefiLib\\UefiLib.c", 0x62u, "Table != ((void *) 0)"); /*0x4e1c*/
SystemTable = SystemTable_0; /*0x4e21*/
v5 = 0; /*0x4e28*/
*p_DestinationBuffer = 0; /*0x4e2a*/
if ( !*(_QWORD *)(SystemTable + 104) ) /*0x4e2e*/
return 0x800000000000000EuLL; /*0x4e57*/
for ( i = 0; !CompareGuid(ImageHandle, (const GUID *)(i + *(_QWORD *)(SystemTable + 112))); i += 24 ) /*0x4e34*/
{
if ( (unsigned __int64)++v5 >= *(_QWORD *)(SystemTable + 104) ) /*0x4e55*/
return 0x800000000000000EuLL; /*0x4e55*/
}
*p_DestinationBuffer = *(_QWORD *)(*(_QWORD *)(SystemTable + 112) + 24 * v5 + 16); /*0x4e8b*/
return 0; /*0x4e75*/
}
// Function: PciExpressLibGetPciExpressAddress @ 0x4e90 (0x3a bytes)
__int64 __fastcall PciExpressLibGetPciExpressAddress(__int64 n1024064)
{
if ( (n1024064 & 0xFFFFFFFFF0000000uLL) != 0 ) /*0x4ea0*/
DebugAssert("e:\\hs\\MdePkg\\Library\\SmmPciExpressLib\\PciExpressLib.c", 0x76u, "((Address) & ~0xfffffff) == 0"); /*0x4eb5*/
return n1024064 + qword_D240; /*0x4ec4*/
}
// Function: HobLibGetHobList @ 0x4ecc (0x82 bytes)
__int64 __fastcall HobLibGetHobList(__int64 ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
__int64 DestinationBuffer; // rax
__int64 ConfigTable; // rax
DestinationBuffer = DestinationBuffer_1; /*0x4ed0*/
if ( !DestinationBuffer_1 ) /*0x4eda*/
{
ConfigTable = UefiLibGetConfigTable(&ImageHandle__2, &DestinationBuffer_1); /*0x4eea*/
if ( ConfigTable < 0 ) /*0x4ef2*/
{
DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", ConfigTable); /*0x4f03*/
DebugAssert("e:\\hs\\MdePkg\\Library\\DxeHobLib\\HobLib.c", 0x36u, "!EFI_ERROR (Status)"); /*0x4f1b*/
}
DestinationBuffer = DestinationBuffer_1; /*0x4f20*/
if ( !DestinationBuffer_1 ) /*0x4f2a*/
{
DebugAssert("e:\\hs\\MdePkg\\Library\\DxeHobLib\\HobLib.c", 0x37u, "mHobList != ((void *) 0)"); /*0x4f3d*/
return DestinationBuffer_1; /*0x4f42*/
}
}
return DestinationBuffer; /*0x4f49*/
}
// Function: HobLibGetNextHob @ 0x4f50 (0x58 bytes)
_WORD *__fastcall HobLibGetNextHob(__int16 n11, _WORD *i)
{
_WORD *i_1; // rbx
i_1 = i; /*0x4f5a*/
if ( !i ) /*0x4f63*/
DebugAssert("e:\\hs\\MdePkg\\Library\\DxeHobLib\\HobLib.c", 0x6Cu, "HobStart != ((void *) 0)"); /*0x4f76*/
while ( 1 ) /*0x4f8e*/
{
if ( *i_1 == 0xFFFF ) /*0x4f94*/
return 0; /*0x4f96*/
if ( *i_1 == n11 ) /*0x4f85*/
break; /*0x4f85*/
i_1 = (_WORD *)((char *)i_1 + (unsigned __int16)i_1[1]); /*0x4f8b*/
}
return i_1; /*0x4f9d*/
}
// Function: ReFlashFindFlashDescriptor @ 0x4fa8 (0x4e bytes)
_WORD *__fastcall ReFlashFindFlashDescriptor(const GUID *ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
_WORD *i; // rdx
_WORD *NextHob; // rax
_WORD *NextHob_1; // rbx
for ( i = (_WORD *)HobLibGetHobList((__int64)ImageHandle, SystemTable); /*0x4fba*/
;
i = (_WORD *)((char *)NextHob_1 + (unsigned __int16)NextHob_1[1]) )
{
NextHob = HobLibGetNextHob(4, i); /*0x4fdb*/
NextHob_1 = NextHob; /*0x4fe0*/
if ( !NextHob || CompareGuid(ImageHandle, (const GUID *)(NextHob + 4)) ) /*0x4fc6*/
break; /*0x4fc6*/
}
return NextHob_1; /*0x4ff0*/
}
// Function: Assert_43 @ 0x4ff8 (0x73 bytes)
__int64 __fastcall Assert_43(unsigned int a1)
{
unsigned int v1; // ebx
int n0x400000; // edi
unsigned __int32 v3; // esi
__int64 result; // rax
v1 = a1 >> 22; /*0x5010*/
n0x400000 = a1 & 0x3FFFFF; /*0x5018*/
do /*0x5054*/
{
v3 = n0x400000 + (Assert_33(0x508u) & 0xFFFFFF); /*0x502e*/
n0x400000 = 0x400000; /*0x5030*/
while ( ((v3 - Assert_33(0x508u)) & 0x800000) == 0 ) /*0x504c*/
fn_addr(); /*0x5037*/
result = v1--; /*0x504e*/
}
while ( (_DWORD)result ); /*0x5054*/
return result; /*0x5065*/
}
// Function: Assert_49 @ 0x506c (0x31 bytes)
__int64 __fastcall Assert_49(__int64 n1000000)
{
Assert_43(3579545 * n1000000 / 0xF4240uLL); /*0x508f*/
return n1000000; /*0x5097*/
}
// Function: ReFlashGetLanguage @ 0x50a0 (0x73 bytes)
const char *ReFlashGetLanguage()
{
__int64 en_US; // rax
const char *en_US_1; // rbx
en_US = en_US; /*0x50ac*/
en_US_1 = "en-US"; /*0x50b3*/
if ( (const char *)en_US == "en-US" ) /*0x50ce*/
en_US = 0; /*0x50ce*/
en_US = en_US; /*0x50d9*/
if ( (__int64)GetVariable(L"PlatformLang", &Guid_) >= 0 ) /*0x50f6*/
en_US_1 = (const char *)en_US; /*0x50f6*/
en_US = (__int64)en_US_1; /*0x50fe*/
return en_US_1; /*0x510d*/
}
// Function: HiiParseNameValuePairs @ 0x5114 (0x1a9 bytes)
__int64 __fastcall HiiParseNameValuePairs(__int64 a1, unsigned __int64 *p_n32, CHAR16 *Name)
{
_WORD *v4; // r10
unsigned __int64 i; // r9
__int16 v7; // cx
__int16 v8; // cx
__int16 v9; // cx
__int16 v10; // cx
char v11; // cl
char v12; // cl
CHAR16 v13; // dx
char v14; // cl
unsigned __int8 v15; // cl
CHAR16 v16; // r8
char v17; // cl
unsigned __int8 v18; // cl
CHAR16 v19; // dx
char v20; // cl
unsigned __int8 v21; // cl
v4 = (_WORD *)(a1 + 4); /*0x511c*/
for ( i = 0; ; ++i ) /*0x5125*/
{
v7 = *(v4 - 2); /*0x5128*/
if ( (unsigned __int16)(v7 - 48) > 0x36u ) /*0x5134*/
break; /*0x5134*/
if ( (unsigned __int16)(v7 - 58) <= 6u ) /*0x5141*/
break; /*0x5141*/
if ( (unsigned __int16)(v7 - 71) <= 0x19u ) /*0x514f*/
break; /*0x514f*/
v8 = *(v4 - 1); /*0x5155*/
if ( (unsigned __int16)(v8 - 48) > 0x36u ) /*0x5161*/
break; /*0x5161*/
if ( (unsigned __int16)(v8 - 58) <= 6u ) /*0x516e*/
break; /*0x516e*/
if ( (unsigned __int16)(v8 - 71) <= 0x19u ) /*0x517c*/
break; /*0x517c*/
v9 = *v4; /*0x5182*/
if ( (unsigned __int16)(*v4 - 48) > 0x36u ) /*0x518d*/
break; /*0x518d*/
if ( (unsigned __int16)(v9 - 58) <= 6u ) /*0x519a*/
break; /*0x519a*/
if ( (unsigned __int16)(v9 - 71) <= 0x19u ) /*0x51a8*/
break; /*0x51a8*/
v10 = v4[1]; /*0x51ae*/
if ( (unsigned __int16)(v10 - 48) > 0x36u /*0x51e4*/
|| (unsigned __int16)(v10 - 58) <= 6u
|| (unsigned __int16)(v10 - 71) <= 0x19u
|| i >= *p_n32 - 1 )
{
break; /*0x51e4*/
}
v11 = *((_BYTE *)v4 - 4); /*0x51ea*/
if ( (unsigned __int8)(v11 - 48) > 9u ) /*0x51f3*/
{
if ( (unsigned __int8)(v11 - 65) > 5u ) /*0x51ff*/
v12 = v11 - 87; /*0x5206*/
else
v12 = v11 - 55; /*0x5201*/
}
else
{
v12 = v11 - 48; /*0x51f5*/
}
v13 = 16 * (v12 & 0xF); /*0x520f*/
Name[i] = v13; /*0x5213*/
v14 = *((_BYTE *)v4 - 2); /*0x5218*/
if ( (unsigned __int8)(v14 - 48) > 9u ) /*0x5221*/
{
if ( (unsigned __int8)(v14 - 65) > 5u ) /*0x522d*/
v15 = v14 - 87; /*0x5234*/
else
v15 = v14 - 55; /*0x522f*/
}
else
{
v15 = v14 - 48; /*0x5223*/
}
v16 = 16 * (v13 | v15); /*0x523f*/
Name[i] = v16; /*0x5244*/
v17 = *(_BYTE *)v4; /*0x5249*/
if ( (unsigned __int8)(*(_BYTE *)v4 - 48) > 9u ) /*0x5251*/
{
if ( (unsigned __int8)(v17 - 65) > 5u ) /*0x525d*/
v18 = v17 - 87; /*0x5264*/
else
v18 = v17 - 55; /*0x525f*/
}
else
{
v18 = v17 - 48; /*0x5253*/
}
v19 = 16 * (v16 | v18); /*0x526e*/
Name[i] = v19; /*0x5272*/
v20 = *((_BYTE *)v4 + 2); /*0x5277*/
if ( (unsigned __int8)(v20 - 48) > 9u ) /*0x5280*/
{
if ( (unsigned __int8)(v20 - 65) > 5u ) /*0x528c*/
v21 = v20 - 87; /*0x5293*/
else
v21 = v20 - 55; /*0x528e*/
}
else
{
v21 = v20 - 48; /*0x5282*/
}
v4 += 4; /*0x5299*/
Name[i] = v19 | v21; /*0x52a0*/
}
*p_n32 = i; /*0x52ad*/
Name[i] = 0; /*0x52b7*/
return 0; /*0x52bc*/
}
// Function: HiiParseGuidString @ 0x52c0 (0x7d bytes)
__int64 __fastcall HiiParseGuidString(__int64 a1, unsigned __int64 n32, _BYTE *n4)
{
unsigned __int64 n32_1; // r9
__int64 v5; // r11
__int64 n32_2; // rbx
char v7; // dl
char v8; // dl
__int64 result; // rax
char v10; // cl
n32_1 = 0; /*0x52c5*/
v5 = a1; /*0x52cb*/
if ( n32 ) /*0x52d1*/
{
n32_2 = n32 - 1; /*0x52d3*/
do /*0x5335*/
{
if ( n32_1 == n32_2 ) /*0x52da*/
{
LOBYTE(a1) = *(_BYTE *)(v5 + 2 * n32_1); /*0x52dc*/
v7 = 0; /*0x52e0*/
}
else
{
v8 = *(_BYTE *)(v5 + 2 * n32_1); /*0x52e4*/
if ( (unsigned __int8)(v8 - 48) > 9u ) /*0x52ed*/
{
if ( (unsigned __int8)(v8 - 65) > 5u ) /*0x52f9*/
v7 = v8 - 87; /*0x5300*/
else
v7 = v8 - 55; /*0x52fb*/
}
else
{
v7 = v8 - 48; /*0x52ef*/
}
LOBYTE(a1) = *(_BYTE *)(v5 + 2 * n32_1 + 2); /*0x5303*/
}
result = (unsigned int)(a1 - 48); /*0x5308*/
if ( (unsigned __int8)(a1 - 48) > 9u ) /*0x530d*/
{
result = (unsigned int)(a1 - 65); /*0x5314*/
if ( (unsigned __int8)(a1 - 65) > 5u ) /*0x5319*/
v10 = a1 - 87; /*0x5320*/
else
v10 = a1 - 55; /*0x531b*/
}
else
{
v10 = a1 - 48; /*0x530f*/
}
n32_1 += 2LL; /*0x5326*/
*n4++ = v10 | (16 * v7); /*0x532c*/
}
while ( n32_1 < n32 ); /*0x5335*/
}
return result; /*0x533c*/
}
// Function: HiiParseRoutingData @ 0x5340 (0x165 bytes)
__int64 __fastcall HiiParseRoutingData(__int16 *a1, __int64 a2)
{
__int64 v3; // rbx
__int16 *v5; // rsi
__int16 i; // ax
__int16 *v7; // rdi
unsigned __int64 n32; // rsi
__int16 *j; // rdx
__int16 v10; // cx
_BYTE *n4_1; // rbx
__int64 result; // rax
_BYTE *n4_2; // rcx
__int64 v14; // rax
unsigned __int64 v15; // rbx
_BYTE *n4; // [rsp+40h] [rbp+8h] BYREF
_BYTE *n4_3; // [rsp+50h] [rbp+18h] BYREF
v3 = 0; /*0x5358*/
n4 = 0; /*0x535b*/
v5 = a1; /*0x5363*/
do /*0x539f*/
{
for ( i = *v5; i != 38 && i; i = a1[v3] ) /*0x5366*/
++v3; /*0x5370*/
if ( !a1[v3] ) /*0x5382*/
return 0x800000000000000EuLL; /*0x5488*/
v5 = &a1[++v3]; /*0x5398*/
}
while ( StrnCmp((unsigned __int64)v5, L"PATH=", 0xAu) ); /*0x539f*/
v7 = &a1[v3]; /*0x53a9*/
n32 = 0; /*0x53ad*/
for ( j = v7 + 5; ; ++j ) /*0x53b0*/
{
v10 = *j; /*0x53b4*/
if ( (unsigned __int16)(*j - 48) > 0x36u /*0x53d1*/
|| (unsigned __int16)(v10 - 58) <= 6u
|| (unsigned __int16)(v10 - 71) <= 0x19u )
{
break; /*0x53d1*/
}
++n32; /*0x53d3*/
}
n4_1 = (_BYTE *)(n32 >> 1); /*0x53f0*/
result = (*(__int64 (__fastcall **)(__int64, unsigned __int64, _BYTE **))(BootServices + 64))(4, n32 >> 1, &n4); /*0x53f6*/
if ( result >= 0 ) /*0x53fc*/
{
HiiParseGuidString((__int64)(v7 + 5), n32, n4); /*0x5411*/
result = 0; /*0x5416*/
}
else
{
n4_1 = n4; /*0x53fe*/
}
if ( result >= 0 ) /*0x541c*/
{
n4_2 = n4; /*0x541e*/
if ( n4 /*0x5442*/
&& (unsigned __int64)n4_1 >= 4
&& *((unsigned __int16 *)n4 + 1) <= (unsigned __int64)n4_1
&& ((unsigned __int8)(*n4 - 1) <= 4u || *n4 == 127) )
{
n4_3 = n4; /*0x5450*/
v14 = (*(__int64 (__fastcall **)(void *, _BYTE **, __int64))(BootServices + 184))(&unk_CB58, &n4_3, a2); /*0x545f*/
n4_2 = n4; /*0x5465*/
v15 = v14; /*0x546a*/
}
else
{
v15 = 0x800000000000000EuLL; /*0x546f*/
}
(*(void (__fastcall **)(_BYTE *))(BootServices + 72))(n4_2); /*0x5480*/
return v15; /*0x5483*/
}
return result; /*0x549c*/
}
// Function: ReFlashStripHiiConfigValues @ 0x54a8 (0xd6 bytes)
__int64 __fastcall ReFlashStripHiiConfigValues(char *ReservedPool, UINTN BufferSize)
{
__int64 v3; // rbx
__int64 v4; // rbp
__int16 n38_1; // di
char *ReservedPool_1; // rax
__int16 n38; // ax
char *src; // [rsp+40h] [rbp+8h] BYREF
v3 = 0; /*0x54cc*/
v4 = 0; /*0x54cf*/
(*(void (__fastcall **)(__int64, UINTN, char **))(BootServices + 64))(4, BufferSize, &src); /*0x54d6*/
n38_1 = *(_WORD *)ReservedPool; /*0x54d9*/
if ( *(_WORD *)ReservedPool ) /*0x54d9*/
{
ReservedPool_1 = ReservedPool; /*0x54e1*/
do /*0x5532*/
{
if ( n38_1 == 38 && !StrnCmp((unsigned __int64)(ReservedPool_1 + 2), L"VALUE=", 0xCu) ) /*0x54fb*/
{
do /*0x550a*/
{
++v3; /*0x550c*/
n38 = *(_WORD *)&ReservedPool[2 * v3]; /*0x550f*/
}
while ( n38 != 38 && n38 ); /*0x550a*/
n38_1 = *(_WORD *)&ReservedPool[2 * v3]; /*0x5519*/
if ( !n38_1 ) /*0x5520*/
break; /*0x5520*/
}
++v3; /*0x5527*/
*(_WORD *)&src[2 * v4] = n38_1; /*0x552a*/
ReservedPool_1 = &ReservedPool[2 * v3]; /*0x552e*/
n38_1 = *(_WORD *)ReservedPool_1; /*0x5532*/
++v4; /*0x5535*/
}
while ( *(_WORD *)ReservedPool_1 ); /*0x5532*/
}
*(_WORD *)&src[2 * v4] = 0; /*0x554d*/
InternalCopyMemOverlap(ReservedPool, src, 2 * v4 + 2); /*0x5557*/
return (*(__int64 (__fastcall **)(char *))(BootServices + 72))(src); /*0x5575*/
}
// Function: HiiExtractConfigCallback @ 0x5580 (0x2c1 bytes)
void *__fastcall HiiExtractConfigCallback(__int64 a1, unsigned __int64 DestMax, unsigned __int64 *a3, __int64 a4)
{
void *result; // rax
_WORD *v8; // rbx
UINTN AllocationSize; // rbx
const void *Buffer; // rdx
CHAR16 *CopyPool; // rax
UINTN CopyPool_1; // r14
UINTN v13; // rax
const void *Buffer_1; // rdx
CHAR16 *Destination; // rax
const CHAR16 *Source; // r8
CHAR16 *Destination_1; // r12
const CHAR16 *Source_1; // r8
__int64 v19; // rbx
__int64 v20; // r15
UINTN v21; // rax
__int64 BootServices; // rdx
__int64 v23; // [rsp+30h] [rbp-89h] BYREF
__int64 v24; // [rsp+38h] [rbp-81h] BYREF
EFI_GUID n4; // [rsp+40h] [rbp-79h] BYREF
CHAR16 Name[80]; // [rsp+50h] [rbp-69h] BYREF
unsigned __int64 p_n32; // [rsp+128h] [rbp+6Fh] BYREF
v23 = 0; /*0x55a9*/
if ( !DestMax ) /*0x55b7*/
{
*a3 = 0; /*0x55b9*/
return (void *)0x8000000000000002LL; /*0x55c6*/
}
result = (void *)(*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CA80, 0, &v24); /*0x55e0*/
if ( (__int64)result >= 0 )
{
if ( StrnCmp(DestMax, L"GUID=", 0xAu) ) /*0x5602*/
{
LABEL_6:
*a3 = DestMax; /*0x560c*/
return (void *)0x8000000000000002LL; /*0x560f*/
}
p_n32 = 32; /*0x561d*/
HiiParseGuidString(DestMax + 10, 0x20u, &n4); /*0x5625*/
v8 = (_WORD *)(DestMax + 74); /*0x562a*/
if ( *(_WORD *)(DestMax + 74) != 38 )
{
DebugPrintErrorLevel(0x80000000LL, "HII Extract Config: Guid extraction failed\n");
goto LABEL_6; /*0x564a*/
}
if ( StrnCmp(DestMax + 76, L"NAME=", 0xAu) ) /*0x565a*/
{
LABEL_10:
*a3 = (unsigned __int64)v8; /*0x5664*/
return (void *)0x8000000000000002LL; /*0x5667*/
}
p_n32 = 80; /*0x566f*/
HiiParseNameValuePairs(DestMax + 86, &p_n32, Name); /*0x5686*/
v8 = (_WORD *)(DestMax + 86 + 8 * p_n32); /*0x568f*/
if ( *v8 != 38 )
{
DebugPrintErrorLevel(0x80000000LL, "HII Extract Config: Name extraction failed\n");
*a3 = DestMax + 74; /*0x56aa*/
return (void *)0x8000000000000002LL; /*0x56ad*/
}
p_n32 = 0; /*0x56b7*/
result = GetVariable(Name, &n4); /*0x56cf*/
if ( (__int64)result >= 0 ) /*0x56d7*/
{
while ( *++v8 != 38 ) /*0x56e6*/
{
if ( !*v8 ) /*0x56e4*/
{
AllocationSize = 2 * StrLen(L"&OFFSET=0&WIDTH=") + 18; /*0x5709*/
CopyPool = (CHAR16 *)AllocateCopyPool(AllocationSize, Buffer); /*0x5714*/
CopyPool_1 = (UINTN)CopyPool; /*0x5719*/
if ( !CopyPool ) /*0x571f*/
return (void *)0x8000000000000009LL; /*0x571f*/
UnicodeSPrintAsciiFormat(CopyPool, AllocationSize, L"&OFFSET=0&WIDTH=%x", p_n32, &v23); /*0x5741*/
v13 = StrLen((const CHAR16 *)DestMax); /*0x5749*/
Destination = (CHAR16 *)AllocateCopyPool(AllocationSize + 2 * (v13 + 1), Buffer_1); /*0x5755*/
Destination_1 = Destination; /*0x575a*/
if ( !Destination ) /*0x5760*/
return (void *)0x8000000000000009LL; /*0x572b*/
StrCpyS(Destination, DestMax, Source); /*0x5768*/
StrCpyS(Destination_1, CopyPool_1, Source_1); /*0x5773*/
v19 = v23; /*0x5780*/
v20 = (*(__int64 (__fastcall **)(__int64, CHAR16 *, __int64, unsigned __int64, __int64, unsigned __int64 *))(v24 + 24))( /*0x579f*/
v24,
Destination_1,
v23,
p_n32,
a4,
a3);
v21 = StrLen((const CHAR16 *)DestMax); /*0x57a2*/
BootServices = BootServices; /*0x57a7*/
*a3 = DestMax + 2 * v21; /*0x57b2*/
(*(void (__fastcall **)(UINTN))(BootServices + 72))(CopyPool_1); /*0x57b8*/
(*(void (__fastcall **)(CHAR16 *))(BootServices + 72))(Destination_1); /*0x57c5*/
goto LABEL_24; /*0x57c8*/
}
}
if ( StrnCmp((unsigned __int64)(v8 + 1), L"OFFSET=", 0xEu) ) /*0x57db*/
goto LABEL_10; /*0x57e3*/
v19 = v23; /*0x57f1*/
v20 = (*(__int64 (__fastcall **)(__int64, unsigned __int64, __int64, unsigned __int64, __int64, unsigned __int64 *))(v24 + 24))( /*0x580d*/
v24,
DestMax,
v23,
p_n32,
a4,
a3);
LABEL_24:
(*(void (__fastcall **)(__int64))(BootServices + 72))(v19); /*0x5810*/
return (void *)v20; /*0x581d*/
}
else
{
*a3 = DestMax; /*0x56d9*/
}
}
return result; /*0x5834*/
}
// Function: HiiRouteConfigCallback @ 0x5844 (0x26a bytes)
__int64 __fastcall HiiRouteConfigCallback(__int64 a1, __int16 *a2, __int16 **a3)
{
__int64 result; // rax
__int16 *v6; // rbx
__int64 v7; // r8
unsigned __int64 p_n32_1; // r14
__int64 v9; // [rsp+30h] [rbp-89h] BYREF
__int64 v10; // [rsp+38h] [rbp-81h] BYREF
EFI_GUID n4; // [rsp+40h] [rbp-79h] BYREF
_BYTE v12[16]; // [rsp+50h] [rbp-69h] BYREF
CHAR16 Name[80]; // [rsp+60h] [rbp-59h] BYREF
unsigned int n3; // [rsp+128h] [rbp+6Fh]
unsigned __int64 p_n32; // [rsp+138h] [rbp+7Fh] BYREF
v9 = 0; /*0x585e*/
if ( !a2 ) /*0x586d*/
{
*a3 = 0; /*0x586f*/
return 0x8000000000000002uLL; /*0x587c*/
}
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CA80, 0, &v10); /*0x5896*/
if ( result < 0 ) /*0x589f*/
return result; /*0x589f*/
if ( StrnCmp((unsigned __int64)a2, L"GUID=", 0xAu) ) /*0x58b8*/
{
*a3 = a2; /*0x58c2*/
return 0x8000000000000002uLL; /*0x58c5*/
}
if ( HiiParseRoutingData(a2, (__int64)v12) < 0 ) /*0x58d6*/
return 0x800000000000000EuLL; /*0x58e2*/
p_n32 = 32; /*0x58f3*/
HiiParseGuidString((__int64)(a2 + 5), 0x20u, &n4); /*0x58fb*/
v6 = a2 + 37; /*0x5900*/
if ( a2[37] != 38 )
{
DebugPrintErrorLevel(0x80000000LL, "HII Route Config: Guid extraction failed\n");
LABEL_11:
*a3 = v6; /*0x591b*/
return 0x8000000000000002uLL; /*0x591e*/
}
if ( StrnCmp((unsigned __int64)(a2 + 38), L"NAME=", 0xAu) ) /*0x5931*/
goto LABEL_11; /*0x5939*/
p_n32 = 80; /*0x593f*/
HiiParseNameValuePairs((__int64)(a2 + 43), &p_n32, Name); /*0x5952*/
v6 = &a2[4 * p_n32 + 43]; /*0x595b*/
if ( *v6 != 38 )
{
DebugPrintErrorLevel(0x80000000LL, "HII Route Config: Name extraction failed\n");
goto LABEL_11; /*0x596c*/
}
p_n32 = 0; /*0x596e*/
if ( (__int64)GetVariable(Name, &n4) >= 0 ) /*0x5995*/
{
v7 = v9; /*0x59c3*/
p_n32_1 = p_n32; /*0x59c8*/
}
else
{
v7 = 0; /*0x59ab*/
n3 = 3; /*0x59ae*/
p_n32_1 = 0; /*0x59b5*/
v9 = 0; /*0x59b8*/
p_n32 = 0; /*0x59bd*/
}
for ( result = (*(__int64 (__fastcall **)(__int64, __int16 *, __int64, unsigned __int64 *, __int16 **))(v10 + 32))( /*0x59e0*/
v10,
a2,
v7,
&p_n32,
a3);
;
result = (*(__int64 (__fastcall **)(__int64, __int16 *, __int64, unsigned __int64 *, __int16 **))(v10 + 32))(
v10,
a2,
v9,
&p_n32,
a3) )
{
if ( result == 0x8000000000000007uLL ) /*0x59ff*/
goto LABEL_22; /*0x59ff*/
if ( result != 0x8000000000000002uLL ) /*0x5a04*/
break; /*0x5a04*/
if ( v9 ) /*0x5a09*/
return result; /*0x5a09*/
LABEL_22:
if ( v9 ) /*0x5a12*/
(*(void (__fastcall **)(__int64))(BootServices + 72))(v9); /*0x5a1b*/
result = (*(__int64 (__fastcall **)(__int64, unsigned __int64, __int64 *))(BootServices + 64))(4, p_n32, &v9); /*0x5a33*/
if ( result < 0 ) /*0x5a39*/
return result; /*0x5a39*/
p_n32_1 = p_n32; /*0x5a4c*/
}
if ( result >= 0 ) /*0x5a60*/
{
(*(void (__fastcall **)(CHAR16 *, EFI_GUID *, _QWORD, unsigned __int64, __int64))(RuntimeServices + 88))( /*0x5a82*/
Name,
&n4,
n3,
p_n32_1,
v9);
(*(void (__fastcall **)(__int64))(BootServices + 72))(v9); /*0x5a91*/
return 0; /*0x5a94*/
}
return result; /*0x5aa6*/
}
// Function: ReFlashInstallProtocol @ 0x5abc (0x1af bytes)
__int64 ReFlashInstallProtocol(__int64 a1, __int64 a2, __int64 a3, ...)
{
__int64 v3; // rdi
_UNKNOWN **v4; // rbx
_UNKNOWN **v7; // rdi
_QWORD *v8; // rax
_QWORD *v9; // rax
_QWORD *v10; // rax
__int64 v11; // rax
__int64 v12; // rcx
__int64 v13; // rdx
__int64 v14; // rax
__int128 v15; // xmm0
__int64 v16; // rbx
__int64 result; // rax
__int64 v18; // [rsp+70h] [rbp+18h] BYREF
__int64 v19; // [rsp+78h] [rbp+20h] BYREF
va_list va; // [rsp+78h] [rbp+20h]
_QWORD *v21; // [rsp+80h] [rbp+28h]
_QWORD *v22; // [rsp+88h] [rbp+30h]
va_list va1; // [rsp+90h] [rbp+38h] BYREF
va_start(va1, a3);
va_start(va, a3);
v19 = va_arg(va1, _QWORD); /*0x5abc*/
v21 = va_arg(va1, _QWORD *); /*0x5abc*/
v22 = va_arg(va1, _QWORD *); /*0x5abc*/
v18 = 0; /*0x5ae5*/
v3 = 0; /*0x5ae9*/
v4 = &off_C8D0; /*0x5aec*/
do /*0x5b1c*/
{
if ( *v4 && !StrnCmp(a2 + 2, *v4, 16) ) /*0x5b07*/
break; /*0x5b0f*/
++v3; /*0x5b11*/
v4 += 4; /*0x5b14*/
}
while ( !v3 ); /*0x5b1c*/
if ( v3 == 1 ) /*0x5b29*/
{
v7 = (_UNKNOWN **)&unk_CB38; /*0x5b2b*/
}
else
{
v7 = &off_C8D0 + 4 * v3; /*0x5b34*/
v8 = v7[1]; /*0x5b37*/
if ( v8 ) /*0x5b3e*/
{
if ( !*v8 ) /*0x5b4d*/
*v8 = HiiExtractConfigCallback; /*0x5b59*/
v9 = v7[1]; /*0x5b5c*/
if ( !v9[1] ) /*0x5b60*/
v9[1] = HiiRouteConfigCallback; /*0x5b6d*/
v10 = v7[1]; /*0x5b71*/
if ( !v10[2] ) /*0x5b75*/
v10[2] = HiiUnsupportedCallback; /*0x5b82*/
}
else
{
v7[1] = off_CA40; /*0x5b47*/
}
}
v11 = (*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices + 152))( /*0x5b9d*/
*(_QWORD *)(a1 + 24),
&unk_CB78,
(__int64 *)va);
v12 = v19; /*0x5ba3*/
v13 = *(_QWORD *)(a1 + 32); /*0x5bab*/
if ( v11 < 0 ) /*0x5baf*/
v12 = 0; /*0x5baf*/
v19 = v12; /*0x5bb3*/
v14 = ReFlashFlashMapAppend(v12, v13); /*0x5bb8*/
v15 = *(_OWORD *)(a2 + 2); /*0x5bbd*/
v19 = v14; /*0x5bc8*/
xmmword_CA5C = v15; /*0x5bd0*/
v16 = ReFlashFlashMapAppend(v14, &unk_CA58); /*0x5be4*/
(*(void (__fastcall **)(__int64))(BootServices + 72))(v19); /*0x5bec*/
result = (*(__int64 (__fastcall **)(__int64 *, void *, __int64, void *, void *, _QWORD))(BootServices + 328))( /*0x5c1b*/
&v18,
&unk_CB78,
v16,
&unk_CA90,
v7[1],
0);
if ( result >= 0 ) /*0x5c24*/
{
if ( v22 ) /*0x5c31*/
*v22 = v18; /*0x5c38*/
if ( v21 ) /*0x5c46*/
{
if ( v7 == (_UNKNOWN **)&unk_CB38 ) /*0x5c4b*/
v7 = 0; /*0x5c4b*/
*v21 = v7; /*0x5c4f*/
}
return 0; /*0x5c52*/
}
return result; /*0x5c5e*/
}
// Function: InternalGetBestLanguage @ 0x5c6c (0x135 bytes)
char *__fastcall InternalGetBestLanguage(char *PackageList, char *Language, char *en_US, char *a4)
{
char *Language_2; // rdx
char *PackageList_4; // rbx
char **p_Language; // r10
char *PackageList_1; // rcx
char *PackageList_3; // rsi
char v11; // r11
char *PackageList_2; // rdi
char *Language_3; // r8
char n59; // al
char *PackageList_5; // rax
unsigned __int64 n8; // rbx
char *ReservedPool; // rax
char *ReservedPool_1; // rdi
char *PackageList_6; // [rsp+20h] [rbp-38h]
char *Language_1; // [rsp+68h] [rbp+10h] BYREF
char *en_US_1; // [rsp+70h] [rbp+18h]
char *v22; // [rsp+78h] [rbp+20h]
Language_1 = Language; /*0x5c73*/
en_US_1 = en_US; /*0x5c77*/
v22 = a4; /*0x5c7b*/
if ( !PackageList ) /*0x5c8e*/
return 0; /*0x5c8e*/
Language_2 = Language_1; /*0x5c97*/
PackageList_4 = PackageList_6; /*0x5c9c*/
if ( Language_1 ) /*0x5ca4*/
{
p_Language = &Language_1; /*0x5caa*/
while ( 1 ) /*0x5cb5*/
{
PackageList_1 = PackageList; /*0x5cb5*/
PackageList_3 = 0; /*0x5cb8*/
do /*0x5d3f*/
{
v11 = 0; /*0x5cba*/
PackageList_2 = PackageList_1; /*0x5cbd*/
Language_3 = Language_2; /*0x5cc0*/
if ( *Language_2 ) /*0x5cc3*/
{
n59 = *Language_2; /*0x5cc8*/
do /*0x5cec*/
{
if ( n59 == 59 ) /*0x5ccc*/
break; /*0x5ccc*/
if ( n59 == 45 ) /*0x5cd4*/
v11 = 1; /*0x5cd4*/
if ( n59 != *PackageList_1 ) /*0x5cda*/
break; /*0x5cda*/
if ( !*PackageList_1 ) /*0x5cdf*/
goto LABEL_19; /*0x5cdf*/
if ( *PackageList_1 == 59 ) /*0x5ce4*/
break; /*0x5ce4*/
++Language_3; /*0x5ce6*/
++PackageList_1; /*0x5ce9*/
n59 = *Language_3; /*0x5cec*/
}
while ( *Language_3 ); /*0x5cec*/
}
while ( *PackageList_1 && *PackageList_1 != 59 ) /*0x5cf7*/
++PackageList_1; /*0x5cf9*/
LABEL_19:
if ( (v11 || !*Language_3 || *Language_3 == 59) && Language_3 - Language_2 > 0 ) /*0x5d1b*/
{
PackageList_3 = PackageList_2; /*0x5d1d*/
PackageList_4 = PackageList_1; /*0x5d20*/
}
PackageList_5 = PackageList_1 + 1; /*0x5d26*/
if ( *PackageList_1 != 59 ) /*0x5d2a*/
PackageList_5 = PackageList_1; /*0x5d2a*/
PackageList_1 = PackageList_5; /*0x5d2e*/
}
while ( *PackageList_5 && *Language_3 && *Language_3 != 59 ); /*0x5d3f*/
if ( PackageList_3 ) /*0x5d48*/
break; /*0x5d48*/
Language_2 = *++p_Language; /*0x5d4e*/
if ( !*p_Language ) /*0x5d4e*/
goto LABEL_33; /*0x5d54*/
}
}
else
{
PackageList_3 = PackageList_6; /*0x5d5c*/
LABEL_33:
if ( !PackageList_3 ) /*0x5d64*/
return 0; /*0x5d64*/
}
n8 = PackageList_4 - PackageList_3; /*0x5d6a*/
ReservedPool = (char *)AllocateReservedPool(n8 + 1); /*0x5d71*/
ReservedPool_1 = ReservedPool; /*0x5d76*/
if ( !ReservedPool ) /*0x5d7c*/
return 0; /*0x5c92*/
InternalCopyMemOverlap(ReservedPool, PackageList_3, n8); /*0x5d8b*/
ReservedPool_1[n8] = 0; /*0x5d93*/
return ReservedPool_1; /*0x5d97*/
}
// Function: ReFlashGetPackageList @ 0x5da4 (0xbf bytes)
void *__fastcall ReFlashGetPackageList(__int64 a1)
{
__int64 v3; // rax
void *ReservedPool; // rbx
UINTN AllocationSize; // [rsp+30h] [rbp+8h] BYREF
AllocationSize = 0; /*0x5dae*/
if ( !a1 ) /*0x5dba*/
return 0; /*0x5dba*/
v3 = qword_D2E0; /*0x5dc3*/
if ( !qword_D2E0 ) /*0x5dcd*/
{
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CA70, 0, &qword_D2E0) < 0 ) /*0x5def*/
return 0; /*0x5dbe*/
v3 = qword_D2E0; /*0x5df1*/
}
if ( (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, UINTN *))(v3 + 24))(v3, a1, 0, &AllocationSize) != 0x8000000000000005uLL ) /*0x5e16*/
return 0; /*0x5e16*/
ReservedPool = AllocateReservedPool(AllocationSize); /*0x5e37*/
if ( (*(__int64 (__fastcall **)(__int64, __int64, void *, UINTN *))(qword_D2E0 + 24))( /*0x5e41*/
qword_D2E0,
a1,
ReservedPool,
&AllocationSize) < 0 )
{
(*(void (__fastcall **)(void *))(BootServices + 72))(ReservedPool); /*0x5e4d*/
return 0; /*0x5e50*/
}
return ReservedPool; /*0x5e5d*/
}
// Function: HiiSetStringNew @ 0x5e64 (0xb6 bytes)
__int64 __fastcall HiiSetStringNew(
char *i,
__int64 a2,
__int64 a3,
unsigned __int16 n48,
__int64 *p_n29,
__int64 DmiVar%02x%04x%02x%02x)
{
__int64 v7; // rsi
char *j; // rbx
char v10; // di
__int64 result; // rax
v7 = qword_D2E0; /*0x5e86*/
if ( !*i ) /*0x5e7f*/
return a2; /*0x5efc*/
do /*0x5ef5*/
{
for ( j = i; *j != 59; ++j ) /*0x5ea8*/
{
if ( !*j ) /*0x5eaa*/
break; /*0x5ead*/
}
v10 = *j; /*0x5ec0*/
*j = 0; /*0x5ed7*/
result = (*(__int64 (__fastcall **)(__int64, char *, __int64, _QWORD, __int64, __int64 *, _QWORD))(v7 + 8))( /*0x5eda*/
v7,
i,
a3,
n48,
DmiVar%02x%04x%02x%02x,
p_n29,
0);
if ( result != 0x8000000000000020uLL ) /*0x5eea*/
break; /*0x5eea*/
if ( !v10 ) /*0x5eef*/
break; /*0x5eef*/
i = j + 1; /*0x5ef1*/
}
while ( j[1] ); /*0x5ef5*/
return result; /*0x5f0e*/
}
// Function: ReFlashInternalGetHiiString @ 0x5f1c (0x142 bytes)
__int64 __fastcall ReFlashInternalGetHiiString(__int64 a1, __int64 n48, __int64 *p_n29, __int64 DmiVar%02x%04x%02x%02x)
{
unsigned __int16 n48_1; // r15
char *Language; // rbx
char *PackageList; // rax
char *PackageList_1; // rdi
char *BestLanguage; // r12
__int64 v13; // rbx
__int64 v14; // rdx
n48_1 = n48; /*0x5f47*/
if ( !qword_D2E0 /*0x5f70*/
&& (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CA70, 0, &qword_D2E0) < 0 )
{
return 0x800000000000000EuLL; /*0x5f70*/
}
Language = (char *)ReFlashGetLanguage(); /*0x5f89*/
PackageList = (char *)ReFlashGetPackageList(a1); /*0x5f8c*/
PackageList_1 = PackageList; /*0x5f91*/
if ( !PackageList ) /*0x5f97*/
return 0x800000000000000EuLL; /*0x5f72*/
BestLanguage = InternalGetBestLanguage(PackageList, Language, "en-US", "en-US"); /*0x5fb9*/
if ( BestLanguage ) /*0x5fbf*/
{
v13 = (*(__int64 (__fastcall **)(__int64, char *, __int64, _QWORD, __int64, __int64 *, _QWORD))(qword_D2E0 + 8))( /*0x5ffe*/
qword_D2E0,
BestLanguage,
a1,
n48_1,
DmiVar%02x%04x%02x%02x,
p_n29,
0);
(*(void (__fastcall **)(char *))(BootServices + 72))(BestLanguage); /*0x6001*/
if ( v13 == 0x8000000000000020uLL ) /*0x6011*/
v13 = HiiSetStringNew(PackageList_1, v14, a1, n48_1, p_n29, DmiVar%02x%04x%02x%02x); /*0x602c*/
}
else
{
v13 = 0x800000000000000EuLL; /*0x5fc1*/
}
(*(void (__fastcall **)(char *))(BootServices + 72))(PackageList_1); /*0x6039*/
return v13; /*0x6053*/
}
// Function: ReFlashSetProgress @ 0x6060 (0x145 bytes)
__int64 __fastcall ReFlashSetProgress(__int64 a1, unsigned __int16 n47, wchar_t *________________)
{
__int64 v4; // rax
__int64 result; // rax
_BYTE *ReservedPool; // rdi
__int64 v9; // rsi
_BYTE *i; // rbx
_BYTE *i_1; // r9
char v12; // r14
UINTN AllocationSize; // [rsp+78h] [rbp+20h] BYREF
AllocationSize = 0; /*0x6076*/
v4 = qword_D2E0; /*0x607f*/
if ( !qword_D2E0 ) /*0x6090*/
{
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CA70, 0, &qword_D2E0) < 0 ) /*0x60b2*/
return 0x800000000000000EuLL; /*0x60be*/
v4 = qword_D2E0; /*0x60c3*/
}
result = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, UINTN *))(v4 + 24))(v4, a1, 0, &AllocationSize); /*0x60d8*/
if ( result == 0x8000000000000005uLL ) /*0x60e8*/
{
ReservedPool = AllocateReservedPool(AllocationSize); /*0x610d*/
v9 = (*(__int64 (__fastcall **)(__int64, __int64, _BYTE *, UINTN *))(qword_D2E0 + 24))( /*0x6114*/
qword_D2E0,
a1,
ReservedPool,
&AllocationSize);
if ( v9 >= 0 ) /*0x611a*/
{
for ( i = ReservedPool; i < &ReservedPool[AllocationSize]; *i++ = v12 ) /*0x612a*/
{
i_1 = i; /*0x612c*/
while ( *i != 59 && *i ) /*0x6134*/
++i; /*0x6136*/
v12 = *i; /*0x613e*/
*i = 0; /*0x614e*/
v9 = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, _BYTE *, wchar_t *, _QWORD))(qword_D2E0 + 16))( /*0x6163*/
qword_D2E0,
a1,
n47,
i_1,
________________,
0);
if ( v9 < 0 ) /*0x6169*/
break; /*0x6169*/
}
}
(*(void (__fastcall **)(_BYTE *))(BootServices + 72))(ReservedPool); /*0x6188*/
return v9; /*0x618b*/
}
return result; /*0x6198*/
}
// Function: ReFlashReadHiiConfig @ 0x61a8 (0x182 bytes)
__int64 __fastcall ReFlashReadHiiConfig(__int64 *p_n7, __int64 a2, __int64 n100, __int64 TotalBlocks)
{
__int64 v5; // rax
__int64 result; // rax
__int64 n7_1; // rbx
CHAR16 *ReservedPool; // rsi
UINTN _GUID_00000000000000000000000000000000&NAME_0000&PATH_00&_; // rax
__int64 v11; // r9
__int64 v12; // rbx
__int64 n100_1; // [rsp+70h] [rbp+18h] BYREF
__int64 n7; // [rsp+78h] [rbp+20h] BYREF
n100_1 = n100; /*0x61b3*/
n7 = 0; /*0x61c2*/
v5 = qword_D2C8; /*0x61ca*/
if ( !qword_D2C8 ) /*0x61d7*/
{
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *, __int64))(BootServices + 320))( /*0x61f9*/
&unk_CAA0,
0,
&qword_D2C8,
TotalBlocks) < 0 )
return 0x800000000000000EuLL; /*0x6205*/
v5 = qword_D2C8; /*0x620a*/
}
if ( !qword_D2D0 ) /*0x6219*/
{
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *, __int64))(BootServices + 320))( /*0x623b*/
&unk_CA80,
0,
&qword_D2D0,
TotalBlocks) < 0 )
return 0x800000000000000EuLL; /*0x623b*/
v5 = qword_D2C8; /*0x623d*/
}
LOBYTE(TotalBlocks) = 1; /*0x624b*/
result = (*(__int64 (__fastcall **)(__int64, __int64 *, _QWORD, __int64, void *, const wchar_t *))(v5 + 8))( /*0x626a*/
v5,
&n7,
0,
TotalBlocks,
&unk_C8F0,
L"Setup");
if ( result == 0x8000000000000005uLL ) /*0x627a*/
{
n7_1 = n7; /*0x6280*/
ReservedPool = (CHAR16 *)AllocateReservedPool(n7 + 112); /*0x629f*/
_GUID_00000000000000000000000000000000&NAME_0000&PATH_00&_ = UnicodeSPrintAsciiFormat( /*0x62a6*/
ReservedPool,
n7_1 + 112,
L"%s",
aGuid0000000000);// "GUID=00000000000000000000000000000000&NAME=0000&PATH=00&"
LOBYTE(v11) = 1; /*0x62b5*/
v12 = (*(__int64 (__fastcall **)(__int64, __int64 *, CHAR16 *, __int64, void *, const wchar_t *))(qword_D2C8 + 8))( /*0x62ce*/
qword_D2C8,
&n7,
&ReservedPool[_GUID_00000000000000000000000000000000&NAME_0000&PATH_00&_],
v11,
&unk_C8F0,
L"Setup");
if ( v12 >= 0 ) /*0x62d4*/
{
n7 = *p_n7; /*0x62dc*/
v12 = (*(__int64 (__fastcall **)(__int64, CHAR16 *, __int64, __int64 *, __int64 *))(qword_D2D0 + 32))( /*0x62fe*/
qword_D2D0,
ReservedPool,
a2,
p_n7,
&n100_1);
*p_n7 = n7; /*0x6306*/
}
(*(void (__fastcall **)(CHAR16 *))(BootServices + 72))(ReservedPool); /*0x6313*/
return v12; /*0x6316*/
}
return result; /*0x631e*/
}
// Function: ReFlashWriteHiiConfig @ 0x632c (0x219 bytes)
__int64 __fastcall ReFlashWriteHiiConfig(__int64 n7, __int64 a2, _WORD *i, __int64 a4)
{
__int64 v6; // rax
__int64 result; // rax
UINTN BufferSize; // r14
CHAR16 *ReservedPool; // rbx
UINTN _GUID_00000000000000000000000000000000&NAME_0000&PATH_00&_; // rax
__int64 v11; // r9
__int64 v12; // rdi
unsigned int n2; // ecx
_WORD *j; // rax
char v15[72]; // [rsp+30h] [rbp-48h] BYREF
_WORD *i_1; // [rsp+90h] [rbp+18h] BYREF
__int64 n2_1; // [rsp+98h] [rbp+20h] BYREF
i_1 = i; /*0x6337*/
n2_1 = 0; /*0x6350*/
v6 = qword_D2C8; /*0x6357*/
if ( !qword_D2C8 ) /*0x6361*/
{
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CAA0, 0, &qword_D2C8) < 0 ) /*0x6383*/
return 0x800000000000000EuLL; /*0x638f*/
v6 = qword_D2C8; /*0x6394*/
}
if ( !qword_D2D0 ) /*0x63a2*/
{
if ( (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_CA80, 0, &qword_D2D0) < 0 ) /*0x63c4*/
return 0x800000000000000EuLL; /*0x63c4*/
v6 = qword_D2C8; /*0x63c6*/
}
LOBYTE(a4) = 1; /*0x63d4*/
result = (*(__int64 (__fastcall **)(__int64, __int64 *, _QWORD, __int64, void *, const wchar_t *))(v6 + 8))( /*0x63f6*/
v6,
&n2_1,
0,
a4,
&unk_C8F0,
L"Setup");
if ( result == 0x8000000000000005uLL ) /*0x6406*/
{
BufferSize = n2_1 + 112; /*0x6414*/
ReservedPool = (CHAR16 *)AllocateReservedPool(n2_1 + 112); /*0x6434*/
_GUID_00000000000000000000000000000000&NAME_0000&PATH_00&_ = UnicodeSPrintAsciiFormat( /*0x6437*/
ReservedPool,
BufferSize,
L"%s",
aGuid0000000000);// "GUID=00000000000000000000000000000000&NAME=0000&PATH=00&"
LOBYTE(v11) = 1; /*0x6449*/
v12 = (*(__int64 (__fastcall **)(__int64, __int64 *, CHAR16 *, __int64, void *, const wchar_t *))(qword_D2C8 + 8))( /*0x6462*/
qword_D2C8,
&n2_1,
&ReservedPool[_GUID_00000000000000000000000000000000&NAME_0000&PATH_00&_],
v11,
&unk_C8F0,
L"Setup");
if ( v12 >= 0 ) /*0x646b*/
{
ReFlashStripHiiConfigValues((char *)ReservedPool, BufferSize); /*0x647f*/
v12 = (*(__int64 (__fastcall **)(__int64, CHAR16 *, __int64, __int64, _WORD **, char *))(qword_D2D0 + 24))( /*0x64b1*/
qword_D2D0,
ReservedPool,
a2,
n7,
&i_1,
v15);
if ( v12 >= 0 ) /*0x64b7*/
{
n2 = 2; /*0x64c1*/
for ( j = i_1; *j; n2 += 2 ) /*0x64c9*/
++j; /*0x64cf*/
n2_1 = n2; /*0x64e6*/
v12 = (*(__int64 (__fastcall **)(__int64, __int64 *, _WORD *, _QWORD, void *, const wchar_t *))(qword_D2C8 + 8))( /*0x6510*/
qword_D2C8,
&n2_1,
i_1,
0,
&unk_C8F0,
L"Setup");
(*(void (__fastcall **)(_WORD *))(BootServices + 72))(i_1); /*0x651a*/
}
(*(void (__fastcall **)(CHAR16 *))(BootServices + 72))(ReservedPool); /*0x6527*/
}
else
{
(*(void (__fastcall **)(CHAR16 *))(BootServices + 72))(ReservedPool); /*0x6474*/
}
return v12; /*0x652a*/
}
return result; /*0x6535*/
}
// Function: ReFlashFindConfigTable @ 0x6548 (0x5e bytes)
__int64 __fastcall ReFlashFindConfigTable(__int64 SystemTable, GUID *ImageHandle)
{
__int64 v3; // rdi
unsigned __int64 v4; // rbx
v3 = *(_QWORD *)(::SystemTable + 104); /*0x6561*/
v4 = *(_QWORD *)(::SystemTable + 112); /*0x6565*/
if ( !v3 ) /*0x656c*/
return 0; /*0x658e*/
while ( StrnCmp(v4, ImageHandle, 0x10u) ) /*0x6582*/
{
v4 += 24LL; /*0x6584*/
if ( !--v3 ) /*0x658c*/
return 0; /*0x658c*/
}
return *(_QWORD *)(v4 + 16); /*0x659a*/
}
// Function: ReFlashInitConsole @ 0x65a8 (0xe1 bytes)
__int64 ReFlashInitConsole()
{
__int64 v1; // rcx
unsigned __int64 n0x10; // rbx
__int64 v3; // rax
if ( byte_D300 ) /*0x65bb*/
{
if ( qword_D308 ) /*0x65c4*/
return 0; /*0x65c8*/
if ( !qword_D310 ) /*0x65d7*/
return 0x8000000000000003uLL; /*0x65d7*/
v1 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(qword_D310 + 208))(&unk_C760, 0, &qword_D308); /*0x65fe*/
if ( v1 < 0 ) /*0x6604*/
qword_D308 = 0; /*0x6606*/
}
else
{
if ( qword_D318 ) /*0x6616*/
return 0; /*0x6616*/
if ( byte_D301 == 1 ) /*0x661f*/
return 0x8000000000000003uLL; /*0x661f*/
n0x10 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(31); /*0x663a*/
(*(void (__fastcall **)(unsigned __int64))(BootServices + 32))(n0x10); /*0x663d*/
if ( n0x10 > 0x10 ) /*0x6644*/
return 0x8000000000000003uLL; /*0x65e3*/
v1 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_C6C0, 0, &qword_D318); /*0x6663*/
v3 = qword_D318; /*0x6666*/
if ( v1 < 0 ) /*0x6670*/
v3 = 0; /*0x6670*/
qword_D318 = v3; /*0x6674*/
}
return v1; /*0x6683*/
}
// Function: DebugPrintErrorLevel @ 0x668c (0x8a bytes)
__int64 DebugPrintErrorLevel(__int64 a1, char *HII_Extract_Config:_Guid_extraction_failed_n, ...)
{
__int64 result; // rax
__int64 (__fastcall **v4)(__int64, char *, __int64 *); // r9
char v5; // r10
char *HII_Extract_Config:_Guid_extraction_failed_n_1; // rdx
__int64 v8; // [rsp+40h] [rbp+18h] BYREF
va_list va; // [rsp+40h] [rbp+18h]
__int64 v10; // [rsp+48h] [rbp+20h]
va_list va1; // [rsp+50h] [rbp+28h] BYREF
va_start(va1, HII_Extract_Config:_Guid_extraction_failed_n);
va_start(va, HII_Extract_Config:_Guid_extraction_failed_n);
v8 = va_arg(va1, _QWORD); /*0x668c*/
v10 = va_arg(va1, _QWORD); /*0x668c*/
result = ReFlashInitConsole(); /*0x66a3*/
if ( result >= 0 ) /*0x66ae*/
{
result = DebugLibGetDebugMask(); /*0x66c6*/
if ( v4 ) /*0x66ce*/
{
if ( ((unsigned int)a1 & (unsigned int)result) != 0 ) /*0x66d2*/
{
HII_Extract_Config:_Guid_extraction_failed_n_1 = HII_Extract_Config:_Guid_extraction_failed_n; /*0x66d4*/
if ( *HII_Extract_Config:_Guid_extraction_failed_n != v5 ) /*0x66dc*/
{
do /*0x66fe*/
{
if ( *HII_Extract_Config:_Guid_extraction_failed_n_1 == 37 ) /*0x66e1*/
{
if ( *++HII_Extract_Config:_Guid_extraction_failed_n_1 == 115 ) /*0x66e9*/
{
*HII_Extract_Config:_Guid_extraction_failed_n_1 = 97; /*0x66eb*/
}
else if ( *HII_Extract_Config:_Guid_extraction_failed_n_1 == 71 ) /*0x66f3*/
{
*HII_Extract_Config:_Guid_extraction_failed_n_1 = 103; /*0x66f5*/
}
}
++HII_Extract_Config:_Guid_extraction_failed_n_1; /*0x66f8*/
}
while ( *HII_Extract_Config:_Guid_extraction_failed_n_1 != v5 ); /*0x66fe*/
HII_Extract_Config:_Guid_extraction_failed_n_1 = HII_Extract_Config:_Guid_extraction_failed_n; /*0x6700*/
}
return (*v4)(a1, HII_Extract_Config:_Guid_extraction_failed_n_1, (__int64 *)va); /*0x670d*/
}
}
}
return result; /*0x6710*/
}
// Function: AllocateReservedPool @ 0x6718 (0x2b bytes)
void *__cdecl AllocateReservedPool(UINTN AllocationSize)
{
void *v2; // [rsp+38h] [rbp+10h] BYREF
v2 = 0; /*0x6728*/
(*(void (__fastcall **)(__int64, UINTN, void **))(BootServices + 64))(4, AllocationSize, &v2); /*0x6736*/
return v2; /*0x673e*/
}
// Function: AllocateCopyPool @ 0x6744 (0x3e bytes)
void *__cdecl AllocateCopyPool(UINTN AllocationSize, const void *Buffer)
{
void *result; // rax
void *v4; // rbx
result = AllocateReservedPool(AllocationSize); /*0x6751*/
v4 = result; /*0x6756*/
if ( result ) /*0x675c*/
{
(*(void (__fastcall **)(void *, UINTN, _QWORD))(BootServices + 360))(result, AllocationSize, 0); /*0x676e*/
return v4; /*0x6774*/
}
return result; /*0x677c*/
}
// Function: ReFlashFlashMapGetSize @ 0x6784 (0x52 bytes)
__int64 __fastcall ReFlashFlashMapGetSize(_BYTE *src)
{
_BYTE *src_1; // rdx
__int64 v3; // r8
__int64 v4; // r10
src_1 = src; /*0x6784*/
if ( !src ) /*0x678a*/
return 0; /*0x678c*/
v3 = 0; /*0x678f*/
while ( 1 ) /*0x6792*/
{
if ( *src_1 == 127 && src_1[1] == 0xFF ) /*0x679b*/
return v3 + 4; /*0x67d1*/
v4 = (unsigned __int8)src_1[2]; /*0x67a2*/
if ( !*src_1 || !((_DWORD)v4 + ((unsigned __int8)src_1[3] << 8)) ) /*0x67ad*/
break; /*0x67ad*/
v3 += (unsigned int)v4 + ((unsigned __int8)src_1[3] << 8); /*0x67bb*/
src_1 += 256 * (unsigned __int64)(unsigned __int8)src_1[3] + v4; /*0x67c8*/
}
return v3; /*0x678e*/
}
// Function: ReFlashFlashMapAppend @ 0x67d8 (0xd5 bytes)
char *__fastcall ReFlashFlashMapAppend(char *src, __int64 src_2)
{
char *src_1; // rdi
unsigned __int64 n8; // rbx
char *ReservedPool; // rax
char *ReservedPool_1; // r14
char *ReservedPool_2; // r15
src_1 = src; /*0x67f4*/
if ( src_2 ) /*0x67fa*/
{
if ( src ) /*0x6815*/
n8 = ReFlashFlashMapGetSize(src) - 4; /*0x681c*/
else
n8 = 0; /*0x6822*/
ReservedPool = (char *)AllocateReservedPool( /*0x683a*/
n8
+ ((unsigned __int64)*(unsigned __int8 *)(src_2 + 3) << 8)
+ *(unsigned __int8 *)(src_2 + 2)
+ 4LL);
ReservedPool_1 = ReservedPool; /*0x683f*/
ReservedPool_2 = ReservedPool; /*0x6842*/
if ( n8 ) /*0x6848*/
{
InternalCopyMemOverlap(ReservedPool, src_1, n8); /*0x6853*/
ReservedPool_2 += n8; /*0x6858*/
}
InternalCopyMemOverlap( /*0x6872*/
ReservedPool_2,
(char *)src_2,
*(unsigned __int8 *)(src_2 + 2) + ((unsigned __int64)*(unsigned __int8 *)(src_2 + 3) << 8));
*(_DWORD *)&ReservedPool_2[256 * (unsigned __int64)*(unsigned __int8 *)(src_2 + 3) + *(unsigned __int8 *)(src_2 + 2)] = dword_CB88; /*0x688c*/
return ReservedPool_1; /*0x688f*/
}
else
{
if ( !src ) /*0x67ff*/
src = (char *)&dword_CB88; /*0x6801*/
return ReFlashFlashMapClone(src); /*0x6808*/
}
}
// Function: ReFlashFlashMapClone @ 0x68b0 (0x46 bytes)
char *__fastcall ReFlashFlashMapClone(char *src)
{
UINTN AllocationSize; // rbx
char *ReservedPool; // rdi
AllocationSize = ReFlashFlashMapGetSize(src); /*0x68ca*/
ReservedPool = (char *)AllocateReservedPool(AllocationSize); /*0x68db*/
InternalCopyMemOverlap(ReservedPool, src, AllocationSize); /*0x68de*/
return ReservedPool; /*0x68f0*/
}
// Function: GetVariable @ 0x68f8 (0xbe bytes)
void *__cdecl GetVariable(const CHAR16 *Name, const EFI_GUID *Guid)
{
__int64 v2; // r8
UINTN *p_AllocationSize_1; // r9
UINTN *p_AllocationSize; // rdi
__int64 v5; // rsi
void *result; // rax
void *ReservedPool; // rax
_QWORD *v10; // [rsp+60h] [rbp+28h]
p_AllocationSize = p_AllocationSize_1; /*0x6916*/
v5 = v2; /*0x6919*/
if ( !*v10 ) /*0x6922*/
*p_AllocationSize_1 = 0; /*0x6928*/
result = (void *)(*(__int64 (__fastcall **)(const CHAR16 *))(RuntimeServices + 72))(Name); /*0x693b*/
if ( result == (void *)0x8000000000000005LL ) /*0x6941*/
{
if ( *v10 ) /*0x6952*/
(*(void (**)(void))(BootServices + 72))(); /*0x6961*/
ReservedPool = AllocateReservedPool(*p_AllocationSize); /*0x6967*/
*v10 = ReservedPool; /*0x696c*/
if ( ReservedPool ) /*0x6972*/
return (void *)(*(__int64 (__fastcall **)(const CHAR16 *, const EFI_GUID *, __int64, UINTN *, void *))(RuntimeServices + 72))( /*0x6998*/
Name,
Guid,
v5,
p_AllocationSize,
ReservedPool);
else
return (void *)0x8000000000000009LL; /*0x6974*/
}
return result; /*0x69af*/
}
// Function: ValueToString @ 0x69b8 (0x71 bytes)
_BYTE *__fastcall ValueToString(__int64 a1, _BYTE *n, __int64 n10, char a4)
{
unsigned __int64 v4; // r11
_BYTE *n_1; // r10
unsigned __int64 v6; // rax
unsigned __int64 n0xA; // rdx
char v8; // dl
v4 = (unsigned int)a1; /*0x69bb*/
n_1 = n; /*0x69c1*/
if ( a4 ) /*0x69c7*/
v4 = a1; /*0x69c7*/
if ( (_DWORD)n10 == 10 ) /*0x69cf*/
v4 = -a1; /*0x69cf*/
if ( a1 >= 0 ) /*0x69d6*/
v4 = a1; /*0x69d6*/
if ( v4 ) /*0x69dd*/
{
do /*0x6a04*/
{
v6 = v4 / (int)n10; /*0x69e7*/
n0xA = v4 % (int)n10; /*0x69e7*/
v4 = v6; /*0x69ea*/
if ( n0xA >= 0xA ) /*0x69f1*/
v8 = n0xA + 87; /*0x69f8*/
else
v8 = n0xA + 48; /*0x69f3*/
*n_1++ = v8; /*0x69fb*/
}
while ( v6 ); /*0x6a04*/
}
else
{
*n = 48; /*0x6a08*/
n_1 = n + 1; /*0x6a0b*/
}
if ( (_DWORD)n10 == 10 && a1 < 0 ) /*0x6a17*/
*n_1++ = 45; /*0x6a19*/
*n_1 = 0; /*0x6a20*/
return n_1 - 1; /*0x6a28*/
}
// Function: AsciiStrDecimalToUintn @ 0x6a2c (0xd7 bytes)
__int64 __fastcall AsciiStrDecimalToUintn(const CHAR8 *FormatString, const CHAR8 **p_FormatString, int n32)
{
char v3; // r10
char v4; // r9
unsigned int n0x7FFFFFFF; // r8d
const CHAR8 *FormatString_1; // rdx
CHAR8 v9; // cl
char n10; // cl
v3 = 0; /*0x6a36*/
v4 = 1; /*0x6a3e*/
n0x7FFFFFFF = 0; /*0x6a41*/
while ( *FormatString == 32 || *FormatString == 9 ) /*0x6a4f*/
FormatString += 2; /*0x6a51*/
if ( *FormatString ) /*0x6a57*/
{
if ( *FormatString == 45 ) /*0x6a69*/
{
v4 = -1; /*0x6a6b*/
FormatString += 2; /*0x6a6e*/
}
FormatString_1 = FormatString + 2; /*0x6a75*/
if ( *FormatString != 43 ) /*0x6a79*/
FormatString_1 = FormatString; /*0x6a79*/
while ( 1 ) /*0x6a7d*/
{
v9 = *FormatString_1; /*0x6a7d*/
if ( (unsigned __int8)(*FormatString_1 - 48) > 9u ) /*0x6a84*/
{
if ( (unsigned __int8)((v9 & 0xDF) - 65) > 0x19u ) /*0x6a93*/
break; /*0x6a93*/
n10 = (v9 & 0xDF) - 55; /*0x6a98*/
}
else
{
n10 = v9 - 48; /*0x6a86*/
}
if ( n10 >= 10 ) /*0x6aa3*/
break; /*0x6aa3*/
n0x7FFFFFFF = n10 + 10 * n0x7FFFFFFF; /*0x6aa9*/
if ( v4 == 1 ) /*0x6ab0*/
{
if ( n0x7FFFFFFF >= 0x80000000 ) /*0x6ab9*/
v3 = 1; /*0x6abb*/
}
else if ( n0x7FFFFFFF > 0x80000000 ) /*0x6acb*/
{
v3 = 1; /*0x6acb*/
}
FormatString_1 += 2; /*0x6acf*/
}
*p_FormatString = FormatString_1; /*0x6ad5*/
if ( v3 ) /*0x6adb*/
{
n0x7FFFFFFF = 0x7FFFFFFF; /*0x6ae6*/
if ( v4 == -1 ) /*0x6aec*/
n0x7FFFFFFF = 0x80000000; /*0x6aec*/
}
return n0x7FFFFFFF * v4; /*0x6af4*/
}
else
{
*p_FormatString = FormatString; /*0x6a5d*/
return 0; /*0x6a60*/
}
}
// Function: StatusToString @ 0x6b04 (0xc7 bytes)
const char *__fastcall StatusToString(unsigned __int64 n4, __int64 n37, __int64 n32)
{
__int64 v4; // rax
char *EFI_INTERRUPT_PENDING; // rcx
unsigned __int64 n3; // rdx
if ( !n4 ) /*0x6b07*/
return "EFI_SUCCESS"; /*0x6b10*/
if ( (n4 & 0x8000000000000000uLL) != 0LL ) /*0x6b11*/
{
n3 = n4 & 0x1FFFFFFFFFFFFFFFLL; /*0x6b65*/
if ( (n4 & 0xA000000000000000uLL) == 0xA000000000000000uLL ) /*0x6b71*/
{
if ( n3 >= 3 ) /*0x6b77*/
return 0; /*0x6b77*/
v4 = 25 * n3; /*0x6b79*/
EFI_INTERRUPT_PENDING = aEfiInterruptPe; // "EFI_INTERRUPT_PENDING" /*0x6b7d*/
return &EFI_INTERRUPT_PENDING[v4]; /*0x6b84*/
}
if ( (n4 & 0xC000000000000000uLL) == 0xC000000000000000uLL ) /*0x6b96*/
{
if ( n3 > 2 ) /*0x6b9c*/
return 0; /*0x6b9c*/
v4 = 25 * n3 + 52375; /*0x6ba2*/
}
else
{
if ( n3 > 0x1E ) /*0x6baf*/
return 0; /*0x6baf*/
v4 = 25 * n3 + 52439; /*0x6bb9*/
}
LABEL_18:
EFI_INTERRUPT_PENDING = (char *)&_ImageBase; /*0x6bc0*/
return &EFI_INTERRUPT_PENDING[v4]; /*0x6bc0*/
}
if ( (n4 & 0x2000000000000000LL) == 0 ) /*0x6b20*/
{
if ( n4 > 4 ) /*0x6b3f*/
return 0; /*0x6b3f*/
v4 = 26 * n4 + 52086; /*0x6b45*/
goto LABEL_18; /*0x6b4c*/
}
if ( n4 >= 2 ) /*0x6b26*/
return 0; /*0x6b2a*/
v4 = 35 * n4; /*0x6b2b*/
EFI_INTERRUPT_PENDING = aEfiWarnInterru; // "EFI_WARN_INTERRUPT_SOURCE_PENDING" /*0x6b2f*/
return &EFI_INTERRUPT_PENDING[v4]; /*0x6b10*/
}
// Function: HiiConstructConfigAltString @ 0x6bcc (0x26 bytes)
__int64 HiiConstructConfigAltString(wchar_t *________________, const CHAR8 *DmiVar%02x%04x%02x%02x, ...)
{
va_list va; // [rsp+40h] [rbp+18h] BYREF
va_start(va, DmiVar%02x%04x%02x%02x);
return HiiConstructConfigAltStringWorker(________________, 0, DmiVar%02x%04x%02x%02x, va); /*0x6bed*/
}
// Function: HiiConstructConfigAltStringWorker @ 0x6bf4 (0x478 bytes)
__int64 __fastcall HiiConstructConfigAltStringWorker(
CHAR16 *StartOfBuffer,
UINTN BufferSize,
CHAR8 *FormatString,
va_list va)
{
CHAR8 *FormatString_1; // r12
UINTN BufferSize_1; // r13
CHAR16 *StartOfBuffer_1; // rdi
CHAR16 *StartOfBuffer_2; // r15
va_list i_1; // rcx
CHAR16 n37_1; // ax
__int64 n32; // r8
__int64 n37; // rdx
__int16 n32_1; // si
va_list i_2; // rcx
unsigned int v14; // edi
unsigned int v15; // eax
CHAR16 *j; // rax
unsigned int *v17; // r9
UINTN v18; // r8
CHAR16 *m; // rcx
const char *v20; // rax
__int64 v21; // r9
UINTN v22; // rax
char v23; // al
CHAR16 n100; // dx
char v25; // r9
__int64 n10; // r8
__int64 *i_3; // rcx
_WORD *v28; // rbx
_BYTE *ii; // rcx
_BYTE *jj; // rcx
bool v31; // zf
__int16 v32; // dx
_WORD *v33; // rcx
_WORD *v34; // rcx
unsigned __int64 v35; // rax
CHAR16 *v36; // rcx
CHAR16 v37; // ax
_BYTE *k; // rdx
__int64 v39; // r15
__int64 v41; // [rsp+20h] [rbp-E0h]
__int64 v42; // [rsp+28h] [rbp-D8h]
__int64 v43; // [rsp+30h] [rbp-D0h]
__int64 v44; // [rsp+38h] [rbp-C8h]
__int64 v45; // [rsp+40h] [rbp-C0h]
__int64 v46; // [rsp+48h] [rbp-B8h]
__int64 v47; // [rsp+50h] [rbp-B0h]
__int64 v48; // [rsp+58h] [rbp-A8h]
__int64 v49; // [rsp+60h] [rbp-A0h]
__int64 v50; // [rsp+68h] [rbp-98h]
CHAR8 *p_FormatString; // [rsp+70h] [rbp-90h] BYREF
CHAR16 *StartOfBuffer_3; // [rsp+78h] [rbp-88h]
_WORD v53[32]; // [rsp+80h] [rbp-80h] BYREF
_BYTE n[256]; // [rsp+C0h] [rbp-40h] BYREF
_BYTE n_1[304]; // [rsp+1C0h] [rbp+C0h] BYREF
va_list i; // [rsp+310h] [rbp+210h]
FormatString_1 = FormatString; /*0x6c1b*/
BufferSize_1 = BufferSize; /*0x6c1e*/
StartOfBuffer_1 = StartOfBuffer; /*0x6c21*/
StartOfBuffer_2 = StartOfBuffer; /*0x6c24*/
if ( !StartOfBuffer || !FormatString ) /*0x6c33*/
return -1; /*0x704d*/
if ( BufferSize == 1 ) /*0x6c3d*/
{
LABEL_83:
*StartOfBuffer_2 = 0; /*0x7044*/
v39 = (char *)StartOfBuffer_2 - (char *)StartOfBuffer_1; /*0x7048*/
return v39 >> 1; /*0x704b*/
}
i_1 = va - 1; /*0x6c43*/
for ( i = va - 1; ; i_1 = i ) /*0x6c47*/
{
n37_1 = *(_WORD *)FormatString_1; /*0x6c4e*/
n32 = 32; /*0x6c59*/
n37 = 37; /*0x6c5d*/
if ( !*(_WORD *)FormatString_1 ) /*0x6c64*/
{
LABEL_82:
StartOfBuffer_1 = StartOfBuffer; /*0x703d*/
goto LABEL_83; /*0x703d*/
}
FormatString_1 += 2; /*0x6c6a*/
if ( n37_1 != 37 ) /*0x6c71*/
{
*StartOfBuffer_2 = n37_1; /*0x6c73*/
LABEL_8:
++StartOfBuffer_2; /*0x6c77*/
--BufferSize_1; /*0x6c7b*/
goto LABEL_78; /*0x6c7e*/
}
if ( *(_WORD *)FormatString_1 == 37 ) /*0x6c88*/
{
FormatString_1 += 2; /*0x6c8a*/
*StartOfBuffer_2 = 37; /*0x6c8e*/
goto LABEL_8; /*0x6c92*/
}
n32_1 = 32; /*0x6c94*/
if ( *(_WORD *)FormatString_1 == 48 ) /*0x6c9d*/
{
n32_1 = 48; /*0x6c9f*/
FormatString_1 += 2; /*0x6ca2*/
}
switch ( *(_WORD *)FormatString_1 ) /*0x6cac*/
{
case '*': /*0x6cac*/
FormatString_1 += 2; /*0x6cae*/
i_2 = i_1 + 1; /*0x6cb2*/
i = i_2; /*0x6cb6*/
v14 = *(_DWORD *)i_2; /*0x6cbd*/
break;
case 's': /*0x6cac*/
i = i_2 + 1; /*0x6ce8*/
for ( j = (CHAR16 *)i_2[1]; *j; ++j ) /*0x6cef*/
{
if ( !--BufferSize_1 ) /*0x6cf8*/
goto LABEL_80; /*0x6cf8*/
*StartOfBuffer_2++ = *j; /*0x6cfe*/
}
goto LABEL_77; /*0x6d10*/
case 'S': /*0x6cac*/
case 'a': /*0x6cac*/
i = i_2 + 1; /*0x6fee*/
for ( k = i_2[1]; *k; ++k ) /*0x6ff5*/
{
if ( !--BufferSize_1 ) /*0x6ffe*/
goto LABEL_80; /*0x6ffe*/
*StartOfBuffer_2++ = (char)*k; /*0x7003*/
}
goto LABEL_77; /*0x7012*/
default:
v15 = AsciiStrDecimalToUintn(FormatString_1, (const CHAR8 **)&p_FormatString, 32); /*0x6cc9*/
i_2 = i; /*0x6cce*/
v14 = v15; /*0x6cd5*/
FormatString_1 = p_FormatString; /*0x6cd7*/
break;
}
if ( *(_WORD *)FormatString_1 != 99 ) /*0x6d35*/
break; /*0x6d35*/
i = i_2 + 1; /*0x6d3b*/
*StartOfBuffer_2++ = *((_WORD *)i_2 + 4); /*0x6d45*/
LABEL_77:
FormatString_1 += 2; /*0x7014*/
LABEL_78:
if ( BufferSize_1 == 1 ) /*0x701c*/
goto LABEL_82; /*0x701c*/
}
if ( (*FormatString_1 & 0xDF) == 0x47 ) /*0x6d5a*/
{
StartOfBuffer_3 = StartOfBuffer_2; /*0x6d64*/
i = i_2 + 1; /*0x6d69*/
v17 = (unsigned int *)i_2[1]; /*0x6d70*/
LODWORD(v50) = *((unsigned __int8 *)v17 + 15); /*0x6da8*/
LODWORD(v49) = *((unsigned __int8 *)v17 + 14); /*0x6dac*/
LODWORD(v48) = *((unsigned __int8 *)v17 + 13); /*0x6db3*/
LODWORD(v47) = *((unsigned __int8 *)v17 + 12); /*0x6dba*/
LODWORD(v46) = *((unsigned __int8 *)v17 + 11); /*0x6dc6*/
LODWORD(v45) = *((unsigned __int8 *)v17 + 10); /*0x6dcb*/
LODWORD(v44) = *((unsigned __int8 *)v17 + 9); /*0x6dd0*/
LODWORD(v43) = *((unsigned __int8 *)v17 + 8); /*0x6dd4*/
LODWORD(v42) = *((unsigned __int16 *)v17 + 3); /*0x6dd8*/
LODWORD(v41) = *((unsigned __int16 *)v17 + 2); /*0x6ddc*/
v18 = UnicodeSPrintAsciiFormat( /*0x6de9*/
StartOfBuffer_2,
BufferSize_1,
L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
*v17,
v41,
v42,
v43,
v44,
v45,
v46,
v47,
v48,
v49,
v50);
StartOfBuffer_2 += v18; /*0x6df2*/
if ( *(_WORD *)FormatString_1 == 71 ) /*0x6df6*/
{
for ( m = StartOfBuffer_3; *m; ++m ) /*0x6dfd*/
{
if ( (unsigned __int16)(*m - 97) <= 0x19u ) /*0x6e11*/
*m -= 32; /*0x6e17*/
}
}
BufferSize_1 -= v18; /*0x6e24*/
goto LABEL_77; /*0x6e27*/
}
if ( *(_WORD *)FormatString_1 == 114 ) /*0x6e32*/
{
i = i_2 + 1; /*0x6e38*/
v20 = StatusToString((unsigned __int64)i_2[1], n37, n32); /*0x6e45*/
if ( v20 ) /*0x6e53*/
v22 = UnicodeSPrintAsciiFormat(StartOfBuffer_2, BufferSize_1, L"%S", v20); /*0x6e79*/
else
v22 = UnicodeSPrintAsciiFormat( /*0x6e68*/
StartOfBuffer_2,
BufferSize_1,
L"%S(%X)",
aStatusCode, // "Status Code"
v21);
StartOfBuffer_2 += v22; /*0x6e7e*/
BufferSize_1 -= v22; /*0x6e82*/
goto LABEL_77; /*0x6e85*/
}
if ( *(_WORD *)FormatString_1 == 108 ) /*0x6e90*/
{
FormatString_1 += 2; /*0x6e92*/
v23 = 1; /*0x6e96*/
}
else
{
v23 = 0; /*0x6e9a*/
}
n100 = *(_WORD *)FormatString_1; /*0x6e9d*/
v25 = 1; /*0x6ea2*/
if ( *(_WORD *)FormatString_1 != 112 ) /*0x6eaf*/
v25 = v23; /*0x6eaf*/
if ( n100 == 100 || n100 == 105 ) /*0x6ebd*/
{
n10 = 10; /*0x6ed3*/
}
else
{
if ( (n100 & 0xDF) != 0x58 ) /*0x6ec5*/
goto LABEL_78; /*0x6ec5*/
n10 = 16; /*0x6ecb*/
}
i_3 = (__int64 *)(i_2 + 1); /*0x6ed9*/
v28 = v53; /*0x6edd*/
i = (va_list)i_3; /*0x6ee1*/
if ( v25 ) /*0x6eeb*/
{
for ( ii = ValueToString(*i_3, n, n10, 1); ii >= n; --ii ) /*0x6efc*/
*v28++ = (char)*ii; /*0x6f04*/
}
else
{
for ( jj = ValueToString(*(int *)i_3, n_1, n10, 0); jj >= n_1; --jj ) /*0x6f2b*/
*v28++ = (char)*jj; /*0x6f33*/
}
v31 = *(_WORD *)FormatString_1 == 88; /*0x6f49*/
*v28 = 0; /*0x6f4f*/
if ( v31 || *(_WORD *)FormatString_1 == 112 ) /*0x6f5b*/
{
v32 = v53[0]; /*0x6f5d*/
v33 = v53; /*0x6f61*/
if ( v53[0] ) /*0x6f68*/
{
do /*0x6f87*/
{
if ( (unsigned __int16)(*v33 - 97) <= 0x19u ) /*0x6f7a*/
*v33 -= 32; /*0x6f80*/
++v33; /*0x6f83*/
}
while ( *v33 ); /*0x6f87*/
goto LABEL_62; /*0x6f8b*/
}
}
else
{
LABEL_62:
v32 = v53[0]; /*0x6f8d*/
}
v34 = v53; /*0x6f91*/
v35 = 0; /*0x6f95*/
if ( v32 ) /*0x6f9b*/
{
do /*0x6fa4*/
{
++v34; /*0x6f9d*/
++v35; /*0x6fa1*/
}
while ( *v34 ); /*0x6fa4*/
}
while ( v35 < v14 ) /*0x6fc2*/
{
++v35; /*0x6fae*/
if ( !--BufferSize_1 ) /*0x6fb5*/
goto LABEL_80; /*0x6fb5*/
*StartOfBuffer_2++ = n32_1; /*0x6fb7*/
}
v36 = v53; /*0x6fc4*/
if ( !v32 ) /*0x6fcb*/
goto LABEL_77; /*0x6fcb*/
while ( --BufferSize_1 ) /*0x6fcd*/
{
v37 = *v36++; /*0x6fd3*/
*StartOfBuffer_2++ = v37; /*0x6fda*/
if ( !*v36 ) /*0x6fe2*/
goto LABEL_77; /*0x6fe6*/
}
LABEL_80:
*StartOfBuffer_2 = 0; /*0x702a*/
v39 = (char *)StartOfBuffer_2 - (char *)StartOfBuffer; /*0x702e*/
return v39 >> 1; /*0x7059*/
}
// Function: UnicodeSPrintAsciiFormat @ 0x706c (0x1d bytes)
UINTN UnicodeSPrintAsciiFormat(CHAR16 *StartOfBuffer, UINTN BufferSize, const CHAR8 *FormatString, ...)
{
va_list va; // [rsp+48h] [rbp+20h] BYREF
va_start(va, FormatString);
return HiiConstructConfigAltStringWorker(StartOfBuffer, BufferSize, (CHAR8 *)FormatString, va); /*0x7084*/
}
// Function: StrnCmp @ 0x708c (0x78 bytes)
__int64 __fastcall StrnCmp(unsigned __int64 a1, _BYTE *a2, unsigned __int64 n8)
{
unsigned __int64 v3; // r10
unsigned __int64 n8_1; // r9
unsigned __int64 v5; // r8
v3 = a1 + n8; /*0x7092*/
if ( n8 >= 8 ) /*0x7099*/
{
n8_1 = a1 & 7; /*0x709e*/
if ( (a1 & 7) != 0 && n8_1 == ((unsigned __int8)a2 & 7) ) /*0x70ad*/
{
v5 = 8 - n8_1; /*0x70b2*/
if ( n8_1 != 8 ) /*0x70b5*/
{
do /*0x70c7*/
{
if ( *(_BYTE *)a1 != *a2 ) /*0x70bb*/
break; /*0x70bb*/
++a1; /*0x70bd*/
++a2; /*0x70c0*/
--v5; /*0x70c3*/
}
while ( v5 ); /*0x70c7*/
}
}
while ( a1 <= v3 - 8 && *(_QWORD *)a1 == *(_QWORD *)a2 ) /*0x70d5*/
{
a1 += 8LL; /*0x70d7*/
a2 += 8; /*0x70da*/
}
}
while ( 1 ) /*0x70f0*/
{
if ( a1 >= v3 ) /*0x70f3*/
return 0; /*0x70f7*/
if ( *(_BYTE *)a1 != *a2 ) /*0x70e8*/
break; /*0x70e8*/
++a1; /*0x70ea*/
++a2; /*0x70ed*/
}
return *(char *)a1 - (char)*a2; /*0x70f7*/
}
// Function: DevicePathFindAcpiNode @ 0x7104 (0x9e bytes)
__int64 __fastcall DevicePathFindAcpiNode(_BYTE *a1, _WORD **a2)
{
_WORD *i_1; // rsi
bool v5; // zf
_WORD *i; // rbx
__int64 result; // rax
if ( !a1 || !a2 ) /*0x712b*/
return 0x8000000000000002uLL; /*0x717d*/
i_1 = *a2; /*0x712d*/
while ( 2 ) /*0x7136*/
{
v5 = *i_1 == 0xFFFF; /*0x7136*/
for ( i = i_1; ; v5 = *i == 0xFFFF ) /*0x713a*/
{
if ( v5 ) /*0x713d*/
return 0x800000000000000EuLL; /*0x717b*/
i = (_WORD *)((char *)i + (unsigned __int16)i[1]); /*0x7143*/
if ( *i == 4 ) /*0x714a*/
break; /*0x714a*/
}
i_1 = i; /*0x715f*/
result = StrnCmp((unsigned __int64)(i + 4), a1, 0x10u); /*0x7162*/
if ( result ) /*0x716a*/
continue; /*0x716a*/
break;
}
*a2 = i; /*0x716c*/
return result; /*0x719b*/
}
// Function: ReFlashParseFirmwareImage @ 0x71a4 (0x530 bytes)
void *__fastcall ReFlashParseFirmwareImage(__int64 i, UINTN *p_n0x1000000, _DWORD *p_ImageType)
{
UINTN Length; // rax
__int64 v7; // rcx
void *ia_1; // rax
__int64 ia_3; // r14
__int64 ia_2; // rdi
__int64 v11; // rdi
__int64 v12; // r8
__int64 v13; // rdi
__int64 ia_4; // rbx
UINTN Length_1; // rax
__int64 v16; // rcx
void *ia_5; // rsi
__int64 ia_6; // rax
__int64 v19; // rbx
_QWORD *Pool_1; // rbx
_QWORD *Pool; // rax
__int64 v22; // rax
void *v23; // rax
__int64 v24; // rax
void *v25; // rax
__int64 ia; // [rsp+40h] [rbp-29h] BYREF
UINTN AllocationSize_1; // [rsp+48h] [rbp-21h] BYREF
void *v29; // [rsp+50h] [rbp-19h] BYREF
__int64 v30; // [rsp+58h] [rbp-11h] BYREF
__int64 v31; // [rsp+60h] [rbp-9h] BYREF
UINTN AllocationSize; // [rsp+68h] [rbp-1h] BYREF
__int64 v33; // [rsp+70h] [rbp+7h] BYREF
__int64 (__fastcall **v34)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD); // [rsp+78h] [rbp+Fh] BYREF
__int64 (__fastcall **v35)(_QWORD, _QWORD, _QWORD, _Q... [10621 chars total]
// Function: Assert_5 @ 0x76d4 (0x14b bytes)
__int64 __fastcall Assert_5(const char *FilePath, unsigned __int16 n3, wchar_t *Firmware_Update)
{
__int64 v3; // rbp
_BYTE *x_UEFI_2; // rax
__int64 result; // rax
__int64 v7; // rsi
_BYTE *x_UEFI_1; // rbx
_BYTE *x_UEFI; // r15
unsigned __int64 n0xF4240; // rax
__int64 v11; // rdx
__int64 v12; // rax
unsigned __int16 n3_1; // [rsp+78h] [rbp+10h] BYREF
n3_1 = n3; /*0x76de*/
v3 = qword_D158; /*0x76ef*/
if ( !qword_D158 ) /*0x76ff*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\UefiHiiLib\\HiiString.c", 0x46u, "HiiHandle != ((void *) 0)"); /*0x7712*/
if ( !Firmware_Update ) /*0x771a*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\UefiHiiLib\\HiiString.c", 0x47u, "String != ((void *) 0)"); /*0x772e*/
x_UEFI_2 = Assert_14(v3); /*0x7736*/
if ( !x_UEFI_2 ) /*0x7741*/
return 0; /*0x7743*/
v7 = 0x8000000000000002uLL; /*0x774c*/
x_UEFI_1 = x_UEFI_2; /*0x7756*/
while ( *x_UEFI_1 )
{
x_UEFI = x_UEFI_1; /*0x7762*/
if ( *x_UEFI_1 ) /*0x7765*/
{
do /*0x7772*/
{
if ( *x_UEFI_1 == 59 ) /*0x776d*/
break; /*0x776d*/
++x_UEFI_1; /*0x776f*/
}
while ( *x_UEFI_1 ); /*0x7772*/
if ( *x_UEFI_1 ) /*0x7777*/
*x_UEFI_1++ = 0; /*0x777c*/
}
n0xF4240 = Assert_21("x-UEFI"); /*0x7789*/
if ( Assert_8(x_UEFI, v11, n0xF4240) )
{
v12 = n3_1
? (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, _BYTE *, wchar_t *, _QWORD))(qword_D250 + 16))(
qword_D250,
v3,
n3_1,
x_UEFI,
Firmware_Update,
0)
: (*(__int64 (__fastcall **)(__int64, __int64, unsigned __int16 *, _BYTE *, _QWORD, wchar_t *, _QWORD))qword_D250)(
qword_D250,
v3,
&n3_1,
x_UEFI,
0,
Firmware_Update,
0);
v7 = v12; /*0x77df*/
if ( v12 < 0 ) /*0x77e5*/
break; /*0x77e5*/
}
}
AllocatePoolWithAssert(); /*0x77f3*/
result = 0; /*0x77f8*/
if ( v7 >= 0 ) /*0x77ff*/
return n3_1; /*0x7801*/
return result; /*0x7813*/
}
// Function: Assert_14 @ 0x7820 (0xa7 bytes)
void *__fastcall Assert_14(__int64 a1)
{
void *ZeroPool; // rax
void *ZeroPool_1; // rbx
char v5; // [rsp+38h] [rbp+10h] BYREF
__int64 v6; // [rsp+40h] [rbp+18h] BYREF
if ( !a1 ) /*0x7830*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\UefiHiiLib\\HiiLanguage.c", 0x2Fu, "HiiHandle != ((void *) 0)"); /*0x7843*/
v6 = 0; /*0x7854*/
if ( (*(__int64 (__fastcall **)(__int64, __int64, char *, __int64 *))(qword_D250 + 24))(qword_D250, a1, &v5, &v6) != 0x8000000000000005uLL ) /*0x7875*/
return 0; /*0x7875*/
ZeroPool = AllocateZeroPool(4u); /*0x7885*/
ZeroPool_1 = ZeroPool; /*0x788a*/
if ( !ZeroPool ) /*0x7890*/
return 0; /*0x7890*/
if ( (*(__int64 (__fastcall **)(__int64, __int64, void *, __int64 *))(qword_D250 + 24))(qword_D250, a1, ZeroPool, &v6) < 0 ) /*0x78ad*/
{
AllocatePoolWithAssert(); /*0x78b2*/
return 0; /*0x7879*/
}
return ZeroPool_1; /*0x78c1*/
}
// Function: Assert_6 @ 0x78c8 (0x13c bytes)
__int64 Assert_6(__int64 a1, unsigned __int8 *FormatString, ...)
{
unsigned __int8 *FormatStringa_1; // r8
unsigned int *FormatStringa_2; // rdi
int v6; // ebx
unsigned int *FormatStringa_3; // rax
unsigned int **v8; // rsi
int v9; // ebx
char *ZeroPool; // rax
char *ZeroPool_1; // rsi
unsigned __int8 *FormatString_1; // rdx
unsigned __int8 *FormatString_2; // r8
char *DestinationBuffer; // rbp
unsigned int **v15; // r15
UINTN Length; // rbx
__int64 v17; // rax
__int64 v18; // rcx
__int64 v20[9]; // [rsp+20h] [rbp-48h] BYREF
unsigned int *FormatStringa; // [rsp+80h] [rbp+18h] BYREF
va_list FormatStringb; // [rsp+80h] [rbp+18h]
va_list va1; // [rsp+88h] [rbp+20h] BYREF
va_start(va1, FormatString);
va_start(FormatStringb, FormatString);
FormatStringa = va_arg(va1, unsigned int *); /*0x78c8*/
FormatStringa_1 = (unsigned __int8 *)FormatStringa; /*0x78c8*/
if ( !a1 ) /*0x78f1*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\UefiHiiLib\\HiiLib.c", 0xA0u, "PackageListGuid != ((void *) 0)"); /*0x7906*/
FormatStringa_2 = FormatStringa; /*0x790b*/
v6 = 0; /*0x7913*/
FormatStringa_3 = FormatStringa; /*0x7916*/
if ( !FormatStringa ) /*0x791c*/
return 0; /*0x791c*/
va_copy((va_list)v8, FormatStringb); /*0x7922*/
do /*0x793b*/
{
++v8; /*0x7935*/
v6 += Assert_36(FormatStringa_3, FormatString, FormatStringa_1) - 4; /*0x7939*/
FormatStringa_3 = *v8; /*0x793b*/
}
while ( *v8 ); /*0x793b*/
if ( !v6 ) /*0x7945*/
return 0; /*0x7945*/
v9 = v6 + 24; /*0x794b*/
ZeroPool = (char *)AllocateZeroPool(4u); /*0x7953*/
ZeroPool_1 = ZeroPool; /*0x7958*/
if ( !ZeroPool ) /*0x795e*/
return 0; /*0x79f3*/
Assert_46(ZeroPool, a1); /*0x796a*/
*((_DWORD *)ZeroPool_1 + 4) = v9; /*0x796f*/
DestinationBuffer = ZeroPool_1 + 20; /*0x7972*/
va_copy((va_list)v15, FormatStringb); /*0x7976*/
do /*0x79a1*/
{
Length = (unsigned int)Assert_36(FormatStringa_2, FormatString_1, FormatString_2) - 4; /*0x7993*/
CopyMem(DestinationBuffer, FormatStringa_2 + 1, Length); /*0x7995*/
++v15; /*0x799a*/
DestinationBuffer += Length; /*0x799e*/
FormatStringa_2 = *v15; /*0x79a1*/
}
while ( *v15 ); /*0x79a1*/
CopyMem(DestinationBuffer, &SourceBuffer__0, 4u); /*0x79b7*/
v17 = (*(__int64 (__fastcall **)(__int64, char *, unsigned __int8 *, __int64 *))qword_D270)( /*0x79d1*/
qword_D270,
ZeroPool_1,
FormatString,
v20);
v18 = v20[0]; /*0x79d3*/
if ( v17 < 0 ) /*0x79db*/
v18 = 0; /*0x79db*/
v20[0] = v18; /*0x79df*/
AllocatePoolWithAssert(); /*0x79e7*/
return v20[0]; /*0x79f5*/
}
// Function: ReFlashReadRomLayout @ 0x7a04 (0xdf bytes)
unsigned __int64 __fastcall ReFlashReadRomLayout(_DWORD *Guid2, _QWORD *p_SourceBuffer)
{
_DWORD *Guid2_1; // rbx
unsigned int Data1; // ebp
if ( !p_SourceBuffer ) /*0x7a21*/
return 0x8000000000000002uLL; /*0x7ac4*/
Guid2_1 = Guid2 + 4194289; /*0x7a27*/
if ( Guid2 + 4194289 != (_DWORD *)((unsigned __int64)(Guid2 + 4194289) & 0xFFFFFFFFFFFFFFFCuLL) ) /*0x7a38*/
DebugAssert( /*0x7a4d*/
"e:\\hs\\AmiModulePkg\\Library\\AmiRomLayout\\AmiRomLayoutLibCommon.c",
0xC8u,
"(UINTN)SearchPointer == ((UINTN)SearchPointer & (~0x03))");
Data1 = Guid1__1.Data1; /*0x7a52*/
while ( Guid2_1 != Guid2 ) /*0x7a5b*/
{
if ( *Guid2_1 == Data1 /*0x7a8f*/
&& CompareGuid(&Guid1__1, (const GUID *)Guid2_1)
&& CompareGuid(&ImageHandle_, (const GUID *)(Guid2_1 + 7))
&& Guid2_1[11] == 1280134994 )
{
RegionSize = Guid2_1[13]; /*0x7a9a*/
LODWORD(n40) = Guid2_1[13] * Guid2_1[14]; /*0x7aa7*/
*p_SourceBuffer = Guid2_1 + 15; /*0x7ab1*/
return 0; /*0x7ab6*/
}
--Guid2_1; /*0x7a91*/
}
return 0x800000000000000EuLL; /*0x7add*/
}
// Function: ReFlashGetHiiString @ 0x7ae4 (0x4b bytes)
__int64 __fastcall ReFlashGetHiiString(__int64 a1)
{
__int64 v1; // rax
unsigned __int16 v2; // cx
unsigned __int16 v4; // [rsp+58h] [rbp+10h] BYREF
v1 = (*(__int64 (__fastcall **)(__int64, __int64, unsigned __int16 *, const char *, _QWORD, __int64, _QWORD))qword_F668)( /*0x7b15*/
qword_F668,
qword_F680,
&v4,
"en-US",
0,
a1,
0);
v2 = v4; /*0x7b17*/
if ( v1 ) /*0x7b24*/
return 2; /*0x7b24*/
return v2; /*0x7b2a*/
}
// Function: Assert_13 @ 0x7b30 (0xab bytes)
char *__fastcall Assert_13(__int64 a1, const CHAR16 *SourceBuffer)
{
UINTN AllocationSize; // rsi
_WORD *Pool; // rax
_WORD *Pool_1; // rdi
UINTN v7; // rax
char *v8; // rbx
__int64 SourceBuffera; // [rsp+40h] [rbp+18h] BYREF
if ( (*(__int64 (__fastcall **)(__int64, void *, __int64 *))(BootServices_0 + 152))(a1, &unk_C780, &SourceBuffera) ) /*0x7b55*/
return 0; /*0x7b55*/
AllocationSize = 2 * StrLen(SourceBuffer) + 6; /*0x7b6c*/
Pool = AllocatePool(AllocationSize); /*0x7b77*/
Pool_1 = Pool; /*0x7b7c*/
if ( !Pool ) /*0x7b82*/
return 0; /*0x7b60*/
*Pool = 1028; /*0x7b87*/
Assert_22(Pool, AllocationSize); /*0x7b8f*/
v7 = StrLen(SourceBuffer); /*0x7b97*/
CopyMem(Pool_1 + 2, SourceBuffer, 2 * v7 + 2); /*0x7bab*/
v8 = Assert_12((const void *)SourceBuffera, Pool_1); /*0x7bc0*/
AllocatePoolWithAssert(); /*0x7bc3*/
return v8; /*0x7bd5*/
}
// Function: Assert_0 @ 0x7bdc (0x218 bytes)
unsigned __int64 Assert_0(__int64 CtxPtr, __int64 a2, __int64 n100, ...)
{
const CHAR16 *SourceBuffer_1; // rdi
char *i_1; // rsi
unsigned __int64 result; // rax
__int64 v6; // rax
__int64 *v7; // rax
__int64 *v8; // rbx
const CHAR16 *SourceBuffer; // rax
__int64 i; // rcx
UINTN AllocationSize; // [rsp+48h] [rbp+20h] BYREF
va_list AllocationSizea; // [rsp+48h] [rbp+20h]
va_list va1; // [rsp+50h] [rbp+28h] BYREF
va_start(va1, n100);
va_start(AllocationSizea, n100);
AllocationSize = va_arg(va1, _QWORD); /*0x7bdc*/
SourceBuffer_1 = 0; /*0x7c07*/
i_1 = 0; /*0x7c09*/
if ( !(*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C6B0, 0, &qword_F688) ) /*0x7c0b*/
return (*(__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD, __int64 *))qword_F688)(0, 0, 0, &i_0); /*0x7c2b*/
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C800, 0, &qword_F690); /*0x7c47*/
if ( !result ) /*0x7c50*/
{
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C820, 0, &qword_F668); /*0x7c6d*/
if ( !result ) /*0x7c76*/
{
result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C830, 0, &qword_F678); /*0x7c93*/
if ( !result ) /*0x7c9c*/
{
AllocationSize = 0; /*0x7ca2*/
v6 = Assert_6((__int64)&qword_D030, 0, &unk_D040, 0); /*0x7cba*/
qword_F680 = v6; /*0x7cbf*/
if ( v6 ) /*0x7cc9*/
{
result = (*(__int64 (__fastcall **)(__int64, __int64, UINTN *, __int64))(qword_F690 + 32))( /*0x7cf3*/
qword_F690,
v6,
(UINTN *)AllocationSizea,
qword_D338);
if ( result == 0x8000000000000005uLL ) /*0x7d03*/
{
qword_D338 = (__int64)AllocatePool(AllocationSize); /*0x7d1b*/
result = (*(__int64 (__fastcall **)(__int64, __int64, UINTN *, __int64))(qword_F690 + 32))( /*0x7d2f*/
qword_F690,
qword_F680,
(UINTN *)AllocationSizea,
qword_D338);
}
if ( !result ) /*0x7d35*/
{
String = 0; /*0x7d3b*/
v7 = (__int64 *)Assert_4(); /*0x7d42*/
v8 = v7; /*0x7d47*/
if ( v7 ) /*0x7d4d*/
{
SourceBuffer = (const CHAR16 *)Assert_40((__int64)v7); /*0x7d52*/
SourceBuffer_1 = SourceBuffer; /*0x7d57*/
if ( SourceBuffer ) /*0x7d5d*/
i_1 = Assert_13(*v8, SourceBuffer); /*0x7d6a*/
}
(*(void (__fastcall **)(__int64, __int64))(qword_F690 + 8))(qword_F690, qword_F680); /*0x7d7e*/
AllocatePoolWithAssert(); /*0x7d89*/
i = i_0; /*0x7d8e*/
if ( i_1 ) /*0x7d98*/
i = (__int64)i_1; /*0x7d98*/
i_0 = i; /*0x7d9c*/
if ( SourceBuffer_1 ) /*0x7da6*/
AllocatePoolWithAssert(); /*0x7dab*/
if ( v8 ) /*0x7db3*/
AllocatePoolWithAssert(); /*0x7db8*/
if ( String ) /*0x7dc7*/
AllocatePoolWithAssert(); /*0x7dc9*/
return -(__int64)(i_1 == 0) & 0x800000000000000EuLL; /*0x7de1*/
}
}
else
{
return 0x8000000000000009uLL; /*0x7ccb*/
}
}
}
}
return result; /*0x7dee*/
}
// Function: Assert_15 @ 0x7df4 (0xa1 bytes)
bool __fastcall Assert_15(const CHAR16 *a1)
{
UINTN i; // rax
const CHAR16 *v4; // rbx
UINTN v5; // rax
__int64 v6; // rdx
const CHAR16 *Pool; // rsi
const CHAR16 *j; // r8
__int16 v9; // ax
_WORD *v10; // r8
__int64 v11; // rcx
CHAR16 *v12; // rbx
for ( i = StrLen(a1) - 1; a1[i] != 46; --i ) /*0x7e0b*/
{
if ( !i ) /*0x7e15*/
return 1; /*0x7e15*/
}
if ( !i ) /*0x7e24*/
return 1; /*0x7e28*/
v4 = &a1[i + 1]; /*0x7e2e*/
v5 = StrLen(v4); /*0x7e35*/
Pool = (const CHAR16 *)AllocatePool(2 * v5 + 2); /*0x7e47*/
for ( j = Pool; ; j = v10 + 1 ) /*0x7e4a*/
{
v11 = *v4; /*0x7e60*/
if ( !(_WORD)v11 ) /*0x7e66*/
break; /*0x7e66*/
v9 = CharToUpper(v11, v6, j); /*0x7e4f*/
*v10 = v9; /*0x7e54*/
++v4; /*0x7e58*/
}
*j = 0; /*0x7e6b*/
v12 = Assert_10(v11, Pool); /*0x7e77*/
AllocatePoolWithAssert(Pool); /*0x7e7a*/
return v12 != 0; /*0x7e8f*/
}
// Function: Assert_9 @ 0x7e98 (0xcd bytes)
void __fastcall Assert_9(CHAR16 *String)
{
UINTN v2; // rbx
UINTN v3; // rax
UINTN AllocationSize; // rbx
CHAR16 *Pool; // rax
const CHAR16 *%s%s; // r8
CHAR16 *Pool_1; // rsi
if ( String ) /*0x7ead*/
{
v2 = StrLen(::Pool); /*0x7ed8*/
v3 = StrLen(String); /*0x7edb*/
if ( v2 == 1 && *::Pool == 92 ) /*0x7ef3*/
{
AllocationSize = 2 * v3 + 4; /*0x7ef5*/
Pool = (CHAR16 *)AllocatePool(AllocationSize); /*0x7f00*/
%s%s = (const CHAR16 *)"%s%s"; /*0x7f05*/
}
else
{
AllocationSize = 2 * (v2 + v3) + 4; /*0x7f11*/
Pool = (CHAR16 *)AllocatePool(AllocationSize); /*0x7f1c*/
%s%s = "%s\\%s"; /*0x7f21*/
}
Pool_1 = Pool; /*0x7f3a*/
UnicodeSPrint(Pool, AllocationSize, %s%s, ::Pool, String); /*0x7f3d*/
AllocatePoolWithAssert(); /*0x7f49*/
::Pool = Pool_1; /*0x7f4e*/
}
else
{
::Pool = (CHAR16 *)AllocatePool(4u); /*0x7eb7*/
*(_DWORD *)::Pool = 92; /*0x7ebe*/
}
}
// Function: StrAllocatePad @ 0x7f68 (0x86 bytes)
char *__fastcall StrAllocatePad(const CHAR16 *SourceBuffer, __int64 a2)
{
UINTN v4; // rsi
char *Pool; // rbx
__int64 v6; // rcx
char *v7; // rdi
v4 = StrLen(SourceBuffer); /*0x7f8b*/
Pool = (char *)AllocatePool(2 * (v4 + a2) + 2); /*0x7fac*/
CopyMem(Pool, SourceBuffer, 2 * v4); /*0x7faf*/
if ( a2 ) /*0x7fb9*/
{
v6 = a2; /*0x7fbe*/
v7 = &Pool[2 * v4]; /*0x7fc4*/
while ( v6 ) /*0x7fc8*/
{
*(_WORD *)v7 = 32; /*0x7fc8*/
v7 += 2; /*0x7fc8*/
--v6; /*0x7fc8*/
}
v4 += a2; /*0x7fcb*/
}
*(_WORD *)&Pool[2 * v4] = 0; /*0x7fd6*/
return Pool; /*0x7fe4*/
}
// Function: CharToUpper @ 0x7ff0 (0x2f bytes)
__int64 __fastcall CharToUpper(unsigned __int16 a1, __int64 a2, const CHAR16 *j)
{
unsigned int v3; // eax
int n2139095039; // edx
if ( (unsigned __int16)(a1 - 97) <= 0x19u ) /*0x7ff7*/
return (unsigned int)a1 - 32; /*0x7ff7*/
v3 = a1; /*0x7ffe*/
if ( (unsigned __int16)(a1 - 224) <= 0x1Eu /*0x8012*/
&& (n2139095039 = 2139095039, LOWORD(v3) = a1 - 224, _bittest(&n2139095039, v3)) )
{
return (unsigned int)a1 - 32; /*0x801b*/
}
else
{
return a1; /*0x8014*/
}
}
// Function: Assert_11 @ 0x8020 (0xc2 bytes)
__int64 __fastcall Assert_11(const CHAR16 *SourceBuffer, CHAR16 *SourceBuffer_2)
{
__int64 j_2; // r14
char *SourceBuffer_4; // rbp
const CHAR16 *SourceBuffer_1; // rdi
UINTN v6; // rsi
UINTN v7; // rax
__int64 v8; // rdx
const CHAR16 *j; // r8
char *SourceBuffer_3; // rax
unsigned __int16 v11; // cx
signed __int64 v12; // rdi
unsigned __int16 j_1; // ax
__int64 v14; // rdx
unsigned __int16 v15; // ax
int v16; // r8d
j_2 = 0; /*0x803e*/
SourceBuffer_4 = 0; /*0x8041*/
SourceBuffer_1 = SourceBuffer; /*0x8044*/
v6 = StrLen(SourceBuffer); /*0x804f*/
v7 = StrLen(SourceBuffer_2); /*0x8052*/
if ( v7 <= v6 ) /*0x805a*/
{
if ( v7 >= v6 ) /*0x806f*/
goto LABEL_6; /*0x806f*/
SourceBuffer_3 = StrAllocatePad(SourceBuffer_2, v6 - v7); /*0x807a*/
SourceBuffer_2 = (CHAR16 *)SourceBuffer_3; /*0x807f*/
}
else
{
SourceBuffer_3 = StrAllocatePad(SourceBuffer_1, v7 - v6); /*0x8065*/
SourceBuffer_1 = (const CHAR16 *)SourceBuffer_3; /*0x806a*/
}
SourceBuffer_4 = SourceBuffer_3; /*0x8082*/
LABEL_6:
v11 = *SourceBuffer_1; /*0x8085*/
if ( *SourceBuffer_1 ) /*0x8085*/
{
v12 = (char *)SourceBuffer_1 - (char *)SourceBuffer_2; /*0x808d*/
do /*0x80b7*/
{
j_1 = CharToUpper(v11, v8, j); /*0x8090*/
v15 = CharToUpper(*SourceBuffer_2, v14, (const CHAR16 *)j_1); /*0x809c*/
j = (const CHAR16 *)(v16 - (unsigned int)v15); /*0x80a4*/
j_2 = (int)j; /*0x80a7*/
if ( (_DWORD)j ) /*0x80aa*/
break; /*0x80aa*/
v11 = *(CHAR16 *)((char *)++SourceBuffer_2 + v12); /*0x80b0*/
}
while ( v11 ); /*0x80b7*/
}
if ( SourceBuffer_4 ) /*0x80bc*/
AllocatePoolWithAssert(); /*0x80c1*/
return j_2; /*0x80d8*/
}
// Function: Assert_41 @ 0x80e4 (0x101 bytes)
__int64 __fastcall Assert_41(const CHAR16 *SourceBuffer, CHAR16 *SourceBuffer_2)
{
UINTN v4; // rdi
UINTN i_1; // rax
__int64 v6; // rbp
UINTN i; // rbx
CHAR16 *SourceBuffer_3; // rdx
const CHAR16 *SourceBuffer_1; // rcx
__int64 v10; // rax
__int64 result; // rax
__int64 v12; // rax
v4 = StrLen(SourceBuffer); /*0x810f*/
i_1 = StrLen(SourceBuffer_2); /*0x8112*/
v6 = 1; /*0x8117*/
for ( i = i_1; v4; --v4 ) /*0x8129*/
{
if ( SourceBuffer[v4] == 46 ) /*0x8130*/
break; /*0x8130*/
}
if ( i_1 ) /*0x813a*/
{
do /*0x8146*/
{
if ( SourceBuffer_2[i] == 46 ) /*0x8141*/
break; /*0x8141*/
--i; /*0x8143*/
}
while ( i ); /*0x8146*/
}
SourceBuffer_3 = SourceBuffer_2; /*0x8148*/
SourceBuffer_1 = SourceBuffer; /*0x814b*/
if ( !v4 ) /*0x8151*/
{
if ( i ) /*0x8156*/
{
SourceBuffer_2[i] = 0; /*0x8158*/
v10 = Assert_11(SourceBuffer, SourceBuffer_2); /*0x815d*/
SourceBuffer_2[i] = 46; /*0x8166*/
if ( v10 <= 0 ) /*0x816e*/
return -1; /*0x816e*/
return v6; /*0x8175*/
}
return Assert_11(SourceBuffer_1, SourceBuffer_3); /*0x8156*/
}
SourceBuffer[v4] = 0; /*0x8177*/
if ( !i ) /*0x817f*/
{
v12 = Assert_11(SourceBuffer, SourceBuffer_2); /*0x8181*/
SourceBuffer[v4] = 46; /*0x818a*/
if ( v12 < 0 ) /*0x8192*/
return -1; /*0x8192*/
return v6; /*0x8192*/
}
SourceBuffer_2[i] = 0; /*0x8198*/
result = Assert_11(SourceBuffer, SourceBuffer_2); /*0x819d*/
SourceBuffer[v4] = 46; /*0x81a2*/
SourceBuffer_2[i] = 46; /*0x81a7*/
if ( !result ) /*0x81af*/
{
SourceBuffer_3 = &SourceBuffer_2[i + 1]; /*0x81b9*/
SourceBuffer_1 = &SourceBuffer[v4 + 1]; /*0x81bd*/
return Assert_11(SourceBuffer_1, SourceBuffer_3); /*0x81c1*/
}
return result; /*0x81da*/
}
// Function: Assert_47 @ 0x81e8 (0x6e bytes)
__int64 __fastcall Assert_47(__int64 *a1, __int64 *a2)
{
__int64 v2; // r8
__int64 v3; // rax
v2 = *a1; /*0x81e8*/
v3 = *a2; /*0x81ef*/
if ( *(_WORD *)(*a1 + 80) == 46 && *(_WORD *)(v2 + 82) == 46 && !*(_WORD *)(v2 + 84) ) /*0x8200*/
return -1; /*0x8206*/
if ( *(_WORD *)(v3 + 80) == 46 && *(_WORD *)(v3 + 82) == 46 && !*(_WORD *)(v3 + 84) ) /*0x8219*/
return 1; /*0x821e*/
if ( (*(_BYTE *)(v2 + 72) & 0x10) != 0 ) /*0x8239*/
{
if ( (*(_BYTE *)(v3 + 72) & 0x10) == 0 ) /*0x823d*/
return -1; /*0x820c*/
}
else if ( (*(_BYTE *)(v3 + 72) & 0x10) == 0 ) /*0x8243*/
{
return Assert_41((const CHAR16 *)(v2 + 80), (const CHAR16 *)(v3 + 80)); /*0x8243*/
}
if ( (*(_BYTE *)(v2 + 72) & 0x10) == 0 ) /*0x8247*/
return 1; /*0x8225*/
return Assert_41((const CHAR16 *)(v2 + 80), (const CHAR16 *)(v3 + 80)); /*0x820c*/
}
// Function: Assert_2 @ 0x8258 (0x1fb bytes)
char **__fastcall Assert_2(__int64 a1)
{
char **p_SourceBuffer; // r14
CHAR16 *Pool; // rbx
__int64 v4; // r15
bool v5; // al
CHAR16 *ZeroPool; // rsi
UINTN v7; // rbp
const CHAR16 *_%s__1; // r8
char *DestinationBuffer; // r12
const CHAR16 *_%s_; // r8
UINTN AllocationSize; // [rsp+50h] [rbp+8h] BYREF
p_SourceBuffer = (char **)ListAllocate(100, 112, 50); /*0x828b*/
do /*0x8414*/
{
AllocationSize = 0; /*0x8296*/
Pool = 0; /*0x82a3*/
v4 = (*(__int64 (__fastcall **)(__int64, UINTN *, _QWORD))(a1 + 32))(a1, &AllocationSize, 0); /*0x82aa*/
if ( v4 == 0x8000000000000005uLL ) /*0x82ba*/
{
Pool = (CHAR16 *)AllocatePool(AllocationSize); /*0x82d1*/
v4 = (*(__int64 (__fastcall **)(__int64, UINTN *, CHAR16 *))(a1 + 32))(a1, &AllocationSize, Pool); /*0x82d8*/
}
if ( v4 >= 0 && AllocationSize && (Pool[40] != 46 || Pool[41]) ) /*0x82f8*/
{
if ( (Pool[36] & 6) != 0 ) /*0x8307*/
{
v5 = 0; /*0x831c*/
}
else
{
if ( !String ) /*0x8310*/
goto LABEL_13; /*0x8310*/
v5 = Assert_15(Pool + 40); /*0x8315*/
}
if ( v5 ) /*0x8321*/
{
LABEL_13:
ZeroPool = (CHAR16 *)AllocatePool(0x70u); /*0x8327*/
*(_QWORD *)ZeroPool = Pool; /*0x8334*/
v7 = (-(__int64)((Pool[36] & 0x10) != 0) & 0xFFFFFFFFFFFFFFFEuLL) + 49; /*0x8349*/
if ( StrLen(Pool + 40) >= v7 ) /*0x8355*/
{
DestinationBuffer = (char *)AllocatePool(2 * v7 + 2); /*0x8399*/
CopyMem(DestinationBuffer, Pool + 40, 2 * v7 - 6); /*0x839c*/
*(_DWORD *)&DestinationBuffer[2 * v7 - 6] = 3014702; /*0x83a1*/
*(_DWORD *)&DestinationBuffer[2 * v7 - 2] = 46; /*0x83ae*/
_%s_ = (const CHAR16 *)"<%s>"; /*0x83b7*/
if ( (Pool[36] & 0x10) == 0 ) /*0x83ca*/
_%s_ = "%s"; /*0x83cc*/
UnicodeSPrint(ZeroPool + 5, 0x64u, _%s_, Pool + 40); /*0x83d3*/
AllocatePoolWithAssert(); /*0x83db*/
}
else
{
_%s__1 = (const CHAR16 *)"<%s>"; /*0x8362*/
if ( (Pool[36] & 0x10) == 0 ) /*0x836e*/
_%s__1 = "%s"; /*0x8370*/
UnicodeSPrint(ZeroPool + 5, 0x64u, _%s__1, Pool + 40); /*0x8377*/
}
Assert_18(p_SourceBuffer, ZeroPool); /*0x83e9*/
AllocatePoolWithAssert(); /*0x83f1*/
continue; /*0x83fb*/
}
}
if ( Pool ) /*0x8400*/
AllocatePoolWithAssert(); /*0x8405*/
}
while ( AllocationSize && v4 >= 0 ); /*0x8414*/
Assert_16( /*0x842e*/
*p_SourceBuffer,
(unsigned int)(*((_DWORD *)p_SourceBuffer + 3) / *((_DWORD *)p_SourceBuffer + 4)),
*((unsigned int *)p_SourceBuffer + 4));
return p_SourceBuffer; /*0x8445*/
}
// Function: Assert_3 @ 0x8454 (0x175 bytes)
unsigned __int64 __fastcall Assert_3(__int64 a1)
{
__int64 v1; // rdi
unsigned __int64 i_1; // r15
_WORD *ZeroPool; // r14
_WORD *ZeroPool_1; // rbp
unsigned __int64 i; // rbx
unsigned __int64 v7; // rcx
__int64 v8; // rbx
int v10; // [rsp+20h] [rbp-28h]
unsigned __int16 v11; // [rsp+50h] [rbp+8h] BYREF
v1 = 0; /*0x846e*/
v11 = 0; /*0x8470*/
i_1 = (unsigned int)(*(_DWORD *)(a1 + 12) / *(_DWORD *)(a1 + 16)); /*0x8480*/
ZeroPool = AllocateZeroPool(4u); /*0x8490*/
ZeroPool_1 = ZeroPool; /*0x8493*/
for ( i = 0; i < i_1; ZeroPool += 20 ) /*0x849b*/
{
if ( i < (unsigned int)(*(_DWORD *)(a1 + 12) / *(_DWORD *)(a1 + 16)) ) /*0x84aa*/
v7 = *(_QWORD *)a1 + i * *(unsigned int *)(a1 + 16); /*0x84b8*/
else
v7 = 0; /*0x84ac*/
*ZeroPool = ReFlashGetHiiString(v7 + 10); /*0x84c4*/
++i; /*0x84c8*/
}
(*(void (__fastcall **)(__int64, __int64, __int64, const char *, CHAR16 *, _QWORD))(qword_F668 + 16))( /*0x8505*/
qword_F668,
qword_F680,
3,
"en-US",
Pool,
0);
(*(void (__fastcall **)(__int64, __int64, __int64, const char *, __int64, _QWORD))(qword_F668 + 16))( /*0x8535*/
qword_F668,
qword_F680,
4,
"en-US",
qword_D3F0,
0);
LOWORD(v10) = i_1; /*0x8559*/
v8 = (*(__int64 (__fastcall **)(__int64, __int64, __int64, _WORD *, int, unsigned __int16 *))(qword_F678 + 104))( /*0x8565*/
qword_F680,
3,
4,
ZeroPool_1,
v10,
&v11);
AllocatePoolWithAssert(); /*0x8568*/
(*(void (__fastcall **)(__int64, __int64, __int64))(qword_F690 + 16))(qword_F690, qword_F680, qword_D338); /*0x8585*/
if ( !v8 && v11 < (unsigned __int64)(unsigned int)(*(_DWORD *)(a1 + 12) / *(_DWORD *)(a1 + 16)) ) /*0x85a1*/
return *(_QWORD *)a1 + v11 * (unsigned __int64)*(unsigned int *)(a1 + 16); /*0x85aa*/
return v1; /*0x85bf*/
}
// Function: Assert_20 @ 0x85cc (0x6c bytes)
void __fastcall Assert_20(__int64 a1)
{
unsigned int i_1; // eax
unsigned __int64 i_2; // rdi
unsigned __int64 i; // rsi
i_1 = *(_DWORD *)(a1 + 12) / *(_DWORD *)(a1 + 16); /*0x85e0*/
i_2 = 0; /*0x85e3*/
for ( i = i_1; i_2 < i; ++i_2 ) /*0x85ec*/
{
if ( i_2 < (unsigned int)(*(_DWORD *)(a1 + 12) / *(_DWORD *)(a1 + 16)) /*0x8604*/
&& *(_QWORD *)a1 + i_2 * *(unsigned int *)(a1 + 16) )
{
AllocatePoolWithAssert(); /*0x860c*/
}
}
AllocatePoolWithAssert(); /*0x861c*/
AllocatePoolWithAssert(); /*0x8633*/
}
// Function: Assert_39 @ 0x8638 (0x1de bytes)
__int64 *__fastcall Assert_39(__int64 *a1)
{
_DWORD *v1; // rdi
UINTN i; // rax
int i_1; // edx
__int64 v4; // rcx
char **v5; // rdi
int v6; // ecx
__int64 v7; // rdx
__int64 v8; // rcx
__int64 v9; // rax
__int64 *v11; // rax
__int64 *v12; // r8
__int64 v13; // rax
int v14; // edx
__int64 i_2; // rcx
__int64 v16; // [rsp+40h] [rbp+8h] BYREF
v1 = (_DWORD *)(*a1 + 80); /*0x864c*/
if ( *v1 != 3014702 || *(_WORD *)(*a1 + 84) ) /*0x8665*/
{
Assert_9((CHAR16 *)(*a1 + 80)); /*0x872e*/
if ( dword_D400 ) /*0x8742*/
v9 = qword_D410[dword_D400 - 1]; /*0x8746*/
else
v9 = 0; /*0x8750*/
v16 = v9; /*0x8753*/
if ( !v9 || (*(__int64 (__fastcall **)(__int64, __int64 *, _DWORD *, __int64, _QWORD))(v9 + 8))(v9, &v16, v1, 1, 0) ) /*0x877a*/
return 0; /*0x8780*/
v5 = Assert_2(v16); /*0x878c*/
}
else
{
for ( i = StrLen(Pool); Pool[i] != 92; --i ) /*0x8676*/
; /*0x8684*/
if ( i ) /*0x8691*/
Pool[i] = 0; /*0x8693*/
else
Pool[1] = 0; /*0x8699*/
i_1 = ::i; /*0x869e*/
v4 = qword_D350[::i]; /*0x86ab*/
if ( v4 ) /*0x86b6*/
{
Assert_20(v4); /*0x86b8*/
i_1 = ::i; /*0x86bd*/
qword_D350[::i] = 0; /*0x86c3*/
}
if ( i_1 ) /*0x86cd*/
{
::i = i_1 - 1; /*0x86d1*/
v5 = (char **)qword_D350[i_1 - 1]; /*0x86d7*/
}
else
{
v5 = 0; /*0x86e1*/
}
v6 = dword_D400; /*0x86e4*/
v7 = qword_D410[dword_D400]; /*0x86ea*/
if ( v7 ) /*0x86f5*/
{
(*(void (__fastcall **)(__int64))(v7 + 16))(qword_D410[dword_D400]); /*0x86fa*/
v6 = dword_D400; /*0x86fd*/
qword_D410[dword_D400] = 0; /*0x8703*/
}
if ( v6 ) /*0x870d*/
{
dword_D400 = v6 - 1; /*0x8711*/
v8 = qword_D410[v6 - 1]; /*0x8717*/
}
else
{
v8 = 0; /*0x8721*/
}
v16 = v8; /*0x8724*/
}
if ( !v5 ) /*0x8792*/
return 0; /*0x875f*/
v11 = (__int64 *)Assert_3((__int64)v5); /*0x8797*/
v12 = v11; /*0x879c*/
if ( !v11 ) /*0x87a2*/
return v12; /*0x87a2*/
v13 = *v11; /*0x87a4*/
if ( (*(_BYTE *)(v13 + 72) & 0x10) == 0 ) /*0x87b2*/
return v12; /*0x8803*/
if ( *(_WORD *)(v13 + 80) != 46 || *(_WORD *)(v13 + 82) != 46 || *(_WORD *)(v13 + 84) ) /*0x87c2*/
{
v14 = dword_D400; /*0x87c8*/
i_2 = (unsigned int)::i; /*0x87ce*/
qword_D410[dword_D400] = v16; /*0x87d9*/
qword_D350[i_2] = (__int64)v5; /*0x87e3*/
::i = i_2 + 1; /*0x87ed*/
dword_D400 = v14 + 1; /*0x87f3*/
}
return Assert_39(v12); /*0x8810*/
}
// Function: Assert_40 @ 0x8818 (0x176 bytes)
unsigned __int64 __fastcall Assert_40(__int64 a1)
{
char **v3; // rbx
unsigned __int64 v4; // rax
__int64 *v5; // rdi
int i_1; // ecx
__int64 v7; // rdx
__int64 v8; // rax
int v9; // eax
unsigned int v10; // esi
__int64 v11; // rbx
unsigned int i; // esi
__int64 i_2; // rbx
__int64 v14; // [rsp+40h] [rbp+8h] BYREF
if ( (*(__int64 (__fastcall **)(_QWORD, __int64 *))(*(_QWORD *)(a1 + 8) + 8LL))(*(_QWORD *)(a1 + 8), &v14) ) /*0x8839*/
return 0; /*0x8839*/
v3 = Assert_2(v14); /*0x8854*/
if ( !v3 ) /*0x885a*/
return 0; /*0x8843*/
qword_D3F0 = a1 + 18; /*0x8865*/
Pool = (CHAR16 *)AllocatePool(4u); /*0x8874*/
*(_DWORD *)Pool = 92; /*0x887b*/
v4 = Assert_3((__int64)v3); /*0x8881*/
v5 = (__int64 *)v4; /*0x888d*/
if ( v4 ) /*0x8893*/
{
if ( (*(_BYTE *)(*(_QWORD *)v4 + 72LL) & 0x10) != 0 ) /*0x88a3*/
{
i_1 = ::i; /*0x88a5*/
v7 = (unsigned int)dword_D400; /*0x88ab*/
v8 = v14; /*0x88b1*/
qword_D350[::i] = (__int64)v3; /*0x88b6*/
qword_D410[v7] = v8; /*0x88c0*/
::i = i_1 + 1; /*0x88ca*/
dword_D400 = v7 + 1; /*0x88d3*/
v5 = Assert_39(v5); /*0x88de*/
}
if ( v5 ) /*0x88e4*/
Assert_9((CHAR16 *)(*v5 + 80)); /*0x88ed*/
}
v9 = dword_D400; /*0x88f2*/
if ( !dword_D400 && v5 ) /*0x88ff*/
{
Assert_20((__int64)v3); /*0x8904*/
v9 = dword_D400; /*0x8909*/
}
v10 = 0; /*0x890f*/
if ( v9 ) /*0x8913*/
{
do /*0x8935*/
{
v11 = v10; /*0x8915*/
(*(void (__fastcall **)(__int64))(qword_D410[v10] + 16))(qword_D410[v10]); /*0x8922*/
++v10; /*0x8925*/
qword_D410[v11] = 0; /*0x8927*/
}
while ( v10 < dword_D400 ); /*0x8935*/
}
for ( i = 0; i < ::i; qword_D350[i_2] = 0 ) /*0x893f*/
{
i_2 = i; /*0x8941*/
Assert_20(qword_D350[i++]); /*0x894b*/
}
::i = 0; /*0x8965*/
dword_D400 = 0; /*0x896b*/
return (unsigned __int64)Pool & -(__int64)(v5 != 0); /*0x8985*/
}
// Function: Assert_7 @ 0x8990 (0xe2 bytes)
void *__fastcall Assert_7(unsigned __int64 *p_n0x40000000, _QWORD *a2)
{
__int64 v2; // rax
void *DestinationBuffer; // rbx
char *Pool; // rdi
__int64 v7; // rax
UINTN AllocationSize; // [rsp+38h] [rbp+10h] BYREF
v2 = *a2; /*0x89a5*/
DestinationBuffer = 0; /*0x89b2*/
AllocationSize = 0; /*0x89be*/
Pool = 0; /*0x89c5*/
v7 = (*(__int64 (__fastcall **)(__int64, void *, UINTN *, _QWORD))(v2 + 64))(v2, &unk_C740, &AllocationSize, 0); /*0x89c7*/
if ( v7 == 0x8000000000000005uLL ) /*0x89d7*/
{
Pool = (char *)AllocatePool(AllocationSize); /*0x89f8*/
v7 = (*(__int64 (__fastcall **)(_QWORD, void *, UINTN *, char *))(*a2 + 64LL))( /*0x89fb*/
*a2,
&unk_C740,
&AllocationSize,
Pool);
}
if ( v7 ) /*0x8a02*/
{
*p_n0x40000000 = 0; /*0x8a04*/
return 0; /*0x8a07*/
}
else
{
*p_n0x40000000 = *((_QWORD *)Pool + 2); /*0x8a0f*/
if ( *((_WORD *)Pool + 18) ) /*0x8a16*/
{
AllocationSize = 2 * StrLen((const CHAR16 *)Pool + 18) + 2; /*0x8a2b*/
DestinationBuffer = AllocatePool(AllocationSize); /*0x8a40*/
CopyMem(DestinationBuffer, Pool + 36, AllocationSize); /*0x8a43*/
}
(*(void (__fastcall **)(_QWORD))(*a2 + 16LL))(*a2); /*0x8a4e*/
AllocatePoolWithAssert(); /*0x8a54*/
return DestinationBuffer; /*0x8a59*/
}
}
// Function: Assert_45 @ 0x8a74 (0x4a bytes)
char __fastcall Assert_45(__int64 i, char n3)
{
__int64 j; // rbx
for ( j = i; ; i = j ) /*0x8a81*/
{
if ( Assert_29(i) ) /*0x8aa1*/
return -1; /*0x8aaa*/
if ( Assert_38(j) == n3 ) /*0x8a94*/
break; /*0x8a94*/
j = Assert_31(j); /*0x8a9b*/
}
return Assert_35(j); /*0x8ab1*/
}
// Function: StrTruncate @ 0x8ac0 (0x83 bytes)
UINTN __fastcall StrTruncate(char *DestinationBuffer, const CHAR16 *SourceBuffer, UINTN n0x28)
{
UINTN n0x28_1; // rax
UINTN n0x28_2; // rbx
n0x28_1 = StrLen(SourceBuffer); /*0x8ae0*/
n0x28_2 = n0x28_1; /*0x8ae5*/
if ( n0x28_1 >= n0x28 ) /*0x8af1*/
{
CopyMem(DestinationBuffer, SourceBuffer, 2 * n0x28 - 6); /*0x8b09*/
CopyMem(&DestinationBuffer[2 * n0x28 - 6], L"...", 6u); /*0x8b26*/
return n0x28; /*0x8b2b*/
}
else
{
CopyMem(DestinationBuffer, SourceBuffer, 2 * n0x28_1); /*0x8af7*/
return n0x28_2; /*0x8afc*/
}
}
// Function: DeviceTypeToStr @ 0x8b44 (0xfc bytes)
UINTN __fastcall DeviceTypeToStr(CHAR16 *StartOfBuffer, __int64 i)
{
char n0xE; // al
const CHAR16 *ATAPI; // rsi
char n2; // al
const CHAR16 *HDD; // rbp
UINTN v8; // rdi
UINTN v9; // rbx
UINTN n40; // rax
n0xE = Assert_45(i, 3); /*0x8b68*/
if ( n0xE == 1 ) /*0x8b6f*/
{
ATAPI = L"ATAPI"; /*0x8ba9*/
}
else if ( n0xE == 2 ) /*0x8b73*/
{
ATAPI = L"SCSI"; /*0x8ba0*/
}
else
{
if ( n0xE != 5 ) /*0x8b77*/
{
if ( (unsigned __int8)n0xE <= 0xEu ) /*0x8b7b*/
{
LABEL_8:
ATAPI = L"Unknown"; /*0x8b8e*/
goto LABEL_12; /*0x8b95*/
}
if ( (unsigned __int8)n0xE > 0x10u ) /*0x8b7f*/
{
if ( n0xE == 18 ) /*0x8b83*/
{
ATAPI = L"SATA"; /*0x8b85*/
goto LABEL_12; /*0x8b8c*/
}
goto LABEL_8; /*0x8b83*/
}
}
ATAPI = L"USB"; /*0x8b97*/
}
LABEL_12:
n2 = Assert_45(i, 4); /*0x8bb0*/
if ( n2 == 1 ) /*0x8bc0*/
{
HDD = L"HDD"; /*0x8bd9*/
}
else if ( n2 == 2 ) /*0x8bc5*/
{
HDD = L"CDROM"; /*0x8bd0*/
}
else
{
HDD = L"Unknown"; /*0x8bc7*/
}
v8 = StrLen(ATAPI); /*0x8beb*/
v9 = StrLen(HDD); /*0x8c0a*/
UnicodeSPrint(StartOfBuffer, 0x50u, "%s %s", (const char *)HDD, (const char *)ATAPI); /*0x8c0d*/
n40 = 40; /*0x8c28*/
if ( v9 + v8 + 1 < 0x28 ) /*0x8c35*/
return v9 + v8 + 1; /*0x8c35*/
return n40; /*0x8c39*/
}
// Function: Assert @ 0x8c40 (0x228 bytes)
_DWORD *Assert()
{
__int64 v0; // rsi
_QWORD *p_SourceBuffer; // r15
UINTN v2; // r14
char *ZeroPool; // rdi
unsigned __int64 n0x40000000_1; // rbx
const CHAR16 *SourceBuffer; // rax
UINTN BufferSize; // rdx
CHAR16 *StartOfBuffer; // rcx
__int64 v9; // [rsp+30h] [rbp-18h] BYREF
_QWORD v10[2]; // [rsp+38h] [rbp-10h] BYREF
__int64 v11; // [rsp+80h] [rbp+38h] BYREF
unsigned __int64 n0x40000000; // [rsp+88h] [rbp+40h] BYREF
__int64 i; // [rsp+90h] [rbp+48h] BYREF
unsigned __int64 n100; // [rsp+98h] [rbp+50h] BYREF
if ( (*(__int64 (__fastcall **)(__int64, void *, _QWORD, unsigned __int64 *, __int64 *))(BootServices_0 + 312))( /*0x8c88*/
2,
&unk_C810,
0,
&n100,
&v11)
|| !n100 )
{
return 0; /*0x8e59*/
}
v0 = 0; /*0x8c9e*/
p_SourceBuffer = ListAllocate(n100, 120, 1); /*0x8ca0*/
if ( n100 ) /*0x8ca7*/
{
while ( 1 ) /*0x8cc3*/
{
v2 = 0; /*0x8cc3*/
if ( !(*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices_0 + 152))( /*0x8cca*/
*(_QWORD *)(v11 + 8 * v0),
&unk_C810,
&v9) )
break; /*0x8cca*/
LABEL_22:
if ( ++v0 >= n100 ) /*0x8e40*/
goto LABEL_23; /*0x8e40*/
}
ZeroPool = (char *)AllocateZeroPool(4u); /*0x8ce8*/
*((_QWORD *)ZeroPool + 1) = v9; /*0x8ceb*/
*(_QWORD *)ZeroPool = *(_QWORD *)(v11 + 8 * v0); /*0x8cf7*/
if ( (*(__int64 (__fastcall **)(__int64, _QWORD *))(v9 + 8))(v9, v10) ) /*0x8d05*/
{
n0x40000000_1 = 0; /*0x8d0e*/
n0x40000000 = 0; /*0x8d10*/
}
else
{
SourceBuffer = (const CHAR16 *)Assert_7(&n0x40000000, v10); /*0x8d1e*/
if ( SourceBuffer ) /*0x8d29*/
{
v2 = StrTruncate(ZeroPool + 18, SourceBuffer, 0x28u); /*0x8d40*/
AllocatePoolWithAssert(); /*0x8d43*/
n0x40000000_1 = n0x40000000; /*0x8d48*/
LABEL_14:
BufferSize = 100 - 2 * v2; /*0x8db8*/
StartOfBuffer = (CHAR16 *)&ZeroPool[2 * v2 + 18]; /*0x8dc8*/
if ( n0x40000000_1 >= 0x100000 ) /*0x8dd2*/
{
if ( n0x40000000_1 >= 0x40000000 ) /*0x8de8*/
{
if ( n0x40000000_1 >= 0x10000000000LL ) /*0x8e04*/
UnicodeSPrint(StartOfBuffer, BufferSize, " %dTB", n0x40000000_1 >> 40); /*0x8e21*/
else
UnicodeSPrint(StartOfBuffer, BufferSize, (const CHAR16 *)" %dGB", n0x40000000_1 >> 30); /*0x8e11*/
}
else
{
UnicodeSPrint(StartOfBuffer, BufferSize, (const CHAR16 *)" %dMB", n0x40000000_1 >> 20); /*0x8df5*/
}
}
else
{
UnicodeSPrint(StartOfBuffer, BufferSize, (const CHAR16 *)" %dKB", n0x40000000_1 >> 10); /*0x8ddf*/
}
Assert_18(p_SourceBuffer, (CHAR16 *)ZeroPool); /*0x8e2c*/
AllocatePoolWithAssert(); /*0x8e34*/
goto LABEL_22; /*0x8e34*/
}
n0x40000000_1 = n0x40000000; /*0x8d4e*/
}
(*(void (__fastcall **)(_QWORD, void *, __int64 *))(BootServices_0 + 152))(*(_QWORD *)(v11 + 8 * v0), &unk_C780, &i); /*0x8d6c*/
if ( Assert_45(i, 3) == -1 && Assert_45(i, 4) == -1 ) /*0x8d8e*/
StrTruncate(ZeroPool + 18, L"Unknown", 0x12u); /*0x8da1*/
else
v2 = DeviceTypeToStr((CHAR16 *)ZeroPool + 9, i); /*0x8db5*/
goto LABEL_14; /*0x8da6*/
}
LABEL_23:
(*(void (__fastcall **)(__int64))(BootServices_0 + 72))(v11); /*0x8e46*/
return p_SourceBuffer; /*0x8e5b*/
}
// Function: Assert_4 @ 0x8e68 (0x150 bytes)
_DWORD *Assert_4()
{
const void *SourceBuffer; // rdi
void *Pool; // rbp
_DWORD *result; // rax
_DWORD *v3; // rsi
unsigned __int64 i_1; // r15
_WORD *ZeroPool; // r14
_WORD *ZeroPool_1; // r12
unsigned __int64 i; // rbx
unsigned __int64 v8; // rcx
__int64 v9; // rbx
unsigned __int16 v10; // [rsp+60h] [rbp+8h] BYREF
SourceBuffer = 0; /*0x8e7e*/
v10 = 0; /*0x8e80*/
Pool = 0; /*0x8e85*/
result = Assert(); /*0x8e87*/
v3 = result; /*0x8e8c*/
if ( result ) /*0x8e92*/
{
i_1 = (unsigned int)(result[3] / result[4]); /*0x8ea5*/
ZeroPool = AllocateZeroPool(4u); /*0x8eb5*/
ZeroPool_1 = ZeroPool; /*0x8eb8*/
for ( i = 0; i < i_1; ZeroPool += 20 ) /*0x8ec1*/
{
if ( i < (unsigned int)(v3[3] / v3[4]) ) /*0x8ed0*/
v8 = *(_QWORD *)v3 + i * (unsigned int)v3[4]; /*0x8ede*/
else
v8 = 0; /*0x8ed2*/
*ZeroPool = ReFlashGetHiiString(v8 + 18); /*0x8eea*/
++i; /*0x8eee*/
}
v9 = (*(__int64 (__fastcall **)(__int64, __int64, __int64, _WORD *, _WORD, unsigned __int16 *))(qword_F678 + 104))( /*0x8f2a*/
qword_F680,
3,
4,
ZeroPool_1,
i_1,
&v10);
AllocatePoolWithAssert(); /*0x8f2d*/
if ( !v9 ) /*0x8f35*/
{
Pool = AllocatePool(0x78u); /*0x8f49*/
if ( v10 < (unsigned __int64)(unsigned int)(v3[3] / v3[4]) ) /*0x8f59*/
SourceBuffer = (const void *)(*(_QWORD *)v3 + v10 * (unsigned __int64)(unsigned int)v3[4]); /*0x8f62*/
CopyMem(Pool, SourceBuffer, 0x78u); /*0x8f6e*/
}
AllocatePoolWithAssert(); /*0x8f76*/
AllocatePoolWithAssert(); /*0x8f7e*/
(*(void (__fastcall **)(__int64, __int64, __int64))(qword_F690 + 16))(qword_F690, qword_F680, qword_D338); /*0x8f9b*/
return Pool; /*0x8f9e*/
}
return result; /*0x8fab*/
}
// Function: ListAllocate @ 0x8fb8 (0x5a bytes)
_DWORD *__fastcall ListAllocate(int n100, int n120, int n50)
{
unsigned int AllocationSize; // ebx
_DWORD *Pool; // rsi
AllocationSize = n120 * n100; /*0x8fdd*/
Pool = AllocatePool(0x18u); /*0x8fe0*/
Pool[3] = 0; /*0x8fe3*/
Pool[4] = n120; /*0x8fe7*/
Pool[2] = AllocationSize; /*0x8fec*/
Pool[5] = n50; /*0x8fef*/
*(_QWORD *)Pool = AllocatePool(AllocationSize); /*0x9001*/
return Pool; /*0x900c*/
}
// Function: Assert_18 @ 0x9014 (0x7a bytes)
__int64 __fastcall Assert_18(_QWORD *p_SourceBuffer, CHAR16 *ZeroPool)
{
int v4; // ecx
unsigned int AllocationSize; // r8d
void *Pool; // rbx
__int64 result; // rax
v4 = *((_DWORD *)p_SourceBuffer + 2); /*0x9029*/
if ( *((_DWORD *)p_SourceBuffer + 3) == v4 ) /*0x902f*/
{
AllocationSize = v4 + *((_DWORD *)p_SourceBuffer + 4) * *((_DWORD *)p_SourceBuffer + 5); /*0x903a*/
*((_DWORD *)p_SourceBuffer + 2) = AllocationSize; /*0x9040*/
Pool = AllocatePool(AllocationSize); /*0x9053*/
CopyMem(Pool, (const void *)*p_SourceBuffer, *((unsigned int *)p_SourceBuffer + 3)); /*0x9056*/
AllocatePoolWithAssert(); /*0x905e*/
*p_SourceBuffer = Pool; /*0x9063*/
}
CopyMem( /*0x9073*/
(void *)(*p_SourceBuffer + *((unsigned int *)p_SourceBuffer + 3)),
ZeroPool,
*((unsigned int *)p_SourceBuffer + 4));
result = *((unsigned int *)p_SourceBuffer + 4); /*0x9078*/
*((_DWORD *)p_SourceBuffer + 3) += result; /*0x907b*/
return result; /*0x9088*/
}
// Function: ReFlashReadDmiArray @ 0x9090 (0x14e bytes)
void *ReFlashReadDmiArray()
{
void *n1024; // rax
unsigned __int8 v1; // si
unsigned __int8 v2; // di
_QWORD *v3; // rbx
__int64 v4; // rdx
__int64 v5; // [rsp+20h] [rbp-18h]
__int64 v6; // [rsp+28h] [rbp-10h]
n1024 = (void *)(*(__int64 (__fastcall **)(const wchar_t *, void *, _QWORD, __int64 *, char *))(RuntimeServices + 72))( /*0x90d3*/
L"DmiArray",
&unk_C850,
0,
&qword_D0E0,
byte_D4C0);
if ( !n1024 ) /*0x90d9*/
{
v1 = byte_D4C0[0]; /*0x90df*/
n1024 = &unk_E260; /*0x90e6*/
v2 = 0; /*0x90ed*/
dst = (char *)&unk_E260; /*0x90f0*/
if ( byte_D4C0[0] ) /*0x90fa*/
{
v3 = &unk_DA60; /*0x9100*/
do /*0x91b6*/
{
v4 = 5LL * ((unsigned int)v2 + 1); /*0x9114*/
LODWORD(v6) = (unsigned __int8)byte_D4C0[v4 + 4]; /*0x9134*/
LODWORD(v5) = (unsigned __int8)byte_D4C0[v4 + 3]; /*0x913f*/
HiiConstructConfigAltString( /*0x9143*/
L" ",
(const CHAR8 *)L"DmiVar%02x%04x%02x%02x",
(unsigned __int8)byte_D4C0[v4],
*(unsigned __int16 *)&byte_D4C0[v4 + 1],
v5,
v6);
n1024 = 1024; /*0x9159*/
n1024 = (void *)(*(__int64 (__fastcall **)(const wchar_t *, void *, _QWORD, unsigned __int64 *, char *))(RuntimeServices + 72))( /*0x9177*/
L" ",
&unk_C850,
0,
&n1024,
src);
if ( n1024 ) /*0x917d*/
{
*v3 = 0; /*0x91a8*/
}
else
{
InternalCopyMemOverlap(dst, src, n1024); /*0x9190*/
n1024 = (void *)n1024; /*0x9195*/
dst += n1024; /*0x919c*/
*v3 = n1024; /*0x91a3*/
}
++v2; /*0x91ac*/
++v3; /*0x91af*/
}
while ( v2 < v1 ); /*0x91b6*/
}
byte_D9C0 = 1; /*0x91bc*/
}
return n1024; /*0x91d7*/
}
// Function: ReFlashSaveDmiArray @ 0x91e0 (0x107 bytes)
_UNKNOWN **ReFlashSaveDmiArray()
{
_UNKNOWN **result; // rax
unsigned __int8 v1; // bl
unsigned __int8 v2; // di
_QWORD *v3; // rsi
__int64 v4; // rdx
__int64 v5; // [rsp+20h] [rbp-18h]
__int64 v6; // [rsp+28h] [rbp-10h]
_UNKNOWN *retaddr; // [rsp+38h] [rbp+0h] BYREF
result = &retaddr; /*0x91e0*/
v1 = 0; /*0x91f4*/
if ( byte_D9C0 ) /*0x91fc*/
{
(*(void (__fastcall **)(const wchar_t *, void *, __int64, __int64, char *))(RuntimeServices + 88))( /*0x922f*/
L"DmiArray",
&unk_C850,
7,
qword_D0E0,
byte_D4C0);
v2 = byte_D4C0[0]; /*0x9232*/
result = (_UNKNOWN **)&unk_E260; /*0x9239*/
dst = (__int64)&unk_E260; /*0x9240*/
if ( byte_D4C0[0] ) /*0x924a*/
{
v3 = &unk_DA60; /*0x9250*/
do /*0x92d0*/
{
v4 = 5LL * ((unsigned int)v1 + 1); /*0x925c*/
LODWORD(v6) = (unsigned __int8)byte_D4C0[v4 + 4]; /*0x927c*/
LODWORD(v5) = (unsigned __int8)byte_D4C0[v4 + 3]; /*0x9287*/
HiiConstructConfigAltString( /*0x928b*/
(__int64)L" ",
(__int64)L"DmiVar%02x%04x%02x%02x",
(unsigned __int8)byte_D4C0[v4],
*(unsigned __int16 *)&byte_D4C0[v4 + 1],
v5,
v6);
(*(void (__fastcall **)(const wchar_t *, void *, __int64, _QWORD, __int64))(RuntimeServices + 88))( /*0x92ba*/
L" ",
&unk_C850,
7,
*v3,
dst);
result = (_UNKNOWN **)*v3; /*0x92bd*/
++v1; /*0x92c0*/
dst += *v3++; /*0x92c2*/
}
while ( v1 < v2 ); /*0x92d0*/
}
}
return result; /*0x92e1*/
}
// Function: ReFlashCheckSmbiosPreserve @ 0x92e8 (0x92 bytes)
__int64 ReFlashCheckSmbiosPreserve()
{
_DWORD v1[4]; // [rsp+30h] [rbp-10h] BYREF
char v2; // [rsp+50h] [rbp+10h] BYREF
__int64 v3; // [rsp+58h] [rbp+18h] BYREF
v1[0] = 1261470371; /*0x92f5*/
v1[1] = 1300136134; /*0x9313*/
v1[2] = 962121884; /*0x9321*/
v1[3] = -245553641; /*0x9328*/
v3 = 1; /*0x932f*/
byte_D4B8 = 0; /*0x9337*/
if ( (*(__int64 (__fastcall **)(const wchar_t *, _DWORD *, _QWORD, __int64 *, char *))(RuntimeServices + 72))( /*0x9344*/
L"PreserveSmbiosNvramVar",
v1,
0,
&v3,
&v2) >= 0 )
{
byte_D4B8 = 1; /*0x9346*/
ReFlashReadDmiArray(); /*0x934d*/
}
return (*(__int64 (__fastcall **)(const wchar_t *, _DWORD *, __int64))(RuntimeServices + 88))( /*0x9374*/
L"PreserveSmbiosNvramVar",
v1,
3);
}
// Function: ReFlashSaveSmbiosIfNeeded @ 0x937c (0x1e bytes)
_UNKNOWN **ReFlashSaveSmbiosIfNeeded()
{
_UNKNOWN **result; // rax
if ( byte_D4B8 ) /*0x9387*/
result = ReFlashSaveDmiArray(); /*0x9389*/
byte_D4B8 = 0; /*0x938e*/
return result; /*0x9395*/
}
// Function: ReFlashReadSfpRecord @ 0x939c (0x9b bytes)
__int64 ReFlashReadSfpRecord()
{
__int64 v0; // rcx
void *v1; // rax
_DWORD v3[4]; // [rsp+30h] [rbp-10h] BYREF
__int64 n8; // [rsp+50h] [rbp+10h] BYREF
v0 = qword_D9C8; /*0x93a5*/
n8 = 8; /*0x93ac*/
v3[0] = 20351105; /*0x93b4*/
v3[1] = 1260242093; /*0x93bb*/
v3[2] = 2060792246; /*0x93c2*/
v3[3] = 1809565838; /*0x93c9*/
if ( !qword_D9C8 ) /*0x93d3*/
{
(*(void (__fastcall **)(const wchar_t *, _DWORD *, _QWORD, __int64 *, __int64 *))(RuntimeServices + 72))( /*0x93fa*/
L"SFPFREC",
v3,
0,
&n8,
&qword_D9C8);
v0 = qword_D9C8; /*0x93fd*/
}
n32 = 32; /*0x9407*/
v1 = &unk_D9D0; /*0x940e*/
n178 = 178; /*0x9415*/
if ( v0 ) /*0x941f*/
LODWORD(v1) = v0; /*0x941f*/
dword_D0F7 = (int)v1; /*0x9422*/
return ((__int64 (*)(void))loc_D0E8)(); /*0x9431*/
}
// Function: ReFlashReadSfpExtended @ 0x9438 (0x9b bytes)
__int64 ReFlashReadSfpExtended()
{
__int64 v0; // rcx
void *v1; // rax
_DWORD v3[4]; // [rsp+30h] [rbp-10h] BYREF
__int64 n8; // [rsp+50h] [rbp+10h] BYREF
v0 = qword_D9C8; /*0x9441*/
n8 = 8; /*0x9448*/
v3[0] = 20351105; /*0x9450*/
v3[1] = 1260242093; /*0x9457*/
v3[2] = 2060792246; /*0x945e*/
v3[3] = 1809565838; /*0x9465*/
if ( !qword_D9C8 ) /*0x946f*/
{
(*(void (__fastcall **)(const wchar_t *, _DWORD *, _QWORD, __int64 *, __int64 *))(RuntimeServices + 72))( /*0x9496*/
L"SFPFREC",
v3,
0,
&n8,
&qword_D9C8);
v0 = qword_D9C8; /*0x9499*/
}
n32 = 36; /*0x94a3*/
v1 = &unk_D9D0; /*0x94aa*/
n178 = 178; /*0x94b1*/
if ( v0 ) /*0x94bb*/
LODWORD(v1) = v0; /*0x94bb*/
dword_D0F7 = (int)v1; /*0x94be*/
return ((__int64 (*)(void))loc_D0E8)(); /*0x94cd*/
}
// Function: ReFlashReadFlashLayoutFromBlockIo @ 0x94d4 (0x115 bytes)
__int64 __fastcall ReFlashReadFlashLayoutFromBlockIo(char *dst)
{
__int64 result; // rax
__int64 v3; // rbx
__int64 v4; // r8
unsigned __int64 v5; // [rsp+40h] [rbp-20h] BYREF
__int64 v6; // [rsp+48h] [rbp-18h] BYREF
__int64 v7; // [rsp+50h] [rbp-10h] BYREF
char v8; // [rsp+88h] [rbp+28h] BYREF
char *src; // [rsp+90h] [rbp+30h] BYREF
__int64 v10; // [rsp+98h] [rbp+38h] BYREF
result = (*(__int64 (__fastcall **)(__int64, void *, _QWORD, unsigned __int64 *, __int64 *))(BootServices + 312))( /*0x9504*/
2,
&unk_C790,
0,
&v5,
&v10);
if ( result >= 0 ) /*0x950d*/
{
v3 = 0; /*0x9513*/
if ( v5 ) /*0x9519*/
{
while ( 1 ) /*0x9535*/
{
if ( (*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices + 152))( /*0x953e*/
*(_QWORD *)(v10 + 8 * v3),
&unk_C790,
&v7) >= 0 )
{
src = 0; /*0x9540*/
v6 = 0; /*0x9549*/
LOBYTE(v4) = 24; /*0x9561*/
if ( (*(__int64 (__fastcall **)(__int64, void *, __int64, _QWORD, char **, __int64 *, char *))(v7 + 24))( /*0x957f*/
v7,
&unk_D108,
v4,
0,
&src,
&v6,
&v8) >= 0 )
break; /*0x957f*/
}
if ( ++v3 >= v5 ) /*0x9588*/
goto LABEL_6; /*0x9588*/
}
src += 16; /*0x95bb*/
InternalCopyMemOverlap(dst, src, 0x78u); /*0x95bf*/
src -= 16; /*0x95cf*/
(*(void (__fastcall **)(__int64))(BootServices + 72))(v10); /*0x95d4*/
(*(void (__fastcall **)(char *))(BootServices + 72))(src); /*0x95e2*/
return 0; /*0x95e5*/
}
else
{
LABEL_6:
(*(void (__fastcall **)(__int64))(BootServices + 72))(v10); /*0x958a*/
return 0x800000000000000EuLL; /*0x9598*/
}
}
return result; /*0x95a2*/
}
// Function: ReFlashScanFlashSignature @ 0x95ec (0x86 bytes)
unsigned __int64 __fastcall ReFlashScanFlashSignature(char *dst, unsigned __int64 i)
{
int v2; // esi
_BYTE *j; // rbx
unsigned __int64 j_1; // rax
v2 = dword_D118; /*0x9600*/
for ( j = (_BYTE *)(i + 16777200); *(_DWORD *)j != v2 || StrnCmp((unsigned __int64)&dword_D118, j, 0x10u); j -= 4 ) /*0x9606*/
{
j_1 = (unsigned __int64)j; /*0x9631*/
if ( j_1 < i ) /*0x963b*/
return 0x800000000000000EuLL; /*0x963d*/
}
InternalCopyMemOverlap(dst, j + 64, 0x78u); /*0x9669*/
return 0; /*0x9656*/
}
// Function: HiiGetStringAndUpdate @ 0x9674 (0xe9 bytes)
signed __int64 __fastcall HiiGetStringAndUpdate(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 v4; // rbp
__int64 v5; // rbx
signed __int64 UnicodeString_1; // rcx
__int64 v7; // rsi
_QWORD *v8; // rdi
__int64 v9; // r8
_BYTE *v10; // rdx
_QWORD *v11; // rdi
unsigned __int64 UnicodeString; // rax
_QWORD v14[2]; // [rsp+20h] [rbp-28h] BYREF
_QWORD v15[3]; // [rsp+30h] [rbp-18h] BYREF
v14[0] = a1; /*0x9688*/
v4 = 1; /*0x968c*/
v14[1] = a2; /*0x9691*/
v15[0] = a3; /*0x9695*/
v15[1] = a4; /*0x9699*/
v5 = 0; /*0x96a2*/
UnicodeString_1 = HiiInitUpdateContext(); /*0x96a4*/
if ( UnicodeString_1 < 0 ) /*0x96aa*/
return 0x8000000000000007uLL; /*0x96ac*/
v7 = 0; /*0x96bb*/
v8 = v14; /*0x96be*/
do /*0x96f0*/
{
if ( v7 ) /*0x96c7*/
break; /*0x96c7*/
v9 = v8[1]; /*0x96c9*/
v10 = (_BYTE *)*v8; /*0x96cd*/
--v4; /*0x96d0*/
v7 = 1; /*0x96e3*/
v8 += 2; /*0x96e6*/
UnicodeString_1 = HiiInternalApplyUpdate(UnicodeString_1, v10, v9, v4 == 0); /*0x96ea*/
}
while ( UnicodeString_1 >= 0 ); /*0x96f0*/
if ( UnicodeString_1 >= 0 ) /*0x96f5*/
{
while ( !HiiCheckUpdateState((char *)0xFED40018LL, 16) ) /*0x9705*/
; /*0x96f7*/
v11 = v15; /*0x9711*/
UnicodeString_1 = 0x8000000000000005uLL; /*0x9716*/
do /*0x9738*/
{
if ( v5 ) /*0x971d*/
break; /*0x971d*/
UnicodeString = HiiInternalGetUnicodeString(UnicodeString_1, (_BYTE *)*v11, v11 + 1); /*0x9726*/
v5 = 1; /*0x972b*/
v11 += 2; /*0x972e*/
UnicodeString_1 = UnicodeString; /*0x9732*/
}
while ( UnicodeString == 0x8000000000000005uLL ); /*0x9738*/
MEMORY[0xFED40018] = 64; /*0x973c*/
}
return UnicodeString_1; /*0x9757*/
}
// Function: ReFlashVerifyUpdate @ 0x9760 (0xb3 bytes)
unsigned __int64 ReFlashVerifyUpdate()
{
int buf; // [rsp+20h] [rbp-30h] BYREF
int v2; // [rsp+26h] [rbp-2Ah]
__int16 v3; // [rsp+30h] [rbp-20h] BYREF
int n167772160; // [rsp+32h] [rbp-1Eh]
int n1862270976; // [rsp+36h] [rbp-1Ah]
__int16 v6; // [rsp+40h] [rbp-10h] BYREF
int n184549376; // [rsp+42h] [rbp-Eh]
int n1912602624; // [rsp+46h] [rbp-Ah]
char v9; // [rsp+4Ah] [rbp-6h]
n167772160 = 167772160; /*0x9775*/
n1862270976 = 1862270976; /*0x9781*/
v3 = -16128; /*0x978c*/
InternalSetMem16(&buf, 0xAu, 0); /*0x9796*/
if ( HiiGetStringAndUpdate((__int64)&v3, 10, (__int64)&buf, 10) < 0 ) /*0x97b0*/
return 0x800000000000001AuLL; /*0x97b0*/
if ( v2 ) /*0x97b6*/
return 0x800000000000001AuLL; /*0x97b6*/
v6 = -16128; /*0x97bb*/
n184549376 = 184549376; /*0x97c1*/
n1912602624 = 1912602624; /*0x97cc*/
v9 = 0; /*0x97d3*/
InternalSetMem16(&buf, 0xAu, 0); /*0x97d7*/
HiiGetStringAndUpdate((__int64)&v6, 11, (__int64)&buf, 10); /*0x97ea*/
if ( v2 ) /*0x97f3*/
return 0x800000000000001AuLL; /*0x97f9*/
else
return 0; /*0x97f5*/
}
// Function: ReFlashExecuteUpdate @ 0x9814 (0x293 bytes)
char ReFlashExecuteUpdate()
{
char n2; // bl
int n30000; // esi
int n5; // edi
bool v3; // zf
__int16 v5; // [rsp+20h] [rbp-89h] BYREF
int n201326592_1; // [rsp+22h] [rbp-87h]
int n167772224; // [rsp+26h] [rbp-83h]
__int16 n0x2000; // [rsp+2Ah] [rbp-7Fh]
int buf_1[4]; // [rsp+30h] [rbp-79h] BYREF
__int16 v10; // [rsp+40h] [rbp-69h] BYREF
int n201326592; // [rsp+42h] [rbp-67h]
int v12; // [rsp+46h] [rbp-63h]
__int16 n256; // [rsp+4Ah] [rbp-5Fh]
__int16 v14; // [rsp+50h] [rbp-59h] BYREF
int n167772160; // [rsp+52h] [rbp-57h]
int n1560281088; // [rsp+56h] [rbp-53h]
__int16 v17; // [rsp+60h] [rbp-49h] BYREF
int n369098752; // [rsp+62h] [rbp-47h]
int n1694498816; // [rsp+66h] [rbp-43h]
int n0x4000000; // [rsp+6Ah] [rbp-3Fh]
int n0x4000000_1; // [rsp+6Eh] [rbp-3Bh]
int n134283264; // [rsp+72h] [rbp-37h]
__int16 v23; // [rsp+78h] [rbp-31h] BYREF
int n369098752_1; // [rsp+7Ah] [rbp-2Fh]
int n1694498816_1; // [rsp+7Eh] [rbp-2Bh]
int n0x4000000_2; // [rsp+82h] [rbp-27h]
int n0x4000000_3; // [rsp+86h] [rbp-23h]
int n151060480; // [rsp+8Ah] [rbp-1Fh]
int buf[4]; // [rsp+90h] [rbp-19h] BYREF
int buf_; // [rsp+A0h] [rbp-9h] BYREF
int v31; // [rsp+A6h] [rbp-3h]
_BYTE v32[6]; // [rsp+B0h] [rbp+7h] BYREF
int v33; // [rsp+B6h] [rbp+Dh]
char v34; // [rsp+C3h] [rbp+1Ah]
_BYTE v35[6]; // [rsp+C8h] [rbp+1Fh] BYREF
int n637534208; // [rsp+CEh] [rbp+25h]
n2 = 0; /*0x9838*/
if ( ReFlashSpiCheckControllerId() || MEMORY[0xFED40000] == 0xFF || !MEMORY[0xFED40000] ) /*0x985e*/
return 0; /*0x9a88*/
if ( (MEMORY[0xFED40000] & 0x20) == 0 ) /*0x9875*/
{
n30000 = 30000; /*0x9879*/
MEMORY[0xFED40000] = 2; /*0x987e*/
do /*0x98b0*/
{
n5 = 5; /*0x988b*/
do /*0x989d*/
{
Assert_43(0x6Bu); /*0x9895*/
--n5; /*0x989a*/
}
while ( n5 ); /*0x989d*/
if ( (MEMORY[0xFED40000] & 0x20) != 0 && MEMORY[0xFED40000] < 0 ) /*0x98ab*/
break; /*0x98ab*/
--n30000; /*0x98ad*/
}
while ( n30000 ); /*0x98b0*/
}
n369098752 = 369098752; /*0x98bc*/
v17 = -16128; /*0x98c3*/
if ( !ReFlashSpiCheckControllerId() ) /*0x98c7*/
{
n1694498816 = 1694498816; /*0x98e3*/
n0x4000000 = 0x4000000; /*0x98ee*/
n0x4000000_1 = 0x4000000; /*0x98f5*/
n134283264 = 134283264; /*0x98fd*/
HiiGetStringAndUpdate((__int64)&v17, 22, (__int64)v35, 36); /*0x9904*/
if ( n637534208 == 637534208 ) /*0x9910*/
{
v10 = -16128; /*0x991c*/
n256 = 256; /*0x9923*/
n201326592 = 201326592; /*0x992a*/
v12 = -1728053248; /*0x9935*/
InternalSetMem16(buf, 0xAu, 0); /*0x993c*/
HiiGetStringAndUpdate((__int64)&v10, 12, (__int64)buf, 10); /*0x9951*/
v3 = *(int *)((char *)&buf[1] + 2) == 0; /*0x9956*/
}
else
{
v3 = n637534208 == 0; /*0x9912*/
}
if ( !v3 ) /*0x9959*/
return 2; /*0x9959*/
}
v5 = -16128; /*0x9967*/
n0x2000 = 0x2000; /*0x996f*/
n201326592_1 = 201326592; /*0x9976*/
n167772224 = 167772224; /*0x9982*/
InternalSetMem16(buf_1, 0xAu, 0); /*0x998a*/
HiiGetStringAndUpdate((__int64)&v5, 12, (__int64)buf_1, 10); /*0x99a0*/
InternalSetMem16(buf_1, 0xAu, 0); /*0x99af*/
n0x2000 = 2048; /*0x99c0*/
HiiGetStringAndUpdate((__int64)&v5, 12, (__int64)buf_1, 10); /*0x99ce*/
if ( *(int *)((char *)&buf_1[1] + 2) ) /*0x99d6*/
return 2; /*0x995b*/
v23 = -16128; /*0x99d8*/
n369098752_1 = 369098752; /*0x99dc*/
if ( ReFlashSpiCheckControllerId() /*0x9a1c*/
|| (n1694498816_1 = 1694498816,
n0x4000000_2 = 0x4000000,
n0x4000000_3 = 0x4000000,
n151060480 = 151060480,
HiiGetStringAndUpdate((__int64)&v23, 22, (__int64)v32, 21),
!v33) )
{
if ( v34 ) /*0x9a21*/
return 3; /*0x9a23*/
}
v14 = -16128; /*0x9a2a*/
n167772160 = 167772160; /*0x9a31*/
n1560281088 = 1560281088; /*0x9a3c*/
InternalSetMem16(&buf_, 0xAu, 0); /*0x9a43*/
HiiGetStringAndUpdate((__int64)&v14, 10, (__int64)&buf_, 10); /*0x9a56*/
if ( v31 ) /*0x9a60*/
{
if ( ((v31 - 100663296) & 0xFEFFFFFF) != 0 || (n2 = 1, (ReFlashVerifyUpdate() & 0x8000000000000000uLL) != 0LL) ) /*0x9a78*/
n2 = 2; /*0x9a7a*/
}
Assert_51((char *)0xFED40000LL); /*0x9a7f*/
return n2; /*0x9a9e*/
}
// Function: DebugLibGetDebugMask @ 0x9aa8 (0x4e bytes)
__int64 DebugLibGetDebugMask()
{
unsigned __int8 v0; // al
char n3_1; // al
char n3; // cl
__int64 result; // rax
v0 = __inbyte(0x70u); /*0x9aad*/
__outbyte(0x70u, v0 & 0x80 | 0x4B); /*0x9ab2*/
n3_1 = __inbyte(0x71u); /*0x9ab8*/
n3 = n3_1; /*0x9ab9*/
if ( (unsigned __int8)n3_1 > 3u ) /*0x9ac0*/
{
n3 = n3; /*0x9ac2*/
if ( !n3 ) /*0x9aca*/
n3 = MEMORY[0xFDAF0490] & 2 | 1; /*0x9ad6*/
}
if ( (unsigned __int8)(n3 - 1) > 0xFDu ) /*0x9ae0*/
return 0; /*0x9af3*/
result = 2147483718LL; /*0x9ae5*/
if ( n3 == 1 ) /*0x9aef*/
return 2147483652LL; /*0x9aef*/
return result; /*0x9af2*/
}
// Function: Assert_32 @ 0x9af8 (0x34 bytes)
__int64 __fastcall Assert_32(_WORD *PcdVal)
{
if ( ((unsigned __int8)PcdVal & 1) != 0 ) /*0x9b04*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLib.c", 0xB7u, "(Address & 1) == 0"); /*0x9b19*/
*PcdVal = 1280; /*0x9b23*/
return 1280; /*0x9b26*/
}
// Function: Assert_33 @ 0x9b2c (0x30 bytes)
unsigned __int32 __fastcall Assert_33(unsigned __int16 n1288)
{
if ( (n1288 & 3) != 0 ) /*0x9b38*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLibMsc.c", 0xC1u, "(Port & 3) == 0"); /*0x9b4d*/
return __indword(n1288); /*0x9b56*/
}
// Function: SetMem @ 0x9b5c (0x6e bytes)
void *__cdecl SetMem(void *Buffer, UINTN Length, UINT8 Value)
{
if ( !Length ) /*0x9b6f*/
return Buffer; /*0x9b71*/
if ( !Buffer ) /*0x9b79*/
DebugAssert("e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\ZeroMemWrapper.c", 0x35u, "Buffer != ((void *) 0)"); /*0x9b8c*/
if ( Length > -(__int64)Buffer ) /*0x9b9a*/
DebugAssert( /*0x9baf*/
"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\ZeroMemWrapper.c",
0x36u,
"Length <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)Buffer + 1)");
return InternalIsZeroBuffer((char *)Buffer, Length, Value); /*0x9bc4*/
}
// Function: AssertCpuDeadLoop @ 0x9bcc (0x8c bytes)
__int64 AssertCpuDeadLoop()
{
__int64 result; // rax
__int64 v1; // rax
result = qword_D9E8; /*0x9bd0*/
if ( !qword_D9E8 ) /*0x9bda*/
{
v1 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices_0 + 320))(&unk_C700, 0, &qword_D9E8); /*0x9bf3*/
if ( v1 < 0 ) /*0x9bfc*/
{
DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v1); /*0x9c0d*/
DebugAssert("e:\\hs\\MdePkg\\Library\\DxePcdLib\\DxePcdLib.c", 0x4Eu, "!EFI_ERROR (Status)"); /*0x9c25*/
}
result = qword_D9E8; /*0x9c2a*/
if ( !qword_D9E8 ) /*0x9c34*/
{
DebugAssert("e:\\hs\\MdePkg\\Library\\DxePcdLib\\DxePcdLib.c", 0x4Fu, "mPcd != ((void *) 0)"); /*0x9c47*/
return qword_D9E8; /*0x9c4c*/
}
}
return result; /*0x9c53*/
}
// Function: Assert_1 @ 0x9c58 (0x203 bytes)
void __fastcall Assert_1(
char *SourceBuffer,
unsigned __int64 n2,
UINTN Length,
__int64 (__fastcall *Assert_47)(_QWORD, _QWORD),
void *DestinationBuffer)
{
__int64 (__fastcall *Assert_47_1)(_QWORD, _QWORD); // rbx
unsigned __int64 n2_2; // rbp
char *SourceBuffer_2; // rsi
char *SourceBuffer_5; // rbx
unsigned __int64 v10; // rbp
char *SourceBuffer_3; // rax
unsigned __int64 n2a_1; // rsi
char *SourceBuffera; // [rsp+30h] [rbp-48h]
char *SourceBuffer_4; // [rsp+38h] [rbp-40h]
unsigned __int64 n2a; // [rsp+40h] [rbp-38h]
char *SourceBuffer_1; // [rsp+80h] [rbp+8h]
unsigned __int64 n2_1; // [rsp+88h] [rbp+10h]
n2_1 = n2; /*0x9c63*/
SourceBuffer_1 = SourceBuffer; /*0x9c67*/
Assert_47_1 = Assert_47; /*0x9c72*/
n2_2 = n2; /*0x9c78*/
SourceBuffer_2 = SourceBuffer; /*0x9c7b*/
while ( 1 ) /*0x9c7e*/
{
if ( !SourceBuffer_2 ) /*0x9c81*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\BaseSortLib\\BaseSortLib.c", 0x3Au, "BufferToSort != ((void *) 0)"); /*0x9c94*/
if ( !Assert_47_1 ) /*0x9c9c*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\BaseSortLib\\BaseSortLib.c", 0x3Bu, "CompareFunction != ((void *) 0)"); /*0x9caf*/
if ( !DestinationBuffer ) /*0x9cbd*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\BaseSortLib\\BaseSortLib.c", 0x3Cu, "Buffer != ((void *) 0)"); /*0x9cd2*/
if ( n2_2 < 2 || !Length ) /*0x9ce5*/
break; /*0x9ce5*/
SourceBuffer_5 = &SourceBuffer_2[Length * (n2_2 - 1)]; /*0x9d01*/
v10 = n2_2 - 1; /*0x9d12*/
SourceBuffer_3 = SourceBuffer_2; /*0x9d17*/
SourceBuffera = SourceBuffer_2; /*0x9d1a*/
n2a_1 = 0; /*0x9d1f*/
SourceBuffer_4 = SourceBuffer_3; /*0x9d24*/
do /*0x9d90*/
{
if ( Assert_47(SourceBuffer_3, SourceBuffer_5) <= 0 ) /*0x9d39*/
{
CopyMem(DestinationBuffer, SourceBuffera, Length); /*0x9d4b*/
CopyMem(SourceBuffera, SourceBuffer_4, Length); /*0x9d5d*/
CopyMem(SourceBuffer_4, DestinationBuffer, Length); /*0x9d72*/
++n2a_1; /*0x9d77*/
SourceBuffera += Length; /*0x9d7a*/
}
SourceBuffer_3 = &SourceBuffer_4[Length]; /*0x9d84*/
SourceBuffer_4 += Length; /*0x9d87*/
--v10; /*0x9d8c*/
}
while ( v10 ); /*0x9d90*/
n2a = n2a_1; /*0x9d9a*/
CopyMem(DestinationBuffer, SourceBuffer_5, Length); /*0x9db5*/
CopyMem(SourceBuffer_5, &SourceBuffer_1[Length * n2a_1], Length); /*0x9dd1*/
CopyMem(&SourceBuffer_1[Length * n2a_1], DestinationBuffer, Length); /*0x9de4*/
if ( n2a_1 >= 2 ) /*0x9df2*/
Assert_1(SourceBuffer_1, n2a_1, Length, Assert_47, DestinationBuffer); /*0x9e12*/
n2_2 = n2_1 - n2a_1 - 1; /*0x9e1a*/
n2_1 = n2_2; /*0x9e1d*/
if ( n2_2 < 2 ) /*0x9e29*/
break; /*0x9e29*/
Assert_47_1 = Assert_47; /*0x9e2f*/
SourceBuffer_2 = &SourceBuffer_1[Length * (n2a_1 + 1)]; /*0x9e3b*/
SourceBuffer_1 += Length * (n2a + 1); /*0x9e3e*/
}
}
// Function: Assert_16 @ 0x9e5c (0x9d bytes)
void __fastcall Assert_16(char *SourceBuffer, unsigned __int64 n2, UINTN Length)
{
void *DestinationBuffer; // rbx
if ( !SourceBuffer ) /*0x9e7c*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\BaseSortLib\\BaseSortLib.c", 0x9Fu, "BufferToSort != ((void *) 0)"); /*0x9e91*/
DestinationBuffer = AllocateZeroPool(4u); /*0x9ea3*/
if ( !DestinationBuffer ) /*0x9ea9*/
DebugAssert("e:\\hs\\MdeModulePkg\\Library\\BaseSortLib\\BaseSortLib.c", 0xA3u, "Buffer != ((void *) 0)"); /*0x9ebe*/
Assert_1(SourceBuffer, n2, Length, (__int64 (__fastcall *)(_QWORD, _QWORD))Assert_47, DestinationBuffer); /*0x9ed8*/
AllocatePoolWithAssert(); /*0x9ef4*/
}
// Function: Assert_50 @ 0x9efc (0x20 bytes)
__int64 __fastcall Assert_50(int n5)
{
int n5_1; // ebx
__int64 result; // rax
if ( n5 ) /*0x9efe*/
{
n5_1 = n5; /*0x9f05*/
do /*0x9f14*/
{
result = Assert_43(0x6Bu); /*0x9f0c*/
--n5_1; /*0x9f11*/
}
while ( n5_1 ); /*0x9f14*/
}
return result; /*0x9f1b*/
}
// Function: HiiCheckUpdateState @ 0x9f1c (0x5c bytes)
char __fastcall HiiCheckUpdateState(char *a1, char a2)
{
int n30000; // edi
int n5; // esi
n30000 = 30000; /*0x9f36*/
while ( 1 ) /*0x9f3b*/
{
n5 = 5; /*0x9f3b*/
do /*0x9f4d*/
{
Assert_43(0x6Bu); /*0x9f45*/
--n5; /*0x9f4a*/
}
while ( n5 ); /*0x9f4d*/
if ( !--n30000 ) /*0x9f52*/
break; /*0x9f52*/
if ( *a1 < 0 ) /*0x9f58*/
return a2 & *a1; /*0x9f5f*/
}
return 0; /*0x9f72*/
}
// Function: Assert_48 @ 0x9f78 (0x5b bytes)
__int64 Assert_48()
{
__int64 n7500; // rbx
int n5; // edi
__int64 result; // rax
n7500 = 7500; /*0x9f8d*/
do /*0x9fbb*/
{
n5 = 5; /*0x9f98*/
do /*0x9faa*/
{
Assert_43(0x6Bu); /*0x9fa2*/
--n5; /*0x9fa7*/
}
while ( n5 ); /*0x9faa*/
result = MEMORY[0xFED40019]; /*0x9fac*/
--n7500; /*0x9fb0*/
}
while ( !MEMORY[0xFED40019] && n7500 ); /*0x9fbb*/
return result; /*0x9fcc*/
}
// Function: Assert_51 @ 0x9fd4 (0xab bytes)
unsigned __int64 __fastcall Assert_51(char *a1)
{
int n7500; // [rsp+20h] [rbp-18h]
n7500 = 7500; /*0x9fdd*/
if ( !HiiCheckUpdateState(a1, 32) ) /*0x9fef*/
return 0x8000000000000007uLL; /*0x9ffb*/
*a1 = 32; /*0xa00c*/
if ( !HiiCheckUpdateState(a1, 32) ) /*0xa019*/
return 0; /*0xa019*/
do /*0xa054*/
{
Assert_50(5); /*0xa02a*/
--n7500; /*0xa035*/
}
while ( HiiCheckUpdateState(a1, 32) && n7500 ); /*0xa054*/
if ( HiiCheckUpdateState(a1, 32) ) /*0xa060*/
return 0x8000000000000007uLL; /*0xa06c*/
else
return 0; /*0xa078*/
}
// Function: HiiInitUpdateContext @ 0xa080 (0xa8 bytes)
unsigned __int64 HiiInitUpdateContext()
{
__int64 v0; // rbx
__int64 n2; // rbp
__int64 n30000; // rdi
int n5; // esi
v0 = 0; /*0xa0a5*/
if ( !HiiCheckUpdateState((char *)0xFED40000LL, 32) ) /*0xa0a0*/
return 0x8000000000000013uLL; /*0xa0ab*/
n2 = 2; /*0xa0b7*/
do /*0xa0f7*/
{
n30000 = 30000; /*0xa0c2*/
MEMORY[0xFED40018] = 64; /*0xa0c7*/
do /*0xa0ec*/
{
--n30000; /*0xa0cb*/
n5 = 5; /*0xa0ce*/
do /*0xa0e0*/
{
Assert_43(0x6Bu); /*0xa0d8*/
--n5; /*0xa0dd*/
}
while ( n5 ); /*0xa0e0*/
}
while ( (MEMORY[0xFED40018] & 0x40) == 0 && n30000 ); /*0xa0ec*/
if ( n30000 ) /*0xa0f1*/
break; /*0xa0f1*/
--n2; /*0xa0f3*/
}
while ( n2 ); /*0xa0f7*/
if ( !n30000 ) /*0xa106*/
return 0x8000000000000007uLL; /*0xa106*/
return v0; /*0xa121*/
}
// Function: HiiInternalApplyUpdate @ 0xa128 (0xf8 bytes)
unsigned __int64 __fastcall HiiInternalApplyUpdate(signed __int64 UnicodeString, _BYTE *a2, __int64 a3, char a4)
{
__int64 v7; // rbx
__int16 v8; // cx
if ( !a3 ) /*0xa14c*/
return -(__int64)(a4 != 0) & 0x8000000000000002uLL; /*0xa161*/
if ( (MEMORY[0xFED40000] & 0x20) == 0 ) /*0xa16a*/
return 0x8000000000000015uLL; /*0xa16a*/
v7 = a3 - 1; /*0xa17e*/
if ( !a4 ) /*0xa182*/
v7 = a3; /*0xa182*/
LABEL_11:
if ( v7 ) /*0xa1bd*/
{
v8 = Assert_48(); /*0xa18d*/
if ( !v8 ) /*0xa193*/
return 0x8000000000000012uLL; /*0xa214*/
while ( v7 ) /*0xa19d*/
{
--v7; /*0xa1a1*/
MEMORY[0xFED40024] = *a2++; /*0xa1a4*/
if ( !--v8 ) /*0xa1b8*/
goto LABEL_11; /*0xa1b8*/
}
}
if ( a4 ) /*0xa1c2*/
{
if ( !HiiCheckUpdateState((char *)0xFED40018LL, 8) ) /*0xa1cd*/
return 0x8000000000000015uLL; /*0xa1cd*/
MEMORY[0xFED40024] = *a2; /*0xa1dc*/
if ( HiiCheckUpdateState((char *)0xFED40018LL, 8) ) /*0xa1e5*/
return 0x8000000000000015uLL; /*0xa176*/
MEMORY[0xFED40018] = 32; /*0xa1f4*/
}
return 0; /*0xa20e*/
}
// Function: HiiInternalGetUnicodeString @ 0xa220 (0xc3 bytes)
unsigned __int64 __fastcall HiiInternalGetUnicodeString(signed __int64 UnicodeString, _BYTE *a2, _QWORD *a3)
{
_BYTE *v4; // rdi
_BYTE *v5; // rbx
__int16 v6; // si
v4 = &a2[*a3]; /*0xa23f*/
v5 = a2; /*0xa242*/
if ( a2 < v4 ) /*0xa24d*/
{
LABEL_2:
if ( HiiCheckUpdateState((char *)0xFED40018LL, 16) ) /*0xa254*/
{
v6 = Assert_48(); /*0xa262*/
if ( !v6 ) /*0xa268*/
return 0x8000000000000012uLL; /*0xa2d7*/
while ( v5 < v4 ) /*0xa26d*/
{
if ( HiiCheckUpdateState((char *)0xFED40018LL, 16) ) /*0xa274*/
{
*v5++ = MEMORY[0xFED40024]; /*0xa286*/
if ( --v6 ) /*0xa293*/
continue; /*0xa293*/
}
if ( v5 < v4 ) /*0xa298*/
goto LABEL_2; /*0xa298*/
break; /*0xa298*/
}
}
}
*a3 += v5 - v4; /*0xa29a*/
return -(__int64)(HiiCheckUpdateState((char *)0xFED40018LL, 16) != 0) & 0x8000000000000005uLL; /*0xa2d0*/
}
// Function: ReFlashSpiCheckControllerId @ 0xa2e4 (0x3c bytes)
char ReFlashSpiCheckControllerId()
{
unsigned __int64 n0xC; // rdx
n0xC = 0; /*0xa2f5*/
while ( *(_WORD *)((char *)&unk_D128 + n0xC) != MEMORY[0xFED40F00] /*0xa30e*/
|| *(_WORD *)((char *)&unk_D128 + n0xC + 2) != MEMORY[0xFED40F02] )
{
n0xC += 4LL; /*0xa310*/
if ( n0xC >= 0xC ) /*0xa318*/
return 0; /*0xa31c*/
}
return 1; /*0xa31c*/
}
// Function: InternalSetMem16 @ 0xa37e (0x4f bytes)
int *__fastcall InternalSetMem16(int *buf, unsigned __int64 n4, int value)
{
int *buf_1; // rdi
unsigned __int64 n4_1; // rcx
int value_1; // eax
__int16 value_2; // bx
int v7; // eax
__int64 v8; // rdx
char n4_2; // dl
unsigned __int64 i; // rcx
buf_1 = buf; /*0xa381*/
n4_1 = n4; /*0xa384*/
value_1 = value; /*0xa387*/
BYTE1(value_1) = value; /*0xa38a*/
value_2 = value_1; /*0xa38c*/
v7 = value_1 << 16; /*0xa38f*/
LOWORD(v7) = value_2; /*0xa393*/
if ( n4 >= 4 ) /*0xa39a*/
{
v8 = (unsigned __int8)buf_1 & 3; /*0xa39f*/
if ( ((unsigned __int8)buf_1 & 3) != 0 ) /*0xa3a3*/
{
memset(buf_1, value_2, 4 - v8); /*0xa3b2*/
buf_1 = (int *)((char *)buf_1 + 4 - v8); /*0xa3b2*/
n4_1 -= 4 - v8; /*0xa3b4*/
}
n4_2 = n4_1; /*0xa3b7*/
for ( i = n4_1 >> 2; i; --i ) /*0xa3ba*/
*buf_1++ = v7; /*0xa3be*/
n4_1 = n4_2 & 3; /*0xa3c4*/
}
memset(buf_1, value_2, n4_1); /*0xa3c7*/
return buf; /*0xa3ca*/
}
// Function: InternalCopyMemOverlap @ 0xa3d0 (0xb0 bytes)
char *__fastcall InternalCopyMemOverlap(char *dst, char *src, unsigned __int64 n8)
{
unsigned __int64 dst_1; // rdi
unsigned __int64 n8_1; // rcx
char v10; // dl
char *n8_2; // rax
unsigned __int64 count; // rax
unsigned __int64 count_1; // rbx
char n8_3; // al
unsigned __int64 v15; // rcx
unsigned __int64 n8_4; // rax
__asm { pushf } /*0xa3d3*/
dst_1 = (unsigned __int64)dst; /*0xa3d9*/
n8_1 = n8; /*0xa3dc*/
v10 = 0; /*0xa3df*/
n8_2 = &src[-dst_1]; /*0xa3e4*/
if ( (unsigned __int64)src < dst_1 ) /*0xa3e7*/
{
n8_2 = (char *)(dst_1 - (_QWORD)src); /*0xa3ed*/
if ( (unsigned __int64)&src[n8] >= dst_1 ) /*0xa3f3*/
{
src += n8; /*0xa3f5*/
dst_1 += n8; /*0xa3f8*/
v10 = 1; /*0xa3fc*/
}
}
if ( n8 < 8 || (unsigned __int64)n8_2 < 8 ) /*0xa409*/
goto LABEL_19; /*0xa409*/
count = (unsigned __int8)src & 7; /*0xa411*/
count_1 = dst_1 & 7; /*0xa415*/
if ( v10 ) /*0xa41b*/
{
--src; /*0xa41d*/
--dst_1; /*0xa420*/
}
if ( count == count_1 && count ) /*0xa42b*/
{
if ( !v10 ) /*0xa42f*/
count = 8 - count; /*0xa434*/
qmemcpy((void *)dst_1, src, count); /*0xa43d*/
src += count; /*0xa43d*/
dst_1 += count; /*0xa43d*/
n8_1 = n8 - count; /*0xa43f*/
}
if ( v10 ) /*0xa444*/
{
src -= 7; /*0xa446*/
dst_1 -= 7LL; /*0xa44a*/
}
n8_3 = n8_1; /*0xa44e*/
v15 = n8_1 >> 3; /*0xa451*/
qmemcpy((void *)dst_1, src, 8 * v15); /*0xa455*/
src += 8 * v15; /*0xa455*/
dst_1 += 8 * v15; /*0xa455*/
n8_4 = n8_3 & 7; /*0xa458*/
if ( n8_4 ) /*0xa45c*/
{
if ( v10 ) /*0xa460*/
{
src += 8; /*0xa462*/
dst_1 += 8LL; /*0xa466*/
}
n8_1 = n8_4; /*0xa46a*/
LABEL_19:
if ( v10 ) /*0xa46f*/
{
--src; /*0xa471*/
--dst_1; /*0xa474*/
}
qmemcpy((void *)dst_1, src, n8_1); /*0xa477*/
}
__asm { popf } /*0xa479*/
return dst; /*0xa47c*/
}
Ajax Dong