name string | code string | asm string | file string |
|---|---|---|---|
SymbolTableTree::GetArraySpace(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&, int&) | compile_errcode SymbolTableTree::GetArraySpace(const string& begin_func_name, const string& name, int& array_space) {
int ret = COMPILE_OK;
string cur_func_name = begin_func_name;
do {
auto iter = m_table_tree.begin();
for (; iter != m_table_tree.end(); ++iter) {
if (iter->first... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, (%rsp)
movq %rsi, %rcx
movq %rdi, %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq %rcx, 0x28(%rsp)
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x253b8
leaq 0x4... | /PaParaZz1[P]c0_compile/src/c0_compile_symbol.cpp |
SymbolTableTree::GetTermIntValue(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&, int&) | compile_errcode SymbolTableTree::GetTermIntValue(const string& begin_func_name, const string& name, int& value) {
int ret = COMPILE_OK;
string cur_func_name = begin_func_name;
do {
auto iter = m_table_tree.begin();
for (; iter != m_table_tree.end(); ++iter) {
if (iter->first == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, (%rsp)
movq %rsi, %rcx
movq %rdi, %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq %rcx, 0x28(%rsp)
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x253b8
leaq 0x4... | /PaParaZz1[P]c0_compile/src/c0_compile_symbol.cpp |
FunctionTableTerm::PrintTerm() const | void FunctionTableTerm::PrintTerm() const {
fprintf(fp_symbol, "--------------------------------------\n");
fprintf(fp_symbol, "function\nname: %s\ntop label: %s\nbottom label: %s\nargument space: %d\nreturn value space: %d\nspace length: %d\nargument type:\n",
m_func_name.c_str(), m_top_label.c_str(), m_bo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4df20(%rip), %rcx # 0x75940
leaq 0x38b66(%rip), %rdi # 0x6058d
movl $0x27, %esi
movl $0x1, %edx
callq 0x21550
movq 0x4df03(%rip), %rdi # 0x75940
movq (%rbx), %rdx
movq 0x20(%rbx), %rcx
movq 0x40(%rbx), %r8
movl 0x60(%rbx), %r9d
mo... | /PaParaZz1[P]c0_compile/src/c0_compile_symbol.cpp |
FunctionTable::InsertTerm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::vector<_SymbolType, std::allocator<_SymbolType>> const&) | void FunctionTable::InsertTerm(const string& func_name,
int space_length,
int return_value_number,
const vector<SymbolType>& argument_type) {
int argument_number = argument_type.size();
FunctionTableTerm term(func_name,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %rbx
movq 0x8(%r8), %r12
subq (%r8), %r12
shrq $0x2, %r12
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r13
movq... | /PaParaZz1[P]c0_compile/src/c0_compile_symbol.cpp |
FunctionTable::SetTermBottomLabel(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&) | void FunctionTable::SetTermBottomLabel(const string& func_name, const string& bottom_label) {
auto iter = m_func_table.begin();
for (; iter != m_func_table.end(); ++iter) {
if (iter->GetName() == func_name) {
iter->SetBottomLabel(bottom_label);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x28333
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rbp
addq $0x40, %r12
movl $0x88, %ebx
movq %rbp, 0x8(%rsp)
movq -0x40(%r12), %rsi
movq -0x38(%r12), %rdx
addq %rsi, %rd... | /PaParaZz1[P]c0_compile/src/c0_compile_symbol.cpp |
SymbolTable::SymbolTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _SymbolType const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | SymbolTable(const string& name, const SymbolType& type, const string& previous_level_name, int base_address)
: m_table_name(name), m_table_type(type), m_previous_level_name(previous_level_name), m_table_base_address(base_address) {
m_table_address_length = 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r15
leaq 0x28(%rdi), %r13
movq %r13, 0x18(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %... | /PaParaZz1[P]c0_compile/include/c0_compile_symbol.hpp |
LexicalAnalysis::ParseDigit(Symbol&, bool) | compile_errcode LexicalAnalysis::ParseDigit(Symbol& symbol, bool negative) {
long sum = 0;
int number_count = 0;
bool first_flag = true;
bool zero_flag = false;
do {
if (first_flag) {
first_flag = false;
if (ch == '0')
zero_flag = true;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rdx
movb $0x1, %bpl
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %r12d, %r12d
movl %r14d, 0xc(%rsp)
movsbq 0x8(%rdx), %r13
cmpq $0x30, %r13
movzbl %bpl, %ebp
... | /PaParaZz1[P]c0_compile/src/c0_compile_lexical_analysis.cpp |
void Symbol::SetValue<int>(int) | explicit SymbolValue(int _value) {
memcpy(&value, &_value, sizeof(int));
} | pushq %rbx
subq $0x30, %rsp
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
movl %esi, -0x18(%rbx)
movl %esi, 0x8(%rdi)
addq $0x10, %rdi
movq %rax, %rsi
callq 0x21390
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x2a576
callq 0x212a0
addq $0x30, %rsp
popq %rbx
ret... | /PaParaZz1[P]c0_compile/include/c0_compile_symbol.hpp |
Factor::Parse() | compile_errcode Factor::Parse() {
int ret = COMPILE_OK;
SymbolName name = handle_symbol_queue->GetCurrentName();
switch (name) {
case INTERGER_SYM: break;
case CHARACTER_SYM: break;
case IDENTIFIER_SYM: {
handle_symbol_queue->SetCacheLocate();
handle_symbol_qu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x4b259(%rip), %r14 # 0x75990
movq (%r14), %rdi
callq 0x2a4f0
cmpl $0x21, %eax
jg 0x2a758
cmpl $0x1a, %eax
je 0x2a7f8
cmpl $0x20, %eax
je 0x2a888
jmp 0x2a7d2
cmpl $0x25, %eax
je 0x2a888
cmpl $0x22, %eax
jne 0x2a7d2
movq (%r14), %rdi
callq 0x2a52... | /PaParaZz1[P]c0_compile/src/c0_compile_gramma_analysis.cpp |
VariableDefinition::Parse() | compile_errcode VariableDefinition::Parse() {
int state = 0;
while (true) {
SymbolName name = handle_symbol_queue->GetCurrentName();
switch (state) {
case 0: {
if (IsValidVariableType(name)) {
state = 1;
break;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x4a946(%rip), %r14 # 0x75990
leaq 0x35863(%rip), %r15 # 0x608b4
leaq 0x8(%rsp), %r12
movq (%r14), %rdi
callq 0x2a4f0
cmpl $0xd, %ebx
ja 0x2b245
movl %ebx, %ecx
movslq (%r15,%rcx,4), %rc... | /PaParaZz1[P]c0_compile/src/c0_compile_gramma_analysis.cpp |
ReturnStatement::Parse() | compile_errcode ReturnStatement::Parse() {
int ret = COMPILE_OK;
int state = 0;
while (true) {
SymbolName name = handle_symbol_queue->GetCurrentName();
switch (state) {
case 0: {
if (name == RETURN_SYM) {
state = 1;
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
xorl %ebx, %ebx
leaq 0x4a3c6(%rip), %r13 # 0x75990
leaq 0x3532f(%rip), %rbp # 0x60900
movq (%r13), %rdi
callq 0x2a4f0
cmpl $0x4, %ebx
ja 0x2b740
movl %ebx, %ecx
movslq (%rbp,%rcx,4), %rcx
add... | /PaParaZz1[P]c0_compile/src/c0_compile_gramma_analysis.cpp |
Default::Parse() | compile_errcode Default::Parse() {
int ret = COMPILE_OK;
int state = 0;
while (true) {
SymbolName name = handle_symbol_queue->GetCurrentName();
switch (state) {
case 0: {
if (name == DEFAULT_SYM) {
state = 1;
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
xorl %r12d, %r12d
leaq 0x48c34(%rip), %r15 # 0x75990
leaq 0x47455(%rip), %r13 # 0x741b8
leaq 0x474a6(%rip), %r14 # 0x74210
xorl %ebx, %ebx
movq (%r15), %rdi
callq 0x2a4f0
cmpl $0x2, %ebx
je 0x2cdf5
cmpl $0x1... | /PaParaZz1[P]c0_compile/src/c0_compile_gramma_analysis.cpp |
Term::LogOutput() | void LogOutput() {
string str("This is a switch child statement");
g_log_tools->GrammaNormalLogs(str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x32a86(%rip), %rsi # 0x6105d
leaq 0x32a8d(%rip), %rdx # 0x6106b
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25f16
leaq 0x474ae(%rip), %rax # 0x75aa0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5f230
movq 0x8(%rsp), %rdi... | /PaParaZz1[P]c0_compile/include/c0_compile_gramma.hpp |
InputStatement::LogOutput() | void LogOutput() {
string str("This is a switch child statement");
g_log_tools->GrammaNormalLogs(str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x32781(%rip), %rsi # 0x61136
leaq 0x32793(%rip), %rdx # 0x6114f
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25f16
leaq 0x470d0(%rip), %rax # 0x75aa0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5f230
movq 0x8(%rsp), %rdi... | /PaParaZz1[P]c0_compile/include/c0_compile_gramma.hpp |
WhileLoopStatement::LogOutput() | void LogOutput() {
string str("This is a switch child statement");
g_log_tools->GrammaNormalLogs(str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x325c9(%rip), %rsi # 0x611a4
leaq 0x325e0(%rip), %rdx # 0x611c2
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25f16
leaq 0x46eaa(%rip), %rax # 0x75aa0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5f230
movq 0x8(%rsp), %rdi... | /PaParaZz1[P]c0_compile/include/c0_compile_gramma.hpp |
Statement::LogOutput() | void LogOutput() {
string str("This is a switch child statement");
g_log_tools->GrammaNormalLogs(str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3252c(%rip), %rsi # 0x611e3
leaq 0x32538(%rip), %rdx # 0x611f6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25f16
leaq 0x46dce(%rip), %rax # 0x75aa0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5f230
movq 0x8(%rsp), %rdi... | /PaParaZz1[P]c0_compile/include/c0_compile_gramma.hpp |
VariableDeclaration::LogOutput() | void LogOutput() {
string str("This is a switch child statement");
g_log_tools->GrammaNormalLogs(str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x32483(%rip), %rsi # 0x61216
leaq 0x3249a(%rip), %rdx # 0x61234
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25f16
leaq 0x46cf2(%rip), %rax # 0x75aa0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5f230
movq 0x8(%rsp), %rdi... | /PaParaZz1[P]c0_compile/include/c0_compile_gramma.hpp |
ValueArgumentList::LogOutput() | void LogOutput() {
string str("This is a switch child statement");
g_log_tools->GrammaNormalLogs(str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x322d5(%rip), %rsi # 0x612fc
leaq 0x322eb(%rip), %rdx # 0x61319
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x25f16
leaq 0x46a5e(%rip), %rax # 0x75aa0
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x5f230
movq 0x8(%rsp), %rdi... | /PaParaZz1[P]c0_compile/include/c0_compile_gramma.hpp |
ArgumentCheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, std::vector<_SymbolType, std::allocator<_SymbolType>>&) | void ArgumentCheck(const string& identifier_name, int line_number, int character_number, vector<SymbolType>& value_argument_type) {
if (!handle_func_table->Find(identifier_name)) {
return;
}
vector<SymbolType> argument_type;
handle_func_table->GetTermArgumentType(identifier_name, argument_type);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r12
movl %edx, 0x4(%rsp)
movl %esi, (%rsp)
movq %rdi, %rbp
leaq 0x4616c(%rip), %rbx # 0x75980
movq (%rbx), %rdi
movq %rbp, %rsi
callq 0x27bc0
testb %al, %al
je 0x2fd9d
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rdx
movaps %xmm0... | /PaParaZz1[P]c0_compile/src/c0_compile_semantic_analysis.cpp |
SwitchStatement::Action() | compile_errcode SwitchStatement::Action() {
int ret = COMPILE_OK;
int state = 0;
SymbolType expression_type;
while (true) {
SymbolName name = handle_correct_queue->GetCurrentName();
switch (state) {
case 0: {
if (name == SWITCH_SYM) {
state... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rbx
xorl %r14d, %r14d
leaq 0x2e283(%rip), %r12 # 0x61480
movq 0x427a4(%rip), %rdi # 0x759a8
callq 0x2a4f0
cmpl $0x... | /PaParaZz1[P]c0_compile/src/c0_compile_semantic_analysis.cpp |
PcodeGenerator::CanInline(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 PcodeGenerator::CanInline(const string& top_label, const string& bottom_label) {
if (top_label == "main")
return false;
vector<Pcode>::iterator iter_top;
vector<Pcode>::iterator iter_bottom;
auto iter = m_pcode_queue.begin();
for (; iter != m_pcode_queue.end(); ++iter) {
PcodeTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2d82a(%rip), %rsi # 0x62d7e
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x210d0
testl %eax, %eax
je 0x3565c
movq 0x18(%rbx), %r12
cmpq 0x20(%rbx), %r12
je 0x35663
xorl %r14... | /PaParaZz1[P]c0_compile/src/c0_compile_pcode.cpp |
Pcode::~Pcode() | Pcode(PcodeType op, string num1, string num2, string num3) : m_op(op), m_num1(num1), m_num2(num2), m_num3(num3) {
m_comment = string("");
} | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x37f5a
callq 0x212a0
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x37f6c
callq 0x212a0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x37f7e
callq 0x212a0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
... | /PaParaZz1[P]c0_compile/include/c0_compile_pcode.hpp |
void __gnu_cxx::new_allocator<Pcode>::construct<Pcode, Pcode>(Pcode*, Pcode&&) | Pcode(PcodeType op, string num1, string num2, string num3) : m_op(op), m_num1(num1), m_num2(num2), m_num3(num3) {
m_comment = string("");
} | movl (%rdx), %eax
movl %eax, (%rsi)
leaq 0x18(%rsi), %rcx
movq %rcx, 0x8(%rsi)
movq 0x8(%rdx), %rdi
leaq 0x18(%rdx), %rax
cmpq %rax, %rdi
je 0x39318
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x3931e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rsi)
movq %rax, 0... | /PaParaZz1[P]c0_compile/include/c0_compile_pcode.hpp |
ConstantDefinition::Generate() | compile_errcode ConstantDefinition::Generate() {
int state = 0;
int ret = 0;
while (true) {
SymbolName name = handle_correct_queue->GetCurrentName();
int line_number = handle_correct_queue->GetCurrentLine();
int character_number = handle_correct_queue->GetCurrentCharacter();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
leaq 0x2ad03(%rip), %r13 # 0x759a8
leaq 0x17b70(%rip), %r12 # 0x6281c
movq (%r13), %rdi
callq 0x2a4f0
cmpl $0x6, %r15d
ja 0x4adf4
movl %r15d, %ecx
movslq (%r12,%rcx,4), %rcx... | /PaParaZz1[P]c0_compile/src/c0_compile_generate.cpp |
ConstantDeclaration::Generate() | compile_errcode ConstantDeclaration::Generate() {
int ret = 0;
int correct_count = 0;
while (true) {
SymbolName name = handle_correct_queue->GetCurrentName();
if (name == CONST_SYM) {
if ((ret = m_constant_definition.Generate()) == COMPILE_OK) {
correct_count++;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
xorl %r14d, %r14d
leaq 0x2ab78(%rip), %r15 # 0x759a8
movq (%r15), %rdi
callq 0x2a4f0
cmpl $0x16, %eax
jne 0x4ae50
movq %rbx, %rdi
callq 0x4ac86
testl %eax, %eax
je 0x4ae63
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x4ae... | /PaParaZz1[P]c0_compile/src/c0_compile_generate.cpp |
VariableDefinition::Generate() | compile_errcode VariableDefinition::Generate() {
int state = 0;
while (true) {
SymbolName name = handle_correct_queue->GetCurrentName();
int line_number = handle_correct_queue->GetCurrentLine();
int character_number = handle_correct_queue->GetCurrentCharacter();
switch (state) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorl %r15d, %r15d
leaq 0x2ab11(%rip), %r13 # 0x759a8
leaq 0x1799a(%rip), %r12 # 0x62838
movq (%r13), %rdi
callq 0x2a4f0
cmpl $0xd, %r15d
ja 0x4b000
movq (%r13), %rcx
movl %r15d, %edx
movslq (... | /PaParaZz1[P]c0_compile/src/c0_compile_generate.cpp |
GlobalJudgeMips(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool GlobalJudgeMips(const string& str) {
std::regex re("g\\d+");
return std::regex_match(str, re);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xf873(%rip), %rsi # 0x619b8
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x37c64
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rcx
xorl ... | /PaParaZz1[P]c0_compile/src/c0_compile_mips.cpp |
MipsGenerator::FindRelativeAddr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&) | compile_errcode MipsGenerator::FindRelativeAddr(string temp_name, int& addr) {
auto iter = m_temp2address.find(temp_name);
if (iter != m_temp2address.end()) {
addr = iter->second;
return COMPILE_OK;
} else {
return -3;
}
} | pushq %rbx
movq %rdx, %rbx
addq $0x48, %rdi
callq 0x4752a
testq %rax, %rax
je 0x52ec3
movl 0x28(%rax), %eax
movl %eax, (%rbx)
xorl %eax, %eax
jmp 0x52ec8
movl $0xfffffffd, %eax # imm = 0xFFFFFFFD
popq %rbx
retq
| /PaParaZz1[P]c0_compile/src/c0_compile_mips.cpp |
MipsGenerator::TranslateADD(Pcode&) | void MipsGenerator::TranslateADD(Pcode& item) {
string num1 = item.GetNum1();
string num2 = item.GetNum2();
string num3 = item.GetNum3();
int ret1 = PrepareStoreREG(num1, reg1, NUM1);
int ret2 = PrepareLoadREG(num2, reg2, NUM2);
int ret3 = PrepareLoadREG(num3, reg3, NUM3);
if (ret2 == -1 && ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf8(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0xe8(%rsp), %rdi
callq 0x253b8
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(... | /PaParaZz1[P]c0_compile/src/c0_compile_mips.cpp |
MipsGenerator::TranslateMULType(Pcode&) | void MipsGenerator::TranslateMULType(Pcode& item) {
string num1 = item.GetNum1();
string num2 = item.GetNum2();
string num3 = item.GetNum3();
PcodeType op_type = item.GetOP();
string op;
if (op_type == MUL)
op = string("mul ");
else if (op_type == DIV)
op = string("div ");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x118(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x108(%rsp), %rdi
callq 0x253b8
leaq 0xd8(%rsp), %rax
movq %rax, -0x1... | /PaParaZz1[P]c0_compile/src/c0_compile_mips.cpp |
MipsGenerator::TranslateJUMP(Pcode&) | void MipsGenerator::TranslateJUMP(Pcode& item) {
string num1 = item.GetNum1();
if (num1 == "RA") {
Output2File("jr $ra");
} else {
Output2File("j " + num1);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x253b8
leaq 0x48c3(%rip), %rsi # 0x61982
movq %r14, %rdi
callq 0x210d0
testl %eax, %eax
je... | /PaParaZz1[P]c0_compile/src/c0_compile_mips.cpp |
mbedtls_blowfish_setkey | int mbedtls_blowfish_setkey( mbedtls_blowfish_context *ctx, const unsigned char *key,
unsigned int keybits )
{
unsigned int i, j, k;
uint32_t data, datal, datar;
if( keybits < MBEDTLS_BLOWFISH_MIN_KEY_BITS || keybits > MBEDTLS_BLOWFISH_MAX_KEY_BITS ||
( keybits % 8 ) )
{
... | leal -0x20(%rdx), %eax
cmpl $0x1a1, %eax # imm = 0x1A1
setae %al
testb $0x7, %dl
setne %cl
orb %al, %cl
jne 0x40ff
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48(%rdi), %rax
leaq 0x1863(%rip), %rcx # 0x5930
xorl %edi, %edi
movl $0x400, %r8d ... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
blowfish_enc | static void blowfish_enc( mbedtls_blowfish_context *ctx, uint32_t *xl, uint32_t *xr )
{
uint32_t Xl, Xr, temp;
short i;
Xl = *xl;
Xr = *xr;
for( i = 0; i < MBEDTLS_BLOWFISH_ROUNDS; ++i )
{
Xl = Xl ^ ctx->P[i];
Xr = F( ctx, Xl ) ^ Xr;
temp = Xl;
Xl = Xr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
movl (%rdx), %r12d
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x422e
movl %eax, %ebp
xorl (%r15,%r13,4), %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x4504
xorl %r12d, %eax
incq %r13
... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
auto pthen<Parser<auto poptional<Parser<auto parser_pred[abi:cxx11]<Parser<parse_char()::$_0>, parse_int()::$_0>(Parser<parse_char()::$_0>, parse_int()::$_0)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0x18, %rsp
movw 0x16(%rsp), %ax
movw %ax, 0x12(%rsp)
leaq 0x12(%rsp), %rdi
callq 0x417e0
addq $0x18, %rsp
retq
nopl (%rax)
| /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto parser_pred[abi:cxx11]<Parser<parse_char()::$_0>, int (*)(int)>(Parser<parse_char()::$_0>, int (*)(int))::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::bas... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0x41a60
addq $0x18, %rsp
retq
nopl (%rax)
| /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto pthen<Parser<auto parse_while<Parser<auto parser_pred[abi:cxx11]<Parser<parse_char()::$_0>, int (*)(int)>(Parser<parse_char()::$_0>, int (*)(int))::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__norm... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x49d10
movq (%rsp), %rdi
addq $0x5a8, %rdi # imm = 0x5A8
movq 0x8(%rsp), %rsi
addq $0x5a8, %rsi # imm = 0x5A8
movl $0x38, %edx
callq 0x3c240
addq $0x18, %rsp
retq
nopw (%... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto parse_while<Parser<auto parser_pred[abi:cxx11]<Parser<parse_char()::$_0>, int (*)(int)>(Parser<parse_char()::$_0>, int (*)(int))::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char c... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x49f50
popq %rax
retq
nopw %cs:(%rax,%rax)
| /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto pthen<Parser<auto parse_while<Parser<auto parser_pred[abi:cxx11]<Parser<parse_char()::$_0>, int (*)(int)>(Parser<parse_char()::$_0>, int (*)(int))::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__norm... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x160(%rsp)
movq %rdx, 0x158(%rsp)
movq %rcx, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x148(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parser_pred[abi:cxx11]<Parser<parse_char()::$_0>, int (*)(int)>(Parser<parse_char()::$_0>, int (*)(int))::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, st... | auto parser_pred(Par par, Pred p) {
return make_parser([par, p](str_iterator begin,
str_iterator end) -> decltype(par(begin, end)) {
auto res = par(begin, end);
if (!res) {
return None();
}
if (p(res->first)) {
return res;
... | subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
leaq 0x38(%rsp), %... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto apply<Parser<auto apply<Parser<auto pthen<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char... | auto parse_try(T p, Ts... ps) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p(begin, end);
if (res) {
return res;
}
return parse_try(ps...)(begin, end);
});
} | subq $0x5d8, %rsp # imm = 0x5D8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x5d0(%rsp)
movq %rdx, 0x5c8(%rsp)
movq %rcx, 0x5c0(%rsp)
movq %rsi, 0x5b8(%rsp)
movq 0x5b8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x5c8(%rsp), %rax
movq %rax, 0x558(%rsp)
movq 0x5c0(%rsp), %rax
movq %rax, 0... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto apply<Parser<auto apply<Parser<auto pthen<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect... | auto parse_try(T p, Ts... ps) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p(begin, end);
if (res) {
return res;
}
return parse_try(ps...)(begin, end);
});
} | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x250(%rsp)
movq %rdx, 0x248(%rsp)
movq %rcx, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq 0x238(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x248(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x240(%rsp), %rax
movq %rax, 0... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parse_try<Parser<auto apply<Parser<auto apply<Parser<auto pthen<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect)::'lambda'(__gnu_cxx::__normal_iterator<cha... | auto parse_try(T p, Ts... ps) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p(begin, end);
if (res) {
return res;
}
return parse_try(ps...)(begin, end);
});
} | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x260(%rsp)
movq %rdx, 0x258(%rsp)
movq %rcx, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x248(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x258(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_trait... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0xf8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdx
m... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parse_try<Parser<auto parse_try<Parser<auto parse_try<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | auto parse_try(T p, Ts... ps) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p(begin, end);
if (res) {
return res;
}
return parse_try(ps...)(begin, end);
});
} | subq $0x88, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x58(%rsp), %rdi
... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parse_try<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<... | auto parse_try(T p, Ts... ps) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p(begin, end);
if (res) {
return res;
}
return parse_try(ps...)(begin, end);
});
} | subq $0x88, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0x58(%rsp), %rdi
... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cx... | auto parse_seq(P p, T str, R x = R()) {
return make_parser([=](str_iterator begin, str_iterator end) {
ParserRet<decltype(p(end, end)->first)> ret;
auto iter = begin;
T str2 = str;
for (; *str2; ++str2) {
ret = parser_pred(p, [=](auto c) { return c == *str2; })(iter, end)... | subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x5a050
movq 0x18(%rsp), %rax
movq 0xb0(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x7... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto parser_pred<Parser<parse_char()::$_0>, auto parse_seq<Parser<parse_char()::$_0>, char const*, OscilloSelect>(Parser<parse_char()::$_0>, char const*, OscilloSelect)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__norma... | auto parser_pred(Par par, Pred p) {
return make_parser([par, p](str_iterator begin,
str_iterator end) -> decltype(par(begin, end)) {
auto res = par(begin, end);
if (!res) {
return None();
}
if (p(res->first)) {
return res;
... | subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movb 0x27(%rsp), %al
movb %al, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4d000
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto pthen<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, Empty>(Parser<parse_char()::$_0>, char const*, Empty)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<ch... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x110(%rsp)
movq %rdx, 0x108(%rsp)
movq %rcx, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0xf8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0xb8... | /Vermeille[P]Synth/parcxx/src/combinators.h |
auto pthen<Parser<auto parse_seq[abi:cxx11]<Parser<parse_char()::$_0>, char const*, Empty>(Parser<parse_char()::$_0>, char const*, Empty)::'lambda'(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__... | auto pthen(P1 p1, P2 p2) {
return make_parser([=](str_iterator begin, str_iterator end) {
auto res = p1(begin, end);
if (res) {
return p2(res->first)(res->second, end);
}
return decltype(p2(res->first)(res->second, end))();
});
} | subq $0xf8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xd8(%rsp), %rsi
movq %rsi, 0x30(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb8(%rsp), %rdx
m... | /Vermeille[P]Synth/parcxx/src/combinators.h |
sexp_make_custom_port | static sexp sexp_make_custom_port (sexp ctx, sexp self,
const char *mode, sexp read, sexp write,
sexp seek, sexp close) {
sexp vec;
sexp_gc_var2(res, str);
sexp_gc_preserve2(ctx, res, str);
str = sexp_make_string(ctx, sexp_make_fixnum(SEXP_PO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0x43e, %eax # imm = 0x43E
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, ... | /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_make_custom_output_port | sexp sexp_make_custom_output_port (sexp ctx, sexp self,
sexp write, sexp seek, sexp close) {
sexp res = sexp_make_custom_port(ctx, self, "w", SEXP_FALSE, write, seek, close);
#if SEXP_USE_STRING_STREAMS
if (!sexp_exceptionp(res))
sexp_pointer_tag(res) = SEXP_OPORT;
#endif
re... | movq %r8, %r9
movq %rcx, %r8
movq %rdx, %rcx
leaq 0x1a73(%rip), %rsi # 0x4000
movl $0x3e, %edx
jmp 0x2430
| /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_bytes_to_string | sexp sexp_bytes_to_string (sexp ctx, sexp vec, sexp_uint_t offset, sexp_uint_t size) {
sexp res;
#if SEXP_USE_PACKED_STRINGS
res = sexp_c_string(ctx, sexp_bytes_data(vec) + offset, size);
#else
res = sexp_alloc_type(ctx, string, SEXP_STRING);
sexp_string_bytes(res) = vec;
sexp_string_offset(res) = offset;
s... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x20, %esi
movl $0x9, %edx
callq 0x20d0
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
subq %r14, %rbx
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
| /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_string_to_utf8_x | sexp sexp_string_to_utf8_x (sexp ctx, sexp self, sexp str) {
sexp_assert_type(ctx, sexp_stringp, SEXP_STRING, str);
#if SEXP_USE_PACKED_STRINGS
return sexp_string_to_utf8(ctx, self, str);
#else
return sexp_string_bytes(str);
#endif
} | movq %rdx, %rcx
testb $0x3, %cl
jne 0x2970
cmpl $0x9, (%rcx)
jne 0x2970
movq 0x8(%rcx), %rax
retq
movl $0x9, %edx
jmp 0x2090
| /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_utf8_ref | sexp sexp_utf8_ref (sexp ctx, sexp self, sexp bv, sexp offset) {
sexp_assert_type(ctx, sexp_bytesp, SEXP_BYTES, bv);
sexp_assert_type(ctx, sexp_fixnump, SEXP_FIXNUM, offset);
unsigned char *p=(unsigned char*)sexp_bytes_data(bv) + sexp_unbox_fixnum(offset);
if (*p < 0x80)
return sexp_make_character(*p);
el... | movq %rdx, %r8
testb $0x3, %r8b
jne 0x29bc
cmpl $0x8, (%r8)
jne 0x29bc
testb $0x1, %cl
jne 0x29c9
movl $0x2, %edx
jmp 0x2090
movl $0x8, %edx
movq %r8, %rcx
jmp 0x2090
movq %rcx, %rdx
sarq %rdx
movsbq 0x10(%r8,%rdx), %rax
testq %rax, %rax
js 0x29e3
shlq $0x8, %rax
orq $0x1e, %rax
retq
leal 0x8(%rax), %esi
cmpb $-0x39, %... | /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_is_a_socket_p | int sexp_is_a_socket_p (int fd) {
#if defined(PLAN9) || defined(_WIN32)
return 0;
#else
struct stat statbuf;
fstat(fd, &statbuf);
return S_ISSOCK(statbuf.st_mode);
#endif
} | pushq %rbx
subq $0x90, %rsp
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x2310
movl $0xf000, %ecx # imm = 0xF000
andl 0x18(%rbx), %ecx
xorl %eax, %eax
cmpl $0xc000, %ecx # imm = 0xC000
sete %al
addq $0x90, %rsp
popq %rbx
retq
| /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_seek | sexp sexp_seek (sexp ctx, sexp self, sexp x, off_t offset, int whence) {
off_t res;
if (! (sexp_portp(x) || sexp_filenop(x)))
return sexp_type_exception(ctx, self, SEXP_IPORT, x);
if (sexp_filenop(x))
return sexp_make_integer(ctx, lseek(sexp_fileno_fd(x), offset, whence));
if (sexp_filenop(sexp_port_fd(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x3, %r14b
je 0x2ed5
movl $0x10, %edx
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
movl %r8d, %ebp
movq %rcx, %r15
movl (%r14), %eax
leal -0x10(%rax), %ecx
cmpl $0x2, %ecx
... | /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_string_3e_utf8_x_stub | sexp sexp_string_to_utf8_x (sexp ctx, sexp self, sexp str) {
sexp_assert_type(ctx, sexp_stringp, SEXP_STRING, str);
#if SEXP_USE_PACKED_STRINGS
return sexp_string_to_utf8(ctx, self, str);
#else
return sexp_string_bytes(str);
#endif
} | testb $0x3, %cl
jne 0x305f
cmpl $0x9, (%rcx)
jne 0x305f
movq 0x8(%rcx), %rax
retq
movl $0x9, %edx
jmp 0x2090
| /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_25_send_file_stub | sexp sexp_25_send_file_stub (sexp ctx, sexp self, sexp_sint_t n, sexp arg0, sexp arg1, sexp arg2, sexp arg3) {
int err = 0;
off_t tmp4;
sexp res;
sexp_gc_var1(res4);
if (! (sexp_filenop(arg0) || sexp_fixnump(arg0)))
return sexp_type_exception(ctx, self, SEXP_FILENO, arg0);
if (! (sexp_filenop(arg1) || s... | movq %rcx, %rax
movq 0x8(%rsp), %rcx
testb $0x3, %al
je 0x311c
testb $0x1, %al
jne 0x3121
movl $0x12, %edx
movq %rax, %rcx
jmp 0x2090
cmpl $0x12, (%rax)
jne 0x310f
testb $0x3, %r8b
je 0x313a
testb $0x1, %r8b
jne 0x3140
movl $0x12, %edx
movq %r8, %rcx
jmp 0x2090
cmpl $0x12, (%r8)
jne 0x312d
testb $0x1, %r9b
jne 0x3152
t... | /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
sexp_25_25_read_line_stub | sexp sexp_25_25_read_line_stub (sexp ctx, sexp self, sexp_sint_t n, sexp arg1, sexp arg2) {
char *err;
char *tmp0;
sexp res;
sexp_gc_var1(res0);
if (! sexp_exact_integerp(arg1))
return sexp_type_exception(ctx, self, SEXP_FIXNUM, arg1);
if (! sexp_iportp(arg2))
return sexp_type_exception(ctx, self, S... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movq $0x43e, 0x8(%rsp) # imm = 0x43E
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
testb $0x1, %r15b
jne 0x32bf
testb $0x2, %r15b
jne 0x3300
cmpl $0xc, (%r15)
jne 0x3300
testb $0x3, %r14b
jne 0x32f3
cmpl $0x1... | /ashinn[P]chibi-scheme/build_O1/lib/chibi/io/io.c |
Catch::Session::showHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void showHelp( std::string const& processName ) {
std::cout << "\nCatch v" << libraryVersion.majorVersion << "."
<< libraryVersion.minorVersion << " build "
<< libraryVersion.buildNumber;
if( libraryVersion.branch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %r15
movq 0x3a138(%rip), %rbx # 0x74fc0
leaq 0x220d1(%rip), %rsi # 0x5cf60
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2b3f0
movl 0x3a596(%rip), %esi # 0x75438
movq %rbx, %rdi
callq 0x2b250
movq %rax,... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::listTests(Catch::Config const&) | inline std::size_t listTests( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( config.testSpec().hasFilters() )
std::cout << "Matching test cases:\n";
else {
std::cout << "All available test cases:\n";
testSpec = TestSpecParser( ITagAliasRe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r13
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x3f158
movq (%r13), %rax
movq %r13, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x3f6c3
movq ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Option<Catch::SectionTracking::TestCaseTracker>::reset() | void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x42037
leaq 0x28(%r14), %rdi
callq 0x4208a
movq (%r14), %rdi
addq $0x10, %r14
cmpq %r14, %rdi
je 0x42037
callq 0x2b330
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::AssertionResult::AssertionResult(Catch::AssertionResult const&) | AssertionResult( AssertionResult const& ) = default; | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4b0ae
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rd... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Option<Catch::SectionTracking::TestCaseTracker>::operator=(Catch::SectionTracking::TestCaseTracker const&) | Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4200e
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4b0ae
movl 0x20(%r15), %eax
movl %eax, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
leaq... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::StreamRedirect::StreamRedirect(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | StreamRedirect( std::ostream& stream, std::string& targetString )
: m_stream( stream ),
m_prevBuf( stream.rdbuf() ),
m_targetString( targetString )
{
stream.rdbuf( m_oss.rdbuf() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x2b480
movq %r15, 0x188(%rbx)
movq (%r12), %rax
addq -0x18(%rax),... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Totals::operator-(Catch::Totals const&) const | Totals operator - ( Totals const& other ) const {
Totals diff;
diff.assertions = assertions - other.assertions;
diff.testCases = testCases - other.testCases;
return diff;
} | movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdi
subq (%rdx), %rcx
subq 0x8(%rdx), %rdi
movq 0x10(%rsi), %r8
subq 0x10(%rdx), %r8
movq %rcx, (%rax)
movq %rdi, 0x8(%rax)
movq %r8, 0x10(%rax)
movq 0x18(%rsi), %rcx
movq 0x20(%r... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Option<Catch::GroupInfo>::operator=(Catch::GroupInfo const&) | Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x44952
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x44952
callq 0x2b330
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r15
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Ptr<Catch::CumulativeReporterBase::SectionNode>::operator=(Catch::Ptr<Catch::CumulativeReporterBase::SectionNode> const&) | Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x44ddc
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x44ded
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>>::~Node() | virtual ~Node() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x2ed51(%rip), %rax # 0x74900
movq %rax, (%rdi)
addq $0x80, %rdi
callq 0x327d6
leaq 0x2d46b(%rip), %rax # 0x73030
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x45bdc
popq %rbx
jmp 0x2b330
popq %rbx
retq
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::JunitReporter::writeGroup(Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>> const&, double) | void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
TestGroupStats const& stats = groupNode.value;
xml.writeAttribute( "name", stats.groupInfo.name );
xml.writeAttribute( "errors", unexpected... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm0, 0x78(%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x16ecd(%rip), %rsi # 0x5d47d
leaq 0x16ecf(%rip), %rdx # 0x5d486
leaq 0x8(%rsp), %rdi
callq 0x4b13e
leaq 0xc0(%rbx), %r14
movq %r14, 0... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::JunitReporter::writeTestCase(Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode> const&) | bool compare( T* lhs, long rhs ) {
return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x1a0(%rsi), %rax
movq 0x1a8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x46d53
movq %rdi, %rbx
movq (%rax), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::JunitReporter::writeSection(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::CumulativeReporterBase::SectionNode const&) | void writeSection( std::string const& className,
std::string const& rootName,
SectionNode const& sectionNode ) {
std::string name = trim( sectionNode.stats.sectionInfo.name );
if( !rootName.empty() )
name = rootName + "/" +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x18(%rcx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2eb8e
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x46e92
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r1... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [5]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [5]) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
if( !name.empty() )
stream() << " " << name << "=\"" << attribute << "\"";
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x473a4
movq %rdx, %r14
movq %rsi, %r15
movq 0x40(%rbx), %r12
leaq 0x153cb(%rip), %rsi # 0x5c712
movl $0x1, %edx
movq %r12, %rdi
callq 0x2b3f0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x2b3f0
movq %rax... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::lazyPrint() | void lazyPrint() {
if( !currentTestRunInfo.used )
lazyPrintRunInfo();
if( !currentGroupInfo.used )
lazyPrintGroupInfo();
if( !m_headerPrinted ) {
printTestCaseAndSectionHeader();
m_headerPrinted = true;
}
... | pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x48(%rdi)
jne 0x477ba
movq %rbx, %rdi
callq 0x47cac
cmpb $0x0, 0x88(%rbx)
jne 0x477cb
movq %rbx, %rdi
callq 0x47eec
cmpb $0x0, 0x1c8(%rbx)
jne 0x477e3
movq %rbx, %rdi
callq 0x47f68
movb $0x1, 0x1c8(%rbx)
popq %rbx
retq
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::print() const | void print() const {
printSourceInfo();
if( stats.totals.assertions.total() > 0 ) {
if( result.isOk() )
stream << "\n";
printResultType();
printOriginalExpression();
printReconstructed... | pushq %rbx
movq %rdi, %rbx
callq 0x48458
movq 0x8(%rbx), %rax
movq 0xe0(%rax), %rcx
addq 0xd8(%rax), %rcx
addq 0xe8(%rax), %rcx
jne 0x47c18
movq (%rbx), %rdi
leaq 0x15997(%rip), %rsi # 0x5d5a3
movl $0x1, %edx
callq 0x2b3f0
jmp 0x47c59
movq 0x10(%rbx), %rax
testb $0x10, 0xb0(%rax)
je 0x47c2d
movl 0x68(%rax), %eax
an... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::printTotals(Catch::Totals const&) | void printTotals( Totals const& totals ) {
if( totals.testCases.total() == 0 ) {
stream << Colour( Colour::Warning ) << "No tests ran\n";
}
else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
stream << Colour( Colour::ResultSucc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
addq 0x18(%rsi), %rax
addq 0x28(%rsi), %rax
jne 0x48a1b
movq 0x18(%rbx), %rbx
movb $0x0, 0x20(%rsp)
callq 0x2d1ec
movq (%rax), %rcx
movq %rax, %rdi
movl $0x6, %esi
callq *0x10(%rcx)
leaq 0x14d3f(%rip... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
main | int main(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
float buffer[FRAMES_PER_BUFFER][2]; /* stereo output buffer */
float sine[TABLE_SIZE]; /* sine wavetable */
int left_phase = 0;
int right_phase = 0;
int left_inc = 1;
int right_inc = 3; /* higher pit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2368, %rsp # imm = 0x2368
leaq 0xc5bc(%rip), %rdi # 0x13020
xorl %ebx, %ebx
movl $0xac44, %esi # imm = 0xAC44
movl $0x400, %edx # imm = 0x400
xorl %eax, %eax
callq 0x6060
cmpq $0xc8, %rbx
je 0x6aac
cvtsi2sd %eb... | /syb0rg[P]PortAudio2/examples/paex_write_sine.c |
Pa_Terminate | PaError Pa_Terminate( void )
{
PaError result;
PA_LOGAPI_ENTER( "Pa_Terminate" );
if( PA_IS_INITIALISED_ )
{
if( --initializationCount_ == 0 )
{
CloseOpenStreams();
TerminateHostApis();
PaUtil_DumpTraceMessages();
}
result = paNoErr... | pushq %r14
pushq %rbx
pushq %rax
movl 0x1cf8b(%rip), %eax # 0x23e80
testl %eax, %eax
je 0x6f1b
xorl %ebx, %ebx
decl %eax
movl %eax, 0x1cf7d(%rip) # 0x23e80
jne 0x6f27
leaq 0x1cf6c(%rip), %r14 # 0x23e78
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6f22
callq 0x78ac
jmp 0x6f0c
movl $0xffffd8f0, %ebx # imm = ... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_HostApiTypeIdToHostApiIndex | PaHostApiIndex Pa_HostApiTypeIdToHostApiIndex( PaHostApiTypeId type )
{
PaHostApiIndex result;
int i;
PA_LOGAPI_ENTER_PARAMS( "Pa_HostApiTypeIdToHostApiIndex" );
PA_LOGAPI(("\tPaHostApiTypeId type: %d\n", type ));
if( !PA_IS_INITIALISED_ )
{
result = paNotInitialized;
}
els... | cmpl $0x0, 0x1cdc7(%rip) # 0x23e80
je 0x70e2
movl 0x1cdc3(%rip), %ecx # 0x23e84
movq 0x1cdc0(%rip), %rdx # 0x23e88
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
cmpq %rax, %rcx
je 0x70e8
movq (%rdx,%rax,8), %rsi
cmpl %edi, 0xc(%rsi)
je 0x70e7
incq %rax
jmp 0x70cf
movl $0xffffd8f0, %eax # imm = 0... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
PaUtil_GetHostApiRepresentation | PaError PaUtil_GetHostApiRepresentation( struct PaUtilHostApiRepresentation **hostApi,
PaHostApiTypeId type )
{
PaError result;
int i;
if( !PA_IS_INITIALISED_ )
{
result = paNotInitialized;
}
else
{
result = paHostApiNotFound;
for( i=0; i... | cmpl $0x0, 0x1cd8b(%rip) # 0x23e80
je 0x7123
movl 0x1cd87(%rip), %eax # 0x23e84
movq 0x1cd84(%rip), %rcx # 0x23e88
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x7129
movq (%rcx,%rdx,8), %r8
incq %rdx
cmpl %esi, 0xc(%r8)
jne 0x710b
movq %r8, (%rdi)
xorl %eax, %eax
retq
movl $0xffff... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_HostApiDeviceIndexToDeviceIndex | PaDeviceIndex Pa_HostApiDeviceIndexToDeviceIndex( PaHostApiIndex hostApi, int hostApiDeviceIndex )
{
PaDeviceIndex result;
PA_LOGAPI_ENTER_PARAMS( "Pa_HostApiDeviceIndexToPaDeviceIndex" );
PA_LOGAPI(("\tPaHostApiIndex hostApi: %d\n", hostApi ));
PA_LOGAPI(("\tint hostApiDeviceIndex: %d\n", hostApiDevic... | cmpl $0x0, 0x1ccc8(%rip) # 0x23e80
je 0x71eb
movl $0xffffd906, %eax # imm = 0xFFFFD906
testl %edi, %edi
js 0x71f0
cmpl %edi, 0x1ccbb(%rip) # 0x23e84
jle 0x71f0
movl $0xffffd8f4, %eax # imm = 0xFFFFD8F4
testl %esi, %esi
js 0x71f0
movq 0x1ccad(%rip), %rcx # 0x23e88
movl %edi, %edx
movq (%rcx,%rdx,... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_GetDeviceCount | PaDeviceIndex Pa_GetDeviceCount( void )
{
PaDeviceIndex result;
PA_LOGAPI_ENTER( "Pa_GetDeviceCount" );
if( !PA_IS_INITIALISED_ )
{
result = paNotInitialized;
}
else
{
result = deviceCount_;
}
PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_GetDeviceCount", "PaDeviceIndex:... | cmpl $0x0, 0x1cc88(%rip) # 0x23e80
movl $0xffffd8f0, %eax # imm = 0xFFFFD8F0
je 0x7205
movl 0x1cc8f(%rip), %eax # 0x23e94
retq
| /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_GetDeviceInfo | const PaDeviceInfo* Pa_GetDeviceInfo( PaDeviceIndex device )
{
int hostSpecificDeviceIndex;
int hostApiIndex = FindHostApi( device, &hostSpecificDeviceIndex );
PaDeviceInfo *result;
PA_LOGAPI_ENTER_PARAMS( "Pa_GetDeviceInfo" );
PA_LOGAPI(("\tPaDeviceIndex device: %d\n", device ));
if( hostApi... | pushq %rax
leaq 0x4(%rsp), %rsi
callq 0x7277
testl %eax, %eax
js 0x7273
movq 0x1cc2a(%rip), %rcx # 0x23e88
movl %eax, %eax
movq (%rcx,%rax,8), %rax
movq 0x28(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
jmp 0x7275
xorl %eax, %eax
popq %rcx
retq
| /syb0rg[P]PortAudio2/src/common/pa_front.c |
FindHostApi | static int FindHostApi( PaDeviceIndex device, int *hostSpecificDeviceIndex )
{
int i=0;
if( !PA_IS_INITIALISED_ )
return -1;
if( device < 0 )
return -1;
while( i < hostApisCount_
&& device >= hostApis_[i]->info.deviceCount )
{
device -= hostApis_[i]->info.devi... | pushq $-0x1
popq %rax
testl %edi, %edi
js 0x72be
cmpl $0x0, 0x1cbfb(%rip) # 0x23e80
je 0x72be
movl 0x1cbf7(%rip), %edx # 0x23e84
movq 0x1cbf4(%rip), %r8 # 0x23e88
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
cmpq %rcx, %rdx
je 0x72be
movq (%r8,%rcx,8), %r10
movl %edi, %r9d
subl 0x18(%r10), %r9d
jl 0... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
ValidateOpenStreamParameters | static PaError ValidateOpenStreamParameters(
const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate,
unsigned long framesPerBuffer,
PaStreamFlags streamFlags,
PaStreamCallback *streamCallback,
PaUtilHostApiRepresentation **hostApi,
PaDevi... | movq %rdi, %rax
orq %rsi, %rax
jne 0x73a2
movl $0xffffd8f4, %eax # imm = 0xFFFFD8F4
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x50(%rsp), %r14
testq %rdi, %rdi
je 0x7423
movl (%r12), %edi
cmpl $-0x2, ... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_IsStreamStopped | PaError Pa_IsStreamStopped( PaStream *stream )
{
PaError result = PaUtil_ValidateStreamPointer( stream );
PA_LOGAPI_ENTER_PARAMS( "Pa_IsStreamStopped" );
PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
if( result == paNoError )
result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
... | pushq %rbx
movq %rdi, %rbx
callq 0x7880
testl %eax, %eax
je 0x7a15
popq %rbx
retq
movq 0x10(%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x20(%rax)
| /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_GetStreamTime | PaTime Pa_GetStreamTime( PaStream *stream )
{
PaError error = PaUtil_ValidateStreamPointer( stream );
PaTime result;
PA_LOGAPI_ENTER_PARAMS( "Pa_GetStreamTime" );
PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
if( error != paNoError )
{
result = 0;
PA_LOGAPI(("Pa_GetStrea... | pushq %rbx
movq %rdi, %rbx
callq 0x7880
testl %eax, %eax
je 0x7a66
xorps %xmm0, %xmm0
popq %rbx
retq
movq 0x10(%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x30(%rax)
| /syb0rg[P]PortAudio2/src/common/pa_front.c |
Pa_ReadStream | PaError Pa_ReadStream( PaStream* stream,
void *buffer,
unsigned long frames )
{
PaError result = PaUtil_ValidateStreamPointer( stream );
PA_LOGAPI_ENTER_PARAMS( "Pa_ReadStream" );
PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
if( result == paNoError ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x7880
testl %eax, %eax
je 0x7aab
popq %rbx
popq %r14
popq %r15
retq
testq %rbx, %rbx
je 0x7ad2
testq %r14, %r14
je 0x7ad6
movq 0x10(%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
testl %eax, %eax
je 0x7add
movl %eax, %ecx
cmpl $0x1, ... | /syb0rg[P]PortAudio2/src/common/pa_front.c |
PaUnixThread_NotifyParent | PaError PaUnixThread_NotifyParent( PaUnixThread* self )
{
PaError result = paNoError;
PA_UNLESS( self->parentWaiting, paInternalError );
if( !self->locked )
{
PA_ENSURE( PaUnixMutex_Lock( &self->mtx ) );
self->locked = 1;
}
self->parentWaiting = 0;
pthread_cond_signal( &self... | pushq %rbx
cmpl $0x0, 0x8(%rdi)
je 0x825c
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x8234
leaq 0x18(%rbx), %rdi
callq 0x7fbf
movl %eax, 0x1bc6f(%rip) # 0x23e98
testl %eax, %eax
js 0x827a
movl $0x1, 0x10(%rbx)
andl $0x0, 0x8(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x6170
leaq 0x18(%rbx), %rdi
callq 0x8026
movl %eax, 0x1b... | /syb0rg[P]PortAudio2/src/os/unix/pa_unix_util.c |
Terminate | static void Terminate( struct PaUtilHostApiRepresentation *hostApi )
{
PaAlsaHostApiRepresentation *alsaHostApi = (PaAlsaHostApiRepresentation*)hostApi;
assert( hostApi );
/** See AlsaErrorHandler and PaAlsa_Initialize for details.
*/
/*snd_lib_error_set_handler(NULL);*/
if( alsaHostApi->allo... | pushq %rbx
testq %rdi, %rdi
je 0x8634
movq %rdi, %rbx
movq 0x108(%rdi), %rdi
testq %rdi, %rdi
je 0x8626
callq 0xeb6c
movq 0x108(%rbx), %rdi
callq 0xea86
movq %rbx, %rdi
callq 0x7c01
popq %rbx
jmp 0x6530
leaq 0xc530(%rip), %rdi # 0x14b6b
leaq 0xc531(%rip), %rsi # 0x14b73
leaq 0xc596(%rip), %rcx # 0x14bdf
... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
OpenStream | static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,
PaStream** s,
const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x8(%rsp)
andl $0x0, 0x1c(%rsp)
movq %r9, %rax
shrq $0x10, %rax
movl $0xffffd8f5, %r15d # imm = 0xFFFFD8F5
testw %ax, %ax
jne 0x8a57
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r14
xorl %r15d, %r15d
testq %... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
IsFormatSupported | static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,
const PaStreamParameters *inputParameters,
const PaStreamParameters *outputParameters,
double sampleRate )
{
int inputChannelCount = 0,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x8bba
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xa92f
movl %eax, 0x1b316(%rip) # 0x23eb0
testl %eax, %eax
js 0x8c43
movl 0x4(%r15), %eax
te... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
CloseStream | static PaError CloseStream( PaStream* s )
{
PaError result = paNoError;
PaAlsaStream *stream = (PaAlsaStream*)s;
PaUtil_TerminateBufferProcessor( &stream->bufferProcessor );
PaUtil_TerminateStreamRepresentation( &stream->streamRepresentation );
PaAlsaStream_Terminate( stream );
return result;... | pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
callq 0x1056b
movq %rbx, %rdi
callq 0x121ca
movq %rbx, %rdi
callq 0xb9e9
xorl %eax, %eax
popq %rbx
retq
| /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
GetStreamWriteAvailable | static signed long GetStreamWriteAvailable( PaStream* s )
{
PaError result = paNoError;
PaAlsaStream *stream = (PaAlsaStream*)s;
unsigned long avail;
int xrun;
PA_ENSURE( PaAlsaStreamComponent_GetAvailableFrames( &stream->playback, &avail, &xrun ) );
if( xrun )
{
snd_pcm_sframes_t s... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x308, %rdi # imm = 0x308
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0xe5f9
movl %eax, 0x1a2c4(%rip) # 0x23eb0
testl %eax, %eax
js 0x9c78
cmpl $0x0, 0xc(%rsp)
je 0x9c68
movq %rbx, %rdi
callq 0xe3e8
movl %eax, 0x1a2a7(%rip) # 0x23eb0
t... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsa_GetStreamOutputCard | PaError PaAlsa_GetStreamOutputCard( PaStream* s, int* card )
{
PaAlsaStream *stream;
PaError result = paNoError;
snd_pcm_info_t* pcmInfo;
PA_ENSURE( GetAlsaStreamPointer( s, &stream ) );
/* XXX: More descriptive error? */
PA_UNLESS( stream->playback.pcm, paDeviceUnavailable );
alsa_snd_pc... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x28(%rbp), %r14
movq %r14, %rsi
callq 0x9d77
andl $0x0, 0x1a089(%rip) # 0x23eb0
movq (%r14), %r12
cmpq $0x0, 0x340(%r12)
je 0x9e8f
callq 0x6610
movq %rsp, %r15
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
subq %... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
FillInDevInfo | static PaError FillInDevInfo( PaAlsaHostApiRepresentation *alsaApi, HwDevInfo* deviceHwInfo, int blocking,
PaAlsaDeviceInfo* devInfo, int* devIdx )
{
PaError result = 0;
PaDeviceInfo *baseDeviceInfo = &devInfo->baseDeviceInfo;
snd_pcm_t *pcm = NULL;
PaUtilHostApiRepresentation *baseApi = &alsaAp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
andq $0x0, (%rsp)
movq %rsi, %r12
orl $-0x1, (%rcx)
andq $0x0, 0x8(%rcx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rax, 0x10(%rcx)
andl $0x0, 0x18(%rcx)
movq %rdi, %r15
movaps 0xa3a4(%... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
GetAvailableFormats | static PaSampleFormat GetAvailableFormats( snd_pcm_t *pcm )
{
PaSampleFormat available = 0;
snd_pcm_hw_params_t *hwParams;
alsa_snd_pcm_hw_params_alloca( &hwParams );
alsa_snd_pcm_hw_params_any( pcm, hwParams );
if( alsa_snd_pcm_hw_params_test_format( pcm, hwParams, SND_PCM_FORMAT_FLOAT ) >= 0)
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6280
movq %rsp, %r14
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x6090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6070
pushq $0xe
popq %rdx
movq %... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
Pa2AlsaFormat | static snd_pcm_format_t Pa2AlsaFormat( PaSampleFormat paFormat )
{
switch( paFormat )
{
case paFloat32:
return SND_PCM_FORMAT_FLOAT;
case paInt16:
return SND_PCM_FORMAT_S16;
case paInt24:
#ifdef PA_LITTLE_ENDIAN
return SND_PCM_FORMAT_S24_3LE;
#elif d... | leaq -0x1(%rdi), %rax
cmpq $0x7, %rax
ja 0xadeb
leaq 0x954a(%rip), %rcx # 0x14328
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xe
jmp 0xae09
cmpq $0x10, %rdi
je 0xae0b
cmpq $0x20, %rdi
jne 0xadfb
pushq $0x1
jmp 0xae09
pushq $-0x1
jmp 0xae09
pushq $0x2
jmp 0xae09
pushq $0xa
jmp 0xae09
pushq $0x20
p... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStreamComponent_InitialConfigure | static PaError PaAlsaStreamComponent_InitialConfigure( PaAlsaStreamComponent *self, const PaStreamParameters *params,
int primeBuffers, snd_pcm_hw_params_t *hwParams, double *sampleRate )
{
/* Configuration consists of setting all of ALSA's parameters.
* These parameters come in two flavors: hardware p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x38(%rdi), %r15
movsd (%rdx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl $0x2, 0xc(%rsp)
movq %r15, %rdi
callq 0x6070
testl %eax, %eax
js 0xc14d
movq %r15, %rdi
movq %... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
OnExit | static void OnExit( void *data )
{
PaAlsaStream *stream = (PaAlsaStream *) data;
assert( data );
PaUtil_ResetCpuLoadMeasurer( &stream->cpuLoadMeasurer );
stream->callback_finished = 1; /* Let the outside world know stream was stopped in callback */
PA_DEBUG(( "%s: Stopping ALSA handles\n", __FUN... | pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xff2a
movl $0x1, 0x23c(%rbx)
movl 0x240(%rbx), %eax
movq %rbx, %rdi
callq 0xdeaf
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xd2dc
movq 0x28(%rbx), %rdi
callq *%rax
movl $0x0, 0x244(%rbx)
popq %rbx
retq
| /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
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.