name string | code string | asm string | file string |
|---|---|---|---|
wabt::interp::RunResult wabt::interp::Thread::DoSimdNarrow<wabt::interp::Simd<signed char, (unsigned char)16>, wabt::interp::Simd<short, (unsigned char)8>>() | RunResult Thread::DoSimdNarrow() {
using SL = typename S::LaneType;
using TL = typename T::LaneType;
auto rhs = Pop<T>();
auto lhs = Pop<T>();
S result;
for (u8 i = 0; i < T::lanes; ++i) {
result[i] = Saturate<SL, TL>(lhs[i]);
}
for (u8 i = 0; i < T::lanes; ++i) {
result[T::lanes + i] = Saturate... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x9af70
movq %rdx, %xmm0
movq %rax, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movdqa %xmm1, (%rsp)
movq %rbx, %rdi
callq 0x9af70
movq %rdx, %xmm0
movq %rax, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
packsswb %xmm1, %xmm1
movq %xmm1, %rsi
... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdWiden<wabt::interp::Simd<short, (unsigned char)8>, wabt::interp::Simd<signed char, (unsigned char)16>, true>() | RunResult Thread::DoSimdWiden() {
auto val = Pop<T>();
S result;
for (u8 i = 0; i < S::lanes; ++i) {
result[i] = val[(low ? 0 : S::lanes) + i];
}
Push(result);
return RunResult::Ok;
} | pushq %rbx
movq %rdi, %rbx
callq 0x9aeae
movq %rax, %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
psraw $0x8, %xmm0
movq %xmm0, %rsi
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rdx
movq %rbx, %rdi
callq 0x9b370
xorl %eax, %eax
popq %rbx
retq
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicStore<unsigned long, unsigned char>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicStore(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V val = static_cast<V>(Pop<T>());
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->AtomicStore(offset, instr.imm_u32x2.snd, val)),
StringPrintf("invalid atomic acc... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x90(%rsp), %r13
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rax
movl 0x8(%r13), %ecx
movq 0x90(%rax), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x90132
movq %r14, %rdi
callq 0x904ec
m... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicRmw<unsigned long, unsigned int>(unsigned int (*)(unsigned int, unsigned int), wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicRmw(BinopFunc<T, T> f,
Instr instr,
Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
T val = static_cast<T>(Pop<R>());
u64 offset = PopPtr(memory);
T old;
TRAP_IF(Failed(memory->Atom... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xa0(%rsp), %r13
movq %rsi, 0x10(%rsp)
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rax
movl 0x8(%r13), %ecx
movq 0x90(%rax), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x901... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicRmwCmpxchg<unsigned long, unsigned short>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicRmwCmpxchg(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V replace = static_cast<V>(Pop<T>());
V expect = static_cast<V>(Pop<T>());
V old;
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->AtomicRmwCmpxchg(offset, instr.im... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %rbp
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rax
movl 0x8(%rbp), %ecx
movq 0x90(%rax), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x90132
movq %rbx, %rdi
call... | /dcodeIO[P]wabt/src/interp/interp.cc |
unsigned long wabt::interp::FreeList<std::unique_ptr<wabt::interp::Object, std::default_delete<wabt::interp::Object>>>::New<wabt::interp::Event*>(wabt::interp::Event*&&) | auto FreeList<T>::New(Args&&... args) -> Index {
if (!free_.empty()) {
Index index = free_.back();
assert(is_free_[index]);
free_.pop_back();
is_free_[index] = false;
list_[index] = T(std::forward<Args>(args)...);
return index;
}
assert(list_.size() == is_free_.size());
is_free_.push_bac... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x97c1b
movq -0x8(%rax), %r15
leaq 0x3f(%r15), %rdx
testq %r15, %r15
cmovnsq %r15, %rdx
sarq $0x6, %rdx
shlq $0x3, %rdx
addq 0x30(%rbx), %rdx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
unsigned long wabt::interp::Istream::ReadAt<unsigned long>(unsigned int*) const | T WABT_VECTORCALL Istream::ReadAt(Offset* offset) const {
assert(*offset + sizeof(T) <= data_.size());
T result;
memcpy(&result, data_.data() + *offset, sizeof(T));
*offset += sizeof(T);
return result;
} | movl (%rsi), %ecx
leaq 0x8(%rcx), %rdx
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
subq %rax, %rdi
cmpq %rdi, %rdx
ja 0x9d111
movq (%rax,%rcx), %rax
addl $0x8, %ecx
movl %ecx, (%rsi)
retq
pushq %rax
leaq 0x1a01f(%rip), %rdi # 0xb7138
leaq 0x19e47(%rip), %rsi # 0xb6f67
leaq 0x1a078(%rip), %rcx # 0xb719f
movl $0x6... | /dcodeIO[P]wabt/src/interp/istream.cc |
float wabt::interp::Istream::ReadAt<float>(unsigned int*) const | T WABT_VECTORCALL Istream::ReadAt(Offset* offset) const {
assert(*offset + sizeof(T) <= data_.size());
T result;
memcpy(&result, data_.data() + *offset, sizeof(T));
*offset += sizeof(T);
return result;
} | movl (%rsi), %eax
leaq 0x4(%rax), %rdx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
subq %rcx, %rdi
cmpq %rdi, %rdx
ja 0x9d152
movss (%rcx,%rax), %xmm0
addl $0x4, %eax
movl %eax, (%rsi)
retq
pushq %rax
leaq 0x19fde(%rip), %rdi # 0xb7138
leaq 0x19e06(%rip), %rsi # 0xb6f67
leaq 0x1a07b(%rip), %rcx # 0xb71e3
movl $0... | /dcodeIO[P]wabt/src/interp/istream.cc |
wasm_externtype_t::New(std::unique_ptr<wabt::interp::ExternType, std::default_delete<wabt::interp::ExternType>>) | std::unique_ptr<wasm_externtype_t> wasm_externtype_t::New(
std::unique_ptr<ExternType> ptr) {
switch (ptr->kind) {
case ExternKind::Func:
return MakeUnique<wasm_functype_t>(*cast<FuncType>(ptr.get()));
case ExternKind::Table:
return MakeUnique<wasm_tabletype_t>(*cast<TableType>(ptr.get()));
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %r14
movl 0x8(%r14), %eax
cmpq $0x3, %rax
ja 0x9d2f7
movq %rdi, %rbx
leaq 0x1a080(%rip), %rcx # 0xb72dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9fba3
jmp 0x9d2e4
leaq 0x8(%rsp), ... | /dcodeIO[P]wabt/src/interp/interp-wasm-c-api.cc |
wasm_trap_message | void wasm_trap_message(const wasm_trap_t* trap, own wasm_message_t* out) {
assert(trap);
*out = FromString(trap->As<Trap>()->message());
} | subq $0x28, %rsp
testq %rdi, %rdi
je 0x9d609
movq (%rdi), %rdi
cmpl $0x2, 0x8(%rdi)
jne 0x9d628
movq %rsi, %rdx
leaq 0x8(%rsp), %rsi
callq 0x2a270
addq $0x28, %rsp
retq
leaq 0xd49e(%rip), %rdi # 0xaaaae
leaq 0x19f63(%rip), %rsi # 0xb757a
leaq 0x1a0b2(%rip), %rcx # 0xb76d0
movl $0x236, %edx # imm... | /dcodeIO[P]wabt/src/interp/interp-wasm-c-api.cc |
wasm_module_new | own wasm_module_t* wasm_module_new(wasm_store_t* store,
const wasm_byte_vec_t* binary) {
Errors errors;
ModuleDesc module_desc;
if (Failed(ReadBinaryInterp(binary->data, binary->size, GetOptions(), &errors,
&module_desc))) {
FormatErrorsToFile(e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %rbx
movq %rdi, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x188(%rsp), %rdi
movl $0x120, %edx # imm = 0x120
xorl %esi, %esi
callq 0x1d2e0
movq (%rbx), %r15... | /dcodeIO[P]wabt/src/interp/interp-wasm-c-api.cc |
stumpless_set_transport_port | struct stumpless_target *
stumpless_set_transport_port( struct stumpless_target *target,
const char *port ) {
const char *port_copy;
struct network_target *net_target;
const char *old_port;
VALIDATE_ARG_NOT_NULL( target );
VALIDATE_ARG_NOT_NULL( port );
port_copy = copy_cstri... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x16700
leaq 0x3792(%rip), %rdi # 0x19e80
callq 0x9d70
movq $0x0, -0x8(%rbp)
jmp 0x167c9
cmpq $0x0, -0x18(%rbp)
jne 0x16720
leaq 0x3d33(%rip), %rdi # 0x1a441
callq 0x9d70
movq $0x0, -0x8(%rbp)
... | /goatshriek[P]stumpless/src/target/network.c |
json2map_hookMethod | void json2map_hookMethod(void *data, char *key, char *value) {
int i;
keyvalue_t *list = (keyvalue_t *) data;
i = 0;
while ( strcmp(list->key, "") ) {
i++;
list++;
}
strcpy(list->key, key);
strcpy(list->value, value);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
addq $-0xff, %r14
cmpb $0x0, 0xff(%r14)
leaq 0x1fe(%r14), %r14
jne 0x227d
leaq -0xff(%r14), %rdi
callq 0x2060
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2060
| /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_map2json_array | int test_map2json_array() {
map2json_t *map2jsonObj = map2json_init(NULL);
map2json_push(map2jsonObj, "array[0].object1.key1", "value1");
map2json_push(map2jsonObj, "array[0].object1.key2", "2");
map2json_push(map2jsonObj, "array[3]", "1");
map2json_push(map2jsonObj, "array[2]", "b");
map2json_push(map2jsonObj, "... | pushq %r14
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x47f4
movq %rax, %rbx
leaq 0x3b4c(%rip), %rsi # 0x60bf
leaq 0x3b5b(%rip), %rdx # 0x60d5
movq %rax, %rdi
callq 0x4829
leaq 0x3b53(%rip), %rsi # 0x60dc
leaq 0x3ba5(%rip), %r14 # 0x6135
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4829
leaq 0x3b50(%rip... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_map2json_primitive | int test_map2json_primitive() {
map2json_t *map2jsonObj = map2json_init(NULL);
char primitiveMethod[] = " function()";
*primitiveMethod = JSON2MAP_PRIMITIVE_PREFIXER;
map2json_push(map2jsonObj, "fakePrimitive", primitiveMethod);
ASSERTSTR("{\"fakePrimitive\":function()}", map2json_create(map2jsonObj));
map2json... | pushq %r14
pushq %rbx
subq $0x18, %rsp
xorl %edi, %edi
callq 0x47f4
movq %rax, %rbx
movabsq $0x6f6974636e756620, %rax # imm = 0x6F6974636E756620
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x29286e, 0x8(%rdx) # imm = 0x29286E
movb $0x1b, (%rdx)
leaq 0x3b14(%rip), %rsi # 0x61b6
movq %rbx, %rdi
callq 0x4829
movq... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_emptyJson | int test_json2map_emptyJson() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{}");
ASSERTSTR("", map[0].key);
ASSERTSTR("", map[0].value);
... | pushq %rbp
pushq %r14
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0x5ab(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x37f7(%rip), %rdx # 0x6020
movq %r14, %rdi
xorl %esi, %esi
... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_null | int test_json2map_null() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"nullpointer\":null}");
ASSERTSTR("nullpointer", map[0].key);
ASS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0x655(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x375c(%rip), %rdx # 0x602f
movq %r14,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_true | int test_json2map_true() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"booleanValue\":true}");
ASSERTSTR("booleanValue", map[0].key);
A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0x719(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x36ba(%rip), %rdx # 0x6051
movq %r14,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_numberInt | int test_json2map_numberInt() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"number\":123456}");
ASSERTSTR("number", map[0].key);
ASSERT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0x8a1(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x356d(%rip), %rdx # 0x608c
movq %r14,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_numberFloat | int test_json2map_numberFloat() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"number\":123456.789}");
ASSERTSTR("number", map[0].key);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0x965(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x34c6(%rip), %rdx # 0x60a9
movq %r14,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_array | int test_json2map_array() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"array\":[{\"object1\":{\"key1\":\"value1\",\"key2\":2}},{\"array2\... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %r14
xorl %edi, %edi
callq 0x40e0
movq %rax, %r15
leaq -0xa2a(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %r14, %rsi
callq 0x4736
leaq 0x34ad(%rip), %rdx # 0x6155
movq %r15,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_primitive | int test_json2map_primitive() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"fakePrimitive\":function()}");
ASSERTSTR("fakePrimitive", ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0xdf2(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x3154(%rip), %rdx # 0x61c4
movq %r14,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_deepNesting | int test_json2map_deepNesting() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"lvl1\":{\"lvl2\":{\"lvl3\":{\"lvl4\":{\"lvl5\":[{\"lvl6\":{\... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0xeb6(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
leaq 0x30b7(%rip), %rdx # 0x61eb
movq %r14,... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_jsonNull | int test_json2map_jsonNull() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
json2map_t *json2mapObj = json2map_init(0);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, NULL);
ASSERTSTR("", map[0].key);
ASSERTSTR("", map[0].value);
... | pushq %rbp
pushq %r14
pushq %rbx
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %rbx
xorl %edi, %edi
callq 0x40e0
movq %rax, %r14
leaq -0x1051(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4736
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40fd
leaq 0x2d... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
test_json2map_objectHook | int test_json2map_objectHook() {
keyvalue_t *map = (keyvalue_t *) calloc(sizeof(keyvalue_t), LIST_SIZE);
int i;
json2map_t *json2mapObj = json2map_init(1);
json2map_registerDataHook(json2mapObj, map, &json2map_hookMethod);
json2map_parse(json2mapObj, NULL, "{\"lvl1\":{\"lvl2\":{\"lvl3\":{\"lvl4\":{\"lvl5\":[{\"lv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1fe, %edi # imm = 0x1FE
movl $0xff, %esi
callq 0x20e0
movq %rax, %r14
movl $0x1, %ebx
movl $0x1, %edi
callq 0x40e0
movq %rax, %r15
leaq -0x1124(%rip), %rdx # 0x226c
movq %rax, %rdi
movq %r14, %rsi
callq 0x4736
leaq 0x2ee... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
main | int main(int argc, char **argv) {
TESTCALL("test_map2json_emptyMap", test_map2json_emptyMap);
TESTCALL("test_map2json_null", test_map2json_null);
TESTCALL("test_map2json_true", test_map2json_true);
TESTCALL("test_map2json_false", test_map2json_false);
TESTCALL("test_map2json_numberInt", test_map2json_numberInt);
... | pushq %rbx
movq %rsi, %rbx
leaq 0x2bcb(%rip), %rdi # 0x677c
leaq 0x2bd4(%rip), %rsi # 0x678c
xorl %eax, %eax
callq 0x2090
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3bde
leaq 0x2bbd(%rip), %rsi # 0x678c
callq 0x2100
testl %eax, %eax
jne 0x3be3
popq %rbx
jmp 0x22ac
callq 0x22ac
leaq 0x2b92(%rip), %rdi ... | /maximilianvoss[P]ctemplate/libs/json2map/test/testcases.c |
json2map_parse | int json2map_parse(json2map_t *obj, char *prefix, char *jsonString) {
DEBUG_TEXT("json2map_parseObject([json2map_t *], %s)... ", jsonString);
jsmn_parser p;
jsmntok_t *token;
if ( jsonString == NULL ) {
return -1;
}
jsmn_init(&p);
int count = jsmn_parse(&p, jsonString, strlen(jsonString), NULL, 0);
DEBUG_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x41ba
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %r13
movq %r13, %rdi
callq 0x54e5
movq %r14, %rdi
callq 0x2070
movq %r13, %rdi
movq %r14, %rsi
mov... | /maximilianvoss[P]ctemplate/libs/json2map/json2map.c |
json2map_parseObject | static int json2map_parseObject(json2map_t *obj, char *path, char *jsonString, jsmntok_t *token, int start, int end) {
DEBUG_TEXT("json2map_parseObject([json2map_t *], %s, %s, [jsmntok_t *], %d, %d)...", path, jsonString, start, end);
int newEnd;
char *buffer;
csafestring_t *pathBuff = NULL;
csafestring_t *objPat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %r12d
movl %r8d, %r13d
movq %rcx, %rbp
movq %rsi, 0x60(%rsp)
cmpl %r9d, %r8d
setge %al
testl %r8d, %r8d
setle %cl
orb %al, %cl
jne 0x4711
movslq %r12d, %r14
leal -0x1(%r12), %eax
movl %eax, 0x38(%rsp)
leaq 0x14(%rbp), %rax
mov... | /maximilianvoss[P]ctemplate/libs/json2map/json2map.c |
json2map_concatPaths | static csafestring_t *json2map_concatPaths(char *parent, char *key, int arrayIdx) {
DEBUG_TEXT("json2map_concatPaths(%s, %s, %d)...", parent, key, arrayIdx);
char arrayIdxBuff[10];
csafestring_t *buffer = safe_create(NULL);
if ( parent != NULL && *parent != '\0' ) {
safe_strcpy(buffer, parent);
safe_strchrapp... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %edi, %edi
callq 0x54f4
movq %rax, %rbx
testq %r15, %r15
je 0x478a
cmpb $0x0, (%r15)
je 0x478a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5757
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x580e
movq %rbx, %rdi
movq... | /maximilianvoss[P]ctemplate/libs/json2map/json2map.c |
map2json_init | map2json_t *map2json_init(char *prefix) {
DEBUG_TEXT("map2json_init(%s)... ", prefix);
map2json_t *obj;
obj = (map2json_t *) malloc(sizeof(map2json_t));
obj->buffer = safe_create(NULL);
obj->pairs = NULL;
obj->tree = NULL;
obj->prefix = prefix;
DEBUG_TEXT("map2json_init(%s)... DONE", prefix);
return obj;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2120
movq %rax, %r14
xorl %edi, %edi
callq 0x54f4
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
map2json_push | void map2json_push(map2json_t *obj, char *key, char *value) {
DEBUG_TEXT("map2json_push([map2json_t *], %s, %s)... ", key, value);
map2json_keyvalue_t *pair = (map2json_keyvalue_t *) malloc(sizeof(map2json_keyvalue_t));
char *realKey;
if ( obj->prefix == NULL ) {
realKey = key;
} else {
size_t prefixLength =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2120
movq %rax, %r15
movq 0x18(%rbx), %r13
testq %r13, %r13
je 0x487d
movq %r13, %rdi
callq 0x2070
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
c... | /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
map2json_create | char *map2json_create(map2json_t *obj) {
DEBUG_PUT("map2json_create([map2json_t *])... ");
map2json_freeTreeMemory(obj->tree);
map2json_createTree(obj);
safe_strcpy(obj->buffer, "");
map2json_createJsonString(obj->buffer, obj->tree);
DEBUG_PUT("map2json_create([map2json_t *])... DONE");
return obj->buffer->da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x4c78
movl $0x40, %edi
callq 0x2120
pxor %xmm0, %xmm0
movdqu %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movl $0x1, 0x20(%rax)
pcmpeqd %xmm1, %xmm1
movdqu %xmm1, 0x10(%rax)
movdqu %xmm0, (%rax)
mov... | /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
map2json_freeTreeMemory | static void map2json_freeTreeMemory(map2json_tree_t *obj) {
DEBUG_PUT("map2json_freeTreeMemory([map2json_t *])... ");
if ( obj == NULL ) {
DEBUG_PUT("map2json_freeTreeMemory([map2json_t *])... DONE");
return;
}
map2json_freeTreeMemory(obj->arrayObjects);
map2json_freeTreeMemory(obj->children);
map2json_free... | testq %rdi, %rdi
je 0x4cb2
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x4c78
movq 0x30(%rbx), %rdi
callq 0x4c78
movq 0x28(%rbx), %rdi
callq 0x4c78
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4ca9
callq 0x2030
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
| /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
map2json_createJsonString | static void map2json_createJsonString(csafestring_t *buffer, map2json_tree_t *tree) {
DEBUG_TEXT("map2json_createJsonString(%s, [map2json_tree_t *])... ", buffer->data);
if ( tree == NULL ) {
DEBUG_TEXT("map2json_createJsonString(%s, [map2json_tree_t *])... DONE", buffer->data);
return;
}
if ( tree->key != NU... | testq %rsi, %rsi
je 0x4e0f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rbx)
je 0x4d02
movq %r14, %rdi
movl $0x22, %esi
callq 0x580e
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x5638
movq %r14, %rdi
movl $0x22, %esi
callq 0x580e
movq %r14, %rdi
movl $0x3a, %esi
callq ... | /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
map2json_destroy | void map2json_destroy(map2json_t *obj) {
DEBUG_PUT("map2json_destroy([map2json_t *])... ");
map2json_freePairsMemory(obj->pairs);
map2json_freeTreeMemory(obj->tree);
safe_destroy(obj->buffer);
free(obj);
DEBUG_PUT("map2json_destroy([map2json_t *])... DONE");
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4e37
movq 0x8(%rbx), %rdi
callq 0x4c78
movq 0x10(%rbx), %rdi
callq 0x55a5
movq %rbx, %rdi
popq %rbx
jmp 0x2030
| /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
map2json_freePairsMemory | static void map2json_freePairsMemory(map2json_keyvalue_t *pair) {
DEBUG_PUT("map2json_freePairsMemory([map2json_t *])... ");
if ( pair == NULL ) {
DEBUG_PUT("map2json_freePairsMemory([map2json_t *])... DONE");
return;
}
map2json_freePairsMemory(pair->next);
free(pair->key);
free(pair->value);
free(pair);
DE... | testq %rdi, %rdi
je 0x4e63
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x4e37
movq (%rbx), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
| /maximilianvoss[P]ctemplate/libs/json2map/map2json.c |
stringlib_splitTokens | stringlib_tokens_t *stringlib_splitTokens(char *str, char chr) {
char *lastPos;
char *newPos;
stringlib_tokens_t *tokens = NULL;
stringlib_tokens_t *currentToken;
stringlib_tokens_t *newToken;
newPos = str;
lastPos = str;
while ( *newPos != '\0' ) {
if ( *newPos == chr ) {
newToken = (stringlib_tokens_t... | movb (%rdi), %al
testb %al, %al
je 0x4f4b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
leaq 0x1(%rdi), %r13
xorl %r12d, %r12d
movq %rdi, %r14
movq %rdi, %r15
movq %rdi, (%rsp)
cmpb %bpl, %al
jne 0x4eff
movl $0x18, %edi
callq 0x2120
movq $0x0, 0x10(%rax)
movq %rax, %rcx
te... | /maximilianvoss[P]ctemplate/libs/json2map/stringlib.c |
stringlib_isInteger | int stringlib_isInteger(char *str) {
char *ptr = str;
if ( *ptr == '\0' ) {
return 0;
}
while ( *ptr != '\0' ) {
if ( ( *ptr < 48 || *ptr > 57 ) && *ptr != '.' ) {
return 0;
}
ptr++;
}
return 1;
} | movb (%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x4f93
incq %rdi
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
setae %dl
cmpb $0x2e, %cl
setne %cl
testb %dl, %cl
jne 0x4f93
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x4f72
movl $0x1, %eax
retq
| /maximilianvoss[P]ctemplate/libs/json2map/stringlib.c |
jsmn_parse | int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
jsmntok_t *tokens, unsigned int num_tokens) {
int r;
int i;
jsmntok_t *token;
int count = parser->toknext;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
char c;
jsmntype_t type;
c = js[parser->pos];
switch (c) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, -0x14(%rsp)
movl (%rdi), %r14d
movl 0x4(%rdi), %r12d
cmpq %rdx, %r14
jae 0x546b
leaq 0x8(%rcx), %rax
movq %rax, -0x10(%rsp)
movl %r12d, %r15d
movl %r12d, %r9d
movl %r12d, %r10d
movl %r14d, %r11d
movb (%rsi,%r14), %al
movzbl %al, %ebp
cmpl $0x2... | /maximilianvoss[P]ctemplate/libs/json2map/jsmn.c |
safe_create | csafestring_t *safe_create(char *str) {
csafestring_t *obj = (csafestring_t *) malloc(sizeof(csafestring_t));
#ifdef EXPERIMENTAL_SIZING
obj->sizing_size = safe_getInitSize();
obj->buffer_length = 1<<obj->sizing_size;
sizing_size += obj->sizing_size;
#else
obj->buffer_length = INIT_LENGTH_CALC;
#endif
if ( st... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x10, %edi
callq 0x2120
movq %rax, %rbx
movq $0x8, 0x8(%rax)
testq %r14, %r14
je 0x5549
movq %r14, %rdi
callq 0x2070
incq %rax
movl $0x8, %ecx
movq %rcx, %rdi
addq %rcx, %rcx
cmpq %rax, %rdi
jb 0x5525
movq %rdi, 0x8(%rbx)
callq 0x2120
movq %rax, (%rbx)
movq %rax, %... | /maximilianvoss[P]ctemplate/libs/json2map/libs/csafestring/csafestring.c |
safe_clone | csafestring_t *safe_clone(csafestring_t *obj) {
csafestring_t *clone = (csafestring_t *) malloc(sizeof(csafestring_t));
clone->buffer_length = obj->buffer_length;
clone->data = malloc(clone->buffer_length);
memcpy(clone->data, obj->data, clone->buffer_length);
#ifdef EXPERIMENTAL_SIZING
clone->sizing_size = obj->... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2120
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %r15, 0x8(%rax)
movq %r15, %rdi
callq 0x2120
movq %rax, (%r14)
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2110
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| /maximilianvoss[P]ctemplate/libs/json2map/libs/csafestring/csafestring.c |
safe_destroy | void safe_destroy(csafestring_t *obj) {
if ( obj == NULL ) {
return;
}
if ( obj->data != NULL ) {
free(obj->data);
}
#ifdef EXPERIMENTAL_SIZING
sizing_size -= obj->sizing_size;
sizing_count--;
#endif
free(obj);
} | testq %rdi, %rdi
je 0x55c4
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x55bb
callq 0x2030
movq %rbx, %rdi
popq %rbx
jmp 0x2030
retq
| /maximilianvoss[P]ctemplate/libs/json2map/libs/csafestring/csafestring.c |
safe_resizeBuffer | void safe_resizeBuffer(csafestring_t *obj, size_t newLength) {
char hit = 0;
newLength++;
while ( obj->buffer_length < newLength ) {
hit = 1;
obj->buffer_length <<= 1;
#ifdef EXPERIMENTAL_SIZING
obj->sizing_size++;
sizing_size++;
#endif
}
if ( hit ) {
char *tmp = (char *) calloc(sizeof(char), obj->buffe... | incq %rsi
movq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x5626
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rcx, %rax
addq %rax, %rax
cmpq %rsi, %rax
jb 0x55dc
movq %rax, 0x8(%rbx)
cmpq %rsi, %rcx
jae 0x5621
movl $0x1, %edi
movq %rax, %rsi
callq 0x20e0
movq %rax, %r14
movq (%rbx), %r15
movq %r15, %rdi
callq 0x2070... | /maximilianvoss[P]ctemplate/libs/json2map/libs/csafestring/csafestring.c |
safe_strncmp | int safe_strncmp(csafestring_t *obj, const char *str, size_t size) {
size_t length = size;
if ( str == NULL ) {
return 1;
}
size_t strLength = strlen(str);
if ( obj->buffer_length < length ) {
length = obj->buffer_length;
}
if ( strLength < length ) {
length = strLength;
}
return strncmp(obj->data, ... | testq %rsi, %rsi
je 0x56b4
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2070
movq 0x8(%r15), %rcx
cmpq %rbx, %rcx
cmovbq %rcx, %rbx
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2050
mov... | /maximilianvoss[P]ctemplate/libs/json2map/libs/csafestring/csafestring.c |
Test_Versioning::~Test_Versioning() | Q_OBJECT
private slots:
void TestPrefixSameVersion()
{
bool needsUpgrade;
needsUpgrade = QSimpleUpdater::compareVersions("0.0.1", "0.0.1");
QVERIFY(!needsUpgrade);
needsUpgrade = QSimpleUpdater::compareVersions("0.0.1", "v0.0.1");
QVERIFY(!needsUpgrade);
needsUpgrade = QSimpleU... | pushq %rbx
movq %rdi, %rbx
callq 0x98a0
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x90f0
nop
| /alex-spataru[P]QSimpleUpdater/build_O3/UnitTests_autogen/KRHXW7JQHD/../../../tests/Test_Versioning.h |
QSimpleUpdater::~QSimpleUpdater() | QSimpleUpdater::~QSimpleUpdater()
{
URLS.clear();
foreach (Updater *updater, UPDATERS)
updater->deleteLater();
UPDATERS.clear();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x12cc1(%rip), %rax # 0x20290
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x1478b(%rip), %rdi # 0x21d68
callq 0xe342
movq 0x14797(%rip), %r14 # 0x21d80
movq 0x14798(%rip), %r15 # 0x21d88
movq 0x14799(%rip), %r12 # 0x21d90
testq ... | /alex-spataru[P]QSimpleUpdater/src/QSimpleUpdater.cpp |
QSimpleUpdater::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QSimpleUpdater::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<QSimpleUpdater *>(_o);
(void)_t;
switch (_id) {
case 0: _t->checkingFinished((*reinterpret_cast< std::add_pointer_t<QStri... | pushq %rbx
subq $0x20, %rsp
cmpl $0x5, %esi
je 0xdfa7
testl %esi, %esi
jne 0xe14e
cmpl $0x10, %edx
ja 0xe14e
movl %edx, %eax
leaq 0xa602(%rip), %rdx # 0x18580
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%rcx), %rax
movq %rsp, %rcx
movq $0x0, (%rcx)
movq %rax, 0x8(%rcx)
leaq 0x12360(%rip), %rsi ... | /alex-spataru[P]QSimpleUpdater/build_O3/QSimpleUpdater_autogen/include/moc_QSimpleUpdater.cpp |
Updater::~Updater() | Updater::~Updater()
{
delete m_downloader;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10845(%rip), %rax # 0x204e0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x120(%rdi), %rdi
testq %rdi, %rdi
je 0xfcb4
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x108(%rbx), %rax
testq %rax, %rax
je 0xfcdb
lock
decl (%rax)
jne 0xfcdb
movq 0x108(%rbx), %rdi
movl $0x2, %esi
movl $0x8, %edx
... | /alex-spataru[P]QSimpleUpdater/src/Updater.cpp |
Updater::onReply(QNetworkReply*) | void Updater::onReply(QNetworkReply *reply)
{
/* Check if we need to redirect */
QUrl redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
if (!redirect.isEmpty())
{
setUrl(redirect.toString());
checkForUpdates();
return;
}
/* There was a netw... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x2, %edx
callq 0x9d20
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
callq 0x9a90
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x9340
leaq 0x88(%rsp), %rdi
callq 0x9810
testb %al, %al
je 0x103... | /alex-spataru[P]QSimpleUpdater/src/Updater.cpp |
Updater::setUpdateAvailable(bool) | void Updater::setUpdateAvailable(const bool available)
{
m_updateAvailable = available;
QMessageBox box;
box.setTextFormat(Qt::RichText);
box.setIcon(QMessageBox::Information);
if (updateAvailable() && (notifyOnUpdate() || notifyOnFinish()))
{
QString text = tr("Would you like to dow... | pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
movb %sil, 0x43(%rdi)
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x9b60
movq %r14, %rdi
movl $0x1, %esi
callq 0x9a80
leaq 0xc8(%rsp), %rdi
movl $0x1, %esi
callq 0x9140
cmpb $0x0, 0x43(%rbx)
je 0x11394
cmpb $0x0, 0x41(%rbx)... | /alex-spataru[P]QSimpleUpdater/src/Updater.cpp |
Downloader::startDownload(QUrl const&) | void Downloader::startDownload(const QUrl &url)
{
/* Reset UI */
m_ui->progressBar->setValue(0);
m_ui->stopButton->setText(tr("Stop"));
m_ui->downloadLabel->setText(tr("Downloading updates"));
m_ui->timeLabel->setText(tr("Time remaining") + ": " + tr("unknown"));
/* Configure the network requ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movq 0x38(%rax), %rdi
xorl %esi, %esi
callq 0x9940
movq 0x68(%rbx), %rax
movq 0x68(%rax), %r15
leaq 0xdece(%rip), %rsi # 0x208f0
leaq 0x714c(%rip), %rdx # 0x19b75
movq %rsp, %r12
movq %r12, %rdi
... | /alex-spataru[P]QSimpleUpdater/src/Downloader.cpp |
Downloader::openDownload() | void Downloader::openDownload()
{
if (!m_fileName.isEmpty())
QDesktopServices::openUrl(QUrl::fromLocalFile(m_downloadDir.filePath(m_fileName)));
else
{
QMessageBox::critical(this, tr("Error"), tr("Cannot find downloaded update!"), QMessageBox::Close);
}
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x60(%rdi)
je 0x13afb
leaq 0x50(%rbx), %rdx
addq $0x48, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9200
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x9c30
leaq 0x20(%rsp), %rdi
callq 0x9820
leaq 0x20(%rsp), %rdi
callq 0x9190
movq 0... | /alex-spataru[P]QSimpleUpdater/src/Downloader.cpp |
Downloader::saveFile(long long, long long) | void Downloader::saveFile(qint64 received, qint64 total)
{
Q_UNUSED(received);
Q_UNUSED(total);
/* Check if we need to redirect */
QUrl url = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
if (!url.isEmpty())
{
startDownload(url);
return;
}
/*... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x9d20
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x9a90
leaq 0x10(%rsp), %rdi
callq 0x9340
leaq 0x8(%rsp), %rdi
callq 0x9810
testb %al, %al
je 0x13f20
movq 0x50(%rbx), %rax
movq %rax... | /alex-spataru[P]QSimpleUpdater/src/Downloader.cpp |
Downloader::calculateTimeRemaining(long long, long long) | void Downloader::calculateTimeRemaining(qint64 received, qint64 total)
{
uint difference = QDateTime::currentDateTime().toSecsSinceEpoch() - m_startTime;
if (difference > 0)
{
QString timeString;
qreal timeRemaining = (total - received) / (received / difference);
if (timeRemaining ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x9320
movq %r12, %rdi
callq 0x9210
movq %rax, %r12
movl 0x40(%rbx), %ebp
movq %rsp, %rdi
callq 0x95c0
subl %ebp, %r12d
je 0x1555f
xorps %xmm0, %xmm0
movaps %xmm0... | /alex-spataru[P]QSimpleUpdater/src/Downloader.cpp |
Downloader::qt_metacall(QMetaObject::Call, int, void**) | int Downloader::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 17)
qt_static_metacall(this, _c, _id, _a);
_id -= 17;
} else if (_c == QMetaO... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x98c0
movl %eax, %ebx
testl %eax, %eax
js 0x158e1
cmpl $0x7, %ebp
je 0x158cf
testl %ebp, %ebp
jne 0x158e1
cmpl $0x10, %ebx
ja 0x158de
movq %r15, %rdi
xorl %esi, %esi
movl %ebx, %edx
movq %r14, %rcx
callq 0x1572... | /alex-spataru[P]QSimpleUpdater/build_O3/QSimpleUpdater_autogen/include/moc_Downloader.cpp |
Ui_Downloader::retranslateUi(QWidget*) | void retranslateUi(QWidget *Downloader)
{
Downloader->setWindowTitle(QCoreApplication::translate("Downloader", "Updater", nullptr));
updater_icon->setText(QString());
downloadLabel->setText(QCoreApplication::translate("Downloader", "Downloading updates", nullptr));
timeLabel->setText... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3bd5(%rip), %rsi # 0x19f0b
leaq 0x3a85(%rip), %rdx # 0x19dc2
movq %rsp, %r15
movq %r15, %rdi
xorl %ecx, %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
callq 0x9cd0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9920
movq (... | /alex-spataru[P]QSimpleUpdater/build_O3/QSimpleUpdater_autogen/include/ui_Downloader.h |
Curl_add_buffer | CURLcode Curl_add_buffer(Curl_send_buffer *in, const void *inptr, size_t size)
{
char *new_rb;
size_t new_size;
if(~size < in->size_used) {
/* If resulting used size of send buffer would wrap size_t, cleanup
the whole buffer and return error. Otherwise the required buffer
size will fit into a s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
xorq $-0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x17312
jmp 0x172d8
leaq 0x7c771(%rip), %rax # 0x93a50
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
... | /macressler[P]curl/lib/http.c |
Curl_compareheader | bool
Curl_compareheader(const char *headerline, /* line to check */
const char *header, /* header keyword _with_ colon */
const char *content) /* content string to find */
{
/* RFC2616, section 4.2 says: "Each header field consists of a name followed
* by a colon (":") and th... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x367b0
cmpl $0x0, %eax
jne 0x17480
movb $0x0, -0x1(%rbp)
jmp 0x1756e
mov... | /macressler[P]curl/lib/http.c |
use_http_1_1plus | static bool use_http_1_1plus(const struct Curl_easy *data,
const struct connectdata *conn)
{
if((data->state.httpversion == 10) || (conn->httpversion == 10))
return FALSE;
if((data->set.httpversion == CURL_HTTP_VERSION_1_0) &&
(conn->httpversion <= 10))
return FALSE;
retu... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xa, 0x507c(%rax)
je 0x17d86
movq -0x18(%rbp), %rax
cmpl $0xa, 0x230(%rax)
jne 0x17d8c
movb $0x0, -0x1(%rbp)
jmp 0x17dda
movq -0x10(%rbp), %rax
cmpq $0x1, 0x5d8(%rax)
jne 0x17dad
movq -0x18(%rbp), %rax
cmpl $0xa, 0x230... | /macressler[P]curl/lib/http.c |
expect100 | static CURLcode expect100(struct Curl_easy *data,
struct connectdata *conn,
Curl_send_buffer *req_buffer)
{
CURLcode result = CURLE_OK;
const char *ptr;
data->state.expect100header = FALSE; /* default to false unless it is set
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x5080(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17d60
testb $0x1, %al
jne 0x17e79
jmp 0x17ef3
movq -0x10(%rbp), %rax
cmpl $0x14, 0x230... | /macressler[P]curl/lib/http.c |
header_append | static CURLcode header_append(struct Curl_easy *data,
struct SingleRequest *k,
size_t length)
{
size_t newsize = k->hbuflen + length;
if(newsize > CURL_MAX_HTTP_HEADER) {
/* The reason to have a max limit for this is to avoid the risk of a bad
s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x19000, -0x28(%rbp) # imm = 0x19000
jbe 0x19785
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x6290c(... | /macressler[P]curl/lib/http.c |
checkhttpprefix | static bool
checkhttpprefix(struct Curl_easy *data,
const char *s)
{
struct curl_slist *head = data->set.http200aliases;
bool rc = FALSE;
#ifdef CURL_DOES_CONVERSIONS
/* convert from the network encoding using a scratch area */
char *scratch = strdup(s);
if(NULL == scratch) {
failf(data, "... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x760(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x199b2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%r... | /macressler[P]curl/lib/http.c |
print_http_error | static void print_http_error(struct Curl_easy *data)
{
struct SingleRequest *k = &data->req;
char *beg = k->p;
/* make sure that data->req.p points to the HTTP status line */
if(!strncmp(beg, "HTTP", 4)) {
/* skip to HTTP status code */
beg = strchr(beg, ' ');
if(beg && *++beg) {
/* find tr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x61d4c(%rip), %rsi # 0x7b770
movl $0x4, %edx
callq 0x9400
cmpl $0x0, %eax
jne 0x19acc
movq ... | /macressler[P]curl/lib/http.c |
http_output_basic | static CURLcode http_output_basic(struct connectdata *conn, bool proxy)
{
size_t size = 0;
char *authorization = NULL;
struct Curl_easy *data = conn->data;
char **userp;
const char *user;
const char *pwd;
CURLcode result;
char *out;
if(proxy) {
userp = &conn->allocptr.proxyuserpwd;
user = con... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x11(%rbp)
je 0x19b53
movq -0x10(%rbp), %rax
addq $0x3f0, %rax # im... | /macressler[P]curl/lib/http.c |
checkrtspprefix | static bool
checkrtspprefix(struct Curl_easy *data,
const char *s)
{
bool result = FALSE;
#ifdef CURL_DOES_CONVERSIONS
/* convert from the network encoding using a scratch area */
char *scratch = strdup(s);
if(NULL == scratch) {
failf(data, "Failed to allocate memory for conversion!");
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x62418(%rip), %rdi # 0x7c0c7
movl $0x5, %edx
callq 0x9420
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x... | /macressler[P]curl/lib/http.c |
Curl_infof | void Curl_infof(struct Curl_easy *data, const char *fmt, ...)
{
if(data && data->set.verbose) {
va_list ap;
size_t len;
char print_buffer[2048 + 1];
va_start(ap, fmt);
vsnprintf(print_buffer, sizeof(print_buffer), fmt, ap);
va_end(ap);
len = strlen(print_buffer);
Curl_debug(data, CURLI... | pushq %rbp
movq %rsp, %rbp
subq $0x8f0, %rsp # imm = 0x8F0
testb %al, %al
je 0x19d47
movaps %xmm0, -0x8c0(%rbp)
movaps %xmm1, -0x8b0(%rbp)
movaps %xmm2, -0x8a0(%rbp)
movaps %xmm3, -0x890(%rbp)
movaps %xmm4, -0x880(%rbp)
movaps %xmm5, -0x870(%rbp)
movaps %xmm6, -0x860(%rbp)
movaps %xmm7, -0x850(%rbp)
movq %r9... | /macressler[P]curl/lib/sendf.c |
Curl_debug | int Curl_debug(struct Curl_easy *data, curl_infotype type,
char *ptr, size_t size,
struct connectdata *conn)
{
int rc;
if(data->set.printhost && conn && conn->host.dispname) {
char buffer[160];
const char *t = NULL;
const char *w = "Data";
switch(type) {
case CURLIN... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x791(%rax)
je 0x19f60
cmpq $0x0, -0x30(%rbp)
je 0x19f60
movq -0x30(%rbp), %rax
cmpq $0x0, 0xe0(%rax)... | /macressler[P]curl/lib/sendf.c |
Curl_failf | void Curl_failf(struct Curl_easy *data, const char *fmt, ...)
{
if(data->set.verbose || data->set.errorbuffer) {
va_list ap;
size_t len;
char error[CURL_ERROR_SIZE + 2];
va_start(ap, fmt);
vsnprintf(error, CURL_ERROR_SIZE, fmt, ap);
len = strlen(error);
if(data->set.errorbuffer && !data->... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
testb %al, %al
je 0x19fd7
movaps %xmm0, -0x1c0(%rbp)
movaps %xmm1, -0x1b0(%rbp)
movaps %xmm2, -0x1a0(%rbp)
movaps %xmm3, -0x190(%rbp)
movaps %xmm4, -0x180(%rbp)
movaps %xmm5, -0x170(%rbp)
movaps %xmm6, -0x160(%rbp)
movaps %xmm7, -0x150(%rbp)
movq %r9... | /macressler[P]curl/lib/sendf.c |
Curl_sendf | CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn,
const char *fmt, ...)
{
struct Curl_easy *data = conn->data;
ssize_t bytes_written;
size_t write_len;
CURLcode result = CURLE_OK;
char *s;
char *sptr;
va_list ap;
va_start(ap, fmt);
s = vaprintf(fmt, ap); /* return... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x1a141
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(... | /macressler[P]curl/lib/sendf.c |
Curl_write | CURLcode Curl_write(struct connectdata *conn,
curl_socket_t sockfd,
const void *mem,
size_t len,
ssize_t *written)
{
ssize_t bytes_written;
CURLcode result = CURLE_OK;
int num = (sockfd == conn->sock[SECONDARYSOCKET]);
bytes_writte... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x25c(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x40(%rbp)
movq -... | /macressler[P]curl/lib/sendf.c |
Curl_write_plain | CURLcode Curl_write_plain(struct connectdata *conn,
curl_socket_t sockfd,
const void *mem,
size_t len,
ssize_t *written)
{
ssize_t bytes_written;
CURLcode result;
int num = (sockfd == conn->sock[SECONDARYSOCKET... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x25c(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x38(... | /macressler[P]curl/lib/sendf.c |
Curl_recv_plain | ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf,
size_t len, CURLcode *code)
{
curl_socket_t sockfd = conn->sock[num];
ssize_t nread;
/* Check and return data that already received and storied in internal
intermediate buffer */
nread = get_pre_recved(conn, num, ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0x258(%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jle 0x1a553
mov... | /macressler[P]curl/lib/sendf.c |
Curl_client_write | CURLcode Curl_client_write(struct connectdata *conn,
int type,
char *ptr,
size_t len)
{
struct Curl_easy *data = conn->data;
if(0 == len)
len = strlen(ptr);
DEBUGASSERT(type <= 3);
/* FTP data may need conversion. */
if((t... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x1a647
movq -0x20(%rbp), %rdi
callq 0x93b0
movq %rax, -0x28(%rbp)
jmp 0x1a64... | /macressler[P]curl/lib/sendf.c |
convert_lineends | static size_t convert_lineends(struct Curl_easy *data,
char *startPtr, size_t size)
{
char *inPtr, *outPtr;
/* sanity check */
if((startPtr == NULL) || (size < 1)) {
return size;
}
if(data->state.prev_block_had_trailing_cr) {
/* The previous block of incoming data
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a6f2
cmpq $0x1, -0x20(%rbp)
jae 0x1a6ff
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a89e
movq -0x10(%rbp), %rax
testb $0x1, 0x5082(%rax)
je 0x1a75e
movq -0x18(%rbp), %rax... | /macressler[P]curl/lib/sendf.c |
chop_write | static CURLcode chop_write(struct connectdata *conn,
int type,
char *optr,
size_t olen)
{
struct Curl_easy *data = conn->data;
curl_write_callback writeheader = NULL;
curl_write_callback writebody = NULL;
char *ptr = optr;
size_t... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq ... | /macressler[P]curl/lib/sendf.c |
Curl_read_plain | CURLcode Curl_read_plain(curl_socket_t sockfd,
char *buf,
size_t bytesfromsocket,
ssize_t *n)
{
ssize_t nread = sread(sockfd, buf, bytesfromsocket);
if(-1 == nread) {
int err = SOCKERRNO;
int return_error;
#ifdef USE_WINSOCK
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x92b0
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq -0x28(%rbp), %rax
jne 0x1ac13
callq 0x90b0
... | /macressler[P]curl/lib/sendf.c |
Curl_read | CURLcode Curl_read(struct connectdata *conn, /* connection data */
curl_socket_t sockfd, /* read from this socket */
char *buf, /* store read data here */
size_t sizerequested, /* max amount to read */
ssize_t *n) ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x38, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq ... | /macressler[P]curl/lib/sendf.c |
showit | static int showit(struct Curl_easy *data, curl_infotype type,
char *ptr, size_t size)
{
static const char s_infotype[CURLINFO_END][3] = {
"* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
int rc = 0;
#ifdef CURL_DOES_CONVERSIONS
char *buf = NULL;
size_t conv_size = 0;
switch(type) {
case C... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2c0(%rax)
je 0x1af11
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x42ce0
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
movq -0x8(... | /macressler[P]curl/lib/sendf.c |
pausewrite | static CURLcode pausewrite(struct Curl_easy *data,
int type, /* what type of data */
const char *ptr,
size_t len)
{
/* signalled to pause sending on this connection, but since we have data
we want to send we need to dup it to save a... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0xc68, %rax # imm = 0xC68
movq %rax, -0x38(%rbp)
movb $0x1, -0x45(%rbp)
movq -0x3... | /macressler[P]curl/lib/sendf.c |
ftp_setup_connection | static CURLcode ftp_setup_connection(struct connectdata *conn)
{
struct Curl_easy *data = conn->data;
char *type;
char command;
struct FTP *ftp;
conn->data->req.protop = ftp = malloc(sizeof(struct FTP));
if(NULL == ftp)
return CURLE_OUT_OF_MEMORY;
data->state.path++; /* don't include the initial s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x28, %edi
leaq 0x78885(%rip), %rax # 0x93a48
callq *(%rax)
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x1e8(%rax)
xorl %eax, %eax
... | /macressler[P]curl/lib/ftp.c |
ftp_do | static CURLcode ftp_do(struct connectdata *conn, bool *done)
{
CURLcode result = CURLE_OK;
struct ftp_conn *ftpc = &conn->proto.ftpc;
*done = FALSE; /* default to false */
ftpc->wait_data_conn = FALSE; /* default to no such wait */
if(conn->data->state.wildcardmatch) {
result = wc_statemach(conn);
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x99(%rax)
movq -0x10(%rbp), %rax
movq (%ra... | /macressler[P]curl/lib/ftp.c |
ftp_done | static CURLcode ftp_done(struct connectdata *conn, CURLcode status,
bool premature)
{
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
ssize_t nread;
int ftpcode;
CURLcode result = ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax ... | /macressler[P]curl/lib/ftp.c |
ftp_do_more | static CURLcode ftp_do_more(struct connectdata *conn, int *completep)
{
struct Curl_easy *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = CURLE_OK;
bool connected = FALSE;
bool complete = FALSE;
/* the ftp struct is inited in ftp_connect() */
struct FTP *ftp = data->req.pr... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movb $0x0, -0x2d(%rbp)
movb $0x0, -0x2e(%rbp)
movq -0x... | /macressler[P]curl/lib/ftp.c |
ftp_connect | static CURLcode ftp_connect(struct connectdata *conn,
bool *done) /* see description above */
{
CURLcode result;
struct ftp_conn *ftpc = &conn->proto.ftpc;
struct pingpong *pp = &ftpc->pp;
*done = FALSE; /* default to not done yet */
/* We always support persistent connectio... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3c850
m... | /macressler[P]curl/lib/ftp.c |
ftp_multi_statemach | static CURLcode ftp_multi_statemach(struct connectdata *conn,
bool *done)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = Curl_pp_statemach(&ftpc->pp, FALSE);
/* Check for the state outside of the Curl_socket_check() return code checks
since at times we are... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x54bf0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0xbc(%rax), %edx
xorl %eax, %eax
movl $... | /macressler[P]curl/lib/ftp.c |
ftp_doing | static CURLcode ftp_doing(struct connectdata *conn,
bool *dophase_done)
{
CURLcode result = ftp_multi_statemach(conn, dophase_done);
if(result)
DEBUGF(infof(conn->data, "DO phase failed\n"));
else if(*dophase_done) {
result = ftp_dophase_done(conn, FALSE /* not connected */);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c040
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1c0cc
jmp 0x1c0c8
jmp 0x1c0ca
jmp 0x1c0e9
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x1c0e7
movq -0x8(%rbp), %rdi
xorl... | /macressler[P]curl/lib/ftp.c |
ftp_domore_getsock | static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks,
int numsocks)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(!numsocks)
return GETSOCK_BLANK;
/* When in DO_MORE state, we could be either waiting for us to connect to a
* remote site, or we could... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1c163
movl $0x0, -0x4(%rbp)
jmp 0x1c244
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl 0xbc(... | /macressler[P]curl/lib/ftp.c |
ftp_readresp | static CURLcode ftp_readresp(curl_socket_t sockfd,
struct pingpong *pp,
int *ftpcode, /* return the ftp-code if done */
size_t *size) /* size of the response */
{
struct connectdata *conn = pp->conn;
struct Curl_easy *data = conn... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x8(%rbp), %edi
movq -0x... | /macressler[P]curl/lib/ftp.c |
Curl_ftpsend | CURLcode Curl_ftpsend(struct connectdata *conn, const char *cmd)
{
ssize_t bytes_written;
#define SBUF_SIZE 1024
char s[SBUF_SIZE];
size_t write_len;
char *sptr = s;
CURLcode result = CURLE_OK;
#ifdef HAVE_GSSAPI
enum protection_level data_sec = conn->data_prot;
#endif
write_len = strlen(cmd);
if(write... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x430(%rbp)
movl $0x0, -0x434(%rbp)
movq -0x18(%rbp), %rdi
callq 0x93b0
movq %rax, -0x428(%rbp)
cmpq $0x3fd, -0x428(%rbp) # imm = 0x3FD
jbe 0x1c664
movl $0x2b, -0x4(%rb... | /macressler[P]curl/lib/ftp.c |
state | static void _state(struct connectdata *conn,
ftpstate newstate
#ifdef DEBUGBUILD
, int lineno
#endif
)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
#if defined(DEBUGBUILD)
#if defined(CURL_DISABLE_VERBOSE_STRINGS)
(void) lineno;
#else
if(ftpc->state != newstate)
infof... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xbc(%rax)
popq %rbp
retq
nopl (%rax,%rax)
| /macressler[P]curl/lib/ftp.c |
ftp_state_user_resp | static CURLcode ftp_state_user_resp(struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax ... | /macressler[P]curl/lib/ftp.c |
ftp_state_user | static CURLcode ftp_state_user(struct connectdata *conn)
{
CURLcode result;
struct FTP *ftp = conn->data->req.protop;
/* send USER */
PPSENDF(&conn->proto.ftpc.pp, "USER %s", ftp->user?ftp->user:"");
state(conn, FTP_USER);
conn->data->state.ftp_trying_alternative = FALSE;
return CURLE_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1d7f5
movq -0x20(%rbp), %rax... | /macressler[P]curl/lib/ftp.c |
ftp_state_acct_resp | static CURLcode ftp_state_acct_resp(struct connectdata *conn,
int ftpcode)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
if(ftpcode != 230) {
failf(data, "ACCT rejected by server: %03d", ftpcode);
result = CURLE_FTP_WEIRD_PASS_REPLY; /* FIX */
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0xe6, -0xc(%rbp)
je 0x1d8a8
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x5ed94(%rip), %rsi # 0x7c62c
movb $0x0, %al
callq 0x19f90... | /macressler[P]curl/lib/ftp.c |
ftp_state_quote | static CURLcode ftp_state_quote(struct connectdata *conn,
bool init,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
bool quote = ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax... | /macressler[P]curl/lib/ftp.c |
ftp_state_mdtm | static CURLcode ftp_state_mdtm(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
/* Requested time of file or time-depended transfer? */
if((data->set.get_filetime || data->set.timecondition) && ftpc->file) {
/* we hav... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x792(%rax)
jne 0x1dc56
movq -0x20(%rbp), ... | /macressler[P]curl/lib/ftp.c |
ftp_state_mdtm_resp | static CURLcode ftp_state_mdtm_resp(struct connectdata *conn,
int ftpcode)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct FTP *ftp = data->req.protop;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(ftpcode) {
case 213:
{
/* we got ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x628, %... | /macressler[P]curl/lib/ftp.c |
ftp_state_type_resp | static CURLcode ftp_state_type_resp(struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
if(ftpcode/100 != 2) {
/* "sasserftpd" and "(u)r(x)bot ftpd" both responds wi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x2, %eax
je 0x1e12f
movq -0x28(%rbp), %rdi
leaq 0x5e860(%... | /macressler[P]curl/lib/ftp.c |
ftp_state_rest_resp | static CURLcode ftp_state_rest_resp(struct connectdata *conn,
int ftpcode,
ftpstate instate)
{
CURLcode result = CURLE_OK;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(instate) {
case FTP_REST:
default:
#ifdef CURL_FTP_HTTPSTYLE_HEA... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x1a, %eax
je 0x1e32e
jmp 0x1e324
movl -0x4... | /macressler[P]curl/lib/ftp.c |
ftp_state_use_pasv | static CURLcode ftp_state_use_pasv(struct connectdata *conn)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result = CURLE_OK;
/*
Here's the excecutive summary on what to do:
PASV is RFC959, expect:
227 Entering Passive Mode (a1,a2,a3,a4,p1,p2)
LPSV is RFC1639, expect:
228 Entering Lo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x39c(%rax)
jne 0x1e456
movq -0x10(%rbp), %rax
testb $0x1, 0x393(%rax)
je 0x1e456
movq -0x10(%rbp), %rax
m... | /macressler[P]curl/lib/ftp.c |
ftp_state_pasv_resp | static CURLcode ftp_state_pasv_resp(struct connectdata *conn,
int ftpcode)
{
struct ftp_conn *ftpc = &conn->proto.ftpc;
CURLcode result;
struct Curl_easy *data = conn->data;
struct Curl_dns_entry *addr = NULL;
int rc;
unsigned short connectport; /* the local port connect(... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x628, %rax # imm = 0x628
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0xca0(%rax), %rax
addq $0x... | /macressler[P]curl/lib/ftp.c |
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.