llvm::Value* Load::Codegen(WasmFunction* fct, llvm::IRBuilder<>& builder) {
llvm::Value* address = GetPointer(fct, builder);
// Create the load.
llvm::Value* value = builder.CreateLoad(address, "load");
// Now we need to convert this load to a size potentially.
switch (type_) {
case INT_32:
case INT_64:
value = ResizeIntegerIfNeed(value, value->getType(), type_, sign_, builder);
break;
case FLOAT_32:
case FLOAT_64:
assert(GetTypeSize(type_) == size_);
break;
default:
assert(0);
break;
}
return value;
}
int GetSafeNB(char pre, int MaxL1)
{
int i, L1, tsize, inc;
tsize = GetTypeSize(pre);
inc = ATL_MinMMAlign / tsize;
if (inc < 4) inc = 4;
L1 = (GetCacheSize(MaxL1) * 1024) / tsize;
for (i=inc; i*i < L1; i += inc);
if (i*i > L1) i -= inc;
if (pre == 'd' || pre == 's')
{
if (i*i == L1) i -= inc;
}
else
{
if (i*i == L1) i -= 2*inc;
else i -= inc;
}
if (i < 16) i = 16;
if (i > 80) i = 80;
return(i);
}
TEST_F(DropTests, DroppingTable) {
catalog::Bootstrapper::bootstrap();
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
txn_manager.BeginTransaction();
// Insert a table first
auto id_column =
catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER),
"dept_id", true);
auto name_column =
catalog::Column(VALUE_TYPE_VARCHAR, 32,
"dept_name", false);
std::unique_ptr<catalog::Schema> table_schema(new catalog::Schema({id_column, name_column}));
std::unique_ptr<catalog::Schema> table_schema2(new catalog::Schema({id_column, name_column}));
catalog::Bootstrapper::global_catalog->CreateDatabase("default_database");
txn_manager.CommitTransaction();
txn_manager.BeginTransaction();
catalog::Bootstrapper::global_catalog->CreateTable("default_database", "department_table", std::move(table_schema));
txn_manager.CommitTransaction();
txn_manager.BeginTransaction();
catalog::Bootstrapper::global_catalog->CreateTable("default_database", "department_table_2", std::move(table_schema2));
txn_manager.CommitTransaction();
EXPECT_EQ(catalog::Bootstrapper::global_catalog->GetDatabaseWithName("default_database")->GetTableCount(), 2);
// Now dropping the table using the executer
txn_manager.BeginTransaction();
catalog::Bootstrapper::global_catalog->DropTable("default_database", "department_table");
txn_manager.CommitTransaction();
EXPECT_EQ(catalog::Bootstrapper::global_catalog->GetDatabaseWithName("default_database")->GetTableCount(), 1);
}
PSZ ARRAY::MakeArrayList(PGLOBAL g)
{
char *p, *tp;
int i;
size_t z, len = 2;
if (Type == TYPE_LIST)
return "(?" "?" "?)"; // To be implemented
z = MY_MAX(24, GetTypeSize(Type, Len) + 4);
tp = (char*)PlugSubAlloc(g, NULL, z);
for (i = 0; i < Nval; i++) {
Value->SetValue_pvblk(Vblp, i);
Value->Print(g, tp, z);
len += strlen(tp);
} // enfor i
if (trace)
htrc("Arraylist: len=%d\n", len);
p = (char *)PlugSubAlloc(g, NULL, len);
strcpy(p, "(");
for (i = 0; i < Nval;) {
Value->SetValue_pvblk(Vblp, i);
Value->Print(g, tp, z);
strcat(p, tp);
strcat(p, (++i == Nval) ? ")" : ",");
} // enfor i
if (trace)
htrc("Arraylist: newlen=%d\n", strlen(p));
return p;
} // end of MakeArrayList
void VertexData::Load(u32 start, u32 count)
{
const u32 tsize = GetTypeSize();
data.SetCount((start + count) * tsize * size);
for(u32 i=start; i<start + count; ++i)
{
const u8* src = Memory.GetMemFromAddr(addr) + stride * i;
u8* dst = &data[i * tsize * size];
switch(tsize)
{
case 1:
{
memcpy(dst, src, size);
}
break;
case 2:
{
const u16* c_src = (const u16*)src;
u16* c_dst = (u16*)dst;
for(u32 j=0; j<size; ++j) *c_dst++ = re(*c_src++);
}
break;
case 4:
{
const u32* c_src = (const u32*)src;
u32* c_dst = (u32*)dst;
for(u32 j=0; j<size; ++j) *c_dst++ = re(*c_src++);
}
break;
}
}
}
void CNscContext::AddStructure (const char *pszIdentifier,
unsigned char *pauchStructData, size_t nStructDataSize)
{
//
// Make sure we still have room
//
if (m_nStructs >= Max_Structs)
{
GenerateError ("Too many defined structures, limit of %d",
m_nStructs);
return;
}
//
// Add a new symbol
//
NscType nType = (NscType) (NscType_Struct_0 + m_nStructs);
NscSymbol *pSymbol = m_sSymbols .Add (
pszIdentifier, NscSymType_Structure);
pSymbol ->nType = nType;
pSymbol ->ulFlags = 0;
pSymbol ->nStackOffset = 0;
size_t nSymbol = m_sSymbols .GetSymbolOffset (pSymbol);
m_sSymCount ++;
if (!IsNWScript() && m_fSymPrint) printf("Add struct symbol %s, count now %d\n", pszIdentifier, m_sSymCount);
//
// Count the number of elements
//
NscSymbolStructExtra sExtra;
sExtra .nElementCount = 0;
sExtra .nTotalSize = 0;
unsigned char *pauchData = pauchStructData;
unsigned char *pauchEnd = &pauchData [nStructDataSize];
while (pauchData < pauchEnd)
{
NscPCodeHeader *p = (NscPCodeHeader *) pauchData;
sExtra .nElementCount++;
sExtra .nTotalSize += GetTypeSize (p ->nType);
pauchData += p ->nOpSize;
}
//
// Add the symbol data
//
size_t nExtra = m_sSymbols .AppendData (&sExtra, sizeof (sExtra));
m_sSymbols .AppendData (pauchStructData, nStructDataSize);
//
// Save the data
//
m_sSymbols .GetSymbol (nSymbol) ->nExtra = nExtra;
//
// Save the symbol offset
//
m_anStructSymbol [m_nStructs++] = nSymbol;
m_anGlobalDefs .Add (nSymbol);
}
NscSymbol *CNscContext::AddPrototype (const char *pszIdentifier,
NscType nType, UINT32 ulFlags, unsigned char *pauchArgData,
size_t nArgDataSize)
{
//
// Check for duplicate
//
NscSymbol *pSymbol = m_sSymbols .Find (pszIdentifier);
if (pSymbol != NULL)
return pSymbol;
//
// Add a new symbol
//
pSymbol = m_sSymbols .Add (
pszIdentifier, NscSymType_Function);
pSymbol ->nType = nType;
pSymbol ->ulFlags = ulFlags;
pSymbol ->nStackOffset = 0;
pSymbol ->nCompiledStart = 0xffffffff;
pSymbol ->nCompiledEnd = 0xffffffff;
size_t nSymbol = m_sSymbols .GetSymbolOffset (pSymbol);
m_sSymCount ++;
if (!IsNWScript() && m_fSymPrint) printf("Add prototype symbol %s, count now %d\n", pszIdentifier, m_sSymCount);
//
// Count the number of arguments
//
NscSymbolFunctionExtra sExtra;
sExtra .nArgCount = 0;
sExtra .nArgSize = 0;
sExtra .nAction = 0;
sExtra .nCodeOffset = 0;
sExtra .nCodeSize = 0;
sExtra .nFile = -1;
sExtra .nLine = -1;
unsigned char *pauchData = pauchArgData;
unsigned char *pauchEnd = &pauchData [nArgDataSize];
while (pauchData < pauchEnd)
{
NscPCodeHeader *p = (NscPCodeHeader *) pauchData;
sExtra .nArgCount++;
sExtra .nArgSize += GetTypeSize (p ->nType);
pauchData += p ->nOpSize;
}
//
// If this is a global, then set the action
//
if ((ulFlags & NscSymFlag_EngineFunc) != 0)
{
g_anNscActions .Add (nSymbol);
sExtra .nAction = g_nNscActionCount++;
}
//
// Otherwise, add this function to the global symbol table
//
else if (IsPhase2 ())
{
AddGlobalFunction (nSymbol);
}
//
// Add the symbol data
//
size_t nExtra = m_sSymbols .AppendData (&sExtra, sizeof (sExtra));
m_sSymbols .AppendData (pauchArgData, nArgDataSize);
//
// Save the data
//
pSymbol = m_sSymbols .GetSymbol (nSymbol);
pSymbol ->nExtra = nExtra;
return pSymbol;
}
BOOLEAN
ObReadObject(
_In_ ULONG64 Object,
_Out_ PHANDLE_OBJECT HandleObj
)
/*++
Routine Description:
Description.
Arguments:
Object -
HandleObj -
Return Value:
BOOLEAN.
--*/
{
BOOLEAN Result = FALSE;
LPWSTR ObjName = NULL;
ULONG BodyOffset = 0;
GetFieldOffset("nt!_OBJECT_HEADER", "Body", &BodyOffset);
WCHAR TypeStr[64] = { 0 };
if ((!Object) || (!IsValid(Object))) return FALSE;
if (!ObTypeInit)
{
ObjTypeTable = ExtRemoteTyped("(nt!_OBJECT_TYPE **)@$extin", GetExpression("nt!ObTypeIndexTable"));
ObTypeInit = TRUE;
}
ULONG64 ObjHeaderAddr = Object - BodyOffset;
if (!IsValid(ObjHeaderAddr)) return FALSE;
ExtRemoteTyped ObjHeader("(nt!_OBJECT_HEADER *)@$extin", ObjHeaderAddr);
HandleObj->ObjectPtr = Object; // ObjHeader.Field("Body").GetPointerTo().GetPtr();
if (ObjHeader.HasField("TypeIndex"))
{
HandleObj->ObjectTypeIndex = ObjHeader.Field("TypeIndex").GetChar();
if ((HandleObj->ObjectTypeIndex <= 1) || (HandleObj->ObjectTypeIndex >= 45)) return FALSE;
ExtRemoteTypedEx::GetUnicodeString(ObjTypeTable.ArrayElement(HandleObj->ObjectTypeIndex).Field("Name"), TypeStr, sizeof(TypeStr));
wcscpy_s(HandleObj->Type, TypeStr);
}
else
{
if (!IsValid(ObjHeader.Field("Type").GetPtr())) goto CleanUp;
ExtRemoteTypedEx::GetUnicodeString(ObjHeader.Field("Type").Field("Name"), TypeStr, sizeof(TypeStr));
wcscpy_s(HandleObj->Type, TypeStr);
}
if (_wcsicmp(TypeStr, L"File") == 0)
{
ExtRemoteTyped FileObject("(nt!_FILE_OBJECT *)@$extin", HandleObj->ObjectPtr);
ObjName = ExtRemoteTypedEx::GetUnicodeString2(FileObject.Field("FileName"));
}
else if (_wcsicmp(TypeStr, L"Driver") == 0)
{
ExtRemoteTyped DrvObject("(nt!_DRIVER_OBJECT *)@$extin", HandleObj->ObjectPtr);
ObjName = ExtRemoteTypedEx::GetUnicodeString2(DrvObject.Field("DriverName"));
}
else if (_wcsicmp(TypeStr, L"Process") == 0)
{
ExtRemoteTyped ProcessObj("(nt!_EPROCESS *)@$extin", HandleObj->ObjectPtr);
ObjName = ExtRemoteTypedEx::GetUnicodeString2(ProcessObj.Field("ImageFileName"));
}
else if (_wcsicmp(TypeStr, L"ALPC Port") == 0)
{
// dt nt!_ALPC_PORT
}
else if (_wcsicmp(TypeStr, L"EtwRegistration") == 0)
{
// dt nt!_ETW_?
}
else if (_wcsicmp(TypeStr, L"Thread") == 0)
{
// dt nt!_ETHREAD
}
else if (_wcsicmp(TypeStr, L"Event") == 0)
{
// dt nt!_KTHREAD
}
else if (_wcsicmp(TypeStr, L"Key") == 0)
{
ExtRemoteTyped KeyObject("(nt!_CM_KEY_BODY *)@$extin", HandleObj->ObjectPtr);
HandleObj->ObjectKcb = KeyObject.Field("KeyControlBlock").GetPtr();
ObjName = RegGetKeyName(KeyObject.Field("KeyControlBlock"));
// dt nt!_CM_KEY_BODY -> nt!_CM_KEY_CONTROL_BLOCK
}
else
{
ULONG Offset = 0;
UCHAR InfoMask = 0;
if (ObjHeader.HasField("InfoMask"))
{
InfoMask = ObjHeader.Field("InfoMask").GetUchar();
if (InfoMask & OBP_NAME_INFO_BIT)
{
if (InfoMask & OBP_CREATOR_INFO_BIT) Offset += GetTypeSize("nt!_OBJECT_HEADER_CREATOR_INFO");
Offset += GetTypeSize("nt!_OBJECT_HEADER_NAME_INFO");
}
}
else
{
Offset = ObjHeader.Field("NameInfoOffset").GetUchar();
}
if (Offset)
{
ExtRemoteTyped ObjNameInfo("(nt!_OBJECT_HEADER_NAME_INFO *)@$extin", ObjHeaderAddr - Offset);
ObjName = ExtRemoteTypedEx::GetUnicodeString2(ObjNameInfo.Field("Name"));
}
}
if (ObjName)
{
wcscpy_s(HandleObj->Name, ObjName);
free(ObjName);
ObjName = NULL;
}
Result = TRUE;
CleanUp:
return Result;
}
/******************************************************************************
* *
* UINT GetTypeSize(TSYMTYPEDEF1 *pType1) *
* *
*******************************************************************************
*
* Returns the size (in bytes) of the type's memory footprint. The type can
* be any kind of type.
*
* Where:
* pType1 is the type descriptor to get the memory footprint
*
* Returns:
* Type memory footprint in bytes
* 0 if the type is invalid for some reasons
*
******************************************************************************/
UINT GetTypeSize(TSYMTYPEDEF1 *pType1)
{
TSYMTYPEDEF1 Type1; // Local type storage
UINT nSize = 0; // Size variable
char *pDef; // Pointer to the type definition
// Make sure the given type descriptor is valid
if( pType1 )
{
// Copy the input type into the local store so we may modify it
memcpy(&Type1, pType1, sizeof(TSYMTYPEDEF1));
// Get the local type into the canonical form - this will modify it
TypedefCanonical(&Type1);
// Simple - if there is any pointer redirection level, the final size is just the pointer size
if( Type1.maj )
return( sizeof(void *) );
// Depending on the base type, find the size - built in types:
if( *pType1->pDef <= TYPEDEF__LAST )
return( nSimpleTypes[*(BYTE *)pType1->pDef] );
// Get the new type definition...
pDef = Type1.pDef;
// We know we have a terminal type here - one of the complex types:
switch( *pDef )
{
case 'u': // Unions always keep the size in bits
case 's': // Structures always keep the size in bytes
pDef++;
nSize = GetDec(&pDef);
break;
case 'e': // Consider enum an integer size
case 'r': // A type that is a subrange of itself - right now we assume "int"
nSize = sizeof(int);
break;
case 'a': // Array is most complicated since we need the size of a child * the number of elements
{
int lower, upper; // Array bounds
pDef = strchr(pDef, ';'); // Find the first ';' to get to the bounds
scan2dec(pDef+1, &lower, &upper); // Scan 2 decimal numbers "%d,%d"
pDef = strchr(pDef, '('); // Find the trailing '(' to get to the child element
// This will call itself recursively to get the size of one array element
pType1 = Type2Typedef(pDef, 0, Type1.file_id);
nSize = (upper-lower+1) * GetTypeSize(pType1);
}
break;
default:
; // We should not be here...
break;
}
}
return( nSize );
}
/*
* Get type size information.
*/
static void GetTypeSize(ILSizeInfo *info, ILType *type)
{
unsigned long num;
unsigned long posn;
/* Only complex types have a non-zero memory size */
if(type == 0 || !ILType_IsComplex(type))
{
return;
}
/* Account for the size of the complex type header */
info->loadedMeta += sizeof(ILType);
/* Account for element information */
switch(ILType_Kind(type))
{
case IL_TYPE_COMPLEX_BYREF:
case IL_TYPE_COMPLEX_PTR:
case IL_TYPE_COMPLEX_PINNED:
{
GetTypeSize(info, ILType_Ref(type));
}
break;
case IL_TYPE_COMPLEX_ARRAY:
case IL_TYPE_COMPLEX_ARRAY_CONTINUE:
{
GetTypeSize(info, ILType_ElemType(type));
}
break;
case IL_TYPE_COMPLEX_CMOD_REQD:
case IL_TYPE_COMPLEX_CMOD_OPT:
{
GetTypeSize(info, type->un.modifier__.type__);
}
break;
case IL_TYPE_COMPLEX_LOCALS:
{
num = ILTypeNumLocals(type);
for(posn = 0; posn < num; ++posn)
{
GetTypeSize(info, ILTypeGetLocalWithPrefixes(type, posn));
}
}
break;
case IL_TYPE_COMPLEX_WITH:
{
num = ILTypeNumWithParams(type);
GetTypeSize(info, ILTypeGetWithMainWithPrefixes(type));
for(posn = 1; posn <= num; ++posn)
{
GetTypeSize(info, ILTypeGetWithParamWithPrefixes(type, posn));
}
}
break;
case IL_TYPE_COMPLEX_PROPERTY:
case IL_TYPE_COMPLEX_METHOD:
case IL_TYPE_COMPLEX_METHOD | IL_TYPE_COMPLEX_METHOD_SENTINEL:
{
num = ILTypeNumParams(type);
GetTypeSize(info, ILTypeGetReturnWithPrefixes(type));
for(posn = 1; posn <= num; ++posn)
{
GetTypeSize(info, ILTypeGetParamWithPrefixes(type, posn));
}
}
break;
}
}
/*
* Get the metadata size information for a program item,
* both on-disk and in-memory.
*/
static void GetMetadataSize(ILSizeInfo *info, ILProgramItem *item)
{
ILImage *image = ILProgramItem_Image(item);
if(!item)
{
return;
}
info->meta += image->tokenSize[ILProgramItem_Token(item) >> 24];
switch(ILProgramItem_Token(item) & IL_META_TOKEN_MASK)
{
case IL_META_TOKEN_MODULE:
GetStringSize(info, ILModule_Name((ILModule *)item));
info->meta += 16; /* GUID size */
info->loadedMeta += sizeof(ILModule);
break;
case IL_META_TOKEN_MODULE_REF:
GetStringSize(info, ILModule_Name((ILModule *)item));
info->loadedMeta += sizeof(ILModule);
break;
case IL_META_TOKEN_TYPE_REF:
info->loadedMeta += sizeof(ILClass);
info->loadedMeta += sizeof(ILProgramItemLink);
GetClassNameSize(info, (ILClass *)item);
break;
case IL_META_TOKEN_TYPE_DEF:
info->loadedMeta += sizeof(ILClass);
GetClassNameSize(info, (ILClass *)item);
break;
case IL_META_TOKEN_FIELD_DEF:
info->loadedMeta += sizeof(ILField);
GetStringSize(info, ILMember_Name(item));
GetBlobSize(info, item, ((ILMember *)item)->signatureBlob);
GetTypeSize(info, ILMember_Signature(item));
break;
case IL_META_TOKEN_METHOD_DEF:
info->loadedMeta += sizeof(ILMethod);
GetStringSize(info, ILMember_Name(item));
GetBlobSize(info, item, ((ILMember *)item)->signatureBlob);
GetTypeSize(info, ILMember_Signature(item));
break;
case IL_META_TOKEN_PARAM_DEF:
info->loadedMeta += sizeof(ILParameter);
GetStringSize(info, ILParameter_Name((ILParameter *)item));
break;
case IL_META_TOKEN_INTERFACE_IMPL:
info->loadedMeta += sizeof(ILImplements);
break;
case IL_META_TOKEN_MEMBER_REF:
if(ILMemberGetKind((ILMember *)item) == IL_META_MEMBERKIND_METHOD)
{
info->loadedMeta += sizeof(ILMethod);
}
else
{
info->loadedMeta += sizeof(ILField);
}
info->loadedMeta += sizeof(ILProgramItemLink);
GetStringSize(info, ILMember_Name(item));
GetBlobSize(info, item, ((ILMember *)item)->signatureBlob);
GetTypeSize(info, ILMember_Signature(item));
break;
case IL_META_TOKEN_CONSTANT:
info->loadedMeta += sizeof(ILConstant);
GetBlobSize(info, item, ((ILConstant *)item)->value);
break;
case IL_META_TOKEN_CUSTOM_ATTRIBUTE:
info->loadedMeta += sizeof(ILAttribute);
GetBlobSize(info, item, ((ILAttribute *)item)->value);
break;
case IL_META_TOKEN_FIELD_MARSHAL:
info->loadedMeta += sizeof(ILFieldMarshal);
GetBlobSize(info, item, ((ILFieldMarshal *)item)->type);
break;
case IL_META_TOKEN_DECL_SECURITY:
info->loadedMeta += sizeof(ILDeclSecurity);
GetBlobSize(info, item, ((ILDeclSecurity *)item)->blob);
break;
case IL_META_TOKEN_CLASS_LAYOUT:
info->loadedMeta += sizeof(ILClassLayout);
break;
case IL_META_TOKEN_FIELD_LAYOUT:
info->loadedMeta += sizeof(ILFieldLayout);
break;
case IL_META_TOKEN_STAND_ALONE_SIG:
info->loadedMeta += sizeof(ILStandAloneSig);
GetBlobSize(info, item, ((ILStandAloneSig *)item)->typeBlob);
GetTypeSize(info, ((ILStandAloneSig *)item)->type);
break;
case IL_META_TOKEN_EVENT_MAP:
info->loadedMeta += sizeof(ILEventMap);
break;
case IL_META_TOKEN_EVENT:
info->loadedMeta += sizeof(ILEvent);
break;
case IL_META_TOKEN_PROPERTY_MAP:
info->loadedMeta += sizeof(ILPropertyMap);
break;
case IL_META_TOKEN_PROPERTY:
info->loadedMeta += sizeof(ILProperty);
break;
case IL_META_TOKEN_METHOD_SEMANTICS:
info->loadedMeta += sizeof(ILMethodSem);
break;
case IL_META_TOKEN_METHOD_IMPL:
info->loadedMeta += sizeof(ILOverride);
break;
case IL_META_TOKEN_TYPE_SPEC:
info->loadedMeta += sizeof(ILTypeSpec);
GetBlobSize(info, item, ((ILTypeSpec *)item)->typeBlob);
GetTypeSize(info, ((ILTypeSpec *)item)->type);
break;
case IL_META_TOKEN_IMPL_MAP:
info->loadedMeta += sizeof(ILPInvoke);
GetStringSize(info, ILPInvoke_Alias((ILPInvoke *)item));
break;
case IL_META_TOKEN_FIELD_RVA:
info->loadedMeta += sizeof(ILFieldRVA);
break;
case IL_META_TOKEN_ASSEMBLY:
info->loadedMeta += sizeof(ILAssembly);
GetStringSize(info, ILAssembly_Name((ILAssembly *)item));
GetStringSize(info, ILAssembly_Locale((ILAssembly *)item));
break;
case IL_META_TOKEN_ASSEMBLY_REF:
info->loadedMeta += sizeof(ILAssembly);
info->loadedMeta += sizeof(ILProgramItemLink);
GetStringSize(info, ILAssembly_Name((ILAssembly *)item));
GetStringSize(info, ILAssembly_Locale((ILAssembly *)item));
break;
case IL_META_TOKEN_PROCESSOR_DEF:
case IL_META_TOKEN_PROCESSOR_REF:
info->loadedMeta += sizeof(ILProcessorInfo);
break;
case IL_META_TOKEN_OS_DEF:
case IL_META_TOKEN_OS_REF:
info->loadedMeta += sizeof(ILOSInfo);
break;
case IL_META_TOKEN_FILE:
info->loadedMeta += sizeof(ILFileDecl);
GetStringSize(info, ILFileDecl_Name((ILFileDecl *)item));
GetBlobSize(info, item, ((ILFileDecl *)item)->hash);
break;
case IL_META_TOKEN_EXPORTED_TYPE:
info->loadedMeta += sizeof(ILExportedType);
info->loadedMeta += sizeof(ILProgramItemLink);
GetClassNameSize(info, (ILClass *)item);
break;
case IL_META_TOKEN_MANIFEST_RESOURCE:
info->loadedMeta += sizeof(ILManifestRes);
GetStringSize(info, ILManifestRes_Name((ILManifestRes *)item));
break;
case IL_META_TOKEN_NESTED_CLASS:
info->loadedMeta += sizeof(ILNestedInfo);
break;
case IL_META_TOKEN_GENERIC_PAR:
info->loadedMeta += sizeof(ILGenericPar);
GetStringSize(info, ILGenericPar_Name((ILGenericPar *)item));
break;
case IL_META_TOKEN_METHOD_SPEC:
info->loadedMeta += sizeof(ILMethodSpec);
GetBlobSize(info, item, ((ILMethodSpec *)item)->typeBlob);
GetTypeSize(info, ((ILMethodSpec *)item)->type);
break;
}
}
void CSearchDlg::StartNewSearch()
{
static uint32 m_nSearchID = 0;
m_nSearchID++;
FindWindow(IDC_STARTS)->Disable();
FindWindow(IDC_SDOWNLOAD)->Disable();
FindWindow(IDC_CANCELS)->Enable();
CSearchList::CSearchParams params;
params.searchString = CastChild( IDC_SEARCHNAME, wxTextCtrl )->GetValue();
params.searchString.Trim(true);
params.searchString.Trim(false);
if (params.searchString.IsEmpty()) {
return;
}
if (CastChild(IDC_EXTENDEDSEARCHCHECK, wxCheckBox)->GetValue()) {
params.extension = CastChild( IDC_EDITSEARCHEXTENSION, wxTextCtrl )->GetValue();
uint32 sizemin = GetTypeSize( (uint8) CastChild( IDC_SEARCHMINSIZE, wxChoice )->GetSelection() );
uint32 sizemax = GetTypeSize( (uint8) CastChild( IDC_SEARCHMAXSIZE, wxChoice )->GetSelection() );
// Parameter Minimum Size
params.minSize = (uint64_t)(CastChild( IDC_SPINSEARCHMIN, wxSpinCtrl )->GetValue()) * (uint64_t)sizemin;
// Parameter Maximum Size
params.maxSize = (uint64_t)(CastChild( IDC_SPINSEARCHMAX, wxSpinCtrl )->GetValue()) * (uint64_t)sizemax;
if ((params.maxSize < params.minSize) && (params.maxSize)) {
wxMessageDialog dlg(this,
_("Min size must be smaller than max size. Max size ignored."),
_("Search warning"), wxOK|wxCENTRE|wxICON_INFORMATION);
dlg.ShowModal();
params.maxSize = 0;
}
// Parameter Availability
params.availability = CastChild( IDC_SPINSEARCHAVAIBILITY, wxSpinCtrl )->GetValue();
switch ( CastChild( IDC_TypeSearch, wxChoice )->GetSelection() ) {
case 0: params.typeText.Clear(); break;
case 1: params.typeText = ED2KFTSTR_ARCHIVE; break;
case 2: params.typeText = ED2KFTSTR_AUDIO; break;
case 3: params.typeText = ED2KFTSTR_CDIMAGE; break;
case 4: params.typeText = ED2KFTSTR_IMAGE; break;
case 5: params.typeText = ED2KFTSTR_PROGRAM; break;
case 6: params.typeText = ED2KFTSTR_DOCUMENT; break;
case 7: params.typeText = ED2KFTSTR_VIDEO; break;
default:
AddDebugLogLineC( logGeneral,
CFormat( wxT("Warning! Unknown search-category (%s) selected!") )
% params.typeText
);
break;
}
}
SearchType search_type = KadSearch;
int selection = CastChild( ID_SEARCHTYPE, wxChoice )->GetSelection();
if (!thePrefs::GetNetworkED2K()) {
selection += 2;
}
if (!thePrefs::GetNetworkKademlia()) {
selection += 1;
}
switch (selection) {
case 0: // Local Search
search_type = LocalSearch;
break;
case 1: // Global Search
search_type = GlobalSearch;
break;
case 2: // Kad search
search_type = KadSearch;
break;
default:
// Should never happen
wxFAIL;
break;
}
uint32 real_id = m_nSearchID;
wxString error = theApp->searchlist->StartNewSearch(&real_id, search_type, params);
if (!error.IsEmpty()) {
// Search failed / Remote in progress
wxMessageBox(error, _("Search warning"),
wxOK | wxCENTRE | wxICON_INFORMATION, this);
FindWindow(IDC_STARTS)->Enable();
FindWindow(IDC_SDOWNLOAD)->Disable();
FindWindow(IDC_CANCELS)->Disable();
} else {
CreateNewTab(
((search_type == KadSearch) ? wxT("!") : wxEmptyString) +
params.searchString + wxT(" (0)"),
real_id);
}
}
static bool DeserializeObject(CLR_RT_HeapBlock* pObj, CLR_UINT8* serData, CLR_INT32& serOffset, const CLR_INT32 serSize )
{
if(pObj == NULL)
{
return false;
}
switch(pObj->DataType())
{
case DATATYPE_OBJECT:
if(!DeserializeObject(pObj->Dereference(), serData, serOffset, serSize)) return false;
break;
case DATATYPE_CLASS:
case DATATYPE_VALUETYPE:
{
CLR_RT_TypeDef_Instance cls; cls.InitializeFromIndex( pObj->ObjectCls() );
int totFields = cls.CrossReference().m_totalFields;
while(totFields-- > 0)
{
if(!DeserializeObject( ++pObj, serData, serOffset, serSize )) return false;
}
}
break;
case DATATYPE_SZARRAY:
{
CLR_RT_HeapBlock_Array* array = (CLR_RT_HeapBlock_Array*)pObj;
int cnt = array->m_numOfElements;
if(array->m_typeOfElement <= DATATYPE_LAST_NONPOINTER && cnt < 256)
{
CLR_UINT8* pData = (CLR_UINT8*)array->GetFirstElement();
int nativeSize = GetTypeSize((CLR_DataType)array->m_typeOfElement);
if(nativeSize <= 0) return false;
while(cnt--)
{
int size = nativeSize;
int i = 0;
while(size--)
{
#ifndef BIG_ENDIAN
pData[i++ ] = serData[serOffset++];
#else
pData[size] = serData[serOffset++];
#endif
}
pData += array->m_sizeOfElement;
}
}
else
{
return false;
}
}
break;
default:
{
CLR_UINT64 data = (CLR_UINT64)pObj->NumericByRef().u8;
if(!DeserializeIntrinsicType(pObj, serData, serOffset, serSize)) return false;
}
break;
}
return true;
}
void CreateYCSBDatabase() {
const oid_t col_count = state.column_count + 1;
const bool is_inlined = true;
/////////////////////////////////////////////////////////
// Create tables
/////////////////////////////////////////////////////////
// Clean up
delete ycsb_database;
ycsb_database = nullptr;
user_table = nullptr;
auto &manager = catalog::Manager::GetInstance();
ycsb_database = new storage::Database(ycsb_database_oid);
manager.AddDatabase(ycsb_database);
bool own_schema = true;
bool adapt_table = false;
// Create schema first
std::vector<catalog::Column> columns;
auto column =
catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER),
"YCSB_KEY", is_inlined);
columns.push_back(column);
for (oid_t col_itr = 1; col_itr < col_count; col_itr++) {
auto column =
catalog::Column(VALUE_TYPE_INTEGER, ycsb_field_length,
"FIELD" + std::to_string(col_itr), is_inlined);
columns.push_back(column);
}
catalog::Schema *table_schema = new catalog::Schema(columns);
std::string table_name("USERTABLE");
user_table = storage::TableFactory::GetDataTable(
ycsb_database_oid, user_table_oid, table_schema, table_name, 1000,
own_schema, adapt_table);
ycsb_database->AddTable(user_table);
// Primary index on user key
std::vector<oid_t> key_attrs;
auto tuple_schema = user_table->GetSchema();
catalog::Schema *key_schema;
index::IndexMetadata *index_metadata;
bool unique;
key_attrs = {0};
key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs);
key_schema->SetIndexedColumns(key_attrs);
unique = true;
index_metadata = new index::IndexMetadata(
"primary_index", user_table_pkey_index_oid, INDEX_TYPE_BTREE,
INDEX_CONSTRAINT_TYPE_INVALID, tuple_schema, key_schema, unique);
index::Index *pkey_index = index::IndexFactory::GetInstance(index_metadata);
user_table->AddIndex(pkey_index);
}
Offset<const Table *> CopyTable(FlatBufferBuilder &fbb,
const reflection::Schema &schema,
const reflection::Object &objectdef,
const Table &table,
bool use_string_pooling) {
// Before we can construct the table, we have to first generate any
// subobjects, and collect their offsets.
std::vector<uoffset_t> offsets;
auto fielddefs = objectdef.fields();
for (auto it = fielddefs->begin(); it != fielddefs->end(); ++it) {
auto &fielddef = **it;
// Skip if field is not present in the source.
if (!table.CheckField(fielddef.offset())) continue;
uoffset_t offset = 0;
switch (fielddef.type()->base_type()) {
case reflection::String: {
offset = use_string_pooling
? fbb.CreateSharedString(GetFieldS(table, fielddef)).o
: fbb.CreateString(GetFieldS(table, fielddef)).o;
break;
}
case reflection::Obj: {
auto &subobjectdef = *schema.objects()->Get(fielddef.type()->index());
if (!subobjectdef.is_struct()) {
offset = CopyTable(fbb, schema, subobjectdef,
*GetFieldT(table, fielddef)).o;
}
break;
}
case reflection::Union: {
auto &subobjectdef = GetUnionType(schema, objectdef, fielddef, table);
offset = CopyTable(fbb, schema, subobjectdef,
*GetFieldT(table, fielddef)).o;
break;
}
case reflection::Vector: {
auto vec = table.GetPointer<const Vector<Offset<Table>> *>(
fielddef.offset());
auto element_base_type = fielddef.type()->element();
auto elemobjectdef = element_base_type == reflection::Obj
? schema.objects()->Get(fielddef.type()->index())
: nullptr;
switch (element_base_type) {
case reflection::String: {
std::vector<Offset<const String *>> elements(vec->size());
auto vec_s = reinterpret_cast<const Vector<Offset<String>> *>(vec);
for (uoffset_t i = 0; i < vec_s->size(); i++) {
elements[i] = use_string_pooling
? fbb.CreateSharedString(vec_s->Get(i)).o
: fbb.CreateString(vec_s->Get(i)).o;
}
offset = fbb.CreateVector(elements).o;
break;
}
case reflection::Obj: {
if (!elemobjectdef->is_struct()) {
std::vector<Offset<const Table *>> elements(vec->size());
for (uoffset_t i = 0; i < vec->size(); i++) {
elements[i] =
CopyTable(fbb, schema, *elemobjectdef, *vec->Get(i));
}
offset = fbb.CreateVector(elements).o;
break;
}
}
// FALL-THRU
default: { // Scalars and structs.
auto element_size = GetTypeSize(element_base_type);
if (elemobjectdef && elemobjectdef->is_struct())
element_size = elemobjectdef->bytesize();
fbb.StartVector(element_size, vec->size());
fbb.PushBytes(vec->Data(), element_size * vec->size());
offset = fbb.EndVector(vec->size());
break;
}
}
break;
}
default: // Scalars.
break;
}
if (offset) {
offsets.push_back(offset);
}
}
// Now we can build the actual table from either offsets or scalar data.
auto start = objectdef.is_struct()
? fbb.StartStruct(objectdef.minalign())
: fbb.StartTable();
size_t offset_idx = 0;
for (auto it = fielddefs->begin(); it != fielddefs->end(); ++it) {
auto &fielddef = **it;
if (!table.CheckField(fielddef.offset())) continue;
auto base_type = fielddef.type()->base_type();
switch (base_type) {
case reflection::Obj: {
auto &subobjectdef = *schema.objects()->Get(fielddef.type()->index());
if (subobjectdef.is_struct()) {
CopyInline(fbb, fielddef, table, subobjectdef.minalign(),
subobjectdef.bytesize());
break;
}
}
// ELSE FALL-THRU
case reflection::Union:
case reflection::String:
case reflection::Vector:
fbb.AddOffset(fielddef.offset(), Offset<void>(offsets[offset_idx++]));
break;
default: { // Scalars.
auto size = GetTypeSize(base_type);
CopyInline(fbb, fielddef, table, size, size);
break;
}
}
}
assert(offset_idx == offsets.size());
if (objectdef.is_struct()) {
fbb.ClearOffsets();
return fbb.EndStruct();
} else {
return fbb.EndTable(start, static_cast<voffset_t>(fielddefs->size()));
}
}
vector<NETWORK_ENTRY>
GetSockets(
)
/*++
Routine Description:
Description.
Arguments:
-
Return Value:
vector<NETWORK_ENTRY>.
--*/
{
ULONG64 TableAddr;
ULONG64 TableCountAddr;
PULONG64 Table = NULL;
ULONG TableCount;
vector<NETWORK_ENTRY> NetworkEntries;
ULONG ProcessorType;
ULONG PlateformId, Major, Minor, ServicePackNumber;
if (g_Ext->m_Control->GetActualProcessorType(&ProcessorType) != S_OK) goto CleanUp;
if (g_Ext->m_Control->GetSystemVersion(&PlateformId, &Major, &Minor, NULL, NULL, NULL, &ServicePackNumber, NULL, NULL, NULL) != S_OK) goto CleanUp;
// g_Ext->Dml("Major: %d, Minor: %d, ProcessorType = %x\n", Major, Minor, ProcessorType);
if ((Minor < 6000) && (ProcessorType == IMAGE_FILE_MACHINE_I386))
{
if (g_Ext->m_Symbols->GetOffsetByName("tcpip!AddrObjTable", &TableAddr) != S_OK) goto CleanUp;
if (g_Ext->m_Symbols->GetOffsetByName("tcpip!AddrObjTableSize", &TableCountAddr) != S_OK) goto CleanUp;
if (ReadPointersVirtual(1, TableAddr, &TableAddr) != S_OK) goto CleanUp;
if (g_Ext->m_Data->ReadVirtual(TableCountAddr, &TableCount, sizeof(ULONG), NULL) != S_OK) goto CleanUp;
Table = (PULONG64)malloc(TableCount * sizeof(ULONG64));
if (ReadPointersVirtual(TableCount, TableAddr, Table) != S_OK) goto CleanUp;
for (UINT i = 0; i < TableCount; i += 1)
{
Network::OBJECT_ENTRY_X86 ObjectEntry = { 0 };
NETWORK_ENTRY NetworkEntry = { 0 };
if (Table[i] == 0) continue;
if (g_Ext->m_Data->ReadVirtual(Table[i], &ObjectEntry, sizeof(Network::OBJECT_ENTRY_X86), NULL) != S_OK) goto CleanUp;
NetworkEntry.ObjectPtr = Table[i];
NetworkEntry.CreationTime = ObjectEntry.CreationTime;
NetworkEntry.ProcessId = ObjectEntry.ProcessId;
NetworkEntry.Protocol = ObjectEntry.Protocol;
NetworkEntry.Local.Port = (ObjectEntry.Port[1] << 8) | ObjectEntry.Port[0];
NetworkEntry.Local.IPv4_Addr[3] = ObjectEntry.LocalAddress[3];
NetworkEntry.Local.IPv4_Addr[2] = ObjectEntry.LocalAddress[2];
NetworkEntry.Local.IPv4_Addr[1] = ObjectEntry.LocalAddress[1];
NetworkEntry.Local.IPv4_Addr[0] = ObjectEntry.LocalAddress[0];
NetworkEntry.State = TcbListenState;
NetworkEntries.push_back(NetworkEntry);
}
}
else if (Minor > 6000)
{
if (g_Ext->m_Symbols->GetOffsetByName("tcpip!PartitionCount", &TableCountAddr) != S_OK) goto CleanUp;
ReadPointer(GetExpression("tcpip!PartitionTable"), &TableAddr);
if (!TableAddr) goto CleanUp;
if (g_Ext->m_Data->ReadVirtual(TableCountAddr, &TableCount, sizeof(ULONG), NULL) != S_OK) goto CleanUp;
ULONG ListEntrySize = GetTypeSize("nt!_LIST_ENTRY");
ULONG PoolHeaderSize = GetTypeSize("nt!_POOL_HEADER");
ExtRemoteUnTyped PartitionTable(TableAddr, "tcpip!_PARTITION_TABLE");
for (UINT PartitionIndex = 0; PartitionIndex < TableCount; PartitionIndex += 1)
{
NETWORK_ENTRY NetworkEntry = { 0 };
// g_Ext->Dml(" -> Partition[%d].HashTables = 0x%I64X\n", PartitionIndex, Partition->HashTables);
ExtRemoteTyped HashTable("(nt!_RTL_DYNAMIC_HASH_TABLE *)@$extin", PartitionTable.ArrayElement(PartitionIndex).Field("HashTables").GetPtr());
ULONG64 Directory = HashTable.Field("Directory").GetPtr();
ULONG TableEntries = HashTable.Field("TableSize").GetUlong();
for (UINT i = 0; i < TableEntries; i += 1)
{
ExtRemoteTypedList List(Directory + i * ListEntrySize, "nt!_LIST_ENTRY", "Flink");
for (List.StartHead(); List.HasNode(); List.Next())
{
ULONG64 Current = List.GetNodeOffset();
if (!IsValid(Current)) break;
ExtRemoteUnTyped Tcb(Current, "tcpip!_TCB");
Tcb.SubtractOffset("HashTableEntry");
ExtRemoteTyped PoolHeader("(nt!_POOL_HEADER *)@$extin", Tcb.GetPointerTo() - PoolHeaderSize);
if (PoolHeader.Field("PoolTag").GetUlong() != 'EpcT') continue;
//# Seen as 0x1f0 on Vista SP0, 0x1f8 on Vista SP2 and 0x210 on 7
//# Seen as 0x320 on Win7 SP0 x64
ULONG PoolSize;
if (PoolHeader.Field("BlockSize").GetTypeSize() == sizeof(USHORT))
{
PoolSize = PoolHeader.Field("BlockSize").GetUshort() * 0x10;
}
else
{
PoolSize = PoolHeader.Field("BlockSize").GetUlong() * 0x10;
}
if (PoolSize < 0x100) continue;
ULONG64 SrcAddress = 0;
ULONG64 DstAddress = 0;
NetworkEntry.Protocol = PROTOCOL_TCP;
NetworkEntry.State = Tcb.Field("State").GetUlong();
NetworkEntry.Local.Port = Tcb.Field("LocalPort").GetUshort();
NetworkEntry.Remote.Port = Tcb.Field("RemotePort").GetUshort();
DstAddress = Tcb.Field("Path", TRUE).Field("DestinationAddress").GetPtr();
if (IsValid(Tcb.Field("Path").GetPtr() &&
IsValid(Tcb.Field("Path", TRUE).Field("SourceAddress").GetPtr()) &&
IsValid(Tcb.Field("Path", TRUE).Field("SourceAddress", TRUE).Field("Identifier").GetPtr()) &&
IsValid(Tcb.Field("Path", TRUE).Field("SourceAddress", TRUE).Field("Identifier", TRUE).Field("Address").GetPtr())))
{
SrcAddress = Tcb.Field("Path", TRUE).Field("SourceAddress", TRUE).Field("Identifier", TRUE).Field("Address").GetPtr();
}
if (DstAddress && g_Ext->m_Data->ReadVirtual(DstAddress, &NetworkEntry.Remote.IPv4_Addr, sizeof(NetworkEntry.Remote.IPv4_Addr), NULL) != S_OK) goto CleanUp;
if (SrcAddress && g_Ext->m_Data->ReadVirtual(SrcAddress, &NetworkEntry.Local.IPv4_Addr, sizeof(NetworkEntry.Local.IPv4_Addr), NULL) != S_OK) goto CleanUp;
ExtRemoteTyped OwningProcess("(nt!_EPROCESS *)@$extin", Tcb.Field("OwningProcess").GetPtr());
NetworkEntry.ProcessId = OwningProcess.Field("UniqueProcessId").GetPtr();
OwningProcess.Field("ImageFileName").GetString((LPSTR)NetworkEntry.ProcessName, sizeof(NetworkEntry.ProcessName));
NetworkEntries.push_back(NetworkEntry);
}
}
}
}
CleanUp:
if (Table) free(Table);
return NetworkEntries;
}
void WDbgArk::InitCallbackCommands(void) {
// TODO(swwwolf): optimize by calculating offsets in constructor only once
// init systemcb map
SystemCbCommand command_info = { "nt!PspLoadImageNotifyRoutineCount", "nt!PspLoadImageNotifyRoutine", 0 };
system_cb_commands["image"] = command_info;
command_info.list_count_name = "nt!PspCreateProcessNotifyRoutineCount";
command_info.list_head_name = "nt!PspCreateProcessNotifyRoutine";
system_cb_commands["process"] = command_info;
command_info.list_count_name = "nt!PspCreateThreadNotifyRoutineCount";
command_info.list_head_name = "nt!PspCreateThreadNotifyRoutine";
system_cb_commands["thread"] = command_info;
command_info.list_count_name = "nt!CmpCallBackCount";
command_info.list_head_name = "nt!CmpCallBackVector";
command_info.offset_to_routine = GetCmCallbackItemFunctionOffset();
system_cb_commands["registry"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!KeBugCheckCallbackListHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY");
system_cb_commands["bugcheck"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!KeBugCheckReasonCallbackListHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY");
system_cb_commands["bugcheckreason"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!KeBugCheckAddPagesCallbackListHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY");
system_cb_commands["bugcheckaddpages"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!PopRegisteredPowerSettingCallbacks";
command_info.offset_to_routine = GetPowerCallbackItemFunctionOffset();
system_cb_commands["powersetting"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "";
command_info.offset_to_routine = 0;
system_cb_commands["callbackdir"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!IopNotifyShutdownQueueHead";
system_cb_commands["shutdown"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!IopNotifyLastChanceShutdownQueueHead";
system_cb_commands["shutdownlast"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!IopDriverReinitializeQueueHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY") + m_PtrSize;
system_cb_commands["drvreinit"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!IopBootDriverReinitializeQueueHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY") + m_PtrSize;
system_cb_commands["bootdrvreinit"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!IopFsNotifyChangeQueueHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY") + m_PtrSize;
system_cb_commands["fschange"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!KiNmiCallbackListHead";
command_info.offset_to_routine = m_PtrSize;
system_cb_commands["nmi"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!SeFileSystemNotifyRoutinesHead";
command_info.offset_to_routine = m_PtrSize;
system_cb_commands["logonsessionroutine"] = command_info;
command_info.list_count_name = "nt!IopUpdatePriorityCallbackRoutineCount";
command_info.list_head_name = "nt!IopUpdatePriorityCallbackRoutine";
command_info.offset_to_routine = 0;
system_cb_commands["prioritycallback"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "";
system_cb_commands["pnp"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!PspLegoNotifyRoutine"; // actually just a pointer
system_cb_commands["lego"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!RtlpDebugPrintCallbackList";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY");
system_cb_commands["debugprint"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!AlpcpLogCallbackListHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY");
system_cb_commands["alpcplog"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!EmpCallbackListHead";
command_info.offset_to_routine = GetTypeSize("nt!_GUID");
system_cb_commands["empcb"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!IopPerfIoTrackingListHead";
command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY");
system_cb_commands["ioperf"] = command_info;
command_info.list_count_name = "";
command_info.list_head_name = "nt!DbgkLkmdCallbackArray";
command_info.offset_to_routine = 0;
system_cb_commands["dbgklkmd"] = command_info;
}
void ExecuteTileGroupTest() {
const int tuples_per_tilegroup_count = 10;
const int tile_group_count = 5;
const int tuple_count = tuples_per_tilegroup_count * tile_group_count;
const oid_t col_count = 250;
const bool is_inlined = true;
const bool indexes = false;
std::vector<catalog::Column> columns;
for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) {
auto column =
catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER),
"FIELD" + std::to_string(col_itr), is_inlined);
columns.push_back(column);
}
catalog::Schema *table_schema = new catalog::Schema(columns);
std::string table_name("TEST_TABLE");
/////////////////////////////////////////////////////////
// Create table.
/////////////////////////////////////////////////////////
bool own_schema = true;
bool adapt_table = true;
std::unique_ptr<storage::DataTable> table(storage::TableFactory::GetDataTable(
INVALID_OID, INVALID_OID, table_schema, table_name,
tuples_per_tilegroup_count, own_schema, adapt_table));
// PRIMARY INDEX
if (indexes == true) {
std::vector<oid_t> key_attrs;
auto tuple_schema = table->GetSchema();
catalog::Schema *key_schema;
index::IndexMetadata *index_metadata;
bool unique;
key_attrs = {0};
key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs);
key_schema->SetIndexedColumns(key_attrs);
unique = true;
index_metadata = new index::IndexMetadata(
"primary_index", 123, INDEX_TYPE_BTREE,
INDEX_CONSTRAINT_TYPE_PRIMARY_KEY, tuple_schema, key_schema, unique);
index::Index *pkey_index = index::IndexFactory::GetInstance(index_metadata);
table->AddIndex(pkey_index);
}
/////////////////////////////////////////////////////////
// Load in the data
/////////////////////////////////////////////////////////
// Insert tuples into tile_group.
auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
const bool allocate = true;
auto txn = txn_manager.BeginTransaction();
auto testing_pool = TestingHarness::GetInstance().GetTestingPool();
for (int rowid = 0; rowid < tuple_count; rowid++) {
int populate_value = rowid;
storage::Tuple tuple(table_schema, allocate);
for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) {
auto value = ValueFactory::GetIntegerValue(populate_value + col_itr);
tuple.SetValue(col_itr, value, testing_pool);
}
ItemPointer tuple_slot_id = table->InsertTuple(&tuple);
EXPECT_TRUE(tuple_slot_id.block != INVALID_OID);
EXPECT_TRUE(tuple_slot_id.offset != INVALID_OID);
txn_manager.PerformInsert(tuple_slot_id.block, tuple_slot_id.offset);
}
txn_manager.CommitTransaction();
/////////////////////////////////////////////////////////
// Do a seq scan with predicate on top of the table
/////////////////////////////////////////////////////////
txn = txn_manager.BeginTransaction();
std::unique_ptr<executor::ExecutorContext> context(
new executor::ExecutorContext(txn));
// Column ids to be added to logical tile after scan.
// std::vector<oid_t> column_ids;
// for(oid_t col_itr = 0 ; col_itr <= 200; col_itr++) {
// column_ids.push_back(col_itr);
//}
std::vector<oid_t> column_ids({198, 206});
// Create and set up seq scan executor
planner::SeqScanPlan seq_scan_node(table.get(), nullptr, column_ids);
int expected_num_tiles = tile_group_count;
executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get());
// Create and set up materialization executor
std::vector<catalog::Column> output_columns;
std::unordered_map<oid_t, oid_t> old_to_new_cols;
oid_t col_itr = 0;
for (auto column_id : column_ids) {
auto column =
catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER),
"FIELD" + std::to_string(column_id), is_inlined);
output_columns.push_back(column);
old_to_new_cols[col_itr] = col_itr;
col_itr++;
}
std::unique_ptr<catalog::Schema> output_schema(
new catalog::Schema(output_columns));
bool physify_flag = true; // is going to create a physical tile
planner::MaterializationPlan mat_node(old_to_new_cols,
output_schema.release(), physify_flag);
executor::MaterializationExecutor mat_executor(&mat_node, nullptr);
mat_executor.AddChild(&seq_scan_executor);
EXPECT_TRUE(mat_executor.Init());
std::vector<std::unique_ptr<executor::LogicalTile>> result_tiles;
for (int i = 0; i < expected_num_tiles; i++) {
EXPECT_TRUE(mat_executor.Execute());
std::unique_ptr<executor::LogicalTile> result_tile(
mat_executor.GetOutput());
EXPECT_THAT(result_tile, NotNull());
result_tiles.emplace_back(result_tile.release());
}
EXPECT_FALSE(mat_executor.Execute());
txn_manager.CommitTransaction();
}
size_t GetSize() const { return GetTypeSize(m_type); }
