name string | code string | asm string | file string |
|---|---|---|---|
lhCursorPrevPage | static int lhCursorPrevPage(lhash_kv_cursor *pPtr)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
lhash_bmap_rec *pRec;
lhpage *pPage;
int rc;
for(;;){
pRec = pCur->pRec;
if( pRec == 0 ){
pCur->iState = L_HASH_CURSOR_STATE_DONE;
return UNQLITE_DONE;
}
if( pPtr->iState == L_HASH_CURSOR... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x15359
leaq 0x8(%rsp), %r14
cmpl $0x2, 0x8(%rbx)
jne 0x15318
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15318
movq (%rbx), %rax
movq (%rax), %rax
callq *0x50(%rax)
movq $0x0, 0x18(%rbx)
movq 0x10(%r15), %rax
mo... | /symisc[P]unqlite/unqlite.c |
SySetRelease | JX9_PRIVATE sxi32 SySetRelease(SySet *pSet)
{
sxi32 rc = SXRET_OK;
if( pSet->pAllocator && pSet->pBase ){
rc = SyMemBackendFree(pSet->pAllocator, pSet->pBase);
}
pSet->pBase = 0;
pSet->nUsed = 0;
pSet->nCursor = 0;
return rc;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x153a0
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x153a0
callq 0xefed
movq $0x0, 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movl %eax, 0x1c(%rbx)
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
unqliteGenErrorFormat | UNQLITE_PRIVATE int unqliteGenErrorFormat(unqlite *pDb,const char *zFmt,...)
{
va_list ap;
int rc;
va_start(ap,zFmt);
rc = SyBlobFormatAp(&pDb->sErr,zFmt,ap);
va_end(ap);
/* Append a new line */
SyBlobAppend(&pDb->sErr,(const void *)"\n",sizeof(char));
return rc;
} | pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x15d5f
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
m... | /symisc[P]unqlite/unqlite.c |
unqliteKvIopageWrite | static int unqliteKvIopageWrite(unqlite_page *pPage)
{
int rc;
if( pPage == 0 ){
/* TICKET 1433-0348 */
return UNQLITE_OK;
}
rc = unqlitePageWrite(pPage);
return rc;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
testq %rdi, %rdi
je 0x16304
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0xe70e
movl %eax, %r15d
testl %eax, %eax
jne 0x16307
cmpl $0x2, 0x1f0(%rbx)
jne 0x15f0b
xorl %r15d, %r15d
cmpl $0x0, 0x1fc(... | /symisc[P]unqlite/unqlite.c |
unqliteKvIoPageUnRef | static int unqliteKvIoPageUnRef(unqlite_page *pPage)
{
if( pPage ){
page_unref((Page *)pPage);
}
return UNQLITE_OK;
} | testq %rdi, %rdi
je 0x16504
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x16463
movq 0x30(%rcx), %rdi
testq %rdi, %rdi
je 0x16463
callq *0x20(%rax)
movl 0x24(%rbx), %r14d
leal -0x1(%r14), %eax
movl %eax, 0x24(%rbx)
movq 0x18(%rbx), %rax
... | /symisc[P]unqlite/unqlite.c |
pager_shared_lock | static int pager_shared_lock(Pager *pPager)
{
int rc = UNQLITE_OK;
if( pPager->iState == PAGER_OPEN ){
unqlite_kv_methods *pMethods;
/* Open the target database */
rc = unqliteOsOpen(pPager->pVfs,pPager->pAllocator,pPager->zFilename,&pPager->pfd,pPager->iOpenFlags);
if( rc != UNQLITE_OK ){
unqliteG... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp # imm = 0x218
cmpl $0x0, 0x1f0(%rdi)
je 0x166e7
xorl %ebp, %ebp
jmp 0x16724
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x30(%rbx), %r14
movl 0x16c(%rbx), %r8d
movq %r14, %rcx
callq 0x16e2f
testl %eax, %eax
j... | /symisc[P]unqlite/unqlite.c |
unqliteOsOpen | UNQLITE_PRIVATE int unqliteOsOpen(
unqlite_vfs *pVfs,
SyMemBackend *pAlloc,
const char *zPath,
unqlite_file **ppOut,
unsigned int flags
)
{
unqlite_file *pFile;
int rc;
*ppOut = 0;
if( zPath == 0 ){
/* May happen if dealing with an in-memory database */
return SXERR_EMPTY;
}
/* All... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rcx)
testq %rdx, %rdx
je 0x16ed7
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
movl 0xc(%rdi), %esi
addl $0x8, %esi
movq %r14, %rdi
callq 0xef9b
testq %rax, %rax
je 0x16ede
movq %rax, %r15
movl 0x... | /symisc[P]unqlite/unqlite.c |
pager_lock_db | static int pager_lock_db(Pager *pPager, int eLock){
int rc = UNQLITE_OK;
if( pPager->iLock < eLock || pPager->iLock == NO_LOCK ){
rc = unqliteOsLock(pPager->pfd, eLock);
if( rc==UNQLITE_OK ){
pPager->iLock = eLock;
}else{
unqliteGenError(pPager->pDb,
rc == UNQLITE_BUSY ? "Another proc... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl %esi, 0x1f4(%rdi)
jge 0x17508
movl %esi, %ebp
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testl %eax, %eax
je 0x17501
movl %eax, %r15d
movq 0x8(%r14), %rdi
cmpl $-0xe, %eax
leaq 0x2d272(%rip), %rax # 0x4475e
le... | /symisc[P]unqlite/unqlite.c |
pager_unlink_page | static int pager_unlink_page(Pager *pPager,Page *pPage)
{
if( pPage->pNextCollide ){
pPage->pNextCollide->pPrevCollide = pPage->pPrevCollide;
}
if( pPage->pPrevCollide ){
pPage->pPrevCollide->pNextCollide = pPage->pNextCollide;
}else{
sxu32 nBucket = PAGE_HASH(pPage->pgno) & (pPager->nSize - 1);
pP... | movq 0x48(%rsi), %rax
testq %rax, %rax
je 0x177e9
movq 0x50(%rsi), %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rsi), %rcx
testq %rcx, %rcx
je 0x177f8
addq $0x48, %rcx
jmp 0x1780e
movl 0x250(%rdi), %ecx
decl %ecx
andl 0x10(%rsi), %ecx
shlq $0x3, %rcx
addq 0x248(%rdi), %rcx
movq %rax, (%rcx)
movq 0x228(%rdi), %rax
cmpq %rsi, %... | /symisc[P]unqlite/unqlite.c |
unqliteBitvecTest | UNQLITE_PRIVATE int unqliteBitvecTest(Bitvec *p,pgno i)
{
bitvec_rec *pRec;
/* Point to the desired bucket */
pRec = p->apRec[i & (p->nSize - 1)];
for(;;){
if( pRec == 0 ){ break; }
if( pRec->iPage == i ){
/* Page found */
return 1;
}
/* Point to the next entry */
pRec = pRec->pNextCol... | movq 0x10(%rdi), %rax
movl 0xc(%rdi), %ecx
decl %ecx
movl %esi, %edx
andl %ecx, %edx
movq (%rax,%rdx,8), %rcx
testq %rcx, %rcx
je 0x178e2
movl $0x1, %eax
cmpq %rsi, (%rcx)
je 0x178e4
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x178e2
cmpq %rsi, (%rcx)
je 0x178e4
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x178e2
cmpq %rs... | /symisc[P]unqlite/unqlite.c |
unqliteBitvecSet | UNQLITE_PRIVATE int unqliteBitvecSet(Bitvec *p,pgno i)
{
bitvec_rec *pRec;
sxi32 iBuck;
/* Allocate a new instance */
pRec = (bitvec_rec *)SyMemBackendPoolAlloc(p->pAlloc,sizeof(bitvec_rec));
if( pRec == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pRec,sizeof(bitvec_rec));
/* Fill... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x18, %esi
callq 0xb3b2
testq %rax, %rax
je 0x17a2d
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x14, %rcx
jb 0x1792d
movq %r14, (%rax)
movl 0xc(%rbx), %r15d
leal -0x1(%r15), %ecx
andl %ec... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_errlog | static int unqliteBuiltin_db_errlog(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_vm *pVm;
SyBlob *pErr;
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Point to the error log */
pErr = &pVm->pDb->sErr;
/* Return the log */
jx9_result... | pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0xc0(%rax), %rsi
movl 0xc8(%rax), %edx
callq 0xca2b
xorl %eax, %eax
popq %rcx
retq
| /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_collection_create | static int unqliteBuiltin_collection_create(jx9_context *pCtx,int argc,jx9_value **argv)
{
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name")... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x17e56
movq (%rdx), %rdi
leaq 0x4(%rsp), %r15
movq %r15, %rsi
callq 0xcc6d
movl (%r15), %ebp
testl %ebp, %ebp
jle 0x17e6a
movq %rax, %r14
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl %ebp, 0x8(%rsi)
movq (%rbx), %rax
movq ... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_fetch_next | static int unqliteBuiltin_db_fetch_next(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x17f21
movq (%rdx), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0xcc6d
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x17f35
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_fetch_by_id | static int unqliteBuiltin_db_fetch_by_id(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
jx9_int64 nId;
int nByte;
int rc;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x17fae
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x2cddf(%rip), %rcx # 0x44d88
jmp 0x1804e
movq %rdx, %r14
movq (%rdx), %rdi
leaq 0x4(%rsp), %r12
movq %r12, %rsi
callq 0xcc6d
cmpl $0x0, (%r12)
jle 0x1... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_last_record_id | static int unqliteBuiltin_db_last_record_id(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collec... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x182dc
movq (%rdx), %rdi
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0xcc6d
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x182f0
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_set_schema | static int unqliteBuiltin_db_set_schema(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
jg 0x18eed
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x2c557(%rip), %rcx # 0x45442
jmp 0x18f15
movq %rdx, %r14
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x18f03
movq (%rax), %rax
testb $0x1, 0x40(%rax)
jne 0x18... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_get_schema | static int unqliteBuiltin_db_get_schema(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x19045
movq (%rdx), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0xcc6d
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x19059
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1c270
testq %... | /symisc[P]unqlite/unqlite.c |
unqliteBuiltin_db_rollback | static int unqliteBuiltin_db_rollback(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_vm *pVm;
unqlite *pDb;
int rc;
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
/* Point to the unqlite Vm */
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Point to the underlying database handle */
pD... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rdi
movl $0x1, %esi
callq 0xeba0
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0xcb9a
movq %r14, (%rbx)
movl $0xfffffe90, %eax # imm = 0xFFFFFE90
... | /symisc[P]unqlite/unqlite.c |
jx9_create_function | JX9_PRIVATE int jx9_create_function(jx9_vm *pVm, const char *zName, int (*xFunc)(jx9_context *, int, jx9_value **), void *pUserData)
{
SyString sName;
int rc;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return JX9_CORRUPT;
}
SyStringInitFromBuf(&sName, zName, SyStrlen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0xffffffe8, %ebx # imm = 0xFFFFFFE8
testq %rdi, %rdi
je 0x192ea
movq %rdi, %r12
cmpl $0xdead2bad, 0x6e0(%rdi) # imm = 0xDEAD2BAD
je 0x192ea
movq %rcx, %r15
movq %rsi, 0x8(%rsp)
cmpb $0x0, (%rsi)
movq %rsi, %r13
je 0x19229
lea... | /symisc[P]unqlite/unqlite.c |
unqliteVmLoadCollection | static int unqliteVmLoadCollection(
unqlite_vm *pVm, /* Target VM */
const char *zName, /* Collection name */
sxu32 nByte, /* zName length */
int iFlag, /* Control flag */
unqlite_col **ppOut /* OUT: in-memory collection */
)
{
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x40(%rsp)
movl %ecx, %r12d
movl %edx, 0x24(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r13
movq 0xd8(%r13), %rax
movq 0x10(%rax), %rbx
movq (%rbx), %rax
movq 0x8(%rax), %rbp
leaq 0x18(%rsp), %rsi
movq %r13, %rdi
callq ... | /symisc[P]unqlite/unqlite.c |
CollectionSetHeader | static int CollectionSetHeader(
unqlite_kv_engine *pEngine, /* Underlying KV storage engine */
unqlite_col *pCol, /* Target collection */
jx9_int64 iRec, /* Last record ID */
jx9_int64 iTotal, /* Total number of records in this collection */
jx9_value *pSchema /* Collec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x1997f
movq (%rbx), %rax
movq (%rax), %rax
movq 0xd8(%rax), %rax
movq 0x10(%rax), %r14
leaq 0x88(%rbx), %r15
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp... | /symisc[P]unqlite/unqlite.c |
unqliteVmInstallCollection | static int unqliteVmInstallCollection(
unqlite_vm *pVm, /* Target VM */
unqlite_col *pCol /* Collection to install */
)
{
SyString *pName = &pCol->sName;
sxu32 iBucket;
/* Hash the collection name */
pCol->nHash = SyBinHash((const void *)pName->zString,pName->nByte);
/* Install it in the corresponding... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
movl 0x10(%rsi), %esi
callq 0x198ac
movl %eax, 0x18(%r14)
movl 0xd4(%rbx), %r12d
leal -0x1(%r12), %ecx
andl %eax, %ecx
movq 0xc0(%rbx), %rax
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x130(%r14)
movq (%rax,%rcx,8), %rd... | /symisc[P]unqlite/unqlite.c |
jx9HashmapExtractNodeKey | JX9_PRIVATE void jx9HashmapExtractNodeKey(jx9_hashmap_node *pNode,jx9_value *pKey)
{
/* Fill with the current key */
if( pNode->iType == HASHMAP_INT_NODE ){
if( SyBlobLength(&pKey->sBlob) > 0 ){
SyBlobRelease(&pKey->sBlob);
}
pKey->x.iVal = pNode->xKey.iKey;
MemObjSetType(pKey, MEMOBJ_INT);
}else... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x8(%rdi)
jne 0x1a22e
cmpl $0x0, 0x28(%rbx)
je 0x1a220
leaq 0x18(%rbx), %rdi
callq 0xdbfd
movq 0x10(%r14), %rax
movq %rax, (%rbx)
movl $0x2, %eax
jmp 0x1a267
leaq 0x18(%rbx), %rdi
movl $0x0, 0x28(%rbx)
movl 0x30(%rbx), %eax
testb $0x4, %al
je 0... | /symisc[P]unqlite/unqlite.c |
jx9NewHashmap | JX9_PRIVATE jx9_hashmap * jx9NewHashmap(
jx9_vm *pVm, /* VM that trigger the hashmap creation */
sxu32 (*xIntHash)(sxi64), /* Hash function for int keys.NULL otherwise*/
sxu32 (*xBlobHash)(const void *, sxu32) /* Hash function for BLOB keys.NULL otherwise */
)
{
jx9_hashmap *pMap;
/* Allocate ... | pushq %rbx
movq %rdi, %rbx
movl $0x58, %esi
callq 0xb3b2
testq %rax, %rax
je 0x1ad20
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x54, %rcx
jb 0x1acec
movq %rbx, (%rax)
movl $0x1, 0x50(%rax)
leaq 0x15(%rip), %rcx # 0x1ad24
movq %rcx, 0x30(%rax)
leaq 0x1b(%rip), %rcx # 0x1ad35
movq %rc... | /symisc[P]unqlite/unqlite.c |
jx9MemObjToInteger | JX9_PRIVATE sxi32 jx9MemObjToInteger(jx9_value *pObj)
{
if( (pObj->iFlags & MEMOBJ_INT) == 0 ){
/* Preform the conversion */
pObj->x.iVal = MemObjIntValue(&(*pObj));
/* Invalidate any prior representations */
SyBlobRelease(&pObj->sBlob);
MemObjSetType(pObj, MEMOBJ_INT);
}
return SXRET_OK;
} | movl 0x8(%rdi), %eax
testb $0x2, %al
jne 0x1b263
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x4, %al
jne 0x1b1f6
testb $0x8, %al
jne 0x1b223
testb $0x1, %al
jne 0x1b228
testb $0x20, %al
jne 0x1b1f1
testb $0x40, %al
jne 0x1b266
btl $0x8, %eax
jb 0x1b287
xorl %r14d, %r14d
jmp 0x1b242
movsd (%rbx), %xmm... | /symisc[P]unqlite/unqlite.c |
HashmapInsertIntKey | static sxi32 HashmapInsertIntKey(jx9_hashmap *pMap,sxi64 iKey,jx9_value *pValue)
{
jx9_hashmap_node *pNode;
jx9_value *pObj;
sxu32 nIdx;
sxu32 nHash;
sxi32 rc;
/* Reserve a jx9_value for the value */
pObj = jx9VmReserveMemObj(pMap->pVm,&nIdx);
if( pObj == 0 ){
return SXERR_MEM;
}
if( pValue ){
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1b79e
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1b3c7
testq %r12, %r12
je 0x1b33d
movq %r12, %rdi
movq %rax, %rsi
callq ... | /symisc[P]unqlite/unqlite.c |
MemObjStringValue | static sxi32 MemObjStringValue(SyBlob *pOut,jx9_value *pObj)
{
if( pObj->iFlags & MEMOBJ_REAL ){
SyBlobFormat(&(*pOut), "%.15g", pObj->x.rVal);
}else if( pObj->iFlags & MEMOBJ_INT ){
SyBlobFormat(&(*pOut), "%qd", pObj->x.iVal);
/* %qd (BSD quad) is equivalent to %lld in the libc printf */
}else if( pObj... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl 0x8(%rsi), %eax
testb $0x4, %al
jne 0x1b409
testb $0x2, %al
jne 0x1b420
testb $0x8, %al
jne 0x1b436
testb $0x40, %al
jne 0x1b44a
btl $0x8, %eax
jae 0x1b484
movq (%rbx), %rdx
leaq 0x2990b(%rip), %rsi # 0x44d12
jmp 0x1b42a
movsd (%rbx), %xmm0
leaq 0x298ed(%rip), %rsi ... | /symisc[P]unqlite/unqlite.c |
VmJsonEncode | static sxi32 VmJsonEncode(
jx9_value *pIn, /* Encode this value */
json_private_data *pData /* Context data */
){
SyBlob *pOut = pData->pOut;
int nByte;
if( jx9_value_is_null(pIn) || jx9_value_is_resource(pIn)){
/* null */
SyBlobAppend(pOut, "null", sizeof("null")-1);
}else if( jx9_va... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rbx
movl 0x8(%rdi), %eax
testl $0x120, %eax # imm = 0x120
je 0x1b4cb
leaq 0x2c32b(%rip), %rsi # 0x477ec
movq %rbx, %rdi
movl $0x4, %edx
jmp 0x1b52f
movq %rdi, %r14
testb $0x8, %al
jne 0x1b506
movq %rsi, %r15
movq %r14, ... | /symisc[P]unqlite/unqlite.c |
VmJsonObjectEncode | static int VmJsonObjectEncode(jx9_value *pKey,jx9_value *pValue,void *pUserData)
{
json_private_data *pJson = (json_private_data *)pUserData;
const char *zKey;
int nByte;
if( pJson->nRecCount > 31 ){
/* Recursion limit reached, return immediately */
return JX9_OK;
}
if( !pJson->isFirst ){
/* Appen... | cmpl $0x1f, 0x10(%rdx)
jg 0x1b74f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x8(%rdx)
jne 0x1b6ba
movq (%rbx), %rdi
leaq 0x29677(%rip), %rsi # 0x44d27
movl $0x1, %edx
callq 0x113de
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xcc... | /symisc[P]unqlite/unqlite.c |
HashmapNodeLink | static void HashmapNodeLink(jx9_hashmap *pMap, jx9_hashmap_node *pNode, sxu32 nBucketIdx)
{
/* Link */
if( pMap->apBucket[nBucketIdx] != 0 ){
pNode->pNextCollide = pMap->apBucket[nBucketIdx];
pMap->apBucket[nBucketIdx]->pPrevCollide = pNode;
}
pMap->apBucket[nBucketIdx] = pNode;
/* Link to the map list... | movq 0x8(%rdi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x1b97e
movq %rdx, 0x50(%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x58(%rdx)
movq %rsi, (%rax,%rcx,8)
cmpq $0x0, 0x10(%rdi)
je 0x1b99f
leaq 0x18(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1b9ab
movq %rcx, 0x40(%rsi)
movq %rsi, 0x... | /symisc[P]unqlite/unqlite.c |
SyBinaryStrToInt64 | JX9_PRIVATE sxi32 SyBinaryStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
const char *zIn, *zEnd;
int isNeg = FALSE;
sxi64 nVal = 0;
int c;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r15d
addq %rdi, %r15
testl %esi, %esi
je 0x1bcf8
callq 0xa3e0
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1bcdf
incq %r14
cmpq %r15, %r14
jb 0x1bcca
jmp 0x1bcf8
movzbl %cl, %eax
cmpl $0x2b, %e... | /symisc[P]unqlite/unqlite.c |
SyOctalStrToInt64 | JX9_PRIVATE sxi32 SyOctalStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
const char *zIn, *zEnd;
int isNeg = FALSE;
sxi64 nVal = 0;
int c;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r15d
addq %rdi, %r15
testl %esi, %esi
je 0x1bea4
callq 0xa3e0
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1be8e
incq %r14
cmpq %r15, %r14
jb 0x1be79
jmp 0x1bea4
movzbl %c... | /symisc[P]unqlite/unqlite.c |
SyStrToInt64 | JX9_PRIVATE sxi32 SyStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
int isNeg = FALSE;
const char *zEnd;
sxi64 nVal;
sxi16 i;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r15d
addq %rdi, %r15
xorl %ebp, %ebp
testl %esi, %esi
je 0x1c081
callq 0xa3e0
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1c068
incq %r14
cmpq %r15, %r14
jb 0x1c053
jmp 0... | /symisc[P]unqlite/unqlite.c |
CollectionCacheInstallRecord | static int CollectionCacheInstallRecord(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId, /* Unique record ID */
jx9_value *pValue /* JSON value */
)
{
unqlite_col_record *pRecord;
sxu32 iBucket;
/* Fetch the record first */
pRecord = CollectionCacheFetchRecord(pCol,nId);
if( pRecord ){... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xd8(%rdi)
je 0x1c4fc
movq 0xc8(%rbx), %rax
movl 0xdc(%rbx), %ecx
decl %ecx
movl %r14d, %edx
andl %ecx, %edx
movq (%rax,%rdx,8), %rsi
testq %rsi, %rsi
je 0x1c4fc
cmpq %r14, 0x8(%rsi)
je 0x1c4fe
movq 0x50(%r... | /symisc[P]unqlite/unqlite.c |
VmNewOperandStack | static jx9_value * VmNewOperandStack(
jx9_vm *pVm, /* Target VM */
sxu32 nInstr /* Total numer of generated bytecode instructions */
)
{
jx9_value *pStack;
/* No instruction ever pushes more than a single element onto the
** stack and the stack never grows on successive executions of the
** same loop.... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal 0x10(%rbx), %ebp
movl %ebp, %esi
shll $0x6, %esi
callq 0xef9b
testq %rax, %rax
je 0x1c92c
testl %ebp, %ebp
je 0x1c92e
addl $0xf, %ebx
movl %ebp, %ecx
shlq $0x6, %rcx
shlq $0x6, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax,%rbx)
movups %xmm0, 0x20(... | /symisc[P]unqlite/unqlite.c |
jx9VmThrowError | JX9_PRIVATE sxi32 jx9VmThrowError(
jx9_vm *pVm, /* Target VM */
SyString *pFuncName, /* Function name. NULL otherwise */
sxi32 iErr, /* Severity level: [i.e: Error, Warning or Notice]*/
const char *zMessage /* Null terminated error message */
)
{
SyBlob *pWorker = &pVm->sWorker;
SyString... | cmpl $0x0, 0x4e0(%rdi)
je 0x1c99d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movl $0x0, 0x3b0(%rdi)
movl 0x3b8(%rdi), %eax
testb $0x4, %al
je 0x1c981
movq $0x0, 0x3a8(%rbx)
movl $0x0, 0x3b4(%rbx)
andl $-0x5, %eax
movl %eax, 0x3b8(%rbx)
movl 0x3... | /symisc[P]unqlite/unqlite.c |
jx9MemObjLoad | JX9_PRIVATE sxi32 jx9MemObjLoad(jx9_value *pSrc, jx9_value *pDest)
{
SyMemcpy((const void *)&(*pSrc), &(*pDest),
sizeof(jx9_value)-(sizeof(jx9_vm *)+sizeof(SyBlob)+sizeof(sxu32)));
if( pSrc->iFlags & MEMOBJ_HASHMAP ){
/* Increment reference count */
((jx9_hashmap *)pSrc->x.pOther)->iRef++;
}
if( SyBl... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x14, %edx
callq 0x10370
testb $0x40, 0x8(%r14)
je 0x1cb10
movq (%r14), %rax
incl 0x50(%rax)
cmpl $0x0, 0x28(%rbx)
je 0x1cb1f
leaq 0x18(%rbx), %rdi
callq 0xdbfd
movl 0x28(%r14), %eax
testl %eax, %eax
je 0x1cb3d
movq 0x20(%r14), %rcx
movq %rcx, 0x20(... | /symisc[P]unqlite/unqlite.c |
jx9MemObjToNumeric | JX9_PRIVATE sxi32 jx9MemObjToNumeric(jx9_value *pObj)
{
if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_REAL|MEMOBJ_BOOL|MEMOBJ_NULL) ){
if( pObj->iFlags & (MEMOBJ_BOOL|MEMOBJ_NULL) ){
if( pObj->iFlags & MEMOBJ_NULL ){
pObj->x.iVal = 0;
}
MemObjSetType(pObj, MEMOBJ_INT);
}
/* Already numeric */
re... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testb $0x2e, %al
je 0x1f9e3
testb $0x28, %al
je 0x1fa76
testb $0x20, %al
je 0x1f9d3
movq $0x0, (%rbx)
andl $0xfffffe90, %eax # imm = 0xFFFFFE90
orl $0x2, %eax
movl %eax, 0x8(%rbx)
jmp 0x1fa76
testb $0x1, %al
jne 0x1f9fe
movq %r... | /symisc[P]unqlite/unqlite.c |
jx9MemObjTryInteger | JX9_PRIVATE sxi32 jx9MemObjTryInteger(jx9_value *pObj)
{
if( pObj->iFlags & MEMOBJ_REAL ){
/* Work only with reals */
MemObjTryIntger(&(*pObj));
}
return SXRET_OK;
} | testb $0x4, 0x8(%rdi)
je 0x1fe5a
movsd (%rdi), %xmm0
movapd 0x24438(%rip), %xmm1 # 0x44240
andpd %xmm0, %xmm1
ucomisd 0x244bc(%rip), %xmm1 # 0x442d0
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cvttsd2si %xmm0, %rax
leaq 0x1(%rcx), %rdx
cmovaq %rdx, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
uco... | /symisc[P]unqlite/unqlite.c |
SyHashInsert | JX9_PRIVATE sxi32 SyHashInsert(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void *pUserData)
{
SyHashEntry_Pr *pEntry;
sxi32 rc;
#if defined(UNTRUST)
if( INVALID_HASH(pHash) || pKey == 0 ){
return SXERR_CORRUPT;
}
#endif
if( pHash->nEntry >= pHash->nBucketSize * SXHASH_FILL_FACTOR ){
rc = HashGrow... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x38(%rdi), %r15d
leal (%r15,%r15,2), %eax
cmpl %eax, 0x28(%rdi)
jb 0x204a6
movq (%rbx), %rdi
movl %r15d, %r13d
shll $0x4, %r13d
movl %r13d, %esi
callq 0xef9b
testq %rax, %... | /symisc[P]unqlite/unqlite.c |
SyStrIsNumeric | JX9_PRIVATE sxi32 SyStrIsNumeric(const char *zSrc, sxu32 nLen, sxu8 *pReal, const char **pzTail)
{
const char *zCur, *zEnd;
#ifdef UNTRUST
if( SX_EMPTY_STR(zSrc) ){
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
/* Jump leading white spaces */
while( zSrc < zEnd && (unsigned char)zSrc[0] < 0xc0 &&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %r15d
addq %rdi, %r15
testl %esi, %esi
je 0x205b1
movsbq (%rbx), %r12
cmpq $-0x41, %r12
ja 0x2059f
callq 0xa3e0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0x2059f
incq %rbx
cmpq %r15, %rbx
jb ... | /symisc[P]unqlite/unqlite.c |
jx9HashmapCmp | JX9_PRIVATE sxi32 jx9HashmapCmp(
jx9_hashmap *pLeft, /* Left hashmap */
jx9_hashmap *pRight, /* Right hashmap */
int bStrict /* TRUE for strict comparison */
)
{
jx9_hashmap_node *pLe, *pRe;
sxi32 rc;
sxu32 n;
if( pLeft == pRight ){
/* Same hashmap instance. This can easily happen since ha... | cmpq %rsi, %rdi
je 0x20acb
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl 0x2c(%rdi), %ebp
movl 0x2c(%rsi), %ecx
cmpl %ecx, %ebp
jne 0x20ace
movq 0x10(%rdi), %r15
movq $0x0, 0x8(%rsp)
testl %ebp, %ebp
je 0x20ac7
movl %edx, %ebx
leaq 0x8(%rsp), %r12
cmpl $0x1, 0x8(%r15)
jne ... | /symisc[P]unqlite/unqlite.c |
jx9_result_string_format | JX9_PRIVATE int jx9_result_string_format(jx9_context *pCtx, const char *zFormat, ...)
{
jx9_value *p;
va_list ap;
int rc;
p = pCtx->pRet;
if( (p->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(p);
MemObjSetType(p, MEMOBJ_STRING);
}
/* Format the given ... | pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x20cd8
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
mov... | /symisc[P]unqlite/unqlite.c |
unqliteCollectionDropRecord | UNQLITE_PRIVATE int unqliteCollectionDropRecord(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId, /* Unique ID of the record to be droped */
int wr_header, /* True to alter collection header */
int log_err /* True to log error */
)
{
SyBlob *pWorker = &pCol->sWorker;
int rc; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
addq $0x68, %rdi
movl $0x0, 0x78(%rbx)
movl 0x80(%rbx), %eax
testb $0x4, %al
je 0x2105c
movq $0x0, 0x70(%rbx)
movl $0x0, 0x7c(%rbx)
andl $-0x5, %eax
movl %eax, 0x80(%rbx)
leaq 0x... | /symisc[P]unqlite/unqlite.c |
VmExtractSuper | static jx9_value * VmExtractSuper(
jx9_vm *pVm, /* Target VM */
const char *zName, /* Superglobal name: NOT NULL TERMINATED */
sxu32 nByte /* zName length */
)
{
SyHashEntry *pEntry;
jx9_value *pValue;
sxu32 nIdx;
/* Query the superglobal table */
pEntry = SyHashGet(&pVm->hSuper, (const ... | pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
testl %edx, %edx
je 0x222b1
cmpl $0x0, 0x368(%rbx)
je 0x222b1
leaq 0x340(%rbx), %rdi
callq 0x206c3
testq %rax, %rax
je 0x222d1
movl 0x10(%rax), %eax
cmpl %eax, 0x210(%rbx)
jbe 0x222d1
imull 0x218(%rbx), %eax
addq 0x208(%rbx), %rax
jmp 0x222d3
xorl %eax, %eax
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
VmHttpSplitURI | static sxi32 VmHttpSplitURI(SyhttpUri *pOut, const char *zUri, sxu32 nLen)
{
const char *zEnd = &zUri[nLen];
sxu8 bHostOnly = FALSE;
sxu8 bIPv6 = FALSE ;
const char *zCur;
SyString *pComp;
sxu32 nPos = 0;
sxi32 rc;
/* Zero the structure first */
SyZero(pOut, sizeof(SyhttpUri));
/* Remov... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %eax
addq %rsi, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
movq $-0x4, %rax
movl $0x0, 0x4(%rbx,%rax)
addq $0x4, %rax
cmpq $0x8c, %rax
jb 0x22f45
movq %r15, 0x80(%rbx)
movl... | /symisc[P]unqlite/unqlite.c |
jx9CompileFunction | static sxi32 jx9CompileFunction(jx9_gen_state *pGen)
{
SyString *pName;
sxi32 iFlags;
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
pGen->pIn++; /* Jump the 'function' keyword */
iFlags = 0;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
/* Invalid functi... | pushq %rbx
movq %rdi, %rbx
movq 0x158(%rdi), %rax
movq 0x160(%rdi), %rcx
movl 0x14(%rax), %edx
leaq 0x20(%rax), %r8
movq %r8, 0x158(%rdi)
cmpq %rcx, %r8
jae 0x26395
testb $0xc, 0x30(%rax)
je 0x26395
movl 0x34(%rax), %edx
leaq 0x40(%rax), %rsi
movq %rsi, 0x158(%rbx)
cmpq %rcx, %rsi
jae 0x2633a
testb $0x2, 0x51(%rax)
jne... | /symisc[P]unqlite/unqlite.c |
jx9VmGetStreamDevice | JX9_PRIVATE const jx9_io_stream * jx9VmGetStreamDevice(
jx9_vm *pVm, /* Target VM */
const char **pzDevice, /* Full path, URI, ... */
int nByte /* *pzDevice length*/
)
{
const char *zIn, *zEnd, *zCur, *zNext;
jx9_io_stream **apStream, *pStream;
SyString sDev, sCur;
sxu32 n, nEntr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %r14
testl %edx, %edx
setg %al
jle 0x2df8a
movslq %edx, %rcx
addq %r14, %rcx
leaq -0x3(%rcx), %rdx
movq %r14, %r13
cmpq %rdx, %r13
jae 0x2df7d
cmpb $0x3a, (%r13)
jne 0x2df7d
cmpb $0x2f, 0x1(%r... | /symisc[P]unqlite/unqlite.c |
jx9Vfs_disk_total_space | static int jx9Vfs_disk_total_space(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iSize;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlyi... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %ebp
testl %esi, %esi
jle 0x3b195
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x3b19a
xorl %r14d, %r14d
jmp 0x3b1e8
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x3b1cb
cmpq $0x0, 0x88(%r14)
je 0x3b1cb
xorl %esi, %esi
callq 0xcc6d
movq %rax, %rd... | /symisc[P]unqlite/unqlite.c |
jx9Vfs_file_size | static int jx9Vfs_file_size(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iSize;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %ebp
testl %esi, %esi
jle 0x3b2b8
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x3b2bd
xorl %r14d, %r14d
jmp 0x3b30b
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x3b2ee
cmpq $0x0, 0x90(%r14)
je 0x3b2ee
xorl %esi, %esi
callq 0xcc6d
movq %rax, %rd... | /symisc[P]unqlite/unqlite.c |
jx9Vfs_file_mtime | static int jx9Vfs_file_mtime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iTime;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %ebp
testl %esi, %esi
jle 0x3b3d6
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x3b3db
xorl %r14d, %r14d
jmp 0x3b429
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x3b40c
cmpq $0x0, 0xa0(%r14)
je 0x3b40c
xorl %esi, %esi
callq 0xcc6d
movq %rax, %rd... | /symisc[P]unqlite/unqlite.c |
jx9Vfs_file_ctime | static int jx9Vfs_file_ctime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iTime;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %ebp
testl %esi, %esi
jle 0x3b465
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
jne 0x3b46a
xorl %r14d, %r14d
jmp 0x3b4b8
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x3b49b
cmpq $0x0, 0xa8(%r14)
je 0x3b49b
xorl %esi, %esi
callq 0xcc6d
movq %rax, %rd... | /symisc[P]unqlite/unqlite.c |
jx9Vfs_is_file | static int jx9Vfs_is_file(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs =... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x3b54a
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x3b54a
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x3b530
cmpq $0x0, 0xc0(%r14)
je 0x3b530
xorl %esi, %esi
callq 0xcc6d
movq %rax, %rdi
callq *0xc0(%r14)
xorl %r14d, %r14d
testl %ea... | /symisc[P]unqlite/unqlite.c |
jx9Vfs_is_readable | static int jx9Vfs_is_readable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pV... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x3b67e
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x3b67e
movq (%rbx), %rax
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x3b664
cmpq $0x0, 0xd0(%r14)
je 0x3b664
xorl %esi, %esi
callq 0xcc6d
movq %rax, %rdi
callq *0xd0(%r14)
xorl %r14d, %r14d
testl %ea... | /symisc[P]unqlite/unqlite.c |
jx9Builtin_basename | static int jx9Builtin_basename(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath, *zBase, *zEnd;
int c, d, iLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
c = d = '/';
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3c44d
movq %rdx, %r12
movq (%rdx), %rdi
testb $0x1, 0x8(%rdi)
je 0x3c44d
movl %esi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0xcc6d
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0x3c44d
leaq (%rcx,%rax), %rs... | /symisc[P]unqlite/unqlite.c |
jx9Builtin_readdir | static int jx9Builtin_readdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle"... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x3e0e1
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x3e0e1
movq (%rax), %r12
testq %r12, %r12
je 0x3e0e1
cmpl $0xfeac14, 0x34(%r12) # imm = 0xFEAC14
jne 0x3e0e1
movq (%r12), %r15
testq %r15, %r15
je 0x3e12f
cmpq $0x0, 0x38(%r1... | /symisc[P]unqlite/unqlite.c |
jx9Builtin_fclose | static int jx9Builtin_fclose(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
jx9_vm *pVm;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO han... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x3f40c
movq %rdx, %r14
movq (%rdx), %rax
testb $0x1, 0x9(%rax)
je 0x3f40c
movq (%rax), %r15
testq %r15, %r15
je 0x3f40c
cmpl $0xfeac14, 0x34(%r15) # imm = 0xFEAC14
jne 0x3f40c
movq (%r15), %rax
testq %rax, %rax
je 0x3f456
mov... | /symisc[P]unqlite/unqlite.c |
UnixVfs_lStat | static int UnixVfs_lStat(const char *zPath, jx9_value *pArray, jx9_value *pWorker)
{
struct stat st;
int rc;
rc = lstat(zPath, &st);
if( rc != 0 ){
return -1;
}
/* dev */
jx9_value_int64(pWorker, (jx9_int64)st.st_dev);
jx9_array_add_strkey_elem(pArray, "dev", pWorker); /* Will make it's own copy */... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
callq 0xa240
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x419e1
movq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0xcb9a
movq %r15, (%rbx)
movl $0xfffffe90, %ebp # i... | /symisc[P]unqlite/unqlite.c |
UnixVfs_islink | static int UnixVfs_islink(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
rc = S_ISLNK(st.st_mode);
return rc ? JX9_OK : -1 ;
} | pushq %rbx
subq $0x90, %rsp
movq %rsp, %rbx
movq %rbx, %rsi
callq 0xa270
movl 0x18(%rbx), %edx
andl $0xf000, %edx # imm = 0xF000
xorl $0xa000, %edx # imm = 0xA000
xorl %ecx, %ecx
orl %eax, %edx
setne %cl
negl %ecx
movl %ecx, %eax
addq $0x90, %rsp
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
UnixVfs_Filetype | static int UnixVfs_Filetype(const char *zPath, jx9_context *pCtx)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
/* Expand 'unknown' */
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
return -1;
}
if(S_ISREG(st.st_mode) ){
jx9_result_string(pCtx, "file", sizeof("... | pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0xa270
testl %eax, %eax
je 0x41ad0
movq 0x8(%rbx), %rdi
leaq 0x684d(%rip), %rsi # 0x48309
movl $0x7, %edx
callq 0xca2b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x41b57
movl $0xf000, %eax # imm = 0xF000
andl 0x18(%rsp), %eax
addl... | /symisc[P]unqlite/unqlite.c |
UnixVfs_Getenv | static int UnixVfs_Getenv(const char *zVar, jx9_context *pCtx)
{
char *zEnv;
zEnv = getenv(zVar);
if( zEnv == 0 ){
return -1;
}
jx9_result_string(pCtx, zEnv, -1/*Compute length automatically*/);
return JX9_OK;
} | pushq %rbx
movq %rsi, %rbx
callq 0xa040
testq %rax, %rax
je 0x41b83
movq 0x8(%rbx), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0xca2b
xorl %eax, %eax
jmp 0x41b88
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
UnixVfs_Touch | static int UnixVfs_Touch(const char *zPath, jx9_int64 touch_time, jx9_int64 access_time)
{
struct utimbuf ut;
int rc;
ut.actime = (time_t)access_time;
ut.modtime = (time_t)touch_time;
rc = utime(zPath, &ut);
if( rc != 0 ){
return -1;
}
return JX9_OK;
} | subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rsi
callq 0xa050
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x18, %rsp
retq
| /symisc[P]unqlite/unqlite.c |
UnixVfs_Mmap | static int UnixVfs_Mmap(const char *zPath, void **ppMap, jx9_int64 *pSize)
{
struct stat st;
void *pMap;
int fd;
int rc;
/* Open the file in a read-only mode */
fd = open(zPath, O_RDONLY);
if( fd < 0 ){
return -1;
}
/* stat the handle */
fstat(fd, &st);
/* Obtain a memory view of the whole fil... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
xorl %esi, %esi
xorl %eax, %eax
callq 0xa340
testl %eax, %eax
js 0x41c24
movl %eax, %ebp
movq %rsp, %r15
movl %eax, %edi
movq %r15, %rsi
callq 0xa3c0
movq 0x30(%r15), %r12
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12,... | /symisc[P]unqlite/unqlite.c |
UnixVfs_link | static int UnixVfs_link(const char *zSrc, const char *zTarget, int is_sym)
{
int rc;
if( is_sym ){
/* Symbolic link */
rc = symlink(zSrc, zTarget);
}else{
/* Hard link */
rc = link(zSrc, zTarget);
}
return rc == 0 ? JX9_OK : -1;
} | pushq %rax
testl %edx, %edx
je 0x41c5d
callq 0xa190
jmp 0x41c62
callq 0xa390
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rcx
retq
| /symisc[P]unqlite/unqlite.c |
UnixVfs_TempDir | static void UnixVfs_TempDir(jx9_context *pCtx)
{
static const char *azDirs[] = {
"/var/tmp",
"/usr/tmp",
"/usr/local/tmp"
};
unsigned int i;
struct stat buf;
const char *zDir;
zDir = getenv("TMPDIR");
if( zDir && zDir[0] != 0 && !access(zDir, 07) ){
jx9_result_string(pCtx, zDir... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x6a23(%rip), %rdi # 0x486af
callq 0xa040
testq %rax, %rax
je 0x41caf
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x41caf
movq %r14, %rdi
movl $0x7, %esi
callq 0xa350
testl %eax, %eax
je 0x41d10
xorl %r12d, %r12d
leaq ... | /symisc[P]unqlite/unqlite.c |
UnixVfs_Username | static void UnixVfs_Username(jx9_context *pCtx)
{
#ifndef JX9_UNIX_STATIC_BUILD
struct passwd *pwd;
uid_t uid;
uid = getuid();
pwd = getpwuid(uid); /* Try getting UID for username */
if (pwd == 0) {
return;
}
/* Return the username */
jx9_result_string(pCtx, pwd->pw_name, -1);
#else
... | pushq %rbx
movq %rdi, %rbx
callq 0xa160
movl %eax, %edi
callq 0xa130
testq %rax, %rax
je 0x41d71
movq (%rax), %rsi
movq 0x8(%rbx), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
popq %rbx
jmp 0xca2b
popq %rbx
retq
| /symisc[P]unqlite/unqlite.c |
SyProcFormat | JX9_PRIVATE sxi32 SyProcFormat(ProcConsumer xConsumer, void *pData, const char *zFormat, ...)
{
va_list ap;
sxi32 rc;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zFormat) ){
return SXERR_EMPTY;
}
#endif
va_start(ap, zFormat);
rc = FormatMount(SXFMT_CONS_PROC, 0, xConsumer, pData, 0, zFormat, ap);
va_end(... | subq $0xe8, %rsp
movq %rsi, %r10
movq %rdi, %rdx
leaq 0x30(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x41dcf
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %x... | /symisc[P]unqlite/unqlite.c |
pager_create_header | static int pager_create_header(Pager *pPager)
{
Page *pHeader;
int rc;
/* Allocate a new page */
pHeader = pager_alloc_page(pPager,0);
if( pHeader == 0 ){
return UNQLITE_NOMEM;
}
pPager->pHeader = pHeader;
/* Link the page */
pager_link_page(pPager,pHeader);
/* Add to the dirty list */
pager_p... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %esi, %esi
callq 0x16c26
testq %rax, %rax
je 0x41f9c
movq %rax, %rbx
movq %rax, 0x1a0(%r14)
movq %r14, %rdi
movq %rax, %rsi
callq 0x16caa
movl 0x20(%rbx), %eax
testb $0x2, %al
jne 0x41e84
orl $0x26, %eax
movl %eax, 0x20(%rbx)
movq $0x0, 0x40(%rbx)
movq 0x220(%r14), ... | /symisc[P]unqlite/unqlite.c |
pager_write_dirty_pages | static int pager_write_dirty_pages(Pager *pPager,Page *pDirty)
{
int rc = UNQLITE_OK;
Page *pNext;
for(;;){
if( pDirty == 0 ){
break;
}
/* Point to the next dirty page */
pNext = pDirty->pDirtyPrev; /* Not a bug: Reverse link */
if( (pDirty->flags & PAGE_DONT_WRITE) == 0 ){
rc = unqliteOsW... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x42046
movq %rsi, %r14
movq 0x40(%r14), %r15
testb $0x8, 0x20(%r14)
jne 0x42018
movq 0x30(%rbx), %rdi
movq (%r14), %rsi
movslq 0x208(%rbx), %rdx
movq 0x10(%r14), %rcx
imulq %rdx, %rcx
movq (%rdi), %rax
callq *0x1... | /symisc[P]unqlite/unqlite.c |
page_merge_dirty | static Page * page_merge_dirty(Page *pA, Page *pB)
{
Page result, *pTail;
/* Prevent compiler warning */
result.pDirtyNext = result.pDirtyPrev = 0;
pTail = &result;
while( pA && pB ){
if( pA->pgno < pB->pgno ){
pTail->pDirtyPrev = pA;
pA->pDirtyNext = pTail;
pTail = pA;
pA = pA->pDirtyP... | testq %rdi, %rdi
setne %dl
testq %rsi, %rsi
setne %cl
movl %edx, %eax
andb %cl, %al
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%rsp)
cmpb $0x1, %al
jne 0x420e0
leaq -0x68(%rsp), %rax
movq %rsi, %r8
movq %rdi, %r9
movq 0x10(%r9), %rcx
cmpq 0x10(%r8), %rcx
jae 0x420b3
movq %r9, 0x40(%rax)
movq %rax, 0x38(%r9)
movq 0x40(%r9),... | /symisc[P]unqlite/unqlite.c |
mlir::sparse_tensor::SparseTensorStorage<unsigned long, unsigned long, signed char>* mlir::sparse_tensor::SparseTensorReader::readSparseTensor<unsigned long, unsigned long, signed char>(unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*) | SparseTensorStorage<P, I, V> *
readSparseTensor(uint64_t lvlRank, const uint64_t *lvlSizes,
const LevelType *lvlTypes, const uint64_t *dim2lvl,
const uint64_t *lvl2dim) {
const uint64_t dimRank = getRank();
MapRef map(dimRank, lvlRank, dim2lvl, lvl2dim);
auto *lvlCOO ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movq 0x18(%rdi), %r15
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x2ce... | /mlir/ExecutionEngine/SparseTensor/File.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned int, unsigned int, short>* mlir::sparse_tensor::SparseTensorReader::readSparseTensor<unsigned int, unsigned int, short>(unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*) | SparseTensorStorage<P, I, V> *
readSparseTensor(uint64_t lvlRank, const uint64_t *lvlSizes,
const LevelType *lvlTypes, const uint64_t *dim2lvl,
const uint64_t *lvl2dim) {
const uint64_t dimRank = getRank();
MapRef map(dimRank, lvlRank, dim2lvl, lvl2dim);
auto *lvlCOO ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movq 0x18(%rdi), %r15
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x2ce... | /mlir/ExecutionEngine/SparseTensor/File.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned int, unsigned int, signed char>* mlir::sparse_tensor::SparseTensorReader::readSparseTensor<unsigned int, unsigned int, signed char>(unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*) | SparseTensorStorage<P, I, V> *
readSparseTensor(uint64_t lvlRank, const uint64_t *lvlSizes,
const LevelType *lvlTypes, const uint64_t *dim2lvl,
const uint64_t *lvl2dim) {
const uint64_t dimRank = getRank();
MapRef map(dimRank, lvlRank, dim2lvl, lvl2dim);
auto *lvlCOO ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movq 0x18(%rdi), %r15
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x2ce... | /mlir/ExecutionEngine/SparseTensor/File.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned short, short>* mlir::sparse_tensor::SparseTensorReader::readSparseTensor<unsigned short, unsigned short, short>(unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*) | SparseTensorStorage<P, I, V> *
readSparseTensor(uint64_t lvlRank, const uint64_t *lvlSizes,
const LevelType *lvlTypes, const uint64_t *dim2lvl,
const uint64_t *lvl2dim) {
const uint64_t dimRank = getRank();
MapRef map(dimRank, lvlRank, dim2lvl, lvl2dim);
auto *lvlCOO ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movq 0x18(%rdi), %r15
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x2ce... | /mlir/ExecutionEngine/SparseTensor/File.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned short, signed char>* mlir::sparse_tensor::SparseTensorReader::readSparseTensor<unsigned short, unsigned short, signed char>(unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*) | SparseTensorStorage<P, I, V> *
readSparseTensor(uint64_t lvlRank, const uint64_t *lvlSizes,
const LevelType *lvlTypes, const uint64_t *dim2lvl,
const uint64_t *lvl2dim) {
const uint64_t dimRank = getRank();
MapRef map(dimRank, lvlRank, dim2lvl, lvl2dim);
auto *lvlCOO ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movq 0x18(%rdi), %r15
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x2ce... | /mlir/ExecutionEngine/SparseTensor/File.h |
mlir_ciface_getSparseTensorReaderReadToBuffers32BF16 | void _mlir_ciface_outSparseTensorWriterMetaData(
void *p, index_type dimRank, index_type nse,
StridedMemRefType<index_type, 1> *dimSizesRef) {
assert(p);
ASSERT_NO_STRIDE(dimSizesRef);
assert(dimRank != 0);
index_type *dimSizes = MEMREF_GET_PAYLOAD(dimSizesRef);
std::ostream &file = *static_cast<std::... | pushq %rbx
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rbx
shlq $0x3, %rax
addq 0x8(%rsi), %rax
movq 0x10(%rdx), %r10
shlq $0x3, %r10
addq 0x8(%rdx), %r10
movq 0x10(%rcx), %r11
shlq $0x2, %r11
addq 0x8(%rcx), %r11
movq 0x10(%r8), %r9
addq %r9, %r9
addq 0x8(%r8), %r9
movq %rbx, %rsi
movq %rax, %rdx
movq %r10, %rcx
movq %r11... | /ExecutionEngine/SparseTensorRuntime.cpp |
mlir::sparse_tensor::SparseTensorStorage<unsigned long, unsigned long, double>::finalizeSegment(unsigned long, unsigned long, unsigned long) | void finalizeSegment(uint64_t l, uint64_t full = 0, uint64_t count = 1) {
if (count == 0)
return; // Short-circuit, since it'll be a nop.
if (isCompressedLvl(l)) {
uint64_t pos = coordinates[l].size();
positions[l].insert(positions[l].end(), count,
detail::checkOverfl... | pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %r8
movq 0x20(%rdi), %r9
movq 0x28(%rdi), %r10
subq %r9, %r10
sarq $0x3, %r10
leaq (,%rsi,8), %rax
leaq (%rax,%rax,2), %rax
leaq 0x6eb33(%rip), %r11 # 0xb04f0
testq %rcx, %rcx
je 0x41a8c
movzwl 0x2(%r8,%rsi,8), %ebx
shll $0x10, %ebx
addq $-0x40000, %rbx # imm = 0... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned int, unsigned int, double>::SparseTensorStorage(unsigned long, unsigned long const*, unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*, mlir::sparse_tensor::SparseTensorCOO<double>*) | SparseTensorStorage<P, C, V>::SparseTensorStorage(
uint64_t dimRank, const uint64_t *dimSizes, uint64_t lvlRank,
const uint64_t *lvlSizes, const LevelType *lvlTypes,
const uint64_t *dim2lvl, const uint64_t *lvl2dim,
SparseTensorCOO<V> *lvlCOO)
: SparseTensorStorage(dimRank, dimSizes, lvlRank, lvlSiz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdi, %rbx
movaps 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r8, 0x18(%rsp)
callq 0x4b8b0
testq %r12, %r12
je 0x4b82e
leaq 0xe0(%rbx), %rax
movq %rax, 0x20(%rsp)
movl $0x1, %r13d
xorl %r14d, %r14d
leaq 0x64f7c(%rip... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned int, unsigned int, double>::getCoordinatesBuffer(std::vector<unsigned int, std::allocator<unsigned int>>**, unsigned long) | void getCoordinatesBuffer(std::vector<C> **out, uint64_t lvl) final {
assert(out && "Received nullptr for out parameter");
assert(lvl < getLvlRank());
// Note that the sparse tensor support library always stores COO in SoA
// format, even when AoS is requested. This is never an issue, since all
// a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x28(%rdi), %rax
movq 0xe0(%rdi), %rbx
subq 0x20(%rdi), %rax
sarq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0xe8(%rdi), %r14
movq %r14, %r13
subq %rbx, %r13
sarq $0x3, %r13
leaq 0x1... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned short, float>::getCoordinatesBuffer(std::vector<unsigned short, std::allocator<unsigned short>>**, unsigned long) | void getCoordinatesBuffer(std::vector<C> **out, uint64_t lvl) final {
assert(out && "Received nullptr for out parameter");
assert(lvl < getLvlRank());
// Note that the sparse tensor support library always stores COO in SoA
// format, even when AoS is requested. This is never an issue, since all
// a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x28(%rdi), %rax
movq 0xe0(%rdi), %rbx
subq 0x20(%rdi), %rax
sarq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0xe8(%rdi), %r14
movq %r14, %r13
subq %rbx, %r13
sarq $0x2, %r13
leaq 0x1... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned short, float>::finalizeSegment(unsigned long, unsigned long, unsigned long) | void finalizeSegment(uint64_t l, uint64_t full = 0, uint64_t count = 1) {
if (count == 0)
return; // Short-circuit, since it'll be a nop.
if (isCompressedLvl(l)) {
uint64_t pos = coordinates[l].size();
positions[l].insert(positions[l].end(), count,
detail::checkOverfl... | pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %r8
movq 0x20(%rdi), %r9
movq 0x28(%rdi), %r10
subq %r9, %r10
sarq $0x3, %r10
leaq (,%rsi,8), %rax
leaq (%rax,%rax,2), %rax
leaq 0x45e1d(%rip), %r11 # 0xb0ebc
testq %rcx, %rcx
je 0x6b171
movzwl 0x2(%r8,%rsi,8), %ebx
shll $0x10, %ebx
addq $-0x40000, %rbx # imm = 0... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned short, float>::SparseTensorStorage(unsigned long, unsigned long const*, unsigned long, unsigned long const*, mlir::sparse_tensor::LevelType const*, unsigned long const*, unsigned long const*, long const*) | SparseTensorStorage<P, C, V>::SparseTensorStorage(
uint64_t dimRank, const uint64_t *dimSizes, uint64_t lvlRank,
const uint64_t *lvlSizes, const LevelType *lvlTypes,
const uint64_t *dim2lvl, const uint64_t *lvl2dim, const intptr_t *lvlBufs)
: SparseTensorStorage(dimRank, dimSizes, lvlRank, lvlSizes, lvl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdi, %r12
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x6a960
movq %rbx, 0x18(%rsp)
movl $0x1, %r15d
testq %rbx, %rbx
je 0x6b360
xorl %r14d, %r14d
xorl %r13d, %r13... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned char, float>::lexInsert(unsigned long const*, float) | void lexInsert(const uint64_t *lvlCoords, V val) final {
assert(lvlCoords);
if (allDense) {
uint64_t lvlRank = getLvlRank();
uint64_t valIdx = 0;
// Linearize the address.
for (uint64_t l = 0; l < lvlRank; l++)
valIdx = valIdx * getLvlSize(l) + lvlCoords[l];
values[valIdx] ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xa8(%rdi)
jne 0x6c354
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
subq %rax, %rcx
je 0x6c39a
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
xorl %edx, %edx
imulq (%rax,%rsi,8), %rdx
addq (%r14,%rsi,8), %rdx
in... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
mlir::sparse_tensor::SparseTensorStorage<unsigned short, unsigned short, bf16>::insPath(unsigned long const*, unsigned long, unsigned long, bf16) | void insPath(const uint64_t *lvlCoords, uint64_t diffLvl, uint64_t full,
V val) {
const uint64_t lvlRank = getLvlRank();
assert(diffLvl <= lvlRank);
for (uint64_t l = diffLvl; l < lvlRank; l++) {
const uint64_t c = lvlCoords[l];
appendCrd(l, full, c);
full = 0;
lvlCurs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdi, %rbx
movw %bp, 0x6(%rsp)
movq 0x28(%rdi), %r13
subq 0x20(%rdi), %r13
sarq $0x3, %r13
cmpq %rdx, %r13
jbe 0x7da62
movq %rdx, %r14
movq %rsi, %r15
movq (%r15,%r14,8), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rcx, %rd... | /mlir/ExecutionEngine/SparseTensor/Storage.h |
SharedPtrUnitTest_constructor_Test::TestBody() | void val(int val)
{
val_ = val;
} | pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq %rsp, %r8
movl %eax, (%r8)
leaq 0x2f83c(%rip), %rsi # 0x3908b
leaq 0x335ba(%rip), %rdx # 0x3ce10
leaq 0x10(%rsp), %rdi
callq 0xc19f
cmpb $0x0, 0x10(%rsp)
jne 0x98c5
leaq 0x8(%rsp),... | /mlutken[P]nestle/estl/memory/unittest/shared_ptr_unittest.cpp |
SharedPtrUnitTest_use_count_Test::TestBody() | void val(int val)
{
val_ = val;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movq %rsp, %r8
movl %eax, (%r8)
leaq 0x2f32c(%rip), %rsi # 0x3908b
leaq 0x330aa(%rip), %rdx # 0x3ce10
leaq 0x20(%rsp), %rdi
callq 0xc19f
cmpb $0x0, 0x20(%rsp)
jne 0x9dd5
lea... | /mlutken[P]nestle/estl/memory/unittest/shared_ptr_unittest.cpp |
testing::internal::SuiteApiResolver<SharedPtrUnitTest>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0xcaf5
testb %al, %al
jne 0xb993
leaq 0x2d8bf(%rip), %rdx # 0x391a2
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x20f, %ecx # imm = 0x20F
callq 0x2b536
movq 0x446ea(%rip), %rdi # 0x4ffe8
leaq 0x2d92... | /mlutken[P]nestle/testing/googletest/googletest/include/gtest/internal/gtest-internal.h |
MyClass::MyClass() | MyClass () {
std::cerr << "MyClass DEFAULT CONSTRUCTOR: " << val_ << " this: " << this << std::endl;
// = default; TODO: We should not need this
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffff9d, (%rdi) # imm = 0xFFFFFF9D
movq 0x44528(%rip), %r14 # 0x4ffe8
leaq 0x2d6bd(%rip), %rsi # 0x39184
movl $0x1d, %edx
movq %r14, %rdi
callq 0x8590
movl (%rbx), %esi
movq %r14, %rdi
callq 0x8930
movq %rax, %r14
leaq 0x2d88b(%rip), %rsi # 0x393... | /mlutken[P]nestle/estl/memory/unittest/shared_ptr_unittest.cpp |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_.get() != nullptr) negation << *message_;
return negation;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x10f8a
leaq 0x8(%r14), %rbx
movq %r14, %rdi
callq 0x2ea1c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rsi
testq %rsi... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | size_t GetId(const std::string& str) {
IdMap::iterator it = ids_.find(str);
if (it != ids_.end()) return it->second;
size_t id = ids_.size();
return ids_[str] = id;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x332ae
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x1166b
movq 0x40(%rax), %r15
jmp 0x1167d
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33232
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*) | void PushLine(char edit, const char* line) {
switch (edit) {
case ' ':
++common_;
FlushEdits();
hunk_.push_back(std::make_pair(' ', line));
break;
case '-':
++removes_;
hunk_removes_.push_back(std::make_pair('-', line));
break;
case '+':
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x11cab
cmpl $0x2b, %ebp
je 0x11c99
cmpl $0x20, %ebp
jne 0x11cdf
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x2ccb2
movl $0x38, %r12d
movl $0x28, %r15d
jmp 0x11cbb
incq 0x10(%rbx)
movl $0x50, %r12d
movl... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x10b90
movq (%r15), %rax
movq %rax, (%rsp)
leaq 0x10(%rax), %r15
leaq 0x29070(%rip), %rsi ... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*) | std::string GetBoolAssertionFailureMessage(
const AssertionResult& assertion_result,
const char* expression_text,
const char* actual_predicate_value,
const char* expected_predicate_value) {
const char* actual_message = assertion_result.message();
Message msg;
msg << "Value of: " << expression_text... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x121bd
movq (%rax), %r13
jmp 0x121c4
leaq 0x29440(%rip), %r13 # 0x3b604
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x10b90... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
const char* rhs_expression,
const char* lhs,
const char* rhs) {
if (String::CStringEquals(lhs, rhs)) {
return AssertionSuccess();
}
return EqFailure(lhs_expr... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x1272e
orq %r8, %rcx
jne 0x1273d
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x127aa
movq %rcx, %rdi
movq %r8, %rsi
ca... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression,
const char* s1,
const char* s2) {
if (!String::CStringEquals(s1, s2)) {
return AssertionSuccess();
} else {
return AssertionFailur... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x12a23
orq %r8, %rcx
jne 0x12a36
leaq 0x10(%rsp), %r14
movb $0x0, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x28630(%ri... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::TestInfo::~TestInfo() | TestInfo::~TestInfo() { delete factory_; } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x151cb
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x90(%rbx), %r14
leaq 0xe0(%rbx), %rdi
callq 0x2fde0
leaq 0xc8(%rbx), %rdi
callq 0x2fe10
movq %r14, %rdi
callq 0x2fe40
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation) | void ReportInvalidTestSuiteType(const char* test_suite_name,
CodeLocation code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
<< "All tests in the same test suite must use the same test fixture\n"
<< "class.... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x10b90
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x25e4b(%rip), %rsi # 0x3b29c
movl $0x25, %edx
movq %r15, %rdi
callq 0x8590
testq %r12, %r12
je 0x15473
movq %r12, %rdi
callq ... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RegisterParameterizedTests() | void UnitTestImpl::RegisterParameterizedTests() {
if (!parameterized_tests_registered_) {
parameterized_test_registry_.RegisterTests();
type_parameterized_test_registry_.CheckForInstantiations();
parameterized_tests_registered_ = true;
}
} | cmpb $0x0, 0x160(%rdi)
jne 0x159b1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
movq 0xf0(%rdi), %r15
cmpq %r15, %r14
je 0x15999
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x15985
leaq 0x100(%rbx), %rdi
callq 0xddf4
movb $0x1, 0x160(%rbx)
popq %rbx
popq %r14
popq... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, 0x38(%rsp)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x10b90
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
movq (%rbx), %rcx
movq %rcx, 0x10(%rsp)
testl %eax, %eax
jle 0x1cab5
movq 0x10(%rsp), %... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.