name stringlengths 1 4.98k | code stringlengths 61 2.07M | asm stringlengths 57 12.9M | file stringlengths 18 192 |
|---|---|---|---|
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_comment<0>(char*&) | xml_node<Ch> *parse_comment(Ch *&text)
{
// If parsing of comments is disabled
if (!(Flags & parse_comment_nodes))
{
// Skip until end of comment
while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x31(%rbp)
jne 0x869d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al,... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_cdata<0>(char*&) | xml_node<Ch> *parse_cdata(Ch *&text)
{
// If CDATA is disabled
if (Flags & parse_no_data_nodes)
{
// Skip until end of cdata
while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
{
if (!text[... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x39(%rbp)
jne 0x8... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>* rapidxml::xml_document<char>::parse_doctype<0>(char*&) | xml_node<Ch> *parse_doctype(Ch *&text)
{
// Remember value start
Ch *value = text;
// Skip to >
while (*text != Ch('>'))
{
// Determine character type
switch (*text)
{
//... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
je 0x8a18
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x30(%... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::memory_pool<char>::allocate_node(rapidxml::node_type, char const*, char const*, unsigned long, unsigned long) | xml_node<Ch> *allocate_node(node_type type,
const Ch *name = 0, const Ch *value = 0,
std::size_t name_size = 0, std::size_t value_size = 0)
{
void *memory = allocate_aligned(sizeof(xml_node<Ch>));
xml_node<Ch> *nod... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x60, %esi
callq 0x9120
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
void rapidxml::xml_document<char>::parse_node_attributes<0>(char*&, rapidxml::xml_node<char>*) | void parse_node_attributes(Ch *&text, xml_node<Ch> *node)
{
// For all attributes
while (attribute_name_pred::test(*text))
{
// Extract attribute name
Ch *name = text;
++text; // Skip first character of attribute name
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x93d0
cmpb $0x0, %al
je 0x8eb7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
void rapidxml::xml_document<char>::parse_node_contents<0>(char*&, rapidxml::xml_node<char>*) | void parse_node_contents(Ch *&text, xml_node<Ch> *node)
{
// For all children and text
while (1)
{
// Skip whitespace between > and node contents
Ch *contents_start = text; // Store start of node contents before whitespace is skipped
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7d10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb ... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::memory_pool<char>::allocate_aligned(unsigned long) | void *allocate_aligned(std::size_t size)
{
// Calculate aligned pointer
char *result = align(m_ptr);
// If not enough memory left in current pool, allocate a new pool
if (result + size > m_end)
{
// Calculate required pool size (may be... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq 0x8(%rdi), %rsi
callq 0x6340
movq -0x48(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jbe 0x91e5
movq $0x10000, -0x20(%rbp) ... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::memory_pool<char>::allocate_raw(unsigned long) | char *allocate_raw(std::size_t size)
{
// Allocate
void *memory;
if (m_alloc_func) // Allocate memory using either user-specified allocation function or global operator new[]
{
memory = m_alloc_func(size);
assert(memory); // Al... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10018(%rax)
je 0x9351
movq -0x20(%rbp), %rax
movq 0x10018(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9330
jmp 0x934f
l... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
unsigned long rapidxml::internal::measure<char>(char const*) | inline std::size_t measure(const Ch *p)
{
const Ch *tmp = p;
while (*tmp)
++tmp;
return tmp - p;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9397
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9380
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::memory_pool<char>::allocate_attribute(char const*, char const*, unsigned long, unsigned long) | xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0,
std::size_t name_size = 0, std::size_t value_size = 0)
{
void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));
xml_attribute<Ch> *attribute = new(memory) xm... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x38, %esi
callq 0x9120
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9d90
movq -0x40(%rbp), %rax
movq %... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
rapidxml::xml_node<char>::append_attribute(rapidxml::xml_attribute<char>*) | void append_attribute(xml_attribute<Ch> *attribute)
{
assert(attribute && !attribute->parent());
if (first_attribute())
{
attribute->m_prev_attribute = m_last_attribute;
m_last_attribute->m_next_attribute = attribute;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
je 0x9529
movq -0x10(%rbp), %rdi
callq 0x9db0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
char* rapidxml::xml_document<char>::skip_and_expand_character_refs<rapidxml::xml_document<char>::attribute_value_pred<(char)39>, rapidxml::xml_document<char>::attribute_value_pure_pred<(char)39>, 0>(char*&) | static Ch *skip_and_expand_character_refs(Ch *&text)
{
// If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
if (Flags & parse_no_entity_translation &&
!(Flags & parse_normalize_whitespace) &&
!(Flags & parse_tr... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9dd0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x9e20
cmpb $0x0, %al
je 0x9968
movq -0x10(%rbp), %rax
movsbl... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
void rapidxml::xml_document<char>::insert_coded_character<0>(char*&, unsigned long) | static void insert_coded_character(Ch *&text, unsigned long code)
{
if (Flags & parse_no_utf8)
{
// Insert 8-bit ASCII character
// Todo: possibly verify that code is less than 256 and use replacement char otherwise?
text[0] = static_cast<u... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x80, -0x10(%rbp)
jae 0x9e7c
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xa060
cmpq $0x800, -0x1... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
char rapidxml::xml_document<char>::parse_and_append_data<0>(rapidxml::xml_node<char>*, char*&, char*) | Ch parse_and_append_data(xml_node<Ch> *node, Ch *&text, Ch *contents_start)
{
// Backup to contents start if whitespace trimming is disabled
if (!(Flags & parse_trim_whitespace))
text = contents_start;
// Skip until end of data
Ch... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
bool rapidxml::internal::compare<char>(char const*, unsigned long, char const*, unsigned long, bool) | inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive)
{
if (size1 != size2)
return false;
if (case_sensitive)
{
for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
if (... | pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xa71f
movb $0x0, -0x1(%rbp)
jmp 0xa7de
testb $0x1, -0x29(%rbp)
je 0xa774
movq -0x10(%rbp), %rax
add... | Matlock42[P]Jeopardy/./RapidXml/rapidxml.hpp |
Question::Question(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Question::Question(std::string aCat, int aPrice, std::string aQuestion)
{
this->mCategory = aCat;
this->mPrice = aPrice;
this->mQuestion = aQuestion;
this->mPlayed = false;
for(int i = 0; i < 4; i++)
mAns[i] = "";
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3390
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3390
movq ... | Matlock42[P]Jeopardy/jQuestion.cpp |
Question::addAnswer(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | bool Question::addAnswer(int aPos, std::string aAns)
{
if(aPos > 3 || aPos < 0)
return false;
if(this->mAns[aPos] != "")
return false;
this->mAns[aPos] = aAns;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, -0x14(%rbp)
jg 0xb18b
cmpl $0x0, -0x14(%rbp)
jge 0xb191
movb $0x0, -0x1(%rbp)
jmp 0xb1dc
movq -0x28(%rbp), %rdi
addq $0x48, %rd... | Matlock42[P]Jeopardy/jQuestion.cpp |
Question::showAnswers() | int Question::showAnswers()
{
int i;
// There are 4 possible answers loop through them
for (i = 1; i <= 4; i++)
{
cout << (i) << ". " << this->mAns[(i-1)] << "\n";
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jg 0xb338
movl -0xc(%rbp), %esi
movq 0x6cdd(%rip), %rdi # 0x11fc8
callq 0x3480
movq %rax, %rdi
leaq 0x1e46(%rip), %rsi # 0xd140
callq 0x3280
movq -0x18(%rb... | Matlock42[P]Jeopardy/jQuestion.cpp |
main | int main(int arg, char * args[]){
getcwd(root_path,1000);
string cmd, ClientLog = "clientlog.txt";
MYIP = args[1];
MYPORT = args[2];
TRACKER1IP = args[3];
TRACKER1PORT = args[4];
DOWNLOADLOG = args[5];
PORT = stoi(MYPORT);
ReadLogFile(ClientLog);
UpdateToTracker();
while(1){
cout<<"Enter Command: ";
... | pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp # imm = 0x3F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1c7e0(%rip), %rdi # 0x21530
movl $0x3e8, %esi # imm = 0x3E8
callq 0x4240
leaq -0x30(%rbp), %rdi
callq 0x45a0
leaq -0x51(%rbp), %rdi
movq %rdi, -0x370(%rbp)
callq... | girdhari9[P]mTORRENT/ClientServer.cpp |
ReadLogFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void ReadLogFile(string ClientLog){
ifstream TrackerFile(ClientLog.c_str(), ifstream::binary);
if (TrackerFile.is_open()){
string detail;
while(getline (TrackerFile,detail)){
stringstream Log(detail); // Used for breaking words
string mtorrentfilename,SHA,FilePath; // to store individu... | pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x8(%rbp)
callq 0x41f0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x438(%rbp)
movl $0x4, %edx
callq 0x4740
movq -0x438(%rbp), %rdi
callq 0x4650
movb %al, -0x429(%rbp)
jmp 0x5b93
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0x5ba2
j... | girdhari9[P]mTORRENT/ClientServer.cpp |
UpdateToTracker() | void UpdateToTracker(){
for(unsigned int i = 0; i < LogVector.size(); i += 3){
string mtorrentfilename, SHA, root_path;
mtorrentfilename = LogVector.front(); LogVector.pop_back();
SHA = LogVector.front(); LogVector.pop_back();
root_path = LogVector.front(); LogVector.pop_back();
thread client (FunctionCallin... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x98(%rbp)
leaq 0x1bb3d(%rip), %rdi # 0x21930
callq 0x72a0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f6f
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x45a0
leaq -0x48(%rbp), %rdi
callq 0x4... | girdhari9[P]mTORRENT/ClientServer.cpp |
UpdateDownloadLog(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void UpdateDownloadLog(int flag,string filename){
ifstream TrackerFile(DOWNLOADLOG.c_str(), ifstream::binary);
string detail;
if (TrackerFile.is_open()){
while(getline (TrackerFile,detail)){
Download.push_back(detail);
}
if(flag){
string detail ="[S] " + MYIP + ":" + MYPORT + " " + root_path ... | pushq %rbp
movq %rsp, %rbp
subq $0x680, %rsp # imm = 0x680
movq %rsi, -0x660(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1b518(%rip), %rdi # 0x214c8
callq 0x41f0
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x658(%rbp)
movl $0x4, %edx
callq 0x4740
leaq -0x238(%rbp), %rdi
callq 0x45a0... | girdhari9[P]mTORRENT/ClientServer.cpp |
UpdateLogFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void UpdateLogFile(string ClientLog){
ifstream TrackerFile(ClientLog, ifstream::binary);
string detail;
if (TrackerFile.is_open()){
while( getline(TrackerFile,detail) ){
stringstream Log(detail); // Used for breaking words
string mtorrentfilename,SHA,FilePath; // to store individual words ... | pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp # imm = 0x670
movq %rdi, %rsi
movq %rsi, -0x648(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x640(%rbp)
movl $0x4, %edx
callq 0x4660
leaq -0x230(%rbp), %rdi
callq 0x45a0
movq -0x640(%rbp), %rdi
callq 0x4650
movb %al, -0x631(%rbp)
jmp 0x66d1
mov... | girdhari9[P]mTORRENT/ClientServer.cpp |
ShowDownloadDetail() | void ShowDownloadDetail(){
ifstream TrackerFile(DOWNLOADLOG.c_str(), ifstream::binary);
if (TrackerFile.is_open()){
string detail;
while(getline (TrackerFile,detail)){
cout<<detail<<"\n";
}
TrackerFile.close();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
leaq 0x1a946(%rip), %rdi # 0x214c8
callq 0x41f0
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
movq %rdi, -0x248(%rbp)
movl $0x4, %edx
callq 0x4740
movq -0x248(%rbp), %rdi
callq 0x4650
movb %al, -0x239(%rbp)
jmp 0x6bb6
movb -0x239(%rbp), %al
testb $0x1,... | girdhari9[P]mTORRENT/ClientServer.cpp |
FunctionCalling(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | int FunctionCalling(string filename, int RequestType,string SHA_TO_Add, string root_path){
sem_init(&mutex1, 0, 1);
int FileSize;
string FileName, SHA;
if(filename.size() > 9 && filename.substr(filename.size()-9) != ".mtorrent"){
cout<<"\n> Please give name of mtorrent file!\n";
return 0... | pushq %rbp
movq %rsp, %rbp
subq $0x770, %rsp # imm = 0x770
movq %rdi, -0x5d8(%rbp)
movq %rdx, -0x5e8(%rbp)
movq %rcx, -0x5e0(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x16c4a(%rip), %rdi # 0x219b0
xorl %esi, %esi
movl $0x1, %edx
callq 0x4390
le... | girdhari9[P]mTORRENT/ClientConnection.cpp |
ReadFileByLine(int, int) | void ReadFileByLine(int TrackerFileD,int flag){
char sendBuffer[BUFFER_SIZE];
int index = 0;
mTorrentFileData.clear();
memset(&sendBuffer, '\0',BUFFER_SIZE);
while (read(TrackerFileD, &sendBuffer[index], 1) == 1) {
if (sendBuffer[index] == '\n' || sendBuffer[index] == 0x0) {
if(... | pushq %rbp
movq %rsp, %rbp
subq $0x8a0, %rsp # imm = 0x8A0
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x7e4(%rbp)
leaq 0x15956(%rip), %rdi # 0x21998
callq 0xdf40
leaq -0x7e0(%rbp), %rdi
xorl %esi, %esi
movl $0x7d0, %edx # imm = 0x7D0
callq 0x4260
movl -0x4(%rbp), %edi
movslq -0x7e... | girdhari9[P]mTORRENT/ClientConnection.cpp |
TrackerConnection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int) | int TrackerConnection(string IPaddress,int PORT){
int sock = 0;
struct sockaddr_in serv_addr;
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_I... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4130
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0xc35d
leaq 0xa09d(%rip), %rdi # 0x163e7
movb $0x0, %al
callq 0x4070
movl $... | girdhari9[P]mTORRENT/ClientConnection.cpp |
SendToSeederList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int) | void SendToSeederList(string filename, string SHA, int sock, string root_path,int RequestType){
char sendBuffer[BUFFER_SIZE];
memset(&sendBuffer, '\0',BUFFER_SIZE);
cout<<"[+]system started...\n";
cout<<"[+]system connecting...\n";
string IP = MYIP, FilePath;
int IPsize = IP.size(), RootPathS... | pushq %rbp
movq %rsp, %rbp
subq $0x890, %rsp # imm = 0x890
movq %rsi, -0x878(%rbp)
movq %rcx, -0x860(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0x800(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x858(%rbp)
movl $0x7d0, %edx ... | girdhari9[P]mTORRENT/ClientConnection.cpp |
ReadSHA[abi:cxx11](int) | string ReadSHA(int TorrentFileD){
char sendBuffer[BUFFER_SIZE];
int read_size = read(TorrentFileD, sendBuffer, SHA_DIGEST_LENGTH);
if(read_size == SHA_DIGEST_LENGTH){
return sendBuffer;
}
return "-1";
} | pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp # imm = 0x820
movq %rdi, -0x808(%rbp)
movq %rdi, %rax
movq %rax, -0x800(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0x7e0(%rbp), %rsi
movl $0x14, %edx
callq 0x45c0
movl %eax, -0x7e4(%rbp)
cmpl $0x14, -0x7e4(%rbp)
jne 0xc6a3
leaq -... | girdhari9[P]mTORRENT/ClientConnection.cpp |
GetSeedersDetails(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void GetSeedersDetails(int sock,string SHA){
char recvBuffer[BUFFER_SIZE];
memset(&recvBuffer, '\0',BUFFER_SIZE);
cout<<"[+]system connected...\n";
printf("> recieving seeders details...\n");
int DataLength, RequestType = 0;
send(sock , &RequestType , sizeof(int) , 0 );
send(sock, SHA.c_... | pushq %rbp
movq %rsp, %rbp
subq $0xa50, %rsp # imm = 0xA50
movq %rsi, -0xa30(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x7e0(%rbp), %rdi
movq %rdi, -0xa18(%rbp)
xorl %esi, %esi
movl %esi, -0xa24(%rbp)
movl $0x7d0, %edx # imm = 0x7D0
callq 0x4260
movq 0x14868(%rip), %rdi # 0x20fc... | girdhari9[P]mTORRENT/ClientConnection.cpp |
BitVectorRequestToServers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void BitVectorRequestToServers(string IPaddress, int PORT, int thread_n,int TotalPacket, string SHA){
int sock = Connection(IPaddress,PORT);
int BitMapRequest = 1;
send(sock , &BitMapRequest , sizeof(int) , 0 );
send(sock , &TotalPacket , sizeof(int) , 0 );
send(sock, SHA.c_str(), sizeof(SHA), 0);
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movl %esi, %eax
movq %rdi, %rsi
movq %r8, -0xc0(%rbp)
movq %rsi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4200
movq -0xb8(%rbp), %rdi
mo... | girdhari9[P]mTORRENT/ClientConnection.cpp |
PieceSelection(int, int, int*) | void PieceSelection(int TotalPacket,int TotalConn, int BitMap[]){
int MinPackFromOneServer = (TotalPacket/TotalConn)+1;
int PackIndex[TotalConn], TotalPackAssign = 0;
memset(&PackIndex, 0, sizeof(PackIndex));
for(auto it = TotalAvlPack.begin(); it != TotalAvlPack.end(); it++){
string PackS = Pa... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
cltd
idivl %ecx
incl %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %edx
movq %rsp, %rax
movq %rax, -0x20(%rbp)
leaq 0xf(,%rdx,4), %rax
andq $-0x10, %r... | girdhari9[P]mTORRENT/ClientConnection.cpp |
clientConnection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int, int, std::vector<int, std::allocator<int>>, int, std::basic_ofstream<char, std::char_traits<char>>&, std::__cxx11::basic_string... | int clientConnection(string IPaddress,int PORT,string &recvFileName, int FileSize, int LastPartSize, int TotalPacket, vector<int> BitMap1, int thread_n, ofstream &output, string SHA){
int sock = 0;
struct sockaddr_in serv_addr;
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n So... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xd0(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
m... | girdhari9[P]mTORRENT/ClientConnection.cpp |
RecieveDataFromServer(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, std::vector<int, std::allocator<int>>, int, std::basic_ofstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void RecieveDataFromServer(int sock,string recvFileName, int FileSize, int LastPartSize, int TotalPacket, vector<int> BitMap1, int thread_n, ofstream &output, string SHA){
char sendBuffer[BUFFER_SIZE];
char recvBuffer[BUFFER_SIZE];
memset(&recvBuffer, '\0',BUFFER_SIZE);
memset(&sendBuffer, '\0',BUFFER_... | pushq %rbp
movq %rsp, %rbp
subq $0x1050, %rsp # imm = 0x1050
movq %r9, -0x1030(%rbp)
movq %rsi, -0x1020(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x1028(%rbp)
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%... | girdhari9[P]mTORRENT/ClientConnection.cpp |
Connection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int) | int Connection(string IPaddress,int PORT){
int sock = 0;
struct sockaddr_in serv_addr;
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
printf("\n Socket creation error \n");
return -1;
}
memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4130
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0xd96d
leaq 0x8a8d(%rip), %rdi # 0x163e7
movb $0x0, %al
callq 0x4070
movl $... | girdhari9[P]mTORRENT/ClientConnection.cpp |
ServerConnection() | void ServerConnection(){
int server_fd;
struct sockaddr_in address;
int opt = 1;
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0){
perror("socket failed");
exit(EXIT_FAILURE);
}
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,&opt, sizeof(o... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x1, -0x18(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x4130
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jne 0x13bde
leaq 0x2acd(%rip), %rdi # 0x1669c
callq 0x4370
movl $0x1, %edi
callq 0x44e0
movl -0x4(%rbp), %edi
movl $0x1, %esi
movl $0xf, %edx
leaq -0... | girdhari9[P]mTORRENT/ServerConnection.cpp |
Communication(int, sockaddr_in) | void Communication(int server_fd,struct sockaddr_in address){
int new_socket,addrlen = sizeof(address), RequestType;
printf("[+]server started...\n");
while(1){
printf("[+]Listening...\n");
if ((new_socket = accept(server_fd, (struct sockaddr *)&address,(socklen_t*)&addrlen))<0){
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movl $0x10, -0x1c(%rbp)
leaq 0x29e7(%rip), %rdi # 0x166c8
movb $0x0, %al
callq 0x4070
leaq 0x29ef(%rip), %rdi # 0x166de
movb $0x0, %al
callq 0x4070
movl -0x14(%rbp), %edi
leaq -0x10(%rbp), %rsi
leaq... | girdhari9[P]mTORRENT/ServerConnection.cpp |
BitVectorDetailSend(int) | void BitVectorDetailSend(int new_socket){
if(fork() == 0){
int ack, TotalPacket;
char SHA[20];
printf("Client is ready...\n");
read(new_socket, &TotalPacket,sizeof(int));
read(new_socket, SHA ,20);
string BitBuffer = TotalFile[(string)SHA];
send(new_socket... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
callq 0x4160
cmpl $0x0, %eax
jne 0x13f29
leaq 0x2983(%rip), %rdi # 0x166f6
xorl %eax, %eax
callq 0x4070
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x45c0
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x90(%rbp)
movl... | girdhari9[P]mTORRENT/ServerConnection.cpp |
SendData(int) | void SendData(int new_socket){
if(fork() == 0){
char recvBuffer[BUFFER_SIZE];
char sendBuffer[BUFFER_SIZE];
memset(&recvBuffer, '\0',BUFFER_SIZE);
memset(&sendBuffer, '\0',BUFFER_SIZE);
int ack;
int fileNameLength,LastPartSize = 0,TotalPacket;
read(new_soc... | pushq %rbp
movq %rsp, %rbp
subq $0x1230, %rsp # imm = 0x1230
movl %edi, -0x4(%rbp)
callq 0x4160
cmpl $0x0, %eax
jne 0x1428e
leaq -0x7e0(%rbp), %rdi
movq %rdi, -0x11f8(%rbp)
xorl %esi, %esi
movl %esi, -0x1204(%rbp)
movl $0x7d0, %edx # imm = 0x7D0
movq %rdx, -0x1220(%rbp)
callq 0x4260
movq -0x1220(%r... | girdhari9[P]mTORRENT/ServerConnection.cpp |
SetBitMap(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void SetBitMap(int TotalPacket, int flag, string SHA){
char *BitBuffer = new char[TotalPacket];
if(flag){
for(int i=0; i<TotalPacket; i++)
BitBuffer[i] = '1';
}
else{
for(int i=0; i<TotalPacket; i++)
BitBuffer[i] = '0';
}
TotalFile[SHA] = (string)BitBuffer... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x60(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x4030
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x14314
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x14312
movq -0x18(%r... | girdhari9[P]mTORRENT/ServerConnection.cpp |
mtorrentFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | string mtorrentFile(string SrcFileName, string TorrentFileName, string Tracker1IP, string Tracker1Port){
struct stat fileStat;
int err = stat(SrcFileName.c_str(), &fileStat);
if (0 != err){
string error = "Error occured in file";
cout<<"Error occured in file";
return error ;
}... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %r8, -0x1a8(%rbp)
movq %rcx, -0x1a0(%rbp)
movq %rdx, -0x198(%rbp)
movq %rsi, -0x190(%rbp)
movq %rdi, %rax
movq -0x190(%rbp), %rdi
movq %rax, -0x188(%rbp)
movq %rax, %rsi
movq %rsi, -0x180(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %... | girdhari9[P]mTORRENT/CreateTorrentFile.cpp |
CalculateSHA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int) | string CalculateSHA(string SrcFileName,int mtorrentPtr){
unsigned char src_buffer[FILE_SIZE];
unsigned char hashChunk[SHA_DIGEST_LENGTH];
unsigned char fullhash[SHA_DIGEST_LENGTH];
SHA_CTX sc;
int srcFilePtr = open(SrcFileName.c_str(), O_RDONLY);
SHA1_Init(&sc);
SHA1_Update(&sc, SrcFileNa... | pushq %rbp
movq %rsp, %rbp
subq $0x80190, %rsp # imm = 0x80190
movq %rsi, -0x80160(%rbp)
movq %rdi, %rax
movq -0x80160(%rbp), %rdi
movq %rax, -0x80170(%rbp)
movq %rax, %rcx
movq %rcx, -0x80168(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x41f0
movq %rax, %rdi
xorl %esi, %esi... | girdhari9[P]mTORRENT/CreateTorrentFile.cpp |
connect(Destination*) | Connection connect(Destination* pDest)
{
shared_ptr<Connection> pConn(new Connection(pDest->ip, pDest->port));
// ...
cout << "Creat connection(" << pConn.use_count() << ")" << endl;
return *pConn;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x20d0
movq %rax, -0x58(%rbp)
movb $0x1, -0x4d(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2060
jmp 0x230f
movq -0x58(%rbp), %rdi
... | iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_15.cc |
SHA256AutoDetect[abi:cxx11]() | std::string SHA256AutoDetect()
{
std::string ret = "standard";
#if defined(USE_ASM) && defined(HAVE_GETCPUID)
bool have_sse4 = false;
bool have_xsave = false;
bool have_avx = false;
bool have_avx2 = false;
bool have_shani = false;
bool enabled_avx = false;
(void)AVXEnabled;
(void)ha... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1100
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x50c56(%rip), %rsi # 0x5201d
callq 0x10d0
jmp 0x13ce
lea... | theuni[P]libutreexo/crypto/sha256.cpp |
void (anonymous namespace)::TransformD64Wrapper<&sha256_shani::Transform(unsigned int*, unsigned char const*, unsigned long)>(unsigned char*, unsigned char const*) | void TransformD64Wrapper(unsigned char* out, const unsigned char* in)
{
uint32_t s[8];
static const unsigned char padding1[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1060
movb $-0x80, -0x50(%rbp)
movb $0x1, -0x32(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bb0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x286d0
le... | theuni[P]libutreexo/crypto/sha256.cpp |
(anonymous namespace)::SelfTest() | bool SelfTest() {
// Input state (equal to the initial SHA256 state)
static const uint32_t init[8] = {
0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul, 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul
};
// Some random input data to test with
static const unsigned char data[641]... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq $0x0, -0x10(%rbp)
cmpq $0x8, -0x10(%rbp)
ja 0x1a2d
leaq -0x30(%rbp), %rdx
leaq 0x5071b(%rip), %rdi # 0x520e0
movq %rdi, %rsi
addq $0x20, %rsi
callq 0xa790
movq 0x536c8(%rip), %rax # 0x550a0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
l... | theuni[P]libutreexo/crypto/sha256.cpp |
(anonymous namespace)::sha256::Initialize(unsigned int*) | void inline Initialize(uint32_t* s)
{
s[0] = 0x6a09e667ul;
s[1] = 0xbb67ae85ul;
s[2] = 0x3c6ef372ul;
s[3] = 0xa54ff53aul;
s[4] = 0x510e527ful;
s[5] = 0x9b05688cul;
s[6] = 0x1f83d9abul;
s[7] = 0x5be0cd19ul;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6a09e667, (%rax) # imm = 0x6A09E667
movq -0x8(%rbp), %rax
movl $0xbb67ae85, 0x4(%rax) # imm = 0xBB67AE85
movq -0x8(%rbp), %rax
movl $0x3c6ef372, 0x8(%rax) # imm = 0x3C6EF372
movq -0x8(%rbp), %rax
movl $0xa54ff53a, 0xc(%rax) # imm = 0x... | theuni[P]libutreexo/crypto/sha256.cpp |
CSHA256::Write(unsigned char const*, unsigned long) | CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
{
const unsigned char* end = data + len;
size_t bufsize = bytes % 64;
if (bufsize && bufsize + len >= 64) {
// Fill the buffer, and process it.
memcpy(buf + bufsize, data, 64 - bufsize);
bytes += 64 - bufsize;
dat... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x60(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1cca... | theuni[P]libutreexo/crypto/sha256.cpp |
CSHA256::Finalize(unsigned char*) | void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
{
static const unsigned char pad[64] = {0x80};
unsigned char sizedesc[8];
WriteBE64(sizedesc, bytes << 3);
Write(pad, 1 + ((119 - (bytes % 64)) % 64));
Write(sizedesc, 8);
WriteBE32(hash, s[0]);
WriteBE32(hash + 4, s[1]);
WriteBE32(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
movq 0x60(%rax), %rsi
shlq $0x3, %rsi
callq 0x1e90
movq -0x20(%rbp), %rdi
movq 0x60(%rdi), %rax
andq $0x3f, %rax
movl $0x77, %edx
subq %rax, %rdx
andq $0x3f, %rdx
... | theuni[P]libutreexo/crypto/sha256.cpp |
SHA256D64(unsigned char*, unsigned char const*, unsigned long) | void SHA256D64(unsigned char* out, const unsigned char* in, size_t blocks)
{
if (TransformD64_8way) {
while (blocks >= 8) {
TransformD64_8way(out, in);
out += 256;
in += 512;
blocks -= 8;
}
}
if (TransformD64_4way) {
while (blocks >= 4)... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x5318c(%rip) # 0x550c8
je 0x1f84
jmp 0x1f40
cmpq $0x8, -0x18(%rbp)
jb 0x1f82
movq 0x5317a(%rip), %rax # 0x550c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x8(%rbp), %r... | theuni[P]libutreexo/crypto/sha256.cpp |
(anonymous namespace)::sha256::Transform(unsigned int*, unsigned char const*, unsigned long) | void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
{
while (blocks--) {
uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
Round(a, b, c, d, e, f, g, h, 0... | pushq %rbp
movq %rsp, %rbp
subq $0x760, %rsp # imm = 0x760
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4920
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp... | theuni[P]libutreexo/crypto/sha256.cpp |
(anonymous namespace)::sha256::Round(unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int, unsigned int, unsigned int, unsigned int&, unsigned int) | void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uint32_t e, uint32_t f, uint32_t g, uint32_t& h, uint32_t k)
{
uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
uint32_t t2 = Sigma0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq 0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%... | theuni[P]libutreexo/crypto/sha256.cpp |
(anonymous namespace)::sha256::TransformD64(unsigned char*, unsigned char const*) | void TransformD64(unsigned char* out, const unsigned char* in)
{
// Transform 1
uint32_t a = 0x6a09e667ul;
uint32_t b = 0xbb67ae85ul;
uint32_t c = 0x3c6ef372ul;
uint32_t d = 0xa54ff53aul;
uint32_t e = 0x510e527ful;
uint32_t f = 0x9b05688cul;
uint32_t g = 0x1f83d9abul;
uint32_t h = 0x... | pushq %rbp
movq %rsp, %rbp
subq $0xca0, %rsp # imm = 0xCA0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x6a09e667, -0x14(%rbp) # imm = 0x6A09E667
movl $0xbb67ae85, -0x18(%rbp) # imm = 0xBB67AE85
movl $0x3c6ef372, -0x1c(%rbp) # imm = 0x3C6EF372
movl $0xa54ff53a, -0x20(%rbp) # imm = 0xA54FF53A
movl $0x5... | theuni[P]libutreexo/crypto/sha256.cpp |
sha256d64_avx2::Transform_8way(unsigned char*, unsigned char const*) | void Transform_8way(unsigned char* out, const unsigned char* in)
{
// Transform 1
__m256i a = K(0x6a09e667ul);
__m256i b = K(0xbb67ae85ul);
__m256i c = K(0x3c6ef372ul);
__m256i d = K(0xa54ff53aul);
__m256i e = K(0x510e527ful);
__m256i f = K(0x9b05688cul);
__m256i g = K(0x1f83d9abul);
... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x20b60, %rsp # imm = 0x20B60
movq %rdi, 0x10338(%rsp)
movq %rsi, 0x10330(%rsp)
movl $0x6a09e667, %edi # imm = 0x6A09E667
callq 0x27840
vmovdqa %ymm0, 0x10300(%rsp)
movl $0xbb67ae85, %edi # imm = 0xBB67AE85
callq 0x27840
vmovdqa %ymm0, 0x102e0(%rsp... | theuni[P]libutreexo/crypto/sha256_avx2.cpp |
sha256d64_avx2::(anonymous namespace)::Read8(unsigned char const*, int) | __m256i inline Read8(const unsigned char* chunk, int offset) {
__m256i ret = _mm256_set_epi32(
ReadLE32(chunk + 0 + offset),
ReadLE32(chunk + 64 + offset),
ReadLE32(chunk + 128 + offset),
ReadLE32(chunk + 192 + offset),
ReadLE32(chunk + 256 + offset),
ReadLE32(chunk +... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x140, %rsp # imm = 0x140
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x54(%rsp), %rax
addq %rax, %rdi
callq 0x28660
movl %eax, 0x4(%rsp)
movq 0x58(%rsp), %rax
movslq 0x54(%rsp), %rcx
leaq 0x40(%rax,%rcx), %rdi
callq 0x28660
movl... | theuni[P]libutreexo/crypto/sha256_avx2.cpp |
sha256d64_avx2::(anonymous namespace)::Write8(unsigned char*, int, long long vector[4]) | void inline Write8(unsigned char* out, int offset, __m256i v) {
v = _mm256_shuffle_epi8(v, _mm256_set_epi32(0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL, 0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL));
WriteLE32(out + 0 + offset, _mm256_extract_epi32(v, 7));
WriteLE32(out + 32 + offset, ... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xe0, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
vmovaps %ymm0, (%rsp)
vmovaps (%rsp), %ymm1
movl $0xc0d0e0f, 0x7c(%rsp) # imm = 0xC0D0E0F
movl $0x8090a0b, 0x78(%rsp) # imm = 0x8090A0B
movl $0x4050607, 0x74(%rsp) # imm = 0x4050607
movl $0x10203, 0x70(%rsp) ... | theuni[P]libutreexo/crypto/sha256_avx2.cpp |
sha256_shani::Transform(unsigned int*, unsigned char const*, unsigned long) | void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
{
__m128i m0, m1, m2, m3, s0, s1, so0, so1;
/* Load state */
s0 = _mm_loadu_si128((const __m128i*)s);
s1 = _mm_loadu_si128((const __m128i*)(s + 4));
Shuffle(s0, s1);
while (blocks--) {
/* Remember old state */
... | pushq %rbp
movq %rsp, %rbp
subq $0x18a0, %rsp # imm = 0x18A0
movq %rdi, -0x1878(%rbp)
movq %rsi, -0x1880(%rbp)
movq %rdx, -0x1888(%rbp)
movq -0x1878(%rbp), %rax
movq %rax, -0x1868(%rbp)
movq -0x1868(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x18e0(%rbp)
movq -0x1878(%rbp), %rax
addq $0x10, %rax
movq %ra... | theuni[P]libutreexo/crypto/sha256_shani.cpp |
sha256d64_shani::Transform_2way(unsigned char*, unsigned char const*) | void Transform_2way(unsigned char* out, const unsigned char* in)
{
__m128i am0, am1, am2, am3, as0, as1, aso0, aso1;
__m128i bm0, bm1, bm2, bm3, bs0, bs1, bso0, bso1;
/* Transform 1 */
bs0 = as0 = INIT0;
bs1 = as1 = INIT1;
am0 = Load(in);
bm0 = Load(in + 64);
QuadRound(as0, as1, am0, 0x... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7d48, %rsp # imm = 0x7D48
movq %rdi, -0x75f8(%rbp)
movq %rsi, -0x7600(%rbp)
movaps 0x2a367(%rip), %xmm0 # 0x550e0
movaps %xmm0, -0x7650(%rbp)
movaps %xmm0, -0x76d0(%rbp)
movaps 0x2a362(%rip), %xmm0 # 0x550f0
movaps... | theuni[P]libutreexo/crypto/sha256_shani.cpp |
sha256d64_sse41::Transform_4way(unsigned char*, unsigned char const*) | void Transform_4way(unsigned char* out, const unsigned char* in)
{
// Transform 1
__m128i a = K(0x6a09e667ul);
__m128i b = K(0xbb67ae85ul);
__m128i c = K(0x3c6ef372ul);
__m128i d = K(0xa54ff53aul);
__m128i e = K(0x510e527ful);
__m128i f = K(0x9b05688cul);
__m128i g = K(0x1f83d9abul);
... | pushq %rbp
movq %rsp, %rbp
subq $0x105a0, %rsp # imm = 0x105A0
movq %rdi, -0x8408(%rbp)
movq %rsi, -0x8410(%rbp)
movl $0x6a09e667, %edi # imm = 0x6A09E667
callq 0x50810
movdqa %xmm0, -0x8420(%rbp)
movl $0xbb67ae85, %edi # imm = 0xBB67AE85
callq 0x50810
movdqa %xmm0, -0x8430(%rbp)
movl $0x3c6ef372, ... | theuni[P]libutreexo/crypto/sha256_sse41.cpp |
sha256d64_sse41::(anonymous namespace)::Read4(unsigned char const*, int) | __m128i inline Read4(const unsigned char* chunk, int offset) {
__m128i ret = _mm_set_epi32(
ReadLE32(chunk + 0 + offset),
ReadLE32(chunk + 64 + offset),
ReadLE32(chunk + 128 + offset),
ReadLE32(chunk + 192 + offset)
);
return _mm_shuffle_epi8(ret, _mm_set_epi32(0x0C0D0E0FUL, ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movl %esi, -0x6c(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x6c(%rbp), %rax
addq %rax, %rdi
callq 0x51120
movl %eax, -0x8c(%rbp)
movq -0x68(%rbp), %rax
movslq -0x6c(%rbp), %rcx
leaq 0x40(%rax,%rcx), %rdi
callq 0x51120
movl %eax, -0x88(%rbp)
movq -0x68(%rbp),... | theuni[P]libutreexo/crypto/sha256_sse41.cpp |
sha256d64_sse41::(anonymous namespace)::Write4(unsigned char*, int, long long vector[2]) | void inline Write4(unsigned char* out, int offset, __m128i v) {
v = _mm_shuffle_epi8(v, _mm_set_epi32(0x0C0D0E0FUL, 0x08090A0BUL, 0x04050607UL, 0x00010203UL));
WriteLE32(out + 0 + offset, _mm_extract_epi32(v, 3));
WriteLE32(out + 32 + offset, _mm_extract_epi32(v, 2));
WriteLE32(out + 64 + offset, _mm_ex... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movl %esi, -0x4c(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps -0x60(%rbp), %xmm1
movl $0xc0d0e0f, -0x24(%rbp) # imm = 0xC0D0E0F
movl $0x8090a0b, -0x28(%rbp) # imm = 0x8090A0B
movl $0x4050607, -0x2c(%rbp) # imm = 0x4050607
movl $0x10203, -0x30(%rbp) # imm = ... | theuni[P]libutreexo/crypto/sha256_sse41.cpp |
getLookFor(char*) | void getLookFor(char file[]){
if(file != NULL)
lookforfile = file;
cout << lookforfile << endl;
string line;
ifstream is(lookforfile.c_str());
while(getline(is, line)){
Tag item;
item.name = line;
item.cname = line.insert( 1, "/");
item.count = 0;
t... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2506
movq -0x8(%rbp), %rsi
leaq 0x4c97(%rip), %rdi # 0x7198
callq 0x2210
movq 0x4acb(%rip), %rdi # 0x6fd8
leaq 0x4c84(%rip), %rsi # 0x7198
movq %rsi, -0x290(%rbp)
callq 0x2160
movq %rax,... | PRDeving[P]CheckMyTags/src/checkmytags.cpp |
countSubstring(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | int countSubstring(const string* str, const string sub){
if (sub.length() == 0) return 0;
int count = 0;
for (size_t offset = str->find(sub); offset != std::string::npos;
offset = str->find(sub, offset + sub.length())){
++count;
}
return count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x2240
cmpq $0x0, %rax
jne 0x26f3
movl $0x0, -0x4(%rbp)
jmp 0x2758
movq -0x30(%rbp), %rsi
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xor... | PRDeving[P]CheckMyTags/src/checkmytags.cpp |
checkIf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | void checkIf(string* line){
for(unsigned int x = 0; x < tags.size(); x++){
if(line->find(tags[x].name) != string::npos){
tags[x].count += countSubstring(line, tags[x].name);
}
if(line->find(tags[x].cname) != string::npos){
tags[x].count -= countSubstring(line, tags[x]... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x58(%rbp)
leaq 0x4a24(%rip), %rdi # 0x71b8
callq 0x2f70
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x28d7
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %eax
mov... | PRDeving[P]CheckMyTags/src/checkmytags.cpp |
main | int main(int argc, char* argv[]){
getLookFor(argv[2]);
int count = 0;
string line;
if(argc < 2){
cout << "No file." << endl;
return 0;
}
ifstream is(argv[1]);
while(getline(is, line)){
checkIf(&line);
count++;
}
cout << endl << endl << count <<... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x24e0
movl $0x0, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2220
cmpl $0x2, -0x8(%rbp)
jge 0x2971
movq 0x46b5(%rip), %rdi # 0x... | PRDeving[P]CheckMyTags/src/checkmytags.cpp |
main | int main()
{
try
{
Window appWindow("SK's Mandelbrot Set Viewer", SDL_WINDOW_SHOWN);
appWindow.startEventLoop();
}
catch(std::string errMsg)
{
std::cerr << errMsg << std::endl;
exit(-1);
}
catch(...)
{
std::cerr << "An unknown error occured!" << std::endl;
exit(-1);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22e0
movq -0x80(%rbp), %rdx
leaq 0x1adf(%rip), %rsi # 0x4039
leaq -0x40(%rbp), %rdi
callq 0x26e0
jmp 0x2565
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x4, %edx
callq 0x2e80
jmp 0x2579
l... | bsaikiran618[P]mandelbrot-set-viewer/main.cpp |
Window::drawAxes(Cartesian2DPlane*) | void Window::drawAxes( Cartesian2DPlane *plane )
{
Cartesian2DPoint leftExtreme (double(0), -1000, plane);
Cartesian2DPoint rightExtreme (double(0), 1000, plane);
Cartesian2DPoint topExtreme (double(1000), 0, plane);
Cartesian2DPoint bottomExtreme (double(-1000),0, plane);
SDL_SetRenderDrawColor(screenRenderer... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x1637(%rip), %xmm1 # 0x4098
callq 0x31c0
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
xorps %xmm0, %xmm0
movs... | bsaikiran618[P]mandelbrot-set-viewer/Window.cpp |
Window::drawScreen(Cartesian2DPlane*) | void Window::drawScreen(Cartesian2DPlane *plane)
{
clock_t start, end;
start = clock();
SDL_SetRenderDrawColor(screenRenderer, 0,0,0,SDL_ALPHA_OPAQUE);
SDL_RenderClear(screenRenderer);
for(uint64_t scr_x = 0; scr_x < plane->getWidth(); scr_x++)
{
for(uint64_t scr_y = 0; scr_y < plane->getHeight... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x2130
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rdi
xorl %ecx, %ecx
movl $0xff, %r8d
movl %ecx, %esi
movl %ecx, %edx
callq 0x2280
movq -0x98(... | bsaikiran618[P]mandelbrot-set-viewer/Window.cpp |
Window::Window(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long) | Window::Window(std::string windowTitle, uint64_t flags)
{
if(SDL_Init(SDL_INIT_VIDEO) < 0) throw "Couldn't initialize SDL Video!";
if((window = SDL_CreateWindow(windowTitle.c_str(), WINDOW_X, WINDOW_Y, SCREEN_W, SCREEN_H, flags)) == NULL)
throw "Couldn't create SDL window!";
//windowSurface = SDL_GetWindowS... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x21a0
cmpl $0x0, %eax
jge 0x2ed6
movl $0x8, %edi
callq 0x20f0
movq %rax, %rdi
leaq 0x1203(%rip), %rax # 0x40c6
... | bsaikiran618[P]mandelbrot-set-viewer/Window.cpp |
Window::startEventLoop() | void Window::startEventLoop()
{
SDL_Event e;
bool appQuit = false;
bool changed = false;
srand(42);
Cartesian2DPlane plane(SCREEN_W, SCREEN_H, 150);
drawScreen(&plane);
while(!appQuit)
{
changed = false;
while(SDL_PollEvent(&e))
{
if(e.type == SDL_QUIT)
{
appQuit = true;
br... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x41(%rbp)
movb $0x0, -0x42(%rbp)
movl $0x2a, %edi
callq 0x21d0
leaq -0x78(%rbp), %rdi
movl $0x384, %edx # imm = 0x384
movsd 0x10e6(%rip), %xmm0 # 0x40b0
movq %rdx, %rsi
callq 0x34d0... | bsaikiran618[P]mandelbrot-set-viewer/Window.cpp |
Cartesian2DPlane::Cartesian2DPlane(unsigned long, unsigned long, double) | Cartesian2DPlane::Cartesian2DPlane(uint64_t w, uint64_t h, double zoom)
{
width = w;
height = h;
originX = width/2;
originY = height/2;
XScaleFactor = zoom;
YScaleFactor = (height/double(width)) * XScaleFactor;
// The above calculation makes sure that X and Y are
// "stretched" to equal lengths, so that even if... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rcx
shrq %rcx
movq %rcx, 0... | bsaikiran618[P]mandelbrot-set-viewer/Cartesian2D.cpp |
inMandelbrotSet(std::complex<double>, unsigned long) | int inMandelbrotSet(std::complex<double> point, uint64_t max_iters)
{
std::complex<double> initial = point;
int count = 0;
for(uint64_t i=0;i<max_iters;i++)
{
if(std::abs(point) > 2) return count;
point = std::pow(point, 2) + initial;
count++;
}
return -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3824
leaq -0x... | bsaikiran618[P]mandelbrot-set-viewer/Mandelbrot.cpp |
main | int main() {
// create the work item queue and consumer threads
WorkQueue<MyWorkItem*> queue; // queue of work items to be processed by threads
std::vector<ConsumerThread<MyWorkItem, MyThreadItem>* > threadqueue;
// add 1000 work jobs to the WorkQueue
for (int i = 0; i < 5000; ++i) {
// esta... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movl $0x0, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2730
leaq -0x90(%rbp), %rdi
callq 0x2780
movl $0x0, -0x94(%rbp)
cmpl $0x1388, -0x94(%rbp) # imm = 0x1388
jge 0x247b
movq $0x1388, -0xa0(%rbp) # imm = 0x1388
movl $0x1389, %edi # imm = ... | walaj[P]pthread-lite/example.cpp |
WorkQueue<MyWorkItem*>::add(MyWorkItem*) | void add(T item) {
pthread_mutex_lock(&m_mutex);
m_queue.push_back(item);
pthread_cond_signal(&m_condv);
pthread_mutex_unlock(&m_mutex);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3080
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
call... | walaj[P]pthread-lite/./pthread-lite.h |
WorkThread::start() | int start()
{
int result = pthread_create(&m_tid, NULL, runThread, this);
if (result == 0) {
m_running = 1;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rcx, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x28a(%rip), %rdx # 0x2b50
callq 0x21d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x28df
movq -0x18(%rbp), %rax
movl $0x1, 0x10(... | walaj[P]pthread-lite/./pthread-lite.h |
WorkThread::join() | int join()
{
int result = -1;
if (m_running == 1) {
result = pthread_join(m_tid, NULL);
if (result == 0) {
m_detached = 1;
}
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpl $0x1, 0x10(%rax)
jne 0x29c8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%... | walaj[P]pthread-lite/./pthread-lite.h |
ConsumerThread<MyWorkItem, MyThreadItem>::run() | void* run() {
// Remove 1 item at a time and process it. Blocks if no items are
// available to process.
for (int i = 0;; i++) {
W* item = (W*)m_queue.remove();
if (!item)
return NULL;
item->run(m_thread_data); // pass thread data to worker unit always
delete item;
if (m_queu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x34b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x344d
movq $0x0, -0x8(%rbp)
jmp 0x34a3
movq -0x28(%rbp), %rax
movq -0x20(%r... | walaj[P]pthread-lite/./pthread-lite.h |
WorkQueue<MyWorkItem*>::remove() | T remove() {
pthread_mutex_lock(&m_mutex);
while (m_queue.size() == 0) {
pthread_cond_wait(&m_condv, &m_mutex);
}
T item = m_queue.front();
m_queue.pop_front();
pthread_mutex_unlock(&m_mutex);
return item;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x35a0
cmpq $0x0, %rax
jne 0x34f2
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x18, %rsi
callq 0x2180
jmp 0x34cd
movq -0x18(%rbp), %... | walaj[P]pthread-lite/./pthread-lite.h |
WorkQueue<MyWorkItem*>::size() | int size() {
pthread_mutex_lock(&m_mutex);
int size = m_queue.size();
pthread_mutex_unlock(&m_mutex);
return size;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x18, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x35a0
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x18, %rdi
callq 0x20a0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| walaj[P]pthread-lite/./pthread-lite.h |
MyWorkItem::runStringProcessing(MyThreadItem*) | bool runStringProcessing(MyThreadItem* thread_data) {
// do something with the data ... (silly example here)
size_t results = 0;
if (m_data)
for (size_t n = 0; n < 1000; ++n)
for (size_t i = 0; i < m_len; ++i)
if (m_data[i] == 'a')
++results;
thread_data->AddHits(results); //... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x3800
movq $0x0, -0x20(%rbp)
cmpq $0x3e8, -0x20(%rbp) # imm = 0x3E8
jae 0x37fe
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%... | walaj[P]pthread-lite/example.cpp |
main | int main ()
{
Quote base("0-201-82470-1", 50);
Bulk_quote bulk("0-201-54848-8", 50, 10, .25);
// ok: but probably not what is wanted---
// the objects in basket have no derived members
vector<Quote> basket;
basket.push_back(Quote("0-201-82470-1", 50));
// ok, but copies only the Quote part of the object... | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movl $0x0, -0x4(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x2190
movq -0x218(%rbp), %rdx
leaq 0x4ca0(%rip), %rsi # 0x7040
leaq -0x58(%rbp), %rdi
callq 0x2130
jmp 0x23ab
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movsd 0x4c4d(... | iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/vecBasket.cc |
Basket::display(std::ostream&) const | void Basket::display(ostream &os) const
{
os << "Basket size: " << items.size() << endl;
// print each distinct ISBN in the Basket along with
// count of how many copies are ordered and what their price will be
// upper_bound returns an iterator to the next item in the set
for (auto next_item = ite... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1278(%rip), %rsi # 0x71ae
callq 0x20d0
movq -0x60(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x6250
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x2030
m... | iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Basket.cc |
Basket::total_receipt(std::ostream&) const | double Basket::total_receipt(ostream &os) const
{
double sum = 0.0; // holds the running total
// iter refers to the first element in a batch of elements with the same ISBN
// upper_bound returns an iterator to the element just past the end of that batch
for (auto iter = items.cbegin();
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x6270
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
callq 0x62d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
c... | iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Basket.cc |
print_total(std::ostream&, Quote const&, unsigned long) | double print_total(ostream &os,
const Quote &item, size_t n)
{
// depending on the type of the object bound to the item parameter
// calls either Quote::net_price or Bulk_quote::net_price
double ret = item.net_price(n);
os << "ISBN: " << item.isbn() // calls Quote::isbn
<< " # sold: "... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7c0(%rip), %rsi # 0x71f8
callq 0x20d0
movq %rax, -... | iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Quote.cc |
Lim_quote::net_price(unsigned long) const | double Lim_quote::net_price(size_t cnt) const
{
size_t discounted = min(cnt, quantity);
size_t undiscounted = cnt - discounted;
return discounted * (1 - discount) * price
+ undiscounted * price;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x30, %rsi
leaq -0x10(%rbp), %rdi
callq 0x3b30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %r... | iZhangHui[P]CppPrimer/CH15_ObjectOrientedProgramming/examples/Quote.cc |
Create_DB_Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void Create_DB_Test(string filename) {
int record_num = 10;
int ht_size = record_num * 2;
Options opts;
opts.segment_size = 256 * 1024;
opts.hashtable_size = ht_size;
KVDS *db = KVDS::Create_KVDS(filename.c_str(), opts);
delete db;
} | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x58(%rsp)
movq %rdi, 0x120(%rsp)
movl $0xa, 0x11c(%rsp)
movl 0x11c(%rsp), %eax
shll %eax
movl %eax, 0x118(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x37460
movq 0x58(%rsp), %rdi
movl $0x40000, 0x10c(%rsp) # imm = 0x40000
movl 0x118(%rsp), %eax
movl %eax, 0x108(%rsp)
callq ... | yangwanyuan[P]HLKVDS/tools/DbTest.cc |
Open_DB_Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void Open_DB_Test(string filename) {
Options opts;
KVDS *db = KVDS::Open_KVDS(filename.c_str(), opts);
//DB Insert
string test_key = "test-key";
int test_key_size = 8;
string test_value = "test-value";
int test_value_size = 10;
Status s = db->Insert(test_key.c_str(), test_key_size, t... | subq $0x4b8, %rsp # imm = 0x4B8
movq %rdi, 0x210(%rsp)
movq %rdi, 0x4b0(%rsp)
leaq 0x460(%rsp), %rdi
callq 0x37460
movq 0x210(%rsp), %rdi
callq 0x8180
movq %rax, %rdi
movups 0x4a0(%rsp), %xmm0
movaps %xmm0, 0x440(%rsp)
movups 0x460(%rsp), %xmm0
movups 0x470(%rsp), %xmm1
movups 0x480(%rsp), %xmm2
movups 0x490... | yangwanyuan[P]HLKVDS/tools/DbTest.cc |
main | int main(int argc, char** argv) {
string filename = argv[1];
Create_DB_Test(filename);
Open_DB_Test(filename);
std::cout << "first process success" << std::endl;
Create_DB_Test(filename);
Open_DB_Test(filename);
return 0;
} | subq $0xe8, %rsp
movl $0x0, 0xe4(%rsp)
movl %edi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0xb7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8830
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xb8(%rsp), %rdi
callq 0x8680
jmp 0x9f3d
leaq 0xb7(%rsp), %rdi
cal... | yangwanyuan[P]HLKVDS/tools/DbTest.cc |
MDinit | void MDinit(dword *MDbuf) {
MDbuf[0] = 0x67452301UL;
MDbuf[1] = 0xefcdab89UL;
MDbuf[2] = 0x98badcfeUL;
MDbuf[3] = 0x10325476UL;
MDbuf[4] = 0xc3d2e1f0UL;
return;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x67452301, (%rax) # imm = 0x67452301
movq -0x8(%rsp), %rax
movl $0xefcdab89, 0x4(%rax) # imm = 0xEFCDAB89
movq -0x8(%rsp), %rax
movl $0x98badcfe, 0x8(%rax) # imm = 0x98BADCFE
movq -0x8(%rsp), %rax
movl $0x10325476, 0xc(%rax) # imm = 0x10325476
movq -0x8(%rsp), %... | yangwanyuan[P]HLKVDS/src/rmd160.c |
compress_ | void compress_(dword *MDbuf, dword *X) {
dword aa = MDbuf[0], bb = MDbuf[1], cc = MDbuf[2], dd = MDbuf[3], ee =
MDbuf[4];
dword aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2], ddd = MDbuf[3], eee =
MDbuf[4];
/* round 1 */FF(aa, bb, cc, dd, ee, X[ 0], 11);
FF(ee, aa, bb, cc, dd, ... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rsp)
movq -0x8(%rsp... | yangwanyuan[P]HLKVDS/src/rmd160.c |
MDfinish | void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen) {
dword i; /* counter */
dword X[16]; /* message words */
memset(X, 0, 16 * sizeof(dword));
/* put bytes from strptr into X */
for (i = 0; i < (lswlen & 63); i++) {
/* byte i goes into word X[i div 4] at pos. 8*(i... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x8280
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl 0x54(%rsp), %ecx
andl $0x3f, %ecx
cmpl %ecx, %eax
jae 0x105ea
movq 0x58(%rsp), %rax
movq %rax, %rcx
addq... | yangwanyuan[P]HLKVDS/src/rmd160.c |
hlkvds::DS_MultiTier_Impl::ReadData(hlkvds::KVSlice&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Status DS_MultiTier_Impl::ReadData(KVSlice &slice, std::string &data) {
HashEntry *entry;
entry = &slice.GetHashEntry();
TierType tier_type = locateTierFromEntry(entry);
if (tier_type == TierType::FastTierType) {
return ft_->ReadData(slice, data);
}
return mt_->ReadData(slice, data);
} | subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x116b0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x10c30
... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::locateTierFromEntry(hlkvds::HashEntry*) | DS_MultiTier_Impl::TierType DS_MultiTier_Impl::locateTierFromEntry(HashEntry *entry) {
uint16_t pos = entry->GetHeaderLocation();
int vol_id = (int)pos;
if (vol_id == hlkvds::FastTierVolId) {
return TierType::FastTierType;
}
return TierType::MediumTierType;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11790
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x64, 0x8(%rsp)
jne 0x10c67
movl $0x0, 0x24(%rsp)
jmp 0x10c6f
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::GetSBReservedContent(char*, unsigned long) | bool DS_MultiTier_Impl::GetSBReservedContent(char* buf, uint64_t length) {
if (length != SuperBlockManager::ReservedRegionLength()) {
return false;
}
memset((void*)buf, 0, length);
char* buf_ptr = buf;
//Get sbResHeader_
uint64_t header_size = sizeof(MultiTierDS_SB_Reserved_Header);
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x10cf3
movb $0x0, 0x47(%rsp)
jmp 0x10d9b
movq 0x30(%rsp), %rdi
movq 0x28(%rsp)... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::SetSBReservedContent(char*, unsigned long) | bool DS_MultiTier_Impl::SetSBReservedContent(char* buf, uint64_t length) {
if (length != SuperBlockManager::ReservedRegionLength()) {
return false;
}
char* buf_ptr = buf;
//Set sbResHeader_
uint64_t header_size = sizeof(MultiTierDS_SB_Reserved_Header);
memcpy((void*)&sbResHeader_, (cons... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x116c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x10df3
movb $0x0, 0x47(%rsp)
jmp 0x10e8a
movq 0x8(%rsp), %rdi
movq 0x30(%rsp),... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::GetAllSSTs(char*, unsigned long) | bool DS_MultiTier_Impl::GetAllSSTs(char* buf, uint64_t length) {
uint64_t sst_total_length = GetSSTsLengthOnDisk();
if (length != sst_total_length) {
return false;
}
char *buf_ptr = buf;
//Copy TS
int64_t time_len = KVTime::SizeOf();
lastTime_->Update();
time_t t = lastTime_->Ge... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
movq (%rdi), %rax
callq *0x98(%rax)
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x10ee0
movb $0x0, 0x57(%rsp)
jmp 0x10fbb
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
callq ... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::SetAllSSTs(char*, unsigned long) | bool DS_MultiTier_Impl::SetAllSSTs(char* buf, uint64_t length) {
uint64_t sst_total_length = GetSSTsLengthOnDisk();
if (length != sst_total_length) {
return false;
}
char *buf_ptr = buf;
//Set TS
int64_t time_len = KVTime::SizeOf();
time_t t;
memcpy((void *)&t, (const void *)buf... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
movq (%rdi), %rax
callq *0x98(%rax)
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x11010
movb $0x0, 0x57(%rsp)
jmp 0x110db
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
callq ... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::CreateAllComponents(unsigned long) | bool DS_MultiTier_Impl::CreateAllComponents(uint64_t sst_offset) {
bool ret;
ret = mt_->CreateVolume(bdVec_);
if (!ret) {
return false;
}
uint32_t mt_seg_num = mt_->GetTotalSegNum();
ret = ft_->CreateVolume(bdVec_, sst_offset, mt_seg_num);
if (!ret) {
return false;
}
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x4d620
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x11128
movb $0x0, 0x27(%rsp)
jmp 0x11196
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x116f0
movl... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::OpenAllComponents() | bool DS_MultiTier_Impl::OpenAllComponents() {
bool ret;
ret = ft_->OpenVolume(bdVec_);
if (!ret) {
__ERROR("Fast Tier Open Volume Failed!");
return false;
}
ret = mt_->OpenVolume(bdVec_);
if (!ret) {
__ERROR("Medium Tier Open Volume Failed!");
return false;
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x4b8a0
andb $0x1, %al
movb %al, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x11257
jmp 0x111df
movq 0x5fdf2(%rip), %rax # 0x70fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8480
movq... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
hlkvds::DS_MultiTier_Impl::ModifyDeathEntry(hlkvds::HashEntry&) | void DS_MultiTier_Impl::ModifyDeathEntry(HashEntry &entry) {
TierType tier_type = locateTierFromEntry(&entry);
if (tier_type == TierType::FastTierType) {
return ft_->ModifyDeathEntry(entry);
}
return mt_->ModifyDeathEntry(entry);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x10c30
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x113a2
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x4bdc0
jmp 0x113b5
movq 0x8(%rsp), %rax
movq 0x38(%r... | yangwanyuan[P]HLKVDS/src/DS_MultiTier_Impl.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.