name string | code string | asm string | file string |
|---|---|---|---|
vdbeLeave | static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){
int i;
sqlite3 *db;
Db *aDb;
int nDb;
db = p->db;
aDb = db->aDb;
nDb = db->nDb;
for(i=0; i<nDb; i++){
if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
sqlite3BtreeLeave(aDb[i].pBt);
}
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movslq 0x28(%rax), %r14
testq %r14, %r14
jle 0x4b4c5
movq %rdi, %rbx
movq 0x20(%rax), %r15
addq $0x8, %r15
xorl %r12d, %r12d
cmpq $0x1, %r12
je 0x4b4b9
movl 0xc8(%rbx), %eax
btl %r12d, %eax
jae 0x4b4b9
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4b4b9... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3OsOpenMalloc | SQLITE_PRIVATE int sqlite3OsOpenMalloc(
sqlite3_vfs *pVfs,
const char *zFile,
sqlite3_file **ppFile,
int flags,
int *pOutFlags
){
int rc;
sqlite3_file *pFile;
pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
if( pFile ){
rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
if( r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, %r12d
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
movslq 0x4(%rdi), %r15
movq %r15, %rdi
callq 0x2bce4
testq %rax, %rax
je 0x4b546
movq %rax, %r14
movq %rbp, 0x8(%rsp)
xorl %ebp, %ebp
movq %rax, %rdi
x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeCloseStatement | static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){
sqlite3 *const db = p->db;
int rc = SQLITE_OK;
int i;
const int iSavepoint = p->iStatement-1;
assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
assert( db->nStatement>0 );
assert( p->iStatement==(db->nStatement+db->nSavepoint) );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movq (%rdi), %rbx
movl 0x40(%rdi), %r15d
decl %r15d
movl 0x28(%rbx), %eax
testl %eax, %eax
jle 0x4b65f
movq %r14, 0x10(%rsp)
xorl %r14d, %r14d
movl $0x8, %ebp
xorl %r12d, %r12d
movq 0x20(%rbx), %rcx
m... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeMemClear | static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
if( VdbeMemDynamic(p) ){
vdbeMemClearExternAndSetNull(p);
}
if( p->szMalloc ){
sqlite3DbFreeNN(p->db, p->zMalloc);
p->szMalloc = 0;
}
p->z = 0;
} | pushq %rbx
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
je 0x4b833
movq %rbx, %rdi
callq 0x4b857
cmpl $0x0, 0x20(%rbx)
je 0x4b84d
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0x3c824
movl $0x0, 0x20(%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeMemClearExternAndSetNull | static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
assert( VdbeMemDynamic(p) );
if( p->flags&MEM_Agg ){
sqlite3VdbeMemFinalize(p, p->u.pDef);
assert( (p->flags & MEM_Agg)==0 );
testcase( p->flags & MEM_Dyn );
}
if( p->flags&MEM... | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
btl $0xd, %eax
jae 0x4b873
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x4b888
movzwl 0x8(%rbx), %eax
btl $0xa, %eax
jae 0x4b880
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
movw $0x1, 0x8(%rbx)
popq %rbx
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeMemFinalize | SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
sqlite3_context ctx;
Mem t;
assert( pFunc!=0 );
assert( pFunc->xFinalize!=0 );
assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
memset(&ctx, 0, sizeof(ctx));
m... | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %rdi
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movw $0x1, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%rax)
movq %rax, ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeMemGrow | int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
assert( sqlite3VdbeCheckMemInvariants(pMem) );
assert( !sqlite3VdbeMemIsRowSet(pMem) );
testcase( pMem->db==0 );
/* If the bPreserve flag is set to true, then the memory cell must already
** contain a valid string or blob value. */
assert( bPreserve... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x21, %esi
movl $0x20, %r14d
cmovgel %esi, %r14d
movl 0x20(%rdi), %eax
testl %eax, %eax
setle %cl
testl %edx, %edx
sete %dl
orb %cl, %dl
jne 0x4b95e
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
cmpq %rax, %rsi
jne 0x4b966
movq 0x28(%rbx), %rdi
movl %... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
valueToText | static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
assert( pVal!=0 );
assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
assert( !sqlite3VdbeMemIsRowSet(pVal) );
assert( (pVal->flags & (MEM_Null))==0 );
if( pVal->flags & (M... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
movzwl %ax, %ecx
testb $0x12, %cl
je 0x4bb06
btl $0xe, %ecx
jae 0x4bab7
movq %rbx, %rdi
callq 0x31761
testl %eax, %eax
jne 0x4bb24
movzwl 0x8(%rbx), %eax
orl $0x2, %eax
movw %ax, 0x8(%rbx)
movzbl 0xa(%rbx), %eax
movzbl %bpl, %esi
an... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeMemStringify | SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
int fg = pMem->flags;
const int nByte = 32;
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
assert( !(fg&MEM_Zero) );
assert( !(fg&(MEM_Str|MEM_Blob)) );
assert( fg&(MEM_Int|MEM_Real) );
assert( !sqlite3VdbeMemIsRowSe... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x8(%rdi), %r15d
cmpl $0x20, 0x20(%rdi)
jge 0x4bb69
movq %rbx, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x4b911
testl %eax, %eax
je 0x4bb7b
movb $0x0, 0xa(%rbx)
movl $0x7, %r15d
jmp 0x4bbff
movq 0x18(%rbx),... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeMemAddTerminator | static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
return SQLITE_NOMEM_BKPT;
}
pMem->z[pMem->n] = 0;
pMem->z[pMem->n+1] = 0;
pMem->flags |= MEM_Term;
return SQLITE_OK;
} | pushq %rbx
movq %rdi, %rbx
movl 0xc(%rdi), %esi
addl $0x2, %esi
movl $0x1, %edx
callq 0x4b911
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x4c1f0
movq 0x10(%rbx), %rcx
movslq 0xc(%rbx), %rdx
xorl %eax, %eax
movb %al, (%rcx,%rdx)
movq 0x10(%rbx), %rcx
movslq 0xc(%rbx), %rdx
movb %al, 0x1(%rcx,%rdx)
orb $0x2, 0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3AtoF | SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
#ifndef SQLITE_OMIT_FLOATING_POINT
int incr;
const char *zEnd = z + length;
/* sign * significand * (10 ^ (esign * exponent)) */
int sign = 1; /* sign of significand */
i64 s = 0; /* significand */
int d = 0; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $0x0, (%rsi)
cmpl $0x1, %ecx
jne 0x4c24a
movl $0x1, %r14d
movl $0x1, %r9d
movq %rdi, %rcx
jmp 0x4c294
movl $0x3, %r8d
movl $0x3, %eax
subl %ecx, %eax
movl $0x1, %r9d
cmpl %edx, %eax
jge 0x4c283
subl %ecx, %r8d
movslq %r8d, %rax
movslq %edx, %r8
movb... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
doubleToInt64 | static SQLITE_NOINLINE i64 doubleToInt64(double r){
#ifdef SQLITE_OMIT_FLOATING_POINT
/* When floating-point is omitted, double and int64 are the same thing */
return r;
#else
/*
** Many compilers we encounter do not define constants for the
** minimum and maximum 64-bit integers, or they define them
** inc... | movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movsd 0x5f4c7(%rip), %xmm1 # 0xabbd0
ucomisd %xmm0, %xmm1
jae 0x4c71f
ucomisd 0x5f4c1(%rip), %xmm0 # 0xabbd8
jae 0x4c71e
cvttsd2si %xmm0, %rax
retq
incq %rax
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3Atoi64 | SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
int incr;
u64 u = 0;
int neg = 0; /* assume positive */
int i;
int c = 0;
int nonNum = 0; /* True if input contains UTF16 with high byte non-zero */
int rc; /* Baseline return code */
const char *zStart;
const... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, %ecx
jne 0x4c76b
movl $0x1, %r9d
xorl %eax, %eax
movq %rdi, %rcx
jmp 0x4c7af
movl $0x3, %eax
movl $0x3, %r8d
subl %ecx, %r8d
cmpl %edx, %r8d
jge 0x4c796
subl %ecx, %eax
movslq %eax, %r8
movslq %edx, %rax
cmpb $0x0, (%rdi,%r8)
jne 0x4c79a
addq $0x2, %r8
cmpq %rax, %... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
applyAffinity | static void applyAffinity(
Mem *pRec, /* The value to apply affinity to */
char affinity, /* The affinity to be applied */
u8 enc /* Use this text encoding */
){
if( affinity>=SQLITE_AFF_NUMERIC ){
assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
|| a... | pushq %rbx
movq %rdi, %rbx
cmpb $0x43, %sil
jl 0x554da
movzwl 0x8(%rbx), %eax
testb $0x4, %al
jne 0x55513
testb $0x8, %al
jne 0x55515
testb $0x2, %al
je 0x55513
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x34473
cmpb $0x42, %sil
jne 0x55513
movzwl 0x8(%rbx), %eax
movl %eax, %ecx
andl $0x2, %ecx
shrl %ecx
testb $0xc,... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeMemCast | SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
if( pMem->flags & MEM_Null ) return;
switch( aff ){
case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */
if( (pMem->flags & MEM_Blob)==0 ){
sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
assert( pMem->fla... | pushq %rbx
movzwl 0x8(%rdi), %eax
testb $0x1, %al
jne 0x555df
movq %rdi, %rbx
movzbl %sil, %ecx
addl $-0x41, %ecx
cmpl $0x4, %ecx
ja 0x555b0
leaq 0x518bf(%rip), %rsi # 0xa6e00
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
testb $0x10, %al
jne 0x555d6
movzbl %dl, %edx
movq %rbx, %rdi
movl $0x42, %esi
callq 0... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3MemCompare | SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
int f1, f2;
int combined_flags;
f1 = pMem1->flags;
f2 = pMem2->flags;
combined_flags = f1|f2;
assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) );
/* If one value is NULL, it is less t... | movzwl 0x8(%rdi), %r8d
movzwl 0x8(%rsi), %ecx
movl %ecx, %eax
orl %r8d, %eax
testb $0x1, %al
jne 0x55654
testb $0xc, %al
je 0x55661
movl %ecx, %eax
andl %r8d, %eax
testb $0x4, %al
jne 0x5568a
testb $0x8, %al
jne 0x5569e
testb $0x4, %r8b
jne 0x556bb
movl $0x1, %eax
testb $0x8, %r8b
je 0x55660
movl $0xffffffff, %eax ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3GetVarint32 | SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
u32 a,b;
/* The 1-byte case. Overwhelmingly the most common. Handled inline
** by the getVarin32() macro */
a = *p;
/* a: p0 (unmasked) */
#ifndef getVarint32
if (!(a&0x80))
{
/* Values between 0 and 127 */
*v = a;
return... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl (%rdi), %ecx
movzbl 0x1(%rdi), %eax
testb %al, %al
js 0x55746
andl $0x7f, %ecx
shll $0x7, %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movb $0x2, %al
jmp 0x55784
movsbl 0x2(%rdi), %edx
testl %edx, %edx
js 0x55764
andl $0x7f, %ecx
shll $0xe, %ecx
andl $0x7f, %eax
shll $0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeMemFromBtree | SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(
BtCursor *pCur, /* Cursor pointing at record to retrieve. */
u32 offset, /* Offset from the start of data to return bytes from. */
u32 amt, /* Number of bytes to return. */
Mem *pMem /* OUT: Return data in this Mem structure. */
){
char *zDa... | movzwl 0x44(%rdi), %r8d
movq 0x38(%rdi), %rax
movq 0x88(%rdi), %r9
movl 0x58(%r9), %r9d
subl %eax, %r9d
xorl %r10d, %r10d
testl %r9d, %r9d
cmovgl %r9d, %r10d
cmpl %r9d, %r8d
cmovlel %r8d, %r10d
leal (%rdx,%rsi), %r8d
cmpl %r10d, %r8d
jbe 0x557c2
jmp 0x5845e
movl %esi, %esi
addq %rsi, %rax
movq %rax, 0x10(%rcx)
movw $0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeSerialGet | SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
const unsigned char *buf, /* Buffer to deserialize from */
u32 serial_type, /* Serial type to deserialize */
Mem *pMem /* Memory cell to write value into */
){
switch( serial_type ){
case 10: { /* Internal use only: NULL with virt... | cmpl $0xb, %esi
ja 0x558d9
movl %esi, %eax
leaq 0x5162b(%rip), %rcx # 0xa6e14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movw $0x1, 0x8(%rdx)
jmp 0x55816
pushq %rax
callq 0x584f6
movl $0x8, %eax
addq $0x8, %rsp
retq
addl $-0x8, %esi
movq %rsi, (%rdx)
movw $0x4, 0x8(%rdx)
xorl %eax, %eax
retq
movl 0x2(%rd... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3PutVarint | SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){
if( v<=0x7f ){
p[0] = v&0x7f;
return 1;
}
if( v<=0x3fff ){
p[0] = ((v>>7)&0x7f)|0x80;
p[1] = v&0x7f;
return 2;
}
return putVarint64(p,v);
} | cmpq $0x7f, %rsi
ja 0x55907
movb %sil, (%rdi)
movl $0x1, %eax
retq
cmpq $0x3fff, %rsi # imm = 0x3FFF
ja 0x5853a
movl %esi, %eax
shrl $0x7, %eax
orb $-0x80, %al
movb %al, (%rdi)
andb $0x7f, %sil
movb %sil, 0x1(%rdi)
movl $0x2, %eax
retq
| /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3ResetOneSchema | SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
int i;
assert( iDb<db->nDb );
if( iDb>=0 ){
assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
DbSetProperty(db, iDb, DB_ResetWanted);
DbSetProperty(db, 1, DB_ResetWanted);
db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
}
if( db->nSchemaLoc... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
js 0x559b5
movq 0x20(%rbx), %rax
movl %esi, %ecx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %rcx
orw $0x8, 0x72(%rcx)
movq 0x38(%rax), %rax
orw $0x8, 0x72(%rax)
andb $-0x9, 0x2c(%rbx)
cmpl $0x0, 0x48(%rbx)
jne 0x559f0
movl 0x28(%rbx), %eax
testl %eax, %eax
jl... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BtreeMovetoUnpacked | SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
BtCursor *pCur, /* The cursor to be moved */
UnpackedRecord *pIdxKey, /* Unpacked index key */
i64 intKey, /* The table key */
int biasRight, /* If true, bias the search to the high end */
int *pRes /* Write search r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %r12
testq %rsi, %rsi
movq %rsi, 0x28(%rsp)
je 0x56083
movq (%rsi), %rax
leaq 0x2aec(%rip), %rcx # 0x58b14
movq %rcx, (%rsp)
cmpw $0xd, 0x8(%rax)
ja 0x560ae
movq 0x8(%rsi), ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VdbeMemNumerify | SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
int rc;
assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
rc = sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc);
if( rc==0 ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0xd, %al
jne 0x580a6
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x4c753
movl %eax, %ebp
movw $0x4, %ax
testl %ebp, %ebp
je 0x58097
movq (%rbx), %r14
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movz... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3BlobCompare | int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
int c;
int n1 = pB1->n;
int n2 = pB2->n;
/* It is possible to have a Blob value that has some non-zero content
** followed by zero content. But that only comes up for Blobs formed
** by the OP_MakeRecord opcode, and such Blobs never get passed into
... | pushq %rbx
movl 0xc(%rdi), %eax
movl 0xc(%rsi), %ecx
movzwl 0x8(%rdi), %edx
movzwl 0x8(%rsi), %r8d
movl %r8d, %r9d
orl %edx, %r9d
btl $0xe, %r9d
jb 0x5821d
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
movl %eax, %ebx
subl %ecx, %ebx
cmovll %eax, %ecx
movslq %ecx, %rdx
callq 0xa1a0
testl %eax, %eax
cmovnel %eax, %ebx
mov... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
moveToChild | static int moveToChild(BtCursor *pCur, u32 newPgno){
BtShared *pBt = pCur->pBt;
assert( cursorOwnsBtShared(pCur) );
assert( pCur->eState==CURSOR_VALID );
assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
assert( pCur->iPage>=0 );
if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
return SQLITE_CORRUPT_BKPT;
}
pCur... | movsbq 0x54(%rdi), %rax
cmpq $0x13, %rax
jl 0x58798
pushq %rax
leaq 0x53878(%rip), %rsi # 0xabfea
leaq 0x53994(%rip), %rdx # 0xac10d
leaq 0x53696(%rip), %r8 # 0xabe16
movl $0xb, %edi
movl $0x10821, %ecx # imm = 0x10821
xorl %eax, %eax
callq 0x2df95
movl $0xb, %eax
popq %rcx
retq
movq %rdi, %rcx
mo... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
moveToRightmost | static int moveToRightmost(BtCursor *pCur){
Pgno pgno;
int rc = SQLITE_OK;
MemPage *pPage = 0;
assert( cursorOwnsBtShared(pCur) );
assert( pCur->eState==CURSOR_VALID );
while( !(pPage = pCur->pPage)->leaf ){
pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
pCur->ix = pPage->nCell;
rc = moveT... | pushq %rbx
movq %rdi, %rbx
movq 0x88(%rbx), %rax
cmpb $0x0, 0x8(%rax)
jne 0x59344
movq 0x50(%rax), %rcx
movzbl 0x9(%rax), %edx
movl 0x8(%rcx,%rdx), %esi
bswapl %esi
movzwl 0x16(%rax), %eax
movw %ax, 0x56(%rbx)
movq %rbx, %rdi
callq 0x5875f
testl %eax, %eax
je 0x59313
jmp 0x59350
movzwl 0x16(%rax), %eax
decl %eax
movw %... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
dropCell | static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
u32 pc; /* Offset to cell content of cell being deleted */
u8 *data; /* pPage->aData */
u8 *ptr; /* Used to move bytes around within data[] */
int rc; /* The return code */
int hdr; /* Beginning of the header.... | cmpl $0x0, (%rcx)
je 0x596c8
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x60(%rdi), %rbp
movslq %esi, %r13
movzwl (%rbp,%r13,2), %ecx
rolw $0x8, %cx
movzwl %cx, %esi
leal (%rsi,%rdx), %ecx
cmpl 0x34(%rax), %ecx
jbe 0x5972b... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
balance | static int balance(BtCursor *pCur){
int rc = SQLITE_OK;
const int nMin = pCur->pBt->usableSize * 2 / 3;
u8 aBalanceQuickSpace[13];
u8 *pFree = 0;
VVA_ONLY( int balance_quick_called = 0 );
VVA_ONLY( int balance_deeper_called = 0 );
do {
int iPage = pCur->iPage;
MemPage *pPage = pCur->pPage;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rdi, %r12
movq 0x20(%rdi), %rax
movl 0x34(%rax), %eax
addl %eax, %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rax, %rcx
shrq $0x21, %rcx
movq %rcx, 0x200(%rsp)
movb 0x54(%rdi), %cl
movq 0x88... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeSorterMerge | static SorterRecord *vdbeSorterMerge(
SortSubtask *pTask, /* Calling thread context */
SorterRecord *p1, /* First list to merge */
SorterRecord *p2 /* Second list to merge */
){
SorterRecord *pFinal = 0;
SorterRecord **pp = &pFinal;
int bCached = 0;
assert( p1!=0 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rbp
movq $0x0, (%rbp)
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
leaq 0x10(%r14), %r13
leaq 0x10(%r15), %rdx
movl (%r15), %ecx
movl (%r14), %r9d
movq %rbx, %rdi
movq %r12, %rs... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeSorterCompareText | static int vdbeSorterCompareText(
SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
int *pbKey2Cached, /* True if pTask->pUnpacked is pKey2 */
const void *pKey1, int nKey1, /* Left side of comparison */
const void *pKey2, int nKey2 /* Right side of comparison */
){
const u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x14(%rsp)
movq %r8, %r14
movl %ecx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
movzbl (%rdx), %ebx
movzbl (%r8), %ebp
movsbl 0x1(%rdx), %eax
testl %eax, %eax
js 0x5cc50
movl %eax, 0xc(%rsp)
jmp 0x5cc5e
l... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeSorterOpenTempFile | static int vdbeSorterOpenTempFile(
sqlite3 *db, /* Database handle doing sort */
i64 nExtend, /* Attempt to extend file to this size */
sqlite3_file **ppFd
){
int rc;
if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS;
rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x715d9(%rip), %rax # 0xce5c8
testq %rax, %rax
je 0x5d006
movl $0xca, %edi
callq *%rax
movl %eax, %ecx
movl $0xd0a, %eax # imm = 0xD0A
testl %ecx, %ecx
jne 0x5d064
movq (%r15), %rdi
leaq 0xc(... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeIncrMergerNew | static int vdbeIncrMergerNew(
SortSubtask *pTask, /* The thread that will be using the new IncrMerger */
MergeEngine *pMerger, /* The MergeEngine that the IncrMerger will control */
IncrMerger **ppOut /* Write the new IncrMerger here */
){
int rc = SQLITE_OK;
IncrMerger *pIncr = *ppOut = (IncrMerge... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x713b3(%rip), %rax # 0xce5c8
testq %rax, %rax
je 0x5d225
movl $0x64, %edi
callq *%rax
testl %eax, %eax
jne 0x5d27e
movl $0x48, %edi
callq 0x2bce4
testq %rax, %rax
je 0x5d27e
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbePmaReaderIncrMergeInit | static int vdbePmaReaderIncrMergeInit(PmaReader *pReadr, int eMode){
int rc = SQLITE_OK;
IncrMerger *pIncr = pReadr->pIncr;
SortSubtask *pTask = pIncr->pTask;
sqlite3 *db = pTask->pSorter->db;
/* eMode is always INCRINIT_NORMAL in single-threaded mode */
assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRIN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x48(%rdi), %r14
movq (%r14), %r12
movq 0x8(%r14), %rsi
movq 0x10(%r12), %rax
movq 0x20(%rax), %r13
movq %r12, %rdi
movl %ebp, %edx
callq 0x5d3bc
testl %eax, %eax
je 0x5d302
addq $0x8, %rsp
popq %rbx
popq %... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeMergeEngineInit | static int vdbeMergeEngineInit(
SortSubtask *pTask, /* Thread that will run pMerger */
MergeEngine *pMerger, /* MergeEngine to initialize */
int eMode /* One of the INCRINIT_XXX constants */
){
int rc = SQLITE_OK; /* Return code */
int i; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x8(%rsi)
movslq (%rsi), %rax
testq %rax, %rax
jle 0x5d4f0
movl %edx, %ebp
movq %rsi, %r14
leal -0x1(%rax), %r15d
shlq $0x4, %rax
leaq (%rax,%rax,4), %r12
xorl %r13d, %r13d
movq 0x18(%r14), %rdi
cmpl $0x2... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
vdbeChangeP4Full | static void SQLITE_NOINLINE vdbeChangeP4Full(
Vdbe *p,
Op *pOp,
const char *zP4,
int n
){
if( pOp->p4type ){
freeP4(p->db, pOp->p4type, pOp->p4.p);
pOp->p4type = 0;
pOp->p4.p = 0;
}
if( n<0 ){
sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
}else{
if( n==0 ) n = sqlite3Strlen30(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsbl 0x1(%rsi), %esi
testl %esi, %esi
je 0x61118
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
callq 0x49cd2
movb $0x0, 0x1(%rbx)
movq $0x0, 0x10(%rbx)
testl %ebp, %ebp
js 0x61128
je 0x6114b
testq %r14, %r... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3TriggerUpdateStep | SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
Parse *pParse, /* Parser */
Token *pTableName, /* Name of the table to be updated */
ExprList *pEList, /* The SET clause: list of column and new values */
Expr *pWhere, /* The WHERE clause */
u8 orconf, /* The conflict algori... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r13
movq 0x40(%rsp), %r8
movq (%rdi), %r14
movl $0x76, %esi
movq %r9, %rcx
callq 0x9ac73
movq %rax, %r15
testq %rax, %rax
je 0x72e4e
cmpb $0x2, 0x10c(%r13)
jb 0x72e17
... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3DropTrigger | SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
Trigger *pTrigger = 0;
int i;
const char *zDb;
const char *zName;
sqlite3 *db = pParse->db;
if( db->mallocFailed ) goto drop_trigger_cleanup;
if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
goto drop_trigger_cleanup;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq (%rdi), %r14
cmpb $0x0, 0x61(%r14)
jne 0x73117
movl %edx, %ebp
movq %rdi, %r15
callq 0x6130a
testl %eax, %eax
jne 0x73117
movl %ebp, 0x1c(%rsp)
movq %r15, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %r12
movl 0x... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VtabFinishParse | SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
Table *pTab = pParse->pNewTable; /* The table being constructed */
sqlite3 *db = pParse->db; /* The database connection */
if( pTab==0 ) return;
addArgumentToVtab(pParse);
pParse->sArg.z = 0;
if( pTab->nModuleArg<1 ) return;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x138(%rdi), %r15
testq %r15, %r15
je 0x7407f
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r14
callq 0x9cc82
movq $0x0, 0x158(%rbx)
cmpl $0x0, 0x54(%r15)
jle 0x7407f
cmpb $0x0, 0xb5(%r14)
je 0x74019
movq (%r15), %rsi
movq 0x70(%r15), %rd... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3VtabBeginParse | SQLITE_PRIVATE void sqlite3VtabBeginParse(
Parse *pParse, /* Parsing context */
Token *pName1, /* Name of new table, or database name */
Token *pName2, /* Name of new table or NULL */
Token *pModuleName, /* Name of the module for the virtual table */
int ifNotExists /* No error if... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl %r8d, (%rsp)
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x6519f
movq 0x138(%rbx), %r15
testq %r15, %r15
je 0x7429a
movq (%rbx), %r12
movq 0x70(%r15), %rax
testq %rax, %rax
je 0x74209
movq 0x20(%r12), ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3TableLock | SQLITE_PRIVATE void sqlite3TableLock(
Parse *pParse, /* Parsing context */
int iDb, /* Index of the database containing the table to lock */
int iTab, /* Root page number of the table to be locked */
u8 isWriteLock, /* True for a write lock */
const char *zName /* Name of the table ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xa0(%rdi), %r12
testq %r12, %r12
cmoveq %rdi, %r12
cmpl $0x1, %esi
je 0x7491b
movl %ecx, %ebx
movl %esi, %r15d
movq (%rdi), %rax
movq 0x20(%rax), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rax
cmpb $0x0, 0x11(%rax)
je 0x7491b
movq %r8, %r14
... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
exprProbability | static int exprProbability(Expr *p){
double r = -1.0;
if( p->op!=TK_FLOAT ) return -1;
sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
assert( r>=0.0 );
if( r>1.0 ) return -1;
return (int)(r*134217728.0);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x8(%rsp)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpb $-0x73, (%rdi)
jne 0x7c8fa
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x7c8c8
movq %r14, %rdi
callq 0xa190
movq %rax, %rdx
andl $0x3ffff... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3CodeVerifyNamedSchema | SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
sqlite3 *db = pParse->db;
int i;
for(i=0; i<db->nDb; i++){
Db *pDb = &db->aDb[i];
if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zDbSName)) ){
sqlite3CodeVerifySchema(pParse, i);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movl 0x28(%r12), %ebp
testl %ebp, %ebp
jle 0x80478
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %r13d
xorl %r15d, %r15d
movq 0x20(%r12), %rax
cmpq $0x0, (%rax,%r13)
je 0x80469
testq %rbx, %rbx
je 0x80459
movq -0x8(%rax,%r13), %... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3DropTriggerPtr | SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
Table *pTable;
Vdbe *v;
sqlite3 *db = pParse->db;
int iDb;
iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
assert( iDb>=0 && iDb<db->nDb );
pTable = tableOfTrigger(pTrigger);
assert( pTable );
assert( pTable->pS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x8099d
movq 0x20(%r12), %rcx
addq $0x18, %rcx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
incl %ebp
leaq 0x20(%rcx), %rdx
cmpq %rax, (%rcx)
movq %... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
propagateConstants | static int propagateConstants(
Parse *pParse, /* The parsing context */
Select *p /* The query in which to propagate constants */
){
WhereConst x;
Walker w;
int nChng = 0;
x.pParse = pParse;
do{
x.nConst = 0;
x.nChng = 0;
x.apExpr = 0;
findConstInWhere(&x, p->pWhere);
if( x.nC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r13
movq %rdi, -0x8(%r13)
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
leaq -0x3ffb(%rip), %r12 # 0x7f1f8
movups %xmm0, (%r13)
movq 0x30(%rbx), %rsi
movq %r15, %rdi
callq 0x887b0... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
isSelfJoinView | static struct SrcList_item *isSelfJoinView(
SrcList *pTabList, /* Search for self-joins in this FROM clause */
struct SrcList_item *pThis /* Search for prior reference to this subquery */
){
struct SrcList_item *pItem;
for(pItem = pTabList->a; pItem<pThis; pItem++){
if( pItem->pSelect==0 ) conti... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x8(%rdi), %rax
xorl %ebx, %ebx
cmpq %rsi, %rax
jae 0x83476
movq %rsi, %r15
movq %rdi, %r14
addq $0x45, %r14
movq -0x15(%r14), %r13
testq %r13, %r13
je 0x8342c
testb $0x10, (%r14)
jne 0x8342c
movq -0x2d(%r14), %r12
testq %r12, %r12
je 0x8342c
movq -0x35(%r14),... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
generateOutputSubroutine | static int generateOutputSubroutine(
Parse *pParse, /* Parsing context */
Select *p, /* The SELECT statement */
SelectDest *pIn, /* Coroutine supplying data */
SelectDest *pDest, /* Where to send the data */
int regReturn, /* The return address register */
int regP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movq %rcx, 0x20(%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
movq 0x10(%rdi), %r14
movl 0xb8(%r14), %eax
movl %eax, 0x34(%rsp)
movq 0x18(%r14), %rdi
callq 0x764c8
movl %eax, %r12d
testl %r1... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
constructAutomaticIndex | static void constructAutomaticIndex(
Parse *pParse, /* The parsing context */
WhereClause *pWC, /* The WHERE clause */
struct SrcList_item *pSrc, /* The FROM clause term to get the next index */
Bitmask notReady, /* Mask of cursors that are not available */
WhereLevel *pLevel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r15
movq %r8, 0x48(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq %rdi, 0x50(%rsp)
movl $0x11, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x60f79
movl %ea... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3WhereExprUsageNN | SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){
Bitmask mask;
if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
return sqlite3WhereGetMask(pMaskSet, p->iTable);
}else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){
assert( p->op!=TK_IF_NULL_ROW );
return 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r12d, %r12d
movb (%r15), %cl
movl 0x4(%r15), %eax
cmpb $-0x62, %cl
jne 0x8e266
testb $0x8, %al
je 0x8e32c
movl $0x0, %r13d
testl $0x804000, %eax # imm = 0x804000
je 0x8e297
jmp 0x8e... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3ExprForVectorField | SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(
Parse *pParse, /* Parsing context */
Expr *pVector, /* The vector. List of expressions or a sub-SELECT */
int iField /* Which column of the vector to return */
){
Expr *pRet;
if( pVector->op==TK_SELECT ){
assert( pVector->flags & EP_xI... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movzbl (%rsi), %eax
cmpl $0xa5, %eax
je 0x8e4d7
cmpl $0x7f, %eax
jne 0x8e4ec
xorl %r14d, %r14d
movl $0xa6, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x664ce
testq %rax, %rax
je 0x8e502
movw %bp, 0x30(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %r14
jmp 0x8e50... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
exprMightBeIndexed2 | static SQLITE_NOINLINE int exprMightBeIndexed2(
SrcList *pFrom, /* The FROM clause */
Bitmask mPrereq, /* Bitmask of FROM clause terms referenced by pExpr */
int *aiCurCol, /* Write the referenced table cursor and column here */
Expr *pExpr /* An operand of a comparison operator ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x2, %rsi
jb 0x8e537
movq %rsi, %rdx
shrq %rdx
incq %rcx
cmpq $0x3, %rsi
movq %rdx, %rsi
ja 0x8e528
imulq $0x70, %rcx, %rcx
movq 0x28(%rdi,%rcx), %rdx
movq 0x10(%rdx), %r15
... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
whereScanNext | static WhereTerm *whereScanNext(WhereScan *pScan){
int iCur; /* The cursor on the LHS of the term */
i16 iColumn; /* The column on the LHS of the term. -1 for IPK */
Expr *pX; /* An expression being tested */
WhereClause *pWC; /* Shorthand for pScan->pWC */
WhereTerm *pTerm; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %r15d
movq 0x8(%rdi), %r13
movb 0x22(%rdi), %al
movzbl %al, %eax
movswl 0x56(%rbx,%rax,2), %r9d
movl 0x28(%rbx,%rax,4), %ebp
movl %r9d, 0xc(%rsp)
cmpl 0x14(%r13), %r15d
jge 0x8e974
movslq %r15d, %r14
shlq... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
whereLoopClear | static void whereLoopClear(sqlite3 *db, WhereLoop *p){
if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFreeNN(db, p->aLTerm);
whereLoopClearUnion(db, p);
whereLoopInit(p);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
leaq 0x48(%rbx), %r15
cmpq %r15, %rsi
je 0x8fb07
movq %r14, %rdi
callq 0x3c824
movq %r14, %rdi
movq %rbx, %rsi
callq 0x903f2
movq %r15, 0x38(%rbx)
movw $0x0, 0x2c(%rbx)
movw $0x3, 0x30(%rbx)
movl $0x0, 0x28(%rbx)
popq %rbx
popq %r14
... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
updateVirtualTable | static void updateVirtualTable(
Parse *pParse, /* The parsing context */
SrcList *pSrc, /* The virtual table to be modified */
Table *pTab, /* The virtual table */
ExprList *pChanges, /* The columns to change in the UPDATE statement */
Expr *pRowid, /* Expression used to recompute ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbp
movq %rcx, %r14
movq %rdi, %r13
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rdi), %rcx
movq 0x60(%rdx), %r12
testq %r12, %r12
movq %rcx, 0x58(%rsp)
movq %r8, 0x60(%rsp)
je 0x977b6
movq (%r13), %rax
cmpq %rax, (%... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
sqlite3UpsertDoUpdate | SQLITE_PRIVATE void sqlite3UpsertDoUpdate(
Parse *pParse, /* The parsing and code-generating context */
Upsert *pUpsert, /* The ON CONFLICT clause for the upsert */
Table *pTab, /* The table being updated */
Index *pIdx, /* The UNIQUE constraint that failed */
int iCur ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq (%rdi), %r14
movl 0x34(%rsi), %esi
testq %rcx, %rcx
sete %al
cmpl %r8d, %esi
sete %cl
orb %al, %cl
jne 0x9925c
movl %r8d, %r13d
movq 0x10(%r12), %rax
movq %rax, 0x8(%rsp)
testb $0x20, ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
xferOptimization | static int xferOptimization(
Parse *pParse, /* Parser context */
Table *pDest, /* The table we are inserting into */
Select *pSelect, /* A SELECT statement to use as the data source */
int onError, /* How to handle constraint errors */
int iDbDest /* The database of pDes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %r15d, %r15d
testq %rdx, %rdx
je 0x99d38
movq %rdi, %rbx
cmpq $0x0, 0x180(%rdi)
jne 0x99d38
movq %rdx, %r14
cmpq $0x0, 0x68(%rdx)
jne 0x99d38
movl %ecx, %r12d
movq %rsi, %r13
movl %r8d, 0x44(%rsp)
movq (%rbx), %rbp
movq 0x20(%rbp), ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
setPragmaResultColumnNames | static void setPragmaResultColumnNames(
Vdbe *v, /* The query under construction */
const PragmaName *pPragma /* The pragma */
){
u8 n = pPragma->nPragCName;
sqlite3VdbeSetNumCols(v, n==0 ? 1 : n);
if( n==0 ){
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0xb(%rsi), %r15d
cmpb $0x2, %r15b
movl $0x1, %esi
cmovael %r15d, %esi
callq 0x61fbe
testq %r15, %r15
je 0x9a3c8
movzbl 0xa(%r14), %eax
imulq $0x38, %r15, %r14
leaq 0x329e6(%rip), %rcx # 0xccd70
leaq (%rcx,%rax,8), %r15
xor... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
countStep | static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
CountCtx *p;
p = sqlite3_aggregate_context(context, sizeof(*p));
if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
p->n++;
}
#ifndef SQLITE_OMIT_DEPRECATED
/* The sqlite3_aggregate_count() function is depreca... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x9e7f5
movl $0x8, %esi
callq 0x32f4b
jmp 0x9e7f9
movq 0x10(%rax), %rax
testl %ebp, %ebp
je 0x9e80d
movq (%rbx), %rcx
movl 0x8(%rcx), %ecx
movl $0x55555555, %edx # imm = 0x55555555
btl %ecx, %edx
jae ... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
renameTableTest | static void renameTableTest(
sqlite3_context *context,
int NotUsed,
sqlite3_value **argv
){
sqlite3 *db = sqlite3_context_db_handle(context);
char const *zDb = (const char*)sqlite3_value_text(argv[0]);
char const *zInput = (const char*)sqlite3_value_text(argv[1]);
int bTemp = sqlite3_value_int(argv[4]);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq 0x28(%rax), %rbx
movq (%rdx), %rdi
movl $0x1, %esi
callq 0x31895
movq %rax, %r15
movq 0x8(%r12), %rdi
movl $0x1, %esi
callq 0x31895
movq %rax, %rbp
mov... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
renameParseCleanup | static void renameParseCleanup(Parse *pParse){
sqlite3 *db = pParse->db;
if( pParse->pVdbe ){
sqlite3VdbeFinalize(pParse->pVdbe);
}
sqlite3DeleteTable(db, pParse->pNewTable);
if( pParse->pNewIndex ) sqlite3FreeIndex(db, pParse->pNewIndex);
sqlite3DeleteTrigger(db, pParse->pNewTrigger);
sqlite3DbFree(d... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xa04ef
callq 0x314f2
movq 0x138(%rbx), %rsi
movq %r14, %rdi
callq 0x2b403
movq 0x140(%rbx), %rsi
testq %rsi, %rsi
je 0xa0512
movq %r14, %rdi
callq 0x5ea9f
movq 0x148(%rbx), %rsi
movq %r14, %rdi
callq 0x2b39a
mo... | /glotzerlab[P]libgetar/sqlite3/sqlite3.c |
void tf::SmallVectorImpl<tf::Node*>::append<tf::Node**>(tf::Node**, tf::Node**) | void append(in_iter in_start, in_iter in_end) {
size_type NumInputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (NumInputs > size_type(this->capacity_ptr()-this->end()))
this->grow(this->size()+NumInputs);
// Copy the new elements over.
this->uninitialized_copy(in... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x197a0
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x199c0
movq 0x10(%rsp), %rdi
movq %rax, ... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
void tf::SmallVectorImpl<tf::Node*>::append<std::move_iterator<tf::Node**>>(std::move_iterator<tf::Node**>, std::move_iterator<tf::Node**>) | void append(in_iter in_start, in_iter in_end) {
size_type NumInputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (NumInputs > size_type(this->capacity_ptr()-this->end()))
this->grow(this->size()+NumInputs);
// Copy the new elements over.
this->uninitialized_copy(in... | subq $0x58, %rsp
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x19a00
movq (%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x38(%... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
void tf::BoundedTaskQueue<tf::Node*, 8ul>::push<tf::Node*&, void tf::Executor::_schedule<tf::Node**>(tf::Worker&, tf::Node**, tf::Node**)::'lambda'()>(tf::Node**&&, void tf::Executor::_schedule<tf::Node**>(tf::Worker&, tf::Node**, tf::Node**)::'lambda'()&&) | void BoundedTaskQueue<T, LogSize>::push(O&& o, C&& on_full) {
int64_t b = _bottom.load(std::memory_order_relaxed);
int64_t t = _top.load(std::memory_order_acquire);
// queue is full with one additional item (b-t+1)
if TF_UNLIKELY((b - t) > BufferSize - 1) {
on_full();
return;
} | subq $0xc8, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
subq $-0x80, %rax
movq %rax, 0xb8(%rsp)
movl $0x0, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0xb4(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0xdb10
movl %ea... | /taskflow[P]taskflow/taskflow/core/tsq.hpp |
tf::Executor::_process_exception(tf::Worker&, tf::Node*) | inline void Executor::_process_exception(Worker&, Node* node) {
constexpr static auto flag = ESTATE::EXCEPTION | ESTATE::CANCELLED;
// find the anchor and mark the entire path with exception so recursive
// or nested tasks can be cancelled properly
// since exception can come from asynchronous task (with runt... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x128(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x128(%rsp)
movb %al, 0x107(%rsp)
je 0x1a5f3
movq 0x128(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x158(%rsp)
movl $0x0, 0x154(%rsp)
movq ... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_invoke_runtime_task_impl(tf::Worker&, tf::Node*, std::function<void (tf::Runtime&)>&) | inline bool Executor::_invoke_runtime_task_impl(
Worker& worker, Node* node, std::function<void(Runtime&)>& work
) {
// first time
if((node->_nstate & NSTATE::PREEMPTED) == 0) {
Runtime rt(*this, worker, node);
_observer_prologue(worker, node);
TF_EXECUTOR_EXCEPTION_HANDLER(worker, node, {
wor... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movl (%rax), %eax
andl $0x20000000, %eax # imm = 0x20000000
cmpl $0x0, %eax
jne 0x1b2bf
movq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rs... | /taskflow[P]taskflow/taskflow/core/runtime.hpp |
tf::Subflow::Subflow(tf::Executor&, tf::Worker&, tf::Node*, tf::Graph&) | inline Subflow::Subflow(Executor& executor, Worker& worker, Node* parent, Graph& graph) :
FlowBuilder {graph},
_executor {executor},
_worker {worker},
_parent {parent} {
// need to reset since there could have iterative control flow
_parent->_nstate &= ~(NSTATE::JOINED_SUBFLOW | NSTATE::RETA... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x1b830
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x... | /taskflow[P]taskflow/taskflow/core/flow_builder.hpp |
void tf::Executor::_schedule_graph_with_parent<__gnu_cxx::__normal_iterator<std::unique_ptr<tf::Node, std::default_delete<tf::Node>>*, std::vector<std::unique_ptr<tf::Node, std::default_delete<tf::Node>>, std::allocator<std::unique_ptr<tf::Node, std::default_delete<tf::Node>>>>>>(tf::Worker&, __gnu_cxx::__normal_iterat... | void Executor::_schedule_graph_with_parent(Worker& worker, I beg, I end, Node* parent) {
auto send = _set_up_graph(beg, end, parent->_topology, parent);
parent->_join_counter.fetch_add(send - beg, std::memory_order_relaxed);
_schedule(worker, beg, send);
} | subq $0x98, %rsp
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %r8
movq 0x30(%r8), %rcx
movq 0x38(%rsp), %rsi
mo... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::SmallVectorImpl<tf::Semaphore*>::~SmallVectorImpl() | ~SmallVectorImpl() {
// Destroy the constructed elements in the vector.
this->destroy_range(this->begin(), this->end());
// If this wasn't grown from the inline copy, deallocate the old space.
if (!this->isSmall())
std::free(this->begin());
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x189a0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x1bd30
movq %rax, 0x18(%rsp)
jmp 0x1bcce
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x1bd20
jmp 0x1bcdf
movq 0x8(%rsp), %rdi
callq 0x1bd40
movb %al, 0x7(%rsp)
jmp 0x1b... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
void tf::SmallVectorImpl<int>::append<int const*>(int const*, int const*) | void append(in_iter in_start, in_iter in_end) {
size_type NumInputs = std::distance(in_start, in_end);
// Grow allocated space if needed.
if (NumInputs > size_type(this->capacity_ptr()-this->end()))
this->grow(this->size()+NumInputs);
// Copy the new elements over.
this->uninitialized_copy(in... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1d6e0
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x1d720
movq 0x10(%rsp), %rdi
movq %rax, ... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
void tf::SmallVectorTemplateBase<int, true>::uninitialized_copy<int const, int>(int const*, int const*, int*, std::enable_if<std::is_same<std::remove_const<int const>::type, int>::value, void>::type*) | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
T2>::value>::type * = nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::u... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1d7e8
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x2, %rdx
shlq $0x2, %rdx
callq 0x52a0
addq $0x28, ... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
void tf::SmallVectorTemplateBase<int, true>::uninitialized_copy<int, int>(int*, int*, int*, std::enable_if<std::is_same<std::remove_const<int>::type, int>::value, void>::type*) | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
T2>::value>::type * = nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::u... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1df08
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x2, %rdx
shlq $0x2, %rdx
callq 0x52a0
addq $0x28, ... | /taskflow[P]taskflow/taskflow/core/../utility/small_vector.hpp |
tf::Executor::_invoke_module_task_impl(tf::Worker&, tf::Node*, tf::Graph&) | inline bool Executor::_invoke_module_task_impl(Worker& w, Node* node, Graph& graph) {
// No need to do anything for empty graph
if(graph.empty()) {
return false;
}
// first entry - not spawned yet
if((node->_nstate & NSTATE::PREEMPTED) == 0) {
// signal the executor to preempt this node
node->_n... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1dff0
testb $0x1, %al
jne 0x1df42
jmp 0x1df49
movb $0x0, 0x47(%rsp)
jmp 0x1dfc8
movq 0x28(%rsp), %rax
movl (%rax), %eax
andl $0x20000000, %eax... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
tf::Executor::_invoke_runtime_task_impl(tf::Worker&, tf::Node*, std::function<void (tf::Runtime&, bool)>&) | inline bool Executor::_invoke_runtime_task_impl(
Worker& worker, Node* node, std::function<void(Runtime&, bool)>& work
) {
Runtime rt(*this, worker, node);
// first time
if((node->_nstate & NSTATE::PREEMPTED) == 0) {
_observer_prologue(worker, node);
TF_EXECUTOR_EXCEPTION_HANDLER(worker, node, {
... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x20(%rsp), %rdi
callq 0x1b2f0
movq 0x48(%rsp), %rax
movl (%rax), %eax
andl $0x20000000, %eax # imm = 0x20000000
cmpl... | /taskflow[P]taskflow/taskflow/core/runtime.hpp |
tf::get_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline std::string get_env(const std::string& str) {
#ifdef _MSC_VER
char *ptr = nullptr;
size_t len = 0;
if(_dupenv_s(&ptr, &len, str.c_str()) == 0 && ptr != nullptr) {
std::string res(ptr, len);
std::free(ptr);
return res;
}
return "";
#else
auto ptr = std::getenv(str.c_str());
return ptr ... | subq $0x58, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x5130
movq %rax, %rdi
callq 0x5430
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x22016
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x22024
leaq 0x177b1(%rip), %rax... | /taskflow[P]taskflow/taskflow/core/../utility/os.hpp |
tf::to_string(tf::TaskType) | inline const char* to_string(TaskType type) {
const char* val;
switch(type) {
case TaskType::PLACEHOLDER: val = "placeholder"; break;
case TaskType::STATIC: val = "static"; break;
case TaskType::RUNTIME: val = "runtime"; break;
case TaskType::SUBFLOW: ... | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x6, %rax
ja 0x2550a
movq -0x18(%rsp), %rax
leaq 0x13e3d(%rip), %rcx # 0x392dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x141d8(%rip), %rax # 0x39687
movq %rax, -0x10(%rsp)
jmp 0x25516
leaq 0x141d6(%rip), %rax # 0x396... | /taskflow[P]taskflow/taskflow/core/task.hpp |
tf::Executor::wait_for_all() | inline void Executor::wait_for_all() {
#if __cplusplus >= TF_CPP20
size_t n = _num_topologies.load(std::memory_order_acquire);
while(n != 0) {
_num_topologies.wait(n, std::memory_order_acquire);
n = _num_topologies.load(std::memory_order_acquire);
}
#else
std::unique_lock<std::mutex> lock(_topology_mute... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x90, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x13000
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x60, %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
callq 0x362d0
jmp 0x3611b
leaq 0x30(%rsp), ... | /taskflow[P]taskflow/taskflow/core/executor.hpp |
show_options | static void show_options(char** argv) {
fprintf(stderr, "Source to source compiler from NMODL to C\n");
fprintf(stderr, "Usage: %s [options] Inputfile\n", argv[0]);
fprintf(stderr, "Options:\n");
fprintf(stderr, "\t-o | --outdir <OUTPUT_DIRECTORY> directory where output files will be written\n");
fprintf(s... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x3470f(%rip), %r15 # 0x37ff8
movq (%r15), %rcx
leaq 0x2447c(%rip), %rdi # 0x27d6f
pushq $0x2a
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x3280
movq (%r15), %rdi
movq (%r14), %rdx
leaq 0x2448c(%rip), %rsi # 0x27d9a
xorl %eax, %eax
callq 0x31b0... | /BlueBrain[P]mod2c/src/mod2c_core/modl.c |
current_line | char* current_line() { /* assumes we actually want the previous line */
static char buf[NRN_BUFSIZE];
char* p;
sprintf(buf,"at line %d in file %s:\\n%s", linenum-1, finname,
inlinebuf[whichbuf?0:1]+30);
for (p = buf; *p; ++p) {
if (*p == '\n') {
*p = '\0';
}
if (*p == '"') {
*p = '\047';
}
}
retur... | pushq %rbx
movl 0x33543(%rip), %edx # 0x382a0
decl %edx
leaq 0x398e2(%rip), %rax # 0x3e648
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x0, 0x33536(%rip) # 0x382a8
sete %al
shll $0xd, %eax
leaq 0x33531(%rip), %rsi # 0x382b0
leaq (%rax,%rsi), %r8
addq $0x1e, %r8
leaq 0x37522(%rip), %rbx # 0x3c2b0
leaq 0x... | /BlueBrain[P]mod2c/src/mod2c_core/io.c |
diag | void diag(s1, s2)
char *s1, *s2;
{
char *cp;
Fprintf(stderr, "%s", s1);
if (s2) {
Fprintf(stderr, "%s", s2);
}
if (fin) {
Fprintf(stderr, " at line %d in file %s\n", linenum, finname);
Fprintf(stderr, "%s", inlinep);
if (ctp >= inlinep) {
for (cp = inlinep; cp < ctp - 1; cp++) {
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x33222(%rip), %r14 # 0x37ff8
movq (%r14), %rsi
callq 0x3150
testq %rbx, %rbx
je 0x4dee
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3150
leaq 0x3986b(%rip), %rax # 0x3e660
cmpq $0x0, (%rax)
je 0x4e81
movq (%r14), %rdi
movl 0x33498(%rip), %edx # 0x382a0
lea... | /BlueBrain[P]mod2c/src/mod2c_core/io.c |
set_suffix | void set_suffix() {
for (modbase = modprefix + strlen(modprefix); modbase != modprefix;
modbase--) {
if (*modbase == '\\' || *modbase == '/') {
modbase++;
break;
}
}
if (!mechname) {
sprintf(suffix,"_%s", modbase);
mechname = modbase;
} else if (strcmp(mechname, "nothing") == 0) {
vectorize = 0... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x38e49(%rip), %rax # 0x3e658
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x30f0
testq %rax, %rax
je 0x583c
movzbl (%rbx,%rax), %ecx
cmpl $0x5c, %ecx
je 0x5834
cmpl $0x2f, %ecx
je 0x5834
decq %rax
jne 0x581f
jmp 0x583f
addq %rax, %rbx
incq %rbx
jmp 0x583f
addq %rax, %rbx
movq %rbx,... | /BlueBrain[P]mod2c/src/mod2c_core/nocpout.c |
nrn_list | void nrn_list(q1, q2)
Item *q1, *q2;
{
List **plist = (List **)0;
Item *q;
switch (SYM(q1)->type) {
case RANGE:
plist = (List **)0;
for (q = q1->next; q != q2->next; q = q->next) {
SYM(q)->nrntype |= NRNRANGE;
}
break;
case SUFFIX:
plist = (List **)0;
mechname = SYM(q2)->name;
if (strcmp(SYM(q... | pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
movzwl (%rax), %ecx
addl $0xfffffea9, %ecx # imm = 0xFFFFFEA9
cmpl $0x10, %ecx
ja 0xa334
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x151a9(%rip), %rdx # 0x1f364
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rcx
movq 0x48(%rcx), %rcx
mov... | /BlueBrain[P]mod2c/src/mod2c_core/nocpout.c |
item2str | char* item2str(Item* q, char* cp) {
if (q->itemtype == SYMBOL) {
sprintf(cp, " %s", SYM(q)->name);
} else if (q->itemtype == VERBATIM) {
sprintf(cp, "%s", STR(q));
} else if (q->itemtype == ITEM) {
item2str(ITM(q), cp);
}else {
sprintf(cp, " %s", STR(q));
}
return cp + strlen(cp);
} | pushq %rbx
movq %rsi, %rbx
movzwl (%rdi), %eax
movq 0x8(%rdi), %rdx
cmpl $0x102, %eax # imm = 0x102
je 0xc06f
cmpl $0x2, %eax
je 0xc062
cmpl $0x1, %eax
jne 0xc04f
movq 0x48(%rdx), %rdx
leaq 0x21278(%rip), %rsi # 0x2d2ce
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3260
jmp 0xc07a
movq %rdx, %rdi
movq %rbx, %r... | /BlueBrain[P]mod2c/src/mod2c_core/nocpout.c |
solvequeue | void solvequeue(q1, q2, blocktype, qerr) /*solve NAME=q1 [using METHOD=q2]*/
/* q2 = 0 means method wasn't there */
/* qerr in ITEM0 or else the closing
brace of an IFERROR stmt */
Item *q1, *q2, *qerr;
int blocktype;
{
/* the solvq list is organized in groups of an item element
followed by the metho... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x31b17(%rip) # 0x3e530
jne 0xca29
xorl %eax, %eax
callq 0x5260
movq %rax, 0x31b07(%rip) # 0x3e530
cmpl $0x130, %ebp # imm = 0x130
jne 0xca9d
l... | /BlueBrain[P]mod2c/src/mod2c_core/solve.c |
main | int main(int argc, char** argv) {
int option = -1;
int option_index = 0;
char* output_dir = NULL;
if (argc < 2) {
show_options(argv);
exit(1);
}
while ( (option = getopt_long (argc, argv, ":vho:", long_options, &option_index)) != -1) {
switch (option) {
case 'v':
printf("... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4018, %rsp # imm = 0x4018
movq %rsi, %r14
movl $0x0, 0x4(%rsp)
cmpl $0x2, %edi
jl 0x106e4
movl %edi, %ebp
movq $0x0, 0x8(%rsp)
leaq 0x17712(%rip), %r15 # 0x27c1a
leaq 0x27ca1(%rip), %r12 # 0x381b0
leaq 0x4(%rsp), %r13
movq 0x27a... | /BlueBrain[P]mod2c/src/mod2c_core/modl.c |
explicit_decl | void explicit_decl(int level, Item* q)
{
/* used to be inside parse1.y without the lastvars condition
Without the condition it served two purposes.
1) variables explicitly declared were so marked so that they
would appear first in the .var file. Unmarked variables
appear last.
2) Give error ... | pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x8(%rsi), %rbx
movl 0x34(%rbx), %eax
testl %edi, %edi
jne 0x1072c
testb $0x1, %al
je 0x10729
movq 0x48(%rbx), %rsi
leaq 0x177f7(%rip), %rdi # 0x27f16
xorl %eax, %eax
callq 0x4dc8
movl 0x34(%rbx), %eax
orl $0x1, %eax
orl $0x8, %eax
movl %eax, 0x34(%rbx)
movswl 0... | /BlueBrain[P]mod2c/src/mod2c_core/parsact.c |
parminstall | void parminstall(n, num, units, limits)
Symbol *n;
char *num, *units, *limits;
{
char buf[NRN_BUFSIZE];
previous_subtype = n->subtype;
previous_str = n->u.str;
if (n->u.str == (char *) 0)
Lappendsym(syminorder, n);
n->subtype |= PARM;
Sprintf(buf, "\n%s\n%s\n%s\n", num, units, limits);
n-... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2000, %rsp # imm = 0x2000
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, 0x2dd9e(%rip) # 0x3e670
movq 0x28(%rdi), %rcx
movq %rcx, 0x2dd8b(%rip) # 0x3e668
testq %rcx, %rcx
jne 0x108fa
leaq 0x... | /BlueBrain[P]mod2c/src/mod2c_core/parsact.c |
ifnew_parminstall | void parminstall(n, num, units, limits)
Symbol *n;
char *num, *units, *limits;
{
char buf[NRN_BUFSIZE];
previous_subtype = n->subtype;
previous_str = n->u.str;
if (n->u.str == (char *) 0)
Lappendsym(syminorder, n);
n->subtype |= PARM;
Sprintf(buf, "\n%s\n%s\n%s\n", num, units, limits);
n-... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %eax, %eax
callq 0x13700
movq %rax, %rbx
testq %rax, %rax
jne 0x10987
movq %r13, %rdi
movl $0x13e, %esi # imm = 0x13E
xorl %eax, %eax
callq 0x137c2
movq %rax, %rbx
movq %rax, %rdi
movq ... | /BlueBrain[P]mod2c/src/mod2c_core/parsact.c |
add_reset_args | void add_reset_args(q)
Item *q;
{
static int reset_fun_cnt=0;
reset_fun_cnt++;
Sprintf(buf, "&_reset, &_freset%d,", reset_fun_cnt);
Insertstr(q->next, buf);
Sprintf(buf, "static double _freset%d;\n", reset_fun_cnt);
Lappendstr(firstlist, buf);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2d40c(%rip), %edx # 0x3e6ac
incl %edx
movl %edx, 0x2d404(%rip) # 0x3e6ac
leaq 0x2da11(%rip), %r14 # 0x3ecc0
leaq 0x16fa9(%rip), %rsi # 0x2825f
movq %r14, %rdi
xorl %eax, %eax
callq 0x3260
movq 0x10(%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq ... | /BlueBrain[P]mod2c/src/mod2c_core/parsact.c |
hocfunchack | void hocfunchack(Symbol* n, Item* qpar1, Item* qpar2, int hack)
{
#if NOCMODL
extern int point_process;
#endif
Item *q;
int i;
#if VECTORIZE
Item* qp=0;
#endif
#if BBCORE
Lappendstr(procfunc, "\n#if 0 /*BBCORE*/\n");
#endif
if (point_process) {
Sprintf(buf, "\nstatic double _hoc_%s(void* _vptr) {\n double _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdi, %r14
leaq 0x2e86d(%rip), %r15 # 0x40cd8
movq (%r15), %rdi
leaq 0xe6aa(%rip), %rsi # 0x20b1f
xorl %eax, %eax
callq 0x5423
leaq 0x2bf0d(%rip), %r13 # 0x3e390
cmpl $0x0, (%r13)
movq 0x48(%r14), %rdx
l... | /BlueBrain[P]mod2c/src/mod2c_core/parsact.c |
acc_net_add | void acc_net_add(Item* qname, Item* qpar1, Item* qexpr, Item* qpar2, const char* xarg1, const char* xarg2) {
Item *q;
if (artificial_cell) { return; }
sprintf(buf, "\
\n#if NET_RECEIVE_BUFFERING\
\n _net_send_buffering(_ml->_net_send_buffer, %s\
", xarg1);
Insertstr(qname, buf);
for (q = qpar1->next; q != ... | leaq 0x2bca0(%rip), %rax # 0x3e380
cmpl $0x0, (%rax)
je 0x126e6
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %rcx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x2c5be(%rip), %r13 # 0x3ecc0
leaq 0x167a6(%rip), %rsi # 0x28eaf
movq %r13, %rdi
movq %r8, %rdx
xorl %eax, %eax
call... | /BlueBrain[P]mod2c/src/mod2c_core/parsact.c |
matchmassage | void matchmassage(nderiv)
int nderiv;
{
int count, nunknown, j;
Item *q, *q1, *setup;
Symbol *s;
List *tmatch, *vmatch;
char *imatch;
matchused = 0;
/* we have a list of states at which the initial values are known
and a list of information about state(time) = match with implicit loop
index if array.
chec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edi, %r12d
movb $0x0, 0x29c2d(%rip) # 0x3ebfc
movq 0x29c2a(%rip), %rax # 0x3ec00
movq 0x10(%rax), %r14
cmpq %rax, %r14
je 0x15044
leaq 0x15456(%rip), %rbx # 0x2a43c
xorl %ebp, %ebp
movq 0x8(%r14), %r15
movq 0x29bb5(%rip... | /BlueBrain[P]mod2c/src/mod2c_core/deriv.c |
init | void init()
{
int i;
Symbol *s;
symbol_init();
for (i = 0; keywords[i].name; i++) {
s = install(keywords[i].name, keywords[i].kval);
s->subtype = KEYWORD;
}
for (i = 0; methods[i].name; i++) {
s = install(methods[i].name, METHOD);
s->subtype = methods[i].subtype;
s->u.i = methods[i]... | pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x136c4
leaq 0x1527a(%rip), %rdi # 0x2ac08
movl $0x10, %ebx
leaq 0x217c6(%rip), %r14 # 0x37160
movswl -0x8(%rbx,%r14), %esi
xorl %eax, %eax
callq 0x137c2
movq $0x1, 0x8(%rax)
movq (%rbx,%r14), %rdi
addq $0x10, %rbx
cmpq $0x5c0, %rbx # imm = 0x5C0... | /BlueBrain[P]mod2c/src/mod2c_core/init.c |
massage_linblk | void massage_linblk(q1, q2, q3, q4, sensused) /* LINEAR NAME stmtlist '}' */
Item *q1, *q2, *q3, *q4;
int sensused;
{
Item *qs;
Symbol *s;
int i;
#if LINT
assert(q2);
#endif
if (++nlineq == 0) {
diag(linblk->name, " has no equations");
}
Sprintf(buf, "static void %s();\n", SYM(q2)->name);
Linsertstr(procfu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
incl 0x20a86(%rip) # 0x38278
jne 0x1780d
movq 0x29525(%rip), %rax # 0x40d20
movq 0x48(%rax), %rdi
leaq 0x151d1(%rip), %rsi # 0x2c9d7
... | /BlueBrain[P]mod2c/src/mod2c_core/simultan.c |
TestPicker::~TestPicker() | Q_OBJECT
private slots:
void initTestCase()
{
m_data.append( QStringLiteral( "English" ) );
m_data.append( QStringLiteral( "Russian" ) );
m_data.append( QStringLiteral( "German" ) );
m_data.append( QStringLiteral( "Spanish" ) );
m_data.append( QStringLiteral( "Portuguese" ) );
m_data.append( ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x47a3e(%rip), %rax # 0x992a8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
callq 0x4e340
leaq 0x38(%rbx), %r14
movq 0x4d68b(%rip), %rax # 0x9ef10
addq $0x10, %rax
movq %rax, 0x38(%rbx)
leaq 0x48(%rbx), %rdi
callq 0x51904
movq %r14, %rdi
callq 0x4e860
... | /igormironchik[P]qtmwidgets/tests/auto/picker/main.cpp |
QtMWidgets::AbstractListViewBase::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::AbstractListViewBase::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<AbstractListViewBase *>(_o);
(void)_t;
switch (_id) {
case 0: _t->rowTouched((*reinterpret_cast< std::a... | pushq %rbx
subq $0x20, %rsp
cmpl $0x5, %esi
ja 0x54b4a
movl %esi, %eax
leaq 0x2a079(%rip), %rsi # 0x7ea44
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
cmpl $0x8, %edx
ja 0x54b4a
movl %edx, %eax
leaq 0x2a076(%rip), %rdx # 0x7ea5c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%rcx), %rax... | /igormironchik[P]qtmwidgets/build_O3/src/QtMWidgets_autogen/EWIEGA46WW/moc_abstractlistview.cpp |
QtMWidgets::MessageBox::qt_metacall(QMetaObject::Call, int, void**) | int QtMWidgets::MessageBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDialog::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
} else if (_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x4ea70
movl %eax, %ebx
testl %eax, %eax
js 0x5579b
cmpl $0x8, %ebp
ja 0x5579b
movl $0x14e, %eax # imm = 0x14E
btl %ebp, %eax
jae 0x557a8
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r14, %rc... | /igormironchik[P]qtmwidgets/build_O3/src/QtMWidgets_autogen/EWIEGA46WW/moc_messagebox.cpp |
QtMWidgets::TableViewSection::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::TableViewSection::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
auto *_t = static_cast<TableViewSection *>(_o);
(void)_t;
void *_v = _a[0];
switch (_id) {
case 0: *... | cmpl $0x2, %esi
je 0x5771f
cmpl $0x1, %esi
jne 0x57723
testl %edx, %edx
jne 0x57723
pushq %rbx
movq (%rcx), %rbx
callq 0x66232
movb %al, (%rbx)
popq %rbx
retq
testl %edx, %edx
je 0x57724
retq
movq (%rcx), %rax
movzbl (%rax), %esi
jmp 0x6623a
nop
| /igormironchik[P]qtmwidgets/build_O3/src/QtMWidgets_autogen/EWIEGA46WW/moc_tableview.cpp |
QtMWidgets::TimePicker::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QtMWidgets::TimePicker::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
#ifndef QT_NO_PROPERTIES
if (_c == QMetaObject::ReadProperty) {
auto *_t = static_cast<TimePicker *>(_o);
(void)_t;
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_... | cmpl $0x2, %esi
je 0x57ad3
cmpl $0x1, %esi
jne 0x57ad7
testl %edx, %edx
jne 0x57ad7
pushq %rbx
movq (%rcx), %rbx
callq 0x616b4
movl %eax, (%rbx)
popq %rbx
retq
testl %edx, %edx
je 0x57ad8
retq
movq (%rcx), %rsi
jmp 0x61268
| /igormironchik[P]qtmwidgets/build_O3/src/QtMWidgets_autogen/EWIEGA46WW/moc_timepicker.cpp |
QtMWidgets::ProgressBarPrivate::repaintRequired() const | bool
ProgressBarPrivate::repaintRequired() const
{
if( value == lastPaintedValue )
return false;
const int valueDifference = qAbs( value - lastPaintedValue );
const int grooveBlock = ( orientation == Qt::Horizontal ? grooveRect().width() :
grooveRect().height() );
// This expression is basically
... | movl 0x10(%rdi), %eax
subl 0x14(%rdi), %eax
jne 0x5a51d
xorl %eax, %eax
retq
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, 0x18(%rdi)
setne %al
movq (%rdi), %rdx
movq 0x20(%rdx), %rdx
movl 0x1c(%rdx,%rax,4), %esi
subl 0x14(%rdx,%rax,4), %esi
incl %esi
imull %ecx, %esi
movl 0xc(%rdi), %eax
subl ... | /igormironchik[P]qtmwidgets/src/progressbar.cpp |
QtMWidgets::AbstractScrollArea::_q_kineticScrollingFinished() | void
AbstractScrollArea::_q_kineticScrollingFinished()
{
if( d->horIndicator->needPaint || d->vertIndicator->needPaint )
{
if( d->horIndicator->policy == ScrollIndicatorAsNeeded ||
d->vertIndicator->policy == ScrollIndicatorAsNeeded )
d->animateScrollIndicators();
}
d->animateHiddingBlurEffect()... | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq 0x58(%rdi), %rax
cmpb $0x0, 0x44(%rax)
jne 0x5d8b6
movq 0x60(%rdi), %rcx
cmpb $0x1, 0x44(%rcx)
jne 0x5d8cf
cmpl $0x0, 0x28(%rax)
je 0x5d8c6
movq 0x60(%rdi), %rax
cmpl $0x0, 0x28(%rax)
jne 0x5d8cf
callq 0x5d188
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0x5d058
nop
| /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::AbstractScrollArea::resizeEvent(QResizeEvent*) | void
AbstractScrollArea::resizeEvent( QResizeEvent * e )
{
QStyleOption opt;
opt.initFrom( this );
d->layoutChildren( opt );
d->normalizePosition();
d->calcIndicators();
update();
e->accept();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4eca0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4d170
movq 0x28(%r14), %rdi
movq %rsp, %rsi
callq 0x5c724
movq 0x28(%r14), %rdi
callq 0x5c85a
movq 0x28(%r14), %rdi
call... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
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.