name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
gnuplotio::Gnuplot::~Gnuplot()
|
~Gnuplot() {
if(debug_messages) {
std::cerr << "ending gnuplot session" << std::endl;
}
// FIXME - boost's close method calls close() on the file descriptor, but we need to
// use sometimes use pclose instead. For now, just skip calling boost's close and use
// flush just in case.
do_flush();
// Wish boost had a pclose method...
//close();
fh_close();
delete feedback;
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x38(%rsi), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
cmpb $0x1, 0xb8(%rdi)
jne 0x978e
movq 0x1086e(%rip), %rdi # 0x19fe8
leaq 0x70e6(%rip), %rsi # 0x10867
callq 0x5320
movq %rax, %rdi
callq 0x51b0
movq %rbx, %rdi
callq 0x97d6
leaq 0x90(%rbx), %rdi
callq 0x97ec
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x97b4
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xb0(%rbx), %rdi
callq 0x96c2
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x877a
movq %rax, %rdi
callq 0x7aab
nop
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
gnuplotio::PlotData::PlotData(gnuplotio::PlotData const&)
|
PlotData() { }
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5440
movb 0x22(%r12), %al
movb %al, 0x22(%rbx)
movzwl 0x20(%r12), %eax
movw %ax, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x28(%r12), %rsi
movq %r14, %rdi
callq 0x5440
leaq 0x48(%rbx), %r15
leaq 0x48(%r12), %rsi
movq %r15, %rdi
callq 0x5440
leaq 0x68(%rbx), %r13
leaq 0x68(%r12), %rsi
movq %r13, %rdi
callq 0x5440
movl $0x88, %esi
leaq (%rbx,%rsi), %rbp
addq %r12, %rsi
movq %rbp, %rdi
callq 0x5440
movl $0xa8, %eax
leaq (%rbx,%rax), %rdi
addq %rax, %r12
movq %r12, %rsi
callq 0x5440
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rbp, %rdi
callq 0x5190
jmp 0x9f0c
movq %rax, %r12
movq %r13, %rdi
callq 0x5190
jmp 0x9f19
movq %rax, %r12
movq %r15, %rdi
callq 0x5190
jmp 0x9f26
movq %rax, %r12
movq %r14, %rdi
callq 0x5190
jmp 0x9f33
movq %rax, %r12
movq %rbx, %rdi
callq 0x5190
movq %r12, %rdi
callq 0x5570
nop
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
gnuplotio::GnuplotTmpfileCollection::make_tmpfile[abi:cxx11]()
|
std::string make_tmpfile() {
const bool debug_messages = false;
std::shared_ptr<GnuplotTmpfile> tmp_file(new GnuplotTmpfile(debug_messages));
// The file will be removed once the pointer is removed from the
// tmp_files container.
tmp_files.push_back(tmp_file);
return tmp_file->file.string();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x5340
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0xa050
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xa520
movq %r14, %rdi
movq %r12, %rsi
callq 0xa122
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5440
leaq 0x10(%rsp), %rdi
callq 0x96c2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x5360
jmp 0xa048
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x96c2
movq %rbx, %rdi
callq 0x5570
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
gnuplotio::GnuplotTmpfile::GnuplotTmpfile(bool)
|
explicit GnuplotTmpfile(bool _debug_messages) :
file(boost::filesystem::unique_path(
boost::filesystem::temp_directory_path() /
"tmp-gnuplot-%%%%-%%%%-%%%%-%%%%")),
debug_messages(_debug_messages)
{
if(debug_messages) {
std::cerr << "create tmpfile " << file << std::endl;
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xa189
leaq 0x6830(%rip), %rsi # 0x1089e
movq %rsp, %rdi
callq 0xa19a
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0xa15e
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xa14e
leaq 0x40(%rsp), %rdi
callq 0x5190
movq %rsp, %rdi
callq 0x5190
leaq 0x20(%rsp), %rdi
callq 0x5190
movb %bpl, 0x20(%rbx)
testb %bpl, %bpl
je 0xa0e0
movq 0xff27(%rip), %rdi # 0x19fe8
leaq 0x67f6(%rip), %rsi # 0x108be
callq 0x5320
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa1a7
movq %rax, %rdi
callq 0x51b0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x5190
jmp 0xa0fb
movq %rax, %r14
movq %rsp, %rdi
callq 0x5190
jmp 0xa108
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0xa115
movq %rax, %r14
movq %rbx, %rdi
callq 0x5190
movq %r14, %rdi
callq 0x5570
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
gnuplotio::GnuplotTmpfile::~GnuplotTmpfile()
|
~GnuplotTmpfile() {
if(debug_messages) {
std::cerr << "delete tmpfile " << file << std::endl;
}
// it is never good to throw exceptions from a destructor
try {
remove(file);
} catch(const std::exception &) {
std::cerr << "Failed to remove temporary file " << file << std::endl;
}
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0xa5d6
movq 0xfa31(%rip), %rdi # 0x19fe8
leaq 0x6310(%rip), %rsi # 0x108ce
callq 0x5320
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa1a7
movq %rax, %rdi
callq 0x51b0
movq %rbx, %rdi
callq 0xa65d
movq %rbx, %rdi
popq %rbx
jmp 0x5190
cmpl $0x2, %edx
jne 0xa621
movq %rax, %rdi
callq 0x5160
movq 0xf9ed(%rip), %rdi # 0x19fe8
leaq 0x62dc(%rip), %rsi # 0x108de
callq 0x5320
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa1a7
movq %rax, %rdi
callq 0x51b0
callq 0x5530
jmp 0xa5de
movq %rax, %rdi
callq 0x7aab
nop
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
gnuplotio::PlotData::PlotData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
explicit PlotData(const std::string &_plotspec) :
plotspec(_plotspec),
is_text(true),
is_inline(false),
has_data(false)
{ }
|
pushq %rbx
movq %rdi, %rbx
callq 0x5440
movw $0x1, 0x20(%rbx)
xorl %eax, %eax
movb %al, 0x22(%rbx)
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb %al, 0x38(%rbx)
leaq 0x58(%rbx), %rcx
movq %rcx, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
movb %al, 0x58(%rbx)
leaq 0x78(%rbx), %rcx
movq %rcx, 0x68(%rbx)
andq $0x0, 0x70(%rbx)
movb %al, 0x78(%rbx)
leaq 0x98(%rbx), %rcx
movq %rcx, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movb %al, 0x98(%rbx)
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movb %al, 0xb8(%rbx)
popq %rbx
retq
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::enable_if<1ul == 1 && !gnuplotio::ModeText::is_size, void>::type gnuplotio::print_block<1ul, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::pair<double, double> const*, std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>>, std::pair<double, double>>, gnuplotio::ModeText>(std::ostream&, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::pair<double, double> const*, std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>>, std::pair<double, double>>&, gnuplotio::ModeText)
|
typename std::enable_if_t<(Depth==1) && !PrintMode::is_size>
print_block(std::ostream &stream, T &arg, PrintMode) {
if(PrintMode::is_binfmt && arg.is_end()) throw plotting_empty_container();
for(; !arg.is_end(); arg.inc()) {
//print_entry(arg.deref());
deref_and_print(stream, arg, PrintMode());
// If asked to print the binary format string, only the first element needs to be
// looked at.
if(PrintMode::is_binfmt) break;
if(PrintMode::is_text) stream << std::endl;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rbx), %rax
je 0xc23c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc244
movq %r14, %rdi
callq 0x51b0
movq (%rbx), %rax
addq $0x10, %rax
movq %rax, (%rbx)
jmp 0xc217
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> gnuplotio::Gnuplot::binfmt<std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>, gnuplotio::Mode1D>(std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, gnuplotio::Mode1D)
|
std::string binfmt(const T &arg, const std::string &arr_or_rec, OrganizationMode) {
assert((arr_or_rec == "array") || (arr_or_rec == "record"));
std::string ret;
try {
std::ostringstream tmp;
tmp << " format='";
top_level_array_sender(tmp, arg, OrganizationMode(), ModeBinfmt());
tmp << "' " << arr_or_rec << "=(";
top_level_array_sender(tmp, arg, OrganizationMode(), ModeSize());
tmp << ")";
tmp << " ";
ret = tmp.str();
} catch(const plotting_empty_container &) {
ret = std::string(" format='' ") + arr_or_rec + "=(0) ";
}
return ret;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x40ef(%rip), %rsi # 0x1042b
movq %rcx, %rdi
callq 0xc536
testb %al, %al
jne 0xc35f
leaq 0x3de9(%rip), %rsi # 0x10138
movq %r14, %rdi
callq 0xc536
testb %al, %al
je 0xc434
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x50(%rsp), %rdi
callq 0x5430
leaq 0x45a4(%rip), %rsi # 0x10924
leaq 0x50(%rsp), %rdi
callq 0x5320
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xc543
leaq 0x46f3(%rip), %rsi # 0x10a91
leaq 0x50(%rsp), %rdi
callq 0x5320
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
leaq 0x4574(%rip), %rsi # 0x1092e
movq %rax, %rdi
callq 0x5320
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xc616
leaq 0x4604(%rip), %rsi # 0x109da
leaq 0x50(%rsp), %rdi
callq 0x5320
leaq 0x46ab(%rip), %rsi # 0x10a92
leaq 0x50(%rsp), %rdi
callq 0x5320
leaq 0x58(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5500
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53d0
movq %r14, %rdi
callq 0x5190
leaq 0x50(%rsp), %rdi
callq 0x50c0
movq %rbx, %rax
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x456d(%rip), %rdi # 0x109a8
leaq 0x41b5(%rip), %rsi # 0x105f7
leaq 0x4593(%rip), %rcx # 0x109dc
movl $0x706, %edx # imm = 0x706
callq 0x5220
jmp 0xc45d
movq %rdx, %r12
movq %rax, %r15
jmp 0xc46d
movq %rdx, %r12
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x50c0
cmpl $0x1, %r12d
jne 0xc51e
movq %r15, %rdi
callq 0x5160
leaq 0x4602(%rip), %rsi # 0x10a88
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7ab6
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r14, %rdx
callq 0xba9d
leaq 0x45e6(%rip), %rdx # 0x10a94
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb952
leaq 0x50(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53d0
movq %r14, %rdi
callq 0x5190
leaq 0x10(%rsp), %rdi
callq 0x5190
leaq 0x30(%rsp), %rdi
callq 0x5190
callq 0x5530
jmp 0xc422
movq %rax, %r15
jmp 0xc51e
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x5190
jmp 0xc50a
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x5190
jmp 0xc519
movq %rax, %r15
callq 0x5530
movq %rbx, %rdi
callq 0x5190
movq %r15, %rdi
callq 0x5570
movq %rax, %rdi
callq 0x7aab
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> gnuplotio::Gnuplot::file<std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>, gnuplotio::Mode1D>(std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, gnuplotio::Mode1D)
|
std::string file(const T &arg, std::string filename, OrganizationMode) {
if(filename.empty()) filename = make_tmpfile();
std::fstream tmp_stream(filename.c_str(), std::fstream::out);
tmp_stream.copyfmt(*this);
top_level_array_sender(tmp_stream, arg, OrganizationMode(), ModeText());
tmp_stream.close();
std::ostringstream cmdline;
// FIXME - hopefully filename doesn't contain quotes or such...
cmdline << " '" << filename << "' ";
return cmdline.str();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x390, %rsp # imm = 0x390
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x0, 0x8(%rcx)
jne 0xc741
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x9bfe
movq %r14, %rdi
movq %r13, %rsi
callq 0x53d0
movq %r13, %rdi
callq 0x5190
movq (%r14), %rsi
leaq 0x180(%rsp), %r13
pushq $0x10
popq %rdx
movq %r13, %rdi
callq 0x5420
movq (%r13), %rax
addq -0x18(%rax), %r13
movq (%r12), %rax
addq -0x18(%rax), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x51a0
leaq 0x190(%rsp), %rdi
movq %r15, %rsi
callq 0xc1f3
leaq 0x180(%rsp), %rdi
callq 0x5060
leaq 0x8(%rsp), %rdi
callq 0x5430
leaq 0x431b(%rip), %rsi # 0x10abb
leaq 0x8(%rsp), %rdi
callq 0x5320
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
leaq 0x42d5(%rip), %rsi # 0x10a91
movq %rax, %rdi
callq 0x5320
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5500
leaq 0x8(%rsp), %rdi
callq 0x50c0
leaq 0x180(%rsp), %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x390, %rsp # imm = 0x390
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc7fe
movq %rax, %rbx
jmp 0xc810
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x50c0
leaq 0x180(%rsp), %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x5570
nop
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::enable_if<1ul == 1 && !gnuplotio::ModeText::is_size, void>::type gnuplotio::print_block<1ul, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::tuple<double, double, double, double> const*, std::vector<std::tuple<double, double, double, double>, std::allocator<std::tuple<double, double, double, double>>>>, std::tuple<double, double, double, double>>, gnuplotio::ModeText>(std::ostream&, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::tuple<double, double, double, double> const*, std::vector<std::tuple<double, double, double, double>, std::allocator<std::tuple<double, double, double, double>>>>, std::tuple<double, double, double, double>>&, gnuplotio::ModeText)
|
typename std::enable_if_t<(Depth==1) && !PrintMode::is_size>
print_block(std::ostream &stream, T &arg, PrintMode) {
if(PrintMode::is_binfmt && arg.is_end()) throw plotting_empty_container();
for(; !arg.is_end(); arg.inc()) {
//print_entry(arg.deref());
deref_and_print(stream, arg, PrintMode());
// If asked to print the binary format string, only the first element needs to be
// looked at.
if(PrintMode::is_binfmt) break;
if(PrintMode::is_text) stream << std::endl;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rbx), %rax
je 0xcce2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xccea
movq %r14, %rdi
callq 0x51b0
movq (%rbx), %rax
addq $0x20, %rax
movq %rax, (%rbx)
jmp 0xccbd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> gnuplotio::Gnuplot::binfmt<std::vector<std::tuple<double, double, double>, std::allocator<std::tuple<double, double, double>>>, gnuplotio::Mode1D>(std::vector<std::tuple<double, double, double>, std::allocator<std::tuple<double, double, double>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, gnuplotio::Mode1D)
|
std::string binfmt(const T &arg, const std::string &arr_or_rec, OrganizationMode) {
assert((arr_or_rec == "array") || (arr_or_rec == "record"));
std::string ret;
try {
std::ostringstream tmp;
tmp << " format='";
top_level_array_sender(tmp, arg, OrganizationMode(), ModeBinfmt());
tmp << "' " << arr_or_rec << "=(";
top_level_array_sender(tmp, arg, OrganizationMode(), ModeSize());
tmp << ")";
tmp << " ";
ret = tmp.str();
} catch(const plotting_empty_container &) {
ret = std::string(" format='' ") + arr_or_rec + "=(0) ";
}
return ret;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x32a1(%rip), %rsi # 0x1042b
movq %rcx, %rdi
callq 0xc536
testb %al, %al
jne 0xd1ad
leaq 0x2f9b(%rip), %rsi # 0x10138
movq %r14, %rdi
callq 0xc536
testb %al, %al
je 0xd282
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x50(%rsp), %rdi
callq 0x5430
leaq 0x3756(%rip), %rsi # 0x10924
leaq 0x50(%rsp), %rdi
callq 0x5320
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xd384
leaq 0x38a5(%rip), %rsi # 0x10a91
leaq 0x50(%rsp), %rdi
callq 0x5320
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
leaq 0x3726(%rip), %rsi # 0x1092e
movq %rax, %rdi
callq 0x5320
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xd45b
leaq 0x37b6(%rip), %rsi # 0x109da
leaq 0x50(%rsp), %rdi
callq 0x5320
leaq 0x385d(%rip), %rsi # 0x10a92
leaq 0x50(%rsp), %rdi
callq 0x5320
leaq 0x58(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5500
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53d0
movq %r14, %rdi
callq 0x5190
leaq 0x50(%rsp), %rdi
callq 0x50c0
movq %rbx, %rax
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x371f(%rip), %rdi # 0x109a8
leaq 0x3367(%rip), %rsi # 0x105f7
leaq 0x3827(%rip), %rcx # 0x10abe
movl $0x706, %edx # imm = 0x706
callq 0x5220
jmp 0xd2ab
movq %rdx, %r12
movq %rax, %r15
jmp 0xd2bb
movq %rdx, %r12
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x50c0
cmpl $0x1, %r12d
jne 0xd36c
movq %r15, %rdi
callq 0x5160
leaq 0x37b4(%rip), %rsi # 0x10a88
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x7ab6
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r14, %rdx
callq 0xba9d
leaq 0x3798(%rip), %rdx # 0x10a94
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb952
leaq 0x50(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53d0
movq %r14, %rdi
callq 0x5190
leaq 0x10(%rsp), %rdi
callq 0x5190
leaq 0x30(%rsp), %rdi
callq 0x5190
callq 0x5530
jmp 0xd270
movq %rax, %r15
jmp 0xd36c
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x5190
jmp 0xd358
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x5190
jmp 0xd367
movq %rax, %r15
callq 0x5530
movq %rbx, %rdi
callq 0x5190
movq %r15, %rdi
callq 0x5570
movq %rax, %rdi
callq 0x7aab
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::enable_if<1ul == 1 && !gnuplotio::ModeBinary::is_size, void>::type gnuplotio::print_block<1ul, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::tuple<double, double, double> const*, std::vector<std::tuple<double, double, double>, std::allocator<std::tuple<double, double, double>>>>, std::tuple<double, double, double>>, gnuplotio::ModeBinary>(std::ostream&, gnuplotio::IteratorRange<__gnu_cxx::__normal_iterator<std::tuple<double, double, double> const*, std::vector<std::tuple<double, double, double>, std::allocator<std::tuple<double, double, double>>>>, std::tuple<double, double, double>>&, gnuplotio::ModeBinary)
|
typename std::enable_if_t<(Depth==1) && !PrintMode::is_size>
print_block(std::ostream &stream, T &arg, PrintMode) {
if(PrintMode::is_binfmt && arg.is_end()) throw plotting_empty_container();
for(; !arg.is_end(); arg.inc()) {
//print_entry(arg.deref());
deref_and_print(stream, arg, PrintMode());
// If asked to print the binary format string, only the first element needs to be
// looked at.
if(PrintMode::is_binfmt) break;
if(PrintMode::is_text) stream << std::endl;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq 0x8(%rbx), %rax
je 0xd4e1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd4e9
movq (%rbx), %rax
addq $0x18, %rax
movq %rax, (%rbx)
jmp 0xd4c4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> gnuplotio::Gnuplot::file<std::vector<std::tuple<double, double, double>, std::allocator<std::tuple<double, double, double>>>, gnuplotio::Mode1D>(std::vector<std::tuple<double, double, double>, std::allocator<std::tuple<double, double, double>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, gnuplotio::Mode1D)
|
std::string file(const T &arg, std::string filename, OrganizationMode) {
if(filename.empty()) filename = make_tmpfile();
std::fstream tmp_stream(filename.c_str(), std::fstream::out);
tmp_stream.copyfmt(*this);
top_level_array_sender(tmp_stream, arg, OrganizationMode(), ModeText());
tmp_stream.close();
std::ostringstream cmdline;
// FIXME - hopefully filename doesn't contain quotes or such...
cmdline << " '" << filename << "' ";
return cmdline.str();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x390, %rsp # imm = 0x390
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpq $0x0, 0x8(%rcx)
jne 0xd5a5
leaq 0x180(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x9bfe
movq %r14, %rdi
movq %r13, %rsi
callq 0x53d0
movq %r13, %rdi
callq 0x5190
movq (%r14), %rsi
leaq 0x180(%rsp), %r13
pushq $0x10
popq %rdx
movq %r13, %rdi
callq 0x5420
movq (%r13), %rax
addq -0x18(%rax), %r13
movq (%r12), %rax
addq -0x18(%rax), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x51a0
leaq 0x190(%rsp), %rdi
movq %r15, %rsi
callq 0xd021
leaq 0x180(%rsp), %rdi
callq 0x5060
leaq 0x8(%rsp), %rdi
callq 0x5430
leaq 0x34b7(%rip), %rsi # 0x10abb
leaq 0x8(%rsp), %rdi
callq 0x5320
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
leaq 0x3471(%rip), %rsi # 0x10a91
movq %rax, %rdi
callq 0x5320
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5500
leaq 0x8(%rsp), %rdi
callq 0x50c0
leaq 0x180(%rsp), %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x390, %rsp # imm = 0x390
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xd662
movq %rax, %rbx
jmp 0xd674
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x50c0
leaq 0x180(%rsp), %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x5570
nop
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
gnuplotio::PlotData::PlotData<std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>>, gnuplotio::Mode1D, gnuplotio::ModeText>(std::vector<std::pair<double, double>, std::allocator<std::pair<double, double>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, gnuplotio::Mode1D, gnuplotio::ModeText)
|
PlotData(
const T &arg,
const std::string &_plotspec,
const std::string &_arr_or_rec,
OrganizationMode, PrintMode
) :
plotspec(_plotspec),
is_text(PrintMode::is_text),
is_inline(true),
has_data(true),
arr_or_rec(_arr_or_rec)
{
{
std::ostringstream tmp;
top_level_array_sender(tmp, arg, OrganizationMode(), PrintMode());
data = tmp.str();
}
if(!is_text) {
try {
{
std::ostringstream tmp;
top_level_array_sender(tmp, arg, OrganizationMode(), ModeBinfmt());
bin_fmt = tmp.str();
}
{
std::ostringstream tmp;
top_level_array_sender(tmp, arg, OrganizationMode(), ModeSize());
bin_size = tmp.str();
}
} catch(const plotting_empty_container &) {
bin_fmt = "";
bin_size = "0";
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x5440
movw $0x101, 0x20(%rbx) # imm = 0x101
movb $0x1, 0x22(%rbx)
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
xorl %eax, %eax
movb %al, 0x38(%rbx)
leaq 0x58(%rbx), %rcx
movq %rcx, 0x48(%rbx)
andq $0x0, 0x50(%rbx)
leaq 0x28(%rbx), %r14
movb %al, 0x58(%rbx)
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x5440
leaq 0x88(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x98(%rbx), %rax
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
xorl %eax, %eax
movb %al, 0x98(%rbx)
leaq 0xa8(%rbx), %r13
leaq 0xb8(%rbx), %rcx
movq %rcx, 0xa8(%rbx)
andq $0x0, 0xb0(%rbx)
movb %al, 0xb8(%rbx)
leaq 0x30(%rsp), %rdi
callq 0x5430
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0xc1f3
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5500
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x53d0
movq %r12, %rdi
callq 0x5190
leaq 0x30(%rsp), %rdi
callq 0x50c0
cmpb $0x0, 0x20(%rbx)
jne 0xec0c
leaq 0x30(%rsp), %rdi
callq 0x5430
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0xc543
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5500
leaq 0x10(%rsp), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x53d0
movq %r12, %rdi
callq 0x5190
leaq 0x30(%rsp), %rdi
callq 0x50c0
leaq 0x30(%rsp), %rdi
callq 0x5430
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0xc616
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5500
leaq 0x10(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x5190
leaq 0x30(%rsp), %rdi
callq 0x50c0
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xec26
jmp 0xec26
jmp 0xec38
jmp 0xec26
movq %rdx, %r12
movq %rax, %rbp
leaq 0x30(%rsp), %rdi
callq 0x50c0
jmp 0xec3e
movq %rdx, %r12
movq %rax, %rbp
cmpl $0x1, %r12d
jne 0xec9b
movq %rbp, %rdi
callq 0x5160
leaq 0x15ee(%rip), %rsi # 0x10241
movq 0x8(%rsp), %rdi
callq 0x55f0
leaq 0x20bd(%rip), %rsi # 0x10d21
movq %r13, %rdi
callq 0x55f0
callq 0x5530
jmp 0xec0c
jmp 0xec98
movq %rax, %rbp
callq 0x5530
jmp 0xec9b
movq %rax, %rdi
callq 0x7aab
jmp 0xec89
movq %rax, %rbp
leaq 0x30(%rsp), %rdi
callq 0x50c0
jmp 0xec9b
movq %rax, %rbp
movq %r13, %rdi
callq 0x5190
movq 0x8(%rsp), %rdi
callq 0x5190
movq %r15, %rdi
callq 0x5190
jmp 0xecba
movq %rax, %rbp
leaq 0x48(%rbx), %rdi
callq 0x5190
movq %r14, %rdi
callq 0x5190
movq %rbx, %rdi
callq 0x5190
movq %rbp, %rdi
callq 0x5570
nop
|
/dstahlke[P]gnuplot-iostream/gnuplot-iostream.h
|
main
|
int main(int argc, char const *argv[]) {
int port = 7896;
int size = 20;
// cout << "Please input port and window size:";
// cin >> port >> size;
ServerService service = ServerService(port, size);
char msg[100] = "BROADCAST FROM SERVER";
//初始化广播
struct sockaddr_in peerAddr = service.initBroadcast(9001);
//发送单条广播
service.startBroadcast(&peerAddr, msg, 5);
service.startBroadcast(&peerAddr, msg, 4);
service.startBroadcast(&peerAddr, msg, 3);
service.startBroadcast(&peerAddr, msg, 2);
service.startBroadcast(&peerAddr, msg);
service.startBroadcast(&peerAddr, msg);
service.startService();
// service.startControlService();
// service.startControlServiceWithResult();
return 0;
}
|
pushq %rbx
subq $0xa0, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x1ed8, %esi # imm = 0x1ED8
movl $0x14, %edx
callq 0x2d04
leaq 0x2a1e(%rip), %rsi # 0x5010
leaq 0x30(%rsp), %rax
movl $0xc, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movl $0x0, 0x60(%rax)
movq %rbx, %rdi
movl $0x2329, %esi # imm = 0x2329
callq 0x458c
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x5, %ecx
callq 0x4640
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl $0x4, %ecx
callq 0x4640
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl $0x3, %ecx
callq 0x4640
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl $0x2, %ecx
callq 0x4640
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x4640
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x4640
leaq 0x8(%rsp), %rdi
callq 0x2d58
leaq 0x8(%rsp), %rdi
callq 0x490a
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x490a
movq %rbx, %rdi
callq 0x2380
nop
|
/VanXNF[P]RUDP/Server/Server.cpp
|
ServerSocketUDP::ServerSocketUDP(int, int, int, int)
|
ServerSocketUDP::ServerSocketUDP(int domain, int type, int protocol, int port) {
this->portNumber = port;
this->serverSocketFD = -1; //FD: file descriptor 文件描述符
this->socketServer(domain, type, protocol);
if (this->bindServer() > 0) {
cout << "Binding successfully done...." << endl;
}
}
|
pushq %rbx
movq %rdi, %rbx
movl %r8d, 0x4(%rdi)
movl $0xffffffff, (%rdi) # imm = 0xFFFFFFFF
callq 0x2760
movq %rbx, %rdi
callq 0x27b8
movq 0x58ac(%rip), %rbx # 0x7fd0
leaq 0x2949(%rip), %rsi # 0x5074
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2290
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
jmp 0x21a0
|
/VanXNF[P]RUDP/Server/ServerSocket.cpp
|
ServerSocketUDP::socketServer(int, int, int)
|
int ServerSocketUDP::socketServer(int domain, int type, int protocol) {
this->serverSocketFD = socket(domain, type, protocol);
if (this->serverSocketFD < 0) {
cerr << "Error in opening socket: " << strerror(errno) << endl;
exit(0);
}
return 1;
}
|
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movl %edx, %esi
movl %ecx, %edx
callq 0x20a0
movl %eax, (%rbx)
testl %eax, %eax
js 0x277c
movl $0x1, %eax
popq %rbx
retq
movq 0x586d(%rip), %rdi # 0x7ff0
leaq 0x2908(%rip), %rsi # 0x5092
callq 0x2230
movq %rax, %rbx
callq 0x2040
movl (%rax), %edi
callq 0x20f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x2140
xorl %edi, %edi
callq 0x22b0
|
/VanXNF[P]RUDP/Server/ServerSocket.cpp
|
ServerSocketUDP::bindServer()
|
int ServerSocketUDP::bindServer() {
struct sockaddr_in serverAddress;
char ip[16];
getLocalIP(ip);
serverAddress.sin_family = AF_INET; //指定协议地址族
serverAddress.sin_addr.s_addr = inet_addr(ip);
serverAddress.sin_port = htons(this->portNumber);
//绑定对应端口，监听服务
if (bind(this->serverSocketFD, (struct sockaddr *) &serverAddress, sizeof(serverAddress)) < 0) {
cerr << "Error in binding: " << endl;
cout << "Error Code: " << strerror(errno) << endl;
exit(1);
}
return 1;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4d90
leaq 0x10(%rsp), %r15
movw $0x2, (%r15)
movq %r14, %rdi
callq 0x2250
movl %eax, 0x4(%r15)
movzwl 0x4(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r15)
movl (%rbx), %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x2080
testl %eax, %eax
js 0x2815
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x57d4(%rip), %rdi # 0x7ff0
leaq 0x2889(%rip), %rsi # 0x50ac
callq 0x2230
movq %rax, %rdi
callq 0x2140
movq 0x5799(%rip), %rdi # 0x7fd0
leaq 0x2881(%rip), %rsi # 0x50bf
callq 0x2230
movq %rax, %rbx
callq 0x2040
movl (%rax), %edi
callq 0x20f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x2140
movl $0x1, %edi
callq 0x22b0
nop
|
/VanXNF[P]RUDP/Server/ServerSocket.cpp
|
ServerSegment::ServerSegment(unsigned int, unsigned char, unsigned char*, unsigned int, unsigned char, unsigned short, unsigned short)
|
ServerSegment::ServerSegment(byte4 seqNumber, byte finFlag, byte *data, byte4 ackNumber, byte ackFlag, byte2 checksum, byte2 reserved) {
this->sequenceNumber = seqNumber;
this->ackNumber = ackNumber;
this->ackFlag = ackFlag;
this->finFlag = finFlag;
this->length = strlen((char *) data);
this->checksum = checksum;
this->reserved = reserved;
this->data = data;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movzwl 0x38(%rsp), %ebp
movzwl 0x30(%rsp), %r15d
movl %esi, (%rdi)
movl %r8d, 0x4(%rdi)
movb %r9b, 0x8(%rdi)
movb %dl, 0x9(%rdi)
movq %rcx, %rdi
callq 0x2130
movw %ax, 0xa(%r14)
movw %r15w, 0xc(%r14)
movw %bp, 0xe(%r14)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/VanXNF[P]RUDP/Server/ServerSegment.cpp
|
ServerSegment::prepareSegment()
|
byte *ServerSegment::prepareSegment() {
int counter = 0;
byte *buffer = (byte *) calloc(MTU, sizeof(byte));
memset(buffer, 0, MTU);
memcpy(buffer + counter, &sequenceNumber, sizeof(sequenceNumber));
counter += sizeof(sequenceNumber);
memcpy(buffer + counter, &ackNumber, sizeof(ackNumber));
counter += sizeof(ackNumber);
memcpy(buffer + counter, &ackFlag, 1);
counter += sizeof(ackFlag);
memcpy(buffer + counter, &finFlag, 1);
counter += sizeof(finFlag);
memcpy(buffer + counter, &length, sizeof(length));
counter += sizeof(length);
memcpy(buffer + counter, &checksum, sizeof(checksum));
counter += sizeof(checksum);
memcpy(buffer + counter, &reserved, sizeof(reserved));
counter += sizeof(reserved);
memcpy(buffer + counter, data, length);
return buffer;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x5c0, %edi # imm = 0x5C0
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
movl $0x5c0, %edx # imm = 0x5C0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2160
movl (%rbx), %eax
movl %eax, (%r14)
movl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movb 0x8(%rbx), %al
movb %al, 0x8(%r14)
movb 0x9(%rbx), %al
movb %al, 0x9(%r14)
movzwl 0xa(%rbx), %edx
movw %dx, 0xa(%r14)
movzwl 0xc(%rbx), %eax
movw %ax, 0xc(%r14)
movzwl 0xe(%rbx), %eax
movw %ax, 0xe(%r14)
leaq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x21e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/VanXNF[P]RUDP/Server/ServerSegment.cpp
|
SendUnit::getRUDP(unsigned int)
|
ServerSegment *SendUnit::getRUDP(byte4 seqNo) {
byte *dataSpace = (byte *) calloc(MTU - HEADER_LEN, sizeof(byte)); //分配数据可用连续空间
memset(dataSpace, 0, (MTU - HEADER_LEN)); // 初始化数据置临零
// 如果剩下的数据小于单次最大传输容量，则读取所有剩余数据，将结束位置为 TRUE 后发送，否则读取单次最大传输容量数据，将结束位置 FALSE 后发送。
if (dataSize - (seqNo - initSeqNo) < MTU - HEADER_LEN) {
memcpy(dataSpace, &data[(seqNo-initSeqNo)], dataSize - (seqNo - initSeqNo));
return new ServerSegment(seqNo, TRUE, dataSpace);
} else {
memcpy(dataSpace, &data[(seqNo-initSeqNo)], (MTU - HEADER_LEN));
return new ServerSegment(seqNo, FALSE, dataSpace);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x5b0, %edi # imm = 0x5B0
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
xorl %r15d, %r15d
movl $0x5b0, %edx # imm = 0x5B0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2160
movq (%rbx), %rdx
movl %ebp, %esi
subl 0x10(%rbx), %esi
subq %rsi, %rdx
addq 0x8(%rbx), %rsi
cmpq $0x5af, %rdx # imm = 0x5AF
ja 0x2a48
movq %r14, %rdi
callq 0x21e0
movl $0x18, %edi
callq 0x2240
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movl $0x59, %edx
movq %r14, %rcx
xorl %r8d, %r8d
movl $0x4e, %r9d
pushq %r15
pushq %r15
callq 0x2882
addq $0x10, %rsp
jmp 0x2a85
movl $0x5b0, %edx # imm = 0x5B0
movq %r14, %rdi
callq 0x21e0
movl $0x18, %edi
callq 0x2240
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movl $0x4e, %edx
movq %r14, %rcx
xorl %r8d, %r8d
movl $0x4e, %r9d
pushq %r15
pushq %r15
callq 0x2882
addq $0x10, %rsp
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a95
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2260
movq %r14, %rdi
callq 0x2380
nop
|
/VanXNF[P]RUDP/Server/SendUnit.cpp
|
Congestion::Congestion(int)
|
Congestion::Congestion(int advertisedSize) {
this->advertisedSize = advertisedSize;
this->cwnd = 1;
this->ssthresh = 16;
this->dupAck = 0;
this->isSlowStart = true;
this->RTTs = INIT_SEC;
this->RTTd = 0;
this->RTO = 0;
}
|
movl %esi, 0x10(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
movabsq $0x4030000000000000, %rax # imm = 0x4030000000000000
movq %rax, 0x8(%rdi)
movl $0x0, 0x14(%rdi)
movb $0x1, 0x18(%rdi)
movabsq $0x40e86a0000000000, %rax # imm = 0x40E86A0000000000
movq %rax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
retq
nop
|
/VanXNF[P]RUDP/Server/Congestion.cpp
|
Congestion::updateRTT(double, double)
|
void Congestion::updateRTT(double start, double end) {
float a = 0.125; //计算新 RTT 样本值时加权 RFC 6298 推荐值
float b = 0.25; //计算 RTT 的偏差的加权平均值时 RFC 6298 推荐值
double newSampleRTT = end - start;
RTTs = (1.0 - a) * RTTs + (a * newSampleRTT);
RTTd = (1.0 - b) * RTTd + (b * abs(RTTs - newSampleRTT));
RTO = RTTs + 4 * RTTd;
}
|
subsd %xmm0, %xmm1
movsd 0x24a8(%rip), %xmm0 # 0x50d0
mulsd %xmm1, %xmm0
movsd 0x20(%rdi), %xmm2
movsd 0x28(%rdi), %xmm3
mulsd 0x249a(%rip), %xmm2 # 0x50d8
addsd %xmm0, %xmm2
movsd %xmm2, 0x20(%rdi)
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
andpd 0x24b9(%rip), %xmm0 # 0x5110
mulsd 0x2481(%rip), %xmm0 # 0x50e0
mulsd 0x2481(%rip), %xmm3 # 0x50e8
addsd %xmm0, %xmm3
movsd %xmm3, 0x28(%rdi)
mulsd 0x2478(%rip), %xmm3 # 0x50f0
addsd %xmm2, %xmm3
movsd %xmm3, 0x30(%rdi)
retq
|
/VanXNF[P]RUDP/Server/Congestion.cpp
|
ServerService::startService()
|
bool ServerService::startService() {
socklen_t clientLength;
struct sockaddr_storage clientDetails;
byte buffer[MTU];
bzero(buffer, MTU);
bool flag = false;
clientLength = sizeof(clientDetails);
while (true) {
recvfrom(serverSocketUDP->getSocket(), buffer, MTU, 0, (struct sockaddr *) &clientDetails, &clientLength);
ServerSegment *segment = parseRequest(buffer);
if (segment->data && segment->ackFlag == 'N') {
cout << "Received: ";
cout << (char *) segment->data << endl;
string key = (char *) segment->data;
key = "I received " + key;
for (int i = 0; i < 200; ++i) {
key += "123 hjg ghjfhdjg hj cjchjfghjcghjc yjccgyjvghjvg jyy yjcgyj vyj";
}
// todo 对收到信息做处理，并响应请求
if (sendSegments((byte *) key.c_str(), serverSocketUDP->getSocket(), clientDetails, receiverWindowSize)) {
flag = true;
}
}
if (flag) {
cout << "Sent all segments. Closing server connection." << endl;
// break;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x718, %rsp # imm = 0x718
movq %rdi, %rbx
leaq 0x150(%rsp), %rdi
xorl %r14d, %r14d
movl $0x5c0, %edx # imm = 0x5C0
xorl %esi, %esi
callq 0x2160
leaq 0x8c(%rsp), %rax
movl $0x80, (%rax)
movq 0x5238(%rip), %r13 # 0x7fd0
leaq 0x90(%rsp), %rbp
leaq 0x23a4(%rip), %r15 # 0x514b
movq 0x10(%rbx), %rdi
callq 0x2870
movl $0x5c0, %edx # imm = 0x5C0
movl %eax, %edi
leaq 0x150(%rsp), %r12
movq %r12, %rsi
xorl %ecx, %ecx
leaq 0xd0(%rsp), %r8
leaq 0x8c(%rsp), %r9
callq 0x21c0
movq %r12, %rsi
callq 0x2fc0
cmpq $0x0, 0x10(%rax)
je 0x2f40
movq %rax, %r12
cmpb $0x4e, 0x8(%rax)
jne 0x2f40
movl $0xa, %edx
movq %r13, %rdi
leaq 0x232c(%rip), %rsi # 0x5134
callq 0x2290
movq 0x10(%r12), %r14
testq %r14, %r14
je 0x2e2f
movq %r14, %rdi
callq 0x2130
movq %r13, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2290
jmp 0x2e48
movq (%r13), %rax
movq -0x18(%rax), %rax
leaq (%rax,%r13), %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x2350
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0x10(%r12), %rsi
movq %rbp, %rdi
leaq 0xb0(%rsp), %r14
movq %r14, %rdx
callq 0x2110
movq %r14, %rdi
leaq 0x22ad(%rip), %rsi # 0x513f
movq %rbp, %rdx
callq 0x492d
movq %rbp, %rdi
movq %r14, %rsi
callq 0x22c0
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x2eca
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x2260
movl $0xc8, %r14d
movq %rbp, %rdi
movq %r15, %rsi
callq 0x23b0
decl %r14d
jne 0x2ed0
movq 0x90(%rsp), %r12
movq 0x10(%rbx), %rdi
callq 0x2870
movl 0x8(%rbx), %r8d
movl $0x10, %ecx
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
movl %r8d, %ecx
callq 0x304c
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x2f3d
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x2260
movb $0x1, %r14b
testb $0x1, %r14b
je 0x2da7
movl $0x2d, %edx
movq %r13, %rdi
leaq 0x2234(%rip), %rsi # 0x518d
callq 0x2290
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
jmp 0x2da7
jmp 0x2f8f
jmp 0x2f8f
movq %rax, %rbx
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x2fb7
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x2260
movq %rbx, %rdi
callq 0x2380
nop
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::parseRequest(unsigned char*)
|
ServerSegment *ServerService::parseRequest(byte *buffer) {
byte4 seqNo = (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | (buffer[0]);
byte4 ackNo = (buffer[7] << 24) | (buffer[6] << 16) | (buffer[5] << 8) | (buffer[4]);
byte ackFlag = (byte) buffer[8];
byte finFlag = (byte) buffer[9];
byte2 length = (buffer[11] << 8) | (buffer[10]);
byte2 checksum = (buffer[13] << 8) | (buffer[12]);
byte2 reserved = (buffer[15] << 8) | (buffer[14]);
byte *data = &buffer[16];
return new ServerSegment(seqNo, finFlag, data, ackNo, ackFlag, checksum, reserved);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rsi), %ebp
movl 0x4(%rsi), %eax
movl %eax, 0xc(%rsp)
movzbl 0x8(%rsi), %r15d
movzbl 0x9(%rsi), %r12d
movzwl 0xc(%rsi), %eax
movq %rax, 0x10(%rsp)
movzwl 0xe(%rsi), %r14d
leaq 0x10(%rsi), %r13
movl $0x18, %edi
callq 0x2240
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movl %r12d, %edx
movq %r13, %rcx
movl 0xc(%rsp), %r8d
movl %r15d, %r9d
pushq %r14
pushq 0x18(%rsp)
callq 0x2882
addq $0x10, %rsp
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2260
movq %r14, %rdi
callq 0x2380
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::sendSegments(unsigned char*, int, sockaddr_storage, int)
|
bool
ServerService::sendSegments(byte *data, int socketFD, struct sockaddr_storage clientDetails, int recvWindowSize) {
byte4 initSeqNo = rand() % 100;
byte4 seqNo = initSeqNo;
byte4 sendBase = initSeqNo;
byte *buffer = (byte *) calloc(MTU, sizeof(byte));
memset(buffer, 0, MTU);
//使用序号获取 udp
auto *sendUnit = new SendUnit(initSeqNo, data);
auto *congestion = new Congestion(recvWindowSize);
// 丢包数
int packetDropped = 0;
//数据分段数量
int packetNumber = (int) (sendUnit->dataSize / (MTU - HEADER_LEN)) + 1;
fd_set readFDs; // fd_set 来存储文件描述符, 用于使用多个套接字时不阻塞线程
FD_ZERO(&readFDs); //FD_ZERO宏将一个 fd_set 类型变量的所有位都设为 0
FD_SET(socketFD, &readFDs);
int nextFD = socketFD + 1;
byte4 ackNo;
struct timeval timeValue;
timeValue.tv_sec = 0; //秒
timeValue.tv_usec = INIT_SEC; //微秒
//双端队列实现滑动窗口
deque<Sliding *> window;
window.clear();
int readyDescriptors; // -1 -> Error
int sendDataNum; // 单次需要发送数据段数量
int SlideWindowDataNum = 0;
int left = 0;
while (true) {
sendDataNum = (int) min(congestion->cwnd, (double) recvWindowSize);
if (congestion->isSlowStart) {
cout << "Sending Packets in mode: Slow Start" << endl;
cout << "Maximum Packets that will be sent:" << sendDataNum << endl;
} else {
cout << "Sending Packets in mode: Congestion Avoidance" << endl;
cout << "Maximum Packets that will be sent:" << sendDataNum << endl;
}
cout << "RetransmissionTime-Out: " << congestion->RTO << endl;
window.clear();
//向滑动窗格填充数据
while (sendDataNum != 0 && (seqNo - initSeqNo) < sendUnit->dataSize) {
buffer = sendUnit->getSendUnit(seqNo);
sendResponse(socketFD, buffer, clientDetails);
window.push_back(new Sliding(sendUnit->getRUDP(seqNo), getTime()));
seqNo += (MTU - HEADER_LEN);
sendDataNum--;
}
//获取滑动窗格分组数
SlideWindowDataNum = (int) window.size();
FD_ZERO(&readFDs);
FD_SET(socketFD, &readFDs);
if (timeValue.tv_usec != 0 && timeValue.tv_sec != 0) {
timeValue.tv_sec = (long) congestion->RTO / NANO_SEC;
timeValue.tv_usec = (congestion->RTO) * 1000 - timeValue.tv_sec;
}
while (true) {
readyDescriptors = select(nextFD, &readFDs, NULL, NULL, &timeValue);
if (readyDescriptors == -1) {
cout << "Error in Select" << endl;
cerr << strerror(errno) << endl;
exit(5);
} else if (readyDescriptors > 0) {
// ACK 判断
ackNo = readAck(socketFD, clientDetails);
cout << "Ack Event " << endl;
if (sendBase < ackNo) {
// 创建新 ACK
cout << "New ACK: " << ackNo << endl;
sendBase = ackNo;
if (window.size() > 0 && sendBase - (MTU - HEADER_LEN) >= window.front()->seqNo) {
while (!window.empty()) {
if (window.front()->seqNo < sendBase && window.front()->mark == false) {
congestion->updateRTT(window.front()->sentTime, getTime());
window.pop_front();
} else {
break;
}
}
}
if (window.size() == 0) {
left = 0;
if (congestion->cwnd >= congestion->ssthresh && congestion->ssthresh != -1) {
congestion->isSlowStart = false; // congestion avoidance
cout << "Entering Congestion Avoidance mode" << endl;
}
if (congestion->isSlowStart) {
congestion->updateSlowStart();
} else {
congestion->updateCongestionAvoidance();
}
break;
}
} else {
// 重复的 ACK 确认
congestion->dupAck++;
cout << "Dup ACK: " << ackNo << " ACK Count:" << congestion->dupAck << endl;
if (congestion->dupAck >= 3) {
// 三次收到重复 ACK 后立即重传
retransmit(ackNo, socketFD, clientDetails, sendUnit);
congestion->updateRTO();
packetDropped++;
cout << "Retransmitting : " << ackNo << endl;
if (window.size() != 0) {
if (!window.front()->mark) {
for (int i = 0; i < window.size() - 1; i++) {
window[i]->mark = true;
}
}
}
congestion->slowStart();
congestion->dupAck = 0;
left = window.size();
}
}
} else if (readyDescriptors == 0) {
// 超时
cout << "Timeout Event " << endl;
if (timeValue.tv_sec == 0 && timeValue.tv_usec == 0) {
// Loss occurred go back to slow start
packetDropped += window.size();
if (window.size() != 0) {
left = window.size();
retransmit(ackNo, socketFD, clientDetails, sendUnit);
cout << "Retransmitting : " << window.front()->seqNo << endl;
window.clear();
}
congestion->slowStart();
}
break;
}
}
cout << "Percentage of Packets Sent: " << SlideWindowDataNum - left << "/" << SlideWindowDataNum << " = "
<< ((float) (SlideWindowDataNum - left) / SlideWindowDataNum) * 100 << endl;
SlideWindowDataNum = 0, left = 0;
if ((seqNo - initSeqNo) > sendUnit->dataSize || (ackNo - initSeqNo) > sendUnit->dataSize) {
cout << endl << "Last Packet has been delivered & All ACKs have been received" << endl;
break;
}
}
memset(buffer, 0, MTU);
delete sendUnit;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r15
callq 0x20c0
movslq %eax, %r13
imulq $0x51eb851f, %r13, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %r13d
movl $0x5c0, %edi # imm = 0x5C0
movl $0x1, %esi
callq 0x2180
movq %rax, %rbx
movl $0x5c0, %edx # imm = 0x5C0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2160
movl $0x20, %edi
callq 0x2240
movq %rax, %r14
movq %rax, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x2948
movq %r13, 0x130(%rsp)
movq %rbx, 0xf8(%rsp)
movq %r14, 0x148(%rsp)
movl $0x38, %edi
callq 0x2240
movq %rax, 0x98(%rsp)
movq %rax, %rdi
movl %ebp, 0x138(%rsp)
movl %ebp, %esi
callq 0x2bdc
xorps %xmm0, %xmm0
movaps %xmm0, 0x1e0(%rsp)
movaps %xmm0, 0x1d0(%rsp)
movaps %xmm0, 0x1c0(%rsp)
movaps %xmm0, 0x1b0(%rsp)
movaps %xmm0, 0x1a0(%rsp)
movaps %xmm0, 0x190(%rsp)
movaps %xmm0, 0x180(%rsp)
movaps %xmm0, 0x170(%rsp)
leal 0x3f(%r12), %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
movl %eax, %edx
andl $-0x40, %edx
movq %r12, 0x110(%rsp)
movl %r12d, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
movq %rdx, 0x160(%rsp)
movq %rax, 0x158(%rsp)
orq %rdx, 0x170(%rsp,%rax,8)
movq $0x0, 0x120(%rsp)
movq $0xc350, 0x128(%rsp) # imm = 0xC350
leaq 0xa0(%rsp), %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0x49b6
movq 0x10(%r15), %r14
movq 0x18(%r15), %r13
movq 0x20(%r15), %rbp
movq 0x28(%r15), %rbx
movq 0x48(%r15), %r15
cmpq %r15, %rbx
jae 0x31fa
movq %rbx, %r12
movq 0x8(%r12), %rdi
addq $0x8, %r12
movl $0x200, %esi # imm = 0x200
callq 0x2260
cmpq %r15, %r12
jb 0x31e2
movq 0x110(%rsp), %rax
incl %eax
movl %eax, 0x144(%rsp)
leaq 0xa0(%rsp), %rax
movq %r14, 0x30(%rax)
movq %r13, 0x38(%rax)
movq %rbp, 0x40(%rax)
movq %rbx, 0x48(%rax)
xorps %xmm0, %xmm0
cvtsi2sdl 0x138(%rsp), %xmm0
movsd %xmm0, 0x168(%rsp)
movq 0x130(%rsp), %rax
movl %eax, %ecx
negl %ecx
movq %rcx, 0x138(%rsp)
movl %eax, 0x8c(%rsp)
movq %rax, 0x118(%rsp)
movq 0xf8(%rsp), %r14
movsd 0x168(%rsp), %xmm0
movq 0x98(%rsp), %rax
minsd (%rax), %xmm0
cvttsd2si %xmm0, %ebx
cmpb $0x1, 0x18(%rax)
jne 0x3312
movl $0x23, %edx
movq 0x4d3e(%rip), %rdi # 0x7fd0
leaq 0x1f2d(%rip), %rsi # 0x51c6
callq 0x2290
movq 0x4d2b(%rip), %rcx # 0x7fd0
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq 0x4d0d(%rip), %rdi # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movl $0x22, %edx
movq 0x4cf4(%rip), %rdi # 0x7fd0
leaq 0x1f07(%rip), %rsi # 0x51ea
callq 0x2290
movq 0x4ce1(%rip), %rdi # 0x7fd0
movl %ebx, %esi
callq 0x2360
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
jmp 0x3399
movl $0x2d, %edx
movq 0x4cb2(%rip), %rdi # 0x7fd0
leaq 0x1ee8(%rip), %rsi # 0x520d
callq 0x2290
movq 0x4c9f(%rip), %rcx # 0x7fd0
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq 0x4c81(%rip), %rdi # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movl $0x22, %edx
movq 0x4c68(%rip), %rdi # 0x7fd0
leaq 0x1e7b(%rip), %rsi # 0x51ea
callq 0x2290
movq 0x4c55(%rip), %rdi # 0x7fd0
movl %ebx, %esi
callq 0x2360
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movl $0x18, %edx
movq 0x4c18(%rip), %rdi # 0x7fd0
leaq 0x1e7c(%rip), %rsi # 0x523b
callq 0x2290
movq 0x98(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x4bf8(%rip), %rdi # 0x7fd0
callq 0x2320
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq %r12, 0x100(%rsp)
movq %r14, 0xf8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0xb8(%rsp), %r13
movq 0xc0(%rsp), %rbp
movq 0xc8(%rsp), %r15
movq 0xe8(%rsp), %r14
cmpq %r14, %r15
jae 0x3467
movq %r15, %r12
movq 0x8(%r12), %rdi
addq $0x8, %r12
movl $0x200, %esi # imm = 0x200
callq 0x2260
cmpq %r14, %r12
jb 0x344f
movq 0x108(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq %r13, 0xd8(%rsp)
movq %rbp, 0xe0(%rsp)
movq %r15, 0xe8(%rsp)
testl %ebx, %ebx
je 0x35e1
movq 0x118(%rsp), %r12
movl %r12d, %eax
subl 0x130(%rsp), %eax
movq 0x148(%rsp), %rbp
cmpq %rax, (%rbp)
jbe 0x35fb
addl $0x5b0, %r12d # imm = 0x5B0
movl %r12d, %eax
movq %rax, %r12
leal -0x5b0(%rax), %r13d
movq %rbp, %rdi
movl %r13d, %esi
callq 0x2aae
movq %rax, %r14
movl $0x10, %ecx
leaq 0x1f8(%rsp), %r8
movq %r8, %rdi
leaq 0x330(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movl $0x5c0, %edx # imm = 0x5C0
movq 0x110(%rsp), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x80, %r9d
callq 0x2060
movl $0x18, %edi
callq 0x2240
movq %rax, %r15
movq %rbp, %rdi
movl %r13d, %esi
callq 0x29c6
movq %rax, %r13
movl $0x1, %edi
leaq 0x1f8(%rsp), %rsi
callq 0x2200
movabsq $0x112e0be826d694b3, %rax # imm = 0x112E0BE826D694B3
imulq 0x200(%rsp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
addq 0x1f8(%rsp), %rdx
cvtsi2sd %rdx, %xmm0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2cf0
movq %r15, 0x278(%rsp)
movq 0xd0(%rsp), %rax
movq 0xe0(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x35a9
movq %r15, (%rax)
addq $0x8, 0xd0(%rsp)
jmp 0x35be
leaq 0xa0(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x4b7c
decl %ebx
je 0x3603
leal 0x5b0(%r12), %eax
movq 0x138(%rsp), %rcx
addl %r12d, %ecx
cmpq %rcx, (%rbp)
ja 0x34c5
jmp 0x3603
movq 0x148(%rsp), %rbp
movq 0xf8(%rsp), %r14
movq 0x118(%rsp), %r12
jmp 0x3603
movq 0xf8(%rsp), %r14
movq %r12, 0x118(%rsp)
movq 0xe8(%rsp), %rax
movq 0xc0(%rsp), %rdi
movq 0xd0(%rsp), %rcx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x170(%rsp)
movapd %xmm0, 0x180(%rsp)
movapd %xmm0, 0x190(%rsp)
movapd %xmm0, 0x1a0(%rsp)
movapd %xmm0, 0x1b0(%rsp)
movapd %xmm0, 0x1c0(%rsp)
movapd %xmm0, 0x1d0(%rsp)
movl 0xc8(%rsp), %edx
movl %eax, %esi
subl %edx, %esi
shrl $0x3, %esi
cmpq $0x1, %rax
adcl $-0x1, %esi
subq 0xd8(%rsp), %rcx
movapd %xmm0, 0x1e0(%rsp)
movq 0x160(%rsp), %rax
movq 0x158(%rsp), %rdx
orq %rax, 0x170(%rsp,%rdx,8)
subq 0xb0(%rsp), %rdi
cmpq $0x0, 0x128(%rsp)
movq 0x98(%rsp), %rbx
je 0x3715
cmpq $0x0, 0x120(%rsp)
je 0x3715
movsd 0x30(%rbx), %xmm0
cvttsd2si %xmm0, %rax
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
movq %rdx, 0x120(%rsp)
cvtsi2sd %rdx, %xmm1
mulsd 0x1a1c(%rip), %xmm0 # 0x5120
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x128(%rsp)
shll $0x6, %esi
shrq $0x3, %rcx
shrq $0x3, %rdi
addl %ecx, %edi
addl %esi, %edi
movq %rdi, 0x108(%rsp)
movq $0x0, 0x90(%rsp)
movq 0x100(%rsp), %r12
movl 0x144(%rsp), %edi
leaq 0x170(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq 0x120(%rsp), %r8
callq 0x2210
cmpl $-0x1, %eax
je 0x4116
testl %eax, %eax
jg 0x3774
jne 0x3740
jmp 0x3c83
movl $0x10, %ecx
movq %rsp, %rdi
leaq 0x330(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x110(%rsp), %rsi
callq 0x4444
movl %eax, %r12d
movl $0xa, %edx
movq 0x482d(%rip), %rdi # 0x7fd0
leaq 0x1aba(%rip), %rsi # 0x5264
callq 0x2290
movq 0x481a(%rip), %rcx # 0x7fd0
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq 0x47fc(%rip), %rdi # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x21a0
cmpl %r12d, 0x8c(%rsp)
jb 0x3a75
incl 0x14(%rbx)
movl $0x9, %edx
movq 0x47d2(%rip), %rdi # 0x7fd0
leaq 0x1a97(%rip), %rsi # 0x529c
callq 0x2290
movl %r12d, %r15d
movq 0x47bc(%rip), %rdi # 0x7fd0
movq %r15, %rsi
callq 0x2190
movq %rax, %r13
movl $0xb, %edx
movq %rax, %rdi
leaq 0x1a78(%rip), %rsi # 0x52a6
callq 0x2290
movl 0x14(%rbx), %esi
movq %r13, %rdi
callq 0x2360
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
cmpl $0x3, 0x14(%rbx)
jl 0x3740
movl $0x10, %ecx
leaq 0x278(%rsp), %rdi
leaq 0x330(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r12d, %esi
callq 0x2aae
movq %rax, %r13
movl $0x10, %ecx
leaq 0x1f8(%rsp), %r8
movq %r8, %rdi
leaq 0x278(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movl $0x5c0, %edx # imm = 0x5C0
movq 0x110(%rsp), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x80, %r9d
callq 0x2060
movl $0x5c0, %edx # imm = 0x5C0
movq %r13, %rdi
xorl %esi, %esi
callq 0x2160
movq %r13, %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2c82
movl $0x11, %edx
movq 0x46d5(%rip), %rdi # 0x7fd0
leaq 0x19b0(%rip), %rsi # 0x52b2
callq 0x2290
movq 0x46c2(%rip), %rdi # 0x7fd0
movq %r15, %rsi
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0xe8(%rsp), %rcx
movq 0xc8(%rsp), %rax
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0xd0(%rsp), %rsi
subq 0xd8(%rsp), %rsi
shlq $0x6, %rdx
sarq $0x3, %rsi
addq %rdx, %rsi
movq 0xb0(%rsp), %rcx
movq 0xc0(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
addq %rsi, %rdx
je 0x3a0d
movq (%rcx), %rsi
cmpb $0x0, 0x14(%rsi)
jne 0x3a0d
decq %rdx
je 0x3a0d
movq %rcx, %rsi
subq 0xb8(%rsp), %rsi
sarq $0x3, %rsi
movq %rsi, %rdi
xorl %r8d, %r8d
movq %rcx, %r9
cmpq $0x40, %rdi
jb 0x39f6
leaq (%rsi,%r8), %r9
movq %rdi, %r10
shrq $0x6, %r10
movabsq $-0x400000000000000, %r11 # imm = 0xFC00000000000000
addq %r10, %r11
testq %rdi, %rdi
cmovgq %r10, %r11
movq %r11, %r10
shlq $0x6, %r10
subq %r10, %r9
shlq $0x3, %r9
addq (%rax,%r11,8), %r9
movq (%r9), %r9
movb $0x1, 0x14(%r9)
incq %r8
addq $0x8, %rcx
incq %rdi
decq %rdx
jne 0x39bc
movq %rbx, %rdi
callq 0x2c92
movq 0xe8(%rsp), %rax
movl 0xc8(%rsp), %ecx
movl %eax, %edx
subl %ecx, %edx
shrl $0x3, %edx
cmpq $0x1, %rax
adcl $-0x1, %edx
movl $0x0, 0x14(%rbx)
shll $0x6, %edx
movq 0xc0(%rsp), %rcx
movq 0xd0(%rsp), %rax
subq 0xd8(%rsp), %rax
subq 0xb0(%rsp), %rcx
shrq $0x3, %rax
shrq $0x3, %rcx
addl %eax, %ecx
addl %edx, %ecx
movq %rcx, 0x90(%rsp)
jmp 0x3740
movl $0x9, %edx
movq 0x454f(%rip), %rdi # 0x7fd0
leaq 0x17e7(%rip), %rsi # 0x526f
callq 0x2290
movl %r12d, %esi
movq 0x4539(%rip), %rdi # 0x7fd0
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0xe8(%rsp), %rax
movq %rax, %rcx
subq 0xc8(%rsp), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0xd0(%rsp), %rdx
subq 0xd8(%rsp), %rdx
shlq $0x6, %rcx
sarq $0x3, %rdx
addq %rcx, %rdx
movq 0xb0(%rsp), %rax
movq 0xc0(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq %rdx, %rcx
je 0x3b2c
leal -0x5b0(%r12), %ecx
movq (%rax), %rax
cmpl 0x10(%rax), %ecx
jae 0x3b90
movq 0xe8(%rsp), %rax
movq %rax, %rcx
subq 0xc8(%rsp), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0xd0(%rsp), %rax
subq 0xd8(%rsp), %rax
movq 0xc0(%rsp), %rdx
sarq $0x3, %rax
subq 0xb0(%rsp), %rdx
addq %rcx, %rax
sarq $0x3, %rdx
movl %r12d, 0x8c(%rsp)
addq %rax, %rdx
jne 0x3740
jmp 0x3fc8
movq 0xb0(%rsp), %rax
cmpq %rax, 0xd0(%rsp)
je 0x3b2c
movq (%rax), %rax
cmpl %r12d, 0x10(%rax)
jae 0x3b2c
cmpb $0x0, 0x14(%rax)
jne 0x3b2c
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x100(%rsp)
movl $0x1, %edi
leaq 0x1f8(%rsp), %rsi
callq 0x2200
movabsq $0x112e0be826d694b3, %rax # imm = 0x112E0BE826D694B3
imulq 0x200(%rsp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
addq 0x1f8(%rsp), %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rdx, %xmm1
movq %rbx, %rdi
movsd 0x100(%rsp), %xmm0
callq 0x2c1c
movq 0xb0(%rsp), %rax
movq 0xc0(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x3c35
addq $0x8, %rax
jmp 0x3c76
movq 0xb8(%rsp), %rdi
movl $0x200, %esi # imm = 0x200
callq 0x2260
movq 0xc8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0xc8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0xc0(%rsp)
movq %rax, 0xb0(%rsp)
jmp 0x3b98
movl $0xe, %edx
movq 0x4341(%rip), %rdi # 0x7fd0
leaq 0x162e(%rip), %rsi # 0x52c4
callq 0x2290
movq 0x432e(%rip), %rcx # 0x7fd0
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq 0x4310(%rip), %rdi # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0x128(%rsp), %rax
orq 0x120(%rsp), %rax
jne 0x3ec8
movq 0xe8(%rsp), %rax
movq %rax, %rcx
subq 0xc8(%rsp), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0xc0(%rsp), %r13
movq 0xd0(%rsp), %rax
subq 0xd8(%rsp), %rax
subq 0xb0(%rsp), %r13
sarq $0x3, %rax
sarq $0x3, %r13
addq %rax, %r13
addq %rcx, %r13
je 0x3ebb
movl $0x10, %ecx
leaq 0x278(%rsp), %rdi
leaq 0x330(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r12d, %esi
callq 0x2aae
movq %rax, %r15
movl $0x10, %ecx
leaq 0x1f8(%rsp), %r8
movq %r8, %rdi
leaq 0x278(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movl $0x5c0, %edx # imm = 0x5C0
movq 0x110(%rsp), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x80, %r9d
callq 0x2060
movl $0x5c0, %edx # imm = 0x5C0
movq %r15, %rdi
xorl %esi, %esi
callq 0x2160
movq %r15, %rdi
callq 0x22a0
movl $0x11, %edx
movq 0x4215(%rip), %rdi # 0x7fd0
leaq 0x14f0(%rip), %rsi # 0x52b2
callq 0x2290
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq 0x41f4(%rip), %rdi # 0x7fd0
callq 0x2190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq %r12, 0x100(%rsp)
movq %r14, 0xf8(%rsp)
movq 0xb0(%rsp), %r15
movq 0xb8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0xc8(%rsp), %rbx
movq 0xe8(%rsp), %r14
cmpq %r14, %rbx
jae 0x3e73
movq %rbx, %r12
movq 0x8(%r12), %rdi
addq $0x8, %r12
movl $0x200, %esi # imm = 0x200
callq 0x2260
cmpq %r14, %r12
jb 0x3e5b
movq %r15, 0xd0(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq %rbx, 0xe8(%rsp)
movq %r13, 0x90(%rsp)
movq 0xf8(%rsp), %r14
movq 0x100(%rsp), %r12
movq 0x98(%rsp), %rdi
callq 0x2c92
movl $0x1c, %edx
movq 0x40fc(%rip), %rdi # 0x7fd0
leaq 0x13f8(%rip), %rsi # 0x52d3
callq 0x2290
movq 0x108(%rsp), %rax
movl %eax, %r15d
subl 0x90(%rsp), %r15d
movq 0x40d6(%rip), %rdi # 0x7fd0
movl %r15d, %esi
callq 0x2360
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x13dc(%rip), %rsi # 0x52f0
callq 0x2290
movq %r13, %rdi
movq 0x108(%rsp), %rsi
callq 0x2360
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x13b7(%rip), %rsi # 0x52f2
callq 0x2290
xorps %xmm0, %xmm0
cvtsi2ss %r15d, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x108(%rsp), %xmm1
divss %xmm1, %xmm0
mulss 0x11d0(%rip), %xmm0 # 0x5130
cvtss2sd %xmm0, %xmm0
movq %r13, %rdi
callq 0x2320
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0x118(%rsp), %rcx
movq 0x130(%rsp), %rdx
subl %edx, %ecx
movq (%rbp), %rax
cmpq %rcx, %rax
jb 0x406c
movl %r12d, %ecx
subl %edx, %ecx
cmpq %rcx, %rax
jae 0x3263
jmp 0x406c
movsd (%rbx), %xmm1
movsd 0x8(%rbx), %xmm0
ucomisd %xmm0, %xmm1
jb 0x4039
ucomisd 0x1149(%rip), %xmm0 # 0x5128
jne 0x3fe3
jnp 0x4039
movq 0x98(%rsp), %rax
movb $0x0, 0x18(%rax)
movl $0x22, %edx
movq 0x3fd5(%rip), %rdi # 0x7fd0
leaq 0x1277(%rip), %rsi # 0x5279
callq 0x2290
movq 0x3fc2(%rip), %rcx # 0x7fd0
movq (%rcx), %rax
movq -0x18(%rax), %rdi
addq %rcx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq 0x3fa4(%rip), %rdi # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0x98(%rsp), %rdi
cmpb $0x1, 0x18(%rdi)
jne 0x404e
callq 0x2cbc
jmp 0x4053
callq 0x2cd4
movq $0x0, 0x90(%rsp)
movl %r12d, 0x8c(%rsp)
jmp 0x3ec8
movq 0x3f5d(%rip), %rdi # 0x7fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq 0x3f42(%rip), %rdi # 0x7fd0
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq %rax, %rbx
leaq 0x1251(%rip), %rsi # 0x52f6
movl $0x3c, %edx
movq %rax, %rdi
callq 0x2290
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movl $0x5c0, %edx # imm = 0x5C0
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movl $0x20, %esi
movq %rbp, %rdi
callq 0x2260
leaq 0xa0(%rsp), %rdi
callq 0x4b2c
movb $0x1, %al
addq $0x2f8, %rsp # imm = 0x2F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3eb3(%rip), %rdi # 0x7fd0
leaq 0x1130(%rip), %rsi # 0x5254
movl $0xf, %edx
callq 0x2290
movq 0x3e9b(%rip), %rdi # 0x7fd0
callq 0x2140
callq 0x2040
movl (%rax), %edi
callq 0x20f0
movq 0x3ea3(%rip), %rdi # 0x7ff0
movq %rax, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x2140
movl $0x5, %edi
callq 0x22b0
movq %rax, %rbx
movl $0x38, %esi
movq 0x98(%rsp), %rdi
jmp 0x4184
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x2260
jmp 0x41bd
jmp 0x41ad
jmp 0x41ad
jmp 0x41ad
jmp 0x41ad
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x2260
jmp 0x41b0
jmp 0x41ad
jmp 0x41ad
jmp 0x41ad
jmp 0x41ad
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x4b2c
movq %rbx, %rdi
callq 0x2380
nop
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::startControlService()
|
ServerSegment* ServerService::startControlService() {
socklen_t clientLength;
struct sockaddr_storage clientDetails;
byte buffer[MTU];
bzero(buffer, MTU);
clientLength = sizeof(clientDetails);
recvfrom(serverSocketUDP->getSocket(), buffer, MTU, 0, (struct sockaddr *) &clientDetails, &clientLength);
ServerSegment *segment = parseRequest(buffer);
if (segment->data && segment->ackFlag == 'N') {
cout << "received: ";
cout << (char *) segment->data << endl;
return segment;
} else {
return nullptr;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x650, %rsp # imm = 0x650
movq %rdi, %r14
leaq 0x90(%rsp), %rbx
movl $0x5c0, %edx # imm = 0x5C0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2160
leaq 0xc(%rsp), %r15
movl $0x80, (%r15)
movq 0x10(%r14), %rdi
callq 0x2870
leaq 0x10(%rsp), %r8
movl $0x5c0, %edx # imm = 0x5C0
movl %eax, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
movq %r15, %r9
callq 0x21c0
movq %rbx, %rsi
callq 0x2fc0
cmpq $0x0, 0x10(%rax)
je 0x4272
movq %rax, %rbx
cmpb $0x4e, 0x8(%rax)
jne 0x4272
movq 0x3d97(%rip), %r14 # 0x7fd0
leaq 0xf7b(%rip), %rsi # 0x51bb
movl $0xa, %edx
movq %r14, %rdi
callq 0x2290
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x4276
movq %r15, %rdi
callq 0x2130
movq 0x3d6b(%rip), %rdi # 0x7fd0
movq %r15, %rsi
movq %rax, %rdx
callq 0x2290
jmp 0x428e
xorl %ebx, %ebx
jmp 0x42b5
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2350
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq %rbx, %rax
addq $0x650, %rsp # imm = 0x650
popq %rbx
popq %r14
popq %r15
retq
nop
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::startControlServiceWithResult(int, unsigned char* (*)(int, unsigned char*))
|
void ServerService::startControlServiceWithResult(int fd, byte* (* pFunction)(int, byte* )) {
socklen_t clientLength;
struct sockaddr_storage clientDetails;
byte buffer[MTU];
bzero(buffer, MTU);
clientLength = sizeof(clientDetails);
recvfrom(serverSocketUDP->getSocket(), buffer, MTU, 0, (struct sockaddr *) &clientDetails, &clientLength);
ServerSegment *segment = parseRequest(buffer);
if (segment->data && segment->ackFlag == 'N') {
cout << "received: ";
cout << (char *) segment->data << endl;
sendSegments(pFunction(fd, segment->data), serverSocketUDP->getSocket(), clientDetails, receiverWindowSize);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6d8, %rsp # imm = 0x6D8
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x110(%rsp), %r15
movl $0x5c0, %edx # imm = 0x5C0
movq %r15, %rdi
xorl %esi, %esi
callq 0x2160
leaq 0x8c(%rsp), %r12
movl $0x80, (%r12)
movq 0x10(%rbx), %rdi
callq 0x2870
leaq 0x90(%rsp), %r8
movl $0x5c0, %edx # imm = 0x5C0
movl %eax, %edi
movq %r15, %rsi
xorl %ecx, %ecx
movq %r12, %r9
callq 0x21c0
movq %r15, %rsi
callq 0x2fc0
cmpq $0x0, 0x10(%rax)
je 0x4408
movq %rax, %r15
cmpb $0x4e, 0x8(%rax)
jne 0x4408
movq 0x3c7e(%rip), %r12 # 0x7fd0
leaq 0xe62(%rip), %rsi # 0x51bb
movl $0xa, %edx
movq %r12, %rdi
callq 0x2290
movq 0x10(%r15), %r13
testq %r13, %r13
je 0x438b
movq %r13, %rdi
callq 0x2130
movq 0x3c52(%rip), %rdi # 0x7fd0
movq %r13, %rsi
movq %rax, %rdx
callq 0x2290
jmp 0x43a4
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x2350
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movq 0x10(%r15), %rsi
movl %ebp, %edi
callq *%r14
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x2870
movl 0x8(%rbx), %r8d
leaq 0x90(%rsp), %rsi
movl $0x10, %ecx
movq %rsp, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
movl %r8d, %ecx
callq 0x304c
addq $0x6d8, %rsp # imm = 0x6D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::readAck(int, sockaddr_storage)
|
byte4 ServerService::readAck(int socketFD, struct sockaddr_storage clientDetails) {
byte *buffer = (byte *) calloc(MTU, sizeof(byte));
socklen_t clientLength = sizeof(clientDetails);
memset(buffer, 0, MTU);
if (recvfrom(socketFD, buffer, MTU, 0, (struct sockaddr *) &clientDetails, &clientLength)) {
ServerSegment *temp = parseRequest(buffer);
if (temp->ackFlag == TRUE) {
free(buffer);
return temp->ackNumber;
}
delete temp;
} else {
//若 ack 标志位为 FALSE 则直接丢弃
free(buffer);
}
return 0;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movl $0x5c0, %edi # imm = 0x5C0
movl $0x1, %esi
callq 0x2180
movq %rax, %rbx
leaq 0xc(%rsp), %r14
movl $0x80, (%r14)
movl $0x5c0, %edx # imm = 0x5C0
movq %rax, %rdi
xorl %esi, %esi
callq 0x2160
leaq 0x30(%rsp), %r8
movl $0x5c0, %edx # imm = 0x5C0
movl %ebp, %edi
movq %rbx, %rsi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x21c0
testq %rax, %rax
je 0x44bc
movq %rbx, %rsi
callq 0x2fc0
movq %rax, %r14
movb 0x8(%rax), %bpl
cmpb $0x59, %bpl
jne 0x44c6
movq %rbx, %rdi
callq 0x22a0
movl 0x4(%r14), %eax
jmp 0x44d3
movq %rbx, %rdi
callq 0x22a0
jmp 0x44d9
movl $0x18, %esi
movq %r14, %rdi
callq 0x2260
cmpb $0x59, %bpl
je 0x44db
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::retransmit(unsigned int, int, sockaddr_storage, SendUnit*)
|
void ServerService::retransmit(byte4 seqNo, int socketFD, struct sockaddr_storage clientDetails, SendUnit *sendUnit) {
byte *buffer = (byte *) calloc(MTU, sizeof(byte));
memset(buffer, 0, MTU);
buffer = sendUnit->getSendUnit(seqNo);
sendResponse(socketFD, buffer, clientDetails);
memset(buffer, 0, MTU);
free(buffer);
}
|
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rcx, %rdi
callq 0x2aae
movq %rax, %r14
leaq 0x8(%rsp), %r8
leaq 0xa0(%rsp), %rsi
movl $0x10, %ecx
movq %r8, %rdi
rep movsq (%rsi), %es:(%rdi)
movl $0x5c0, %edx # imm = 0x5C0
movl %ebx, %edi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x80, %r9d
callq 0x2060
movl $0x5c0, %edx # imm = 0x5C0
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
movq %r14, %rdi
callq 0x22a0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::initBroadcast(int)
|
struct sockaddr_in ServerService::initBroadcast(int port) {
struct sockaddr_in peerAddr;
const int opt = 1;
int ret = 0;
bzero(&peerAddr, sizeof(struct sockaddr_in));
peerAddr.sin_family = AF_INET;
peerAddr.sin_port = htons(port);
peerAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
broadcastFD = socket(AF_INET, SOCK_DGRAM, 0);
if (broadcastFD == -1) {
cout << "Create Broadcast Socket Fail" << endl;
exit(1);
}
ret = setsockopt(broadcastFD, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt));
if (ret == -1) {
cout << "Set Socket To Broadcast Format Fail" << endl;
exit(2);
}
return peerAddr;
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, 0x4(%rsp)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x20a0
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x45f5
leaq 0x4(%rsp), %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x2390
cmpl $-0x1, %eax
je 0x461a
rolw $0x8, %bx
shll $0x10, %ebx
movabsq $-0xfffffffe, %rax # imm = 0xFFFFFFFF00000002
orq %rbx, %rax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x39d4(%rip), %rdi # 0x7fd0
leaq 0xd30(%rip), %rsi # 0x5333
callq 0x2230
movq %rax, %rdi
callq 0x2140
movl $0x1, %edi
callq 0x22b0
movq 0x39af(%rip), %rdi # 0x7fd0
leaq 0xd28(%rip), %rsi # 0x5350
callq 0x2230
movq %rax, %rdi
callq 0x2140
movl $0x2, %edi
callq 0x22b0
nop
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::startBroadcast(sockaddr_in*, char*, int)
|
void ServerService::startBroadcast(struct sockaddr_in *peerAddr, char* msg, int sleepSecond) {
// char msg[100] = "Msg from udp broadcast client!";
if (-1 != sendto(broadcastFD, msg, sizeof(msg), 0, (struct sockaddr *) peerAddr, sizeof(struct sockaddr_in))) {
cout << "Send Broadcast Success" << endl;
} else {
cout << "Send Broadcast Error" << endl;
}
sleep(sleepSecond);
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %rax
movq %rsi, %r8
movl (%rdi), %edi
movl $0x8, %edx
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
movq 0x3966(%rip), %rdi # 0x7fd0
cmpq $-0x1, %rax
je 0x467e
leaq 0xcfd(%rip), %rsi # 0x5374
movl $0x16, %edx
jmp 0x468a
leaq 0xd06(%rip), %rsi # 0x538b
movl $0x14, %edx
callq 0x2290
movq 0x393a(%rip), %r14 # 0x7fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
nop
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
ServerService::receiveBroadcast(int, char*)
|
void ServerService::receiveBroadcast(int port, char* message) {
struct sockaddr_in ownAddr, peerAddr;
char recvMsg[200] = {0};
socklen_t peerAddrLen = 0;
char peerName[30] = {0};
int ret = 0;
bzero(&ownAddr, sizeof(struct sockaddr_in));
bzero(&peerAddr, sizeof(struct sockaddr_in));
ownAddr.sin_family = AF_INET;
ownAddr.sin_port = htons(port);
ownAddr.sin_addr.s_addr = htonl(INADDR_ANY);
broadcastFD = socket(AF_INET, SOCK_DGRAM, 0);
if (broadcastFD == -1) {
cout << "Create Broadcast Sock Fail" << endl;
return;
}
ret = bind(broadcastFD, (struct sockaddr *) &ownAddr, sizeof(struct sockaddr_in));
if (ret == -1) {
cout << "Bind Broadcast Address Fail" << endl;
return;
}
while (true) {
ret = recvfrom(broadcastFD, recvMsg, sizeof(recvMsg), 0, (struct sockaddr *) &peerAddr, &peerAddrLen);
if (ret > 0) {
inet_ntop(AF_INET, &peerAddr.sin_addr.s_addr, peerName, sizeof(peerName));
if (!strcmp("0.0.0.0", peerName)) {
continue;
} else {
printf("Receive from %s, msg:%s\n", peerName, recvMsg);
memcpy(message, peerName, strlen(peerName));
break;
}
} else {
cout << "Receive Broadcast Message Error" << endl;
}
}
bzero(recvMsg, sizeof(recvMsg));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x60(%rsp), %rdi
xorl %ebp, %ebp
movl $0xc8, %edx
xorl %esi, %esi
callq 0x2160
movl %ebp, 0xc(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x4e(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movw $0x2, 0x10(%rsp)
rolw $0x8, %bx
movw %bx, 0x12(%rsp)
movl %ebp, 0x14(%rsp)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x20a0
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x4848
leaq 0x10(%rsp), %rsi
movl %eax, %edi
movl $0x10, %edx
callq 0x2080
cmpl $-0x1, %eax
je 0x489b
movq %r15, 0x28(%rsp)
leaq 0x60(%rsp), %r12
leaq 0x30(%rsp), %r13
leaq 0xc(%rsp), %rbp
movabsq $0x302e302e302e30, %rbx # imm = 0x302E302E302E30
movq 0x384d(%rip), %r15 # 0x7fd0
movl (%r14), %edi
movl $0xc8, %edx
movq %r12, %rsi
xorl %ecx, %ecx
movq %r13, %r8
movq %rbp, %r9
callq 0x21c0
testl %eax, %eax
jle 0x47c1
movl $0x2, %edi
leaq 0x34(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl $0x1e, %ecx
callq 0x2270
cmpq %rbx, 0x40(%rsp)
je 0x4783
jmp 0x47fe
movl $0x1f, %edx
movq %r15, %rdi
leaq 0xc20(%rip), %rsi # 0x53f0
callq 0x2290
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
jmp 0x4783
leaq 0xbd2(%rip), %rdi # 0x53d7
leaq 0x40(%rsp), %rbx
leaq 0x60(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2130
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21e0
movl $0xc8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2160
jmp 0x48dd
movq 0x3781(%rip), %rbx # 0x7fd0
leaq 0xb4a(%rip), %rsi # 0x53a0
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2290
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
movq 0x372e(%rip), %rbx # 0x7fd0
leaq 0xb12(%rip), %rsi # 0x53bb
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x2290
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x21a0
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/VanXNF[P]RUDP/Server/ServerService.cpp
|
getLocalIP(char*)
|
void getLocalIP(char* addressBuffer) {
struct ifaddrs * ifAddrStruct=NULL;
void * tmpAddrPtr=NULL;
getifaddrs(&ifAddrStruct);
while (ifAddrStruct!=NULL) {
if (ifAddrStruct->ifa_addr->sa_family==AF_INET) { // check it is IP4
tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_addr)->sin_addr;
inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
}
ifAddrStruct=ifAddrStruct->ifa_next;
}
// cout << addressBuffer << endl;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq %r14, %rdi
callq 0x23a0
movq (%r14), %rax
testq %rax, %rax
je 0x4dde
movq 0x18(%rax), %rsi
cmpw $0x2, (%rsi)
jne 0x4dd1
addq $0x4, %rsi
movl $0x2, %edi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0x2270
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x4dac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/VanXNF[P]RUDP/Server/IpAddress.cpp
|
getBoardcastIP(char*)
|
void getBoardcastIP(char* addressBuffer) {
struct ifaddrs * ifAddrStruct=NULL;
void * tmpAddrPtr=NULL;
getifaddrs(&ifAddrStruct);
while (ifAddrStruct!=NULL) {
if (ifAddrStruct->ifa_addr->sa_family==AF_INET) { // check it is IP4
tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_ifu.ifu_broadaddr)->sin_addr;
inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
}
ifAddrStruct=ifAddrStruct->ifa_next;
}
// cout << addressBuffer << endl;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq %r14, %rdi
callq 0x23a0
movq (%r14), %rax
testq %rax, %rax
je 0x4e38
movq 0x18(%rax), %rcx
cmpw $0x2, (%rcx)
jne 0x4e2b
movq 0x28(%rax), %rsi
addq $0x4, %rsi
movl $0x2, %edi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0x2270
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x4e02
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/VanXNF[P]RUDP/Server/IpAddress.cpp
|
bsim::operator>(bsim::quad_value_bit_vector const&, bsim::quad_value_bit_vector const&)
|
static inline bool operator>(const quad_value_bit_vector& a,
const quad_value_bit_vector& b) {
if (!a.is_binary() || !b.is_binary()) {
return false;
}
int N = a.bitLength();
for (int i = N - 1; i >= 0; i--) {
if (a.get(i) > b.get(i)) {
return true;
}
if (a.get(i) < b.get(i)) {
return false;
}
}
return false;
}
|
pushq %rax
movslq 0x18(%rdi), %rax
testq %rax, %rax
setle %cl
jle 0x3e03d
movq (%rdi), %rcx
cmpb $0x1, (%rcx)
ja 0x3e0be
movl $0x1, %r8d
movq %r8, %rdx
cmpq %r8, %rax
je 0x3e037
leaq 0x1(%rdx), %r8
cmpb $0x2, (%rcx,%rdx)
jb 0x3e025
cmpq %rax, %rdx
setae %cl
testb %cl, %cl
je 0x3e0be
movslq 0x18(%rsi), %rcx
testq %rcx, %rcx
setle %dl
jle 0x3e074
movq (%rsi), %rdx
cmpb $0x1, (%rdx)
ja 0x3e0be
movl $0x1, %r9d
movq %r9, %r8
cmpq %r9, %rcx
je 0x3e06e
leaq 0x1(%r8), %r9
cmpb $0x2, (%rdx,%r8)
jb 0x3e05b
cmpq %rcx, %r8
setae %dl
testb %dl, %dl
je 0x3e0be
movq (%rdi), %rdx
movq (%rsi), %rsi
movq %rax, %rcx
testq %rax, %rax
jle 0x3e0c5
movb -0x1(%rdx,%rcx), %dil
cmpb $0x3, %dil
je 0x3e0d0
movb -0x1(%rsi,%rcx), %r8b
cmpb $0x3, %r8b
je 0x3e0ef
cmpb $0x2, %dil
jae 0x3e10e
cmpb $0x2, %r8b
jae 0x3e12d
cmpb %r8b, %dil
ja 0x3e0c2
leaq -0x1(%rcx), %rax
cmpb %r8b, %dil
jae 0x3e07e
xorl %edi, %edi
jmp 0x3e0c5
xorl %eax, %eax
popq %rcx
retq
movb $0x1, %dil
testq %rcx, %rcx
setg %al
andb %dil, %al
jmp 0x3e0c0
leaq 0x29211(%rip), %rdi # 0x672e8
leaq 0x29175(%rip), %rsi # 0x67253
leaq 0x29f45(%rip), %rcx # 0x6802a
movl $0xde, %edx
callq 0x2d250
leaq 0x29247(%rip), %rdi # 0x6733d
leaq 0x29156(%rip), %rsi # 0x67253
leaq 0x29f26(%rip), %rcx # 0x6802a
movl $0xdf, %edx
callq 0x2d250
leaq 0x29d53(%rip), %rdi # 0x67e68
leaq 0x29137(%rip), %rsi # 0x67253
leaq 0x29f07(%rip), %rcx # 0x6802a
movl $0xe1, %edx
callq 0x2d250
leaq 0x29d42(%rip), %rdi # 0x67e76
leaq 0x29118(%rip), %rsi # 0x67253
leaq 0x29ee8(%rip), %rcx # 0x6802a
movl $0xe2, %edx
callq 0x2d250
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::andr(bsim::quad_value_bit_vector const&)
|
static inline quad_value_bit_vector
andr(const quad_value_bit_vector& a) {
for (int i = 0; i < a.bitLength(); i++) {
if (a.get(i) != 1) {
return quad_value_bit_vector(1, "0");
}
}
return quad_value_bit_vector(1, "1");
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x18(%rsi), %rax
testq %rax, %rax
setg %bpl
jle 0x3e1e1
movq (%rsi), %rcx
movq %rax, %rdx
negq %rdx
movl $0x1, %esi
movzbl -0x1(%rcx,%rsi), %edi
cmpl $0x1, %edi
jne 0x3e195
cmpq %rax, %rsi
setb %bpl
leaq (%rdx,%rsi), %rdi
incq %rdi
incq %rsi
cmpq $0x1, %rdi
jne 0x3e172
jmp 0x3e1e1
cmpl $0x3, %edi
je 0x3e22a
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2924e(%rip), %rsi # 0x673fc
leaq 0x29248(%rip), %rdx # 0x673fd
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f652
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3e1db
callq 0x2d360
testb $0x1, %bpl
jne 0x3e21e
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2bee8(%rip), %rsi # 0x6a0d9
leaq 0x2bee2(%rip), %rdx # 0x6a0da
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f652
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3e21e
callq 0x2d360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x290b7(%rip), %rdi # 0x672e8
leaq 0x2901b(%rip), %rsi # 0x67253
leaq 0x290c0(%rip), %rcx # 0x672ff
movl $0x109, %edx # imm = 0x109
callq 0x2d250
jmp 0x3e24d
jmp 0x3e260
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3e263
callq 0x2d360
jmp 0x3e263
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::orr(bsim::quad_value_bit_vector const&)
|
static inline quad_value_bit_vector
orr(const quad_value_bit_vector& a) {
for (int i = 0; i < a.bitLength(); i++) {
if (a.get(i) == 1) {
return quad_value_bit_vector(1, "1");
}
}
return quad_value_bit_vector(1, "0");
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x18(%rsi), %rax
testq %rax, %rax
setg %bpl
jle 0x3e300
movq (%rsi), %rcx
movq %rax, %rdx
negq %rdx
movl $0x1, %esi
movzbl -0x1(%rcx,%rsi), %edi
cmpl $0x1, %edi
je 0x3e2bd
cmpl $0x3, %edi
je 0x3e349
cmpq %rax, %rsi
setb %bpl
leaq (%rdx,%rsi), %rdi
incq %rdi
incq %rsi
cmpq $0x1, %rdi
jne 0x3e291
jmp 0x3e300
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2be0c(%rip), %rsi # 0x6a0d9
leaq 0x2be06(%rip), %rdx # 0x6a0da
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f652
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3e2fa
callq 0x2d360
testb $0x1, %bpl
jne 0x3e33d
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x290ec(%rip), %rsi # 0x673fc
leaq 0x290e6(%rip), %rdx # 0x673fd
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f652
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3e33d
callq 0x2d360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28f98(%rip), %rdi # 0x672e8
leaq 0x28efc(%rip), %rsi # 0x67253
leaq 0x28ff6(%rip), %rcx # 0x67354
movl $0x101, %edx # imm = 0x101
callq 0x2d250
jmp 0x3e36c
jmp 0x3e37f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3e382
callq 0x2d360
jmp 0x3e382
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::xorr(bsim::quad_value_bit_vector const&)
|
static inline quad_value_bit_vector
xorr(const quad_value_bit_vector& a) {
int numSet = 0;
for (int i = 0; i < a.bitLength(); i++) {
if (a.get(i) == 1) {
numSet++;
}
}
if ((numSet % 2) == 0) {
return quad_value_bit_vector(1, "0");
}
return quad_value_bit_vector(1, "1");
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x18(%rsi), %rax
testq %rax, %rax
jle 0x3e3ce
movq (%rsi), %rcx
xorl %edx, %edx
xorl %esi, %esi
movb (%rcx,%rdx), %dil
cmpb $0x3, %dil
je 0x3e450
xorl %r8d, %r8d
cmpb $0x1, %dil
sete %r8b
addl %r8d, %esi
incq %rdx
cmpq %rdx, %rax
jne 0x3e3a4
testb $0x1, %sil
jne 0x3e403
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2901e(%rip), %rsi # 0x673fc
leaq 0x29018(%rip), %rdx # 0x673fd
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f652
jmp 0x3e436
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2bcc6(%rip), %rsi # 0x6a0d9
leaq 0x2bcc0(%rip), %rdx # 0x6a0da
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3f652
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e445
callq 0x2d360
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x28e91(%rip), %rdi # 0x672e8
leaq 0x28df5(%rip), %rsi # 0x67253
leaq 0x28eef(%rip), %rcx # 0x67354
movl $0x101, %edx # imm = 0x101
callq 0x2d250
jmp 0x3e473
jmp 0x3e487
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e48a
callq 0x2d360
jmp 0x3e48a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::signed_gt(bsim::quad_value_bit_vector const&, bsim::quad_value_bit_vector const&)
|
static inline bool
signed_gt(const quad_value_bit_vector& a,
const quad_value_bit_vector& b) {
if (!a.is_binary() || !b.is_binary()) {
return false;
}
assert(a.bitLength() == b.bitLength());
int N = a.bitLength();
// a negative b non-negative
if ((a.get(N - 1) == 1) && (b.get(N - 1) == 0)) {
return false;
}
// b negative a non-negative
if ((b.get(N - 1) == 1) && (a.get(N - 1) == 0)) {
return true;
}
// Both negative or both non-negative
//if ((a.get(N - 1) == 1) && (b.get(N - 1) == 1)) {
for (int i = N - 2; i >= 0; i--) {
if (a.get(i) > b.get(i)) {
return true;
}
if (a.get(i) < b.get(i)) {
return false;
}
}
return false;
}
|
pushq %rax
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
setle %al
jle 0x3e4c9
movq (%rdi), %rax
cmpb $0x1, (%rax)
ja 0x3e5a1
movl $0x1, %r8d
movq %r8, %rdx
cmpq %r8, %rcx
je 0x3e4c3
leaq 0x1(%rdx), %r8
cmpb $0x2, (%rax,%rdx)
jb 0x3e4b1
cmpq %rcx, %rdx
setae %al
testb %al, %al
je 0x3e5a1
movslq 0x18(%rsi), %rax
testq %rax, %rax
setle %dl
jle 0x3e508
movq (%rsi), %rdx
cmpb $0x1, (%rdx)
ja 0x3e5a1
movl $0x1, %r9d
movq %r9, %r8
cmpq %r9, %rax
je 0x3e502
leaq 0x1(%r8), %r9
cmpb $0x2, (%rdx,%r8)
jb 0x3e4ef
cmpq %rax, %r8
setae %dl
testb %dl, %dl
je 0x3e5a1
cmpl %eax, %ecx
jne 0x3e650
movq (%rdi), %rdx
movzbl -0x1(%rcx,%rdx), %edi
cmpl $0x1, %edi
je 0x3e52f
cmpl $0x3, %edi
jne 0x3e544
jmp 0x3e631
movq (%rsi), %rax
movzbl -0x1(%rax,%rcx), %eax
testl %eax, %eax
je 0x3e5a1
cmpl $0x3, %eax
je 0x3e631
movq (%rsi), %rsi
movb -0x1(%rsi,%rcx), %r8b
cmpb $0x3, %r8b
je 0x3e631
xorb $0x1, %r8b
movb $0x1, %al
orb %dil, %r8b
je 0x3e5a3
cmpl $0x2, %ecx
setge %al
jl 0x3e5a7
decl %ecx
decl %ecx
movb (%rdx,%rcx), %dil
cmpb $0x3, %dil
je 0x3e5f3
movb (%rsi,%rcx), %r8b
cmpb $0x3, %r8b
je 0x3e612
cmpb $0x2, %dil
jae 0x3e5b5
cmpb $0x2, %r8b
jae 0x3e5d4
cmpb %r8b, %dil
ja 0x3e5a9
jb 0x3e5ae
testl %ecx, %ecx
setg %al
jg 0x3e56b
jmp 0x3e5b0
xorl %eax, %eax
andb $0x1, %al
popq %rcx
retq
jmp 0x3e5b0
movb $0x1, %dil
jmp 0x3e5b0
xorl %edi, %edi
andb %dil, %al
jmp 0x3e5a3
leaq 0x298ac(%rip), %rdi # 0x67e68
leaq 0x28c90(%rip), %rsi # 0x67253
leaq 0x29a60(%rip), %rcx # 0x6802a
movl $0xe1, %edx
callq 0x2d250
leaq 0x2989b(%rip), %rdi # 0x67e76
leaq 0x28c71(%rip), %rsi # 0x67253
leaq 0x29a41(%rip), %rcx # 0x6802a
movl $0xe2, %edx
callq 0x2d250
leaq 0x28cee(%rip), %rdi # 0x672e8
leaq 0x28c52(%rip), %rsi # 0x67253
leaq 0x29a22(%rip), %rcx # 0x6802a
movl $0xde, %edx
callq 0x2d250
leaq 0x28d24(%rip), %rdi # 0x6733d
leaq 0x28c33(%rip), %rsi # 0x67253
leaq 0x29a03(%rip), %rcx # 0x6802a
movl $0xdf, %edx
callq 0x2d250
leaq 0x28cb0(%rip), %rdi # 0x672e8
leaq 0x28c14(%rip), %rsi # 0x67253
leaq 0x28d0e(%rip), %rcx # 0x67354
movl $0x101, %edx # imm = 0x101
callq 0x2d250
leaq 0x29c0f(%rip), %rdi # 0x68266
leaq 0x28bf5(%rip), %rsi # 0x67253
leaq 0x29c20(%rip), %rcx # 0x68285
movl $0x388, %edx # imm = 0x388
callq 0x2d250
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::lshr(bsim::quad_value_bit_vector const&, bsim::quad_value_bit_vector const&)
|
static inline quad_value_bit_vector
lshr(const quad_value_bit_vector& a,
const quad_value_bit_vector& shift_amount) {
if (!a.is_binary() || !shift_amount.is_binary()) {
return unknown_bv(a.bitLength());
}
quad_value_bit_vector res(a.bitLength());
bv_uint64 shift_int = get_shift_int(shift_amount);
if (shift_int == 0) {
return a;
}
//unsigned char sign_bit = a.get(a.bitLength() - 1);
for (int i = a.bitLength() - 1; i >= (int) shift_int; i--) {
res.set(i - shift_int, a.get(i));
}
for (int i = a.bitLength() - 1; i >= (((int) a.bitLength()) - ((int) shift_int)); i--) {
res.set(i, 0);
}
return res;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x18(%rsi), %r12
testq %r12, %r12
setle %al
jle 0x3e888
movq (%r14), %rax
cmpb $0x1, (%rax)
ja 0x3e8f1
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %r12
je 0x3e882
leaq 0x1(%rcx), %rdx
cmpb $0x2, (%rax,%rcx)
jb 0x3e870
cmpq %r12, %rcx
setae %al
testb %al, %al
je 0x3e8f1
movslq 0x18(%r13), %rax
testq %rax, %rax
setle %cl
jle 0x3e8be
movq (%r13), %rcx
cmpb $0x1, (%rcx)
ja 0x3e8f1
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x3e8b8
leaq 0x1(%rdx), %rsi
cmpb $0x2, (%rcx,%rdx)
jb 0x3e8a6
cmpq %rax, %rdx
setae %cl
testb %cl, %cl
je 0x3e8f1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %r12d, %esi
callq 0x3eda4
movl 0x18(%r13), %eax
cmpl $0x41, %eax
jge 0x3ea0e
movq %r13, %rdi
cmpl $0x21, %eax
jl 0x3e95b
callq 0x3f5a0
jmp 0x3e980
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
testl %r12d, %r12d
jle 0x3e92a
leaq 0x2b69f(%rip), %r14 # 0x69fb2
leaq 0x8(%rsp), %r15
movl %r12d, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d700
decl %ebp
jne 0x3e91b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x3f652
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3e949
callq 0x2d360
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x11, %eax
jl 0x3e969
callq 0x40efc
movl %eax, %eax
jmp 0x3e980
cmpl $0x9, %eax
jl 0x3e978
callq 0x4163e
movzwl %ax, %eax
jmp 0x3e980
callq 0x3f5f8
movzbl %al, %eax
cmpq $0x41, %rax
jae 0x3ea2d
testq %rax, %rax
je 0x3e9f0
movslq 0x18(%r14), %rcx
cmpl %eax, %ecx
jle 0x3e9ce
movl %eax, %edx
notl %edx
addl %ecx, %edx
shlq $0x20, %rdx
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
movq (%r14), %rdi
movb -0x1(%rdi,%rcx), %dil
decq %rcx
movq %rdx, %r8
sarq $0x20, %r8
movq 0x8(%rsp), %r9
movb %dil, (%r9,%r8)
addq %rsi, %rdx
cmpq %rax, %rcx
jg 0x3e9ab
movslq 0x18(%r14), %rcx
cltq
movq 0x8(%rsp), %rdx
movb $0x0, -0x1(%rdx,%rcx)
decq %rcx
movslq 0x18(%r14), %rdx
subq %rax, %rdx
cmpq %rdx, %rcx
jg 0x3e9d4
movq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ee02
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x3e944
jmp 0x3e949
leaq 0x2a746(%rip), %rdi # 0x6915b
leaq 0x28837(%rip), %rsi # 0x67253
leaq 0x29bf1(%rip), %rcx # 0x68614
movl $0x3b0, %edx # imm = 0x3B0
callq 0x2d250
leaq 0x29c1d(%rip), %rdi # 0x68651
leaq 0x28818(%rip), %rsi # 0x67253
leaq 0x29bd2(%rip), %rcx # 0x68614
movl $0x3c2, %edx # imm = 0x3C2
callq 0x2d250
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x3ea6a
jmp 0x3ea6f
jmp 0x3ea5d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3ea6f
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value_bit_vector::quad_value_bit_vector(int)
|
quad_value_bit_vector(const int N_) : N(N_) {
//bits.resize(NUM_BYTES(N));
bits.resize(N);
for (uint i = 0; i < ((uint) bits.size()); i++) {
bits[i] = quad_value(0);
}
// for (int i = 0; i < N; i++) {
// set(i, 0);
// }
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %esi, 0x18(%rdi)
movslq %esi, %rsi
callq 0x3efce
movq (%rbx), %rax
cmpl %eax, 0x8(%rbx)
je 0x3ede2
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq %rcx
movl 0x8(%rbx), %edx
movq (%rbx), %rax
subl %eax, %edx
cmpq %rdx, %rcx
jb 0x3edce
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3edfa
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value_bit_vector::quad_value_bit_vector(bsim::quad_value_bit_vector const&)
|
quad_value_bit_vector(const quad_value_bit_vector& other) {
bits.resize(other.bits.size());
N = other.bitLength();
for (int i = 0; i < other.bitLength(); i++) {
bits[i] = other.bits[i];
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
callq 0x3efce
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
cmpl $0x0, 0x18(%r14)
jle 0x3ee4e
xorl %eax, %eax
movq (%r14), %rcx
movq (%rbx), %rdx
movb (%rcx,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
movslq 0x18(%r14), %rcx
cmpq %rcx, %rax
jl 0x3ee36
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3ee66
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
Catch::ResultBuilder& Catch::ExpressionLhs<bsim::quad_value_bit_vector const&>::captureExpression<(Catch::Internal::Operator)0, bsim::quad_value_bit_vector>(bsim::quad_value_bit_vector const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x3f20a
movzbl %al, %esi
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3f2ac
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f2ac
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x28267(%rip), %rsi # 0x673c6
leaq 0x28262(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3f18a
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f19d
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f1b0
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3f1d5
callq 0x2d360
jmp 0x3f1d5
jmp 0x3f1d2
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f1ef
callq 0x2d360
jmp 0x3f1ef
jmp 0x3f1ec
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f202
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Internal::Evaluator<bsim::quad_value_bit_vector, bsim::quad_value_bit_vector, (Catch::Internal::Operator)0>::evaluate(bsim::quad_value_bit_vector const&, bsim::quad_value_bit_vector const&)
|
static bool evaluate( T1 const& lhs, T2 const& rhs) {
return opCast( lhs ) == opCast( rhs );
}
|
pushq %rax
movl 0x18(%rdi), %ecx
cmpl %ecx, 0x18(%rsi)
jne 0x3f267
testl %ecx, %ecx
setle %al
jle 0x3f269
movq (%rdi), %rdx
movq (%rsi), %rsi
movq %rcx, %rdi
negq %rdi
movl $0x1, %r8d
xorl %eax, %eax
movb -0x1(%rdx,%r8), %r9b
cmpb $0x3, %r9b
je 0x3f26d
movb -0x1(%rsi,%r8), %r10b
cmpb $0x3, %r10b
je 0x3f28c
cmpb $0x2, %r9b
je 0x3f269
cmpb %r10b, %r9b
jne 0x3f269
cmpq %rcx, %r8
setae %al
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0x3f22e
jmp 0x3f269
xorl %eax, %eax
andb $0x1, %al
popq %rcx
retq
leaq 0x28074(%rip), %rdi # 0x672e8
leaq 0x27fd8(%rip), %rsi # 0x67253
leaq 0x2807d(%rip), %rcx # 0x672ff
movl $0x109, %edx # imm = 0x109
callq 0x2d250
leaq 0x280aa(%rip), %rdi # 0x6733d
leaq 0x27fb9(%rip), %rsi # 0x67253
leaq 0x2805e(%rip), %rcx # 0x672ff
movl $0x10a, %edx # imm = 0x10A
callq 0x2d250
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::StringMakerBase<true>::convert<bsim::quad_value_bit_vector>(bsim::quad_value_bit_vector const&)
|
static std::string convert( T const& _value ) {
std::ostringstream oss;
oss << _value;
return oss.str();
}
|
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2d4b0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f372
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x2d420
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f2f7
callq 0x2d360
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x42ca5(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f34b
callq 0x2d360
jmp 0x3f34b
movq %rax, %rbx
movq 0x42c5e(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
bsim::quad_value_bit_vector::binary_string[abi:cxx11]() const
|
std::string binary_string() const {
std::string str = "";
const int N = bitLength();
for (int i = N - 1; i >= 0; i--) {
str += get(i).binary_string();
}
return str;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
leaq 0x2ae07(%rip), %rdx # 0x6a1a0
movq %rdx, %rsi
callq 0x3ef3e
movslq 0x18(%r14), %r13
testq %r13, %r13
jle 0x3f3fd
leaq 0x28(%rsp), %rbp
incq %r13
leaq 0x18(%rsp), %r15
leaq 0xf(%rsp), %r12
movq (%r14), %rax
movb -0x2(%rax,%r13), %al
movb %al, 0xf(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3f43e
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2d100
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f3f4
callq 0x2d360
decq %r13
cmpq $0x1, %r13
jg 0x3f3bc
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3f426
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f426
callq 0x2d360
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x3f435
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value::binary_string[abi:cxx11]() const
|
std::string binary_string() const {
if (value == 1) {
return "1";
} else if (value == 0) {
return "0";
} else if (value == QBV_UNKNOWN_VALUE) {
return "x";
} else if (value == QBV_HIGH_IMPEDANCE_VALUE) {
return "z";
}
assert(false);
}
|
pushq %rbx
movzbl (%rsi), %eax
cmpq $0x3, %rax
ja 0x3f4c2
movq %rdi, %rbx
leaq 0x27bb2(%rip), %rcx # 0x67004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x27f93(%rip), %rsi # 0x673fc
leaq 0x27f8d(%rip), %rdx # 0x673fd
jmp 0x3f4b5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2ab32(%rip), %rsi # 0x69fb2
leaq 0x2ab2c(%rip), %rdx # 0x69fb3
jmp 0x3f4b5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x284b4(%rip), %rsi # 0x6794b
leaq 0x284ae(%rip), %rdx # 0x6794c
jmp 0x3f4b5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2ac2b(%rip), %rsi # 0x6a0d9
leaq 0x2ac25(%rip), %rdx # 0x6a0da
movq %rbx, %rdi
callq 0x3ef3e
movq %rbx, %rax
popq %rbx
retq
leaq 0x29c92(%rip), %rdi # 0x6915b
leaq 0x27d83(%rip), %rsi # 0x67253
leaq 0x27ebb(%rip), %rcx # 0x67392
movl $0x86, %edx
callq 0x2d250
nop
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value_bit_vector::quad_value_bit_vector(int, int)
|
quad_value_bit_vector(const int N_, const int val) : N(N_) {
//bits.resize(NUM_BYTES(N));
bits.resize(N);
for (int i = 0; i < N; i++) {
if (i < ((int) sizeof(int)*8)) {
set(i, quad_value((val >> i) & 0x01));
} else {
set(i, quad_value(0));
}
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %esi, 0x18(%rdi)
movslq %esi, %rsi
callq 0x3efce
cmpl $0x0, 0x18(%rbx)
jle 0x3f583
xorl %ecx, %ecx
cmpq $0x20, %rcx
setb %al
movl %ebp, %edx
shrl %cl, %edx
andb %al, %dl
movq (%rbx), %rax
movb %dl, (%rax,%rcx)
incq %rcx
movslq 0x18(%rbx), %rax
cmpq %rax, %rcx
jl 0x3f564
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3f598
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
unsigned long bsim::quad_value_bit_vector::to_type<unsigned long>() const
|
ConvType to_type() const {
ConvType tmp = 0;
ConvType exp = 1;
for (int i = 0; i < bitLength(); i++) {
tmp += exp*get(i).binary_value();
exp *= 2;
}
return tmp;
// ConvType tmp = *(const_cast<ConvType*>((const ConvType*) (&(bits[0]))));
// //TODO FIXME I am a sketchy hack.
// ConvType mask = sizeof(ConvType) > bits.size() ? (1<<N)-1 : -1;
// return tmp & mask;
}
|
pushq %rax
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x3f5d5
movq (%rdi), %rdx
movl $0x1, %esi
xorl %edi, %edi
xorl %eax, %eax
movzbl (%rdx,%rdi), %r8d
cmpq $0x2, %r8
jae 0x3f5d9
imulq %rsi, %r8
addq %r8, %rax
addq %rsi, %rsi
incq %rdi
cmpq %rdi, %rcx
jne 0x3f5b6
jmp 0x3f5d7
xorl %eax, %eax
popq %rcx
retq
leaq 0x2805f(%rip), %rdi # 0x6763f
leaq 0x27c6c(%rip), %rsi # 0x67253
leaq 0x2806e(%rip), %rcx # 0x6765c
movl $0x78, %edx
callq 0x2d250
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
unsigned char bsim::quad_value_bit_vector::to_type<unsigned char>() const
|
ConvType to_type() const {
ConvType tmp = 0;
ConvType exp = 1;
for (int i = 0; i < bitLength(); i++) {
tmp += exp*get(i).binary_value();
exp *= 2;
}
return tmp;
// ConvType tmp = *(const_cast<ConvType*>((const ConvType*) (&(bits[0]))));
// //TODO FIXME I am a sketchy hack.
// ConvType mask = sizeof(ConvType) > bits.size() ? (1<<N)-1 : -1;
// return tmp & mask;
}
|
pushq %rax
movslq 0x18(%rdi), %rdx
testq %rdx, %rdx
jle 0x3f62c
movq (%rdi), %rsi
movl $0x1, %edi
xorl %r8d, %r8d
xorl %ecx, %ecx
movb (%rsi,%r8), %al
cmpb $0x2, %al
jae 0x3f632
mulb %dil
addb %al, %cl
movzbl %dil, %edi
addl %edi, %edi
incq %r8
cmpq %r8, %rdx
jne 0x3f60f
jmp 0x3f62e
xorl %ecx, %ecx
movl %ecx, %eax
popq %rcx
retq
leaq 0x28006(%rip), %rdi # 0x6763f
leaq 0x27c13(%rip), %rsi # 0x67253
leaq 0x28015(%rip), %rcx # 0x6765c
movl $0x78, %edx
callq 0x2d250
nop
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value_bit_vector::quad_value_bit_vector(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
quad_value_bit_vector(const int N_, const std::string& str_raw) : N(N_) {
int num_digits = 0;
std::string str;
for (int i = 0; i < ((int) str_raw.size()); i++) {
if (isdigit(str_raw[i])) {
num_digits++;
str += str_raw[i];
} else if (str_raw[i] == 'z') {
str += str_raw[i];
} else if (str_raw[i] == 'x') {
str += str_raw[i];
} else {
assert(str_raw[i] == '_');
}
}
assert(num_digits <= N);
int len = str.size();
bits.resize(N);
for (int i = len - 1; i >= 0; i--) {
unsigned char val = (str[i] == '0') ? 0 : 1;
if (str[i] == 'x') {
val = QBV_UNKNOWN_VALUE;
}
if (str[i] == 'z') {
val = QBV_HIGH_IMPEDANCE_VALUE;
}
int ind = len - i - 1;
set(ind, val);
}
for (int i = N - 1; i >= len; i--) {
set(i,0);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
movl %esi, 0x18(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r13, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x0, 0x8(%rdx)
jle 0x3f6e8
movq %rdx, %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movq (%r14), %rax
movsbl (%rax,%rbp), %eax
movl %eax, %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x3f6bb
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d330
incl %r13d
jmp 0x3f6dc
movzbl %al, %ecx
cmpl $0x5f, %ecx
je 0x3f6dc
cmpl $0x7a, %ecx
je 0x3f6d1
cmpl $0x78, %ecx
jne 0x3f790
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d330
incq %rbp
movslq 0x8(%r14), %rax
cmpq %rax, %rbp
jl 0x3f69a
movslq 0x18(%rbx), %rsi
cmpl %esi, %r13d
jg 0x3f7af
movq 0x10(%rsp), %r14
movq %rbx, %rdi
callq 0x3efce
testl %r14d, %r14d
jle 0x3f756
movl %r14d, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
incq %rax
xorl %ecx, %ecx
movl $0x2, %edx
movl $0x3, %esi
movq 0x8(%rsp), %rdi
movb -0x2(%rdi,%rax), %dil
xorl %r8d, %r8d
cmpb $0x30, %dil
setne %r8b
cmpb $0x78, %dil
cmovel %edx, %r8d
cmpb $0x7a, %dil
cmovel %esi, %r8d
movq (%rbx), %rdi
movb %r8b, (%rdi,%rcx)
decq %rax
incq %rcx
cmpq $0x1, %rax
jg 0x3f71e
movslq 0x18(%rbx), %rax
cmpl %r14d, %eax
jle 0x3f772
movslq %r14d, %rcx
movq (%rbx), %rdx
movb $0x0, -0x1(%rdx,%rax)
decq %rax
cmpq %rcx, %rax
jg 0x3f762
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f781
callq 0x2d360
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27efa(%rip), %rdi # 0x67691
leaq 0x27ab5(%rip), %rsi # 0x67253
leaq 0x27efe(%rip), %rcx # 0x676a3
movl $0x17d, %edx # imm = 0x17D
callq 0x2d250
leaq 0x27f40(%rip), %rdi # 0x676f6
leaq 0x27a96(%rip), %rsi # 0x67253
leaq 0x27edf(%rip), %rcx # 0x676a3
movl $0x180, %edx # imm = 0x180
callq 0x2d250
jmp 0x3f7d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f7e2
callq 0x2d360
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3f7ef
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value_bit_vector::operator=(bsim::quad_value_bit_vector const&)
|
quad_value_bit_vector& operator=(const quad_value_bit_vector& other) {
if (&other == this) {
return *this;
}
bits.resize(other.bits.size());
N = other.bitLength();
for (int i = 0; i < other.bitLength(); i++) {
bits[i] = other.bits[i];
}
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rdi, %rsi
je 0x3f83e
movq %rsi, %r14
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
movq %rbx, %rdi
callq 0x3efce
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
cmpl $0x0, 0x18(%r14)
jle 0x3f83e
xorl %eax, %eax
movq (%r14), %rcx
movq (%rbx), %rdx
movb (%rcx,%rax), %cl
movb %cl, (%rdx,%rax)
incq %rax
movslq 0x18(%r14), %rcx
cmpq %rcx, %rax
jl 0x3f826
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
bsim::quad_value_bit_vector::quad_value_bit_vector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
quad_value_bit_vector(const std::string& str_raw) : N(0) {
std::string bv_size = "";
int ind = 0;
while (str_raw[ind] != '\'') {
assert(isdigit(str_raw[ind]));
bv_size += str_raw[ind];
ind++;
}
assert (str_raw[ind] == '\'');
ind++;
char format = str_raw[ind];
assert((format == 'b') ||
(format == 'h') ||
(format == 'd'));
ind++;
std::string digits = "";
while (ind < ((int) str_raw.size())) {
digits += str_raw[ind];
ind++;
}
int num_bits = stoi(bv_size);
N = num_bits;
//bits.resize(NUM_BYTES(num_bits));
bits.resize(num_bits);
for (int i = 0; i < ((int) bits.size()); i++) {
bits[i] = 0;
}
// TODO: Check that digits are not too long
assert(format == 'h');
int bit_ind = 0;
for (int i = digits.size() - 1; i >= 0; i--) {
char hex_digit = digits[i];
std::string hex_to_binary = hex_digit_to_binary(hex_digit);
assert(hex_to_binary.size() == 4);
int k = 0;
for (int j = hex_to_binary.size() - 1; j >= 0; j--) {
// Dont add past the end
if ((bit_ind + k) < bitLength()) {
//std::cout << "setting digit = " << hex_to_binary[j] << std::endl;
if (hex_to_binary[j] == '1') {
set(bit_ind + k, quad_value(1));
} else if (hex_to_binary[j] == '0') {
set(bit_ind + k, quad_value(0));
} else if (hex_to_binary[j] == 'x') {
set(bit_ind + k, quad_value(QBV_UNKNOWN_VALUE));
} else if (hex_to_binary[j] == 'z') {
set(bit_ind + k, quad_value(QBV_HIGH_IMPEDANCE_VALUE));
} else {
assert(false);
}
k++;
} else {
//assert(hex_to_binary[j] == '0');
}
}
bit_ind += 4;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movups %xmm0, (%rdi)
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2a928(%rip), %rdx # 0x6a1a0
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ef3e
movq (%r14), %rax
movb (%rax), %cl
xorl %r12d, %r12d
cmpb $0x27, %cl
je 0x3f8c1
xorl %r12d, %r12d
leaq 0x48(%rsp), %r15
movsbl %cl, %esi
leal -0x30(%rsi), %eax
cmpl $0xa, %eax
jae 0x3fc58
movq %r15, %rdi
callq 0x2d330
movq (%r14), %rax
movb 0x1(%rax,%r12), %cl
incq %r12
cmpb $0x27, %cl
jne 0x3f89a
movl %r12d, %ecx
movzbl 0x1(%rax,%rcx), %r13d
leal -0x62(%r13), %eax
cmpl $0x6, %eax
ja 0x3fccd
movl $0x45, %ecx
btl %eax, %ecx
jae 0x3fccd
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2a8ab(%rip), %rdx # 0x6a1a0
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ef3e
addl $0x2, %r12d
cmpl 0x8(%r14), %r12d
jge 0x3f92d
movl %r12d, %r12d
leaq 0x28(%rsp), %r15
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %r15, %rdi
callq 0x2d330
incq %r12
cmpl 0x8(%r14), %r12d
jl 0x3f914
movq 0x48(%rsp), %r14
callq 0x2d050
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x2d4d0
cmpq %r14, (%r12)
je 0x3fc96
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x3fca2
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0x3fca2
testl %ecx, %ecx
jne 0x3f980
movl %ebp, (%r15)
movl %eax, 0x18(%rbx)
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x3efce
movl 0x8(%rbx), %ecx
movq (%rbx), %rax
subl %eax, %ecx
testl %ecx, %ecx
jle 0x3f9b3
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq %rcx
movl 0x8(%rbx), %edx
movq (%rbx), %rax
subl %eax, %edx
movslq %edx, %rdx
cmpq %rdx, %rcx
jl 0x3f99c
cmpb $0x68, %r13b
jne 0x3fcae
movl 0x30(%rsp), %eax
decl %eax
js 0x3fbe3
leaq 0x18(%rsp), %r14
movl %eax, %r15d
xorl %r12d, %r12d
leaq 0x27639(%rip), %r13 # 0x67014
xorl %ebp, %ebp
movq 0x28(%rsp), %rax
movzbl (%rax,%r15), %eax
cmpl $0x60, %eax
jg 0x3fa14
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x3fc77
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq %r14, 0x8(%rsp)
movl $0x30303030, 0x18(%rsp) # imm = 0x30303030
jmp 0x3fb53
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0x3fa3e
leaq 0x27619(%rip), %rdx # 0x6703c
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, 0x8(%rsp)
movl $0x30313031, 0x18(%rsp) # imm = 0x30313031
jmp 0x3fb53
cmpl $0x78, %eax
je 0x3faec
cmpl $0x7a, %eax
jne 0x3fc77
movq %r14, 0x8(%rsp)
movl $0x7a7a7a7a, 0x18(%rsp) # imm = 0x7A7A7A7A
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x30303130, 0x18(%rsp) # imm = 0x30303130
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x30313131, 0x18(%rsp) # imm = 0x30313131
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31303031, 0x18(%rsp) # imm = 0x31303031
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x30313030, 0x18(%rsp) # imm = 0x30313030
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x30303131, 0x18(%rsp) # imm = 0x30303131
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31313030, 0x18(%rsp) # imm = 0x31313030
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31313130, 0x18(%rsp) # imm = 0x31313130
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31303030, 0x18(%rsp) # imm = 0x31303030
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x78787878, 0x18(%rsp) # imm = 0x78787878
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31303131, 0x18(%rsp) # imm = 0x31303131
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31313031, 0x18(%rsp) # imm = 0x31313031
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31303130, 0x18(%rsp) # imm = 0x31303130
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x30313130, 0x18(%rsp) # imm = 0x30313130
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x30303031, 0x18(%rsp) # imm = 0x30303031
jmp 0x3fb53
movq %r14, 0x8(%rsp)
movl $0x31313131, 0x18(%rsp) # imm = 0x31313131
movq $0x4, 0x10(%rsp)
movb $0x0, 0x1c(%rsp)
testb %r12b, %r12b
jne 0x3fc39
xorl %eax, %eax
movl $0x4, %ecx
leal (%rax,%rbp), %edx
cmpl 0x18(%rbx), %edx
jge 0x3fbbc
movq 0x8(%rsp), %rsi
movzbl -0x1(%rsi,%rcx), %edi
cmpl $0x77, %edi
jg 0x3fb9a
cmpl $0x30, %edi
je 0x3fba9
movb $0x1, %sil
cmpl $0x31, %edi
je 0x3fbb0
jmp 0x3fc1a
cmpl $0x78, %edi
je 0x3fbad
cmpl $0x7a, %edi
jne 0x3fc1a
movb $0x3, %sil
jmp 0x3fbb0
xorl %esi, %esi
jmp 0x3fbb0
movb $0x2, %sil
movslq %edx, %rdx
movq (%rbx), %rdi
movb %sil, (%rdi,%rdx)
incl %eax
decq %rcx
jg 0x3fb71
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3fbd0
callq 0x2d360
addl $0x4, %ebp
leaq -0x1(%r15), %rax
testq %r15, %r15
movq %rax, %r15
jg 0x3f9dd
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3fbf7
callq 0x2d360
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x3fc0b
callq 0x2d360
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2953a(%rip), %rdi # 0x6915b
leaq 0x2762b(%rip), %rsi # 0x67253
leaq 0x27aed(%rip), %rcx # 0x6771c
movl $0x165, %edx # imm = 0x165
callq 0x2d250
leaq 0x27b68(%rip), %rdi # 0x677a8
leaq 0x2760c(%rip), %rsi # 0x67253
leaq 0x27ace(%rip), %rcx # 0x6771c
movl $0x155, %edx # imm = 0x155
callq 0x2d250
leaq 0x27aa7(%rip), %rdi # 0x67706
leaq 0x275ed(%rip), %rsi # 0x67253
leaq 0x27aaf(%rip), %rcx # 0x6771c
movl $0x12d, %edx # imm = 0x12D
callq 0x2d250
leaq 0x294dd(%rip), %rdi # 0x6915b
leaq 0x275ce(%rip), %rsi # 0x67253
leaq 0x27b3b(%rip), %rcx # 0x677c7
movl $0x41, %edx
callq 0x2d250
leaq 0x27b25(%rip), %rdi # 0x677c2
callq 0x2d200
leaq 0x27b19(%rip), %rdi # 0x677c2
callq 0x2d500
leaq 0x27ae5(%rip), %rdi # 0x6779a
leaq 0x27597(%rip), %rsi # 0x67253
leaq 0x27a59(%rip), %rcx # 0x6771c
movl $0x14e, %edx # imm = 0x14E
callq 0x2d250
leaq 0x27a90(%rip), %rdi # 0x67764
leaq 0x27578(%rip), %rsi # 0x67253
leaq 0x27a3a(%rip), %rcx # 0x6771c
movl $0x13a, %edx # imm = 0x13A
callq 0x2d250
jmp 0x3fd03
jmp 0x3fd1c
movq %rax, %r14
jmp 0x3fd33
movq %rax, %r14
cmpl $0x0, (%r15)
jne 0x3fd06
movl %ebp, (%r15)
jmp 0x3fd06
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3fd1f
callq 0x2d360
jmp 0x3fd1f
movq %rax, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x3fd33
callq 0x2d360
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3fd40
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
Catch::ResultBuilder& Catch::ExpressionLhs<int const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rbx), %eax
sete %sil
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rax
movl (%rax), %esi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x4617b
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
movl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x4617b
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x27609(%rip), %rsi # 0x673c6
leaq 0x27604(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3fde8
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fdfb
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fe0e
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3fe33
callq 0x2d360
jmp 0x3fe33
jmp 0x3fe30
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fe4d
callq 0x2d360
jmp 0x3fe4d
jmp 0x3fe4a
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3fe60
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<unsigned long const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movl (%rsi), %ecx
xorl %esi, %esi
cmpq %rcx, (%rax)
sete %sil
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rax
movq (%rax), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x46252
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
movl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x4617b
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x274e7(%rip), %rsi # 0x673c6
leaq 0x274e2(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3ff0a
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ff1d
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ff30
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x3ff55
callq 0x2d360
jmp 0x3ff55
jmp 0x3ff52
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ff6f
callq 0x2d360
jmp 0x3ff6f
jmp 0x3ff6c
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ff82
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<unsigned char const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movzbl (%rax), %eax
xorl %esi, %esi
cmpl %eax, (%rbx)
sete %sil
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rax
movzbl (%rax), %esi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x46474
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
movl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x4617b
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x273c5(%rip), %rsi # 0x673c6
leaq 0x273c0(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4002c
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4003f
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40052
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40077
callq 0x2d360
jmp 0x40077
jmp 0x40074
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40091
callq 0x2d360
jmp 0x40091
jmp 0x4008e
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x400a4
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
bsim::quad_value_bit_vector::hex_string[abi:cxx11]() const
|
std::string hex_string() const {
std::string hex = std::to_string(N) + "'h";
std::string hex_digits = "";
for (int i = 0; i < ((int) bits.size()); i += 4) {
unsigned char bit_l = 0;
bool found_abnormal = false;
for (int j = 0; j < 4; j++) {
int index = i + j;
if (index >= ((int) bits.size())) {
} else {
if (bits[index].is_binary()) {
bit_l |= (bits[index].binary_value() & 0x01) << j;
} else if (bits[index].is_unknown()) {
bit_l = 'x';
found_abnormal = true;
break;
} else {
assert(bits[index].is_high_impedance());
bit_l = 'z';
found_abnormal = true;
break;
}
}
}
if (!found_abnormal) {
hex_digits += bit_l > 9 ? bit_l + 87 : bit_l + 48;
} else {
hex_digits += bit_l;
}
}
std::reverse(std::begin(hex_digits), std::end(hex_digits));
return hex + hex_digits;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movl 0x18(%rsi), %ebx
movl %ebx, %ebp
negl %ebp
cmovsl %ebx, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x40120
movl $0x4, %r15d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x40117
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x4011d
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x40120
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x400e4
addl $-0x3, %r15d
jmp 0x40120
addl $-0x2, %r15d
jmp 0x40120
decl %r15d
shrl $0x1f, %ebx
movl %ebx, %esi
addl %r15d, %esi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %r12
movq %r12, %rdi
movl $0x2d, %edx
callq 0x2d440
movq (%r12), %rdi
addq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x403bc
leaq 0x278ad(%rip), %rsi # 0x67a06
movq %r12, %rdi
callq 0x2d700
leaq 0x30(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x40188
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x4018e
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x401b4
callq 0x2d360
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x29fdf(%rip), %rdx # 0x6a1a0
movq %rdx, %rsi
callq 0x3ef3e
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
testl %ecx, %ecx
jle 0x4027b
xorl %ebp, %ebp
movl $0x57, %r12d
movq %rsp, %r15
xorl %ebx, %ebx
movslq %ecx, %rdx
addq %rbx, %rax
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edi, %edi
leaq (%rbx,%rcx), %r9
movb $0x1, %r8b
cmpq %rdx, %r9
jge 0x40231
movzbl (%rax,%rcx), %r9d
cmpl $0x1, %r9d
ja 0x40213
shll %cl, %r9d
orb %r9b, %dil
jmp 0x40231
movb $0x1, %sil
cmpl $0x2, %r9d
je 0x4022b
cmpl $0x3, %r9d
jne 0x40307
movb $0x7a, %dil
jmp 0x4022e
movb $0x78, %dil
xorl %r8d, %r8d
testb %r8b, %r8b
je 0x40243
leaq 0x1(%rcx), %r8
cmpq $0x3, %rcx
movq %r8, %rcx
jb 0x401f4
cmpb $0xa, %dil
movl $0x30, %eax
cmovael %r12d, %eax
testb $0x1, %sil
cmovnel %ebp, %eax
addb %dil, %al
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d330
addq $0x4, %rbx
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
cmpl %ecx, %ebx
jl 0x401e8
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x402be
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x402a3
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40368
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x402e1
callq 0x2d360
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x402f5
callq 0x2d360
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x276fb(%rip), %rdi # 0x67a09
leaq 0x26f3e(%rip), %rsi # 0x67253
leaq 0x2770d(%rip), %rcx # 0x67a29
movl $0x1b9, %edx # imm = 0x1B9
callq 0x2d250
jmp 0x4033b
movq %rax, %rbx
jmp 0x4034c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
jne 0x4035b
jmp 0x40360
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x4034c
callq 0x2d360
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x40360
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
Catch::ResultBuilder& Catch::ExpressionLhs<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::captureExpression<(Catch::Internal::Operator)0, char [6]>(char const (&) [6])
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x2d0f0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x45b2d
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x45fef
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x26e92(%rip), %rsi # 0x673c6
leaq 0x26e8d(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4055f
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40572
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40585
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x405aa
callq 0x2d360
jmp 0x405aa
jmp 0x405a7
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x405c4
callq 0x2d360
jmp 0x405c4
jmp 0x405c1
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x405d7
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::captureExpression<(Catch::Internal::Operator)0, char [7]>(char const (&) [7])
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x2d0f0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x45b2d
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x45fef
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x26d6c(%rip), %rsi # 0x673c6
leaq 0x26d67(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40685
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40698
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406ab
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x406d0
callq 0x2d360
jmp 0x406d0
jmp 0x406cd
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406ea
callq 0x2d360
jmp 0x406ea
jmp 0x406e7
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x406fd
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::captureExpression<(Catch::Internal::Operator)0, char [13]>(char const (&) [13])
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x2d0f0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x45b2d
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x45fef
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x26c46(%rip), %rsi # 0x673c6
leaq 0x26c41(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x407ab
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x407be
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x407d1
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x407f6
callq 0x2d360
jmp 0x407f6
jmp 0x407f3
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40810
callq 0x2d360
jmp 0x40810
jmp 0x4080d
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40823
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::captureExpression<(Catch::Internal::Operator)0, char [15]>(char const (&) [15])
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x2d0f0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x45b2d
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x45fef
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x26b20(%rip), %rsi # 0x673c6
leaq 0x26b1b(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x408d1
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x408e4
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x408f7
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4091c
callq 0x2d360
jmp 0x4091c
jmp 0x40919
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40936
callq 0x2d360
jmp 0x40936
jmp 0x40933
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40949
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ExpressionLhs<bool>::endExpression()
|
void endExpression() {
bool value = m_lhs ? true : false;
m_rb
.setLhs( Catch::toString( value ) )
.setResultType( value )
.endExpression();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %r14
movzbl 0x8(%rdi), %ebx
movq %rsp, %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0x463f8
movq %r14, %rdi
movq %r15, %rsi
callq 0x46996
movq %rax, %rdi
movl %ebx, %esi
callq 0x46980
movq %rax, %rdi
callq 0x469d8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4099f
callq 0x2d360
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x409bf
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<bsim::quad_value const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x40ae8
movzbl %al, %esi
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x40b66
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
movl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x4617b
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2698a(%rip), %rsi # 0x673c6
leaq 0x26985(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40a67
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40a7a
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40a8d
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40ab2
callq 0x2d360
jmp 0x40ab2
jmp 0x40aaf
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40acc
callq 0x2d360
jmp 0x40acc
jmp 0x40ac9
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40adf
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
bsim::quad_value::print(std::ostream&) const
|
void print(std::ostream& out) const {
if (value == 1) {
out << "1";
} else if (value == 0) {
out << "0";
} else if (value == QBV_UNKNOWN_VALUE) {
out << "x";
} else if (value == QBV_HIGH_IMPEDANCE_VALUE) {
out << "z";
}
}
|
movzbl (%rdi), %eax
cmpq $0x3, %rax
ja 0x40c15
leaq 0x27b4e(%rip), %rcx # 0x6874c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x2d420
retq
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
Catch::Internal::Evaluator<bsim::quad_value_bit_vector, bsim::quad_value_bit_vector, (Catch::Internal::Operator)1>::evaluate(bsim::quad_value_bit_vector const&, bsim::quad_value_bit_vector const&)
|
static bool evaluate( T1 const& lhs, T2 const& rhs ) {
return opCast( lhs ) != opCast( rhs );
}
|
pushq %rax
movl 0x18(%rdi), %ecx
cmpl %ecx, 0x18(%rsi)
jne 0x40d93
testl %ecx, %ecx
setle %al
jle 0x40d95
movq (%rdi), %rdx
movq (%rsi), %rsi
movq %rcx, %rdi
negq %rdi
movl $0x1, %r8d
xorl %eax, %eax
movb -0x1(%rdx,%r8), %r9b
cmpb $0x3, %r9b
je 0x40d9b
movb -0x1(%rsi,%r8), %r10b
cmpb $0x3, %r10b
je 0x40dba
cmpb $0x2, %r9b
je 0x40d95
cmpb %r10b, %r9b
jne 0x40d95
cmpq %rcx, %r8
setae %al
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0x40d5a
jmp 0x40d95
xorl %eax, %eax
notb %al
andb $0x1, %al
popq %rcx
retq
leaq 0x26546(%rip), %rdi # 0x672e8
leaq 0x264aa(%rip), %rsi # 0x67253
leaq 0x2654f(%rip), %rcx # 0x672ff
movl $0x109, %edx # imm = 0x109
callq 0x2d250
leaq 0x2657c(%rip), %rdi # 0x6733d
leaq 0x2648b(%rip), %rsi # 0x67253
leaq 0x26530(%rip), %rcx # 0x672ff
movl $0x10a, %edx # imm = 0x10A
callq 0x2d250
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ResultBuilder& Catch::ExpressionLhs<unsigned char const&>::captureExpression<(Catch::Internal::Operator)0, unsigned char>(unsigned char const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movb (%rax), %al
xorl %esi, %esi
cmpb (%rbx), %al
sete %sil
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rax
movzbl (%rax), %esi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x46474
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
movzbl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x46474
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x26575(%rip), %rsi # 0x673c6
leaq 0x26570(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40e7c
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40e8f
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40ea2
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40ec7
callq 0x2d360
jmp 0x40ec7
jmp 0x40ec4
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40ee1
callq 0x2d360
jmp 0x40ee1
jmp 0x40ede
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40ef4
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
bsim::quad_value_bit_vector_operations::lor(bsim::quad_value_bit_vector const&, bsim::quad_value_bit_vector const&)
|
static inline quad_value_bit_vector lor(const quad_value_bit_vector& a,
const quad_value_bit_vector& b) {
quad_value_bit_vector a_or_b(a.bitLength());
for (int i = 0; i < a.bitLength(); i++) {
a_or_b.set(i, a.get(i) | b.get(i));
}
return a_or_b;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x18(%rsi), %esi
callq 0x3eda4
cmpl $0x0, 0x18(%r15)
jle 0x41102
xorl %eax, %eax
movq (%r15), %rcx
movb (%rcx,%rax), %cl
cmpb $0x3, %cl
je 0x4110b
movq (%r14), %rdx
movb (%rdx,%rax), %dl
cmpb $0x3, %dl
je 0x4112a
movb $0x1, %sil
cmpb $0x1, %cl
je 0x410ef
cmpb $0x1, %dl
je 0x410ef
cmpb $0x2, %cl
sete %sil
cmpb $0x2, %dl
sete %dil
orb %sil, %dil
movb $0x2, %sil
jne 0x410ef
cmpb $0x2, %cl
jae 0x41149
cmpb $0x2, %dl
jae 0x41168
orb %cl, %dl
movl %edx, %esi
cmpb $0x4, %dl
jae 0x41187
movq (%rbx), %rcx
movb %sil, (%rcx,%rax)
incq %rax
movslq 0x18(%r15), %rcx
cmpq %rcx, %rax
jl 0x4109b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x261d6(%rip), %rdi # 0x672e8
leaq 0x2613a(%rip), %rsi # 0x67253
leaq 0x26d64(%rip), %rcx # 0x67e84
movl $0xb8, %edx
callq 0x2d250
leaq 0x2620c(%rip), %rdi # 0x6733d
leaq 0x2611b(%rip), %rsi # 0x67253
leaq 0x26d45(%rip), %rcx # 0x67e84
movl $0xb9, %edx
callq 0x2d250
leaq 0x26d18(%rip), %rdi # 0x67e68
leaq 0x260fc(%rip), %rsi # 0x67253
leaq 0x26d26(%rip), %rcx # 0x67e84
movl $0xc6, %edx
callq 0x2d250
leaq 0x26d07(%rip), %rdi # 0x67e76
leaq 0x260dd(%rip), %rsi # 0x67253
leaq 0x26d07(%rip), %rcx # 0x67e84
movl $0xc7, %edx
callq 0x2d250
leaq 0x260bf(%rip), %rdi # 0x6724d
leaq 0x260be(%rip), %rsi # 0x67253
leaq 0x26120(%rip), %rcx # 0x672bc
movl $0x4f, %edx
callq 0x2d250
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
Catch::ResultBuilder& Catch::ExpressionLhs<bsim::quad_value_bit_vector const&>::captureExpression<(Catch::Internal::Operator)2, bsim::quad_value_bit_vector>(bsim::quad_value_bit_vector const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rdi
callq 0x41504
movzbl %al, %esi
movq %r15, %rdi
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3f2ac
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f2ac
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2875f(%rip), %rsi # 0x69bb8
leaq 0x28759(%rip), %rdx # 0x69bb9
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x41484
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41497
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x414aa
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x414cf
callq 0x2d360
jmp 0x414cf
jmp 0x414cc
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x414e9
callq 0x2d360
jmp 0x414e9
jmp 0x414e6
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x414fc
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
unsigned short bsim::quad_value_bit_vector::to_type<unsigned short>() const
|
ConvType to_type() const {
ConvType tmp = 0;
ConvType exp = 1;
for (int i = 0; i < bitLength(); i++) {
tmp += exp*get(i).binary_value();
exp *= 2;
}
return tmp;
// ConvType tmp = *(const_cast<ConvType*>((const ConvType*) (&(bits[0]))));
// //TODO FIXME I am a sketchy hack.
// ConvType mask = sizeof(ConvType) > bits.size() ? (1<<N)-1 : -1;
// return tmp & mask;
}
|
pushq %rax
movslq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x41675
movq (%rdi), %rdx
movl $0x1, %esi
xorl %edi, %edi
xorl %eax, %eax
movzbl (%rdx,%rdi), %r8d
cmpl $0x2, %r8d
jae 0x41679
imull %esi, %r8d
addl %r8d, %eax
movzwl %si, %esi
addl %esi, %esi
incq %rdi
cmpq %rdi, %rcx
jne 0x41654
jmp 0x41677
xorl %eax, %eax
popq %rcx
retq
leaq 0x25fbf(%rip), %rdi # 0x6763f
leaq 0x25bcc(%rip), %rsi # 0x67253
leaq 0x25fce(%rip), %rcx # 0x6765c
movl $0x78, %edx
callq 0x2d250
|
/dillonhuff[P]bsim/./src/quad_value_bit_vector.h
|
Catch::ResultBuilder& Catch::ExpressionLhs<unsigned short const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
|
ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movzwl (%rax), %eax
xorl %esi, %esi
cmpl %eax, (%rbx)
sete %sil
callq 0x46980
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x417b8
movq %r15, %rdi
movq %r14, %rsi
callq 0x46996
movq %rax, %r14
movl (%rbx), %esi
leaq 0x20(%rsp), %rdi
callq 0x4617b
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x469ac
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x25cba(%rip), %rsi # 0x673c6
leaq 0x25cb5(%rip), %rdx # 0x673c8
movq %rsp, %rdi
callq 0x3ef3e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x469c2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x41737
callq 0x2d360
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4174a
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4175d
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x41782
callq 0x2d360
jmp 0x41782
jmp 0x4177f
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4179c
callq 0x2d360
jmp 0x4179c
jmp 0x41799
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x417af
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::StringMakerBase<true>::convert<unsigned short>(unsigned short const&)
|
static std::string convert( T const& _value ) {
std::ostringstream oss;
oss << _value;
return oss.str();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
movzwl (%r14), %esi
movq %r15, %rdi
callq 0x2d270
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x407b9(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x4078b(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::createReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::Config> const&)
|
Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
if( !reporter ) {
std::ostringstream oss;
oss << "No reporter registered with name: '" << reporterName << "'";
throw std::domain_error( oss.str() );
}
return reporter;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r15
movq (%r12), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0x41a0a
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %rax
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %r15
movq %rax, (%r14)
testq %rax, %rax
je 0x41a2f
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x41a3f
movq (%rdi), %rax
callq *0x18(%rax)
testq %r15, %r15
je 0x41a57
movq %r14, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0x2d4b0
leaq 0x275ce(%rip), %rsi # 0x69036
leaq 0x28(%rsp), %rdi
movl $0x23, %edx
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0x2d420
leaq 0x27f50(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2d5a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2d460
xorl %ebp, %ebp
movq 0x404af(%rip), %rsi # 0x81f80
movq 0x404c8(%rip), %rdx # 0x81fa0
movq %r14, %rdi
callq 0x2d640
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41afe
callq 0x2d360
jmp 0x41afe
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x41b10
movq %r14, %rdi
callq 0x2d2d0
jmp 0x41b10
movq %rax, %rbx
movq 0x40499(%rip), %rsi # 0x81fb0
leaq 0x28(%rsp), %rdi
callq 0x2d1d0
leaq 0x98(%rsp), %rdi
callq 0x2d110
jmp 0x41b4a
movq %rax, %rbx
jmp 0x41b4a
jmp 0x41b52
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x41b4a
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::getRegistryHub()
|
inline RegistryHub*& getTheRegistryHub() {
static RegistryHub* theRegistryHub = CATCH_NULL;
if( !theRegistryHub )
theRegistryHub = new RegistryHub();
return theRegistryHub;
}
|
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x409d2(%rip) # 0x82538
jne 0x41bf8
movl $0xd0, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x3f478(%rip), %rax # 0x80ff8
movq %rax, (%rbx)
leaq 0x3f4c6(%rip), %rax # 0x81050
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x52492
leaq 0x3f7f2(%rip), %rax # 0x81390
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x70, %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq 0x3f804(%rip), %rax # 0x813e0
movq %rax, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
movq %rcx, 0xc8(%rbx)
movq %rbx, 0x40940(%rip) # 0x82538
movq 0x40939(%rip), %rax # 0x82538
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::addListeners(Catch::Ptr<Catch::IConfig const> const&, Catch::Ptr<Catch::IStreamingReporter>)
|
Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
it != itEnd;
++it )
reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
return reporters;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x48e38
movq (%rbx), %r12
movq 0x8(%rbx), %rbp
cmpq %rbp, %r12
je 0x41f9c
leaq 0x10(%rsp), %r13
movq (%r12), %rbx
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x18(%rsp)
movq (%r15), %rdi
movq %rdi, 0x20(%rsp)
testq %rdi, %rdi
je 0x41f23
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq *0x20(%rax)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x41f44
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %r13, %rdi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0x41d8d
movq %r14, %rdi
movq %r13, %rsi
callq 0x48db8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x41f6f
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x41f7f
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x41f8f
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %r12
cmpq %rbp, %r12
jne 0x41efe
movq (%r14), %rdi
movq 0x28(%rsp), %rbx
movq %rdi, (%rbx)
testq %rdi, %rdi
je 0x41fb2
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x48eb8
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42021
jmp 0x42019
jmp 0x42019
jmp 0x42019
movq %rax, %rbx
jmp 0x41fee
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x41fee
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x42007
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x42007
jmp 0x42019
jmp 0x42019
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x42024
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x42024
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x48eb8
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::runTests(Catch::Ptr<Catch::Config> const&)
|
Totals runTests( Ptr<Config> const& config ) {
Ptr<IConfig const> iconfig = config.get();
Ptr<IStreamingReporter> reporter = makeReporter( config );
reporter = addListeners( iconfig, reporter );
RunContext context( iconfig, reporter );
Totals totals;
context.testGroupStarting( config->name(), 1, 1 );
TestSpec testSpec = config->testSpec();
if( !testSpec.hasFilters() )
testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *iconfig );
for( std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
it != itEnd;
++it ) {
if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) )
totals += context.runTest( *it );
else
reporter->skipTest( *it );
}
context.testGroupEnded( iconfig->name(), totals, 1, 1 );
return totals;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x42060
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x41c1a
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
testq %rdi, %rdi
je 0x42082
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x110(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x41ea9
leaq 0x10(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x48db8
movq 0x110(%rsp), %rdi
testq %rdi, %rdi
je 0x420be
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x420ce
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x110(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x48ee0
pxor %xmm0, %xmm0
movdqu %xmm0, 0x20(%rbx)
movdqu %xmm0, 0x10(%rbx)
movdqu %xmm0, (%rbx)
movq (%r14), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
callq *0x30(%rax)
leaq 0x110(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x491f2
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42134
callq 0x2d360
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x50a00
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jne 0x4228c
callq 0x48044
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%r12)
movdqu %xmm0, 0x20(%r12)
movdqu %xmm0, 0x30(%r12)
leaq 0x40359(%rip), %rax # 0x824f0
movq %rax, 0x40(%r12)
leaq 0xc0(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x26eb3(%rip), %rsi # 0x69062
leaq 0x26eb0(%rip), %rdx # 0x69066
leaq 0xb0(%rsp), %rdi
callq 0x3ef3e
leaq 0x40(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x49278
movq %rax, %r14
movq %rax, %rdi
callq 0x50fdc
addq $0x50, %r14
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
callq 0x50a00
leaq 0x78(%rsp), %r14
pxor %xmm0, %xmm0
leaq 0xf0(%rsp), %rdi
movdqa %xmm0, (%rdi)
movdqa 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
leaq 0xd0(%rsp), %r15
movaps (%r15), %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x10(%r15), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x10(%rdi)
movdqa (%rdi), %xmm1
movdqa %xmm0, (%rdi)
movdqa %xmm1, (%r15)
movq $0x0, 0x10(%r15)
callq 0x518b0
movq %r15, %rdi
callq 0x518b0
movq 0xb0(%rsp), %rdi
cmpq %r13, %rdi
je 0x42266
callq 0x2d360
leaq 0x90(%rsp), %r15
movq %r15, %rdi
callq 0x518b0
movq %r14, %rdi
callq 0x50c8c
movq -0x38(%r15), %rdi
cmpq %r12, %rdi
je 0x4228c
callq 0x2d360
movq 0x8(%rsp), %r14
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x18(%rcx)
movq (%rax), %r14
movq 0x8(%rax), %r12
cmpq %r12, %r14
je 0x42372
leaq 0x20(%rsp), %r15
leaq 0x110(%rsp), %r13
movq 0x218(%rsp), %rdi
movq 0x228(%rsp), %rbp
movq (%rdi), %rax
callq *0x50(%rax)
cltq
cmpq %rax, %rbp
je 0x42351
movq 0x8(%rsp), %rbp
movq %r15, %rdi
movq %r14, %rsi
callq 0x49998
testb %al, %al
je 0x42351
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x20(%rax)
testb %al, %al
jne 0x42311
testb $0x10, 0x108(%r14)
jne 0x42351
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x49360
movdqu (%rbx), %xmm0
movdqu 0x10(%rbx), %xmm1
paddq 0x40(%rsp), %xmm0
movdqu 0x20(%rbx), %xmm2
movdqu %xmm0, (%rbx)
paddq 0x50(%rsp), %xmm1
movdqu %xmm1, 0x10(%rbx)
paddq 0x60(%rsp), %xmm2
movdqu %xmm2, 0x20(%rbx)
jmp 0x42362
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x80(%rax)
addq $0x118, %r14 # imm = 0x118
cmpq %r12, %r14
jne 0x422c8
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
callq *0x30(%rax)
leaq 0x110(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl $0x1, %ecx
movl $0x1, %r8d
movq %rbx, %rdx
leaq 0x50(%rsp), %r14
callq 0x4964e
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x423b6
callq 0x2d360
leaq 0x20(%rsp), %rdi
callq 0x518b0
leaq 0x110(%rsp), %rdi
callq 0x4977e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x423dd
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x423ed
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x424ad
jmp 0x42506
jmp 0x42506
jmp 0x42506
jmp 0x42506
jmp 0x4245a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x424c5
callq 0x2d360
jmp 0x424c5
jmp 0x424c2
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x424cf
callq 0x2d360
jmp 0x424cf
jmp 0x424b9
movq %rax, %rbx
jmp 0x424dc
movq %rax, %rbx
movq 0x110(%rsp), %rdi
testq %rdi, %rdi
je 0x4247f
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4247f
jmp 0x42506
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x424dc
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x424dc
jmp 0x42506
movq %rax, %rbx
jmp 0x424ec
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r13, %rdi
je 0x424ad
callq 0x2d360
leaq 0x40(%rsp), %rdi
callq 0x49312
jmp 0x424c5
movq %rax, %rbx
jmp 0x424cf
jmp 0x424c2
jmp 0x424c2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x518b0
leaq 0x110(%rsp), %rdi
callq 0x4977e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x424ec
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x424fc
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x2d690
jmp 0x42506
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::applyFilenamesAsTags(Catch::IConfig const&)
|
void applyFilenamesAsTags( IConfig const& config ) {
std::vector<TestCase> const& tests = getAllTestCasesSorted( config );
for(std::size_t i = 0; i < tests.size(); ++i ) {
TestCase& test = const_cast<TestCase&>( tests[i] );
std::set<std::string> tags = test.tags;
std::string filename = test.lineInfo.file;
std::string::size_type lastSlash = filename.find_last_of( "\\/" );
if( lastSlash != std::string::npos )
filename = filename.substr( lastSlash+1 );
std::string::size_type lastDot = filename.find_last_of( "." );
if( lastDot != std::string::npos )
filename = filename.substr( 0, lastDot );
tags.insert( "#" + filename );
setTags( test, tags );
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
movq (%rax), %rdx
movq %rax, (%rsp)
cmpq %rdx, 0x8(%rax)
je 0x42752
leaq 0x48(%rsp), %rbp
xorl %r14d, %r14d
leaq 0x58(%rsp), %r12
leaq 0x18(%rsp), %r15
leaq 0x38(%rsp), %rbx
xorl %r13d, %r13d
movq %r13, 0x8(%rsp)
movq %rbx, %r13
movq %r12, %rdi
movq %rbp, %rbx
movq %rdx, 0x10(%rsp)
leaq (%rdx,%r14), %rbp
addq $0x60, %rbp
movq %rbp, %rsi
callq 0x521d4
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rbp), %rsi
movq 0x88(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movl $0x2, %ecx
movq %r15, %rdi
leaq 0x26a3a(%rip), %rsi # 0x69067
movq $-0x1, %rdx
callq 0x2d740
cmpq $-0x1, %rax
movq %rbx, %rbp
movq %r13, %rbx
je 0x42677
incq %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x2d3e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2d480
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42677
callq 0x2d360
movl $0x1, %ecx
movq %r15, %rdi
leaq 0x27e10(%rip), %rsi # 0x6a496
movq $-0x1, %rdx
callq 0x2d740
cmpq $-0x1, %rax
je 0x426c2
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2d3e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2d480
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x426c2
callq 0x2d360
movq %rbx, %rdi
leaq 0x2710d(%rip), %rsi # 0x697d9
movq %r15, %rdx
callq 0x49917
movq %r12, %rdi
movq %rbx, %rsi
callq 0x64e4a
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x426ee
callq 0x2d360
movq 0x10(%rsp), %rdi
addq %r14, %rdi
movq %r12, %rsi
callq 0x427ac
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
movq 0x8(%rsp), %r13
je 0x42717
callq 0x2d360
movq %r12, %rdi
callq 0x5242a
incq %r13
movq (%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
subq %rdx, %rax
sarq $0x3, %rax
movabsq $-0x5075075075075075, %rcx # imm = 0xAF8AF8AF8AF8AF8B
imulq %rcx, %rax
addq $0x118, %r14 # imm = 0x118
cmpq %rax, %r13
jb 0x425d8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4277e
jmp 0x4277e
jmp 0x4277e
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42781
callq 0x2d360
jmp 0x42781
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4279a
callq 0x2d360
jmp 0x4279a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5242a
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::setTags(Catch::TestCaseInfo&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
|
void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags )
{
testCaseInfo.tags = tags;
testCaseInfo.lcaseTags.clear();
std::ostringstream oss;
for( std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) {
oss << "[" << *it << "]";
std::string lcaseTag = toLower( *it );
testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
testCaseInfo.lcaseTags.insert( lcaseTag );
}
testCaseInfo.tagsAsString = oss.str();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rdi
callq 0x53a74
leaq 0x90(%rbx), %rdi
movq %rdi, 0x8(%rsp)
callq 0x654da
leaq 0x30(%rsp), %rdi
callq 0x2d4b0
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0x42896
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r13
movl $0x1, %edx
movq %rbp, %rdi
leaq 0x26c9b(%rip), %rsi # 0x694ac
callq 0x2d420
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
movq %rbp, %rdi
callq 0x2d420
movl $0x1, %edx
movq %rax, %rdi
leaq 0x27464(%rip), %rsi # 0x69c9b
callq 0x2d420
leaq 0x20(%r12), %rsi
movq %r13, %rdi
callq 0x43fe4
movl 0x108(%rbx), %r15d
movq %r13, %rdi
callq 0x49e22
orl %r15d, %eax
movl %eax, 0x108(%rbx)
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x64c8c
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x42882
callq 0x2d360
movq %r12, %rdi
callq 0x2d430
movq %rax, %r12
cmpq %r14, %rax
jne 0x42802
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2d5a0
addq $0xc0, %rbx
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%r14), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x428ce
callq 0x2d360
movq 0x3f6db(%rip), %rsi # 0x81fb0
leaq 0x30(%rsp), %rdi
callq 0x2d1d0
leaq 0xa0(%rsp), %rdi
callq 0x2d110
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4291b
jmp 0x4291b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4291e
callq 0x2d360
jmp 0x4291e
movq %rax, %rbx
movq 0x3f68b(%rip), %rsi # 0x81fb0
leaq 0x30(%rsp), %rdi
callq 0x2d1d0
leaq 0xa0(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::operator<<(std::ostream&, Catch::SourceLineInfo const&)
|
std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
os << info.file << "(" << info.line << ")";
#else
os << info.file << ":" << info.line;
#endif
return os;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
callq 0x2d420
movq %rax, %r15
leaq 0x26943(%rip), %rsi # 0x69415
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0x2d270
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::filterTests(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&, Catch::TestSpec const&, Catch::IConfig const&)
|
std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
std::vector<TestCase> filtered;
filtered.reserve( testCases.size() );
for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
it != itEnd;
++it )
if( matchTest( *it, testSpec, config ) )
filtered.push_back( *it );
return filtered;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0x5075075075075075, %rsi # imm = 0xAF8AF8AF8AF8AF8B
imulq %rax, %rsi
callq 0x49a26
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0x42b89
movq %r15, %rdi
movq %r12, %rsi
callq 0x49998
testb %al, %al
je 0x42b80
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testb %al, %al
jne 0x42b75
testb $0x10, 0x108(%r12)
jne 0x42b80
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49ae8
addq $0x118, %r12 # imm = 0x118
jmp 0x42b49
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x42b98
movq %rax, %r14
movq %rbx, %rdi
callq 0x49b18
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::registerTestCase(Catch::ITestCase*, char const*, Catch::NameAndDesc const&, Catch::SourceLineInfo const&)
|
void registerTestCase
( ITestCase* testCase,
char const* classOrQualifiedMethodName,
NameAndDesc const& nameAndDesc,
SourceLineInfo const& lineInfo ) {
getMutableRegistryHub().registerTest
( makeTestCase
( testCase,
extractClassName( classOrQualifiedMethodName ),
nameAndDesc.name,
nameAndDesc.description,
lineInfo ) );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0x42d35
movq %rax, %rbx
leaq 0x70(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2d160
leaq 0x50(%rsp), %rdi
movq %rbp, %rsi
callq 0x49b55
movq (%r12), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2d160
movq 0x8(%r12), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x2d160
leaq 0x90(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r15, %rsi
movq %r14, %r9
callq 0x42df9
movq (%rbx), %rax
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
leaq 0x90(%rsp), %rdi
callq 0x49c76
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42c6c
callq 0x2d360
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42c7f
callq 0x2d360
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42c92
callq 0x2d360
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42ca8
callq 0x2d360
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x49c76
jmp 0x42ccf
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42ce7
callq 0x2d360
jmp 0x42ce7
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42cff
callq 0x2d360
jmp 0x42cff
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42d17
callq 0x2d360
jmp 0x42d17
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42d2d
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::getMutableRegistryHub()
|
inline RegistryHub*& getTheRegistryHub() {
static RegistryHub* theRegistryHub = CATCH_NULL;
if( !theRegistryHub )
theRegistryHub = new RegistryHub();
return theRegistryHub;
}
|
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x3f7f7(%rip) # 0x82538
jne 0x42dd3
movl $0xd0, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x3e29d(%rip), %rax # 0x80ff8
movq %rax, (%rbx)
leaq 0x3e2eb(%rip), %rax # 0x81050
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x52492
leaq 0x3e617(%rip), %rax # 0x81390
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x70, %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq 0x3e629(%rip), %rax # 0x813e0
movq %rax, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
movq %rcx, 0xc8(%rbx)
movq %rbx, 0x3f765(%rip) # 0x82538
movq 0x3f75e(%rip), %rax # 0x82538
addq $0x8, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::makeTestCase(Catch::ITestCase*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
|
TestCase makeTestCase( ITestCase* _testCase,
std::string const& _className,
std::string const& _name,
std::string const& _descOrTags,
SourceLineInfo const& _lineInfo )
{
bool isHidden( startsWith( _name, "./" ) ); // Legacy support
// Parse out tags
std::set<std::string> tags;
std::string desc, tag;
bool inTag = false;
for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
char c = _descOrTags[i];
if( !inTag ) {
if( c == '[' )
inTag = true;
else
desc += c;
}
else {
if( c == ']' ) {
TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
if( prop == TestCaseInfo::IsHidden )
isHidden = true;
else if( prop == TestCaseInfo::None )
enforceNotReservedTag( tag, _lineInfo );
tags.insert( tag );
tag.clear();
inTag = false;
}
else
tag += c;
}
}
if( isHidden ) {
tags.insert( "hide" );
tags.insert( "." );
}
TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
return TestCase( _testCase, info );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, (%rsp)
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0xa8(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x262bb(%rip), %rsi # 0x690eb
leaq 0x262b6(%rip), %rdx # 0x690ed
leaq 0x98(%rsp), %rdi
callq 0x3ef3e
leaq 0x98(%rsp), %rsi
movq %r13, 0x20(%rsp)
movq %r13, %rdi
callq 0x43f5c
movl %eax, %r13d
movq %r15, 0x18(%rsp)
movq %r14, 0x10(%rsp)
movq 0x98(%rsp), %rdi
cmpq %rbx, %rdi
je 0x42e78
callq 0x2d360
leaq 0x70(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rcx, -0x8(%r14)
movb %cl, (%r14)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rcx, -0x8(%r15)
movb %cl, (%r15)
cmpq %rcx, 0x8(%rbp)
je 0x42f64
movq %r12, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x28(%rsp), %r12
xorl %r15d, %r15d
movq (%rbp), %rax
movb (%rax,%r15), %al
testb $0x1, %bl
je 0x42efb
movq %r12, %rdi
cmpb $0x5d, %al
jne 0x42f08
movq %r12, %rdi
callq 0x49e22
testl %eax, %eax
je 0x42f12
movb $0x1, %r14b
cmpl $0x2, %eax
je 0x42f21
movl %r13d, %r14d
jmp 0x42f21
leaq 0x48(%rsp), %rdi
cmpb $0x5b, %al
jne 0x42f08
movb $0x1, %bl
jmp 0x42f44
movsbl %al, %esi
callq 0x2d330
jmp 0x42f44
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x49f23
movl %r13d, %r14d
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x64c8c
movq $0x0, 0x30(%rsp)
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
xorl %ebx, %ebx
movl %r14d, %r13d
incq %r15
cmpq 0x8(%rbp), %r15
jb 0x42ece
leaq 0x58(%rsp), %r14
leaq 0x38(%rsp), %r15
movq 0x8(%rsp), %r12
leaq 0xa8(%rsp), %rbx
testb $0x1, %r13b
movq 0x20(%rsp), %r13
je 0x42ff7
leaq 0x98(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x264fc(%rip), %rsi # 0x69481
leaq 0x264f9(%rip), %rdx # 0x69485
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x64e4a
movq 0x98(%rsp), %rdi
cmpq %rbx, %rdi
je 0x42fb5
callq 0x2d360
leaq 0x98(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x274cf(%rip), %rsi # 0x6a496
leaq 0x274c9(%rip), %rdx # 0x6a497
callq 0x3ef3e
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x64e4a
movq 0x98(%rsp), %rdi
cmpq %rbx, %rdi
je 0x42ff7
callq 0x2d360
leaq 0x98(%rsp), %rdi
leaq 0x48(%rsp), %rcx
leaq 0x68(%rsp), %r8
movq %r13, %rsi
movq 0x18(%rsp), %rdx
movq (%rsp), %r9
callq 0x4403c
leaq 0x98(%rsp), %rdx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x443d8
leaq 0x188(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43045
callq 0x2d360
movq %rbx, %r13
leaq 0x168(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4305e
callq 0x2d360
leaq 0x128(%rsp), %rdi
callq 0x5242a
leaq 0xf8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5242a
movq -0x20(%rbx), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x43091
callq 0x2d360
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x430a7
callq 0x2d360
movq 0x98(%rsp), %rdi
cmpq %r13, %rdi
je 0x430b9
callq 0x2d360
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x430c8
callq 0x2d360
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x430d7
callq 0x2d360
leaq 0x68(%rsp), %rdi
callq 0x5242a
movq %r12, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x430fa
jmp 0x4314b
movq %rbx, %rcx
movq %rax, %rbx
movq 0x98(%rsp), %rdi
cmpq %rcx, %rdi
je 0x4314e
callq 0x2d360
jmp 0x4314e
jmp 0x4314b
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x4a020
jmp 0x4314e
jmp 0x4314b
movq %rbx, %rcx
movq %rax, %rbx
movq 0x98(%rsp), %rdi
cmpq %rcx, %rdi
je 0x43180
callq 0x2d360
jmp 0x43180
movq %rax, %rbx
jmp 0x43180
jmp 0x4314b
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x43162
callq 0x2d360
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x43176
callq 0x2d360
leaq 0x68(%rsp), %rdi
callq 0x5242a
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::cleanUp()
|
inline RegistryHub*& getTheRegistryHub() {
static RegistryHub* theRegistryHub = CATCH_NULL;
if( !theRegistryHub )
theRegistryHub = new RegistryHub();
return theRegistryHub;
}
|
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x3f313(%rip) # 0x82538
jne 0x432b7
movl $0xd0, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x3ddb9(%rip), %rax # 0x80ff8
movq %rax, (%rbx)
leaq 0x3de07(%rip), %rax # 0x81050
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x52492
leaq 0x3e133(%rip), %rax # 0x81390
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x70, %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq 0x3e145(%rip), %rax # 0x813e0
movq %rax, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
movq %rcx, 0xc8(%rbx)
movq %rbx, 0x3f281(%rip) # 0x82538
movq 0x3f27a(%rip), %rdi # 0x82538
testq %rdi, %rdi
je 0x432c9
movq (%rdi), %rax
callq *0x8(%rax)
cmpq $0x0, 0x3f267(%rip) # 0x82538
jne 0x43363
movl $0xd0, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x3dd0d(%rip), %rax # 0x80ff8
movq %rax, (%rbx)
leaq 0x3dd5b(%rip), %rax # 0x81050
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x52492
leaq 0x3e087(%rip), %rax # 0x81390
movq %rax, 0x60(%rbx)
movq %rbx, %rax
addq $0x70, %rax
movl $0x0, 0x70(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq 0x3e099(%rip), %rax # 0x813e0
movq %rax, 0xb0(%rbx)
movups %xmm0, 0xb8(%rbx)
movq %rcx, 0xc8(%rbx)
movq %rbx, 0x3f1d5(%rip) # 0x82538
movq $0x0, 0x3f1ca(%rip) # 0x82538
movq 0x3f103(%rip), %rdi # 0x82478
testq %rdi, %rdi
je 0x43380
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x3f0ed(%rip) # 0x82478
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x43395
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::NotImplementedException::NotImplementedException(Catch::SourceLineInfo const&)
|
NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
: m_lineInfo( lineInfo ) {
std::ostringstream oss;
oss << lineInfo << ": function ";
oss << "not implemented";
m_what = oss.str();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3c584(%rip), %rax # 0x7f990
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rbp
movq %rbp, 0x28(%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movq 0x20(%r12), %rax
movq %rax, 0x48(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x2d4b0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x42ab1
leaq 0x25c46(%rip), %rsi # 0x690b3
leaq 0x20(%rsp), %rdi
movl $0xb, %edx
callq 0x2d420
leaq 0x25c3c(%rip), %rsi # 0x690bf
leaq 0x20(%rsp), %rdi
movl $0xf, %edx
callq 0x2d420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d480
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x434bf
callq 0x2d360
movq 0x3eaea(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x434fb
movq %rax, %r12
jmp 0x4351c
movq %rax, %r12
jmp 0x43529
movq %rax, %r12
movq 0x3eaab(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x43529
callq 0x2d360
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x43536
callq 0x2d360
movq %rbx, %rdi
callq 0x2d6d0
movq %r12, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::FileStream::FileStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
FileStream::FileStream( std::string const& filename ) {
m_ofs.open( filename.c_str() );
if( m_ofs.fail() ) {
std::ostringstream oss;
oss << "Unable to open file: '" << filename << "'";
throw std::domain_error( oss.str() );
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3c452(%rip), %rax # 0x7f9b8
movq %rax, (%rdi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2d630
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x2d070
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x435a1
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdi
callq 0x2d4b0
leaq 0x25b1d(%rip), %rsi # 0x690cf
leaq 0x20(%rsp), %rdi
movl $0x16, %edx
callq 0x2d420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0x2d420
leaq 0x26406(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2d460
xorl %ebp, %ebp
movq 0x3e969(%rip), %rsi # 0x81f80
movq 0x3e982(%rip), %rdx # 0x81fa0
movq %r14, %rdi
callq 0x2d640
movq %rax, %r15
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43644
callq 0x2d360
jmp 0x43644
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0x43656
movq %r14, %rdi
callq 0x2d2d0
jmp 0x43656
movq %rax, %r15
movq 0x3e953(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
jmp 0x4367b
jmp 0x43678
movq %rax, %r15
movq %rbx, %rdi
callq 0x2d540
movq %r15, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::DebugOutStream::DebugOutStream()
|
DebugOutStream::DebugOutStream()
: m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
m_os( m_streamBuf.get() )
{}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3c33e(%rip), %rax # 0x7f9e0
movq %rax, (%rdi)
movl $0x148, %edi # imm = 0x148
callq 0x2d3a0
movq %rax, %r14
movq 0x3e8cf(%rip), %rax # 0x81f88
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x38(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
callq 0x2d730
leaq 0x3e39e(%rip), %rax # 0x81a80
movq %rax, (%r14)
leaq 0x40(%r14), %rax
leaq 0x140(%r14), %rcx
movq %rax, 0x28(%r14)
movq %rax, 0x20(%r14)
movq %rcx, 0x30(%r14)
movq %r14, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x2d150
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x43726
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::getCurrentMutableContext()
|
IMutableContext& getCurrentMutableContext() {
if( !currentContext )
currentContext = new Context();
return *currentContext;
}
|
cmpq $0x0, 0x3ed05(%rip) # 0x82478
jne 0x437bd
pushq %rax
movl $0x50, %edi
callq 0x2d3a0
leaq 0x3dcb1(%rip), %rcx # 0x81438
movq %rcx, (%rax)
leaq 0x28(%rax), %rcx
movl $0x0, 0x28(%rax)
xorl %edx, %edx
movq %rdx, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rdx, 0x18(%rax)
movq %rcx, 0x38(%rax)
movq %rcx, 0x40(%rax)
movq %rdx, 0x48(%rax)
movq %rax, 0x3ecbf(%rip) # 0x82478
addq $0x8, %rsp
movq 0x3ecb4(%rip), %rax # 0x82478
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Colour::use(Catch::Colour::Code)
|
void Colour::use( Code _colourCode ) {
static IColourImpl* impl = isDebuggerActive()
? NoColourImpl::instance()
: platformColourInstance();
impl->use( _colourCode );
}
|
pushq %rbx
movl %edi, %ebx
movb 0x3ecaf(%rip), %al # 0x82488
testb %al, %al
je 0x437f0
movq 0x3ec9c(%rip), %rdi # 0x82480
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl %ebx, %esi
popq %rbx
jmpq *%rax
leaq 0x3ec91(%rip), %rdi # 0x82488
callq 0x2d6b0
testl %eax, %eax
je 0x437dd
callq 0x43868
movq %rax, 0x3ec74(%rip) # 0x82480
leaq 0x3ec75(%rip), %rdi # 0x82488
callq 0x2d240
jmp 0x437dd
movq %rax, %rbx
leaq 0x3ec64(%rip), %rdi # 0x82488
callq 0x2d220
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::(anonymous namespace)::platformColourInstance()
|
IContext& getCurrentContext() {
return getCurrentMutableContext();
}
|
pushq %rbx
subq $0x10, %rsp
callq 0x4376b
movq (%rax), %rcx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x43898
movq (%rdi), %rax
callq *0x80(%rax)
testb %al, %al
jne 0x438a6
movl $0x1, %edi
callq 0x2d670
testl %eax, %eax
je 0x438d5
movb 0x3ec9c(%rip), %al # 0x82548
leaq 0x3eb85(%rip), %rbx # 0x82438
testb %al, %al
jne 0x438e1
leaq 0x3ec8a(%rip), %rdi # 0x82548
callq 0x2d6b0
testl %eax, %eax
je 0x438e1
leaq 0x3ec7a(%rip), %rdi # 0x82548
callq 0x2d240
jmp 0x438e1
callq 0x43852
leaq 0x3eb4f(%rip), %rbx # 0x82430
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x438f1
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
jmp 0x43917
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4390f
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::createGeneratorsForTest()
|
IGeneratorsForTest* createGeneratorsForTest()
{
return new GeneratorsForTest();
}
|
pushq %rax
movl $0x50, %edi
callq 0x2d3a0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x10(%rax), %rcx
leaq 0x3db65(%rip), %rdx # 0x814b0
movq %rdx, (%rax)
movl $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
popq %rcx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionInfo::AssertionInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::ResultDisposition::Flags)
|
AssertionInfo::AssertionInfo( std::string const& _macroName,
SourceLineInfo const& _lineInfo,
std::string const& _capturedExpression,
ResultDisposition::Flags _resultDisposition )
: macroName( _macroName ),
lineInfo( _lineInfo ),
capturedExpression( _capturedExpression ),
resultDisposition( _resultDisposition )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
movq 0x20(%r12), %rax
movq %rax, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movl %ebp, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x43a07
callq 0x2d360
jmp 0x43a07
movq %rax, %r15
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x43a15
callq 0x2d360
movq %r15, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::AssertionResult(Catch::AssertionInfo const&, Catch::AssertionResultData const&)
|
AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
: m_info( info ),
m_resultData( data )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r12
leaq 0x30(%rbx), %rbp
movq %rbp, 0x20(%rbx)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
movq 0x40(%r15), %rax
movq %rax, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
movq 0x48(%r15), %rsi
movq 0x50(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movl 0x68(%r15), %eax
movl %eax, 0x68(%rbx)
leaq 0x70(%rbx), %r15
leaq 0x80(%rbx), %r12
movq %r12, 0x70(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
leaq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
movq %rax, 0x90(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movl 0x40(%r14), %eax
movl %eax, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x43b74
callq 0x2d360
jmp 0x43b74
movq %rax, %r14
movq %rbx, %rdi
callq 0x49d12
jmp 0x43ba1
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x43b94
callq 0x2d360
jmp 0x43b94
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x43ba1
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::~AssertionResult()
|
AssertionResult::~AssertionResult() {}
|
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0x43bc6
callq 0x2d360
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x43bdb
callq 0x2d360
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x43bed
callq 0x2d360
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x43bff
callq 0x2d360
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x43c11
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::getExpression[abi:cxx11]() const
|
std::string AssertionResult::getExpression() const {
if( isFalseTest( m_info.resultDisposition ) )
return "!" + m_info.capturedExpression;
else
return m_info.capturedExpression;
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
testb $0x4, 0x68(%rsi)
jne 0x43c7d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x48(%rdx), %rsi
movq 0x50(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
jmp 0x43c90
addq $0x48, %rdx
leaq 0x2545e(%rip), %rsi # 0x690e6
movq %rbx, %rdi
callq 0x49917
movq %rbx, %rax
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const
|
std::string AssertionResult::getExpandedExpression() const {
return m_resultData.reconstructedExpression;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x70(%rsi), %rax
movq 0x78(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::getMessage[abi:cxx11]() const
|
std::string AssertionResult::getMessage() const {
return m_resultData.message;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x90(%rsi), %rax
movq 0x98(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::getSourceInfo() const
|
SourceLineInfo AssertionResult::getSourceInfo() const {
return m_info.lineInfo;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%rsi), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x40(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::getTestMacroName[abi:cxx11]() const
|
std::string AssertionResult::getTestMacroName() const {
return m_info.macroName;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::startsWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
bool startsWith( std::string const& s, std::string const& prefix ) {
return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq 0x8(%rdi), %r13
movq 0x8(%rsi), %rbx
cmpq %rbx, %r13
jae 0x43f7e
xorl %r14d, %r14d
jmp 0x43fbb
movq %rdi, %rsi
xorl %r14d, %r14d
movq %rsp, %r12
movq %r12, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x2d3e0
movq 0x8(%r12), %rdx
cmpq 0x8(%r15), %rdx
jne 0x43fbb
testq %rdx, %rdx
je 0x43fb8
movq (%r15), %rsi
movq (%rsp), %rdi
callq 0x2d3d0
testl %eax, %eax
sete %r14b
jmp 0x43fbb
movb $0x1, %r14b
cmpq %rbx, %r13
jb 0x43fd3
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43fd3
callq 0x2d360
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.