name string | code string | asm string | file string |
|---|---|---|---|
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
// flus... | 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 0x... | /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),... | /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... | 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... | /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 " << fi... | 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(%... | /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 tempo... | 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
mo... | /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)
and... | /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>(s... | 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());
... | 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_st... | 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, OrganizationMod... | 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 0xc43... | /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_stri... | 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());
... | 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, %r... | /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>>>>,... | 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());
... | 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, doub... | 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, OrganizationMod... | 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 0xd28... | /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, do... | 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());
... | 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... | 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());
... | 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, %r... | /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>... | 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)
{
{
... | 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)
xor... | /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.initB... | 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 ... | /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
mov... | /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 %r... | /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,... | 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 0x20... | /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->ch... | 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, 0x... | /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));
... | 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), %... | /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 - ... | 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 ... | /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 %xmm... | /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 = ... | 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 # 0x5... | /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 *... | 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
lea... | /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];
byt... | 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 %ra... | /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
... | 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, %ea... | /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, &clientLengt... | 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 ... | /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 ... | 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(%... | /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)) {
... | 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... | /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, MT... | 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 0x... | /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);
bro... | 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
rol... | /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;... | 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(%r... | /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));
ownA... | 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, ... | /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)->... | 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), %ra... | /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... | 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),... | /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)... | 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, ... | /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 ... | /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... | /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... | /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.ge... | 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, ... | /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... | 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... | /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
c... | /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... | /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
mov... | /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, %... | /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 0x... | /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... | /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
m... | /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
... | /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 sk... | 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 0x280... | /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 sk... | 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... | /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];
} e... | 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
m... | /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 %c... | /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_r... | 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 ... | /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
... | /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
... | /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, %... | /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;
... | 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 $0x... | /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 %r... | /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 %r... | /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 %r... | /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 %r... | /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
... | /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
mov... | /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, %... | /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
... | /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 ... | /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
mov... | /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 sk... | 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 ... | /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
... | /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... | /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 reg... | 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 ... | /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 # 0x813... | /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();... | 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 0x48e... | /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.testGrou... | 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
mo... | /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... | 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), %r... | /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 <... | 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
j... | /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
ret... | /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();
... | 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... | /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,
... | 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 %... | /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 # 0x813... | /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::SourceLineInf... | TestCase makeTestCase( ITestCase* _testCase,
std::string const& _className,
std::string const& _name,
std::string const& _descOrTags,
SourceLineInfo const& _lineInfo )
{
bool isHidden( startsWith... | 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 # ... | /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 # 0x813... | /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... | /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... | /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)
mo... | /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)
m... | /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, 0x3ec7... | /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), %a... | /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... | /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 ... | 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... | /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), %rs... | /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),... | /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, %ra... | /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... | /dillonhuff[P]bsim/test/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.