name stringlengths 1 4.98k | code stringlengths 61 2.07M | asm stringlengths 57 12.9M | file stringlengths 18 192 |
|---|---|---|---|
hlkvds::MediumTier::SetSBReservedContent(char*, unsigned long) | bool MediumTier::SetSBReservedContent(char* buf, uint64_t length) {
char* buf_ptr = buf;
uint64_t medium_tier_header_size = sizeof(MultiTierDS_SB_Reserved_MediumTier_Header);
memcpy((void*)&sbResMediumTierHeader_, (const void *)buf_ptr, medium_tier_header_size);
__DEBUG("MultiTierDS_SB_Reserved_MediumTi... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x158(%rsp)
movq %rsi, 0x150(%rsp)
movq %rdx, 0x148(%rsp)
movq 0x158(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x140(%rsp)
movq $0x8, 0x138(%rsp)
addq $0x18, %rdi
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rdx
callq 0x8410
movq 0x10(%rsp), %... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::GetSST(char*, unsigned long) | bool MediumTier::GetSST(char* buf, uint64_t length) {
char* buf_ptr = buf;
for (uint32_t i = 0; i < volNum_; i++) {
uint64_t vol_sst_length = volMap_[i]->GetSSTLength();
if ( !volMap_[i]->GetSST(buf_ptr, vol_sst_length) ) {
return false;
}
buf_ptr += vol_sst_length;
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4d540
movq (%rsp), %rdi
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::SetSST(char*, unsigned long) | bool MediumTier::SetSST(char* buf, uint64_t length) {
char* buf_ptr = buf;
for (uint32_t i = 0; i < volNum_; i++) {
uint64_t vol_sst_length = volMap_[i]->GetSSTLength();
if ( !volMap_[i]->SetSST(buf_ptr, vol_sst_length) ) {
return false;
}
buf_ptr += vol_sst_length;
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4d610
movq (%rsp), %rdi
addq $0x48, %rdi
movl 0x1c(%rsp), %eax
... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::CreateVolume(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&) | bool MediumTier::CreateVolume(std::vector<BlockDevice*> &bd_vec) {
segSize_ = options_.secondary_seg_size;
uint32_t align_bit = log2(ALIGNED_SIZE);
if (segSize_ != (segSize_ >> align_bit) << align_bit) {
__ERROR("Medium Tier Segment Size is not page aligned!");
return false;
}
int ... | subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq (%rax), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x38(%rax)
movl $0x1000, %edi # imm = 0x1000
callq 0x16680
movq 0x38(%rsp), %rcx
cvttsd2si %xmm0, %rax
movl %eax, 0x9c(%rsp)
movl 0x38(%rcx), %eax
movl 0x... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::initSBReservedContentForCreate() | void MediumTier::initSBReservedContentForCreate() {
sbResMediumTierHeader_.segment_size = segSize_;
sbResMediumTierHeader_.volume_num = volNum_;
for (uint32_t i = 0; i < volNum_; i++) {
MultiTierDS_SB_Reserved_MediumTier_Content sb_res_item;
string dev_path = volMap_[i]->GetDevicePath();
... | subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x190(%rsp)
movq 0x190(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x38(%rax), %ecx
movl %ecx, 0x18(%rax)
movl 0x40(%rax), %ecx
movl %ecx, 0x1c(%rax)
movl $0x0, 0x18c(%rsp)
movq 0x40(%rsp), %rcx
movl 0x18c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4da4e
leaq 0x84(%rsp), %r... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::OpenVolume(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&) | bool MediumTier::OpenVolume(std::vector<BlockDevice*> &bd_vec) {
int fast_tier_device_num = hlkvds::FastTierVolNum;
segSize_ = sbResMediumTierHeader_.segment_size;
volNum_ = sbResMediumTierHeader_.volume_num;
if (!verifyTopology(bd_vec)) {
__ERROR("TheDevice Topology is inconsistent");
... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x98(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0x1, 0x8c(%rsp)
movl 0x18(%rdi), %eax
movl %eax, 0x38(%rdi)
movl 0x1c(%rdi), %eax
movl %eax, 0x40(%rdi)
movq 0x90(%rsp), %rsi
callq 0x4dcc0
testb $0x1, %al
jne 0x4db29
jmp 0x4daae
movq 0x23523(%rip), %rax ... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::verifyTopology(std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&) | bool MediumTier::verifyTopology(std::vector<BlockDevice*> &bd_vec) {
int fast_tier_device_num = hlkvds::FastTierVolNum;
// Verify MediumTier Volume Number
if (volNum_ != bd_vec.size() - fast_tier_device_num) {
__ERROR("record MediumTierVolNum_ = %d, total block device number: %d", volNum_, (int)bd_... | subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x1, 0xbc(%rsp)
movl 0x40(%rax), %eax
movq %rax, 0x50(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x166c0
movq %rax, %rcx
movq 0x50(%rsp), %rax
movslq 0xbc(%rsp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
je 0x4ddc6
jmp 0x4d... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::GetTotalFreeSegs() | uint32_t MediumTier::GetTotalFreeSegs() {
uint32_t free_num = 0;
for (uint32_t i = 0; i < volNum_; i++) {
free_num += volMap_[i]->GetTotalFreeSegs();
}
return free_num;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4e059
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x160f0... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::GetTotalUsedSegs() | uint32_t MediumTier::GetTotalUsedSegs() {
uint32_t used_num = 0;
for (uint32_t i = 0; i < volNum_; i++) {
used_num += volMap_[i]->GetTotalUsedSegs();
}
return used_num;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4e0d9
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x160f0... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::MediumTier::GetSSTLength() | uint64_t MediumTier::GetSSTLength() {
uint64_t length = 0;
for (uint32_t i = 0; i < volNum_; i++) {
length += volMap_[i]->GetSSTLength();
}
return length;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x40(%rcx), %eax
jae 0x4e15c
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x160f0... | yangwanyuan[P]HLKVDS/src/Tier.cc |
hlkvds::KVTime::operator>(hlkvds::KVTime const&) | bool KVTime::operator>(const KVTime& toBeCopied) {
if (tm_.tv_sec > toBeCopied.tm_.tv_sec) {
return true;
} else if (tm_.tv_sec < toBeCopied.tm_.tv_sec) {
return false;
} else {
return tm_.tv_usec > toBeCopied.tm_.tv_usec;
}
} | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jle 0x507d8
movb $0x1, -0x1(%rsp)
jmp 0x5080c
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jge 0x507f1
movb $0x0, -0x1(%rsp)
jmp 0x5... | yangwanyuan[P]HLKVDS/src/Utils.cc |
hlkvds::Thread::Start() | int Thread::Start() {
int result = pthread_create(&tid_, NULL, runThread, (void *) this);
if (result == 0) {
running_ = 1;
}
return result;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq %rcx, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x94(%rip), %rdx # 0x50930
callq 0x8890
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x509df
movq (%rsp), %rax
movl $0x1, 0x10(%rax)
movl 0xc(%rsp), %eax
addq $0x18... | yangwanyuan[P]HLKVDS/src/Utils.cc |
hlkvds::Thread::Join() | int Thread::Join() {
int result = -1;
if (running_ == 1) {
result = pthread_join(tid_, NULL);
if (result == 0) {
detached_ = 0;
}
}
return result;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rax)
jne 0x50a39
movq (%rsp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8490
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x50a37
movq (%rsp), %rax
mov... | yangwanyuan[P]HLKVDS/src/Utils.cc |
hlkvds::Thread::Detach() | int Thread::Detach() {
int result = -1;
if (running_ == 1 && detached_ == 0) {
result = pthread_detach(tid_);
if (result == 0) {
detached_ = 1;
}
}
return result;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rax)
jne 0x50a9f
movq (%rsp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x50a9f
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8370
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x50a9d
m... | yangwanyuan[P]HLKVDS/src/Utils.cc |
hlkvds::Volume::GCThdEntry() | void Volume::GCThdEntry() {
__DEBUG("GC thread start!!");
while (!gcT_stop_) {
gcMgr_->BackGC();
usleep(1000000);
} __DEBUG("GC thread stop!!");
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x16f80
xorb $-0x1, %al
testb $0x1, %al
jne 0x50dd9
jmp 0x50df3
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x227b0
movl $0xf4240, %edi # imm = 0xF4240
callq 0x86e0
jmp 0x50dc3
add... | yangwanyuan[P]HLKVDS/src/Volume.cc |
hlkvds::Volume::Read(char*, unsigned long, long) | bool Volume::Read(char* data, size_t count, off_t offset) {
uint64_t phy_offset = offset + startOff_;
if (bdev_->pRead(data, count, phy_offset) != (ssize_t)count) {
__ERROR("Read data error!!!");
return false;
}
return true;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rdi), %rax
callq *0x50(%rax)
cmpq 0x18... | yangwanyuan[P]HLKVDS/src/Volume.cc |
hlkvds::Volume::Write(char*, unsigned long, long) | bool Volume::Write(char* data, size_t count, off_t offset) {
uint64_t phy_offset = offset + startOff_;
if (bdev_->pWrite(data, count, phy_offset) != (ssize_t)count) {
__ERROR("Write data error!!!");
return false;
}
return true;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rdi), %rax
callq *0x48(%rax)
cmpq 0x18... | yangwanyuan[P]HLKVDS/src/Volume.cc |
hlkvds::Volume::CalcSegOffsetFromOffset(unsigned long, unsigned long&) | bool Volume::CalcSegOffsetFromOffset(uint64_t offset,
uint64_t& seg_offset) {
uint32_t seg_id = 0;
if (!CalcSegIdFromOffset(offset, seg_id)) {
return false;
}
if (!CalcSegOffsetFromId(seg_id, seg_offset)) {
return false;
}
return true;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x515e0
testb $0x1, %al
jne 0x512ef
movb $0x0, 0x37(%rsp)
jmp 0x51312
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18... | yangwanyuan[P]HLKVDS/src/Volume.cc |
hlkvds::Volume::CalcDataOffsetPhyFromEntry(hlkvds::HashEntry*, unsigned long&) | bool Volume::CalcDataOffsetPhyFromEntry(HashEntry* entry,
uint64_t& data_offset) {
uint64_t seg_offset = 0;
uint64_t header_offset = entry->GetHeaderOffset();
if (!CalcSegOffsetFromOffset(header_offset, seg_offset)) {
return false;
}
data_offset = ... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x51640
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x512b0
testb $0x1, %al
jne 0x51374
movb ... | yangwanyuan[P]HLKVDS/src/Volume.cc |
hlkvds::Volume::ModifyDeathEntry(hlkvds::HashEntry&) | void Volume::ModifyDeathEntry(HashEntry &entry) {
uint32_t seg_id;
uint64_t offset = entry.GetHeaderOffset();
if (!CalcSegIdFromOffset(offset, seg_id)) {
__ERROR("Calculate Seg Id Wrong!!! offset = %ld", offset);
}
uint16_t data_size = entry.GetDataSize();
uint32_t death_size = (uint32_... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x51640
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x34(%rsp), %rdx
callq 0x515e0
testb $0x1, %al
jne 0x514b6
jmp 0x51441
movq 0x1fb90(%rip), %rax # 0x70fd... | yangwanyuan[P]HLKVDS/src/Volume.cc |
hlkvds::Volume::CalcSegIdFromOffset(unsigned long, unsigned int&) | inline bool CalcSegIdFromOffset(uint64_t offset, uint32_t& seg_id) {
seg_id = offset >> segSizeBit_;
if (seg_id >= segNum_) {
return false;
}
return true;
} | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movq -0x18(%rsp), %rax
movl 0x40(%rcx), %ecx
shrq %cl, %rax
movq -0x28(%rsp), %rcx
movl %eax, %edx
movq -0x20(%rsp), %rax
movl %edx, (%rax)
movq -0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0x3c(%rcx), %eax
jb... | yangwanyuan[P]HLKVDS/./src/include/Volume.h |
hlkvds::WriteBatch::clear() | void WriteBatch::clear() {
while(!batch_.empty()) {
KVSlice *slice = batch_.front();
batch_.pop_front();
delete slice;
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x239b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x51ad5
jmp 0x51b17
movq 0x10(%rsp), %rdi
callq 0x239d0
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x23a00
movq 0x18(%rsp), %rax
movq %rax, ... | yangwanyuan[P]HLKVDS/src/Write_batch.cc |
array_vector_equal() | TEST(array_vector_equal) {
int a[] = { 1, 2 };
std::vector<double> b = { 1.0, 2.0 };
ASSERT_SEQUENCE_EQUAL(a, b);
ASSERT_SEQUENCE_EQUAL(b, a);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rbp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x40(%rbp)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, ... | eecs280staff[P]unit_test_framework/test/sequence_equal.cpp |
array_vector_unequal() | TEST(array_vector_unequal) {
int a[] = { 1, 2 };
std::vector<double> b = { 1.0, 2.0, -2.1 };
ASSERT_SEQUENCE_EQUAL(a, b);
ASSERT_SEQUENCE_EQUAL(b, a);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, -0x8(%rbp)
movabsq $-0x3fff333333333333, %rax # imm = 0xC000CCCCCCCCCCCD
movq %rax, -0x40(%rbp)
movups 0x79dd(%rip), %xmm0 # 0xb3f8
movaps %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq ... | eecs280staff[P]unit_test_framework/test/sequence_equal.cpp |
void unit_test_framework::Assertions::assert_sequence_equal<int (&) [2], int (&) [2]>(int (&) [2], int (&) [2], int, char const*) | static void assert_sequence_equal(First&& first, Second&& second,
int line_number,
const char* assertion_text) {
using std::begin;
using std::end;
auto it1 = begin(first);
auto it2 = begin(second);
auto end1 = end(... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5490
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5490
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x54a0
movq %r... | eecs280staff[P]unit_test_framework/./unit_test_framework.hpp |
decltype(print(fp, (*std::begin(fp0), *std::end(fp0))))& unit_test_framework::Diagnostic::print_sequence_helper<int [2]>(std::ostream&, int const (&) [2]) | static auto print_sequence_helper(std::ostream &os, const Sequence& seq)
-> decltype(print(os, (*std::begin(seq), *std::end(seq))))& {
if (std::begin(seq) == std::end(seq)) {
return os << "{}";
}
auto it = std::begin(seq);
os << "{ ";
print(os, *it);
for (++it; it != s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5740
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5750
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x569b
movq -0x10(%rbp), %rdi
leaq 0x5a03(%rip), %rsi # 0xb090
callq 0x... | eecs280staff[P]unit_test_framework/./unit_test_framework.hpp |
solution(std::vector<int, std::allocator<int>>&) | int solution(vector<int> &A) {
int n = A.size();
int minI = 0;
double minAvg = (A[0] + A[1]) / 2.0;
for (int i = 0; i < n - 2; i++) {
double avg = (A[i] + A[i + 1]) / 2.0;
if (avg < minAvg) {
minAvg = avg;
minI = i;
}
avg = (A[i] + A[i + 1] + A[i + 2]) / 3.0;
if (avg < minAvg) {
minAvg = avg;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1550
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1570
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x1570
movq %rax, %rcx... | zengfenfei[P]codility/src/MinAvgTwoSlice.cpp |
main | int main() {
vector<int> A(7);
A[0] = 4;
A[1] = 2;
A[2] = 2;
A[3] = 5;
A[4] = 1;
A[5] = 5;
A[6] = 8;
cout << solution(A) << '\n'; // 1
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1590
movq -0x38(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
callq 0x15b0
jmp 0x1439
leaq -0x19(%rbp), %rdi
callq 0x1620
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1570
movq... | zengfenfei[P]codility/src/MinAvgTwoSlice.cpp |
main | int main(int argc, char * argv[]){
//Check arguments for right input
if ( !isArgCountCorrect ( argc ) ) return 1;
total_nodes = std::stoi(argv[1]);
if ( !isPowerOfTwo(total_nodes) ) return 1;
string routing_model = argv[2];
if ( !isValidOption(routing_model) ) return 1;
bits_for_node = log2(... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x8610
cmpl $0x0, %eax
jne 0x24d2
movl $0x1, -0x4(%rbp)
jmp 0x2ff8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x340(%rbp)
leaq -0x31(%rbp), %r... | robertomaldonado[P]HypercubeTopologyRouting/links.cpp |
create_map(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&) | void create_map( map<int, vector<int> > &nodes_map){
vector<int> vector_nodes;
vector<int> x_ors;
vector<int> tmp_neighbors;
//Initialize the vector for nodes
for(int i=0; i < total_nodes; i++)
vector_nodes.push_back(i);
//Initialize the bits to Xor against
int last_bit = 1;
f... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3a30
leaq -0x38(%rbp), %rdi
callq 0x3a30
leaq -0x50(%rbp), %rdi
callq 0x3a30
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl 0xd14e(%rip), %eax # 0x10198
jge 0x3094
leaq -0x20(%rbp), %rdi
leaq -0x54(%rbp), %rsi
call... | robertomaldonado[P]HypercubeTopologyRouting/links.cpp |
print_single_route(int, std::vector<int, std::allocator<int>>&) | void print_single_route(int bits_for_node, vector<int> &ref_to_route){
for(int i = 0 ; i < ref_to_route.size() ; i++){
printf( int_to_bin_str(bits_for_node, ref_to_route[i]).c_str() );
if( i+1 != ref_to_route.size() )
printf("->");
else
printf("\n");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42b0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x32f0
movl -0x4(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%r... | robertomaldonado[P]HypercubeTopologyRouting/links.cpp |
recursive_flip(std::vector<bool, std::allocator<bool>>, std::vector<bool, std::allocator<bool>>, std::vector<bool, std::allocator<bool>>) | void recursive_flip( vector<bool> vector_src, vector<bool> vector_dst, vector<bool> current_xor){
int current;
vector<bool> vector_original = vector_src;
//000 to 011
// 000, 001, 011 //xored is 010
// 000, 010, 011 //xored is 000
current = bin_vector_to_int( bits_for_node, vector_sr... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x1f0(%rbp)
movq %rax, -0x200(%rbp)
movq %rdx, -0x1f8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3c20
movq -0x1f0(%rbp), %rsi
movl 0xce54(%rip),... | robertomaldonado[P]HypercubeTopologyRouting/links.cpp |
factorial(int) | int factorial(int n){
int fact = 1;
while( n>0 ){
fact = fact*n;
n--;
}
return fact;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x38d9
movl -0x8(%rbp), %eax
imull -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x38be
movl -0x8(%rbp), %eax
popq %rbp
retq
nop
| robertomaldonado[P]HypercubeTopologyRouting/links.cpp |
isArgCountCorrect(int) | int isArgCountCorrect(int arg_count){
if (arg_count != 3){
cout << "Usage: ./executable Nsize [dim|all]" << endl;
return 0;
}else{
return 1;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x864c
movq 0x79a0(%rip), %rdi # 0xffc8
leaq 0x2af1(%rip), %rsi # 0xb120
callq 0x21a0
movq %rax, %rdi
movq 0x797a(%rip), %rsi # 0xffb8
callq 0x21d0
movl $0x0, -0x4(%rbp)
jmp 0x8653
movl $0x1, -0x4(%rbp)
movl -0x4(%... | robertomaldonado[P]HypercubeTopologyRouting/checker.cpp |
isPowerOfTwo(int) | int isPowerOfTwo(int n_size){
if ( (ceil(log2(n_size)) == floor(log2(n_size))) ){
return 1;
}else{
cout << "Error: Nsize must be a power of 2 for hypercube." << endl;
return 0;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x39c0
callq 0x2060
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x39c0
callq 0x2260
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x86a3
jp 0x86a3
movl $0x1, -0x4(%rbp)
jmp 0x86cc
movq 0x791e(%... | robertomaldonado[P]HypercubeTopologyRouting/checker.cpp |
isValidOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | int isValidOption(string routing_model){
if ( routing_model.compare("dim") == 0 || routing_model.compare("all") == 0 ){
return 1;
}else{
cout << "Usage: ./executable Nsize [dim|all]" << endl;
return 0;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x2910(%rip), %rsi # 0xb007
callq 0x2080
cmpl $0x0, %eax
je 0x8716
movq -0x18(%rbp), %rdi
leaq 0x2976(%rip), %rsi # 0xb082
callq 0x2080
cmpl $0x0, %eax
jne 0x871f
movl $0x1, -0x4(%rbp)
jmp 0x8748
movq 0x78a2(%rip), ... | robertomaldonado[P]HypercubeTopologyRouting/checker.cpp |
map_to_bin_str[abi:cxx11](std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int) | std::string map_to_bin_str(std::map<int, std::vector<int> > &nodes_map , int n_size){
int bit_size = log2(n_size); //Stores how many bits long is each node
std::string output = "";
//For each node in the map, print it with the corresponding neighbors
for(std::map<int,std::vector<int> >::iterator nodes_... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x39c0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0xa8(%r... | robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp |
int_to_bin_str[abi:cxx11](int, int) | std::string int_to_bin_str(int bit_size, int node){
int tmp_count = 0;
std::vector<bool> node_bits;
std::string output_str = "";
output_str += std::to_string(node) + "(";
//Keep adding the bits based on the parity of bits
while(node != 0){
if( (node % 2) == 0 ){
node_bits.pus... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9120
movb $0x0, -0x41(%rbp)
leaq -0x42(%rbp), %rdi
movq %rdi, -0xd8... | robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp |
bin_vector_to_int(int, std::vector<bool, std::allocator<bool>>) | int bin_vector_to_int(int bit_size, std::vector<bool >node){
int translated_node = 0;
// cout << "Began translation..."<<endl;
for(int i=0; i < node.size(); i++){
// cout << pow(2, i) * node[i] << endl;
translated_node += pow(2, i) * node[i];
}
return translated_node;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3ac0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x8dcb
movl -0x18(%... | robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp |
int_to_bin_vector(int, int) | std::vector<bool> int_to_bin_vector(int bit_size, int node){
int tmp_count = 0;
std::vector<bool> node_bits;
std::string output_str = "";
// output_str += std::to_string(node) + "(";
//Keep adding the bits based on the parity of bits
while(node != 0){
if( (node % 2) == 0 ){
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x9120
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x22a0
movq -0x88(%rbp), %rdx
leaq 0... | robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp |
traverse_rng(unsigned int, unsigned int) | uint64_t traverse_rng(uint32_t n, uint32_t x0)
{
uint64_t sum = 0;
uint32_t i, x;
for (i = 0, x = x0; i < n; ++i) {
x = hash32(x);
sum += get_key(n, x);
}
return sum;
} | subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x123e
movl (%rsp), %edi
callq 0x1250
movl %eax, (%rsp)
movl 0x14(%rsp), %edi
movl (%rsp), %esi
callq 0x12c0
movl %eax, %eax
addq ... | attractivechaos[P]udb2/khashlpp/./../common.c |
hash32(unsigned int) | static inline uint32_t hash32(uint32_t key)
{
key += ~(key << 15);
key ^= (key >> 10);
key += (key << 3);
key ^= (key >> 6);
key += ~(key << 11);
key ^= (key >> 16);
return key;
} | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0xf, %eax
xorl $-0x1, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0xa, %eax
xorl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x3, %eax
addl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x6, %e... | attractivechaos[P]udb2/khashlpp/./../common.c |
main | int main(int argc, char *argv[])
{
uint32_t test_int(uint32_t n, uint32_t x0);
int c;
double t, t0;
uint32_t i, m = 5, max = 50000000, n = 10000000, x0 = 1, step;
uint64_t sum;
long m0;
while ((c = getopt(argc, argv, "n:x:0:k:")) >= 0) {
if (c == 'n') n = atol(optarg);
else if (c == 'x') max = atol(optarg);... | subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
movl %edi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl $0x5, 0x48(%rsp)
movl $0x2faf080, 0x44(%rsp) # imm = 0x2FAF080
movl $0x989680, 0x40(%rsp) # imm = 0x989680
movl $0x1, 0x3c(%rsp)
movl 0x70(%rsp), %edi
movq 0x68(%rsp), %rsi
leaq 0xcfb(%rip), %rdx # 0x2020
callq 0x1040
movl ... | attractivechaos[P]udb2/khashlpp/./../common.c |
test_int(unsigned int, unsigned int) | uint32_t test_int(uint32_t n, uint32_t x0)
{
uint32_t i, x, z = 0;
klib::KHashMap<uint32_t, int, aux_hash> h;
for (i = 0, x = x0; i < n; ++i) {
uint32_t k;
int absent;
x = hash32(x);
k = h.put(get_key(n, x), &absent);
#ifndef UDB2_TEST_DEL
if (absent) h.value(k) = 0;
z += ++h.value(k);
#else
if (absent... | subq $0x88, %rsp
movl %edi, 0x84(%rsp)
movl %esi, 0x80(%rsp)
movl $0x0, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1770
movl $0x0, 0x7c(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jae 0x16d1
movl 0x78(%rsp), %edi
callq 0x1250
movl %eax, 0x3c(%rsp)
jmp 0x160a
movl 0x3c(%rs... | attractivechaos[P]udb2/khashlpp/test.cpp |
klib::KHashSet<klib::KHashMapBucket<unsigned int, int>, klib::KHashMapHash<klib::KHashMapBucket<unsigned int, int>, aux_hash, unsigned int>, klib::KHashMapEq<klib::KHashMapBucket<unsigned int, int>, std::equal_to<unsigned int>>, unsigned int>::put(klib::KHashMapBucket<unsigned int, int> const&, int*) | khint_t put(const T &key, int *absent_ = 0) {
khint_t nb, i, last, mask;
int absent = -1;
nb = n_buckets();
if (count >= (nb>>1) + (nb>>2)) { /* rehashing */
if (resize(nb + khint_t(1)) < 0) {
if (absent_) *absent_ = -1;
return nb;
}
nb = n_buckets();
} /* TODO: to implement automatically shr... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
callq 0x1800
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x24(%rsp)
movl 0x4(%rax), %eax
movl 0x24(%rsp), %ecx
shrl %ecx
movl 0x24(%rsp), %edx... | attractivechaos[P]udb2/khashlpp/./khashl.hpp |
klib::KHashSet<klib::KHashMapBucket<unsigned int, int>, klib::KHashMapHash<klib::KHashMapBucket<unsigned int, int>, aux_hash, unsigned int>, klib::KHashMapEq<klib::KHashMapBucket<unsigned int, int>, std::equal_to<unsigned int>>, unsigned int>::resize(unsigned int) | int resize(khint_t new_nb) {
uint32_t *new_used = 0;
khint_t j = 0, x = new_nb, nb, new_bits, new_mask;
while ((x >>= khint_t(1)) != 0) ++j;
if (new_nb & (new_nb - 1)) ++j;
new_bits = j > 2? j : 2;
new_nb = khint_t(1) << new_bits;
if (count > (new_nb>>1) + (new_nb>>2)) return 0; /* requested size is too s... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %eax
shrl %eax
movl %eax, 0x50(%rsp)
cmpl $0x0, %eax
je 0x1aac
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax... | attractivechaos[P]udb2/khashlpp/./khashl.hpp |
hsql::SQLParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, hsql::SQLParserResult*) | bool SQLParser::parse(const std::string& sql, SQLParserResult* result) {
yyscan_t scanner;
YY_BUFFER_STATE state;
if (hsql_lex_init(&scanner)) {
// Couldn't initialize the lexer.
fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
return false;
}
const char* text = sql.c_str();
stat... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x38af0
cmpl $0x0, %eax
je 0x3a59c
movq 0x529a4(%rip), %rax # 0x8cf28
movq (%rax), %rdi
leaq 0x34aad(%rip), %rsi # 0x6f03b
movb $0x0, %al
callq 0x38c00
movb $0x0, 0x37(%rsp)
jmp 0x3a611
movq 0x28(%rsp), %rdi
callq 0x35de0
m... | hyrise[P]sql-parser/src/SQLParser.cpp |
hsql::SQLParser::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<short, std::allocator<short>>*) | bool SQLParser::tokenize(const std::string& sql, std::vector<int16_t>* tokens) {
// Initialize the scanner.
yyscan_t scanner;
if (hsql_lex_init(&scanner)) {
fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
return false;
}
YY_BUFFER_STATE state;
state = hsql__scan_string(sql.c_str(), ... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x38af0
cmpl $0x0, %eax
je 0x3a74e
movq 0x527f8(%rip), %rax # 0x8cf28
movq (%rax), %rdi
leaq 0x34901(%rip), %rsi # 0x6f03b
movb $0x0, %al
callq 0x38c00
movb $0x0, 0xa7(%rsp)
jmp 0x3a867
movq 0x98(%rsp), %rdi
callq 0x35de0
m... | hyrise[P]sql-parser/src/SQLParser.cpp |
hsql::SQLParserResult::operator=(hsql::SQLParserResult&&) | SQLParserResult& SQLParserResult::operator=(SQLParserResult&& moved) {
isValid_ = moved.isValid_;
errorMsg_ = moved.errorMsg_;
statements_ = std::move(moved.statements_);
moved.errorMsg_ = nullptr;
moved.reset();
return *this;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movb %al, 0x20(%rdi)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rdi)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x393d0
movq 0x8(%... | hyrise[P]sql-parser/src/SQLParserResult.cpp |
hsql::SQLParserResult::reset() | void SQLParserResult::reset() {
for (SQLStatement* statement : statements_) {
delete statement;
}
statements_.clear();
isValid_ = false;
free(errorMsg_);
errorMsg_ = nullptr;
errorLine_ = -1;
errorColumn_ = -1;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x38280
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x36080
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x36d80
testb $0x1, %al
jne 0x3b9a... | hyrise[P]sql-parser/src/SQLParserResult.cpp |
hsql::operator<<(std::ostream&, hsql::ConstraintType) | std::ostream& operator<<(std::ostream& os, const ConstraintType constraint_type) {
switch (constraint_type) {
case ConstraintType::Null:
os << "NULL";
break;
case ConstraintType::NotNull:
os << "NOT NULL";
break;
case ConstraintType::ForeignKey:
os << "FOREIGN KEY";
bre... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x4, %rax
ja 0x622ac
movq (%rsp), %rax
leaq 0x1c1da(%rip), %rcx # 0x7e420
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
leaq 0x1c81e(%rip), %rsi # 0x7ea79
callq 0x377a0
jmp 0x62... | hyrise[P]sql-parser/src/sql/CreateStatement.cpp |
hsql::ReferencesSpecification::~ReferencesSpecification() | ReferencesSpecification::~ReferencesSpecification() {
free(schema);
free(table);
if (columns) {
for (auto* column : *columns) {
free(column);
}
delete columns;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0x38090
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x38090
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6250e
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3... | hyrise[P]sql-parser/src/sql/CreateStatement.cpp |
hsql::ColumnDefinition::~ColumnDefinition() | ColumnDefinition::~ColumnDefinition() {
free(name);
delete column_constraints;
if (references) {
for (auto* ref : *references) {
delete ref;
}
}
delete references;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x2a86e(%rip), %rcx # 0x8cf98
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rdi
callq 0x38090
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x62767
movq 0x18(%rsp), %rdi
callq 0x38c20... | hyrise[P]sql-parser/src/sql/CreateStatement.cpp |
hsql::ColumnDefinition::trySetNullableExplicit() | bool ColumnDefinition::trySetNullableExplicit() {
if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) {
if (column_constraints->count(ConstraintType::Null)) {
return false;
}
nullable = false;
}
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rdi
movl $0x1, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x37100
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, 0xb(%rsp)
jne 0x628cc
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x3, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
... | hyrise[P]sql-parser/src/sql/CreateStatement.cpp |
hsql::CreateStatement::~CreateStatement() | CreateStatement::~CreateStatement() {
free(filePath);
free(schema);
free(tableName);
free(indexName);
delete select;
if (columns) {
for (auto* def : *columns) {
delete def;
}
delete columns;
}
if (tableConstraints) {
for (auto* def : *tableConstraints) {
delete def;
}
... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x2a5b5(%rip), %rcx # 0x8cf88
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x28(%rax), %rdi
callq 0x38090
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x38090
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x38090
movq 0x30(%... | hyrise[P]sql-parser/src/sql/CreateStatement.cpp |
hsql::CreateStatement::setColumnDefsAndConstraints(std::vector<hsql::TableElement*, std::allocator<hsql::TableElement*>>*) | void CreateStatement::setColumnDefsAndConstraints(std::vector<TableElement*>* tableElements) {
columns = new std::vector<ColumnDefinition*>();
tableConstraints = new std::vector<TableConstraint*>();
for (auto tableElem : *tableElements) {
if (auto* colDef = dynamic_cast<ColumnDefinition*>(tableElem)) {
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x18, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x362f0
movq 0x20(%rsp), %rdi
callq 0x36930
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%ra... | hyrise[P]sql-parser/src/sql/CreateStatement.cpp |
hsql::WindowDescription::~WindowDescription() | WindowDescription::~WindowDescription() {
if (partitionList) {
for (Expr* e : *partitionList) {
delete e;
}
delete partitionList;
}
if (orderList) {
for (OrderDescription* orderDescription : *orderList) {
delete orderDescription;
}
delete orderList;
}
delete frameDescript... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x281ce(%rip), %rcx # 0x8ced8
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x64dc7
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x36b30
movq %rax, 0x60(%rsp)
movq 0x6... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::~Expr() | Expr::~Expr() {
delete expr;
delete expr2;
delete select;
delete windowDescription;
free(name);
free(table);
free(alias);
if (exprList) {
for (Expr* e : *exprList) {
delete e;
}
delete exprList;
}
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x27f2e(%rip), %rcx # 0x8cef8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x64feb
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%ra... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeOpUnary(hsql::OperatorType, hsql::Expr*) | Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) {
Expr* e = new Expr(kExprOperator);
e->opType = op;
e->expr = expr;
e->expr2 = nullptr;
return e;
} | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x651fe
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x34(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8c(%rax)
movq 0x28(%rsp), %rcx
mo... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeOpBinary(hsql::Expr*, hsql::OperatorType, hsql::Expr*) | Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) {
Expr* e = new Expr(kExprOperator);
e->opType = op;
e->expr = expr1;
e->expr2 = expr2;
return e;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x652a2
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8c(%rax)
movq 0x3... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeBetween(hsql::Expr*, hsql::Expr*, hsql::Expr*) | Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) {
Expr* e = new Expr(kExprOperator);
e->expr = expr;
e->opType = kOpBetween;
e->exprList = new std::vector<Expr*>();
e->exprList->push_back(left);
e->exprList->push_back(right);
return e;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x65344
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeCaseList(hsql::Expr*) | Expr* Expr::makeCaseList(Expr* caseListElement) {
Expr* e = new Expr(kExprOperator);
// Case list expressions are temporary and will be integrated into the case
// expressions exprList - thus assign operator type kOpNone
e->opType = kOpNone;
e->exprList = new std::vector<Expr*>();
e->exprList->push_back(cas... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x6542a
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl $0x0, 0x8c(%rax)
movl $0x18, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, 0x8(%rsp... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeCaseListElement(hsql::Expr*, hsql::Expr*) | Expr* Expr::makeCaseListElement(Expr* when, Expr* then) {
Expr* e = new Expr(kExprOperator);
e->opType = kOpCaseListElement;
e->expr = when;
e->expr2 = then;
return e;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x654ef
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl $0x3, 0x8c(%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
mo... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeCase(hsql::Expr*, hsql::Expr*, hsql::Expr*) | Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) {
Expr* e = new Expr(kExprOperator);
e->opType = kOpCase;
e->expr = expr;
e->expr2 = elseExpr;
e->exprList = caseList->exprList;
caseList->exprList = nullptr;
delete caseList;
return e;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x655c4
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl $0x2, 0x8c(%rax)
movq 0x40(%rsp), %rcx
... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeLiteral(bool) | Expr* Expr::makeLiteral(bool val) {
Expr* e = new Expr(kExprLiteralInt);
e->ival = (int)val;
e->isBoolLiteral = true;
return e;
} | subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl $0x2, %esi
callq 0x3a360
jmp 0x657ed
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq 0x18(%rsp), %... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeIntervalLiteral(long, hsql::DatetimeField) | Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) {
Expr* e = new Expr(kExprLiteralInterval);
e->ival = duration;
e->datetimeField = unit;
return e;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x5, %esi
callq 0x3a360
jmp 0x6594e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x50(%rax)
movl 0x2c(%rsp), %ecx
mo... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeColumnRef(char*, char*) | Expr* Expr::makeColumnRef(char* table, char* name) {
Expr* e = new Expr(kExprColumnRef);
e->name = name;
e->table = table;
return e;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x8, %esi
callq 0x3a360
jmp 0x65a4f
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rsp), %rcx
mo... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeFunctionRef(char*, std::vector<hsql::Expr*, std::allocator<hsql::Expr*>>*, bool, hsql::WindowDescription*) | Expr* Expr::makeFunctionRef(char* func_name, std::vector<Expr*>* exprList, bool distinct, WindowDescription* window) {
Expr* e = new Expr(kExprFunctionRef);
e->name = func_name;
e->exprList = exprList;
e->distinct = distinct;
e->windowDescription = window;
return e;
} | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rcx, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0x9, %esi
callq 0x3a360
jmp 0x65bbc
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeArrayIndex(hsql::Expr*, long) | Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) {
Expr* e = new Expr(kExprArrayIndex);
e->expr = expr;
e->ival = index;
return e;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0xe, %esi
callq 0x3a360
jmp 0x65cdf
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
mo... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeExists(hsql::SelectStatement*) | Expr* Expr::makeExists(SelectStatement* select) {
Expr* e = new Expr(kExprOperator);
e->opType = kOpExists;
e->select = select;
return e;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x65e49
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl $0x1a, 0x8c(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeInOperator(hsql::Expr*, std::vector<hsql::Expr*, std::allocator<hsql::Expr*>>*) | Expr* Expr::makeInOperator(Expr* expr, std::vector<Expr*>* exprList) {
Expr* e = new Expr(kExprOperator);
e->opType = kOpIn;
e->expr = expr;
e->exprList = exprList;
return e;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0xa, %esi
callq 0x3a360
jmp 0x65ecf
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl $0x15, 0x8c(%rax)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
m... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeExtract(hsql::DatetimeField, hsql::Expr*) | Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) {
Expr* e = new Expr(kExprExtract);
e->datetimeField = datetimeField;
e->expr = expr;
return e;
} | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl $0xf, %esi
callq 0x3a360
jmp 0x6600e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x34(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0x28(%rsp), %rcx
mo... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::makeCast(hsql::Expr*, hsql::ColumnType) | Expr* Expr::makeCast(Expr* expr, ColumnType columnType) {
Expr* e = new Expr(kExprCast);
e->columnType = columnType;
e->expr = expr;
return e;
} | subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movl $0xa0, %edi
callq 0x377c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl $0x10, %esi
callq 0x3a360
jmp 0x660a4
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rcx), %rdx
movq ... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::Expr::getName() const | const char* Expr::getName() const {
if (alias)
return alias;
else
return name;
} | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, 0x40(%rax)
je 0x66276
movq -0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x66284
movq -0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
| hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::substr(char const*, int, int) | char* substr(const char* source, int from, int to) {
int len = to - from;
char* copy = (char*)malloc(len + 1);
;
strncpy(copy, source + from, len);
copy[len] = '\0';
return copy;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x18(%rsp), %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x38640
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rax
addq %rax, %r... | hyrise[P]sql-parser/src/sql/Expr.cpp |
hsql::SQLStatement::~SQLStatement() | SQLStatement::~SQLStatement() {
if (hints) {
for (Expr* hint : *hints) {
delete hint;
}
}
delete hints;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x26b3e(%rip), %rcx # 0x8cf58
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x10(%rax)
je 0x664a6
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x36b30
movq %rax, 0x30(%rsp)
movq 0... | hyrise[P]sql-parser/src/sql/SQLStatement.cpp |
hsql::operator<<(std::ostream&, hsql::ColumnType const&) | std::ostream& operator<<(std::ostream& stream, const ColumnType& column_type) {
switch (column_type.data_type) {
case DataType::UNKNOWN:
stream << "UNKNOWN";
break;
case DataType::INT:
stream << "INT";
break;
case DataType::BIGINT:
stream << "BIGINT";
break;
case Da... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq %rax, (%rsp)
subq $0xf, %rax
ja 0x66820
movq (%rsp), %rax
leaq 0x17ec2(%rip), %rcx # 0x7e550
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
leaq 0x180bf(%rip), %rsi # 0x7e762
call... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::ExecuteStatement::~ExecuteStatement() | ExecuteStatement::~ExecuteStatement() {
free(name);
if (parameters) {
for (Expr* param : *parameters) {
delete param;
}
delete parameters;
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x261d6(%rip), %rcx # 0x8cf00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rdi
callq 0x38090
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x66df5
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::ExportStatement::~ExportStatement() | ExportStatement::~ExportStatement() {
free(filePath);
free(schema);
free(tableName);
delete select;
free(encoding);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x260f7(%rip), %rcx # 0x8cfc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rdi
callq 0x38090
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x38090
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x38090
movq (%rsp), %rax
movq ... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::ImportStatement::~ImportStatement() | ImportStatement::~ImportStatement() {
free(filePath);
free(schema);
free(tableName);
delete whereClause;
free(encoding);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x25f8f(%rip), %rcx # 0x8cfb8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rdi
callq 0x38090
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x38090
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x38090
movq (%rsp), %rax
movq ... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::InsertStatement::~InsertStatement() | InsertStatement::~InsertStatement() {
free(schema);
free(tableName);
delete select;
if (columns) {
for (char* column : *columns) {
free(column);
}
delete columns;
}
if (values) {
for (Expr* expr : *values) {
delete expr;
}
delete values;
}
} | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x25e06(%rip), %rcx # 0x8cf50
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rdi
callq 0x38090
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x38090
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x28(%rsp)
cmp... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::GroupByDescription::~GroupByDescription() | GroupByDescription::~GroupByDescription() {
delete having;
if (columns) {
for (Expr* expr : *columns) {
delete expr;
}
delete columns;
}
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x2596e(%rip), %rcx # 0x8cf38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x675eb
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::SelectStatement::~SelectStatement() | SelectStatement::~SelectStatement() {
delete fromTable;
delete whereClause;
delete groupBy;
delete limit;
// Delete each element in the select list.
if (selectList) {
for (Expr* expr : *selectList) {
delete expr;
}
delete selectList;
}
if (order) {
for (OrderDescription* desc : *... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x140(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x256dd(%rip), %rcx # 0x8ceb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, %rax
je 0x677f4
movq 0x78(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::UpdateStatement::~UpdateStatement() | UpdateStatement::~UpdateStatement() {
delete table;
delete where;
if (updates) {
for (UpdateClause* update : *updates) {
free(update->column);
delete update->value;
delete update;
}
delete updates;
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x2512e(%rip), %rcx # 0x8cf68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x67e5b
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x30(%ra... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::Alias::~Alias() | Alias::~Alias() {
free(name);
if (columns) {
for (char* column : *columns) {
free(column);
}
delete columns;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
callq 0x38090
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x680a0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x37d80
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::TableRef::~TableRef() | TableRef::~TableRef() {
free(schema);
free(name);
delete select;
delete join;
delete alias;
if (list) {
for (TableRef* table : *list) {
delete table;
}
delete list;
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x24de6(%rip), %rcx # 0x8cf10
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rdi
callq 0x38090
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x38090
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rsp)
cmp... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::TableRef::getName() const | const char* TableRef::getName() const {
if (alias)
return alias->name;
else
return name;
} | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, 0x20(%rax)
je 0x682e9
movq -0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x682f7
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
| hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::JoinDefinition::~JoinDefinition() | JoinDefinition::~JoinDefinition() {
delete left;
delete right;
delete condition;
if (namedColumns) {
for (auto* column : *namedColumns) {
free(column);
}
delete namedColumns;
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x24c4e(%rip), %rcx # 0x8cfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x6837b
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::SetOperation::~SetOperation() | SetOperation::~SetOperation() {
delete nestedSelectStatement;
delete resultLimit;
if (resultOrder) {
for (OrderDescription* desc : *resultOrder) {
delete desc;
}
delete resultOrder;
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x24ab6(%rip), %rcx # 0x8cfb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x6851b
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x20(%ra... | hyrise[P]sql-parser/src/sql/statements.cpp |
hsql::operator<<(std::ostream&, hsql::OperatorType const&) | std::ostream& operator<<(std::ostream& os, const OperatorType& op) {
static const std::map<const OperatorType, const std::string> operatorToToken = {
{kOpNone, "None"}, {kOpBetween, "BETWEEN"},
{kOpCase, "CASE"}, {kOpCaseListElement, "CASE LIST ELEMENT"},
{kOpPlus, "+"}, {kOpMinus, "-... | subq $0x548, %rsp # imm = 0x548
movq %rdi, 0x538(%rsp)
movq %rsi, 0x530(%rsp)
cmpb $0x0, 0x26d22(%rip) # 0x8fa90
jne 0x6934c
leaq 0x26d15(%rip), %rdi # 0x8fa90
callq 0x39c30
cmpl $0x0, %eax
je 0x6934c
leaq 0xe8(%rsp), %rdi
movq %rdi, 0xe0(%rsp)
movl $0x0, 0xdc(%rsp)
leaq 0x15c96(%rip), %rdx # 0x7... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::operator<<(std::ostream&, hsql::DatetimeField const&) | std::ostream& operator<<(std::ostream& os, const DatetimeField& datetime) {
static const std::map<const DatetimeField, const std::string> operatorToToken = {
{kDatetimeNone, "None"}, {kDatetimeSecond, "SECOND"}, {kDatetimeMinute, "MINUTE"}, {kDatetimeHour, "HOUR"},
{kDatetimeDay, "DAY"}, {kDatetimeMonth... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq %rsi, 0x1c0(%rsp)
cmpb $0x0, 0x2649a(%rip) # 0x8fac8
jne 0x6983e
leaq 0x2648d(%rip), %rdi # 0x8fac8
callq 0x39c30
cmpl $0x0, %eax
je 0x6983e
leaq 0x98(%rsp), %rdi
movq %rdi, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
leaq 0x153d6(%rip), %rdx # 0x7... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printTableRefInfo(hsql::TableRef*, unsigned long) | void printTableRefInfo(TableRef* table, uintmax_t num_indent) {
switch (table->type) {
case kTableName:
inprint(table->name, num_indent);
if (table->schema) {
inprint("Schema", num_indent + 1);
inprint(table->schema, num_indent + 2);
}
break;
case kTableSelect:
pr... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x69b73
movq (%rsp), %rax
leaq 0x14d85(%rip), %rcx # 0x7e774
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp),... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printSelectStatementInfo(hsql::SelectStatement const*, unsigned long) | void printSelectStatementInfo(const SelectStatement* stmt, uintmax_t num_indent) {
inprint("SelectStatement", num_indent);
inprint("Fields:", num_indent + 1);
for (Expr* expr : *stmt->selectList) printExpression(expr, num_indent + 2);
if (stmt->fromTable) {
inprint("Sources:", num_indent + 1);
printTab... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x14cf9(%rip), %rdi # 0x7e8bf
callq 0x39830
movq 0xa8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x14cf1(%rip), %rdi # 0x7e8cf
callq 0x39830
movq 0xb0(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printExpression(hsql::Expr*, unsigned long) | void printExpression(Expr* expr, uintmax_t num_indent) {
if (!expr) return;
switch (expr->type) {
case kExprStar:
inprint("*", num_indent);
break;
case kExprColumnRef:
inprint(expr->name, num_indent);
if (expr->table) {
inprint("Table:", num_indent + 1);
inprint(expr-... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x6a35b
jmp 0x6a731
movq 0x50(%rsp), %rax
movl 0x8(%rax), %eax
movq %rax, (%rsp)
subq $0x10, %rax
ja 0x6a6c5
movq (%rsp), %rax
leaq 0x14408(%rip), %rcx # 0x7e784
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%rs... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printAlias(hsql::Alias*, unsigned long) | void printAlias(Alias* alias, uintmax_t num_indent) {
inprint("Alias", num_indent + 1);
inprint(alias->name, num_indent + 2);
if (alias->columns) {
for (char* column : *(alias->columns)) {
inprint(column, num_indent + 3);
}
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
leaq 0x140f4(%rip), %rdi # 0x7e852
callq 0x39830
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
addq $0x2, %rsi
callq 0x39830
movq 0x30(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6a7f9
movq 0x30(%rsp), %rax
... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printOperatorExpression(hsql::Expr*, unsigned long) | void printOperatorExpression(Expr* expr, uintmax_t num_indent) {
if (expr == nullptr) {
inprint("null", num_indent);
return;
}
inprint(expr->opType, num_indent);
printExpression(expr->expr, num_indent + 1);
if (expr->expr2) {
printExpression(expr->expr2, num_indent + 1);
} else if (expr->exprL... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x6a82c
movq 0x28(%rsp), %rsi
leaq 0x14036(%rip), %rdi # 0x7e858
callq 0x39830
jmp 0x6a903
movq 0x30(%rsp), %rdi
addq $0x8c, %rdi
movq 0x28(%rsp), %rsi
callq 0x39210
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %r... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printWindowDescription(hsql::WindowDescription*, unsigned long) | void printWindowDescription(WindowDescription* window_description, uintmax_t num_indent) {
inprint("OVER", num_indent);
if (window_description->partitionList) {
inprint("PARTITION BY", num_indent + 1);
for (const auto e : *window_description->partitionList) {
printExpression(e, num_indent + 2);
}
... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x1f8(%rsp), %rsi
leaq 0x7d23(%rip), %rdi # 0x72659
callq 0x39830
movq 0x200(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6aa01
movq 0x1f8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x13f38(%rip), %rdi # 0x7e899
callq 0x39830
movq 0x2... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printOrderBy(std::vector<hsql::OrderDescription*, std::allocator<hsql::OrderDescription*>> const*, unsigned long) | void printOrderBy(const std::vector<OrderDescription*>* expr, uintmax_t num_indent) {
if (!expr) return;
for (const auto& order_description : *expr) {
printExpression(order_description->expr, num_indent);
if (order_description->type == kOrderAsc) {
inprint("ascending", num_indent);
} else {
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x6abdb
jmp 0x6ac7d
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x39560
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x357f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::operator<<(std::ostream&, hsql::FrameBound const&) | std::ostream& operator<<(std::ostream& os, const FrameBound& frame_bound) {
if (frame_bound.type == kCurrentRow) {
os << "CURRENT ROW";
return os;
}
if (frame_bound.unbounded) {
os << "UNBOUNDED";
} else {
os << frame_bound.offset;
}
os << " ";
if (frame_bound.type == kPreceding) {
... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x6acc4
movq 0x8(%rsp), %rdi
leaq 0x13dcb(%rip), %rsi # 0x7ea7e
callq 0x377a0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x6ad3b
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
je 0x6ace1
movq 0x8(%rsp), %rdi
leaq 0x7b0e(... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
hsql::printImportStatementInfo(hsql::ImportStatement const*, unsigned long) | void printImportStatementInfo(const ImportStatement* stmt, uintmax_t num_indent) {
inprint("ImportStatement", num_indent);
inprint(stmt->filePath, num_indent + 1);
switch (stmt->type) {
case ImportType::kImportCSV:
inprint("CSV", num_indent + 1);
break;
case ImportType::kImportTbl:
inpri... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x13c58(%rip), %rdi # 0x7e9c2
callq 0x39830
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
incq %rsi
callq 0x39830
movq 0x10(%rsp), %rax
movl 0x1c(%rax), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x6ae05
movq (%r... | hyrise[P]sql-parser/src/util/sqlhelper.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.