name string | code string | asm string | file string |
|---|---|---|---|
front::irGenerator::irGenerator::irGenerator() | irGenerator::irGenerator() {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x6b64a(%rip), %r14 # 0xf04c8
addq $0x10, %r14
movq %r14, (%rdi)
leaq 0x10(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_op(std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::variant<int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::variant<int, int, std::__cxx11::basic_string<char, std::char_traits<char>... | void irGenerator::ir_op(LeftVal dest, RightVal op1, RightVal op2,
mir::inst::Op op) {
shared_ptr<VarId> destVarId;
shared_ptr<Value> op1Value;
shared_ptr<Value> op2Value;
shared_ptr<mir::inst::OpInst> opInst;
destVarId = shared_ptr<VarId>(new VarId(LeftValueToLabelId(dest)));
op1Val... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movl $0x10, %edi
callq 0xc3c0
movq %rax, %rbx
movl %ebp, 0x3c(%rsp)
leaq 0x70(%rsp), %rdi
movq %r13, %rsi
callq 0x8b130
movb $0x1, %r13b
leaq 0x70(%rsp), %rs... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::rightValueToValue(std::variant<int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&) | shared_ptr<Value> irGenerator::rightValueToValue(RightVal &rightValue) {
shared_ptr<Value> value;
switch (rightValue.index()) {
case 0:
value = shared_ptr<Value>(new Value(get<0>(rightValue)));
break;
case 2: {
value = shared_ptr<Value>(
new Value(VarId(nameToLabelId(get<2>(righ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movzbl 0x20(%rdx), %eax
cmpl $0x2, %eax
je 0x85b13
testl %eax, %eax
jne 0x85bd7
movl $0x20, %edi
callq 0xc3c0
movq %rax, %r14
movq %r12, %rdi
callq 0x8ad5e
movl (%rax), %eax
mo... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_declare_const(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<unsigned int, std::allocator<unsigned int>>, int) | void irGenerator::ir_declare_const(string name,
std::vector<std::uint32_t> values, int id) {
GlobalValue globalValue = GlobalValue(values);
_package.global_values[getConstName(name, id)] = globalValue;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x4d1e0
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4d1e0
movb $0x1, 0x88(%rsp)
leaq 0x6a746(%rip), %rax # 0xf0768
add... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_declare_value(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, front::symbol::SymbolKind, int, std::vector<unsigned int, std::allocator<unsigned int>>, front::irGenerator::localArrayInitType, int) | void irGenerator::ir_declare_value(string name, symbol::SymbolKind kind, int id,
std::vector<uint32_t> inits,
localArrayInitType initType, int len) {
if (_funcStack.back() == _GlobalInitFuncName) {
GlobalValue globalValue;
if (len == 0) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
movl %r9d, %r12d
movl %ecx, 0x4c(%rsp)
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movq 0x200(%rdi), %rax
movq -0x18(%rax), %rdx
cmpq 0xc0(%rdi), %rdx
jne 0x861fe
movq %r8, %r15
testq %rdx, %rdx
je 0x86274
m... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_ref(std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, bool) | void irGenerator::ir_ref(LeftVal dest, LeftVal src, bool begin) {
shared_ptr<VarId> destVarId;
shared_ptr<std::variant<VarId, std::string>> val;
LabelId id;
shared_ptr<mir::inst::Inst> refInst;
destVarId = shared_ptr<VarId>(new VarId(LeftValueToLabelId(dest)));
if ((id = nameToLabelId(get<1>(src))) >= 0) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movl $0x10, %edi
callq 0xc3c0
movq %rax, %rbx
movl %ebp, 0x2c(%rsp)
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x8b130
movb $0x1... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_declare_param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, front::symbol::SymbolKind, int) | void irGenerator::ir_declare_param(string name, symbol::SymbolKind kind,
int id) {
SharedTyPtr ty;
ir_declare_value(name, kind, id, {});
switch (kind) {
case front::symbol::SymbolKind::INT: {
ty = SharedTyPtr(new IntTy());
break;
}
case front::symbol::S... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x18456
leaq 0x60(%rsp... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_assign(std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int) | void irGenerator::ir_assign(LeftVal dest, uint32_t sourceId) {
shared_ptr<VarId> destVarId;
shared_ptr<Value> srcValue;
shared_ptr<mir::inst::AssignInst> assginInst;
destVarId = shared_ptr<VarId>(new VarId(LeftValueToLabelId(dest)));
srcValue = shared_ptr<Value>(new Value(VarId(sourceId)));
assginInst = s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0xc3c0
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x8b130
movb $0x1, %r12b
leaq 0x60(%rsp), %rsi
movq %r15, %rdi
callq 0x859d8
leaq 0x65818(%rip), %r... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::nameToLabelId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | LabelId irGenerator::nameToLabelId(string name) {
LabelId id = -1;
if (_funcNameToFuncData[_funcStack.back()]._localValueNameToId.count(name) ==
1) {
id = _funcNameToFuncData[_funcStack.back()]._localValueNameToId[name];
}
return id;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x210(%rdi), %r14
movq 0x200(%rdi), %rsi
addq $-0x20, %rsi
movq %r14, %rdi
callq 0x8a65c
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8e822
addq $0x8, %r12
cmpq %r12, %rax
je 0x89101
movq 0x200(%r15), %rsi
addq $-0x20... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_end_of_program() | void irGenerator::ir_end_of_program() {
string returnTmp = getNewTmpValueName(mir::types::TyKind::Int);
ir_function_call(returnTmp, front::symbol::SymbolKind::INT,
getFunctionName(_GlobalInitFuncName), {});
ir_jump(mir::inst::JumpInstructionKind::Return, -1, -1, returnTmp,
mir::inst::... | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x85272
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x18456
leaq 0x40(%rsp), %r14
movq %r14, -... | /segviol[P]indigo/frontend/ir_generator.cpp |
front::irGenerator::irGenerator::ir_jump(mir::inst::JumpInstructionKind, int, int, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, mir::inst::JumpKind) | void irGenerator::ir_jump(mir::inst::JumpInstructionKind kind, LabelId bbTrue,
LabelId bbFalse, std::optional<string> condRetName,
mir::inst::JumpKind jumpKind) {
std::optional<VarId> crn;
shared_ptr<mir::inst::JumpInstruction> jumpInst;
if (condRetName.has_val... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r9d, %r13d
movq %r8, %r12
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
cmpb $0x1, 0x20(%r8)
movl %ecx, 0xc(%rsp)
jne 0x8a330
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
le... | /segviol[P]indigo/frontend/ir_generator.cpp |
mir::inst::MirFunction::MirFunction(mir::inst::MirFunction&&) | MirFunction(MirFunction&& other) = default; | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x656a9(%rip), %rax # 0xf0498
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq 0x8(%rsi), %rdx
leaq 0x18(%rsi), %rax
cmpq %rax, %rdx
je 0x8ae18
movq %rdx, 0x8(%r14)
movq (%rax), %rcx
movq %rcx, 0x18(%r14)
jmp 0x8... | /segviol[P]indigo/frontend/../mir/mir.hpp |
has_this(std::vector<mir::inst::VarId, std::allocator<mir::inst::VarId>>, mir::inst::VarId) | bool has_this(vector<mir::inst::VarId> v, mir::inst::VarId s) {
for (int i = 0; i < v.size(); i++) {
if (v[i] == s) {
return true;
}
}
return false;
} | movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
subq %rdx, %rcx
setne %al
je 0x8f977
sarq $0x4, %rcx
movl 0x8(%rsi), %esi
cmpq $0x1, %rcx
movq %rcx, %rdi
adcq $0x0, %rdi
cmpl %esi, 0x8(%rdx)
je 0x8f977
addq $0x18, %rdx
movl $0x1, %r8d
movq %r8, %rax
cmpq %r8, %rdi
je 0x8f971
leaq 0x1(%rax), %r8
leaq 0x10(%rdx), %r9
cmpl %esi, (... | /segviol[P]indigo/frontend/optim_mir.cpp |
calcu_in(int, std::map<int, std::vector<mir::inst::VarId, std::allocator<mir::inst::VarId>>, std::less<int>, std::allocator<std::pair<int const, std::vector<mir::inst::VarId, std::allocator<mir::inst::VarId>>>>>, std::map<int, std::vector<mir::inst::VarId, std::allocator<mir::inst::VarId>>, std::less<int>, std::allocat... | vector<mir::inst::VarId> calcu_in(int n, map<int, vector<mir::inst::VarId>> use,
map<int, vector<mir::inst::VarId>> out,
map<int, vector<mir::inst::VarId>> def) {
// in[b] = use[b] U (out[b] - def[b])
map<int, vector<mir::inst::VarId>>::iterator it... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %r8, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rcx), %rdx
addq $0x8, %rcx
movq %rcx, %rax
testq %rdx, %rdx
je 0x8fe67
movq %rcx, %rax
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rax
movq 0x10(%rdx,%rsi,8), %rdx
te... | /segviol[P]indigo/frontend/optim_mir.cpp |
dominac_frontier(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>, std::map<int, front::optim_mir::BasicBlock*, std::less<int>, std::allocator<std::pair<int const, front::optim_mir::BasicBlock*>>>) | map<int, vector<int>> dominac_frontier(map<int, int> dom,
map<int, BasicBlock*> nodes) {
map<int, vector<int>> dom_f;
map<int, int>::iterator iter;
for (iter = dom.begin(); iter != dom.end(); iter++) {
map<int, BasicBlock*>::iterator it = nodes.find(iter->first);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movl $0x0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %r12, 0x18(%rdi)
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq 0x18(%rsi), %rdi
leaq 0x8(%rsi), %rax
movq %rax,... | /segviol[P]indigo/frontend/optim_mir.cpp |
ir_phi(mir::inst::VarId, int) | shared_ptr<mir::inst::PhiInst> ir_phi(mir::inst::VarId var, int n) {
vector<mir::inst::VarId> vars;
for (int i = 0; i < n; i++) {
vars.push_back(var);
}
return shared_ptr<mir::inst::PhiInst>(new mir::inst::PhiInst(var, vars));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testl %edx, %edx
jle 0x94ec9
movl %edx, %ebp
movq %rsp, %r14
leaq 0x591bf(%rip), %r12 # 0xee058
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x94eba
... | /segviol[P]indigo/frontend/optim_mir.cpp |
pop() | mir::inst::VarId pop() {
mir::inst::VarId a = V.back();
V.pop_back();
return a;
} | movq %rdi, %rax
movq 0x5d490(%rip), %rcx # 0xf2678
leaq 0x58e69(%rip), %rdx # 0xee058
movq %rdx, (%rdi)
movl -0x8(%rcx), %edx
addq $-0x10, %rcx
movl %edx, 0x8(%rdi)
movq %rcx, 0x5d475(%rip) # 0xf2678
retq
| /segviol[P]indigo/frontend/optim_mir.cpp |
rename_var(mir::inst::VarId, front::optim_mir::BasicBlock*, std::map<int, front::optim_mir::BasicBlock*, std::less<int>, std::allocator<std::pair<int const, front::optim_mir::BasicBlock*>>>, std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::al... | void rename_var(mir::inst::VarId id, BasicBlock* b, map<int, BasicBlock*> nodes,
map<int, vector<int>> dom_tree) {
mir::inst::VarId ve = top();
for (int i = 0; i < b->inst.size(); i++) {
if (b->inst[i].index() == 0) {
shared_ptr<mir::inst::Inst> ins = get<0>(b->inst[i]);
if (ins->ins... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rcx, 0x38(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq 0x5d42f(%rip), %rax # 0xf2678
movl -0x8(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x8(%rsi), %rax
cmpq %rax, 0x10(%rsi)
je ... | /segviol[P]indigo/frontend/optim_mir.cpp |
void std::__move_median_to_first<__gnu_cxx::__normal_iterator<mir::inst::VarId*, std::vector<mir::inst::VarId, std::allocator<mir::inst::VarId>>>, __gnu_cxx::__ops::_Iter_less_iter>(__gnu_cxx::__normal_iterator<mir::inst::VarId*, std::vector<mir::inst::VarId, std::allocator<mir::inst::VarId>>>, __gnu_cxx::__normal_iter... | bool operator<(const VarId& other) const { return id < other.id; } | movl 0x8(%rsi), %r8d
movl 0x8(%rdx), %r9d
movl 0x8(%rcx), %eax
cmpl %r9d, %r8d
jae 0x9d7c0
cmpl %eax, %r9d
jae 0x9d7d0
movl 0x8(%rdi), %eax
movl %r9d, 0x8(%rdi)
movl %eax, 0x8(%rdx)
retq
cmpl %eax, %r8d
jae 0x9d7df
movl 0x8(%rdi), %eax
movl %r8d, 0x8(%rdi)
movl %eax, 0x8(%rsi)
retq
movl 0x8(%rdi), %edx
cmpl %eax, %r8d
... | /segviol[P]indigo/frontend/../mir/mir.hpp |
front::symbolTable::SymbolTable::SymbolTable() | SymbolTable::SymbolTable() {
holder_symbol = SharedSyPtr(new symbol::VoidSymbol());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x48(%rdi), %rax
movq %rax, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x38(%rdi) # imm = 0x3F800000
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
mov... | /segviol[P]indigo/frontend/symbol_table.cpp |
front::symbolTable::SymbolTable::pop_symbol() | void SymbolTable::pop_symbol() {
SharedSyPtr symbol = symbol_stack.back();
symbol_stack.pop_back();
symbol_map[symbol->getName()].pop_back();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq -0x10(%rax), %r12
movq -0x8(%rax), %rbx
testq %rbx, %rbx
je 0x9ed96
movq 0x52208(%rip), %rax # 0xf0f90
cmpb $0x0, (%rax)
je 0x9ed92
incl 0x8(%rbx)
jmp 0x9ed96
lock
incl 0x8(%rbx)
movq 0x8(%r14), %rax
leaq -0x10(%r... | /segviol[P]indigo/frontend/symbol_table.cpp |
front::symbol::VoidSymbol::VoidSymbol() | VoidSymbol() : Symbol("void", -1) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e08f(%rip), %rsi # 0xbcf57
leaq 0x1e08c(%rip), %rdx # 0xbcf5b
movq %rsp, %r14
movq %r14, %rdi
callq 0x1ae2c
leaq 0x50b77(%rip), %rax # 0xefa58
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x... | /segviol[P]indigo/frontend/symbol.hpp |
front::symbol::Symbol::~Symbol() | int getLayerNum() { return _layerNum; } | movq %rdi, %rax
leaq 0x50a6e(%rip), %rcx # 0xefa58
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x9f005
movq (%rax), %rsi
incq %rsi
jmp 0xc3d0
retq
| /segviol[P]indigo/frontend/symbol.hpp |
front::syntax::SyntaxAnalyze::match_one_word(front::word::Token) | bool SyntaxAnalyze::match_one_word(Token tk) {
bool return_value = false;
if (matched_index + 1 < word_list.size()) {
if (word_list[matched_index + 1].match_token(tk)) {
LOG(TRACE) << word_list[matched_index + 1].get_self() << std::endl;
matched_index++;
return_value = true;
}
} else {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
incq %rax
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rc... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::try_word(int, front::word::Token, front::word::Token, front::word::Token) | bool SyntaxAnalyze::try_word(int n, Token tk1, Token tk2, Token tk3) {
bool return_value = false;
if (matched_index + n < word_list.size()) {
return_value = try_word(n, tk1) || try_word(n, tk2) || try_word(n, tk3);
}
return return_value;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %esi, %ebp
movslq %esi, %rax
addq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
sarq $0x4, %rsi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rcx
cmpq %rcx, %rax
jae 0xa26af
movl %r8d... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::hp_gn_binary_mir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<front::express::ExpressNode>, std::shared_ptr<front::express::ExpressNode>, mir::inst::Op) | void SyntaxAnalyze::hp_gn_binary_mir(string tmpName, SharedExNdPtr first,
SharedExNdPtr second, Op op) {
RightVal op1;
RightVal op2;
if (first->_type == NodeType::CNS) {
op1.emplace<0>(first->_value);
} else {
op1 = first->_name;
}
if (second->_type == NodeType:... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %r8d, %ebx
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0x58(%rsp)
movb %al, 0x78(%rsp)
movl %eax, 0x8(%rsp)
movb %al, 0x28(%rsp)
movq (%rdx), %rsi
cmpl %eax, (%rsi)
je 0xa4c59
addq $0x10, %rsi
leaq 0x58(%rsp), %r... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::gm_l_val(front::syntax::ValueMode) | SharedExNdPtr SyntaxAnalyze::gm_l_val(ValueMode mode) {
SharedExNdPtr node(new ExpressNode());
string name;
match_one_word(Token::IDENFR);
name = get_least_matched_word().get_self();
if (try_word(1, Token::LBRACK)) {
SharedSyPtr arr = symbolTable.find_least_layer_symbol(name);
SharedExNdPtr index;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x618, %rsp # imm = 0x618
movl %edx, 0x5c(%rsp)
movq %rsi, %r15
movq %rdi, %rbp
movl $0x48, %edi
callq 0xc3c0
movq %rax, %rbx
movq %rax, %rdi
callq 0x7f37c
movq %rbx, (%rbp)
leaq 0x8(%rbp), %rdi
movq %rdi, 0xa8(%rsp)
movq %rbx, %rsi
call... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::computeIndex(std::shared_ptr<front::symbol::Symbol>, std::shared_ptr<front::express::ExpressNode>) | SharedExNdPtr SyntaxAnalyze::computeIndex(SharedSyPtr arr, SharedExNdPtr node) {
vector<SharedExNdPtr> &dimesions =
std::static_pointer_cast<ArraySymbol>(arr)->_dimensions;
string tmpPtr;
string tmpOff;
RightVal rightvalue1;
RightVal rightvalue2;
SharedExNdPtr index = node->_children.front();
size_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3b8, %rsp # imm = 0x3B8
movq %rcx, 0x40(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x108(%rsp)
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0xa8b79
movq 0x48425(%rip), %rax # 0xf0f90
cmpb $0x0, (%rax)
je 0xa8b75... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::gm_func_param(std::vector<std::shared_ptr<front::symbol::Symbol>, std::allocator<std::shared_ptr<front::symbol::Symbol>>>&, int, std::vector<std::pair<std::shared_ptr<front::symbol::Symbol>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std... | void SyntaxAnalyze::gm_func_param(
vector<SharedSyPtr> ¶ms, int funcLayerNum,
vector<std::pair<SharedSyPtr, string>> &genValues) {
string name;
SharedSyPtr symbol;
match_one_word(Token::INTTK);
match_one_word(Token::IDENFR);
name = get_least_matched_word().get_self();
if (try_word(1, Token::LB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rcx, 0xc8(%rsp)
movl %edx, %ebp
movq %rsi, 0xd0(%rsp)
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl $0x4,... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::gm_block_item() | void SyntaxAnalyze::gm_block_item() {
if (try_word(1, Token::CONSTTK)) {
gm_const_decl();
} else if (try_word(1, Token::INTTK)) {
gm_var_decl();
} else {
gm_stmt();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
incq %rax
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r14, %rcx
cmpq %rcx, %rax
jae 0xaa9fd
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::gm_return_stmt() | void SyntaxAnalyze::gm_return_stmt() {
std::optional<string> retStr;
match_one_word(Token::RETURNTK);
if (!try_word(1, Token::SEMICN)) {
SharedExNdPtr retValue;
retValue = gm_exp();
if (retValue->_type == NodeType::CNS) {
string tmpName = irGenerator.getNewTmpValueName(TyKind::Int);
Rig... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movb $0x0, 0x30(%rsp)
movl $0xb, %esi
callq 0xa11e8
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
incq %rax
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::gm_while_stmt_normal() | void SyntaxAnalyze::gm_while_stmt_normal() {
SharedExNdPtr cond;
LabelId whileTrue = irGenerator.getNewLabelId();
LabelId whileEnd = irGenerator.getNewLabelId();
LabelId whileBegin = irGenerator.getNewLabelId();
std::optional<string> condStr;
irGenerator::WhileLabels whileLabels =
irGenerator::WhileLa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r12
leaq 0x80(%rdi), %r14
movq %r14, %rdi
callq 0x85262
movl %eax, %r15d
movq %r14, %rdi
callq 0x85262
movl %eax, %ebx
movq %r14, %rdi
callq 0x85262
movl %eax, %ebp
movb $0x0, 0x30(%rsp)
movq %rbx, 0... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::syntax::SyntaxAnalyze::gm_eq_exp() | SharedExNdPtr SyntaxAnalyze::gm_eq_exp() {
SharedExNdPtr first;
first = gm_rel_exp();
while (try_word(1, Token::EQL, Token::NEQ)) {
SharedExNdPtr second;
SharedExNdPtr father(new ExpressNode());
Op op;
if (try_word(1, Token::EQL)) {
match_one_word(Token::EQL);
father->_operation = Op... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %rdi
callq 0xad318
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
j... | /segviol[P]indigo/frontend/syntax_analyze.cpp |
front::symbol::ArraySymbol::getLen() | int getLen() {
if (_size == -1) {
getSize();
}
return _size / static_pointer_cast<IntSymbol>(_item)->getSize();
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpl $-0x1, 0x44(%rdi)
jne 0xadfeb
movq %r14, %rdi
callq 0xae738
movl 0x44(%r14), %ebx
movq 0x30(%r14), %rax
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0xae011
movq 0x42f8d(%rip), %rcx # 0xf0f90
cmpb $0x0, (%rcx)
je 0xae00d
incl 0x8(%rdi)
jmp 0xae011
lock
incl 0x8(%rd... | /segviol[P]indigo/frontend/symbol.hpp |
front::symbol::FunctionSymbol::~FunctionSymbol() | virtual ~FunctionSymbol() {} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x9ef52
leaq 0x41686(%rip), %rax # 0xefa58
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xae3ee
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0xc3d0
popq %rbx
retq
| /segviol[P]indigo/frontend/symbol.hpp |
front::symbol::ArraySymbol::~ArraySymbol() | virtual ~ArraySymbol() {} | pushq %rbx
movq %rdi, %rbx
addq $0x60, %rdi
callq 0x7f42c
leaq 0x48(%rbx), %rdi
callq 0x7f42c
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xae6fa
callq 0x17e2e
leaq 0x41357(%rip), %rax # 0xefa58
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xae71d
movq (%rbx), %rsi
incq %rsi
popq %rbx
jm... | /segviol[P]indigo/frontend/symbol.hpp |
front::word::word_analyse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<front::word::Word, std::allocator<front::word::Word>>&) | void front::word::word_analyse(string &input_str, vector<Word> &word_arr) {
string buf;
size_t index = 0;
char ch = 0;
input_str = '\0' + input_str;
while (index < input_str.size()) {
get_char(ch, index, input_str);
buf.clear();
while ((!have_body_char(ch) || is_illegel_char(ch)) &&
ind... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq %rsi, 0x30(%rsp)
movq %rdi, %r12
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xb1bbc
movq %rsp, %r15
movq %r12,... | /segviol[P]indigo/frontend/word_analyze.cpp |
front::word::get_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Token front::word::get_token(const string &buf) {
if (buf == "const") {
return Token::CONSTTK;
} else if (buf == "int") {
return Token::INTTK;
} else if (buf == "void") {
return Token::VOIDTK;
} else if (buf == "if") {
return Token::IFTK;
} else if (buf == "else") {
return Token::ELSETK;
... | pushq %rbx
movq %rdi, %rbx
leaq 0x787c(%rip), %rsi # 0xb9120
callq 0xc0d0
testl %eax, %eax
je 0xb195b
leaq 0xa27d(%rip), %rsi # 0xbbb35
movq %rbx, %rdi
callq 0xc0d0
testl %eax, %eax
je 0xb1962
leaq 0xb688(%rip), %rsi # 0xbcf57
movq %rbx, %rdi
callq 0xc0d0
testl %eax, %eax
je 0xb1969
leaq 0xb1f6(%rip), %r... | /segviol[P]indigo/frontend/word_analyze.cpp |
front::word::Word::Word(front::word::Token, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int) | Word::Word(Token in_token_value, string in_self, unsigned int in_line_num) {
token_value = in_token_value;
self = in_self;
line_num = in_line_num;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %esi, (%rdi)
movq %r14, %rdi
movq %rdx, %rsi
callq 0xc1b0
movl %ebx, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq... | /segviol[P]indigo/frontend/word_analyze.cpp |
front::optimization::bmir_optimization::BmirOptimization::should_run_pass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | bool BmirOptimization::should_run_pass(std::string&& pass_name) {
auto pass = pass_name;
return should_run_pass(pass);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x18456
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1f1a
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %... | /segviol[P]indigo/frontend/optimization/bmir_optimization.cpp |
front::optimization::bmir_optimization::BmirOptimization::should_run_pass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool BmirOptimization::should_run_pass(std::string& pass_name) {
if (options.run_pass &&
(options.run_pass->find(pass_name) == options.run_pass->end())) {
return false;
} else {
if (options.skip_pass.find(pass_name) != options.skip_pass.end()) {
return false;
} else {
return true;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
cmpb $0x1, 0x78(%rdi)
jne 0xb1f47
addq $0x48, %rdi
movq %r14, %rsi
callq 0x3750e
movq 0x18(%rbx), %rcx
addq $0x50, %rcx
cmpq %rcx, %rax
je 0xb1f6e
movq 0x18(%rbx), %rdi
subq $-0x80, %rdi
movq %r14, %rsi
callq 0x3750e
movl $0x88, %ecx... | /segviol[P]indigo/frontend/optimization/bmir_optimization.cpp |
AixLog::operator<<(std::ostream&, AixLog::Function const&) | static std::ostream& operator<<(std::ostream& os, const Function& function) {
Log* log = dynamic_cast<Log*>(os.rdbuf());
if (log != nullptr) {
std::lock_guard<std::recursive_mutex> lock(log->mutex_);
log->metadata_.function = function;
} else if (function) {
os << function.name;
}
return os;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3e917(%rip), %rax # 0xf0f28
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rdi
testq %rdi, %rdi
je 0xb263f
movq 0x3e9a4(%rip), %rsi # 0xf0fd0
leaq 0x3b855(%rip), %rdx # 0xede88
xorl %ecx, %ecx
callq 0xc420
movq %rax, %r14
jmp 0xb2642
x... | /segviol[P]indigo/frontend/optimization/../../include/aixlog.hpp |
mir::inst::display_op(std::ostream&, mir::inst::Op) | void display_op(std::ostream& o, Op val) {
switch (val) {
case Op::Add:
o << "+";
break;
case Op::Sub:
o << "-";
break;
case Op::Mul:
o << "*";
break;
case Op::MulSh:
o << "MulSh";
break;
case Op::Div:
o << "/";
break;
case Op::Rem:
... | cmpl $0x12, %esi
ja 0xb2d2a
movl %esi, %eax
leaq 0x9fb6(%rip), %rcx # 0xbcc00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7d8f(%rip), %rsi # 0xba9e9
jmp 0xb2cfd
leaq 0xa253(%rip), %rsi # 0xbceb9
jmp 0xb2d20
leaq 0xa245(%rip), %rsi # 0xbceb7
jmp 0xb2cfd
leaq 0xa234(%rip), %rsi #... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::Variable::display(std::ostream&) const | void Variable::display(std::ostream& o) const {
o << *ty;
if (is_memory_var) {
o << " memory (" << *(type()) << ")";
}
if (is_temp_var) {
o << " temp";
}
o << ", priority: " << priority;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpb $0x1, 0x18(%r14)
jne 0xb2dc7
leaq 0xa152(%rip), %rsi # 0xbced0
movl $0x9, %edx
movq %rbx, %rdi
callq 0xc440
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb3ddc
movq ... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::Value::display(std::ostream&) const | void Value::display(std::ostream& o) const {
if (auto x = std::get_if<VarId>(this)) {
if (has_shift()) {
o << "(";
}
o << *x;
if (has_shift()) {
o << ", ";
arm::display_shift(o, shift);
o << " " << (unsigned int)shift_amount << ")";
}
} else if (auto x = std::get_if<int32... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x8(%rdi), %rax
movb 0x18(%rdi), %cl
xorl %r15d, %r15d
cmpb $0x1, %cl
cmoveq %rax, %r15
jne 0xb2edd
movq %rdi, %r14
cmpb $0x0, 0x18(%rdi)
je 0xb2e69
cmpb $0x0, 0x1a(%r14)
je 0xb2e69
leaq 0xa07c(%rip), %rsi # 0xbced8
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc440
... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::CallInst::display(std::ostream&) const | void CallInst::display(std::ostream& o) const {
o << dest << " = " << func << "(";
for (size_t i = 0; i < params.size(); i++) {
if (i != 0) o << ", ";
o << params[i];
}
o << ")";
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *(%rax)
leaq 0x9e71(%rip), %rsi # 0xbceed
movl $0x3, %edx
movq %rbx, %rdi
callq 0xc440
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq %rbx, %rdi
callq 0xc440
leaq 0x9e38(%rip), %rsi ... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::LoadInst::display(std::ostream&) const | void LoadInst::display(std::ostream& o) const {
o << dest << " = load " << src;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *(%rax)
leaq 0x9d3b(%rip), %rsi # 0xbcef6
movl $0x8, %edx
movq %rbx, %rdi
callq 0xc440
movq 0x18(%r14), %rax
addq $0x18, %r14
movq (%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq ... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::PtrOffsetInst::display(std::ostream&) const | void PtrOffsetInst::display(std::ostream& o) const {
o << dest << " = offset " << ptr << " by " << offset;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *(%rax)
leaq 0x9b91(%rip), %rsi # 0xbcf10
movl $0xa, %edx
movq %rbx, %rdi
callq 0xc440
leaq 0x18(%r14), %rdi
movq 0x18(%r14), %rax
movq %rbx, %rsi
callq *(%rax)
leaq 0x9b7b(%rip), %rsi # 0xbcf1b
movl $0... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::PhiInst::display(std::ostream&) const | void PhiInst::display(std::ostream& o) const {
o << dest << " = phi [";
for (size_t i = 0; i < vars.size(); i++) {
if (i != 0) o << ", ";
o << vars[i];
}
o << "]";
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *(%rax)
leaq 0x9b38(%rip), %rsi # 0xbcf20
movl $0x8, %edx
movq %rbx, %rdi
callq 0xc440
movq 0x30(%r14), %rax
cmpq 0x28(%r14), %rax
je 0xb3449
xorl %r12d, %r12d
leaq 0x9afa(%rip), %r15 ... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::MirFunction::display(std::ostream&) const | void MirFunction::display(std::ostream& o) const {
auto& return_ty = type->ret;
auto& params = type->params;
if (type->is_extern) {
o << "extern fn " << name << "(";
for (auto i = params.begin(); i != params.end(); i++) {
if (i != params.begin()) o << ", ";
o << **i;
}
o << ") -> " << ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r12
cmpb $0x1, 0x30(%r12)
jne 0xb3838
leaq 0x97e2(%rip), %rsi # 0xbcf7c
movl $0xa, %edx
movq %rbx, %rdi
callq 0xc440
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0xc440... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::MirFunction::variable_table_size() const | size_t MirFunction::variable_table_size() const {
size_t size = 0;
for (auto& v : variables) {
auto s = v.second.ty->size();
if (s) size += s.value();
}
return size;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %r15
addq $0x40, %rbx
xorl %r14d, %r14d
cmpq %rbx, %r15
je 0xb3a73
movq 0x30(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movslq %eax, %rcx
shlq $0x1f, %rax
sarq $0x3f, %rax
andq %rax, %rcx
addq %rcx, %r14
movq %r15, %rdi
callq 0xc450
movq %rax, %r15
... | /segviol[P]indigo/mir/mir.cpp |
mir::types::PtrTy::reduce_array() | void PtrTy::reduce_array() {
if (this->item->kind() == TyKind::Array) {
auto arr = std::dynamic_pointer_cast<ArrayTy>(this->item);
this->item = arr->item;
}
// else noop
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x2, %eax
jne 0xb3b57
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0xb3b09
leaq 0x3c334(%rip), %rax # 0xefe38
cmpq %rax, (%rsi)
je 0xb3b0b
xorl %esi, %esi
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0xb3b2b
movq... | /segviol[P]indigo/mir/mir.cpp |
mir::types::FunctionTy::display(std::ostream&) const | void FunctionTy::display(std::ostream& o) const {
o << "Fn(";
for (auto i = params.begin(); i != params.end(); i++) {
if (i != params.begin()) o << ", ";
o << **i;
}
o << ") -> " << *ret;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9370(%rip), %rsi # 0xbcf95
movl $0x3, %edx
movq %rbx, %rdi
callq 0xc440
movq 0x18(%r14), %r12
cmpq 0x20(%r14), %r12
je 0xb3c6f
leaq 0x92c0(%rip), %r15 # 0xbcf03
cmpq 0x18(%r14), %r12
je 0xb3c59
movl $0x2, %edx
movq %... | /segviol[P]indigo/mir/mir.cpp |
mir::types::new_int_ty() | std::shared_ptr<IntTy> new_int_ty() { return std::make_shared<IntTy>(); } | pushq %rbx
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x18, %edi
callq 0xc3c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3ab94(%rip), %rcx # 0xee870
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x3c09e(%rip), %rdx # 0xefd88
movq %rdx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rcx, ... | /segviol[P]indigo/mir/mir.cpp |
mir::types::new_void_ty() | std::shared_ptr<VoidTy> new_void_ty() { return std::make_shared<VoidTy>(); } | pushq %rbx
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x18, %edi
callq 0xc3c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3c8ec(%rip), %rcx # 0xf0610
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x3c0ae(%rip), %rdx # 0xefde0
movq %rdx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rcx, ... | /segviol[P]indigo/mir/mir.cpp |
mir::inst::Variable::type() const | types::SharedTyPtr type() const {
if (is_memory_var) {
return types::new_ptr_ty(ty);
} else {
return ty;
}
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x18(%rsi)
jne 0xb3e12
movq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0xb3e3b
movq 0x3d188(%rip), %rcx # 0xf0f90
cmpb $0x0, (%rcx)
je 0xb3e37
incl 0x8(%rax)
jmp 0xb3e3b
movq 0x8(%rsi), %rax
movq %rax, ... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::AssignInst::deep_copy() | Inst* deep_copy() { return new AssignInst(dest, src); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movl $0x38, %edi
callq 0xc3c0
movq %rax, %rbx
movl 0x10(%r15), %ebp
leaq 0x10(%rsp), %r14
leaq 0x20(%r15), %rsi
movb $-0x1, 0x10(%r14)
movsbq 0x30(%r15), %rax
movb %al, 0x10(%r14)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::OpInst::useVars() const | std::set<VarId> useVars() const {
auto s = std::set<VarId>();
if (lhs.index() == 1) {
s.insert(std::get<VarId>(lhs));
}
if (rhs.index() == 1) {
s.insert(std::get<VarId>(rhs));
}
return s;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
cmpb $0x1, 0x30(%rsi)
jne 0xb417a
leaq 0x20(%r14), %rdi
callq 0x32916
movq %rb... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::OpInst::deep_copy() | Inst* deep_copy() { return new OpInst(dest, lhs, rhs, op); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0xc3c0
movq %rax, %rbx
leaq 0x39e4c(%rip), %rax # 0xee058
movq %rax, 0x8(%rsp)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rsp)
leaq 0x20(%rsp), %rax
leaq 0x20(%r14), %rsi
movb $-0x1, 0x10(%rax)
movsbq 0x30(%r14), %rcx
mo... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::CallInst::deep_copy() | Inst* deep_copy() { return new CallInst(dest, func, params); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movl $0x50, %edi
callq 0xc3c0
movq %rax, %rbx
leaq 0x39a94(%rip), %rax # 0xee058
movq %rax, 0x40(%rsp)
movl 0x10(%r14), %eax
movl %eax, 0x48(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
addq %rsi, %rd... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::LoadInst::deep_copy() | Inst* deep_copy() { return new LoadInst(src, dest); } | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r15
movl $0x38, %edi
callq 0xc3c0
movq %rax, %rbx
leaq 0x18(%rsp), %r14
leaq 0x20(%r15), %rsi
movb $-0x1, 0x10(%r14)
movsbq 0x30(%r15), %rax
movb %al, 0x10(%r14)
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x397af(%rip), %r12 # 0xee... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::StoreOffsetInst::useVars() const | std::set<VarId> useVars()
const { // for storeInst,dest is also use(not defined)
auto s = std::set<VarId>();
s.insert(dest);
if (val.index() == 1) {
s.insert(std::get<VarId>(val));
}
if (offset.index() == 1) {
s.insert(std::get<VarId>(offset));
}
return s;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x8, %rsi
callq 0x20cf2
cmpb $0x1, 0x30(%r14)
jne 0xb4cbc
leaq 0x20(%r14... | /segviol[P]indigo/mir/mir.hpp |
mir::inst::PtrOffsetInst::useVars() const | std::set<VarId> useVars() const {
auto s = std::set<VarId>();
s.insert(ptr);
if (offset.index() == 1) {
s.insert(std::get<VarId>(offset));
}
return s;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x18, %rsi
callq 0x20cf2
cmpb $0x1, 0x40(%r14)
jne 0xb4e69
addq $0x30, %... | /segviol[P]indigo/mir/mir.hpp |
arm::register_type(unsigned int) | RegisterKind register_type(Reg r) {
if (r < 16)
return RegisterKind::GeneralPurpose;
else if (r < 48)
return RegisterKind::DoubleVector;
else if (r < 64)
return RegisterKind::QuadVector;
else if (r < 1 << 31)
return RegisterKind::VirtualGeneralPurpose;
else if (r < 3 << 30)
return Register... | xorl %eax, %eax
cmpl $0x10, %edi
jb 0xb5568
movl $0x1, %eax
cmpl $0x30, %edi
jb 0xb5568
movl $0x2, %eax
cmpl $0x40, %edi
jb 0xb5568
movl $0x3, %eax
testl %edi, %edi
js 0xb5569
retq
cmpl $0xc0000000, %edi # imm = 0xC0000000
movl $0x5, %eax
sbbl $0x0, %eax
retq
| /segviol[P]indigo/arm_code/arm.cpp |
arm::register_num(unsigned int) | uint32_t register_num(Reg r) {
if (r < 16)
return r;
else if (r < 48)
return r - 16;
else if (r < 64)
return r - 48;
else if (r < 1 << 31)
return r - 64;
else if (r < 3 << 30)
return r - (1 << 31);
else
return r - (3 << 30);
} | movl %edi, %eax
cmpl $0x10, %edi
jae 0xb5580
retq
cmpl $0x2f, %eax
ja 0xb5589
addl $-0x10, %eax
retq
cmpl $0x3f, %eax
ja 0xb5592
addl $-0x30, %eax
retq
testl %eax, %eax
js 0xb559a
addl $-0x40, %eax
retq
cmpl $0xbfffffff, %eax # imm = 0xBFFFFFFF
ja 0xb55a7
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
addl ... | /segviol[P]indigo/arm_code/arm.cpp |
arm::display_shift(std::ostream&, arm::RegisterShiftKind) | void display_shift(std::ostream &o, RegisterShiftKind shift) {
switch (shift) {
case RegisterShiftKind::Lsl:
o << "LSL";
break;
case RegisterShiftKind::Lsr:
o << "LSR";
break;
case RegisterShiftKind::Asr:
o << "ASR";
break;
case RegisterShiftKind::Ror:
o << "R... | cmpb $0x4, %sil
ja 0xb56e4
movzbl %sil, %eax
leaq 0x7e91(%rip), %rcx # 0xbd564
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movl $0x3, %edx
jmp 0xc440
retq
| /segviol[P]indigo/arm_code/arm.cpp |
arm::is_valid_immediate(unsigned int) | bool is_valid_immediate(uint32_t val) {
if (val <= 0xff)
return true;
else if (val <= 0x00ffffff) {
int highest_bit = log2(val & -val) + 1;
return (val & ~(0xff << highest_bit)) == 0 && highest_bit % 2 == 0;
} else {
val = prelude::rotl32(val, 8);
int highest_bit = log2(val & -val) + 1;
re... | movb $0x1, %al
cmpl $0x100, %edi # imm = 0x100
jb 0xb57ce
pushq %rbx
movl %edi, %ebx
movl %edi, %eax
negl %eax
andl %edi, %eax
cvtsi2sd %rax, %xmm0
callq 0xc670
addsd 0x7e12(%rip), %xmm0 # 0xbd5c8
cvttsd2si %xmm0, %ecx
movl $0xff, %eax
shll %cl, %eax
notl %eax
andl %ebx, %eax
andl $0x1, %ecx
orl %eax, %e... | /segviol[P]indigo/arm_code/arm.cpp |
arm::display_op(arm::OpCode, std::ostream&) | void display_op(OpCode op, std::ostream &o) {
switch (op) {
case OpCode::Nop:
o << "nop";
break;
case OpCode::B:
o << "b";
break;
case OpCode::Bl:
o << "bl";
break;
case OpCode::Bx:
o << "bx";
break;
case OpCode::Cbz:
o << "cbz";
break;
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x22, %edi
ja 0xb59dc
movl %ebp, %eax
leaq 0x7b30(%rip), %rcx # 0xbd378
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7dd7(%rip), %rsi # 0xbd62f
jmp 0xb59c9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7e09(%rip), %rsi ... | /segviol[P]indigo/arm_code/arm.cpp |
arm::display_cond(arm::ConditionCode, std::ostream&) | void display_cond(ConditionCode cond, std::ostream &o) {
switch (cond) {
case ConditionCode::Equal:
o << "eq";
break;
case ConditionCode::NotEqual:
o << "ne";
break;
case ConditionCode::CarrySet:
o << "cs";
break;
case ConditionCode::CarryClear:
o << "cc";
... | cmpb $0xf, %dil
ja 0xb5a28
movzbl %dil, %eax
leaq 0x7b67(%rip), %rcx # 0xbd578
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movl $0x2, %edx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0xc440
retq
| /segviol[P]indigo/arm_code/arm.cpp |
arm::reverse_cond(arm::ConditionCode) | ConditionCode reverse_cond(ConditionCode cond) {
switch (cond) {
case ConditionCode::Equal:
case ConditionCode::NotEqual:
case ConditionCode::CarrySet:
case ConditionCode::CarryClear:
case ConditionCode::MinusOrNegative:
case ConditionCode::PositiveOrZero:
case ConditionCode::Overflow:
... | movl %edi, %eax
leal -0x3(%rax), %ecx
cmpb $0xc, %cl
ja 0xb5a61
movzbl %cl, %ecx
movl $0x1f85, %edx # imm = 0x1F85
btl %ecx, %edx
jae 0xb5a61
leaq 0x7b5a(%rip), %rax # 0xbd5b8
movb (%rcx,%rax), %al
retq
| /segviol[P]indigo/arm_code/arm.cpp |
arm::MemoryOperand::display(std::ostream&) const | void MemoryOperand::display(std::ostream &o) const {
auto display_offset = [&](std::ostream &o) {
if (auto x = std::get_if<RegisterOperand>(&offset)) {
if (neg_rm) o << "-";
o << *x;
} else if (auto x = std::get_if<int16_t>(&offset)) {
o << "#" << *x;
}
};
o << "[";
display_reg_nam... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3574(%rip), %rsi # 0xb9529
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc440
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0xb55ad
movzbl 0x8(%r14), %eax
cmpl $0x2, %eax
je 0xb60a9
cmpl $0x1, %eax
je 0xb6042
testl %eax, %eax
jne ... | /segviol[P]indigo/arm_code/arm.cpp |
arm::Arith3Inst::display(std::ostream&) const | void Arith3Inst::display(std::ostream &o) const {
display_op(op, o);
display_cond(cond, o);
o << " ";
display_reg_name(o, rd);
o << ", ";
display_reg_name(o, r1);
o << ", " << r2;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edi
callq 0xb582e
movzbl 0xc(%r14), %edi
movq %rbx, %rsi
callq 0xb5a00
leaq 0x62e5(%rip), %rsi # 0xbc552
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc440
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xb55ad
leaq 0x6c76(%rip), %r15 # ... | /segviol[P]indigo/arm_code/arm.cpp |
arm::LoadStoreInst::display(std::ostream&) const | void LoadStoreInst::display(std::ostream &o) const {
display_op(op, o);
display_cond(cond, o);
o << " ";
display_reg_name(o, rd);
o << ", ";
if (auto m = std::get_if<std::string>(&mem)) {
o << *m;
} else if (auto m = std::get_if<MemoryOperand>(&mem)) {
o << *m;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edi
callq 0xb582e
movzbl 0xc(%r14), %edi
movq %rbx, %rsi
callq 0xb5a00
leaq 0x6170(%rip), %rsi # 0xbc552
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc440
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0xb55ad
leaq 0x6b01(%rip), %rsi # ... | /segviol[P]indigo/arm_code/arm.cpp |
arm::CtrlInst::display(std::ostream&) const | void CtrlInst::display(std::ostream &o) const {
if (is_asm_option) {
o << "." << key << " ";
ctrl_inst_display_type_a(val, int);
ctrl_inst_display_type_a(val, double);
ctrl_inst_display_type_a(val, float);
ctrl_inst_display_type_a(val, long);
ctrl_inst_display_type_a(val, std::string);
} els... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x30(%rdi), %r14
cmpb $0x1, 0xd(%rdi)
jne 0xb67c5
leaq 0x4bb3(%rip), %rsi # 0xbb1b1
movl $0x1, %edx
movq %rbx, %rdi
callq 0xc440
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
callq 0xc440
leaq 0x5f30(%ri... | /segviol[P]indigo/arm_code/arm.cpp |
arm::Function::display(std::ostream&) const | void Function::display(std::ostream &o) const {
for (auto &v : this->local_const) {
o << v.first << ":" << std::endl;
o << "\t" << v.second << std::endl;
}
o << "\t.globl " << name << std::endl;
o << "\t@ " << name << ": " << *ty << std::endl;
o << name << ":" << std::endl;
// o << "\t.align 7" <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x58(%rdi), %r15
movq %rdi, (%rsp)
leaq 0x48(%rdi), %r14
cmpq %r14, %r15
je 0xb6bce
leaq 0x2797(%rip), %r12 # 0xb92bb
leaq 0x2079(%rip), %r13 # 0xb8ba4
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbx, %rdi
... | /segviol[P]indigo/arm_code/arm.cpp |
fmt::v7::detail::bigint::align(fmt::v7::detail::bigint const&) | void align(const bigint& other) {
int exp_difference = exp_ - other.exp_;
if (exp_difference <= 0) return;
int num_bigits = static_cast<int>(bigits_.size());
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
bigits_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0xa8(%rdi), %r15d
subl 0xa8(%rsi), %r15d
jle 0x1872b
movq %rdi, %rbx
movl 0x10(%rdi), %r12d
leal (%r15,%r12), %r14d
cmpq %r14, 0x18(%rdi)
jae 0x186da
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
movq 0x18(%rbx), %rax
cmpq %r14, %rax
cmovbq %... | /diatomic[P]diy/include/diy/thirdparty/fmt/format-inl.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_int<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::int_writer<fmt::v7::detail::buffer_appender<char>, char, unsigned __int128>::on_oct()::'lambda'(fmt::v7::detail::buffer_appender<char>)>(fmt::v7::detail::buffer_appender<char>, int, fmt::v7::... | OutputIt write_int(OutputIt out, int num_digits, string_view prefix,
const basic_format_specs<Char>& specs, F f) {
auto data = write_int_data<Char>(num_digits, prefix, specs);
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded<align::right>(out, specs, data.size... | subq $0x38, %rsp
movq %r8, %r9
movq %rcx, %rax
leaq 0x40(%rsp), %r10
movl %esi, %ecx
addq %rax, %rcx
movb 0x9(%r8), %r8b
andb $0xf, %r8b
cmpb $0x4, %r8b
jne 0x20343
movl (%r9), %esi
xorl %r11d, %r11d
movq %rsi, %r8
subq %rcx, %r8
cmovaeq %r8, %r11
cmovaeq %rsi, %rcx
jmp 0x2035a
movl 0x4(%r9), %r11d
cmpl %esi, %r11d
jle... | /diatomic[P]diy/include/diy/thirdparty/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write<char, char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, fmt::v7::basic_string_view<char>, fmt::v7::basic_format_specs<char> const&) | OutputIt write(OutputIt out, basic_string_view<StrChar> s,
const basic_format_specs<Char>& specs) {
auto data = s.data();
auto size = s.size();
if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
size = code_point_index(s, to_unsigned(specs.precision));
auto width = specs.width !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl (%rcx), %eax
movl 0x4(%rcx), %ecx
cmpq %rdx, %rcx
movq %rcx, %r15
cmovaeq %rdx, %r15
testl %ecx, %ecx
cmovsq %rdx, %r15
testq %rax, %rax
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
je 0x... | /diatomic[P]diy/include/diy/thirdparty/fmt/format.h |
fmt::v7::detail::buffer_appender<char> fmt::v7::detail::write_char<char, fmt::v7::detail::buffer_appender<char>>(fmt::v7::detail::buffer_appender<char>, char, fmt::v7::basic_format_specs<char> const&) | OutputIt write_char(OutputIt out, Char value,
const basic_format_specs<Char>& specs) {
using iterator = remove_reference_t<decltype(reserve(out, 0))>;
return write_padded(out, specs, 1, [=](iterator it) {
*it++ = value;
return it;
});
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl (%rdx), %eax
xorl %r14d, %r14d
subq $0x1, %rax
cmovaeq %rax, %r14
movzbl 0x9(%rdx), %eax
andl $0xf, %eax
leaq 0x179a8(%rip), %rcx # 0x38148
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %rdi, %r12
movzbl 0xe(%rdx... | /diatomic[P]diy/include/diy/thirdparty/fmt/format.h |
fmt::v7::detail::arg_formatter_base<fmt::v7::detail::buffer_appender<char>, char, fmt::v7::detail::error_handler>::write(char) | void write(char value) {
auto&& it = reserve(1);
*it++ = value;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq (%rdi), %r14
movq 0x10(%r14), %rsi
incq %rsi
cmpq %rsi, 0x18(%r14)
jae 0x20848
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x10(%r14), %rsi
incq %rsi
cmpq %rsi, 0x18(%r14)
jae 0x2085d
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movq 0x8(%r14), %rax
movq... | /diatomic[P]diy/include/diy/thirdparty/fmt/format.h |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | testl %edi, %edi
jns 0x20c0
pushq %rax
callq 0x2030
movl $0x16, (%rax)
pushq $-0x1
popq %rax
popq %rcx
retq
| /komeilkma[P]curl/tests/libtest/first.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | movq %rdi, %rax
retq
| /komeilkma[P]curl/lib/warnless.c |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum &... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /komeilkma[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /komeilkma[P]curl/lib/warnless.c |
load_file | static int load_file( const char *path, unsigned char **buf, size_t *n )
{
FILE *f;
long size;
if( ( f = fopen( path, "rb" ) ) == NULL )
return( MBEDTLS_ERR_DHM_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
if( ( size = ftell( f ) ) == -1 )
{
fclose( f );
return( MBEDTLS_ER... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x31cb4(%rip), %rsi # 0xc0243
callq 0x382c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8e5aa
movl $0xffffcb80, -0x4(%rbp) # imm = 0xFFFFCB80
jmp 0x8e6d2
movq -0x28(%rbp), %r... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/dhm.c |
bool njoy::ENDFtk::section::Type<2, 151>::RMatrixLimited::TabulatedBackgroundRMatrix::compare<ranges::ref_view<std::vector<double, std::allocator<double>> const>>(ranges::ref_view<std::vector<double, std::allocator<double>> const> const&, ranges::ref_view<std::vector<double, std::allocator<double>> const> const&) | static bool compare( const Range& left, const Range& right ) {
return ranges::cpp20::count(
ranges::views::zip_with(
[] ( double left, double right ) { return left == right; },
left, right ), true ) == ranges::cpp20::distance( left );
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rsi), %rcx
movb $0x1, %dil
leaq 0x8(%rsp), %rsi
movb %dil, 0x1(%rsi)
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
leaq 0x7(%rsp), %rdx
movb %dil, (%rdx)
leaq 0x69c33(%rip), %rdi # 0xad6a4
callq 0x43b30
movq (%rbx), %rcx
movq (%rcx), %rdx
movq 0x8(%r... | /njoy[P]ENDFtk/src/ENDFtk/section/2/151/RMatrixLimited/TabulatedBackgroundRMatrix/src/verify.hpp |
njoy::ENDFtk::section::Type<2, 151>::RMatrixLimited::FrohnerBackgroundRMatrix::verifyLBK(int) | static void
verifyLBK( int LBK ) {
if ( LBK != 3 ) {
Log::error( "Encountered the wrong LBK value" );
Log::info( "Expected LBK to be equal to 3" );
Log::info( "LBK value: {}", LBK );
throw std::exception();
}
} | cmpl $0x3, %edi
jne 0x4423c
retq
pushq %rbx
movl %edi, %ebx
leaq 0x6575a(%rip), %rdi # 0xa99a0
callq 0x395e4
leaq 0x65c4b(%rip), %rdi # 0xa9e9d
callq 0x2cf76
leaq 0x656fc(%rip), %rdi # 0xa995a
movl %ebx, %esi
callq 0x3963e
movl $0x8, %edi
callq 0x172c0
movq 0xabcd2(%rip), %rcx # 0xeff48
addq $0x10, %rcx... | /njoy[P]ENDFtk/src/ENDFtk/section/2/151/RMatrixLimited/FrohnerBackgroundRMatrix/src/verifyLBK.hpp |
spdlog::details::registry::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
auto found = loggers_.find(logger_name);
return found == loggers_.end() ? nullptr : found->second;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x17940
testl %eax, %eax
jne 0x457c8
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0x4ceb8
testq %rax, %rax
je 0x457aa
movq 0x28(%rax), %rcx
movq %rcx, (%r14)
movq 0x30(%rax), %rax
movq %rax, 0x8(%r14)
testq %rax, %rax
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::registry::set_default_logger(std::shared_ptr<spdlog::logger>) | SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
// remove previous default logger from the map
if (default_logger_ != nullptr)
{
loggers_.erase(default_logger_->name());
}
if (new_default_l... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17940
testl %eax, %eax
jne 0x46329
movq 0x130(%rbx), %rsi
testq %rsi, %rsi
je 0x462cc
leaq 0x78(%rbx), %rdi
addq $0x8, %rsi
callq 0x4cef2
movq (%r14), %rsi
testq %rsi, %rsi
je 0x462f7
leaq 0x78(%rbx), %rdi
addq $0x8, %rsi
callq 0x4cffa
movq (%r14)... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/details/registry-inl.h |
spdlog::details::d_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mday, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4e3ce
movl 0xc(%r14), %r14d
cmpq $0x63, %r14
ja 0x4f3b6
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x4f357
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
mo... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::e_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
auto millis = fmt_helper::time_fraction<std::chrono::milliseconds>(msg.time);
const size_t field_size = 3;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad3(static_cast<uint32_t>(milli... | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq 0x18(%rsi), %rcx
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
movq %rcx, %rax
imulq %rdx
movq %rdx, %rsi
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x1a, %rsi
addl %eax, %esi
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rcx, %... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::z_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 6;
ScopedPadder p(field_size, padinfo_, dest);
auto total_minutes = get_cached_offset(msg, tm_time);
bool is_negative = total_minutes < 0;
if (is_negativ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rdi), %rdx
leaq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x4e3ce
movq 0x18(%r12), %rsi
movq %rsi, %rax
subq 0x18(%r14), %rax
movabsq $0x2540be400, %rcx # imm = 0x2540BE400
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::source_filename_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
if (msg.source.empty())
{
ScopedPadder p(0, padinfo_, dest);
return;
}
size_t text_size = padinfo_.enabled() ? std::char_traits<char>::length(msg.source.filename) : 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %rdx
cmpl $0x0, 0x40(%rsi)
je 0x50b74
movq %rsi, %r14
leaq 0x8(%rdx), %r15
cmpb $0x1, 0x15(%rdx)
jne 0x50b8f
movq 0x38(%r14), %rdi
callq 0x17250
movq %rax, %rsi
jmp 0x50b91
addq $0x8, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
m... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::C_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_year % 100, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movslq 0x14(%rdx), %r14
imulq $0x51eb851f, %r14, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %r14d
cmpl $0x63, %r14d
ja 0x51a1b
movl %r14d, %eax
movl $0xcccccccd, %r15d ... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::d_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override
{
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_mday, dest);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl 0xc(%rdx), %r14d
cmpq $0x63, %r14
ja 0x51f04
movl $0xcccccccd, %r15d # imm = 0xCCCCCCCD
imulq %r14, %r15
shrq $0x23, %r15
leal (%r15,%r15), %eax
leal (%rax,%rax,4), %eax
subl %eax, %r14d
orb $0x30, %r15b
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rs... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::pid_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override
{
const auto pid = static_cast<uint32_t>(details::os::pid());
auto field_size = ScopedPadder::count_digits(pid);
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::append_int(pid, dest);
} | pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
callq 0x17930
leaq 0x15(%rsp), %rsi
leaq 0x55d84(%rip), %rcx # 0xa8db1
cmpl $0x64, %eax
jb 0x53060
movl %eax, %edx
imulq $0x51eb851f, %rdx, %rdx # imm = 0x51EB851F
shrq $0x25, %rdx
imull $0x64, %edx, %edi
movl %eax, %r8d
subl %edi, %r8d
movzwl (%rcx,%r8,2), %edi
movw %di,... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::details::elapsed_formatter<spdlog::details::null_scoped_padder, std::chrono::duration<long, std::ratio<1l, 1l>>>::format(spdlog::details::log_msg const&, tm const&, fmt::v9::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override
{
auto delta = (std::max)(msg.time - last_message_time_, log_clock::duration::zero());
auto delta_units = std::chrono::duration_cast<DurationUnits>(delta);
last_message_time_ = msg.time;
auto delta... | subq $0x28, %rsp
movq 0x18(%rsi), %rsi
movq %rsi, %r9
subq 0x18(%rdi), %r9
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
movabsq $0x112e0be826d694b3, %rdx # imm = 0x112E0BE826D694B3
mulq %rdx
movq %rdx, %r8
shrq $0x1a, %r8
movq %rsi, 0x18(%rdi)
leaq 0x1d(%rsp), %rsi
movabsq $0x174876e800, %rax # imm = 0x174876E80... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>::set_color_mode(spdlog::color_mode) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
return;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal()... | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x53c89
cmpl $0x2, %esi
je 0x53c85
cmpl $0x1, %esi
jne 0x53c85
movq 0x1c0(%rbx), %rdi
callq 0x47597
testb %al, %al
je 0x53c85
callq 0x474b5
jmp 0x53c8b
xorl %eax, %eax
jmp 0x53c8b
movb $0x1, %al
movb %al, 0x1d0(%rbx)
popq %rbx
retq
nop
| /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::to_string_[abi:cxx11](fmt::v9::basic_string_view<char> const&) | SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv)
{
return std::string(sv.data(), sv.size());
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %rcx
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x44dc6
movq %rbx, %rax
popq %rbx
retq
| /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>) | SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter)
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::move(sink_formatter);
} | movq %rdi, %rax
movq (%rsi), %rcx
movq $0x0, (%rsi)
movq 0x1d8(%rdi), %rdi
movq %rcx, 0x1d8(%rax)
testq %rdi, %rdi
je 0x54aba
movq (%rdi), %rax
jmpq *0x8(%rax)
retq
nop
| /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/sinks/ansicolor_sink-inl.h |
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.