name string | code string | asm string | file string |
|---|---|---|---|
N_VWrmsNormMaskVectorArray_ManyVector | SUNErrCode MVAPPEND(N_VWrmsNormMaskVectorArray)(int nvec, N_Vector* X,
N_Vector* W, N_Vector id,
sunrealtype* nrm)
{
SUNFunctionBegin(X[0]->sunctx);
sunindextype i;
SUNAssert(nvec > 0, SUN_ERR_ARG_OUTOFRANGE);
/* ... | subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x44(%rsp), %rcx
cmpq %rcx, %rax
jge 0x4eea
movq 0x38(%rsp)... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VWSqrSumLocal_ManyVector | sunrealtype MVAPPEND(N_VWSqrSumLocal)(N_Vector x, N_Vector w)
{
SUNFunctionBegin(x->sunctx);
sunindextype i, N;
sunrealtype sum, contrib;
#ifdef MANYVECTOR_BUILD_WITH_MPI
int rank;
#endif
/* initialize output*/
sum = ZERO;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
#ifdef MANYVECTOR_BUILD_WITH_... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x507f
movq 0x30(%rsp), %rax
movq (%rax), %ra... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
N_VWSqrSumMaskLocal_ManyVector | sunrealtype MVAPPEND(N_VWSqrSumMaskLocal)(N_Vector x, N_Vector w, N_Vector id)
{
SUNFunctionBegin(x->sunctx);
sunindextype i, N;
sunrealtype sum, contrib;
#ifdef MANYVECTOR_BUILD_WITH_MPI
int rank;
#endif
/* initialize output*/
sum = ZERO;
for (i = 0; i < MANYVECTOR_NUM_SUBVECS(x); i++)
{
#ifdef MANYV... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x517c
movq 0x40(%rsp)... | /opencor[P]sundials/src/nvector/manyvector/nvector_manyvector.c |
shm::open(char const (&) [24]) | void*
shm::open( const shm_key_t &key )
{
/**
* just like with init, use same output
* pointer stack location for both.
*/
void *out( nullptr );
auto handle_open_failure = [&]( const shm_key_t &key ) -> void*
{
#if USE_CPP_EXCEPTIONS==1
std::stringstream ss;
ss <<
... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x42, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %edx
movl $0x42, %esi
callq 0x2340
movl %eax, -0x20(%rbp)
cmpl $-0x... | /RaftLib[P]shm/lib/shm.cpp |
shm::close(char const (&) [24], void**, unsigned long, bool, bool) | bool
shm::close( const shm_key_t &key,
void **ptr,
const std::size_t nbytes,
const bool zero,
const bool unlink )
{
if( zero && (ptr != nullptr) && ( *ptr != nullptr ) )
{
std::memset( *ptr, 0x0, nbytes );
}
#if _USE_POSIX_SHM_ == 1
if( ptr != nullptr )
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
testb $0x1, -0x19(%rbp)
je 0x3c3e
cmpq $0x0, -0x10(%rbp)
je 0x3c3e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3c3e
m... | /RaftLib[P]shm/lib/shm.cpp |
JsStandardConstruct | void JsStandardConstruct(struct JsObject *self, struct JsObject *thisobj,
int argc, struct JsValue **argv, struct JsValue *res){
struct JsObject* this0 = JsCreateStandardObject(NULL);
struct JsValue res0;
//获得构造函数的prototype属性
(*self->Get)(self,"prototype",NULL,&res0);
if(res0.type == JS_OBJECT)
th... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movl %edx, %r12d
movq %rdi, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4c2a
movq %rax, %r13
leaq 0xf501(%rip), %rsi # 0x15045
leaq -0x48(%rbp), ... | /solq360[P]js-engine/libjs/core/JsObject.c |
ShiftExpression_rshift_eval | static void
ShiftExpression_rshift_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstBinaryNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstBinaryNode *n = CAST_NODE(na, JsAstBinaryNode);
struct JsValue r1, r2, r3, r4;
EVAL(n->a, context, &r1);
JsGetValue( &r1, &r2);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl (%rdi), %eax
leaq 0x15f4f(%rip), %rcx # 0x1cad0
leaq -0x88(%rbp), %r12
movq %r12, %rdx
callq *(%rcx,%rax,8)
leaq -0x70(%rbp), %r13
movq %r12, ... | /solq360[P]js-engine/libjs/eval/JsEval.c |
RelationalExpression_le_eval | static void
RelationalExpression_le_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstBinaryNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstBinaryNode *n = CAST_NODE(na, JsAstBinaryNode);
struct JsValue r1, r2, r3, r4, r5;
EVAL(n->a, context, &r1);
JsGetValue( &... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl (%rdi), %eax
leaq 0x15cd6(%rip), %r13 # 0x1cad0
leaq -0xa0(%rbp), %r12
movq %r12, %rdx
callq *(%r13,%rax,8)
leaq -0x88(%rbp), %rsi
movq %r12, ... | /solq360[P]js-engine/libjs/eval/JsEval.c |
EqualityExpression_eq_eval | static void
EqualityExpression_eq_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstBinaryNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstBinaryNode *n = CAST_NODE(na, JsAstBinaryNode);
struct JsValue r1, r2, r3, r4;
EVAL(n->a, context, &r1);
JsGetValue( &r1, &r2);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl (%rdi), %eax
leaq 0x15a3a(%rip), %rbx # 0x1cad0
leaq -0x90(%rbp), %r12
movq %r12, %rdx
callq *(%rbx,%rax,8)
leaq -0x78(%rbp), %r13
movq... | /solq360[P]js-engine/libjs/eval/JsEval.c |
LogicalORExpression_eval | static void
LogicalORExpression_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstBinaryNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstBinaryNode *n = CAST_NODE(na, JsAstBinaryNode);
struct JsValue r1, r3, r5;
EVAL(n->a, context, &r1);
JsGetValue( &r1, res);
JsToBo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl (%rdi), %eax
leaq 0x1558f(%rip), %r13 # 0x1cad0
leaq -0x70(%rbp), %r12
movq %r12, %rdx
callq *(%r13,%rax,8)
movq %r12, %rdi
movq %rbx, %rsi
ca... | /solq360[P]js-engine/libjs/eval/JsEval.c |
AssignmentExpression_modeq_eval | static void
AssignmentExpression_modeq_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstAssignmentExpressionNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstAssignmentExpressionNode *n =
CAST_NODE(na, JsAstAssignmentExpressionNode);
struct JsValue r1, r2, r3, r4, v0;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%rdi), %rdi
movl (%rdi), %eax
leaq 0x15276(%rip), %rcx # 0x1cad0
leaq -0xa0(%rbp), %r14
movq %r14, %rdx
callq *(%rcx,%rax,8)
leaq -0x88(%rbp), %r13
movq %r14, ... | /solq360[P]js-engine/libjs/eval/JsEval.c |
AssignmentExpression_lshifteq_eval | static void
AssignmentExpression_lshifteq_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstAssignmentExpressionNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstAssignmentExpressionNode *n =
CAST_NODE(na, JsAstAssignmentExpressionNode);
struct JsValue r1, r2,v0;
EVAL... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
movl (%rdi), %eax
leaq 0x15075(%rip), %rcx # 0x1cad0
leaq -0x70(%rbp), %r12
movq %r12, %rdx
callq *(%rcx,%rax,8)
leaq -0x58(%rbp), %r13
movq %r12, ... | /solq360[P]js-engine/libjs/eval/JsEval.c |
ExpressionStatement_eval | static void
ExpressionStatement_eval(na, context, res)
struct JsAstNode *na; /* (struct JsAstUnaryNode) */
struct JsContext *context;
struct JsValue *res;
{
struct JsAstUnaryNode *n = CAST_NODE(na, JsAstUnaryNode);
struct JsValue r1;
struct JsValue *v = (struct JsValue*)JsMalloc(sizeof(struct JsValue));
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x18, %edi
callq 0xfd41
movq %rax, %r14
movq 0x8(%r12), %rax
movq %rax, 0x18(%r15)
xorl %eax, %eax
callq 0x108df
cmpl $0x1, 0x4(%rax)
jne 0x8110
xorl %eax, %eax
callq 0x108df
cmp... | /solq360[P]js-engine/libjs/eval/JsEval.c |
SyncBlockcStatement_eval | static void SyncBlockcStatement_eval(struct JsAstNode *na,
struct JsContext *context, struct JsValue *res){
struct JsAstSyncBlockStatementNode *n = CAST_NODE(na, JsAstSyncBlockStatementNode);
TRACE(na->location, context, JS_TRACE_STATEMENT);
struct JsObject* lockObj = NULL;
struct JsValue* e =... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rax, 0x18(%rsi)
xorl %eax, %eax
callq 0x108df
cmpl $0x1, 0x4(%rax)
jne 0x93bf
xorl %eax, %eax
callq 0x108df
cmpq $0x0, 0x8(%rax)
je 0x93bf
xorl %e... | /solq360[P]js-engine/libjs/eval/JsEval.c |
JsCreateEngine | struct JsEngine* JsCreateEngine(){
struct JsVm* vm = JsGetVm();
struct JsEngine* e = (struct JsEngine*)JsMalloc(sizeof(struct JsEngine));
e->vm = vm;
JsEngine2Vm(e);
e->state = JS_ENGINE_KERNEL;
e->exec = NULL;
e->waits = JsCreateList();
e->pools = JsCreateList();
e->lock = JsCreateLock();
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
callq 0x108df
movq %rax, %rbx
movl $0x30, %edi
callq 0xfd41
movq %rax, %r14
movq %rbx, (%rax)
movq %rax, %rdi
callq 0x10882
movl $0x2, 0x8(%r14)
movq $0x0, 0x10(%r14)
xorl %eax, %eax
callq 0xff58
movq %rax, 0x18(%r14)
xorl %eax, %eax
callq 0xff58
movq %ra... | /solq360[P]js-engine/libjs/vm/JsEngine.c |
JsNumberInit | void JsNumberInit(struct JsVm* vm){
struct JsObject* number = JsCreateStandardFunctionObject(NULL,NULL,TRUE);
struct JsObject* number_proto = JsCreateNumberObject(NULL,0);
JsNumberFunctionInit(number,number_proto);
JsNumberProtoInit(number,number_proto);
struct JsValue* v = (struct JsValue*)JsMalloc(sizeof(str... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4e1d
movq %rax, %r14
xorps %xmm0, %xmm0
xorl %edi, %edi
callq 0x10d0a
movq %rax, %r15
leaq 0x1c1(%rip), %rax # 0x10d6f
movq %rax, 0x68(%r14)
leaq 0x1... | /solq360[P]js-engine/libjs/init/JsNumber.c |
JsObjectProtoHasOwnPropertyCall | static void JsObjectProtoHasOwnPropertyCall(struct JsObject *obj, struct JsObject *thisobj,
int argc, struct JsValue **argv, struct JsValue *res){
struct JsValue v;
char* prop = "undefined";
if(argc >0 ){
JsToString(argv[0],&v);
(*thisobj->HasOwnProperty)(thisobj,v.u.string,res);
prop = v.u.string... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rsi, %r14
testl %edx, %edx
jle 0x113a7
movq (%rcx), %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x12007
movq 0x8(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq *0x50(%r14)
movq 0x8(%r15), %rsi
jmp 0x113ae
leaq 0x3... | /solq360[P]js-engine/libjs/init/JsOF.c |
JsObjectProtoIsPrototypeOfCall | static void JsObjectProtoIsPrototypeOfCall(struct JsObject *obj, struct JsObject *thisobj,
int argc, struct JsValue **argv, struct JsValue *res){
struct JsObject* prototype;
res->type = JS_BOOLEAN;
if(argc <= 0){
res->u.boolean = FALSE;
return;
}
if(argv[0]->type != JS_OBJECT){
res->type = JS_... | movl $0x2, (%r8)
xorl %eax, %eax
testl %edx, %edx
jle 0x113f3
pushq %rbp
movq %rsp, %rbp
movq (%rcx), %rcx
cmpl $0x5, (%rcx)
jne 0x113f2
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x113f2
cmpq %rsi, %rcx
jne 0x113e0
movl $0x1, %eax
popq %rbp
movl %eax, 0x8(%r8)
retq
| /solq360[P]js-engine/libjs/init/JsOF.c |
JsToNumber | void JsToNumber(struct JsValue *val, struct JsValue *res){
res->type = JS_NUMBER;
switch (val->type) {
case JS_UNDEFINED:
res->u.number = JS_VALUE_NUMBER_NAN;
break;
case JS_NULL:
res->u.number = 0.0;
break;
case JS_BOOLEAN:
res->u.number = (val->u.boolean ? 1.0 : 0.0);
break;
case JS... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x3, (%rsi)
movl (%rdi), %eax
cmpq $0x5, %rax
ja 0x11f0c
movq %rsi, %rbx
leaq 0x462e(%rip), %rcx # 0x164a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, 0x8(%rbx)
... | /solq360[P]js-engine/libjs/core/JsValue.c |
JsToUint32 | unsigned int JsToUint32(struct JsValue *val){
struct JsValue i;
JsToInteger(val, &i);
if (val->type != JS_NUMBER || isnan(i.u.number) || i.u.number == 0.0)
return 0;
else {
i.u.number = fmod(i.u.number ,4294967296.0); /* 2^32 */
if (i.u.number < 0)
i.u.number += 4294967296;
return (unsigned i... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rsi
callq 0x11e53
xorl %eax, %eax
cmpl $0x3, (%rbx)
jne 0x11f96
movsd -0x18(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
je 0x11f96
movsd 0x4591(%rip), %xmm1 # 0x164f8
callq 0x4150
movsd 0x4584(%rip), %xmm2 # 0x164... | /solq360[P]js-engine/libjs/core/JsValue.c |
JsToString | void JsToString(struct JsValue *val, struct JsValue *res){
res->type = JS_STRING;
switch (val->type) {
case JS_UNDEFINED:
res->u.string = "undefined";
break;
case JS_NULL:
res->u.string = "null";
break;
case JS_BOOLEAN:{
if(val->u.boolean == TRUE)
res->u.string ="true";
else
res->... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl $0x4, (%rsi)
movl (%rdi), %eax
cmpq $0x5, %rax
ja 0x120d8
movq %rsi, %rbx
leaq 0x4492(%rip), %rcx # 0x164c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x30e2(%rip), %rax # 0x15120
jmp 0x120f3
movq 0x10(%rdi), %rax
movq %rax... | /solq360[P]js-engine/libjs/core/JsValue.c |
JsEqualityExpressionEqCompare | void JsEqualityExpressionEqCompare( struct JsValue *x, struct JsValue *y,
struct JsValue *res){
struct JsValue tmp;
int xtype, ytype;
int hit;
res->type = JS_BOOLEAN;
if (x->type == y->type)
switch (x->type){
case JS_UNDEFINED:
case JS_NULL:
res->u.boolean = TRUE;
return;
case JS_NUMBE... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x2, (%rdx)
movl (%rdi), %eax
movl (%rsi), %ecx
cmpl %ecx, %eax
jne 0x1245c
cmpl $0x5, %eax
ja 0x1244f
movl %eax, %eax
leaq 0x4175(%rip), %rcx # 0x16568
movslq (%rcx,%rax,4)... | /solq360[P]js-engine/libjs/eval/JsCompare.c |
encode_decode_large | int encode_decode_large(struct test_state *state)
{
int status, i;
size_t to;
struct aec_stream *strm = state->strm;
strm->avail_in = state->ibuf_len;
strm->avail_out = state->cbuf_len;
strm->next_in = state->ubuf;
strm->next_out = state->cbuf;
status = aec_encode_init(strm);
if (s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x58(%rdi), %r15
movq %rax, 0x8(%r15)
movq 0x38(%rdi), %rax
movq %rax, 0x20(%r15)
movq 0x10(%rdi), %rax
movq %rax, (%r15)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%r15)
movq %r15, %rdi
callq 0x1050
testl %eax, %eax
je 0x223f
... | /opensatelliteproject[P]libaec/tests/check_aec.c |
SQStringTable::Resize(long long) | void SQStringTable::Resize(SQInteger size)
{
SQInteger oldsize=_numofslots;
SQString **oldtable=_strings;
AllocNodes(size);
for (SQInteger i=0; i<oldsize; i++){
SQString *p = oldtable[i];
while(p){
SQString *next = p->_next;
SQHash h = p->_hash&(_numofslots-1);
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x30(%rsp)
movq (%rdi), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rsi
callq 0x141a0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jge 0x40458
movq 0x28(%rsp), %rax
... | /KatuH[P]squall/build_O0/_deps/squirrel-src/squirrel/sqstate.cpp |
SQTable::Get(SQObjectPtr const&, SQObjectPtr&) | bool SQTable::Get(const SQObjectPtr &key,SQObjectPtr &val)
{
if(sq_type(key) == OT_NULL)
return false;
_HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1));
if (n) {
val = _realval(n->val);
return true;
}
return false;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x1000001, (%rax) # imm = 0x1000001
jne 0x40ef4
movb $0x0, 0x47(%rsp)
jmp 0x40f8b
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x13b60
mov... | /KatuH[P]squall/build_O0/_deps/squirrel-src/squirrel/sqtable.cpp |
SQVM::LeaveFrame() | void SQVM::LeaveFrame() {
SQInteger last_top = _top;
SQInteger last_stackbase = _stackbase;
SQInteger css = --_callsstacksize;
/* First clean out the call stack frame */
ci->_closure.Null();
_stackbase -= ci->_prevstkbase;
_top = _stackbase + ci->_prevtop;
ci = (css) ? &_callsstack[css-... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x50(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0xc8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xc8(%rax)
movq %rcx, 0x18(%rsp)
movq 0x108(%rax), %rdi
addq $0x10, %rdi
callq 0x14ac0
movq 0x10(%r... | /KatuH[P]squall/build_O0/_deps/squirrel-src/squirrel/sqvm.cpp |
SQVM::PLOCAL_INC(long long, SQObjectPtr&, SQObjectPtr&, SQObjectPtr&) | bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
{
SQObjectPtr trg;
_RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
target = a;
a = trg;
return true;
} | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x143c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rcx
movq 0x38(%rsp... | /KatuH[P]squall/build_O0/_deps/squirrel-src/squirrel/sqvm.cpp |
leveldb::CorruptionTest::Check(int, int) | void Check(int min_expected, int max_expected) {
int next_expected = 0;
int missed = 0;
int bad_keys = 0;
int bad_values = 0;
int correct = 0;
std::string value_space;
Iterator* iter = db_->NewIterator(ReadOptions());
for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
uint64_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, 0x48(%rsp)
movl %esi, 0x54(%rsp)
andl $0x0, 0x1c(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl %edx, 0x4c(%rsp)
movl %edx, 0x50(%rsp)
movb $0x0, (%rax)
movq 0x88(%rdi), %rdi
xorps %xmm0, %xmm0
l... | /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_TableFile_Test::TestBody() | TEST_F(CorruptionTest, TableFile) {
Build(100);
DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
dbi->TEST_CompactMemTable();
dbi->TEST_CompactRange(0, nullptr, nullptr);
dbi->TEST_CompactRange(1, nullptr, nullptr);
Corrupt(kTableFile, 100, 1);
Check(90, 99);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x64
popq %rsi
callq 0xe9da
movq 0x88(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12dc2
movq (%r15), %rdi
testq %rdi, %rdi
je 0xb076
callq 0xa810
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x... | /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_TableFileRepair_Test::TestBody() | TEST_F(CorruptionTest, TableFileRepair) {
options_.block_size = 2 * kValueSize; // Limit scope of corruption
options_.paranoid_checks = true;
Reopen();
Build(100);
DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
dbi->TEST_CompactMemTable();
dbi->TEST_CompactRange(0, nullptr, nullptr);
dbi->TEST_CompactRa... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x7d0, 0x60(%rdi) # imm = 0x7D0
movb $0x1, 0x32(%rdi)
callq 0xf3a6
pushq $0x64
popq %rsi
movq %rbx, %rdi
callq 0xe9da
movq 0x88(%rbx), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12dc2
movq (%r15), %rdi
testq %rdi, %rdi
j... | /walterzhaoJR[P]leveldb/db/corruption_test.cc |
testing::internal::ExecDeathTest::AssumeRole() (.cold.1) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
ExecDeathTestArgs args = { argv, close_fd };
pid_t child_pid = -1;
# if GTEST_OS_QNX
// Obtains the current directory and sets it to be closed in the child
// process.
const int cwd_fd = open(".", O_RDONLY);
GTEST_DEATH_TEST_CHECK_(cw... | pushq %rbx
subq $0x10, %rsp
leaq 0x765b4(%rip), %rdi # 0x81b58
callq 0xabe0
testl %eax, %eax
je 0xb5d3
leaq 0xc(%rsp), %rdi
leaq 0xb(%rsp), %rbx
movq %rbx, %rsi
callq 0x4f3e8
movb (%rbx), %al
movb %al, 0x76589(%rip) # 0x81b50
leaq 0x7658a(%rip), %rdi # 0x81b58
callq 0xa3d0
addq $0x10, %rsp
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
leveldb::test::RandomKey[abi:cxx11](leveldb::Random*, int) | std::string RandomKey(Random* rnd, int len) {
// Make sure to generate a wide variety of characters so we
// test the boundary conditions for short-key optimizations.
static const char kTestChars[] = {'\0', '\1', 'a', 'b', 'c',
'd', 'e', '\xfd', '\xfe', '\xff'};
std::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
jle 0xca6b
movl %edx, %ebx
movq %rsi, %r15
movl $0xcccccccd, %r12d # imm = 0xCCCCCCCD
leaq 0x4c60f(%rip), %r13 # 0x59030
movl (%r15), %eax
i... | /walterzhaoJR[P]leveldb/util/testutil.cc |
testing::AssertionResult testing::internal::PredicateFormatterFromMatcher<leveldb::test::IsOKMatcher>::operator()<leveldb::Status>(char const*, leveldb::Status const&) const | AssertionResult operator()(const char* value_text, const T& x) const {
// We convert matcher_ to a Matcher<const T&> *now* instead of
// when the PredicateFormatterFromMatcher object was constructed,
// as matcher_ may be polymorphic (e.g. NotNull()) and we won't
// know which type to instantiate it to ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
movl $0x8, %edi
callq 0xa5c0
movq %rax, %r14
leaq 0x6fcae(%rip), %rax # 0x7f308
movq %rax, (%r14)
movq %r14, 0x8(%rsp)
movl $0x18, %edi
callq 0xa5c0
movq %rax,... | /walterzhaoJR[P]leveldb/third_party/googletest/googlemock/include/gmock/gmock-matchers.h |
leveldb::CorruptionTest::Key(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | Slice Key(int i, std::string* storage) {
char buf[100];
std::snprintf(buf, sizeof(buf), "%016d", i);
storage->assign(buf, strlen(buf));
return Slice(*storage);
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movl %esi, %ecx
leaq 0x49c40(%rip), %rdx # 0x595b3
movq %rsp, %r14
movl $0x64, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0xaa50
movq %r14, %rdi
callq 0xa240
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
movq %rax, %r8
callq 0xaa10
movq (... | /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_Recovery_Test::~CorruptionTest_Recovery_Test() | TEST_F(CorruptionTest, Recovery) {
Build(100);
Check(100, 100);
Corrupt(kLogFile, 19, 1); // WriteBatch tag for first record
Corrupt(kLogFile, log::kBlockSize + 1000, 1); // Somewhere in second block
Reopen();
// The 64 records in the first two log blocks are completely lost.
Check(36, 36);
} | pushq %rbx
movq %rdi, %rbx
callq 0xfa7a
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_TableFileRepair_Test::~CorruptionTest_TableFileRepair_Test() | TEST_F(CorruptionTest, TableFileRepair) {
options_.block_size = 2 * kValueSize; // Limit scope of corruption
options_.paranoid_checks = true;
Reopen();
Build(100);
DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
dbi->TEST_CompactMemTable();
dbi->TEST_CompactRange(0, nullptr, nullptr);
dbi->TEST_CompactRa... | pushq %rbx
movq %rdi, %rbx
callq 0xfa7a
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_TableFileIndexData_Test::~CorruptionTest_TableFileIndexData_Test() | TEST_F(CorruptionTest, TableFileIndexData) {
Build(10000); // Enough to build multiple Tables
DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
dbi->TEST_CompactMemTable();
Corrupt(kTableFile, -2000, 500);
Reopen();
Check(5000, 9999);
} | pushq %rbx
movq %rdi, %rbx
callq 0xfa7a
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_SequenceNumberRecovery_Test::~CorruptionTest_SequenceNumberRecovery_Test() | TEST_F(CorruptionTest, SequenceNumberRecovery) {
ASSERT_LEVELDB_OK(db_->Put(WriteOptions(), "foo", "v1"));
ASSERT_LEVELDB_OK(db_->Put(WriteOptions(), "foo", "v2"));
ASSERT_LEVELDB_OK(db_->Put(WriteOptions(), "foo", "v3"));
ASSERT_LEVELDB_OK(db_->Put(WriteOptions(), "foo", "v4"));
ASSERT_LEVELDB_OK(db_->Put(Wr... | pushq %rbx
movq %rdi, %rbx
callq 0xfa7a
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_CorruptedDescriptor_Test::~CorruptionTest_CorruptedDescriptor_Test() | TEST_F(CorruptionTest, CorruptedDescriptor) {
ASSERT_LEVELDB_OK(db_->Put(WriteOptions(), "foo", "hello"));
DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
dbi->TEST_CompactMemTable();
dbi->TEST_CompactRange(0, nullptr, nullptr);
Corrupt(kDescriptorFile, 0, 1000);
Status s = TryReopen();
ASSERT_TRUE(!s.ok()... | pushq %rbx
movq %rdi, %rbx
callq 0xfa7a
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/corruption_test.cc |
leveldb::CorruptionTest_CompactionInputError_Test::~CorruptionTest_CompactionInputError_Test() | TEST_F(CorruptionTest, CompactionInputError) {
Build(10);
DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
dbi->TEST_CompactMemTable();
const int last = config::kMaxMemCompactLevel;
ASSERT_EQ(1, Property("leveldb.num-files-at-level" + NumberToString(last)));
Corrupt(kTableFile, 100, 1);
Check(5, 9);
// F... | pushq %rbx
movq %rdi, %rbx
callq 0xfa7a
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/corruption_test.cc |
testing::AssertionResult testing::internal::CmpHelperOpFailure<int, int>(char const*, char const*, int const&, int const&, char const*) | AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
const T1& val1, const T2& val2,
const char* op) {
return AssertionFailure()
<< "Expected: (" << expr1 << ") " << op << " (" << expr2
<< "), actual: " << Form... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %rsi, (%r13)
leaq 0x28(%rsp), %r12
movq %rdx, (%r12)
leaq 0x20(%rsp), %rbp
movq %r9, (%rbp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x36cdd
leaq 0x4955d(%... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [5]>(char const (&) [5]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x36908
movq (%r15), %r12
addq $0x10, %r12
movq %r14, %rdi
callq 0xa240
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xa6b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10286
movq (%r15), %rd... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
bool testing::internal::MatchPrintAndExplain<leveldb::Status const, leveldb::Status const&>(leveldb::Status const&, testing::Matcher<leveldb::Status const&> const&, testing::MatchResultListener*) | bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
MatchResultListener* listener) {
if (!listener->IsInterested()) {
// If the listener is not interested, we do not need to construct the
// inner explanation.
return matcher.Matches(value);
}
StringMatchResult... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %r12
movq %rdi, %r15
cmpq $0x0, 0x8(%rdx)
je 0x1074d
movq %rdx, %r14
leaq 0x30(%rsp), %rbx
leaq 0x40(%rsp), %rax
movq %rax, -0x18(%rax)
leaq 0x6ed49(%rip), %r13 # 0x7f3d8
movq %r13, -0x20(%rax)
mo... | /walterzhaoJR[P]leveldb/third_party/googletest/googlemock/include/gmock/gmock-matchers.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [6], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x10b12
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x10bf4
movq %rbx, %rdi
... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
leveldb::DBImpl::~DBImpl() | DBImpl::~DBImpl() {
// Wait for background work to finish.
mutex_.Lock();
shutting_down_.store(true, std::memory_order_release);
while (background_compaction_scheduled_) {
background_work_finished_signal_.Wait();
}
mutex_.Unlock();
if (db_lock_ != nullptr) {
env_->UnlockFile(db_lock_);
}
del... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6e103(%rip), %rax # 0x7f3f8
movq %rax, (%rdi)
leaq 0xc8(%rdi), %r14
movq %r14, %rdi
callq 0xa950
testl %eax, %eax
jne 0x114cc
movb $0x1, 0xf0(%rbx)
cmpb $0x1, 0x218(%rbx)
jne 0x1134d
leaq 0xf8(%rbx), %r15
movq %rsp, %r12
movq 0x128(... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::CompactRange(leveldb::Slice const*, leveldb::Slice const*) | void DBImpl::CompactRange(const Slice* begin, const Slice* end) {
int max_level_with_files = 1;
{
MutexLock l(&mutex_);
Version* base = versions_->current();
for (int level = 1; level < config::kNumLevels; level++) {
if (base->OverlapInLevel(level, begin, end)) {
max_level_with_files = lev... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0xc8, %rdi
movq %rdi, 0x8(%rsp)
callq 0xa950
testl %eax, %eax
jne 0x12dbb
movq 0x228(%r15), %rax
movq 0x168(%rax), %r13
movl $0x1, %ebp
movl $0x1, %r12d
movq %r13, %rdi
movl %ebp, %es... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::TEST_CompactMemTable() | Status DBImpl::TEST_CompactMemTable() {
// nullptr batch means just wait for earlier writes to be done
Status s = Write(WriteOptions(), nullptr);
if (s.ok()) {
// Wait until the compaction completes
MutexLock l(&mutex_);
while (imm_ != nullptr && bg_error_.ok()) {
background_work_finished_signal... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdx
movb $0x0, (%rdx)
movq (%rsi), %rax
xorl %ecx, %ecx
callq *0x20(%rax)
cmpq $0x0, (%rbx)
jne 0x12e80
leaq 0xc8(%r15), %r14
movq %r14, %rdi
callq 0xa950
testl %eax, %eax
jne 0x12e91
cmpq $0x0, 0x138(%r1... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::BackgroundCall() | void DBImpl::BackgroundCall() {
MutexLock l(&mutex_);
assert(background_compaction_scheduled_);
if (shutting_down_.load(std::memory_order_acquire)) {
// No more background work when shutting down.
} else if (!bg_error_.ok()) {
// No more background work after a background error.
} else {
Backgroun... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
movq %rbx, %rdi
callq 0xa950
testl %eax, %eax
jne 0x131f7
cmpb $0x0, 0x218(%r14)
je 0x131fe
movb 0xf0(%r14), %al
testb $0x1, %al
jne 0x131c9
cmpq $0x0, 0x230(%r14)
jne 0x131c9
movq %r14, %rdi
callq 0x1321e
movb $0x0, 0x218(%r14)
movq %r14, %rdi
call... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::DoCompactionWork(leveldb::DBImpl::CompactionState*) | Status DBImpl::DoCompactionWork(CompactionState* compact) {
const uint64_t start_micros = env_->NowMicros();
int64_t imm_micros = 0; // Micros spent doing imm_ compactions
Log(options_.info_log, "Compacting %d@%d + %d@%d files",
compact->compaction->num_input_files(0), compact->compaction->level(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rbx
movq (%r15), %rax
movq 0xc8(%rax), %rdx
subq 0xc0(%rax), %rdx
movq 0x48(%r14), %rdi
shrq $0x3, %rdx
movl (%rax)... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::OpenCompactionOutputFile(leveldb::DBImpl::CompactionState*) | Status DBImpl::OpenCompactionOutputFile(CompactionState* compact) {
assert(compact != nullptr);
assert(compact->builder == nullptr);
uint64_t file_number;
{
mutex_.Lock();
file_number = versions_->NewFileNumber();
pending_outputs_.insert(file_number);
CompactionState::Output out;
out.number ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
testq %rdx, %rdx
je 0x14073
movq %rdx, %r14
cmpq $0x0, 0x30(%rdx)
jne 0x14092
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc8(%rsi), %r12
movq %r12, %rdi
callq 0xa950
testl %eax, %eax
jne 0x140b1
movq 0x228(%r15), %rax
movq 0x48(%rax), %rcx
le... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::InstallCompactionResults(leveldb::DBImpl::CompactionState*) | Status DBImpl::InstallCompactionResults(CompactionState* compact) {
mutex_.AssertHeld();
Log(options_.info_log, "Compacted %d@%d + %d@%d files => %lld bytes",
compact->compaction->num_input_files(0), compact->compaction->level(),
compact->compaction->num_input_files(1), compact->compaction->level() + 1,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x48(%rsi), %rdi
movq (%rdx), %rax
movq 0xc8(%rax), %rdx
subq 0xc0(%rax), %rdx
movq 0x38(%r15), %rsi
shrq $0x3, %rdx
movl (%rax), %ecx
movq 0xe0(%rax), %r8
subq 0xd8(%rax), %r8
s... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::(anonymous namespace)::CleanupIteratorState(void*, void*) | static void CleanupIteratorState(void* arg1, void* arg2) {
IterState* state = reinterpret_cast<IterState*>(arg1);
state->mu->Lock();
state->mem->Unref();
if (state->imm != nullptr) state->imm->Unref();
state->version->Unref();
state->mu->Unlock();
delete state;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa950
testl %eax, %eax
jne 0x14604
movq 0x10(%rbx), %rdi
callq 0x15db4
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x145ea
callq 0x15db4
movq 0x8(%rbx), %rdi
callq 0x1e3a4
movq (%rbx), %rdi
callq 0xa4a0
movq %rbx, %rdi
popq %rbx
jmp 0xa570
movl %eax, %edi
callq 0xa3f0
n... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::Get(leveldb::ReadOptions const&, leveldb::Slice const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | Status DBImpl::Get(const ReadOptions& options, const Slice& key,
std::string* value) {
Status s;
MutexLock l(&mutex_);
SequenceNumber snapshot;
if (options.snapshot != nullptr) {
snapshot =
static_cast<const SnapshotImpl*>(options.snapshot)->sequence_number();
} else {
snaps... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r8, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
movq $0x0, (%rdi)
leaq 0xc8(%rsi), %r14
movq %r14, %rdi
callq 0xa950
testl %eax, %eax
jne 0x1485d
movq %r15, 0x20(%rsp)
m... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::RecordReadSample(leveldb::Slice) | void DBImpl::RecordReadSample(Slice key) {
MutexLock l(&mutex_);
if (versions_->current()->RecordReadSample(key)) {
MaybeScheduleCompaction();
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xc8(%rdi), %rbx
movq %rbx, %rdi
callq 0xa950
testl %eax, %eax
jne 0x14916
movq 0x228(%r14), %rax
movq 0x168(%rax), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1e2fa
testb %al, %al
je 0x14903
movq %r14, %rdi
cal... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::ReleaseSnapshot(leveldb::Snapshot const*) | void DBImpl::ReleaseSnapshot(const Snapshot* snapshot) {
MutexLock l(&mutex_);
snapshots_.Delete(static_cast<const SnapshotImpl*>(snapshot));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc8(%rdi), %rbx
movq %rbx, %rdi
callq 0xa950
testl %eax, %eax
jne 0x149ad
addq $0x1c0, %r15 # imm = 0x1C0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1604e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa4a0
movl %eax, %edi
callq 0xa3f0
| /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::BuildBatchGroup(leveldb::DBImpl::Writer**) | WriteBatch* DBImpl::BuildBatchGroup(Writer** last_writer) {
mutex_.AssertHeld();
assert(!writers_.empty());
Writer* first = writers_.front();
WriteBatch* result = first->batch;
assert(result != nullptr);
size_t size = WriteBatchInternal::ByteSize(first->batch);
// Allow the group to grow up to a maximum... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq 0x178(%rdi), %rax
movq %rdi, 0x8(%rsp)
cmpq %rax, 0x198(%rdi)
je 0x152b9
movq (%rax), %rcx
movq 0x8(%rcx), %rbx
testq %rbx, %rbx
je 0x152d8
movq 0x8(%rbx), %r13
leaq 0x20000(%r13), %rax
cmpq $0x20001, %r13 ... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DBImpl::GetApproximateSizes(leveldb::Range const*, int, unsigned long*) | void DBImpl::GetApproximateSizes(const Range* range, int n, uint64_t* sizes) {
// TODO(opt): better implementation
MutexLock l(&mutex_);
Version* v = versions_->current();
v->Ref();
for (int i = 0; i < n; i++) {
// Convert user_key into a corresponding internal key.
InternalKey k1(range[i].start, kMa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x40(%rsp)
movl %edx, %ebx
movq %rsi, (%rsp)
movq %rdi, %r12
addq $0xc8, %rdi
movq %rdi, 0x30(%rsp)
callq 0xa950
testl %eax, %eax
jne 0x157d3
movq 0x228(%r12), %rax
movq 0x168(%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e3a0
tes... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::DestroyDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, leveldb::Options const&) | Status DestroyDB(const std::string& dbname, const Options& options) {
Env* env = options.env;
std::vector<std::string> filenames;
Status result = env->GetChildren(dbname, &filenames);
if (!result.ok()) {
// Ignore error in case directory does not exist
return Status::OK();
}
FileLock* lock;
const... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %r15
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x38(... | /walterzhaoJR[P]leveldb/db/db_impl.cc |
leveldb::VersionEdit::~VersionEdit() | ~VersionEdit() = default; | pushq %rbx
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x161f2
leaq 0x60(%rbx), %rdi
movq 0x70(%rbx), %rsi
callq 0x162a8
leaq 0x48(%rbx), %rdi
callq 0x16212
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x15e86
popq %rbx
jmp 0xa570
popq %rbx
retq
| /walterzhaoJR[P]leveldb/./db/version_edit.h |
leveldb::SnapshotList::New(unsigned long) | SnapshotImpl* New(SequenceNumber sequence_number) {
assert(empty() || newest()->sequence_number_ <= sequence_number);
SnapshotImpl* snapshot = new SnapshotImpl(sequence_number);
#if !defined(NDEBUG)
snapshot->list_ = this;
#endif // !defined(NDEBUG)
snapshot->next_ = &head_;
snapshot->prev_ = hea... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq %rdi, 0x10(%rdi)
je 0x15ffd
cmpq %r14, 0x18(%r15)
ja 0x1602f
movl $0x28, %edi
callq 0xa5c0
leaq 0x69512(%rip), %rcx # 0x7f520
movq %rcx, (%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x8(... | /walterzhaoJR[P]leveldb/./db/snapshot.h |
leveldb::NewDBIterator(leveldb::DBImpl*, leveldb::Comparator const*, leveldb::Iterator*, unsigned long, unsigned int) | Iterator* NewDBIterator(DBImpl* db, const Comparator* user_key_comparator,
Iterator* internal_iter, SequenceNumber sequence,
uint32_t seed) {
return new DBIter(db, user_key_comparator, internal_iter, sequence, seed);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0xa8, %edi
callq 0xa5c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x23558
leaq 0x67d5a(%rip), %rax # 0x7f540
movq %rax, (%rbx)
movq %r13, 0x28(%rbx)
movq %r1... | /walterzhaoJR[P]leveldb/db/db_iter.cc |
leveldb::(anonymous namespace)::DBIter::SeekToFirst() | void DBIter::SeekToFirst() {
direction_ = kForward;
ClearSavedValue();
iter_->SeekToFirst();
if (iter_->Valid()) {
FindNextUserEntry(false, &saved_key_ /* temporary storage */);
} else {
valid_ = false;
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, 0x90(%rdi)
movq 0x70(%rdi), %rax
leaq 0x80(%rdi), %rcx
cmpq %rcx, %rax
je 0x1796e
cmpq $0x100001, 0x80(%rbx) # imm = 0x100001
jb 0x1796e
leaq 0x70(%rbx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)... | /walterzhaoJR[P]leveldb/db/db_iter.cc |
leveldb::(anonymous namespace)::DBIter::Seek(leveldb::Slice const&) | void DBIter::Seek(const Slice& target) {
direction_ = kForward;
ClearSavedValue();
saved_key_.clear();
AppendInternalKey(&saved_key_,
ParsedInternalKey(target, sequence_, kValueTypeForSeek));
iter_->Seek(saved_key_);
if (iter_->Valid()) {
FindNextUserEntry(false, &saved_key_ /* tempo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x90(%rdi)
movq 0x70(%rdi), %rax
leaq 0x80(%rdi), %rcx
cmpq %rcx, %rax
je 0x17aae
cmpq $0x100001, 0x80(%rbx) # imm = 0x100001
jb 0x17aae
leaq 0x70(%rbx), %rsi
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -... | /walterzhaoJR[P]leveldb/db/db_iter.cc |
leveldb::(anonymous namespace)::DBIter::Prev() | void DBIter::Prev() {
assert(valid_);
if (direction_ == kForward) { // Switch directions?
// iter_ is pointing at the current entry. Scan backwards until
// the key changes so we can use the normal reverse scanning code.
assert(iter_->Valid()); // Otherwise valid_ would have been false
SaveKey(E... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpb $0x0, 0x94(%rdi)
je 0x17dbf
movq %rdi, %rbx
cmpl $0x0, 0x90(%rdi)
jne 0x17d11
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x17dde
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq $0x7, %rdx
jbe 0x17da0
movq %... | /walterzhaoJR[P]leveldb/db/db_iter.cc |
leveldb::(anonymous namespace)::DBIter::value() const | Slice value() const override {
assert(valid_);
return (direction_ == kForward) ? iter_->value() : saved_value_;
} | pushq %rax
cmpb $0x0, 0x94(%rdi)
je 0x17e99
cmpl $0x0, 0x90(%rdi)
je 0x17e8d
movq 0x70(%rdi), %rax
movq 0x78(%rdi), %rdx
jmp 0x17e97
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
popq %rcx
retq
leaq 0x4ab52(%rip), %rdi # 0x629f2
leaq 0x426ca(%rip), %rsi # 0x5a571
leaq 0x428bd(%rip), %rcx # 0x5a7... | /walterzhaoJR[P]leveldb/db/db_iter.cc |
leveldb::ParsedInternalKey::DebugString[abi:cxx11]() const | std::string ParsedInternalKey::DebugString() const {
std::ostringstream ss;
ss << '\'' << EscapeString(user_key.ToString()) << "' @ " << sequence << " : "
<< static_cast<int>(type);
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0xa880
leaq 0x28(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0xa6b0
movq %rax, %r12
movq (%r14), %rsi
leaq 0x18(%rsp), %r... | /walterzhaoJR[P]leveldb/db/dbformat.cc |
leveldb::InternalFilterPolicy::KeyMayMatch(leveldb::Slice const&, leveldb::Slice const&) const | bool InternalFilterPolicy::KeyMayMatch(const Slice& key, const Slice& f) const {
return user_policy_->KeyMayMatch(ExtractUserKey(key), f);
} | subq $0x18, %rsp
movq 0x8(%rsi), %rax
cmpq $0x7, %rax
jbe 0x18af8
movq 0x8(%rdi), %rdi
movq (%rsi), %rcx
addq $-0x8, %rax
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x18, %rsp
retq
leaq 0x41854(%rip), %rdi # 0x5a353
leaq 0x41866(%rip), %rsi # 0x5a36c
le... | /walterzhaoJR[P]leveldb/db/dbformat.cc |
leveldb::LockFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string LockFileName(const std::string& dbname) { return dbname + "/LOCK"; } | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xfb0e
leaq 0x41d67(%rip), %rsi # 0x5ab4b
movq %rbx, %rdi
callq 0xac80
movq %rbx, %rax
popq %rbx
retq
| /walterzhaoJR[P]leveldb/db/filename.cc |
leveldb::log::Reader::SkipToInitialBlock() | bool Reader::SkipToInitialBlock() {
const size_t offset_in_block = initial_offset_ % kBlockSize;
uint64_t block_start_location = initial_offset_ - offset_in_block;
// Don't search a block if we'd be in the trailer
if (offset_in_block > kBlockSize - 6) {
block_start_location += kBlockSize;
}
end_of_buf... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
movl %eax, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
andq $-0x8000, %rax # imm = 0x8000
leaq 0x8000(%rax), %rbx
cmpl $0x7ffb, %ecx # imm = 0x7FFB
cmovbq %rax, %rbx
movq %rbx, 0x40(%rdi)
movb $0x1, %bpl
testq %rbx, %rb... | /walterzhaoJR[P]leveldb/db/log_reader.cc |
leveldb::log::Reader::ReadPhysicalRecord(leveldb::Slice*) | unsigned int Reader::ReadPhysicalRecord(Slice* result) {
while (true) {
if (buffer_.size() < kHeaderSize) {
if (!eof_) {
// Last read was a full read, so this is a trailer to skip
buffer_.clear();
Status status = file_->Read(kBlockSize, &buffer_, backing_store_);
end_of_buffe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
movq 0x28(%rdi), %rsi
cmpq $0x6, %rsi
ja 0x196b8
leaq 0x48778(%rip), %r13 # 0x61dc5
leaq 0x8(%rsp), %r12
movl $0x5, %ebp
movq %r13, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
cmpb $0x0, 0x3... | /walterzhaoJR[P]leveldb/db/log_reader.cc |
leveldb::log::Writer::AddRecord(leveldb::Slice const&) | Status Writer::AddRecord(const Slice& slice) {
const char* ptr = slice.data();
size_t left = slice.size();
// Fragment the record if necessary and emit it. Note that if slice
// is empty, we still want to iterate once to emit a single
// zero-length record
Status s;
bool begin = true;
do {
const i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%rdx), %r15
movq 0x8(%rdx), %rbx
movb $0x1, %r12b
leaq 0x10(%rsp), %r13
movl 0x8(%r14), %eax
cmpl $0x8001, %eax # imm = 0x8001
jge 0x19a9d
cmpl $0x7ffa, %eax # imm = 0x7FFA
j... | /walterzhaoJR[P]leveldb/db/log_writer.cc |
leveldb::MemTable::MemTable(leveldb::InternalKeyComparator const&) | MemTable::MemTable(const InternalKeyComparator& comparator)
: comparator_(comparator), refs_(0), table_(comparator_, &arena_) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x6596b(%rip), %r12 # 0x7f598
addq $0x10, %r12
movq %r12, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x25c08
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq 0x8(%rbx)... | /walterzhaoJR[P]leveldb/db/memtable.cc |
leveldb::SkipList<char const*, leveldb::MemTable::KeyComparator>::SkipList(leveldb::MemTable::KeyComparator, leveldb::Arena*) | SkipList<Key, Comparator>::SkipList(Comparator cmp, Arena* arena)
: compare_(cmp),
arena_(arena),
head_(NewNode(0 /* any key will do */, kMaxHeight)),
max_height_(1),
rnd_(0xdeadbeef) {
for (int i = 0; i < kMaxHeight; i++) {
head_->SetNext(i, nullptr);
}
} | pushq %rbx
movq %rdi, %rbx
leaq 0x654ff(%rip), %rax # 0x7f598
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl $0x68, %esi
movq %rdx, %rdi
callq 0x25d14
movq $0x0, (%rax)
movq %rax, 0x18(%rbx)
movabsq $0x5eadbeef00000001, %rax # imm = 0x5EADBEEF00000001
movq %r... | /walterzhaoJR[P]leveldb/./db/skiplist.h |
leveldb::TableCache::Get(leveldb::ReadOptions const&, unsigned long, unsigned long, leveldb::Slice const&, void*, void (*)(void*, leveldb::Slice const&, leveldb::Slice const&)) | Status TableCache::Get(const ReadOptions& options, uint64_t file_number,
uint64_t file_size, const Slice& k, void* arg,
void (*handle_result)(void*, const Slice&,
const Slice&)) {
Cache::Handle* handle = nullptr;
Status s = F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
movq %rcx, %rdx
movq %rax, %rcx
callq 0x1c520
cmpq $0x0, (%rbx)
jne 0x1c86d
movq 0x30(%r14), %rdi
movq 0x8(%rsp), %r13
mov... | /walterzhaoJR[P]leveldb/db/table_cache.cc |
leveldb::VersionEdit::Clear() | void VersionEdit::Clear() {
comparator_.clear();
log_number_ = 0;
prev_log_number_ = 0;
last_sequence_ = 0;
next_file_number_ = 0;
has_comparator_ = false;
has_log_number_ = false;
has_prev_log_number_ = false;
has_next_file_number_ = false;
has_last_sequence_ = false;
deleted_files_.clear();
ne... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
addq $0x60, %rdi
movq %r14, 0x3d(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movq 0x70(%rbx), %rsi
callq 0x162a8
leaq 0x68(%rbx), %rax
movq %r14, 0x70(%rbx)
movq %ra... | /walterzhaoJR[P]leveldb/db/version_edit.cc |
leveldb::VersionEdit::EncodeTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | void VersionEdit::EncodeTo(std::string* dst) const {
if (has_comparator_) {
PutVarint32(dst, kComparator);
PutLengthPrefixedSlice(dst, comparator_);
}
if (has_log_number_) {
PutVarint32(dst, kLogNumber);
PutVarint64(dst, log_number_);
}
if (has_prev_log_number_) {
PutVarint32(dst, kPrevLog... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x40(%rdi)
jne 0x1c962
movq %rbx, %rdi
movl $0x1, %esi
callq 0x26997
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x26... | /walterzhaoJR[P]leveldb/db/version_edit.cc |
leveldb::VersionEdit::DecodeFrom(leveldb::Slice const&) | Status VersionEdit::DecodeFrom(const Slice& src) {
Clear();
Slice input = src;
const char* msg = nullptr;
uint32_t tag;
// Temporary storage for parsing
int level;
uint64_t number;
FileMetaData f;
Slice str;
InternalKey key;
while (msg == nullptr && GetVarint32(&input, &tag)) {
switch (tag) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x1c8ac
movups (%r15), %xmm0
leaq 0x100(%rsp), %rdi
movaps %xmm0, (%rdi)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
le... | /walterzhaoJR[P]leveldb/db/version_edit.cc |
leveldb::SomeFileOverlapsRange(leveldb::InternalKeyComparator const&, bool, std::vector<leveldb::FileMetaData*, std::allocator<leveldb::FileMetaData*>> const&, leveldb::Slice const*, leveldb::Slice const*) | bool SomeFileOverlapsRange(const InternalKeyComparator& icmp,
bool disjoint_sorted_files,
const std::vector<FileMetaData*>& files,
const Slice* smallest_user_key,
const Slice* largest_user_key) {
const Comparat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
movq 0x8(%rdi), %r14
testl %esi, %esi
je 0x1da03
testq %r12, %r12
je 0x1da6b
movq %rdi, %r13
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movups (%r12... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Version::NewConcatenatingIterator(leveldb::ReadOptions const&, int) const | Iterator* Version::NewConcatenatingIterator(const ReadOptions& options,
int level) const {
return NewTwoLevelIterator(
new LevelFileNumIterator(vset_->icmp_, &files_[level]), &GetFileIterator,
vset_->table_cache_, options);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x58, %edi
callq 0xa5c0
movq %rax, %r15
movq (%r14), %r12
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
leaq (%r14,%rax,8), %r13
addq $0x20, %r13
movq %r15, %rdi
callq 0x23558
leaq 0x61b89(%ri... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::GetFileIterator(void*, leveldb::ReadOptions const&, leveldb::Slice const&) | static Iterator* GetFileIterator(void* arg, const ReadOptions& options,
const Slice& file_value) {
TableCache* cache = reinterpret_cast<TableCache*>(arg);
if (file_value.size() != 16) {
return NewErrorIterator(
Status::Corruption("FileReader invoked with unexpected value... | cmpq $0x10, 0x8(%rdx)
jne 0x1dbbe
movq (%rdx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
xorl %r8d, %r8d
jmp 0x1c730
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x3e4d4(%rip), %rax # 0x5c0a0
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movq $0x28, 0x8(%rdx)
leaq 0x441e2(%rip), %rax # 0x61dc5
leaq 0x8(%rsp), %rcx
m... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Version::UpdateStats(leveldb::Version::GetStats const&) | bool Version::UpdateStats(const GetStats& stats) {
FileMetaData* f = stats.seek_file;
if (f != nullptr) {
f->allowed_seeks--;
if (f->allowed_seeks <= 0 && file_to_compact_ == nullptr) {
file_to_compact_ = f;
file_to_compact_level_ = stats.seek_file_level;
return true;
}
}
return fa... | movq (%rsi), %rax
testq %rax, %rax
je 0x1e2e4
movl 0x4(%rax), %ecx
leal -0x1(%rcx), %edx
movl %edx, 0x4(%rax)
cmpl $0x1, %ecx
jg 0x1e2e4
cmpq $0x0, 0xc8(%rdi)
je 0x1e2e7
xorl %eax, %eax
retq
movq %rax, 0xc8(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0xd0(%rdi)
movb $0x1, %al
retq
| /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Version::DebugString[abi:cxx11]() const | std::string Version::DebugString() const {
std::string r;
for (int level = 0; level < config::kNumLevels; level++) {
// E.g.,
// --- level 1 ---
// 17:123['a' .. 'd']
// 20:43['e' .. 'g']
r.append("--- level ");
AppendNumberTo(&r, level);
r.append(" ---\n");
const std::vector<F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $0x20, %rsi
movq %rsi, 0x8(%rsp)
leaq 0x28(%rsp), %r15
xorl %r13d, %r13d
leaq 0x18(%rsp), %r12
leaq 0x3d2ba(%rip), %r14 # 0x5baf9... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::Finalize(leveldb::Version*) | void VersionSet::Finalize(Version* v) {
// Precomputed best level for next compaction
int best_level = -1;
double best_score = -1;
for (int level = 0; level < config::kNumLevels - 1; level++) {
double score;
if (level == 0) {
// We treat level-0 specially by bounding the number of files
// ... | pushq %rbx
leaq 0x20(%rsi), %rax
movsd 0x3c88d(%rip), %xmm5 # 0x5b960
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl $0x1, %edx
xorl %edi, %edi
movq 0x39f29(%rip), %xmm0 # 0x59010
movapd 0x39f31(%rip), %xmm1 # 0x59020
movsd 0x3c881(%rip), %xmm2 # 0x5b978
movsd 0x3c869(%rip), %xmm3 # 0x5b968
movsd 0... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::ReuseManifest(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 VersionSet::ReuseManifest(const std::string& dscname,
const std::string& dscbase) {
if (!options_->reuse_logs) {
return false;
}
FileType manifest_type;
uint64_t manifest_number;
uint64_t manifest_size;
if (!ParseFileName(dscbase, &manifest_number, &manifest_type) ||
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq 0x28(%rdi), %rax
cmpb $0x1, 0x54(%rax)
jne 0x1fd49
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rsp), %rsi
leaq 0x4(%rsp), %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x18e8c
xorl %ebx, %ebx
testb %al, %al
je 0x1fd4b
cmpl $0x3, 0x4(%rsp)
jne 0x1f... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::NumLevelFiles(int) const | int VersionSet::NumLevelFiles(int level) const {
assert(level >= 0);
assert(level < config::kNumLevels);
return current_->files_[level].size();
} | pushq %rax
testl %esi, %esi
js 0x1fe11
cmpl $0x7, %esi
jae 0x1fe30
movq 0x168(%rdi), %rcx
movl %esi, %eax
leaq (%rax,%rax,2), %rdx
movq 0x28(%rcx,%rdx,8), %rax
subq 0x20(%rcx,%rdx,8), %rax
shrq $0x3, %rax
popq %rcx
retq
leaq 0x39ccd(%rip), %rdi # 0x59ae5
leaq 0x3bb61(%rip), %rsi # 0x5b980
leaq 0x3bfae(%rip), %r... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::CompactRange(int, leveldb::InternalKey const*, leveldb::InternalKey const*) | Compaction* VersionSet::CompactRange(int level, const InternalKey* begin,
const InternalKey* end) {
std::vector<FileMetaData*> inputs;
current_->GetOverlappingInputs(level, begin, end, &inputs);
if (inputs.empty()) {
return nullptr;
}
// Avoid compacting too much in o... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x168(%rdi), %rdi
movq %r14, %r8
callq 0x1e5ea
movq (%r14), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0x214c4
testl %ebp, %ebp
jle 0x214d4
mo... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Compaction::Compaction(leveldb::Options const*, int) | Compaction::Compaction(const Options* options, int level)
: level_(level),
max_output_file_size_(MaxFileSizeForLevel(options, level)),
input_version_(nullptr),
grandparent_index_(0),
seen_key_(false),
overlapped_bytes_(0) {
for (int i = 0; i < config::kNumLevels; i++) {
level_ptr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, (%rdi)
movq 0x48(%rsi), %rax
movq %rax, 0x8(%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
addq $0x18, %rdi
leaq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movb %r14b, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq %r14, 0x70(%rbx... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Compaction::IsTrivialMove() const | bool Compaction::IsTrivialMove() const {
const VersionSet* vset = input_version_->vset_;
// Avoid a move if there is lots of overlapping grandparent data.
// Otherwise, the move could create a parent file that will require
// a very expensive merge later on.
return (num_input_files(0) == 1 && num_input_files(... | movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
movq 0xc8(%rdi), %rcx
subq 0xc0(%rdi), %rcx
andq %rax, %rcx
cmpq $0x8, %rcx
jne 0x2173a
movq 0xe0(%rdi), %rcx
subq 0xd8(%rdi), %rcx
testq %rax, %rcx
je 0x2173d
xorl %eax, %eax
retq
movq 0x10(%rdi), %rax
movq (%rax), %rax
movq 0xf0(%rdi), %rcx
movq 0xf8(%rdi), %rdx
sub... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Compaction::IsBaseLevelForKey(leveldb::Slice const&) | bool Compaction::IsBaseLevelForKey(const Slice& user_key) {
// Maybe use binary search to find right entry instead of linear search?
const Comparator* user_cmp = input_version_->vset_->icmp_.user_comparator();
for (int lvl = level_ + 2; lvl < config::kNumLevels; lvl++) {
const std::vector<FileMetaData*>& file... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq (%rdi), %rbp
movb $0x1, %al
movl %eax, 0x4(%rsp)
cmpq $0x4, %rbp
jg 0x21959
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq (%rax), %rax
movq 0x40(%rax), %r15
addq $0x2, %rbp
movl $0x0, 0x4(%rsp)
movq 0x10(%r14), %rdx
l... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Compaction::ShouldStopBefore(leveldb::Slice const&) | bool Compaction::ShouldStopBefore(const Slice& internal_key) {
const VersionSet* vset = input_version_->vset_;
// Scan to find earliest grandparent file that contains key.
const InternalKeyComparator* icmp = &vset->icmp_;
while (grandparent_index_ < grandparents_.size() &&
icmp->Compare(internal_key,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0xf0(%rdi), %rax
movq (%rcx), %r13
movq 0x108(%rdi), %rcx
movq 0xf8(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rcx
jae 0x21a24
movq %rsi, %r14
leaq 0x38(%r13), %r15
movq %rsp, %r12
movq (%rax,... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::SaveValue(void*, leveldb::Slice const&, leveldb::Slice const&) | static void SaveValue(void* arg, const Slice& ikey, const Slice& v) {
Saver* s = reinterpret_cast<Saver*>(arg);
ParsedInternalKey parsed_key;
if (!ParseInternalKey(ikey, &parsed_key)) {
s->state = kCorrupt;
} else {
if (s->ucmp->Compare(parsed_key.user_key, s->user_key) == 0) {
s->state = (parsed_... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x8(%rsi), %rax
cmpq $0x8, %rax
jb 0x21b27
movq %rdx, %rbx
movq (%rsi), %rcx
movq -0x8(%rcx,%rax), %rdx
movzbl %dl, %esi
shrq $0x8, %rdx
movq %rdx, 0x18(%rsp)
movl %esi, 0x20(%rsp)
addq $-0x8, %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpl $0x2, %esi
jae... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::Recover(bool*)::LogReporter::~LogReporter() | Status VersionSet::Recover(bool* save_manifest) {
struct LogReporter : public log::Reader::Reporter {
Status* status;
void Corruption(size_t bytes, const Status& s) override {
if (this->status->ok()) *this->status = s;
}
};
// Read "CURRENT" file, which contains a pointer to the current manifes... | pushq %rbx
movq %rdi, %rbx
callq 0x192a0
movq %rbx, %rdi
popq %rbx
jmp 0xa570
| /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::Builder::Builder(leveldb::VersionSet*, leveldb::Version*) | Builder(VersionSet* vset, Version* base) : vset_(vset), base_(base) {
base_->Ref();
BySmallestKey cmp;
cmp.internal_comparator = &vset_->icmp_;
for (int level = 0; level < config::kNumLevels; level++) {
levels_[level].added_files = new FileSet(cmp);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x18(%rdi), %rax
xorl %ecx, %ecx
xorl %esi, %esi
leaq (%rax,%rsi), %rdi
movl $0x0, (%rax,%rsi)
movq %rcx, 0x8(%rax,%rsi)
movq %rdi, 0x10(%rax,%rsi)
movq %rdi, 0x18(%rax,%rsi)
movq %rcx, 0x2... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::Builder::Apply(leveldb::VersionEdit*) | void Apply(VersionEdit* edit) {
// Update compaction pointers
for (size_t i = 0; i < edit->compact_pointers_.size(); i++) {
const int level = edit->compact_pointers_[i].first;
vset_->compact_pointer_[level] =
edit->compact_pointers_[i].second.Encode().ToString();
}
// Delete files... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq 0x48(%rsi), %rax
cmpq %rax, 0x50(%rsi)
je 0x21d7c
movl $0x10, %r12d
leaq 0x28(%rsp), %r13
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
movq (%rax,%r12), %rdx
testq %rdx, %rdx
je 0x21ef5
movslq -0x10(%ra... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionSet::Builder::SaveTo(leveldb::Version*) | void SaveTo(Version* v) {
BySmallestKey cmp;
cmp.internal_comparator = &vset_->icmp_;
for (int level = 0; level < config::kNumLevels; level++) {
// Merge the set of added files with the set of pre-existing files.
// Drop any deleted files. Store the result in *v.
const std::vector<FileMet... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
addq $0x38, %rax
movq %rax, 0x20(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rsi), %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq 0x8(%r14), %rax
leaq (,%r12,8), %rcx
... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::VersionEdit::SetCompactPointer(int, leveldb::InternalKey const&) | void SetCompactPointer(int level, const InternalKey& key) {
compact_pointers_.push_back(std::make_pair(level, key));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
addq $0x48, %rbx
leaq 0x10(%rsp), %rdi
movl %esi, -0x8(%rdi)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0xfb0e
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d4e2
movq 0x8(%r14... | /walterzhaoJR[P]leveldb/./db/version_edit.h |
leveldb::Version::LevelFileNumIterator::Prev() | void Prev() override {
assert(Valid());
if (index_ == 0) {
index_ = flist_->size(); // Marks as invalid
} else {
index_--;
}
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x22565
movl 0x40(%rbx), %eax
testl %eax, %eax
je 0x22551
decl %eax
jmp 0x22560
movq 0x38(%rbx), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x3, %rax
movl %eax, 0x40(%rbx)
popq %rbx
retq
leaq 0x37ffd(%rip), %rdi # 0x5a569
leaq 0... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::Version::LevelFileNumIterator::key() const | Slice key() const override {
assert(Valid());
return (*flist_)[index_]->largest.Encode();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x225af
movq 0x38(%rbx), %rax
movl 0x40(%rbx), %ecx
movq (%rax), %rax
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rdx
testq %rdx, %rdx
je 0x225ce
movq 0x38(%rax), %rax
popq %rbx
retq
leaq 0x37fb3(%rip), %rdi # 0x5a569
leaq 0x393c3(%rip)... | /walterzhaoJR[P]leveldb/db/version_set.cc |
leveldb::WriteBatchInternal::InsertInto(leveldb::WriteBatch const*, leveldb::MemTable*) | Status WriteBatchInternal::InsertInto(const WriteBatch* b, MemTable* memtable) {
MemTableInserter inserter;
inserter.sequence_ = WriteBatchInternal::Sequence(b);
inserter.mem_ = memtable;
return b->Iterate(&inserter);
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x5c303(%rip), %rcx # 0x7f798
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsi), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rax, %rdx
callq 0x231c6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
| /walterzhaoJR[P]leveldb/db/write_batch.cc |
leveldb::WriteBatchInternal::SetContents(leveldb::WriteBatch*, leveldb::Slice const&) | size_t size() const { return size_; } | movq 0x8(%rsi), %r8
cmpq $0xb, %r8
jbe 0x234d6
movq (%rsi), %rcx
movq 0x8(%rdi), %rdx
xorl %esi, %esi
jmp 0xaa10
pushq %rax
leaq 0x38d84(%rip), %rdi # 0x5c262
leaq 0x38d98(%rip), %rsi # 0x5c27d
leaq 0x38df1(%rip), %rcx # 0x5c2dd
movl $0x8c, %edx
callq 0xa3e0
| /walterzhaoJR[P]leveldb/include/leveldb/slice.h |
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.