Datasets:
LLM4Binary
/
decompile-bench

Dataset card Data Studio Files
xet
 Community
1
name
string
code
string
asm
string
file
string
PECommander::initCommands()
void PECommander::initCommands() { this->addCommand("secV", new SectionByAddrCommand(Executable::RVA, "Section by RVA")); this->addCommand("secR", new SectionByAddrCommand(Executable::RAW, "Section by RAW")); this->addCommand("rstrings", new PrintStringsCommand("Print Strings from resources")); this->a...
pushq %rbp pushq %r14 pushq %rbx subq $0x50, %rsp movq %rdi, %rbx leaq 0x18bbf(%rip), %rsi # 0x326f3 leaq 0x30(%rsp), %rdi leaq 0xf(%rsp), %rdx callq 0x164ee pushq $0x30 popq %rdi callq 0x15120 movq %rax, %r14 leaq 0x18ba3(%rip), %rsi # 0x326f8 leaq 0x10(%rsp), %rdi leaq 0xe(%rsp), %rdx callq 0x164ee movb $0x1,...
/hasherezade[P]bearparser/commander/PECommander.cpp
ResString::getQString()
QString getQString() { if (this->m_Exe == NULL) return ""; //ERROR WORD* entries = ptr; int size = *(sizePtr); WORD *content = (WORD*) this->m_Exe->getContentAt(offset,Executable::RAW, size); if (content == NULL) return ""; return QString::fromUtf16(reinterpret_cast<...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x8(%rsi), %rdi testq %rdi, %rdi je 0x1a0c8 movq 0x40(%rsi), %rax movq 0x48(%rsi), %rsi movzwl (%rax), %r14d movq (%rdi), %rax pushq $0x1 popq %rdx movq %r14, %rcx xorl %r8d, %r8d callq *0x70(%rax) testq %rax, %rax je 0x1a0c8 movq %rbx, %rdi movq %rax, %rsi movq %r1...
/hasherezade[P]bearparser/parser/include/bearparser/pe/rsrc/ResourceStringsWrapper.h
PrintStringsCommand::execute(CmdParams*, CmdContext*)
virtual void execute(CmdParams *params, CmdContext *context) { PEFile *pe = cmd_util::getPEFromContext(context); if (!pe) return; ResourcesContainer* container = pe->getResourcesOfType(pe::RESTYPE_STRING); if (container == NULL) { std::cout << "No such resource type!" <...
pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdx, %rdi callq 0x1947c testq %rax, %rax je 0x1a722 movq %rax, %rbx pushq $0x6 popq %rsi movq %rax, %rdi callq 0x1a03e testq %rax, %rax je 0x1a6f2 movq %rax, %rdi callq 0x2f71a movq %rax, %r14 movq 0x37925(%rip), %rdi # 0x51fc0 leaq 0x18246(%rip), %rsi # 0x328e8 call...
/hasherezade[P]bearparser/commander/PECommander.h
WrapperInfoCommand::execute(CmdParams*, CmdContext*)
virtual void execute(CmdParams *params, CmdContext *context) { PEFile *pe = cmd_util::getPEFromContext(context); if (!pe) return; ResourcesAlbum *album = pe->getResourcesAlbum(); if (album == NULL) return; size_t dirsCount = album->dirsCount(); if (dirsCount == 0)...
pushq %r15 pushq %r14 pushq %rbx subq $0x30, %rsp movq %rdx, %rdi callq 0x1947c testq %rax, %rax je 0x1a8e4 movq %rax, %rbx movq 0xa0(%rax), %rax testq %rax, %rax je 0x1a8e4 cmpq $0x0, 0x78(%rax) je 0x1a82b movq %rbx, %rdi callq 0x195ab leaq 0x1812f(%rip), %rsi # 0x32902 leaq 0x10(%rsp), %rdi leaq 0xf(%rsp), %rdx c...
/hasherezade[P]bearparser/commander/PECommander.h
buf_util::roundupToUnit(unsigned long, unsigned long)
bufsize_t buf_util::roundupToUnit(bufsize_t size, bufsize_t unit) { if (unit == 0) { printf("Invalid roundup unit!\n"); return 0; } bufsize_t unitsNum = size / unit; bufsize_t roundDown = unitsNum * unit; if (roundDown < size) unitsNum ++; return unitsNum * unit; }
testq %rsi, %rsi je 0x1b990 movq %rdi, %rax xorl %edx, %edx divq %rsi movq %rax, %rcx imulq %rsi, %rcx cmpq %rdi, %rcx adcq $0x0, %rax imulq %rsi, %rax retq pushq %rax leaq 0x174a1(%rip), %rdi # 0x32e39 callq 0x155e0 xorl %eax, %eax addq $0x8, %rsp retq
/hasherezade[P]bearparser/parser/AbstractByteBuffer.cpp
BufferView::getContentSize()
bufsize_t BufferView::getContentSize() { bufsize_t maxSize = this->parent->getContentSize(); if (offset > maxSize) { return 0; } if (offset + size > maxSize) { bufsize_t trimedSize = maxSize - offset; return trimedSize; } return size; }
pushq %rbx movq %rdi, %rbx movq 0x8(%rdi), %rdi movq (%rdi), %rax callq *0x10(%rax) movq %rax, %rcx movq 0x10(%rbx), %rdx subq %rdx, %rax jae 0x1c834 xorl %eax, %eax jmp 0x1c842 movq 0x18(%rbx), %rsi addq %rsi, %rdx cmpq %rcx, %rdx cmovbeq %rsi, %rax popq %rbx retq
/hasherezade[P]bearparser/parser/AbstractByteBuffer.cpp
WrappedValue::toQString()
QString WrappedValue::toQString() { if (this->m_Type == NONE) return ""; if (this->m_Type == COMPLEX) return "..."; QVariant val = getQVariant(); if (this->m_Type == STRING || this->m_Type == WSTRING) { return val.toString(); } if (this->m_Type == INT) { bufsize_t size = this-...
pushq %r15 pushq %r14 pushq %rbx subq $0x80, %rsp movq %rdi, %rbx movl 0x8(%rsi), %eax cmpl $0x4, %eax je 0x1cc36 testl %eax, %eax jne 0x1cc47 leaq 0x157f3(%rip), %rsi # 0x32427 jmp 0x1cc3d leaq 0x15468(%rip), %rsi # 0x320a5 movq %rbx, %rdi callq 0x16572 jmp 0x1ccbd movq %rsi, %r14 leaq 0x40(%rsp), %rdi callq 0...
/hasherezade[P]bearparser/parser/WrappedValue.cpp
ByteBuffer::_init(unsigned long const&, unsigned long const&)
void ByteBuffer::_init(const bufsize_t& v_size, const bufsize_t& v_padding) { if (v_size == 0) throw BufferException("Zero size requested"); this->content = allocContent(v_size, v_padding); if (this->content) { this->padding = v_padding; this->contentSize = v_size; this->originalSiz...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq (%rsi), %rsi testq %rsi, %rsi je 0x1ce7c movq %rdx, %r15 movq %rdi, %rbx movq (%rdx), %rdx callq 0x1cee2 movq %rax, 0x8(%rbx) movq (%r15), %rax movq %rax, 0x18(%rbx) movq (%r14), %rax movq %rax, 0x10(%rbx) movq %rax, 0x20(%rbx) addq $0x18...
/hasherezade[P]bearparser/parser/ByteBuffer.cpp
AbstractFileBuffer::read(QFile&, unsigned long, bool)
ByteBuffer* AbstractFileBuffer::read(QFile &fIn, bufsize_t minBufSize, const bool allowTruncate) //throws exceptions { bufsize_t readableSize = getReadableSize(fIn); bufsize_t allocSize = (readableSize < minBufSize) ? minBufSize : readableSize; ByteBuffer *bufferedFile = NULL; do { try { ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movl %edx, %ebp movq %rsi, %r15 movq %rdi, %rbx movq (%rdi), %rax callq *0x80(%rax) cmpq %r15, %rax cmovaq %rax, %r15 pushq $0x28 popq %r12 pushq $0x2 popq %r13 movq %r12, %rdi callq 0x15120 movq %rax, %r14 movq %rax, %rdi movq %r15, %rs...
/hasherezade[P]bearparser/parser/FileBuffer.cpp
AbstractFileBuffer::getReadableSize(QString const&)
bufsize_t AbstractFileBuffer::getReadableSize(const QString &path) { if (!path.length()) return 0; QFile fIn(path); if (!fIn.open(QIODevice::ReadOnly)) return 0; const bufsize_t size = getReadableSize(fIn); fIn.close(); return size; }
pushq %rbx subq $0x10, %rsp cmpq $0x0, 0x10(%rdi) je 0x1da7e movq %rdi, %rsi movq %rsp, %rbx movq %rbx, %rdi callq 0x15600 pushq $0x1 popq %rsi movq %rbx, %rdi callq 0x15480 testb %al, %al je 0x1da82 movq %rsp, %rdi movq (%rdi), %rax callq *0x80(%rax) movq %rax, %rbx movq %rsp, %rdi callq 0x15500 jmp 0x1da84 xorl %ebx,...
/hasherezade[P]bearparser/parser/FileBuffer.cpp
AbstractFileBuffer::dump(QString const&, AbstractByteBuffer&, bool)
bufsize_t AbstractFileBuffer::dump(const QString &path, AbstractByteBuffer &bBuf, bool allowExceptions) { BYTE* buf = bBuf.getContent(); bufsize_t bufSize = bBuf.getContentSize(); if (buf == NULL) { if (allowExceptions) throw FileBufferException("Buffer is empty"); return 0; } QFile...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp movl %edx, %ebx movq %rsi, %r12 movq %rdi, %r14 movq (%rsi), %rax movq %rsi, %rdi callq *0x18(%rax) movq %rax, %r15 movq (%r12), %rax movq %r12, %rdi callq *0x10(%rax) testq %r15, %r15 je 0x1db16 movq %rax, %r12 movq %rsp, %r13 movq %r13...
/hasherezade[P]bearparser/parser/FileBuffer.cpp
Executable::Executable(AbstractByteBuffer*, Executable::exe_bits)
Executable::Executable(AbstractByteBuffer *v_buf, exe_bits v_bitMode) : buf(v_buf), bitMode(v_bitMode) { if (!v_buf) throw ExeException("Cannot make an Exe from NULL buffer"); }
pushq %rbp pushq %r14 pushq %rbx subq $0x20, %rsp leaq 0x2ea35(%rip), %rax # 0x4c7a0 addq $0x10, %rax movq %rax, (%rdi) movl %edx, 0x8(%rdi) movq %rsi, 0x10(%rdi) testq %rsi, %rsi je 0x1dd87 addq $0x20, %rsp popq %rbx popq %r14 popq %rbp retq pushq $0x48 popq %rdi callq 0x15260 movq %rax, %rbx leaq 0x15222(%rip), %...
/hasherezade[P]bearparser/parser/Executable.cpp
Executable::detectAddrType(unsigned long, Executable::addr_type)
Executable::addr_type Executable::detectAddrType(offset_t offset, Executable::addr_type hintType) { if (hintType == Executable::RAW) { if (this->isValidAddr(offset, hintType) == false) { return Executable::NOT_ADDR; } else return hintType; // it is RAW } if (hintType == Executab...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 cmpl $0x1, %edx jne 0x1e173 movq (%r14), %rax pushq $0x1 popq %rdx movq %r14, %rdi movq %rbx, %rsi callq *0xa8(%rax) movzbl %al, %eax jmp 0x1e1bc testl %edx, %edx pushq $0x2 popq %rbp cmovnel %edx, %ebp movq (%r14), %rax movq %r14, %...
/hasherezade[P]bearparser/parser/Executable.cpp
ExeWrappersContainer::getWrapperName(unsigned long)
QString ExeWrappersContainer::getWrapperName(size_t id) { if (wrappers.find(id) == wrappers.end()) return ""; return wrappers[id]->getName(); }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rsi, %r15 movq %rdi, %rbx leaq 0x8(%rsp), %rsi movq %rdx, (%rsi) leaq 0x8(%r15), %r14 movq %r14, %rdi callq 0x1edb2 addq $0x10, %r15 cmpq %r15, %rax je 0x1ec99 leaq 0x8(%rsp), %rsi movq %r14, %rdi callq 0x1ecb6 movq (%rax), %rsi movq (%rsi), %rax movq %rbx, %rdi c...
/hasherezade[P]bearparser/parser/MappedExe.cpp
ExeFactory::build(AbstractByteBuffer*, ExeFactory::exe_type)
Executable* ExeFactory::build(AbstractByteBuffer *buf, exe_type type) { ExeFactory::init(); //ensue that the builders are initialized if (builders.find(type) == builders.end()) { return NULL; } ExeBuilder* builder = builders[type]; if (!builder) return NULL; return builder->build(buf);...
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0xc(%rsp), %r14 movl %esi, (%r14) callq 0x1f8c8 leaq 0x329e4(%rip), %r15 # 0x52400 movq %r15, %rdi movq %r14, %rsi callq 0x1fe6a addq $0x8, %r15 cmpq %r15, %rax je 0x1fa54 leaq 0x329c9(%rip), %rdi # 0x52400 leaq 0xc(%rsp), %rsi callq 0x1fb28...
/hasherezade[P]bearparser/parser/ExeFactory.cpp
ExeFactory::getTypeName(ExeFactory::exe_type)
QString ExeFactory::getTypeName(exe_type type) { ExeFactory::init(); //ensue that the builders are initialized if (builders.find(type) == builders.end()) return "Not supported"; ExeBuilder* builder = builders[type]; if (builder == NULL) return "Not supported"; return builder->typeName(); }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx leaq 0xc(%rsp), %r14 movl %esi, (%r14) callq 0x1f8c8 leaq 0x32980(%rip), %r15 # 0x52400 movq %r15, %rdi movq %r14, %rsi callq 0x1fe6a addq $0x8, %r15 cmpq %r15, %rax je 0x1fab8 leaq 0x32965(%rip), %rdi # 0x52400 leaq 0xc(%rsp), %rsi callq 0x1fb28...
/hasherezade[P]bearparser/parser/ExeFactory.cpp
DOSExe::wrap()
void DOSExe::wrap() { this->dosHdrWrapper = new DosHdrWrapper(this); m_dosHdr = (IMAGE_DOS_HEADER*) getContentAt(0, sizeof(IMAGE_DOS_HEADER)); if (m_dosHdr == NULL) throw ExeException("Could not Wrap!"); WORD* magic = (WORD*) this->dosHdrWrapper->getFieldPtr(DosHdrWrapper::MAGIC); if (this->dosHd...
pushq %rbp pushq %r14 pushq %rbx subq $0x50, %rsp movq %rdi, %rbx pushq $0x10 popq %rdi callq 0x15120 movq %rax, %r14 movq %rax, %rdi movq %rbx, %rsi callq 0x2046e movq %r14, 0x50(%rbx) movq (%rbx), %rax pushq $0x40 popq %rdx movq %rbx, %rdi xorl %esi, %esi xorl %ecx, %ecx callq *0x38(%rax) movq %rax, 0x58(%rbx) testq ...
/hasherezade[P]bearparser/parser/pe/DOSExe.cpp
PEFile::PEFile(AbstractByteBuffer*)
PEFile::PEFile(AbstractByteBuffer *v_buf) : MappedExe(v_buf, Executable::BITS_32), dosHdrWrapper(NULL), fHdr(NULL), optHdr(NULL), sects(NULL), album(NULL) { clearWrappers(); _init(v_buf); Logger::append(Logger::D_INFO,"Wrapped"); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx movq %rsi, %r15 movq %rdi, %r13 pushq $0x20 popq %rdx callq 0x20430 leaq 0x2c6d2(%rip), %rax # 0x4cfd8 leaq 0x10(%rax), %rcx movq %rcx, (%r13) leaq 0x18(%r13), %rbx addq $0x130, %rax # imm = 0x130 movq %rax, 0x18(%r13) leaq 0x31405(%rip), %rax # ...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::_init(AbstractByteBuffer*)
void PEFile::_init(AbstractByteBuffer *v_buf) { // wrap the core: core.wrap(v_buf); album = new ResourcesAlbum(this); //generate wrappers: this->dosHdrWrapper = new DosHdrWrapper(this); this->wrappers[WR_DOS_HDR] = this->dosHdrWrapper; this->fHdr = new FileHdrWrapper(this); if (fH...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx addq $0x50, %rdi callq 0x315f0 movl $0xe0, %edi callq 0x15120 movq %rax, %r14 movq %rax, %rdi movq %rbx, %rsi callq 0x221ee movq %r14, 0xa0(%rbx) pushq $0x10 popq %rdi callq 0x15120 movq %rax, %r15 movq %rax, %rdi movq %r...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::wrapCore()
void PEFile::wrapCore() { WatchedLocker lock(&m_peMutex, PE_SHOW_LOCK, __FUNCTION__); // rewrap the core: core.wrap(this->buf); // rewrap the PE headers: for (int i = 0; i < WR_DIR_ENTRY; i++) { this->wrappers[i]->wrap(); } // rewrap the sections: this->sects->wrap(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x48, %rsp movq %rdi, %rbx leaq 0x120(%rdi), %rsi leaq 0x123bc(%rip), %rcx # 0x33242 leaq 0x10(%rsp), %rdi xorl %edx, %edx callq 0x1a4b4 leaq 0x50(%rbx), %rdi movq 0x10(%rbx), %rsi callq 0x315f0 leaq 0x20(%rbx), %r14 xorl %r12d, %r12d leaq 0x8(%rsp), %r15 cmpq $0x6,...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::getRichHeaderBgn(pe::_RICH_SIGNATURE*)
pe::RICH_DANS_HEADER* PEFile::getRichHeaderBgn(pe::RICH_SIGNATURE* richSign) { if (!richSign) return NULL; DWORD xorkey = richSign->checksum; const offset_t richOffset = this->getOffset(richSign); pe::RICH_DANS_HEADER* dansHdr = NULL; offset_t offset = richOffset - sizeof(pe::RICH_DANS_HEADER); ...
testq %rsi, %rsi je 0x20fc4 pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x4(%rsi), %ebp movq (%rdi), %rax xorl %edx, %edx callq *0x30(%rax) movq %rax, %r14 addq $-0x18, %r14 pushq $0x18 popq %r15 xorl %eax, %eax testq %r14, %r14 je 0x20fc7 movq (%rbx), %rax movq %rbx, %rdi movq %r14, %rs...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::rawToRva(unsigned long)
offset_t PEFile::rawToRva(offset_t raw) { WatchedLocker lock(&m_peMutex, PE_SHOW_LOCK, __FUNCTION__); if (raw >= this->getMappedSize(Executable::RAW)) return INVALID_ADDR; SectionHdrWrapper* sec = this->_getSecHdrAtOffset(raw, Executable::RAW, true); if (sec) { offset_t bgnVA = sec->getContentO...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %rbx movq %rdi, %r15 leaq 0x120(%rdi), %rsi leaq 0x11f56(%rip), %rcx # 0x33287 leaq 0x8(%rsp), %rdi xorl %edx, %edx callq 0x1a4b4 movq (%r15), %rax pushq $0x1 popq %rsi movq %r15, %rdi callq *0x78(%rax) pushq $-0x1 popq %r14 cmpq %rb...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::rvaToRaw(unsigned long)
offset_t PEFile::rvaToRaw(offset_t rva) { WatchedLocker lock(&m_peMutex, PE_SHOW_LOCK, __FUNCTION__); if (rva >= this->getMappedSize(Executable::RVA)) { return INVALID_ADDR; } SectionHdrWrapper* sec = this->_getSecHdrAtOffset(rva, Executable::RVA, true); if (sec) { offset_t bgnRVA = ...
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rsi, %rbx movq %rdi, %r15 leaq 0x120(%rdi), %rsi leaq 0x11e3b(%rip), %rcx # 0x33290 leaq 0x8(%rsp), %rdi xorl %edx, %edx callq 0x1a4b4 movq (%r15), %rax pushq $0x2 popq %rsi movq %r15, %rdi callq *0x78(%rax) pushq $-0x1 popq %r14 cmpq %rb...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::createSectionView(unsigned long)
BufferView* PEFile::createSectionView(size_t secId) { WatchedLocker lock(&m_peMutex, PE_SHOW_LOCK, __FUNCTION__); SectionHdrWrapper *sec = this->_getSecHdr(secId); if (!sec) { Logger::append(Logger::D_WARNING, "No such section"); return NULL; } return _createSectionView(sec); }
pushq %r14 pushq %rbx subq $0x38, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x120(%rdi), %rsi leaq 0x11d0a(%rip), %rcx # 0x33299 movq %rsp, %rdi xorl %edx, %edx callq 0x1a4b4 movq %rbx, %rdi movq %r14, %rsi callq 0x1af8a testq %rax, %rax je 0x215b9 movq %rbx, %rdi movq %rax, %rsi callq 0x215f2 movq %rax, %rbx jmp 0...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::_canAddNewSection()
bool PEFile::_canAddNewSection() { ExeNodeWrapper* sec = dynamic_cast<ExeNodeWrapper*>(getWrapper(PEFile::WR_SECTIONS)); if (sec == NULL || sec->canAddEntry() == false) { return false; } const size_t secCount = hdrSectionsNum(); if (secCount == SectHdrsWrapper::SECT_COUNT_MAX) { retu...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx addq $0x18, %rdi movq 0x18(%rbx), %rax pushq $0x5 popq %rsi callq *0x10(%rax) testq %rax, %rax je 0x219ce leaq 0x2b0fb(%rip), %rsi # 0x4ca88 leaq 0x2b2a4(%rip), %rdx # 0x4cc38 xorl %r14d, %r14d movq %rax, %rdi xorl %ecx, %ecx callq 0x15520 testq %rax, %rax je 0x2...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
PEFile::getExportsMap(QMap<unsigned long, QString>&, Executable::addr_type)
size_t PEFile::getExportsMap(QMap<offset_t,QString> &entrypoints, Executable::addr_type aType) { size_t initialSize = entrypoints.size(); ExportDirWrapper* exports = dynamic_cast<ExportDirWrapper*>(this->getWrapper(PEFile::WR_DIR_ENTRY + pe::DIR_EXPORT)); if (!exports) return 0; const size_t e...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movl %edx, 0xc(%rsp) movq %rsi, %rbp movq %rdi, %r14 movq (%rsi), %rax testq %rax, %rax je 0x22020 movq 0x30(%rax), %r13 jmp 0x22023 xorl %r13d, %r13d leaq 0x18(%r14), %rdi movq 0x18(%r14), %rax pushq $0x6 popq %rsi callq *0x10(%rax) tes...
/hasherezade[P]bearparser/parser/pe/PEFile.cpp
RichHdrWrapper::getSize()
bufsize_t RichHdrWrapper::getSize() { if (!this->richSign || !this->dansHdr) { return 0; } const offset_t dansOffset = getOffset(this->dansHdr); const offset_t richOffset = getOffset(this->richSign); offset_t diff = richOffset - dansOffset; pe::RICH_SIGNATURE rich1 = { 0 }; diff += ...
cmpq $0x0, 0x18(%rdi) je 0x22fb1 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x20(%rdi), %rsi testq %rsi, %rsi je 0x22fb4 movq (%rbx), %rax movq %rbx, %rdi xorl %edx, %edx callq *0x30(%rax) movq %rax, %r14 movq (%rbx), %rax movq 0x18(%rbx), %rsi movq %rbx, %rdi xorl %edx, %edx callq *0x30(%rax) subq %r14, %ra...
/hasherezade[P]bearparser/parser/pe/RichHdrWrapper.cpp
RichHdrWrapper::getCompId(unsigned long)
pe::RICH_COMP_ID RichHdrWrapper::getCompId(size_t fieldId) { pe::RICH_COMP_ID emptyId = { 0 }; if (!this->richSign || !this->dansHdr) { return emptyId; } const uint32_t xorVal = this->richSign->checksum; const size_t cnt = this->compIdCounter - 1; bool isOk = false; uint64_t num = th...
movq 0x18(%rdi), %rcx xorl %eax, %eax testq %rcx, %rcx je 0x23190 cmpq $0x0, 0x20(%rdi) je 0x23190 pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %rbx movl 0x4(%rcx), %r15d movq 0x28(%rdi), %r12 leaq 0x7(%rsp), %r14 movb $0x0, (%r14) movq (%rdi), %rax pushq $-0x1 popq %rdx movq %r14, %rcx callq *0xe0...
/hasherezade[P]bearparser/parser/pe/RichHdrWrapper.cpp
FileHdrWrapper::translateMachine(unsigned int)
QString FileHdrWrapper::translateMachine(DWORD val) { if (s_machine.size() == 0) initMachine(); if (s_machine.find(val) == s_machine.end()) return ""; return s_machine[val]; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl %esi, 0x4(%rsp) leaq 0x2e35e(%rip), %r14 # 0x52470 cmpq $0x0, 0x28(%r14) jne 0x2411e callq 0x23a22 leaq 0x4(%rsp), %rsi movq %r14, %rdi callq 0x2491a addq $0x8, %r14 cmpq %r14, %rax je 0x24152 leaq 0x2e335(%rip), %rdi # 0x52470 leaq 0x4(%rsp), %rsi callq 0x2...
/hasherezade[P]bearparser/parser/pe/FileHdrWrapper.cpp
FileHdrWrapper::getFieldName(unsigned long)
QString FileHdrWrapper::getFieldName(size_t fieldId) { switch (fieldId) { case MACHINE: return("Machine"); case SEC_NUM: return ("Sections Count"); case TIMESTAMP: { PEFile* myPe = dynamic_cast<PEFile*>(this->m_Exe); if (myPe && myPe->isReproBuild()) { ...
pushq %rbx movq %rdi, %rbx cmpq $0x6, %rdx ja 0x24265 leaq 0x10697(%rip), %rax # 0x348a0 movslq (%rax,%rdx,4), %rcx addq %rax, %rcx jmpq *%rcx leaq 0x10bed(%rip), %rsi # 0x34e06 jmp 0x24290 leaq 0x10c2d(%rip), %rsi # 0x34e4f jmp 0x24290 movq 0x8(%rsi), %rdi testq %rdi, %rdi je 0x24289 leaq 0x28674(%rip), %r...
/hasherezade[P]bearparser/parser/pe/FileHdrWrapper.cpp
OptHdrWrapper::splitDllCharact(unsigned int)
std::vector<DWORD> OptHdrWrapper::splitDllCharact(DWORD characteristics) { if (s_dllCharact.size() == 0) initDllCharact(); std::vector<DWORD> chSet; map<DWORD, QString>::iterator iter; for (iter = s_dllCharact.begin(); iter != s_dllCharact.end(); ++iter) { if (characteristics & iter->first) { ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movl %esi, %ebp movq %rdi, %rbx leaq 0x2d8cf(%rip), %r15 # 0x52508 cmpq $0x0, 0x28(%r15) jne 0x24c45 callq 0x249f8 andq $0x0, 0x10(%rbx) xorps %xmm0, %xmm0 movups %xmm0, (%rbx) movq 0x18(%r15), %r14 addq $0x8, %r15 cmpq %r15, %r14 je 0x24c7c testl %ebp, 0x20(%r...
/hasherezade[P]bearparser/parser/pe/OptHdrWrapper.cpp
SectionHdrWrapper::getFieldPtr(unsigned long, unsigned long)
void* SectionHdrWrapper::getFieldPtr(size_t fieldId, size_t subField) { IMAGE_SECTION_HEADER* sec = (IMAGE_SECTION_HEADER*) getPtr(); if (!sec) return NULL; if (!this->name) return NULL; switch (fieldId) { case NAME: return (void*) &sec->Name; case VSIZE: return (void*) &sec->Misc.Vi...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movq (%rdi), %rax callq *0x60(%rax) xorl %ecx, %ecx testq %rax, %rax je 0x26343 cmpq $0x0, 0x60(%r14) je 0x26343 cmpq $0x9, %rbx ja 0x2632c leaq 0xf18d(%rip), %rcx # 0x35480 movslq (%rcx,%rbx,4), %rdx addq %rcx, %rdx jmpq *%rdx addq $0x8, %rax jmp 0x...
/hasherezade[P]bearparser/parser/pe/SectHdrsWrapper.cpp
ImportBaseFuncWrapper::getName()
QString ImportBaseFuncWrapper::getName() { QString libName = getLibName(); QString functionName = getShortName(); if (!libName.length()) return functionName; return "[" + QString(libName) + "]." + functionName; }
pushq %r14 pushq %rbx subq $0x78, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x18(%rsp), %rdi callq 0x27e62 leaq 0x30(%rsp), %rdi movq %r14, %rsi callq 0x27b18 movq 0x28(%rsp), %rax testq %rax, %rax je 0x27f76 movq 0x18(%rsp), %rcx movq 0x20(%rsp), %rdx movq %rcx, (%rsp) movq %rdx, 0x8(%rsp) movq %rax, 0x10(%rsp) testq ...
/hasherezade[P]bearparser/parser/pe/ImportBaseDirWrapper.cpp
ImportedFuncWrapper::getImportByNamePtr()
IMAGE_IMPORT_BY_NAME* ImportedFuncWrapper::getImportByNamePtr() { bool isOk = false; uint64_t offset = this->getNumValue(ImportedFuncWrapper::ORIG_THUNK, &isOk); if (!isOk || offset == INVALID_ADDR) { offset = this->getNumValue(ImportedFuncWrapper::THUNK, &isOk); } if (!isOk) return NULL; ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x7(%rsp), %r14 movb $0x0, (%r14) movq (%rdi), %rax pushq $-0x1 popq %rdx xorl %esi, %esi movq %r14, %rcx callq *0xe0(%rax) movb (%r14), %cl cmpq $-0x1, %rax setne %dl testb %cl, %dl jne 0x2893c movq (%rbx), %rax pushq $0x1 popq %rsi pushq $-0x1 popq %rdx leaq 0x7(%...
/hasherezade[P]bearparser/parser/pe/ImportDirWrapper.cpp
ImportedFuncWrapper::getThunkValue()
uint64_t ImportedFuncWrapper::getThunkValue() { bool is64 = (m_Exe->getBitMode() == Executable::BITS_64) ? true : false; uint64_t ordinal = 0; void* thunkPtr = getPtr(); if (!thunkPtr) return 0; if (is64) { uint64_t* ptr = (uint64_t*) thunkPtr; ordinal = *ptr; if (ordinal ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movq 0x8(%rdi), %rdi movq (%rdi), %rax callq *0x58(%rax) movl %eax, %ebx movq (%r14), %rax movq %r14, %rdi callq *0x60(%rax) testq %rax, %rax je 0x28a0e movq %rax, %rcx cmpl $0x40, %ebx jne 0x28a12 movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF andq (%rcx),...
/hasherezade[P]bearparser/parser/pe/ImportDirWrapper.cpp
ImportEntryWrapper::getPtr()
void* ImportEntryWrapper::getPtr() { if (m_PE == NULL) return NULL; IMAGE_DATA_DIRECTORY *d = m_PE->getDataDirectory(); if (!d) return NULL; offset_t importRva = static_cast<offset_t>(d[pe::DIR_IMPORT].VirtualAddress); if (importRva == 0) return NULL; offset_t descAddr = this->m_PE->toRaw(...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x38(%rdi), %rdi testq %rdi, %rdi je 0x28ca5 callq 0x2113e testq %rax, %rax je 0x28ca5 movl 0x8(%rax), %esi testq %rsi, %rsi je 0x28ca5 movq 0x38(%rbx), %rdi movq (%rdi), %rax pushq $0x2 popq %rdx xorl %ecx, %ecx callq *0xc0(%rax) cmpq $-0x1, %rax je 0x28ca5 movq %r...
/hasherezade[P]bearparser/parser/pe/ImportDirWrapper.cpp
ImportEntryWrapper::getLibraryName()
char* ImportEntryWrapper::getLibraryName() { IMAGE_IMPORT_DESCRIPTOR* desc = (IMAGE_IMPORT_DESCRIPTOR*) getPtr(); if (!desc) { return NULL; } offset_t nameRVA = desc->Name; offset_t nAddr = m_Exe->toRaw(nameRVA, Executable::RVA); if (nAddr == INVALID_ADDR) return NULL; //TODO: reim...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %r14 movq (%rdi), %rax callq *0x60(%rax) testq %rax, %rax je 0x28e33 movl 0xc(%rax), %esi movq 0x8(%r14), %rdi movq (%rdi), %rax pushq $0x2 popq %rdx xorl %ebx, %ebx xorl %ecx, %ecx callq *0xc0(%rax) cmpq $-0x1, %rax je 0x28e35 movq 0x8(%r14), %rdi movq (%rdi), %r8 pushq $0x1...
/hasherezade[P]bearparser/parser/pe/ImportDirWrapper.cpp
DelayImpEntryWrapper::containsAddrType(unsigned long, unsigned long)
Executable::addr_type DelayImpEntryWrapper::containsAddrType(size_t fieldId, size_t subField) { switch (fieldId) { case NAME : case MOD : case IAT : case INT : case BOUND_IAT : case UNLOAD_IAT : { bool isOk = false; uint64_t offset = th...
leaq -0x1(%rsi), %rcx xorl %eax, %eax cmpq $0x5, %rcx ja 0x29669 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x7(%rsp), %r14 movb $0x0, (%r14) movq (%rdi), %rax pushq $-0x1 popq %rdx movq %r14, %rcx callq *0xe0(%rax) movq %rax, %rsi xorl %eax, %eax cmpb $0x1, (%r14) jne 0x29662 movq 0x8(%rbx), %rdi pushq $0x2...
/hasherezade[P]bearparser/parser/pe/DelayImpDirWrapper.cpp
DelayImpFuncWrapper::getOrdinal()
uint64_t DelayImpFuncWrapper::getOrdinal() { bool isOk = false; uint64_t addr = this->getNumValue(NAMETHUNK_ADDR, &isOk); if (!isOk || addr == INVALID_ADDR) return INVALID_ADDR; size_t fieldSize = this->ptrLen() * 8; // in bits! size_t shiftSize = (sizeof(addr) - fieldSize) + 1; uint64_t shift...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx leaq 0x7(%rsp), %rcx movb $0x0, (%rcx) movq (%rdi), %rax pushq $-0x1 popq %r14 xorl %esi, %esi movq %r14, %rdx callq *0xe0(%rax) cmpq $-0x1, %rax je 0x29703 cmpb $0x0, 0x7(%rsp) je 0x29703 movq 0x8(%rbx), %rdi movq (%rdi), %rax callq *0x58(%rax) xorl %r14d, %r14d movq %r...
/hasherezade[P]bearparser/parser/pe/DelayImpDirWrapper.cpp
BoundEntryWrapper::getLibraryName()
char* BoundEntryWrapper::getLibraryName() { //---- BoundImpDirWrapper* parent = dynamic_cast<BoundImpDirWrapper*> (this->getParentNode()); if (!parent) return NULL; IMAGE_BOUND_IMPORT_DESCRIPTOR* firstEntry = parent->boundImp(); if (firstEntry == NULL) return NULL; uint64_t offset = this->getO...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rax callq *0x118(%rax) testq %rax, %rax je 0x29d5b leaq 0x22f4c(%rip), %rsi # 0x4cc38 leaq 0x25155(%rip), %rdx # 0x4ee48 movq %rax, %rdi xorl %ecx, %ecx callq 0x15520 testq %rax, %rax je 0x29d5b movq %rax, %rdi callq 0x29ab4 testq %rax, %rax je 0x29...
/hasherezade[P]bearparser/parser/pe/BoundImpDirWrapper.cpp
DebugDirEntryWrapper::translateType(int)
QString DebugDirEntryWrapper::translateType(int type) { switch (type) { case pe::DT_UNKNOWN : return "unknown"; case pe::DT_COFF : return "COFF"; case pe::DT_CODEVIEW : return "Visual C++ (CodeView)"; case pe::DT_FPO : return "Frame pointer omission"; case pe::DT_MISC : retur...
pushq %rbx movq %rdi, %rbx cmpl $0x10, %edx ja 0x2a1e3 movl %edx, %eax leaq 0xb97a(%rip), %rcx # 0x35b54 movslq (%rcx,%rax,4), %rsi addq %rcx, %rsi jmp 0x2a1ea leaq 0xbadb(%rip), %rsi # 0x35cc5 movq %rbx, %rdi callq 0x16572 movq %rbx, %rax popq %rbx retq nop
/hasherezade[P]bearparser/parser/pe/DebugDirWrapper.cpp
DebugDirEntryWrapper::getNB10()
pe::DEBUG_NB10* DebugDirEntryWrapper::getNB10() { BYTE* debugStr = getDebugStruct(); IMAGE_DEBUG_DIRECTORY* d = debugDir(); if (!debugStr || !d) return NULL; if (d->SizeOfData < sizeof(DEBUG_NB10)) { return NULL; } DEBUG_NB10* nb = (DEBUG_NB10*)debugStr; if (nb->cvHdr.CvSignature == ...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x2a066 movq %rax, %rbx movq %r14, %rdi callq 0x2a956 testq %rbx, %rbx sete %cl testq %rax, %rax sete %dl orb %cl, %dl jne 0x2a2ab cmpl $0x11, 0x10(%rax) jae 0x2a2af xorl %eax, %eax jmp 0x2a2bb xorl %eax, %eax cmpl $0x3031424e, (%rbx) # imm = 0x3031424E cmoveq ...
/hasherezade[P]bearparser/parser/pe/DebugDirWrapper.cpp
DebugDirCVEntryWrapper::getSignature()
QString DebugDirCVEntryWrapper::getSignature() { DEBUG_RSDSI* rdsi = (DEBUG_RSDSI*)this->getPtr(); if (!rdsi) return ""; QString out; #if QT_VERSION >= 0x050000 out = QString().asprintf("%.4s", (char*)&rdsi->dwSig); #else out = QString().sprintf("%.4s", (char*)&rdsi->dwSig); #endif return out; ...
pushq %r14 pushq %rbx subq $0x38, %rsp movq %rdi, %rbx movq (%rsi), %rax movq %rsi, %rdi callq *0x60(%rax) testq %rax, %rax je 0x2a7e5 xorps %xmm0, %xmm0 movups %xmm0, (%rbx) andq $0x0, 0x10(%rbx) movaps %xmm0, (%rsp) andq $0x0, 0x10(%rsp) leaq 0xb547(%rip), %rsi # 0x35ced leaq 0x20(%rsp), %rdi movq %rax, %rdx xor...
/hasherezade[P]bearparser/parser/pe/DebugDirWrapper.cpp
DebugDirCVEntryWrapper::getFieldName(unsigned long)
QString DebugDirCVEntryWrapper::getFieldName(size_t fId) { switch (fId) { case F_CVDBG_SIGN: return "CvSig"; case F_CVDBG_GUID: return "Signature"; case F_CVDBG_AGE: return "Age"; case F_CVDBG_PDB: return "PDB"; } return ""; }
pushq %rbx movq %rdi, %rbx cmpq $0x3, %rdx ja 0x2a834 leaq 0xb36d(%rip), %rax # 0x35b98 movslq (%rax,%rdx,4), %rsi addq %rax, %rsi jmp 0x2a83b leaq 0x7bec(%rip), %rsi # 0x32427 movq %rbx, %rdi callq 0x16572 movq %rbx, %rax popq %rbx retq
/hasherezade[P]bearparser/parser/pe/DebugDirWrapper.cpp
ExportDirWrapper::mapNames()
size_t ExportDirWrapper::mapNames() { IMAGE_EXPORT_DIRECTORY* exp = exportDir(); if (exp == NULL) return 0; size_t maxNames = exp->NumberOfNames; offset_t nameOrdRVA = exp->AddressOfNameOrdinals; //uint64_t nameRVA = exp->AddressOfNames; size_t i = 0; for (i = 0; i < maxNames; i++) { ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 callq 0x2ab54 testq %rax, %rax je 0x2abed movl 0x18(%rax), %ebp movl 0x24(%rax), %r15d leaq 0x50(%r14), %r12 xorl %ebx, %ebx pushq $0x2 popq %r13 cmpq %rbx, %rbp je 0x2abf4 movq 0x8(%r14), %rdi movq (%rdi), %rax movq %r15, %rsi...
/hasherezade[P]bearparser/parser/pe/ExportDirWrapper.cpp
ExportDirWrapper::wrap()
bool ExportDirWrapper::wrap() { clear(); mapNames(); IMAGE_EXPORT_DIRECTORY* exp = exportDir(); if (exp == NULL) return 0; size_t maxFunc = exp->NumberOfFunctions; for (size_t i = 0; i < maxFunc; i++) { //TODO: build entries... ExportEntryWrapper *entry = new ExportEntryWrappe...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx movq (%rdi), %rax callq *0x160(%rax) movq %rbx, %rdi callq 0x2ab8e movq %rbx, %rdi callq 0x2ab54 movq %rax, 0x8(%rsp) testq %rax, %rax je 0x2ac9d movq 0x8(%rsp), %rax movl 0x14(%rax), %ebp leaq 0x20(%rbx), %r15 xorl %r12d...
/hasherezade[P]bearparser/parser/pe/ExportDirWrapper.cpp
ExportDirWrapper::getFieldName(unsigned long)
QString ExportDirWrapper::getFieldName(size_t fieldId) { switch (fieldId) { case CHARACTERISTIC: return "Characteristics"; case TIMESTAMP: { PEFile* myPe = dynamic_cast<PEFile*>(this->m_Exe); if (myPe && myPe->isReproBuild()) { return "ReproChecksum"; ...
pushq %rbx movq %rdi, %rbx cmpq $0xa, %rdx ja 0x2aec2 leaq 0xaf31(%rip), %rax # 0x35d4c movslq (%rax,%rdx,4), %rcx addq %rax, %rcx jmpq *%rcx leaq 0xa5b4(%rip), %rsi # 0x353df jmp 0x2aed4 leaq 0xac6e(%rip), %rsi # 0x35aa5 jmp 0x2aed4 leaq 0xafb3(%rip), %rsi # 0x35df6 jmp 0x2aed4 leaq 0xad59(%rip), %...
/hasherezade[P]bearparser/parser/pe/ExportDirWrapper.cpp
ExportEntryWrapper::getFuncName()
char* ExportEntryWrapper::getFuncName() { uint64_t funcRva = getFuncNameRva(); if (funcRva == INVALID_ADDR) return NULL; char* name = (char*) this->m_Exe->getContentAt(funcRva, Executable::RVA, 1); if (name == NULL) return NULL; //TODO.... verify return name; }
pushq %rbx movq %rdi, %rbx callq 0x2b26c cmpq $-0x1, %rax je 0x2b0be movq 0x8(%rbx), %rdi movq (%rdi), %rcx movq 0x70(%rcx), %r9 pushq $0x2 popq %rdx pushq $0x1 popq %rcx movq %rax, %rsi xorl %r8d, %r8d popq %rbx jmpq *%r9 xorl %eax, %eax popq %rbx retq
/hasherezade[P]bearparser/parser/pe/ExportDirWrapper.cpp
ExportEntryWrapper::getFuncNameId()
uint32_t ExportEntryWrapper::getFuncNameId() { if (this->parentDir == NULL) return INVALID_ID; WORD ord = static_cast<WORD>(this->entryNum); std::map<WORD, DWORD>::iterator found = parentDir->ordToNameId.find(ord); if (found == parentDir->ordToNameId.end()) { return INVALID_ID; } return...
pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movq 0x38(%rdi), %rdi testq %rdi, %rdi je 0x2b262 movzwl 0x18(%rbx), %eax leaq 0xe(%rsp), %rsi movw %ax, (%rsi) addq $0x50, %rdi callq 0x2b6b8 movq 0x38(%rbx), %rcx addq $0x58, %rcx cmpq %rcx, %rax je 0x2b262 movl 0x24(%rax), %eax jmp 0x2b265 pushq $-0x1 popq %rax addq $0x10,...
/hasherezade[P]bearparser/parser/pe/ExportDirWrapper.cpp
SecurityDirWrapper::getFieldPtr(unsigned long, unsigned long)
void* SecurityDirWrapper::getFieldPtr(size_t fId, size_t subField) { pe::WIN_CERTIFICATE* cert = getCert(); if (cert == NULL) return 0; switch (fId) { case CERT_LEN : return &cert->dwLength; case REVISION : return &cert->wRevision; case TYPE : return &cert->wCertificateType; ...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 callq 0x2b6f0 testq %rax, %rax je 0x2b7d0 cmpq $0x3, %rbx ja 0x2b7e6 leaq 0xa67f(%rip), %rcx # 0x35e40 movslq (%rcx,%rbx,4), %rdx addq %rcx, %rdx jmpq *%rdx addq $0x4, %rax jmp 0x2b7de xorl %eax, %eax jmp 0x2b7de addq $0x6, %rax jmp 0x2b7de addq $0x8...
/hasherezade[P]bearparser/parser/pe/SecurityDirWrapper.cpp
SecurityDirWrapper::translateType(int)
QString SecurityDirWrapper::translateType(int type) { switch (type) { case pe::WIN_CERT_TYPE_X509 : return "X.509 certificate"; case pe::WIN_CERT_TYPE_PKCS_SIGNED_DATA : return "PKCS Signed Data"; case pe::WIN_CERT_TYPE_RESERVED_1 : return "Reserved"; case pe::WIN_CERT_TYPE_PKCS1_SI...
pushq %rbx movq %rdi, %rbx decl %edx cmpl $0x8, %edx ja 0x2b877 movl %edx, %eax leaq 0xa60a(%rip), %rcx # 0x35e78 movslq (%rcx,%rax,4), %rsi addq %rcx, %rsi jmp 0x2b87e leaq 0x6ba9(%rip), %rsi # 0x32427 movq %rbx, %rdi callq 0x16572 movq %rbx, %rax popq %rbx retq nop
/hasherezade[P]bearparser/parser/pe/SecurityDirWrapper.cpp
TlsDirWrapper::containsAddrType(unsigned long, unsigned long)
Executable::addr_type TlsDirWrapper::containsAddrType(size_t fieldId, size_t subField) { switch (fieldId) { case START_ADDR : case END_ADDR : case INDEX_ADDR : case CALLBACKS_ADDR : return Executable::VA; } return Executable::NOT_ADDR; }
xorl %eax, %eax cmpq $0x4, %rsi setb %al leal (%rax,%rax,2), %eax retq nop
/hasherezade[P]bearparser/parser/pe/TlsDirWrapper.cpp
TlsDirWrapper::getTlsDirPtr()
void* TlsDirWrapper::getTlsDirPtr() { bufsize_t dirSize = 0; if (m_Exe->getBitMode() == Executable::BITS_32) { dirSize = sizeof(IMAGE_TLS_DIRECTORY32); } else if (m_Exe->getBitMode() == Executable::BITS_64) { dirSize = sizeof(IMAGE_TLS_DIRECTORY64); } offset_t rva = getDirEntryAddr...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x8(%rdi), %rdi movq (%rdi), %rax callq *0x58(%rax) cmpl $0x20, %eax jne 0x2bc74 pushq $0x18 popq %r14 jmp 0x2bc8b movq 0x8(%rbx), %rdi movq (%rdi), %rax callq *0x58(%rax) xorl %ecx, %ecx cmpl $0x40, %eax pushq $0x28 popq %r14 cmovneq %rcx, %r14 movq %rbx, %rdi call...
/hasherezade[P]bearparser/parser/pe/TlsDirWrapper.cpp
LdConfigDirWrapper::wrap()
bool LdConfigDirWrapper::wrap() { clear(); if (!getPtr()) return false; //SEHandlerTable: wrapSubentriesTable(SEH_TABLE, SEH_COUNT); //GuardCFFunctionTable: wrapSubentriesTable(GUARD_TABLE, GUARD_COUNT); wrapSubentriesTable(GUARD_LONG_JUMP_TABLE, GUARD_LONG_JUMP_COUNT); wrapSub...
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rax callq *0x160(%rax) movq (%rbx), %rax movq %rbx, %rdi callq *0x60(%rax) movq %rax, %r14 testq %rax, %rax je 0x2bf5b pushq $0x12 popq %rsi pushq $0x13 popq %rdx movq %rbx, %rdi callq 0x2bdf4 pushq $0x16 popq %rsi pushq $0x17 popq %rdx movq %rbx, %rdi call...
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigDirWrapper::firstSubEntryPtr(unsigned long)
void* LdConfigDirWrapper::firstSubEntryPtr(size_t parentId) { bool isOk = false; offset_t offset = this->getNumValue(parentId, &isOk); if (!isOk) return NULL; Executable::addr_type aT = containsAddrType(parentId); if (aT == Executable::NOT_ADDR) return NULL; bufsize_t handlerSize = static_cast...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0xf(%rsp), %r12 movb $0x0, (%r12) movq (%rdi), %rax pushq $-0x1 popq %rdx movq %r12, %rcx callq *0xe0(%rax) cmpb $0x1, (%r12) jne 0x2c01c movq %rax, %r15 movq (%rbx), %rax pushq $-0x1 popq %rdx movq %rbx, %rdi m...
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigDirWrapper::getFieldPtr(unsigned long, unsigned long)
void* LdConfigDirWrapper::getFieldPtr(size_t fId, size_t subField) { const bool is32b = (m_Exe->getBitMode() == Executable::BITS_32) ? true : false; offset_t fieldDelta = _getFieldDelta(is32b, fId); if (fieldDelta != INVALID_ADDR) { const offset_t hdrSize = this->getHdrDefinedSize(); if...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %rbx movq 0x8(%rdi), %rdi movq (%rdi), %rax callq *0x58(%rax) xorl %edi, %edi cmpl $0x20, %eax sete %dil movq %r14, %rsi callq 0x2c0a4 cmpq $-0x1, %rax je 0x2c3a2 movq %rax, %r14 movq %rbx, %rdi callq 0x2bd38 cmpq %rax, %r14 jae 0x2c3a2 movq (%rbx), %rax movq ...
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigDirWrapper::containsAddrType(unsigned long, unsigned long)
Executable::addr_type LdConfigDirWrapper::containsAddrType(size_t fieldId, size_t subField) { switch (fieldId) { case LOCK_PREFIX : case EDIT_LIST : case SEC_COOKIE : case SEH_TABLE : case GUARD_CHECK : case GUARD_DISPATCH : case GUARD_TABLE : case GUA...
leaq -0x9(%rsi), %rcx xorl %eax, %eax cmpq $0x24, %rcx ja 0x2c647 leaq 0x9b5d(%rip), %rax # 0x361a0 movl -0x24(%rax,%rsi,4), %eax retq
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigDirWrapper::translateGuardFlag(unsigned int)
QString LdConfigDirWrapper::translateGuardFlag(DWORD flags) { if (flags & IMAGE_GUARD_CF_INSTRUMENTED) { return ("CF_INSTRUMENTED"); } if (flags & IMAGE_GUARD_CFW_INSTRUMENTED) { return ("CFW_INSTRUMENTED"); } if (flags & IMAGE_GUARD_CF_FUNCTION_TABLE_PRESENT) { return ("CF_F...
pushq %rbx movq %rdi, %rbx btl $0x8, %esi jb 0x2c72b btl $0x9, %esi jb 0x2c734 btl $0xa, %esi jb 0x2c73d btl $0xb, %esi jb 0x2c746 btl $0xc, %esi jb 0x2c74f btl $0xd, %esi jb 0x2c758 btl $0xe, %esi jb 0x2c761 testw %si, %si js 0x2c76a btl $0x10, %esi jb 0x2c773 btl $0x11, %esi jb 0x2c77c btl $0x12, %esi jb 0x2c785 btl ...
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigDirWrapper::translateGuardFlagsContent(QString const&)
QString LdConfigDirWrapper::translateGuardFlagsContent(const QString& delim) { bool isOk = false; DWORD GuardFlags = this->getNumValue(GUARD_FLAGS, &isOk); if (!isOk) { return "-"; } std::set<DWORD> flagsSet = LdConfigDirWrapper::getGuardFlagsSet(GuardFlags); std::set<DWORD>::iterator it...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %rdx, %r14 movq %rsi, %rax movq %rdi, %rbx leaq 0xf(%rsp), %r15 movb $0x0, (%r15) movq (%rsi), %r8 pushq $0x18 popq %rsi pushq $-0x1 popq %rdx movq %rax, %rdi movq %r15, %rcx callq *0xe0(%r8) cmpb $0x0, (%r15) je 0x2c846 leaq 0x48(%...
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigEntryWrapper::getFieldSize(unsigned long, unsigned long)
bufsize_t LdConfigEntryWrapper::getFieldSize(size_t fieldId, size_t subField) { size_t count = this->getFieldsCount(); if (fieldId >= count) { return 0; } if (fieldId == HANDLER_ADDR) { return sizeof(DWORD); } return sizeof(BYTE); }
pushq %rbx movq %rsi, %rbx movq (%rdi), %rax callq *0x78(%rax) xorl %edx, %edx testq %rbx, %rbx sete %dl xorl %ecx, %ecx cmpq %rbx, %rax leaq 0x1(%rdx,%rdx,2), %rax cmovaq %rax, %rcx movq %rcx, %rax popq %rbx retq nop
/hasherezade[P]bearparser/parser/pe/LdConfigDirWrapper.cpp
LdConfigDirWrapper::getFieldsCount()
virtual size_t getFieldsCount() { const offset_t realSize = getSize(); const bool is32b = (m_Exe->getBitMode() == Executable::BITS_32) ? true : false; size_t fId = FIELD_COUNTER - 1; offset_t fieldDelta = INVALID_ADDR; for (; fId != 0; fId--) { fieldDelta = _getFi...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movq (%rdi), %rax callq *0x68(%rax) movq %rax, %rbx movq 0x8(%r14), %rdi movq (%rdi), %rax callq *0x58(%rax) movl %eax, %ebp pushq $-0x1 popq %rax pushq $0x2e popq %r15 movq %r15, %r14 subq $0x1, %r15 jb 0x2cc05 xorl %edi, %edi cmpl $0x20, %ebp sete...
/hasherezade[P]bearparser/parser/include/bearparser/pe/LdConfigDirWrapper.h
RelocBlockWrapper::getPtr()
void* RelocBlockWrapper::getPtr() { if (this->parentDir == NULL) return NULL; IMAGE_BASE_RELOCATION* reloc = this->parentDir->reloc(); if (!reloc) return NULL; offset_t raw = INVALID_ADDR; BYTE *ptr = NULL; // use my cached: if (this->cachedRaw != INVALID_ADDR) { ptr = m_Exe->getCo...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movq 0x50(%rdi), %rdi testq %rdi, %rdi je 0x2dce2 callq 0x2da66 testq %rax, %rax je 0x2dce2 movq 0x40(%rbx), %rsi cmpq $-0x1, %rsi je 0x2dc23 movq 0x8(%rbx), %rdi movq (%rdi), %rax movq 0x70(%rax), %rax pushq $0x1 popq %rdx pus...
/hasherezade[P]bearparser/parser/pe/RelocDirWrapper.cpp
RelocBlockWrapper::maxEntriesNumInBlock()
size_t RelocBlockWrapper::maxEntriesNumInBlock() { if (this->cachedMaxNum > 0) return this->cachedMaxNum; IMAGE_BASE_RELOCATION* reloc = (IMAGE_BASE_RELOCATION*) this->getPtr(); if (!reloc) return 0; bufsize_t entriesSize = getFieldSize(ENTRIES_PTR); offset_t entriesOffset = getFieldOffset(ENTRIES...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq 0x48(%rdi), %r14 testq %r14, %r14 jne 0x2def9 movq %rdi, %rbx movq (%rdi), %rax callq *0x60(%rax) testq %rax, %rax je 0x2def6 movq (%rbx), %rax pushq $0x2 popq %r14 pushq $-0x1 popq %r15 movq %rbx, %rdi movq %r14, %rsi movq %r15, %rdx callq *0x98(%rax) movq %r...
/hasherezade[P]bearparser/parser/pe/RelocDirWrapper.cpp
RelocEntryWrapper::translateType(unsigned short)
QString RelocEntryWrapper::translateType(WORD type) { switch (type) { case 0 : return "Padding (skipped)"; case 1 : return "High WORD of 32-bit field"; case 2 : return "Low WORD of 32-bit field"; case 3 : return "32 bit field"; case 4 : return "HighAdj"; case 5 : ret...
pushq %rbx movq %rdi, %rbx cmpw $0xa, %si ja 0x2df7b movzwl %si, %eax leaq 0x87e6(%rip), %rcx # 0x36758 movslq (%rcx,%rax,4), %rsi addq %rcx, %rsi jmp 0x2df82 leaq 0x44a5(%rip), %rsi # 0x32427 movq %rbx, %rdi callq 0x16572 movq %rbx, %rax popq %rbx retq nop
/hasherezade[P]bearparser/parser/pe/RelocDirWrapper.cpp
ExceptionEntryWrapper::getFieldPtr(unsigned long, unsigned long)
void* ExceptionEntryWrapper::getFieldPtr(size_t fieldId, size_t subField) { void *ptr = this->getPtr(); if (!ptr) return nullptr; if (this->m_Exe->getArch() == Executable::ARCH_INTEL) { IMAGE_IA64_RUNTIME_FUNCTION_ENTRY* exc = (IMAGE_IA64_RUNTIME_FUNCTION_ENTRY*) ptr; if (!exc) return N...
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movq (%rdi), %rax callq *0x60(%rax) testq %rax, %rax je 0x2e438 movq %rax, %rbx movq 0x8(%r15), %rdi movq (%rdi), %rax callq *0x60(%rax) cmpl $0x1, %eax jne 0x2e43c cmpq $0x2, %r14 je 0x2e46d cmpq $0x1, %r14 jne 0x2e471 addq $0x4, %rbx jmp 0x2e471 xorl %e...
/hasherezade[P]bearparser/parser/pe/ExceptionDirWrapper.cpp
ResourceLeafWrapper::getFieldName(unsigned long)
QString ResourceLeafWrapper::getFieldName(size_t fieldId) { switch (fieldId) { case OFFSET_TO_DATA: return "OffsetToData"; case DATA_SIZE: return "DataSize"; case CODE_PAGE: return "CodePage"; case RESERVED: return "Reserved"; } return ""; }
pushq %rbx movq %rdi, %rbx cmpq $0x3, %rdx ja 0x2ed54 leaq 0x7c8d(%rip), %rax # 0x369d8 movslq (%rax,%rdx,4), %rsi addq %rax, %rsi jmp 0x2ed5b leaq 0x36cc(%rip), %rsi # 0x32427 movq %rbx, %rdi callq 0x16572 movq %rbx, %rax popq %rbx retq
/hasherezade[P]bearparser/parser/pe/ResourceDirWrapper.cpp
ClrDirWrapper::containsAddrType(unsigned long, unsigned long)
Executable::addr_type ClrDirWrapper::containsAddrType(size_t fieldId, size_t subField) { switch (fieldId) { case ENTRY_POINT: { const pe::IMAGE_COR20_HEADER* d = clrDir(); if (!d) return Executable::NOT_ADDR; if (d->Flags & pe::COMIMAGE_FLAGS_NATIVE_ENTRYPOINT) { ...
cmpq $0x11, %rsi ja 0x2f489 movl $0x2aa88, %eax # imm = 0x2AA88 btq %rsi, %rax jae 0x2f46d pushq $0x2 popq %rax retq cmpq $0x6, %rsi jne 0x2f489 pushq %rax callq 0x2f218 testq %rax, %rax je 0x2f48c movl 0x10(%rax), %eax shrl $0x3, %eax andl $0x2, %eax jmp 0x2f48e xorl %eax, %eax retq xorl %eax, %eax addq $0x8,...
/hasherezade[P]bearparser/parser/pe/ClrDirWrapper.cpp
ResourcesAlbum::clear()
void ResourcesAlbum::clear() { clearLeafsContent(); //--- std::map<ResourceLeafWrapper*, ResourceContentWrapper*>::iterator cntItr; for (cntItr = leafToContentWrapper.begin(); cntItr != leafToContentWrapper.end(); ++cntItr) { ResourceContentWrapper* cntWr = cntItr->second; delete cntWr; ...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx callq 0x2f76c movq 0xc8(%rbx), %r14 leaq 0xb8(%rbx), %r15 cmpq %r15, %r14 je 0x2f7f4 movq 0x28(%r14), %rdi testq %rdi, %rdi je 0x2f7e7 movq (%rdi), %rax callq *0x8(%rax) movq %r14, %rdi callq 0x15540 movq %rax, %r14 jmp 0x2f7d3 leaq 0xb0(%rbx), %rdi callq 0x300b8 leaq 0x...
/hasherezade[P]bearparser/parser/pe/rsrc/ResourcesAlbum.cpp
main
int main(int argc, char *argv[]) { cf_char_t s[] = " 12345\t "; cf_char_t s1[] = "a1234bcdefg"; cf_char_t buf[100]; cf_assert(cf_str_strip(s)); cf_assert(cf_strcmp("12345", s) == 0); cf_assert(cf_str_capitalize(s1)); cf_assert(cf_strcmp(s1, "A1234bcdefg") == 0); cf_assert(cf_str_swi...
pushq %rbx subq $0x90, %rsp movabsq $0x935343332312020, %rax # imm = 0x935343332312020 leaq 0x10(%rsp), %rdi movq %rax, (%rdi) movw $0x20, 0x8(%rdi) movabsq $0x6463623433323161, %rax # imm = 0x6463623433323161 movq %rax, (%rsp) movl $0x676665, 0x8(%rsp) # imm = 0x676665 callq 0x178f testl %eax, %eax je 0x13b5 leaq 0...
/tkorays[P]CFAST/tests/test_str.c
main
int main() { std::cout << "Using " << get_num_threads() << " threads\n"; spawn([](int &r, const int& i) { r = i + 1; LOG("setting " << r); }, tmpresult, 99); spawn([](int &r, const int& i) { r = 2 * i; LOG("setting " << r); }, i, tmpresult); wait_for_all(); const bool test_ok1 = (tmpresult == 100) && ...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x98, %rsp movq 0xb79d(%rip), %r14 # 0x16fc0 leaq 0x5a16(%rip), %rsi # 0x11240 movl $0x6, %edx movq %r14, %rdi callq 0xb1e0 callq 0xe236 movq %r14, %rdi movl %eax, %esi callq 0xb300 leaq 0x59fa(%rip), %rsi # 0x11247 movl $0x9, %edx m...
/fraguela[P]depspawn/tests/test_lambda.cpp
void depspawn::spawn<std::function<void (int&)>, int&>(std::function<void (int&)> const&, int&)
inline internal::spawn_ret_t spawn(const Function& f, Args&&... args) { using parameter_types = typename internal::ParameterTypes<Function>::type; internal::arg_info *pargs = nullptr; const int nargs = internal::fill_args<typename boost::mpl::begin<parameter_types>::type>(pargs, std::forward<Args>(args)......
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rsi, %r14 movq %rdi, %rbx leaq 0x8(%rsp), %r15 movq $0x0, (%r15) leaq 0xafbc(%rip), %rdi # 0x17200 callq 0xc486 movq $0x4, 0x8(%rax) movw $0x1, 0x20(%rax) movq %r14, (%rax) xorps %xmm0, %xmm0 movups %xmm0, 0x10(%rax) movq %rax, %rdi movq %r15, %rsi...
/fraguela[P]depspawn/include/depspawn/depspawn.h
LinkedListPool<depspawn::internal::arg_info, true, false>::intl_malloc()
T* intl_malloc() { T* ret = head_.load(std::memory_order_relaxed); do { while(clean_ptr(ret) == nullptr) { allocate(); ret = head_.load(std::memory_order_relaxed); } } while(!head_.compare_exchange_weak(ret, next_ptr(clean_ptr(static_cast<T *>(clean_ptr(ret)->next)), ret))); ...
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx movabsq $0xffffffffffff, %r14 # imm = 0xFFFFFFFFFFFF movq 0x20(%rdi), %rcx movabsq $-0x1000000000000, %r15 # imm = 0xFFFF000000000000 movq %rcx, %rax andq %r14, %rax jne 0xc4bc movq %rbx, %rdi callq 0xc4f4 movq 0x20(%rbx), %rcx jmp 0xc4a6 movq 0x18(%rax), %rax andq %r1...
/fraguela[P]depspawn/include/depspawn/LinkedListPool.h
LinkedListPool<depspawn::internal::arg_info, true, false>::allocate()
void allocate() { char * baseptr = PoolAllocator_malloc_free<SCALABLE>::malloc(chunkSize_ * minTSize_); char * const endptr = baseptr + minTSize_ * (chunkSize_ - 1); T * const h = reinterpret_cast<T *>(baseptr); T * const q = reinterpret_cast<T *>(endptr); T * p = h; do { baseptr += minTS...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x18(%rdi), %ebp movslq 0x1c(%rdi), %r15 movl %r15d, %eax imull %ebp, %eax movslq %eax, %rdi callq 0xb240 decl %ebp imull %r15d, %ebp movslq %ebp, %r14 addq %rax, %r14 movq %rax, (%rsp) xorps %xmm0, %xmm0 leaq (%rax,%r15), %rcx movups %xmm0, 0x...
/fraguela[P]depspawn/include/depspawn/LinkedListPool.h
LinkedListPool<depspawn::internal::Workitem, true, false>::allocate()
void allocate() { char * baseptr = PoolAllocator_malloc_free<SCALABLE>::malloc(chunkSize_ * minTSize_); char * const endptr = baseptr + minTSize_ * (chunkSize_ - 1); T * const h = reinterpret_cast<T *>(baseptr); T * const q = reinterpret_cast<T *>(endptr); T * p = h; do { baseptr += minTS...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x18(%rdi), %ebp movslq 0x1c(%rdi), %r15 movl %r15d, %eax imull %ebp, %eax movslq %eax, %rdi callq 0xb240 decl %ebp imull %r15d, %ebp movslq %ebp, %r14 addq %rax, %r14 movq %rax, (%rsp) leaq 0xa182(%rip), %rcx # 0x16910 addq $0x10, %rcx le...
/fraguela[P]depspawn/include/depspawn/LinkedListPool.h
depspawn::internal::TaskPool::Task* depspawn::internal::TaskPool::build_task<std::function<void (int&)> const&, std::reference_wrapper<int>>(depspawn::internal::Workitem*, std::function<void (int&)> const&, std::reference_wrapper<int>&&)
Task *build_task(Workitem *ctx, F&& f, Args&&... args) { return task_pool_.malloc(this, ctx, std::bind(std::forward<F>(f), std::forward<Args>(args)...)); }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x30, %rsp movq %rcx, %rbx movq %rsi, %r15 movq %rdi, %r14 leaq 0x1d8(%rdi), %r12 leaq 0x8(%rsp), %r13 movq %r13, %rdi movq %rdx, %rsi callq 0xcf92 movq (%rbx), %rax movq %rax, 0x20(%r13) movq %r12, %rdi callq 0xc94e movq %rax, %rbx leaq 0x8(%rsp), %rsi movq ...
/fraguela[P]depspawn/include/depspawn/TaskPool.h
depspawn::internal::arg_info::insert_in_arglist(depspawn::internal::arg_info*&)
void arg_info::insert_in_arglist(arg_info*& args) { arg_info *p, *prev; if(!args) { args = this; } else if(addr < args->addr) { next = args; args = this; } else { prev = args; p = args->next; while(p) { if(addr < p->addr) { if( !is_array() && (addr == prev->addr) ) //Arrays ...
movq (%rsi), %rax testq %rax, %rax je 0xdfb4 movq (%rdi), %rcx cmpq (%rax), %rcx jae 0xdfb8 movq %rax, 0x18(%rdi) movq %rdi, (%rsi) retq movq %rax, %rsi movq 0x18(%rax), %rax testq %rax, %rax je 0xdfe1 cmpq (%rax), %rcx jae 0xdfb8 cmpb $0x0, 0x21(%rdi) jne 0xdfd8 cmpq (%rsi), %rcx je 0xde96 movq %rdi, 0x18(%rsi) movq %...
/fraguela[P]depspawn/src/depspawn.cpp
depspawn::internal::arg_info::overlap_array(depspawn::internal::arg_info const*) const
bool arg_info::overlap_array(const arg_info *other) const { int i; const int lim = rank; do { if(wr || other->wr) { //if(data != other->data) return false; SHOULD be == assert(lim == other->rank); for(i = 0; i < lim; i++) { if(!overlaps_intervals(std::get<0>(array_range[...
pushq %rbp pushq %rbx movsbl 0x21(%rdi), %eax movb 0x20(%rdi), %cl movq (%rdi), %rdx movq 0x10(%rdi), %rdi testb %cl, %cl jne 0xe012 cmpb $0x1, 0x20(%rsi) jne 0xe05a testb %al, %al jle 0xe052 movq 0x10(%rsi), %r9 xorl %r8d, %r8d movl (%rdi,%r8,8), %r10d movl (%r9,%r8,8), %r11d xorl %ebx, %ebx cmpl 0x4(%rdi,%r8,8), %r11...
/fraguela[P]depspawn/src/depspawn.cpp
depspawn::internal::arg_info::is_contained_array(depspawn::internal::arg_info const*) const
bool arg_info::is_contained_array(const arg_info *other) const { int i; const int lim = rank; do { assert(lim == other->rank); for(i = 0; i < lim; i++) { if(!contains_intervals(std::get<0>(other->array_range[i]), std::get<1>(other->array_range[i]...
movsbl 0x21(%rdi), %eax movq (%rdi), %rcx movq 0x10(%rdi), %rdx movl $0x0, %edi testb %al, %al jle 0xe0ac movq 0x10(%rsi), %r8 xorl %edi, %edi movl (%r8,%rdi,8), %r9d cmpl (%rdx,%rdi,8), %r9d jg 0xe0ac movl 0x4(%r8,%rdi,8), %r9d cmpl %r9d, 0x4(%rdx,%rdi,8) jg 0xe0ac incq %rdi cmpq %rdi, %rax jne 0xe08c movl %eax, %edi ...
/fraguela[P]depspawn/src/depspawn.cpp
depspawn::internal::is_contained(depspawn::internal::Workitem const*, depspawn::internal::Workitem const*)
bool is_contained(const Workitem* const w, const Workitem * const ancestor) { const arg_info *arg_w = w->args; const arg_info *arg_p = ancestor->args; while(arg_p && arg_w) { if (arg_w->addr < arg_p->addr) { return false; } if (arg_w->is_a...
pushq %r14 pushq %rbx pushq %rax movq 0x10(%rdi), %rbx movq 0x10(%rsi), %r14 testq %r14, %r14 setne %al testq %rbx, %rbx setne %cl andb %al, %cl cmpb $0x1, %cl jne 0xe12b movq (%rbx), %rax movq (%r14), %rcx cmpq %rcx, %rax jb 0xe133 cmpb $0x0, 0x21(%rbx) je 0xe10a cmpq %rax, %rcx jne 0xe117 movq %rbx, %rdi movq %r14, %...
/fraguela[P]depspawn/src/depspawn.cpp
depspawn::wait_for_all()
void wait_for_all() { Workitem *p, *dp; #ifdef DEPSPAWN_USE_TBB if(internal::master_task) { internal::master_task->wait_for_all(); tbb::task::destroy(*internal::master_task); internal::master_task = nullptr; #else if(TP) { TP->wait(false); #endif if(worklist != nullptr) { ...
cmpq $0x0, 0x90ab(%rip) # 0x171f0 je 0xe1ef pushq %rbx movq 0x909d(%rip), %rbx # 0x171f0 movq %rbx, %rdi callq 0xeb10 testb %al, %al jne 0xe153 movl 0x20c(%rbx), %eax testl %eax, %eax jne 0xe153 movb $0x1, 0x208(%rbx) cmpb $0x0, 0x98(%rbx) jne 0xe170 cmpl $0x0, 0x94(%rbx) jne 0xe170 movq 0x910f(%rip), %rax ...
/fraguela[P]depspawn/src/depspawn.cpp
depspawn::Observer::~Observer()
Observer::~Observer() { std::unordered_set<internal::Workitem *> fathers({cur_father_}); internal::Workitem *p; bool must_reiterate; ObserversAtWork.fetch_add(1); //disable future attempts to erase Workitems during my activity while (eraser_assigned) { // Wait for current eraser, if any, to...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rdi, 0x20(%rsp) movq 0x8(%rdi), %rax leaq 0x30(%rsp), %rdx movq %rax, -0x8(%rdx) leaq 0x16(%rsp), %rax movq %rax, (%rsp) leaq 0x30(%rsp), %r14 leaq 0x28(%rsp), %rsi leaq 0x18(%rsp), %r8 leaq 0x17(%rsp), %r9 movq %r14, %rdi xorl %ec...
/fraguela[P]depspawn/src/depspawn.cpp
depspawn::internal::Workitem::Workitem(depspawn::internal::arg_info*, int)
Workitem::Workitem(arg_info *iargs, int nargs) : status(Status_t::Filling), optFlags_(0), guard_(0), nargs_(static_cast<char>(nargs)), args(iargs), next(nullptr), father(enum_thr_spec_father), ndependencies(0), nchildren(1), task(nullptr), deps(nullptr), lastdep(nullptr) { if(father) ...
leaq 0x8505(%rip), %rax # 0x16920 movq %rax, (%rdi) movw $0x0, 0x8(%rdi) movl $0x0, 0xa(%rdi) movb %dl, 0xe(%rdi) movq %rsi, 0x10(%rdi) xorl %ecx, %ecx movq %rcx, 0x18(%rdi) movq %fs:-0x8, %rax movq %rax, 0x20(%rdi) movabsq $0x100000000, %rdx # imm = 0x100000000 movq %rdx, 0x28(%rdi) xorps %xmm0, %xmm0 movups...
/fraguela[P]depspawn/src/workitem.cpp
asl::Socket_::available()
int Socket_::available() { if (_error != 0 || _handle < 0) return -1; #ifndef _WIN32 long n; if (ioctl(_handle, FIONREAD, &n) == 0) #else unsigned long n; if (ioctlsocket(_handle, FIONREAD, &n) == 0) #endif return (int)n; else return -1; } String Socket_::readLine() { char c; String s;...
pushq %r14 pushq %rbx pushq %rax pushq $-0x1 popq %rbx cmpl $0x0, 0x38(%rdi) jne 0x23afb movl 0xc(%rdi), %edi testl %edi, %edi js 0x23afb xorl %ebx, %ebx movq %rsp, %r14 movl $0x541b, %esi # imm = 0x541B movq %r14, %rdx xorl %eax, %eax callq 0x1e880 negl %eax sbbl %ebx, %ebx orl (%r14), %ebx movl %ebx, %eax a...
/aslze[P]asl/src/Socket.cpp
asl::Socket_::readLine()
String Socket_::readLine() { char c; String s; if (available()>0 || waitInput()) { while (1) { int n = read(&c, 1); if (n <= 0 || c == '\n' || _error != 0) break; if (s.length() > 16000) { _error = SOCKET_BAD_LINE; s = ""; break; } s += c; } } return s; ...
pushq %rbp pushq %r15 pushq %r14 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %rbx movb $0x0, 0x8(%rdi) andq $0x0, (%rdi) movq (%rsi), %rax movq %rsi, %rdi callq *0x60(%rax) testl %eax, %eax jg 0x23b3d movq (%r14), %rax movsd 0x1d525(%rip), %xmm0 # 0x41058 movq %r14, %rdi callq *0x78(%rax) testb %al, %al je 0x23...
/aslze[P]asl/src/Socket.cpp
asl::Socket_::read(void*, int)
int Socket_::read(void* data, int size) { int s = 0, size0 = size; do { #ifdef _WIN32 int n = recv(_handle, (char*)data, size, 0); #else int n = ::read(_handle, (char*)data, size); #endif if (!_blocking) return n; if (n <= 0) { _error = SOCKET_BAD_RECV; break; } data = (c...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movl %edx, %ebp movq %rsi, %r15 movq %rdi, %r14 xorl %ebx, %ebx movl %edx, %r12d movl 0xc(%r14), %edi movslq %r12d, %rdx movq %r15, %rsi callq 0x1e980 cmpb $0x1, 0x3c(%r14) jne 0x23bfd testl %eax, %eax jle 0x23c01 movl %eax, %ecx andl $0x7fffffff, %ecx # imm ...
/aslze[P]asl/src/Socket.cpp
asl::PacketSocket_::readFrom(asl::InetAddress&, void*, int)
int PacketSocket_::readFrom(InetAddress& a, void* data, int n) { if (_handle < 0) init(); a = InetAddress(_family); socklen_t len = (socklen_t)a.length(); int r= recvfrom(_handle, (char*)data, n, 0, (sockaddr*)a.ptr(), &len); return r; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x10, %rsp movl %ecx, %ebp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 cmpl $0x0, 0xc(%rdi) jns 0x23fff movq %r14, %rdi xorl %esi, %esi callq 0x1e7d0 movl 0x18(%r14), %esi movq %rsp, %r12 movq %r12, %rdi callq 0x1e1e0 movq %r15, %rdi movq %r12, %rsi callq...
/aslze[P]asl/src/Socket.cpp
asl::Socket_::Socket_(asl::Socket_ const&)
ASL_SMART_CLASS(Socket, SmartObject) { ASL_SMART_INNER_DEF(Socket); friend class Sockets; int _handle; enum { TCP, PACKET, LOCAL } _type; Endian _endian; InetAddress::Type _family; String _hostname; int _error; bool _blocking; virtual bool setOption(int level, int opt, const void* p, int n); bool init(bool f...
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq %rdi, %r14 movl 0x8(%rsi), %eax movl %eax, 0x8(%rdi) movq 0x3065f(%rip), %rax # 0x54eb0 addq $0x10, %rax movq %rax, (%rdi) movups 0xc(%rsi), %xmm0 movups %xmm0, 0xc(%rdi) addq $0x20, %rdi addq $0x20, %rsi callq 0x1efb0 movb 0x3c(%rbx), %al movb %al, 0x3c(%r14) m...
/aslze[P]asl/src/../include/asl/Socket.h
asl::WebSocket::closed()
bool WebSocket::closed() { if (_closed) return true; if (_socket.disconnected()) { _closed = true; _socket.close(); return true; } return false; }
pushq %r14 pushq %rbx pushq %rax movb $0x1, %bl cmpb $0x0, 0x11(%rdi) jne 0x2cede movq %rdi, %r14 movq (%rdi), %rdi movq (%rdi), %rax callq *0x28(%rax) testb %al, %al je 0x2cedc movb $0x1, 0x11(%r14) movq (%r14), %rdi movq (%rdi), %rax callq *0x58(%rax) jmp 0x2cede xorl %ebx, %ebx movl %ebx, %eax addq $0x8, %rsp popq %...
/aslze[P]asl/src/WebSocket.cpp
asl::Array<asl::Map<asl::String, char>::KeyVal>::dup()
Array& dup() { if(d().rc==1) return *this; return (*this = clone()); }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rax movl -0x8(%rax), %eax cmpl $0x1, %eax je 0x3399a movq %rsp, %r14 movq %r14, %rdi movq %rbx, %rsi callq 0x1c960 movq %rbx, %rdi movq %r14, %rsi callq 0x1edf0 movq %rax, %rbx movq %rsp, %rdi callq 0x1e610 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r1...
/aslze[P]asl/src/../include/asl/Array.h
asl::Array<asl::Map<asl::String, char>::KeyVal>::operator=(asl::Array<asl::Map<asl::String, char>::KeyVal> const&)
Array& operator=(const Array& b) { if (_a == b._a) return *this; if(--d().rc==0) free(); _a = b._a; ++d().rc; return *this; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movq (%rdi), %rax cmpq (%rsi), %rax je 0x339f6 movq %rsi, %r14 lock decl -0x8(%rax) jne 0x339ec movq %rbx, %rdi callq 0x1d7c0 movq (%r14), %rax movq %rax, (%rbx) lock incl -0x8(%rax) movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq nop
/aslze[P]asl/src/../include/asl/Array.h
asl::Stack<asl::Xml>::operator>>(asl::Xml&)
Stack& operator>>(T& x) { int lenMinusOne = this->length()-1; x = (*this)[lenMinusOne]; Array<T>::resize(lenMinusOne); return *this; }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rax movq %rdi, %rbx movq (%rdi), %rcx movslq -0x10(%rcx), %r14 leaq (%rcx,%r14,8), %rsi addq $-0x8, %rsi decq %r14 movq %rax, %rdi callq 0x1e720 movq %rbx, %rdi movl %r14d, %esi callq 0x1f480 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r14 retq
/aslze[P]asl/src/../include/asl/Stack.h
asl::IniFile::IniFile(asl::String const&, bool)
IniFile::IniFile(const String& fname, bool shouldwrite) { _modified = false; _filename = fname; _currentTitle = NOSECTION; _ok = false; _shouldwrite = shouldwrite; TextFile file(fname, File::READ); if(!file) { return; } _lines.reserve(16); _ok = true; Section* cursection = &_sections[NOSECTION...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xc8, %rsp movl %edx, 0x34(%rsp) movq %rsi, %r14 movq %rdi, %rbx callq 0x1efe0 leaq 0x8(%rbx), %rax movq %rax, 0x28(%rsp) xorl %eax, %eax andq $0x0, 0x8(%rbx) movb %al, 0x10(%rbx) andq $0x0, 0x20(%rbx) leaq 0x20(%rbx), %r15 movb %al, 0x28(%rbx) lea...
/aslze[P]asl/src/IniFile.cpp
asl::IniFile::operator[](asl::String const&)
String& IniFile::operator[](const String& name) { int slash = name.indexOf('/'); if(slash < 0) { return _sections[_currentTitle][name]; } else { String sec = name.substring(0, slash); Section& section = _sections[sec]; return section[name.substring(slash + 1)]; } }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x38, %rsp movq %rsi, %rbx movq %rdi, %r14 pushq $0x2f popq %rsi movq %rbx, %rdi xorl %edx, %edx callq 0x1d270 testl %eax, %eax js 0x3405e movl %eax, %ebp leaq 0x20(%rsp), %r15 movq %r15, %rdi movq %rbx, %rsi xorl %edx, %edx movl %eax, %ecx callq 0x1cf00 movq %r14, %rdi...
/aslze[P]asl/src/IniFile.cpp
asl::IniFile::operator[](asl::String const&) const
const String IniFile::operator[](const String& name) const { int slash = name.indexOf('/'); if (slash < 0) { return _sections[_currentTitle].has(name) ? _sections[_currentTitle][name] : String(); } else { String sec = name.substring(0, slash); if (!_sections.has(sec)) return String(); const...
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x30, %rsp movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %rbx pushq $0x2f popq %rsi movq %rdx, %rdi xorl %edx, %edx callq 0x1d270 testl %eax, %eax js 0x34162 movl %eax, %ebp movq %rsp, %r12 movq %r12, %rdi movq %r14, %rsi xorl %edx, %edx movl %eax, %ecx callq 0x...
/aslze[P]asl/src/IniFile.cpp
asl::TextFile::append(asl::String const&)
bool TextFile::append(const String& s) { if (!_file && !open(APPEND)) return false; return (int)fwrite(*s, 1, s.length(), _file) >= s.length(); }
pushq %r14 pushq %rbx pushq %rax movq %rsi, %rbx movq (%rdi), %rcx testq %rcx, %rcx jne 0x36767 movq %rdi, %r14 pushq $0x2 popq %rsi callq 0x1e2e0 testb %al, %al je 0x36790 movq (%r14), %rcx cmpl $0x0, (%rbx) je 0x36772 movq 0x8(%rbx), %rdi jmp 0x36776 leaq 0x8(%rbx), %rdi movslq 0x4(%rbx), %rdx pushq $0x1 popq %rsi ca...
/aslze[P]asl/src/TextFile.cpp
asl::Array<asl::File>::insert(int, asl::File const&)
Array<T>& Array<T>::insert(int k, const T& x) { Data* h = &d(); int n = h->n; int s = h->s; if (k < 0) k = n; if (n < s) {} else { s++; if (n == 2147483647) ASL_BAD_ALLOC(); dup(); int rc = d().rc; ASL_RC_FREE(); int s1 = s < 1073741823 ? 2 * s : 2147483647; char* p = (char*)r...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %esi, %ebp movq %rdi, %rbx movq (%rdi), %rax movl -0x10(%rax), %r12d movl -0xc(%rax), %r14d testl %esi, %esi cmovsl %r12d, %ebp cmpl %r14d, %r12d jge 0x38283 leaq -0x10(%rax), %r15 jmp 0x382f3 movq %rdx, 0x10(%rsp) cmpl $0x7fffffff,...
/aslze[P]asl/src/../include/asl/Array.h
TestMaterial::TestAnimation()
void TestMaterial::TestAnimation() { std::cout << "TestAnimation" << std::endl; Vector3 position(3, 3, 3); Vector3 axe(0, 0, 1); double angle(0); std::vector<Vector3> oldPos; for (size_t i=0; i<sObj.size(); i++) { position[0] =(Scalar(7*i%5)-2.)*DispersionScale; position[1] =((Scalar(5*i%6)-3.)*...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0xe8, %rsp movq %rdi, %rbx movq 0x3589(%rip), %r14 # 0x6fd8 leaq 0x1838(%rip), %rsi # 0x528e movl $0xd, %edx movq %r14, %rdi callq 0x2270 movq (%r14), %rax movq -0x18(%rax), %rdi addq %r14, %rdi movl $0xa, %esi callq 0x2210 movsbl %al, %e...
/jrl-umi3218[P]sch-core/tests/shared-tests/tests/common.cpp
TestMaterial::GeneralTest()
void TestMaterial::GeneralTest() { std::fstream outfile; outfile.open("/tmp/sch_generaltest_result.txt",std::ios_base::out|std::ios_base::trunc); outfile.precision(18); for (size_t k=0; k<stppObjects.size(); k++) { CD_Scene testscene; testscene.addObject(sObj[0]); sObj[0]->resetTransformation()...
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x368, %rsp # imm = 0x368 movq %rdi, %r14 leaq 0x158(%rsp), %rbx movq %rbx, %rdi callq 0x2280 leaq 0x11a1(%rip), %rsi # 0x529c movq %rbx, %rdi movl $0x30, %edx callq 0x21d0 movq 0x158(%rsp), %rax movq -0x18(%rax), %rax movq $0x12, 0...
/jrl-umi3218[P]sch-core/tests/shared-tests/tests/common.cpp
bios_edit_u32
uint32_t bios_edit_u32(uint8_t *vbios, size_t vbios_length, unsigned int offs, uint32_t new) { uint32_t orig = 0; if (offs+3 >= vbios_length) { fprintf(stderr, "requested OOB u32 at 0x%04x\n", offs); return 0; } orig = vbios[offs] | vbios[offs+1] << 8 | vbios[offs+2] << 16 | vbios[offs+3] << 24; vbios[offs + 0...
pushq %rbx leal 0x3(%rdx), %eax cmpq %rsi, %rax jae 0x28e3 movl %edx, %r8d movzbl (%rdi,%r8), %r9d leal 0x1(%rdx), %esi movzbl (%rdi,%rsi), %r10d shll $0x8, %r10d orl %r9d, %r10d addl $0x2, %edx movzbl (%rdi,%rdx), %r9d shll $0x10, %r9d orl %r10d, %r9d movzbl (%rdi,%rax), %ebx shll $0x18, %ebx orl %r9d, %ebx movb %cl, ...
/envytools[P]envytools/nva/nvafakebios.c
nva_init_gpu
struct nva_card *nva_init_gpu(struct pci_device *dev) { struct nva_card *card = calloc(sizeof *card, 1); if (!card) return 0; card->type = NVA_DEVICE_GPU; card->bus_type = NVA_BUS_PCI; card->bus.pci = dev; int ret = pci_device_map_range(dev, dev->regions[0].base_addr, dev->regions[0].size, PCI_DEV_MAP_FLAG_WRIT...
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %r14 movl $0x90, %edi movl $0x1, %esi callq 0x2120 testq %rax, %rax je 0x2ef2 movq %rax, %rbx movq $0x0, (%rax) movq %r14, 0x8(%rax) movq 0x28(%r14), %rsi movq 0x30(%r14), %rdx leaq 0x30(%rax), %r8 movq %r14, %rdi movl $0x1, %ecx callq 0x21b0 testl %eax,...
/envytools[P]envytools/nva/nva.c