idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
8,800 | Omega_h::Reader::indent_mismatch() | void Reader::indent_mismatch() {
OMEGA_H_CHECK(!indent_stack.empty());
auto top = indent_stack.back();
std::stringstream ss;
ss << "error: Indentation characters beginning line " << line << " of "
<< stream_name << " don't match those beginning line " << top.line << '\n';
ss << "It is strongly recommended not to mix tabs and spaces in "
"indentation-sensitive formats\n";
throw ParserFail(ss.str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
addq $0x168, %rdi # imm = 0x168
callq 0x1cfba0
testb $0x1, %al
jne 0x5013cc
jmp 0x5013ed
leaq 0x129c95(%rip), %rdi # 0x62b068
leaq 0x134165(%rip), %rsi # 0x63553f
leaq 0x134174(%rip), %rdx # 0x635555
movl $0x7d, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x1e8(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x1da6a0
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x1c6c20
leaq -0x198(%rbp), %rdi
leaq 0x13418d(%rip), %rsi # 0x6355b6
callq 0x1cd8f0
movq %rax, -0x1f0(%rbp)
jmp 0x501437
movq -0x1f0(%rbp), %rdi
movq -0x1e8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x1f8(%rbp)
jmp 0x501457
movq -0x1f8(%rbp), %rdi
leaq 0x134303(%rip), %rsi # 0x635768
callq 0x1cd8f0
movq %rax, -0x200(%rbp)
jmp 0x501473
movq -0x200(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
addq $0x120, %rsi # imm = 0x120
callq 0x1cb420
movq %rax, -0x208(%rbp)
jmp 0x501496
movq -0x208(%rbp), %rdi
leaq 0x134140(%rip), %rsi # 0x6355e4
callq 0x1cd8f0
movq %rax, -0x210(%rbp)
jmp 0x5014b2
movq -0x210(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1bbaf0
movq %rax, -0x218(%rbp)
jmp 0x5014cb
movq -0x218(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x5014de
leaq -0x198(%rbp), %rdi
leaq 0x13411b(%rip), %rsi # 0x635607
callq 0x1cd8f0
jmp 0x5014f3
movb $0x1, -0x1d9(%rbp)
movl $0x10, %edi
callq 0x1c1200
movq %rax, -0x220(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x1cd640
jmp 0x501520
movq -0x220(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x1d4c10
jmp 0x501535
movq -0x220(%rbp), %rdi
movb $0x0, -0x1d9(%rbp)
movq 0x1f64c6(%rip), %rsi # 0x6f7a10
movq 0x1f6997(%rip), %rdx # 0x6f7ee8
callq 0x1de5c0
jmp 0x5015cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x5015b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x50159e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x1c4d10
testb $0x1, -0x1d9(%rbp)
jne 0x5015a9
jmp 0x5015b5
movq -0x220(%rbp), %rdi
callq 0x1c6df0
jmp 0x5015b7
leaq -0x1a8(%rbp), %rdi
callq 0x1c76d0
movq -0x1b0(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,801 | Omega_h::Reader::at_token_indent(std::istream&) | void Reader::at_token_indent(std::istream& stream) {
if (!sensing_indent || lexer_token != tables->indent_info.newline_token) {
at_token(stream);
return;
}
auto last_newline_pos = lexer_text.find_last_of("\n");
if (last_newline_pos == std::string::npos) {
Omega_h_fail("INDENT token did not contain a newline '\\n' !\n");
}
auto lexer_indent =
lexer_text.substr(last_newline_pos + 1, std::string::npos);
// the at_token call is allowed to do anything to lexer_text
at_token(stream);
lexer_text.clear();
std::size_t minlen = std::min(lexer_indent.length(), indent_text.length());
if (lexer_indent.length() > indent_text.length()) {
if (0 != lexer_indent.compare(0, indent_text.length(), indent_text)) {
indent_mismatch();
}
indent_stack.push_back({line, indent_text.length(), lexer_indent.length()});
indent_text = lexer_indent;
lexer_token = tables->indent_info.indent_token;
at_token(stream);
} else if (lexer_indent.length() < indent_text.length()) {
if (0 != indent_text.compare(0, lexer_indent.length(), lexer_indent)) {
indent_mismatch();
}
while (!indent_stack.empty()) {
auto top = indent_stack.back();
if (top.end_length <= minlen) break;
indent_stack.pop_back();
lexer_token = tables->indent_info.dedent_token;
at_token(stream);
}
indent_text = lexer_indent;
} else {
if (0 != lexer_indent.compare(indent_text)) {
indent_mismatch();
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
testb $0x1, 0x141(%rax)
je 0x501624
movq -0x98(%rbp), %rdi
movl 0x90(%rdi), %eax
movl %eax, -0x9c(%rbp)
addq $0x8, %rdi
callq 0x1d9310
movq %rax, %rcx
movl -0x9c(%rbp), %eax
cmpl 0x9c(%rcx), %eax
je 0x501639
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d7f60
jmp 0x5019d2
movq -0x98(%rbp), %rdi
addq $0x50, %rdi
leaq 0x12fd33(%rip), %rsi # 0x63137e
movq $-0x1, %rdx
callq 0x1ccb10
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x501670
leaq 0x133ff6(%rip), %rdi # 0x63565f
movb $0x0, %al
callq 0x1ce550
movq -0x98(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
incq %rdx
leaq -0x38(%rbp), %rdi
movq $-0x1, %rcx
callq 0x1ce800
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d7f60
jmp 0x5016a4
movq -0x98(%rbp), %rdi
addq $0x50, %rdi
callq 0x1d4790
leaq -0x38(%rbp), %rdi
callq 0x1d91b0
movq -0x98(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x148, %rdi # imm = 0x148
callq 0x1d91b0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7650
movq %rax, -0xa8(%rbp)
jmp 0x5016ee
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d91b0
movq -0x98(%rbp), %rdi
movq %rax, -0xb0(%rbp)
addq $0x148, %rdi # imm = 0x148
callq 0x1d91b0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jbe 0x501839
movq -0x98(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
movq %rdi, -0xc0(%rbp)
callq 0x1d91b0
movq -0xc0(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x1d4540
movl %eax, -0xb4(%rbp)
jmp 0x50176b
movl -0xb4(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x50179f
movq -0x98(%rbp), %rdi
callq 0x1e2e50
jmp 0x501785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
jmp 0x5019db
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x168, %rax # imm = 0x168
movq %rax, -0xc8(%rbp)
movq 0x38(%rdi), %rax
movq %rax, -0x78(%rbp)
addq $0x148, %rdi # imm = 0x148
callq 0x1d91b0
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d91b0
movq -0xc8(%rbp), %rdi
movq %rax, -0x68(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x1da840
jmp 0x5017ed
movq -0x98(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
leaq -0x38(%rbp), %rsi
callq 0x1b8780
jmp 0x501806
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d9310
movq -0x98(%rbp), %rdi
movl 0x94(%rax), %eax
movl %eax, 0x90(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1d7f60
jmp 0x501834
jmp 0x5019c9
leaq -0x38(%rbp), %rdi
callq 0x1d91b0
movq -0x98(%rbp), %rdi
movq %rax, -0xd0(%rbp)
addq $0x148, %rdi # imm = 0x148
callq 0x1d91b0
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x50198c
movq -0x98(%rbp), %rax
addq $0x148, %rax # imm = 0x148
movq %rax, -0xe8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1d91b0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4540
movl %eax, -0xd4(%rbp)
jmp 0x5018b5
movl -0xd4(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x5018cf
movq -0x98(%rbp), %rdi
callq 0x1e2e50
jmp 0x5018cf
jmp 0x5018d1
movq -0x98(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x1cfba0
xorb $-0x1, %al
testb $0x1, %al
jne 0x5018ef
jmp 0x501971
movq -0x98(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x1da6a0
movq (%rax), %rcx
movq %rcx, -0x90(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x50(%rbp), %rax
ja 0x50192b
jmp 0x501971
movq -0x98(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x1c48d0
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d9310
movq -0x98(%rbp), %rdi
movl 0x98(%rax), %eax
movl %eax, 0x90(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1d7f60
jmp 0x50196c
jmp 0x5018d1
movq -0x98(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
leaq -0x38(%rbp), %rsi
callq 0x1b8780
jmp 0x50198a
jmp 0x5019c7
movq -0x98(%rbp), %rsi
addq $0x148, %rsi # imm = 0x148
leaq -0x38(%rbp), %rdi
callq 0x1b8460
movl %eax, -0xec(%rbp)
jmp 0x5019ab
movl -0xec(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x5019c5
movq -0x98(%rbp), %rdi
callq 0x1e2e50
jmp 0x5019c5
jmp 0x5019c7
jmp 0x5019c9
leaq -0x38(%rbp), %rdi
callq 0x1c4d10
addq $0xf0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,802 | Omega_h::Reader::backtrack_to_last_accept(std::istream&) | void Reader::backtrack_to_last_accept(std::istream& stream) {
/* all the last_accept and backtracking is driven by
the "accept the longest match" rule */
line = last_lexer_accept_line;
column = last_lexer_accept_column;
line_text = last_lexer_accept_line_text;
while (lexer_text.size() > last_lexer_accept) {
bool ok = !stream.unget().fail();
OMEGA_H_CHECK(ok);
lexer_text.pop_back();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0xa0(%rdi), %rax
movq %rax, 0x38(%rdi)
movq 0xa8(%rdi), %rax
movq %rax, 0x40(%rdi)
movq %rdi, %rsi
addq $0xb0, %rsi
addq $0x70, %rdi
callq 0x1b8780
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x1c6990
movq -0x20(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jbe 0x501aa2
movq -0x10(%rbp), %rdi
callq 0x1bd870
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1b81a0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x501a72
jmp 0x501a93
leaq 0x1295ef(%rip), %rdi # 0x62b068
leaq 0x133c0e(%rip), %rsi # 0x63568e
leaq 0x133ace(%rip), %rdx # 0x635555
movl $0xb9, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x1d2c20
jmp 0x501a31
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,803 | Omega_h::Reader::reset_lexer_state() | void Reader::reset_lexer_state() {
lexer_state = 0;
lexer_text.clear();
lexer_token = -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, 0x48(%rdi)
addq $0x50, %rdi
callq 0x1d4790
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x90(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,804 | Omega_h::Reader::at_lexer_end(std::istream&) | void Reader::at_lexer_end(std::istream& stream) {
if (lexer_token == -1) {
std::stringstream ss;
if (lexer_text.find('\n') == std::string::npos) {
ss << "error: Could not tokenize this (line " << line;
ss << " column " << column << " of " << stream_name << "):\n";
ss << line_text << '\n';
OMEGA_H_CHECK(line_text.size() >= lexer_text.size());
print_underline(ss, line_text, line_text.size() - lexer_text.size(),
line_text.size());
} else {
ss << "error: Could not tokenize this (ends at line " << line;
ss << " column " << column << " of " << stream_name << "):\n";
ss << lexer_text << '\n';
}
throw ParserFail(ss.str());
}
backtrack_to_last_accept(stream);
at_token_indent(stream);
reset_lexer_state();
} | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
cmpl $-0x1, 0x90(%rax)
jne 0x501eef
leaq -0x198(%rbp), %rdi
callq 0x1c6c20
movq -0x1d8(%rbp), %rdi
addq $0x50, %rdi
movl $0xa, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1d4780
cmpq $-0x1, %rax
jne 0x501d34
leaq -0x188(%rbp), %rdi
leaq 0x133b39(%rip), %rsi # 0x635691
callq 0x1cd8f0
movq %rax, -0x1e0(%rbp)
jmp 0x501b66
movq -0x1e0(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x1bbaf0
jmp 0x501b7f
leaq -0x188(%rbp), %rdi
leaq 0x13393b(%rip), %rsi # 0x6354c8
callq 0x1cd8f0
movq %rax, -0x1e8(%rbp)
jmp 0x501b9b
movq -0x1e8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x1f0(%rbp)
jmp 0x501bbb
movq -0x1f0(%rbp), %rdi
leaq 0x133b9f(%rip), %rsi # 0x635768
callq 0x1cd8f0
movq %rax, -0x1f8(%rbp)
jmp 0x501bd7
movq -0x1f8(%rbp), %rdi
movq -0x1d8(%rbp), %rsi
addq $0x120, %rsi # imm = 0x120
callq 0x1cb420
movq %rax, -0x200(%rbp)
jmp 0x501bfa
movq -0x200(%rbp), %rdi
leaq 0x133768(%rip), %rsi # 0x635370
callq 0x1cd8f0
jmp 0x501c0f
movq -0x1d8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
addq $0x70, %rsi
callq 0x1cb420
movq %rax, -0x208(%rbp)
jmp 0x501c2f
movq -0x208(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x501c42
movq -0x1d8(%rbp), %rdi
addq $0x70, %rdi
callq 0x1c6990
movq -0x1d8(%rbp), %rdi
movq %rax, -0x210(%rbp)
addq $0x50, %rdi
callq 0x1c6990
movq %rax, %rcx
movq -0x210(%rbp), %rax
cmpq %rcx, %rax
jb 0x501c7a
jmp 0x501cb4
leaq 0x1293e7(%rip), %rdi # 0x62b068
leaq 0x133a2f(%rip), %rsi # 0x6356b7
leaq 0x1338c6(%rip), %rdx # 0x635555
xorl %eax, %eax
movl $0xcb, %ecx
callq 0x1ce550
jmp 0x501c9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x501ee1
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rax
movq %rax, -0x228(%rbp)
addq $0x70, %rdi
movq %rdi, -0x220(%rbp)
callq 0x1c6990
movq -0x1d8(%rbp), %rdi
movq %rax, -0x230(%rbp)
addq $0x50, %rdi
callq 0x1c6990
movq -0x220(%rbp), %rdi
movq %rax, %rcx
movq -0x230(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x218(%rbp)
callq 0x1c6990
movq -0x228(%rbp), %rdi
movq -0x220(%rbp), %rsi
movq -0x218(%rbp), %rdx
movq %rax, %rcx
callq 0x501f30
jmp 0x501d2f
jmp 0x501e2e
leaq -0x188(%rbp), %rdi
leaq 0x13399b(%rip), %rsi # 0x6356dd
callq 0x1cd8f0
movq %rax, -0x238(%rbp)
jmp 0x501d50
movq -0x238(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x1bbaf0
jmp 0x501d69
leaq -0x188(%rbp), %rdi
leaq 0x133751(%rip), %rsi # 0x6354c8
callq 0x1cd8f0
movq %rax, -0x240(%rbp)
jmp 0x501d85
movq -0x240(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x248(%rbp)
jmp 0x501da5
movq -0x248(%rbp), %rdi
leaq 0x1339b5(%rip), %rsi # 0x635768
callq 0x1cd8f0
movq %rax, -0x250(%rbp)
jmp 0x501dc1
movq -0x250(%rbp), %rdi
movq -0x1d8(%rbp), %rsi
addq $0x120, %rsi # imm = 0x120
callq 0x1cb420
movq %rax, -0x258(%rbp)
jmp 0x501de4
movq -0x258(%rbp), %rdi
leaq 0x13357e(%rip), %rsi # 0x635370
callq 0x1cd8f0
jmp 0x501df9
movq -0x1d8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
addq $0x50, %rsi
callq 0x1cb420
movq %rax, -0x260(%rbp)
jmp 0x501e19
movq -0x260(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x501e2c
jmp 0x501e2e
movb $0x1, -0x1c9(%rbp)
movl $0x10, %edi
callq 0x1c1200
movq %rax, -0x268(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1cd640
jmp 0x501e5b
movq -0x268(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x1d4c10
jmp 0x501e70
movq -0x268(%rbp), %rdi
movb $0x0, -0x1c9(%rbp)
movq 0x1f5b8b(%rip), %rsi # 0x6f7a10
movq 0x1f605c(%rip), %rdx # 0x6f7ee8
callq 0x1de5c0
jmp 0x501f30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x501ec8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x1c4d10
testb $0x1, -0x1c9(%rbp)
jne 0x501ed3
jmp 0x501edf
movq -0x268(%rbp), %rdi
callq 0x1c6df0
jmp 0x501ee1
leaq -0x198(%rbp), %rdi
callq 0x1c76d0
jmp 0x501f24
movq -0x1d8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c6420
movq -0x1d8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c3620
movq -0x1d8(%rbp), %rdi
callq 0x1c9a80
addq $0x270, %rsp # imm = 0x270
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x1dfa40
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,805 | Omega_h::(anonymous namespace)::print_underline(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | void print_underline(std::ostream& os, std::string const& above,
std::size_t start, std::size_t end) {
for (std::size_t i = 0; i < start; ++i) {
if (above.at(i) == '\t')
os << '\t';
else
os << ' ';
}
for (auto i = start; i < end; ++i) os << '~';
os << '\n';
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x501f9d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1d2480
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x501f7f
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x1d19c0
jmp 0x501f8d
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x1d19c0
jmp 0x501f8f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x501f50
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x501fcb
movq -0x8(%rbp), %rdi
movl $0x7e, %esi
callq 0x1d19c0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x501fa5
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
addq $0x30, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,806 | Omega_h::Reader::Reader(std::shared_ptr<Omega_h::ReaderTables const>) | Reader::Reader(ReaderTablesPtr tables_in)
: tables(tables_in),
parser(tables->parser),
lexer(tables->lexer),
grammar(get_grammar(parser)) {
OMEGA_H_CHECK(get_determinism(lexer));
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x1f5e96(%rip), %rax # 0x6f7e98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1d1cb0
movq -0x40(%rbp), %rdi
callq 0x1d9310
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0x1d9310
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq $0x50, %rcx
movq %rcx, 0x20(%rax)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0x1d0a50
movq %rax, -0x28(%rbp)
jmp 0x50205c
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x1d6400
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x98(%rbp)
callq 0x1d67d0
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x90(%rbp)
callq 0x1d67d0
movq -0x38(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x88(%rbp)
callq 0x1d67d0
movq -0x38(%rbp), %rdi
addq $0xd8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x1d91a0
movq -0x38(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x78(%rbp)
callq 0x1e34d0
movq -0x38(%rbp), %rdi
addq $0x108, %rdi # imm = 0x108
movq %rdi, -0x70(%rbp)
callq 0x1e34d0
movq -0x38(%rbp), %rdi
addq $0x120, %rdi # imm = 0x120
movq %rdi, -0x68(%rbp)
callq 0x1d67d0
movq -0x38(%rbp), %rdi
addq $0x148, %rdi # imm = 0x148
movq %rdi, -0x60(%rbp)
callq 0x1d67d0
movq -0x38(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
movq %rdi, -0x58(%rbp)
callq 0x1c6a00
movq -0x38(%rbp), %rdi
addq $0x180, %rdi # imm = 0x180
movq %rdi, -0x50(%rbp)
callq 0x1e2480
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1d2d60
movb %al, -0x41(%rbp)
jmp 0x502146
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x50214f
jmp 0x502154
jmp 0x502202
leaq 0x128f0d(%rip), %rdi # 0x62b068
leaq 0x1335a9(%rip), %rsi # 0x63570b
leaq 0x1333ec(%rip), %rdx # 0x635555
xorl %eax, %eax
movl $0xdf, %ecx
callq 0x1ce550
jmp 0x502177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x50220b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1bd590
movq -0x58(%rbp), %rdi
callq 0x1cf420
movq -0x60(%rbp), %rdi
callq 0x1c4d10
movq -0x68(%rbp), %rdi
callq 0x1c4d10
movq -0x70(%rbp), %rdi
callq 0x1d6620
movq -0x78(%rbp), %rdi
callq 0x1d6620
movq -0x80(%rbp), %rdi
callq 0x1c8350
movq -0x88(%rbp), %rdi
callq 0x1c4d10
movq -0x90(%rbp), %rdi
callq 0x1c4d10
movq -0x98(%rbp), %rdi
callq 0x1c4d10
movq -0x30(%rbp), %rdi
callq 0x1e3dc0
jmp 0x50220b
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1e4eb0
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,807 | Omega_h::Reader::update_position(char) | void Reader::update_position(char c) {
if (c == '\n') {
++line;
column = 1;
line_text.clear();
} else {
++column;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x502266
movq -0x18(%rbp), %rdi
movq 0x38(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x38(%rdi)
movq $0x1, 0x40(%rdi)
addq $0x70, %rdi
callq 0x1d4790
jmp 0x502276
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,808 | Omega_h::(anonymous namespace)::print_indicator(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | void print_indicator(
std::ostream& os, std::string const& above, std::size_t pos) {
for (std::size_t i = 0; i < pos; ++i) {
if (above.at(i) == '\t')
os << '\t';
else
os << ' ';
}
os << "^\n";
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5022e9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d2480
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x5022cb
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x1d19c0
jmp 0x5022d9
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x1d19c0
jmp 0x5022db
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x50229c
movq -0x8(%rbp), %rdi
leaq 0x133530(%rip), %rsi # 0x635824
callq 0x1cd8f0
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,809 | Omega_h::Reader::read_stream(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | any Reader::read_stream(
std::istream& stream, std::string const& stream_name_in) {
line = 1;
column = 1;
lexer_state = 0;
lexer_text.clear();
line_text.clear();
lexer_token = -1;
parser_state = 0;
parser_stack.clear();
parser_stack.push_back(parser_state);
value_stack.clear();
did_accept = false;
stream_name = stream_name_in;
if (tables->indent_info.is_sensitive) {
sensing_indent = true;
indent_text.clear();
indent_stack.clear();
} else {
sensing_indent = false;
}
char c;
while (stream.get(c)) {
if (!is_symbol(c)) {
std::stringstream ss;
ss << "error: Unexpected character code " << int(c);
ss << " at line " << line << " column " << column;
ss << " of " << stream_name << '\n';
error_print_line(stream, ss);
throw ParserFail(ss.str());
}
line_text.push_back(c);
lexer_text.push_back(c);
auto lexer_symbol = get_symbol(c);
lexer_state = step(lexer, lexer_state, lexer_symbol);
if (lexer_state == -1) {
at_lexer_end(stream);
} else {
auto token = accepts(lexer, lexer_state);
update_position(c);
if (token != -1) {
lexer_token = token;
last_lexer_accept = lexer_text.size();
last_lexer_accept_line = line;
last_lexer_accept_column = column;
last_lexer_accept_line_text = line_text;
}
}
}
if (last_lexer_accept < lexer_text.size()) {
std::stringstream ss;
std::string bad_str =
lexer_text.substr(last_lexer_accept, std::string::npos);
ss << "error: Could not tokenize \"" << bad_str;
ss << "\" at end of " << stream_name << '\n';
throw ParserFail(ss.str());
}
at_lexer_end(stream);
lexer_token = get_end_terminal(*grammar);
at_token(stream);
if (!did_accept) {
Omega_h_fail(
"The EOF terminal was accepted but the root nonterminal was not "
"reduced\n"
"This indicates a bug in Omega_h::Reader\n");
}
OMEGA_H_CHECK(value_stack.size() == 1);
return std::move(value_stack.back());
} | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x3d8(%rbp)
movq %rdi, %rax
movq %rax, -0x3d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x3c8(%rbp)
movq $0x1, 0x38(%rdi)
movq $0x1, 0x40(%rdi)
movl $0x0, 0x48(%rdi)
addq $0x50, %rdi
callq 0x1d4790
movq -0x3c8(%rbp), %rdi
addq $0x70, %rdi
callq 0x1d4790
movq -0x3c8(%rbp), %rdi
movl $0xffffffff, 0x90(%rdi) # imm = 0xFFFFFFFF
movl $0x0, 0xd0(%rdi)
addq $0xd8, %rdi
callq 0x1da340
movq -0x3c8(%rbp), %rsi
movq %rsi, %rdi
addq $0xd8, %rdi
addq $0xd0, %rsi
callq 0x1ba3d0
movq -0x3c8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1c75b0
movq -0x3c8(%rbp), %rdi
movb $0x0, 0x140(%rdi)
movq -0x20(%rbp), %rsi
addq $0x120, %rdi # imm = 0x120
callq 0x1b8780
movq -0x3c8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d9310
testb $0x1, 0x90(%rax)
je 0x502424
movq -0x3c8(%rbp), %rdi
movb $0x1, 0x141(%rdi)
addq $0x148, %rdi # imm = 0x148
callq 0x1d4790
movq -0x3c8(%rbp), %rdi
addq $0x168, %rdi # imm = 0x168
callq 0x1deb70
jmp 0x502432
movq -0x3c8(%rbp), %rax
movb $0x0, 0x141(%rax)
jmp 0x502434
movq -0x18(%rbp), %rdi
leaq -0x21(%rbp), %rsi
callq 0x1d6760
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1d38d0
testb $0x1, %al
jne 0x502459
jmp 0x50275d
movsbl -0x21(%rbp), %edi
callq 0x1c8910
testb $0x1, %al
jne 0x502658
leaq -0x1b0(%rbp), %rdi
callq 0x1c6c20
leaq -0x1a0(%rbp), %rdi
leaq 0x13329e(%rip), %rsi # 0x635722
callq 0x1cd8f0
movq %rax, -0x3e0(%rbp)
jmp 0x502492
movq -0x3e0(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x1deb20
jmp 0x5024a4
leaq -0x1a0(%rbp), %rdi
leaq 0x13300c(%rip), %rsi # 0x6354be
callq 0x1cd8f0
movq %rax, -0x3e8(%rbp)
jmp 0x5024c0
movq -0x3e8(%rbp), %rdi
movq -0x3c8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x3f0(%rbp)
jmp 0x5024e0
movq -0x3f0(%rbp), %rdi
leaq 0x132fda(%rip), %rsi # 0x6354c8
callq 0x1cd8f0
movq %rax, -0x3f8(%rbp)
jmp 0x5024fc
movq -0x3f8(%rbp), %rdi
movq -0x3c8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x1bbaf0
jmp 0x502515
leaq -0x1a0(%rbp), %rdi
leaq 0x133245(%rip), %rsi # 0x635768
callq 0x1cd8f0
movq %rax, -0x400(%rbp)
jmp 0x502531
movq -0x400(%rbp), %rdi
movq -0x3c8(%rbp), %rsi
addq $0x120, %rsi # imm = 0x120
callq 0x1cb420
movq %rax, -0x408(%rbp)
jmp 0x502554
movq -0x408(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x502567
movq -0x3c8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1a0(%rbp), %rdx
callq 0x1dcb40
jmp 0x502580
movb $0x1, -0x1e1(%rbp)
movl $0x10, %edi
callq 0x1c1200
movq %rax, -0x410(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x1cd640
jmp 0x5025ad
movq -0x410(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x1d4c10
jmp 0x5025c2
movq -0x410(%rbp), %rdi
movb $0x0, -0x1e1(%rbp)
movq 0x1f5439(%rip), %rsi # 0x6f7a10
movq 0x1f590a(%rip), %rdx # 0x6f7ee8
callq 0x1de5c0
jmp 0x502a15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x502647
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x50262e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x1c4d10
testb $0x1, -0x1e1(%rbp)
jne 0x502639
jmp 0x502645
movq -0x410(%rbp), %rdi
callq 0x1c6df0
jmp 0x502647
leaq -0x1b0(%rbp), %rdi
callq 0x1c76d0
jmp 0x502a09
movq -0x3c8(%rbp), %rdi
addq $0x70, %rdi
movsbl -0x21(%rbp), %esi
callq 0x1ca540
movq -0x3c8(%rbp), %rdi
addq $0x50, %rdi
movsbl -0x21(%rbp), %esi
callq 0x1ca540
movsbl -0x21(%rbp), %edi
callq 0x1c3150
movl %eax, %ecx
movq -0x3c8(%rbp), %rax
movl %ecx, -0x1e8(%rbp)
movq 0x20(%rax), %rdi
movl 0x48(%rax), %esi
movl -0x1e8(%rbp), %edx
callq 0x1d6260
movl %eax, %ecx
movq -0x3c8(%rbp), %rax
movl %ecx, 0x48(%rax)
cmpl $-0x1, 0x48(%rax)
jne 0x5026d1
movq -0x3c8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d79b0
jmp 0x502758
movq -0x3c8(%rbp), %rax
movq 0x20(%rax), %rdi
movl 0x48(%rax), %esi
callq 0x1c7120
movq -0x3c8(%rbp), %rdi
movl %eax, -0x1ec(%rbp)
movsbl -0x21(%rbp), %esi
callq 0x1cdf80
cmpl $-0x1, -0x1ec(%rbp)
je 0x502756
movq -0x3c8(%rbp), %rdi
movl -0x1ec(%rbp), %eax
movl %eax, 0x90(%rdi)
addq $0x50, %rdi
callq 0x1c6990
movq -0x3c8(%rbp), %rdi
movq %rax, 0x98(%rdi)
movq 0x38(%rdi), %rax
movq %rax, 0xa0(%rdi)
movq 0x40(%rdi), %rax
movq %rax, 0xa8(%rdi)
movq %rdi, %rsi
addq $0x70, %rsi
addq $0xb0, %rdi
callq 0x1b8780
jmp 0x502758
jmp 0x502434
movq -0x3c8(%rbp), %rdi
movq 0x98(%rdi), %rax
movq %rax, -0x418(%rbp)
addq $0x50, %rdi
callq 0x1c6990
movq %rax, %rcx
movq -0x418(%rbp), %rax
cmpq %rcx, %rax
jae 0x50293f
leaq -0x378(%rbp), %rdi
callq 0x1c6c20
movq -0x3c8(%rbp), %rax
movq %rax, %rsi
addq $0x50, %rsi
movq 0x98(%rax), %rdx
leaq -0x398(%rbp), %rdi
movq $-0x1, %rcx
callq 0x1ce800
jmp 0x5027c4
leaq -0x368(%rbp), %rdi
leaq 0x132f72(%rip), %rsi # 0x635744
callq 0x1cd8f0
movq %rax, -0x420(%rbp)
jmp 0x5027e0
movq -0x420(%rbp), %rdi
leaq -0x398(%rbp), %rsi
callq 0x1cb420
jmp 0x5027f5
leaq -0x368(%rbp), %rdi
leaq 0x132f5d(%rip), %rsi # 0x635760
callq 0x1cd8f0
movq %rax, -0x428(%rbp)
jmp 0x502811
movq -0x428(%rbp), %rdi
movq -0x3c8(%rbp), %rsi
addq $0x120, %rsi # imm = 0x120
callq 0x1cb420
movq %rax, -0x430(%rbp)
jmp 0x502834
movq -0x430(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x502847
movb $0x1, -0x3b9(%rbp)
movl $0x10, %edi
callq 0x1c1200
movq %rax, -0x438(%rbp)
leaq -0x3b8(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x1cd640
jmp 0x502874
movq -0x438(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x1d4c10
jmp 0x502889
movq -0x438(%rbp), %rdi
movb $0x0, -0x3b9(%rbp)
movq 0x1f5172(%rip), %rsi # 0x6f7a10
movq 0x1f5643(%rip), %rdx # 0x6f7ee8
callq 0x1de5c0
jmp 0x502a15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x50292e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x502922
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x502909
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x3b8(%rbp), %rdi
callq 0x1c4d10
testb $0x1, -0x3b9(%rbp)
jne 0x502914
jmp 0x502920
movq -0x438(%rbp), %rdi
callq 0x1c6df0
jmp 0x502922
leaq -0x398(%rbp), %rdi
callq 0x1c4d10
leaq -0x378(%rbp), %rdi
callq 0x1c76d0
jmp 0x502a09
movq -0x3c8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d79b0
movq -0x3c8(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d2950
movq %rax, %rdi
callq 0x1d1870
movq -0x3c8(%rbp), %rdi
movl %eax, 0x90(%rdi)
movq -0x18(%rbp), %rsi
callq 0x1d7f60
movq -0x3c8(%rbp), %rax
testb $0x1, 0x140(%rax)
jne 0x50299b
leaq 0x132dd9(%rip), %rdi # 0x63576d
movb $0x0, %al
callq 0x1ce550
movq -0x3c8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1dd800
cmpq $0x1, %rax
jne 0x5029b6
jmp 0x5029d7
leaq 0x1286ab(%rip), %rdi # 0x62b068
leaq 0x132e19(%rip), %rsi # 0x6357dd
leaq 0x132b8a(%rip), %rdx # 0x635555
movl $0x13a, %ecx # imm = 0x13A
movb $0x0, %al
callq 0x1ce550
movq -0x3c8(%rbp), %rdi
addq $0xf0, %rdi
callq 0x1de2d0
movq -0x3d8(%rbp), %rdi
movq %rax, %rsi
callq 0x1bc0d0
movq -0x3d0(%rbp), %rax
addq $0x440, %rsp # imm = 0x440
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,810 | Omega_h::Reader::read_string(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&) | any Reader::read_string(
std::string const& string, std::string const& string_name) {
std::istringstream stream(string);
return read_stream(stream, string_name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
movl $0x8, %edx
callq 0x1ddb40
movq -0x1c8(%rbp), %rdi
movq -0x1c0(%rbp), %rsi
movq -0x1b8(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c0510
jmp 0x502a93
leaq -0x1a0(%rbp), %rdi
callq 0x1c0700
movq -0x1d0(%rbp), %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1c0700
movq -0x1a8(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,811 | Omega_h::Reader::read_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | any Reader::read_file(std::string const& file_name) {
std::ifstream stream(file_name.c_str());
if (!stream.is_open()) {
std::stringstream ss;
ss << "Could not open file " << file_name;
throw ParserFail(ss.str());
}
return read_stream(stream, file_name);
} | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x400(%rbp)
movq %rdi, %rax
movq %rax, -0x3f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3f0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
movl $0x8, %edx
callq 0x1e12d0
movq -0x3e8(%rbp), %rdi
callq 0x1dbaf0
movb %al, -0x3da(%rbp)
jmp 0x502b4b
movb -0x3da(%rbp), %al
testb $0x1, %al
jne 0x502c83
jmp 0x502b5b
leaq -0x3b8(%rbp), %rdi
callq 0x1c6c20
jmp 0x502b69
leaq -0x3a8(%rbp), %rdi
leaq 0x132c7e(%rip), %rsi # 0x6357f5
callq 0x1cd8f0
movq %rax, -0x408(%rbp)
jmp 0x502b85
movq -0x408(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cb420
jmp 0x502b97
movb $0x1, -0x3d9(%rbp)
movl $0x10, %edi
callq 0x1c1200
movq %rax, -0x410(%rbp)
leaq -0x3d8(%rbp), %rdi
leaq -0x3b8(%rbp), %rsi
callq 0x1cd640
jmp 0x502bc4
movq -0x410(%rbp), %rdi
leaq -0x3d8(%rbp), %rsi
callq 0x1d4c10
jmp 0x502bd9
movq -0x410(%rbp), %rdi
movb $0x0, -0x3d9(%rbp)
movq 0x1f4e22(%rip), %rsi # 0x6f7a10
movq 0x1f52f3(%rip), %rdx # 0x6f7ee8
callq 0x1de5c0
jmp 0x502cd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x502cbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x502c75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x502c5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x3d8(%rbp), %rdi
callq 0x1c4d10
testb $0x1, -0x3d9(%rbp)
jne 0x502c67
jmp 0x502c73
movq -0x410(%rbp), %rdi
callq 0x1c6df0
jmp 0x502c75
leaq -0x3b8(%rbp), %rdi
callq 0x1c76d0
jmp 0x502cbf
movq -0x3f0(%rbp), %rsi
movq -0x400(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq -0x220(%rbp), %rdx
callq 0x1c0510
jmp 0x502ca3
leaq -0x220(%rbp), %rdi
callq 0x1bbe70
movq -0x3f8(%rbp), %rax
addq $0x410, %rsp # imm = 0x410
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x1bbe70
movq -0x228(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,812 | Omega_h::Reader::at_shift(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | any Reader::at_shift(int, std::string&) { return any(); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x1c2a30
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,813 | Omega_h::Reader::at_reduce(int, std::vector<Omega_h::any, std::allocator<Omega_h::any>>&) | any Reader::at_reduce(int, std::vector<any>&) { return any(); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x1c2a30
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,814 | Omega_h::DebugReader::DebugReader(std::shared_ptr<Omega_h::ReaderTables const>, std::ostream&) | DebugReader::DebugReader(ReaderTablesPtr tables_in, std::ostream& os_in)
: Reader(tables_in), os(os_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1d1cb0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1c12d0
jmp 0x502d78
leaq -0x28(%rbp), %rdi
callq 0x1e4eb0
movq -0x48(%rbp), %rax
movq 0x1f4be4(%rip), %rcx # 0x6f7970
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x198(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1e4eb0
movq -0x30(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,815 | Omega_h::DebugReader::at_shift(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | any DebugReader::at_shift(int token, std::string& text) {
std::string text_escaped;
for (auto c : text) {
switch (c) {
case '\n':
text_escaped.append("\\n");
break;
case '\t':
text_escaped.append("\\t");
break;
case '\r':
text_escaped.append("\\r");
break;
default:
text_escaped.push_back(c);
}
}
os << "SHIFT (" << at(grammar->symbol_names, token) << ")[" << text_escaped
<< "]\n";
return any(std::move(text_escaped));
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1d67d0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1cab90
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1c3fe0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1daa60
testb $0x1, %al
jne 0x502e41
jmp 0x502ef1
leaq -0x50(%rbp), %rdi
callq 0x1ce7e0
movb (%rax), %al
movb %al, -0x59(%rbp)
movsbl -0x59(%rbp), %eax
movl %eax, -0x8c(%rbp)
subl $0x9, %eax
je 0x502ea8
jmp 0x502e60
movl -0x8c(%rbp), %eax
subl $0xa, %eax
je 0x502e7a
jmp 0x502e6d
movl -0x8c(%rbp), %eax
subl $0xd, %eax
je 0x502ebc
jmp 0x502ed0
leaq 0x132989(%rip), %rsi # 0x63580a
leaq -0x40(%rbp), %rdi
callq 0x1e3300
jmp 0x502e8c
jmp 0x502ee1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
jmp 0x502fc4
leaq 0x13295e(%rip), %rsi # 0x63580d
leaq -0x40(%rbp), %rdi
callq 0x1e3300
jmp 0x502eba
jmp 0x502ee1
leaq 0x13294d(%rip), %rsi # 0x635810
leaq -0x40(%rbp), %rdi
callq 0x1e3300
jmp 0x502ece
jmp 0x502ee1
movsbl -0x59(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x1ca540
jmp 0x502edf
jmp 0x502ee1
jmp 0x502ee3
leaq -0x50(%rbp), %rdi
callq 0x1cd7b0
jmp 0x502e2b
movq -0x78(%rbp), %rax
movq 0x198(%rax), %rdi
leaq 0x132910(%rip), %rsi # 0x635813
callq 0x1cd8f0
movq %rax, -0x98(%rbp)
jmp 0x502f11
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
callq 0x1c2b20
movq %rax, -0xa0(%rbp)
jmp 0x502f36
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x1cb420
movq %rax, -0xa8(%rbp)
jmp 0x502f52
movq -0xa8(%rbp), %rdi
leaq 0x1328bb(%rip), %rsi # 0x63581b
callq 0x1cd8f0
movq %rax, -0xb0(%rbp)
jmp 0x502f6e
movq -0xb0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1cb420
movq %rax, -0xb8(%rbp)
jmp 0x502f87
movq -0xb8(%rbp), %rdi
leaq 0x12a00f(%rip), %rsi # 0x62cfa4
callq 0x1cd8f0
jmp 0x502f9c
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1dac90
jmp 0x502fae
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,816 | Omega_h::DebugReader::at_reduce(int, std::vector<Omega_h::any, std::allocator<Omega_h::any>>&) | any DebugReader::at_reduce(int prod_i, std::vector<any>& rhs) {
os << "REDUCE";
std::string lhs_text;
auto& prod = at(grammar->productions, prod_i);
for (int i = 0; i < size(prod.rhs); ++i) {
auto& rhs_name = at(grammar->symbol_names, at(prod.rhs, i));
auto rhs_text = move_value<std::string>(at(rhs, i));
os << " (" << rhs_name << ")[" << rhs_text << "]";
lhs_text.append(rhs_text);
}
auto& lhs_name = at(grammar->symbol_names, prod.lhs);
os << " -> (" << lhs_name << ")[" << lhs_text << "]\n";
return any(std::move(lhs_text));
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x198(%rax), %rdi
leaq 0x12a16d(%rip), %rsi # 0x62d181
callq 0x1cd8f0
leaq -0x40(%rbp), %rdi
callq 0x1d67d0
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %esi
callq 0x1cb3f0
movq %rax, -0x90(%rbp)
jmp 0x50304a
movq -0x90(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cf2d0
movl %eax, -0xac(%rbp)
jmp 0x50307a
movl -0xb0(%rbp), %eax
movl -0xac(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5031fc
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d7fc0
addq $0x20, %rax
movq %rax, -0xc0(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl -0x58(%rbp), %esi
callq 0x1c57d0
movq %rax, -0xb8(%rbp)
jmp 0x5030c2
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movl (%rax), %esi
callq 0x1c2b20
movq %rax, -0xc8(%rbp)
jmp 0x5030e0
movq -0xc8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
movl -0x58(%rbp), %esi
callq 0x1b8f70
movq %rax, -0xd0(%rbp)
jmp 0x503100
movq -0xd0(%rbp), %rdi
callq 0x1ddf20
movq %rax, -0xd8(%rbp)
jmp 0x503115
movq -0xd8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1c4130
movq -0x98(%rbp), %rax
movq 0x198(%rax), %rdi
leaq 0x131c0a(%rip), %rsi # 0x634d44
callq 0x1cd8f0
movq %rax, -0xe0(%rbp)
jmp 0x503148
movq -0xe0(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1cb420
movq %rax, -0xe8(%rbp)
jmp 0x503161
movq -0xe8(%rbp), %rdi
leaq 0x1326ac(%rip), %rsi # 0x63581b
callq 0x1cd8f0
movq %rax, -0xf0(%rbp)
jmp 0x50317d
movq -0xf0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1cb420
movq %rax, -0xf8(%rbp)
jmp 0x503196
movq -0xf8(%rbp), %rdi
leaq 0x13688a(%rip), %rsi # 0x639a2e
callq 0x1cd8f0
jmp 0x5031ab
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1e3e80
jmp 0x5031ba
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x50305c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5032e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
jmp 0x5032e9
movq -0x98(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x20, %rdi
movq -0x48(%rbp), %rax
movl (%rax), %esi
callq 0x1c2b20
movq %rax, -0x100(%rbp)
jmp 0x503227
movq -0x98(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq 0x198(%rax), %rdi
leaq 0x1325d4(%rip), %rsi # 0x63581e
callq 0x1cd8f0
movq %rax, -0x108(%rbp)
jmp 0x503258
movq -0x108(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x1cb420
movq %rax, -0x110(%rbp)
jmp 0x503274
movq -0x110(%rbp), %rdi
leaq 0x132599(%rip), %rsi # 0x63581b
callq 0x1cd8f0
movq %rax, -0x118(%rbp)
jmp 0x503290
movq -0x118(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1cb420
movq %rax, -0x120(%rbp)
jmp 0x5032a9
movq -0x120(%rbp), %rdi
leaq 0x129ced(%rip), %rsi # 0x62cfa4
callq 0x1cd8f0
jmp 0x5032be
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1dac90
jmp 0x5032d0
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
movq -0xa0(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
movq -0x50(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.cpp |
8,817 | std::vector<unsigned long, std::allocator<unsigned long>>::push_back(unsigned long&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cdd70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,818 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::reference Omega_h::at<Omega_h::any>(std::vector<Omega_h::any, std::allocator<Omega_h::any>>&, int) | inline typename std::vector<T>::reference at(std::vector<T>& v, int i) {
OMEGA_H_CHECK(0 <= i);
#if !(defined(__GNUC__) && __GNUC__ < 5)
OMEGA_H_CHECK(i < int(v.size()));
#endif
return v[std::size_t(i)];
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x503348
jmp 0x503369
leaq 0x127d19(%rip), %rdi # 0x62b068
leaq 0x129e67(%rip), %rsi # 0x62d1bd
leaq 0x129e67(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1ddd40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
8,819 | int Omega_h::size<Omega_h::any>(std::vector<Omega_h::any, std::allocator<Omega_h::any>> const&) | inline int size(std::vector<T> const& v) {
return int(v.size());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd800
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
8,820 | void Omega_h::resize<Omega_h::any>(std::vector<Omega_h::any, std::allocator<Omega_h::any>>&, int) | inline void resize(std::vector<T>& v, int n) {
OMEGA_H_CHECK(0 <= n);
v.resize(std::size_t(n));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x5033b8
jmp 0x5033d9
leaq 0x127ca9(%rip), %rdi # 0x62b068
leaq 0x12a2a0(%rip), %rsi # 0x62d666
leaq 0x129df7(%rip), %rdx # 0x62d1c4
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1ba290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
8,821 | void Omega_h::resize<unsigned long>(std::vector<unsigned long, std::allocator<unsigned long>>&, int) | inline void resize(std::vector<T>& v, int n) {
OMEGA_H_CHECK(0 <= n);
v.resize(std::size_t(n));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x503408
jmp 0x503429
leaq 0x127c59(%rip), %rdi # 0x62b068
leaq 0x12a250(%rip), %rsi # 0x62d666
leaq 0x129da7(%rip), %rdx # 0x62d1c4
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1d39d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
8,822 | int Omega_h::size<unsigned long>(std::vector<unsigned long, std::allocator<unsigned long>> const&) | inline int size(std::vector<T> const& v) {
return int(v.size());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d83d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
8,823 | std::vector<unsigned long, std::allocator<unsigned long>>::back() | reference
back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *(end() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e3d80
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1c2420
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1d7bb0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,824 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::empty() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return begin() == end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1c2630
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1c86b0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d3850
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,825 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::back() | reference
back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *(end() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e0750
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1ddc40
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b91d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,826 | std::__shared_ptr_access<Omega_h::ReaderTables const, (__gnu_cxx::_Lock_policy)2, false, false>::operator->() const | element_type*
operator->() const noexcept
{
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e3110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
8,827 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::push_back(Omega_h::Reader::IndentStackEntry&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cb280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,828 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::pop_back() | void
pop_back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
_GLIBCXX_ASAN_ANNOTATE_SHRINK(1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x8(%rdi), %rax
addq $-0x18, %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rdi), %rsi
callq 0x1bb810
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,829 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1de230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,830 | std::vector<int, std::allocator<int>>::clear() | void
clear() _GLIBCXX_NOEXCEPT
{ _M_erase_at_end(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rsi
callq 0x1c0860
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,831 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::clear() | void
clear() _GLIBCXX_NOEXCEPT
{ _M_erase_at_end(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rsi
callq 0x1d94a0
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,832 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::back() | reference
back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *(end() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e4c30
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1de910
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b84f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,833 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&& Omega_h::move_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(Omega_h::any&) | T&& move_value(any& a) {
auto any_ptr = &(a);
auto value_ptr = any_cast<T>(any_ptr);
OMEGA_H_CHECK(value_ptr != nullptr);
return std::move(*value_ptr);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d8180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x50366a
jmp 0x50368b
leaq 0x1279f7(%rip), %rdi # 0x62b068
leaq 0x1321af(%rip), %rsi # 0x635827
leaq 0x1321bd(%rip), %rdx # 0x63583c
movl $0x1c2, %ecx # imm = 0x1C2
movb $0x0, %al
callq 0x1ce550
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
8,834 | Omega_h::Reader::~Reader() | virtual ~Reader() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1da040
movq -0x10(%rbp), %rdi
movl $0x198, %esi # imm = 0x198
callq 0x1ce050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.hpp |
8,835 | Omega_h::DebugReader::~DebugReader() | virtual ~DebugReader() override = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1da040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.hpp |
8,836 | Omega_h::DebugReader::~DebugReader() | virtual ~DebugReader() override = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1e13f0
movq -0x10(%rbp), %rdi
movl $0x1a0, %esi # imm = 0x1A0
callq 0x1ce050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_reader.hpp |
8,837 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf590
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,838 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1d8c40
movq -0x10(%rbp), %rdi
callq 0x1c0040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,839 | std::allocator<Omega_h::Reader::IndentStackEntry>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cd4a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
8,840 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,841 | _gnu_cxx::new_allocator<Omega_h::Reader::IndentStackEntry>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,842 | void std::vector<unsigned long, std::allocator<unsigned long>>::emplace_back<unsigned long>(unsigned long&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x503815
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1ba710
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
jmp 0x503833
movq -0x20(%rbp), %rdi
callq 0x1e3d80
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1c02e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
8,843 | void std::allocator_traits<std::allocator<unsigned long>>::construct<unsigned long, unsigned long>(std::allocator<unsigned long>&, unsigned long*, unsigned long&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1de440
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
8,844 | void std::vector<unsigned long, std::allocator<unsigned long>>::_M_realloc_insert<unsigned long>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, unsigned long&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0x1279dc(%rip), %rdx # 0x62b277
callq 0x1d6210
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1b9350
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c6690
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1bbb80
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1ba710
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1c65e0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1d3680
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1bb430
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1c65e0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1d3680
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x1bb430
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
sarq $0x3, %rdx
callq 0x1c8a00
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
8,845 | void __gnu_cxx::new_allocator<unsigned long>::construct<unsigned long, unsigned long>(unsigned long*, unsigned long&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,846 | std::vector<unsigned long, std::allocator<unsigned long>>::resize(unsigned long) | void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1d83d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x503a64
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1d83d0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
subq %rax, %rsi
callq 0x1cd3a0
jmp 0x503a9a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1d83d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x503a98
movq -0x20(%rbp), %rdi
movq (%rdi), %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b8b50
jmp 0x503a9a
addq $0x30, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,847 | std::vector<unsigned long, std::allocator<unsigned long>>::_M_erase_at_end(unsigned long*) | void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x503d39
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x1d3680
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x1cc520
jmp 0x503d2d
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,848 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d64d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,849 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d64d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,850 | _gnu_cxx::__normal_iterator<Omega_h::Reader::IndentStackEntry const*, std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>>::__normal_iterator(Omega_h::Reader::IndentStackEntry const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
8,851 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1b8a50
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,852 | _gnu_cxx::__normal_iterator<Omega_h::Reader::IndentStackEntry*, std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>>::operator-(long) const | _GLIBCXX20_CONSTEXPR
const _Iterator&
base() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1b8a50
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
8,853 | _gnu_cxx::__normal_iterator<Omega_h::Reader::IndentStackEntry*, std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
8,854 | _gnu_cxx::__normal_iterator<Omega_h::Reader::IndentStackEntry*, std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>>::__normal_iterator(Omega_h::Reader::IndentStackEntry* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
8,855 | std::__shared_ptr_access<Omega_h::ReaderTables const, (__gnu_cxx::_Lock_policy)2, false, false>::_M_get() const | element_type*
_M_get() const noexcept
{ return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e2de0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
8,856 | std::__shared_ptr<Omega_h::ReaderTables const, (__gnu_cxx::_Lock_policy)2>::get() const | element_type*
get() const noexcept
{ return _M_ptr; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
8,857 | void std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::emplace_back<Omega_h::Reader::IndentStackEntry>(Omega_h::Reader::IndentStackEntry&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x503f55
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1b8f20
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
jmp 0x503f73
movq -0x20(%rbp), %rdi
callq 0x1e0750
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1dc2d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
8,858 | void std::allocator_traits<std::allocator<Omega_h::Reader::IndentStackEntry>>::construct<Omega_h::Reader::IndentStackEntry, Omega_h::Reader::IndentStackEntry>(std::allocator<Omega_h::Reader::IndentStackEntry>&, Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1c5390
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
8,859 | void std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_M_realloc_insert<Omega_h::Reader::IndentStackEntry>(__gnu_cxx::__normal_iterator<Omega_h::Reader::IndentStackEntry*, std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>>, Omega_h::Reader::IndentStackEntry&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0x12729c(%rip), %rdx # 0x62b277
callq 0x1e3380
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1d9a50
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1cabf0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1beec0
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
imulq $0x18, -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1b8f20
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1e13c0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1cc4f0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1ca220
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1e13c0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1cc4f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x1ca220
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x1c3c90
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
imulq $0x18, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
8,860 | void __gnu_cxx::new_allocator<Omega_h::Reader::IndentStackEntry>::construct<Omega_h::Reader::IndentStackEntry, Omega_h::Reader::IndentStackEntry>(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,861 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1cd5d0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1c6d10
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x5041a7
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1c6d10
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1c6d10
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1d5870
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1c6d10
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x504216
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1cd5d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x504225
movq -0x38(%rbp), %rdi
callq 0x1cd5d0
movq %rax, -0x58(%rbp)
jmp 0x50422d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,862 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1b8a50
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,863 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5042f2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b99b0
movq %rax, -0x20(%rbp)
jmp 0x5042fa
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x5042fa
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,864 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_S_relocate(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, std::allocator<Omega_h::Reader::IndentStackEntry>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1cef70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,865 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cb450
movq %rax, %rdi
callq 0x1cd4f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,866 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,867 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_S_max_size(std::allocator<Omega_h::Reader::IndentStackEntry> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x555555555555555, %rax # imm = 0x555555555555555
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cd040
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,868 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,869 | std::allocator_traits<std::allocator<Omega_h::Reader::IndentStackEntry>>::max_size(std::allocator<Omega_h::Reader::IndentStackEntry> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bca40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
8,870 | _gnu_cxx::new_allocator<Omega_h::Reader::IndentStackEntry>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d4310
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,871 | std::allocator_traits<std::allocator<Omega_h::Reader::IndentStackEntry>>::allocate(std::allocator<Omega_h::Reader::IndentStackEntry>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1d17f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
8,872 | _gnu_cxx::new_allocator<Omega_h::Reader::IndentStackEntry>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1d4310
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5044eb
movabsq $0xaaaaaaaaaaaaaaa, %rax # imm = 0xAAAAAAAAAAAAAAA
cmpq %rax, -0x10(%rbp)
jbe 0x5044e6
callq 0x1c85c0
callq 0x1be740
imulq $0x18, -0x10(%rbp), %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,873 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_S_do_relocate(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, std::allocator<Omega_h::Reader::IndentStackEntry>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1bfaf0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,874 | Omega_h::Reader::IndentStackEntry* std::__relocate_a<Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, std::allocator<Omega_h::Reader::IndentStackEntry>>(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, std::allocator<Omega_h::Reader::IndentStackEntry>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c6120
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c6120
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c6120
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1c9900
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
8,875 | std::enable_if<std::__is_bitwise_relocatable<Omega_h::Reader::IndentStackEntry>::value, Omega_h::Reader::IndentStackEntry*>::type std::__relocate_a_1<Omega_h::Reader::IndentStackEntry, Omega_h::Reader::IndentStackEntry>(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*, std::allocator<Omega_h::Reader::IndentStackEntry>&) | inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
__relocate_a_1(_Tp* __first, _Tp* __last,
_Tp* __result, allocator<_Up>&) noexcept
{
ptrdiff_t __count = __last - __first;
if (__count > 0)
__builtin_memmove(__result, __first, __count * sizeof(_Tp));
return __result + __count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0x5045ea
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
imulq $0x18, -0x28(%rbp), %rdx
callq 0x1dc5a0
movq -0x18(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
8,876 | void std::allocator_traits<std::allocator<Omega_h::Reader::IndentStackEntry>>::destroy<Omega_h::Reader::IndentStackEntry>(std::allocator<Omega_h::Reader::IndentStackEntry>&, Omega_h::Reader::IndentStackEntry*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d4430
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
8,877 | void __gnu_cxx::new_allocator<Omega_h::Reader::IndentStackEntry>::destroy<Omega_h::Reader::IndentStackEntry>(Omega_h::Reader::IndentStackEntry*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,878 | std::vector<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_M_erase_at_end(Omega_h::Reader::IndentStackEntry*) | void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5046bf
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x1cc4f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x1c3790
jmp 0x5046b3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,879 | _gnu_cxx::__normal_iterator<Omega_h::any*, std::vector<Omega_h::any, std::allocator<Omega_h::any>>>::operator-(long) const | _GLIBCXX20_CONSTEXPR
const _Iterator&
base() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d17c0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
8,880 | Omega_h::diffuse_to_exterior(Omega_h::Mesh*, Omega_h::Read<double>*, int, Omega_h::Read<signed char>*) | void diffuse_to_exterior(
Mesh* mesh, Reals* p_v_data, Int ncomps, Read<I8>* p_visited) {
auto v_data = *p_v_data;
auto visited = *p_visited;
auto new_data = deep_copy(v_data);
auto new_visited = deep_copy(visited);
auto v2v = mesh->ask_star(VERT);
auto v2vv = v2v.a2ab;
auto vv2v = v2v.ab2b;
auto f = OMEGA_H_LAMBDA(LO v) {
if (visited[v]) return;
Int nadj = 0;
for (auto vv = v2vv[v]; vv < v2vv[v + 1]; ++vv) {
auto ov = vv2v[vv];
if (visited[ov]) ++nadj;
}
if (!nadj) return;
for (Int comp = 0; comp < ncomps; ++comp) {
Real sum = 0.0;
for (auto vv = v2vv[v]; vv < v2vv[v + 1]; ++vv) {
auto ov = vv2v[vv];
if (visited[ov]) sum += v_data[ov * ncomps + comp];
}
new_data[v * ncomps + comp] = sum / nadj;
}
new_visited[v] = 1;
};
parallel_for(mesh->nverts(), f, "diffuse_to_exterior");
v_data = new_data;
visited = new_visited;
v_data = mesh->sync_array(VERT, v_data, ncomps);
visited = mesh->sync_array(VERT, visited, 1);
*p_v_data = v_data;
*p_visited = visited;
} | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1cae10
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1bec60
jmp 0x504746
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x504755
leaq -0x91(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x1dfbb0
movq -0x210(%rbp), %rdx
leaq 0x12cc09(%rip), %rsi # 0x63137f
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x504784
leaq -0x60(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x1b9d50
jmp 0x50479a
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bec60
jmp 0x5047cd
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x1dfbb0
movq -0x218(%rbp), %rdx
leaq 0x12cb91(%rip), %rsi # 0x63137f
leaq -0xd8(%rbp), %rdi
callq 0x1d5e00
jmp 0x5047fc
leaq -0xa8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x1ddcc0
jmp 0x504818
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0xd9(%rbp), %rdi
callq 0x1cf450
leaq -0xb8(%rbp), %rdi
callq 0x1e0060
movq -0x8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
xorl %edx, %edx
callq 0x1ce000
jmp 0x504850
leaq -0x110(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1d99b0
jmp 0x504865
leaq -0xf0(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x1d99b0
jmp 0x50487a
leaq -0x188(%rbp), %rdi
movq %rdi, -0x220(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1bec60
jmp 0x504893
leaq -0x178(%rbp), %rdi
movq %rdi, -0x228(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x5048af
leaq -0x168(%rbp), %rdi
movq %rdi, -0x230(%rbp)
leaq -0x120(%rbp), %rsi
callq 0x1d99b0
jmp 0x5048cb
movl -0x14(%rbp), %eax
movl %eax, -0x158(%rbp)
leaq -0x150(%rbp), %rdi
movq %rdi, -0x238(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x5048ed
leaq -0x140(%rbp), %rdi
movq %rdi, -0x240(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x504906
leaq -0x130(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d26b0
jmp 0x50491b
movq -0x8(%rbp), %rdi
callq 0x1d8940
movl %eax, -0x244(%rbp)
jmp 0x50492c
movl -0x244(%rbp), %edi
leaq 0x130f8b(%rip), %rdx # 0x6358c4
leaq -0x188(%rbp), %rsi
callq 0x504e00
jmp 0x504947
leaq -0x1a8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x504959
leaq -0x198(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x1ccda0
jmp 0x50496e
leaq -0x30(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1d68d0
jmp 0x504980
leaq -0x198(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1a8(%rbp), %rdi
callq 0x1dc900
leaq -0x1c8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d26b0
jmp 0x5049ad
leaq -0x1b8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x1d12a0
jmp 0x5049c2
leaq -0x40(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c5d20
jmp 0x5049d4
leaq -0x1b8(%rbp), %rdi
callq 0x1e0060
leaq -0x1c8(%rbp), %rdi
callq 0x1d4740
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x504a09
movq -0x250(%rbp), %rsi
movl -0x14(%rbp), %r8d
leaq -0x1d8(%rbp), %rdi
xorl %edx, %edx
leaq -0x1e8(%rbp), %rcx
callq 0x1dd310
jmp 0x504a2b
leaq -0x30(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x1d68d0
jmp 0x504a3d
leaq -0x1d8(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1e8(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x208(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bec60
jmp 0x504a72
movq -0x258(%rbp), %rsi
leaq -0x1f8(%rbp), %rdi
xorl %edx, %edx
leaq -0x208(%rbp), %rcx
movl $0x1, %r8d
callq 0x1e1840
jmp 0x504a96
leaq -0x40(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x1c5d20
jmp 0x504aa8
leaq -0x1f8(%rbp), %rdi
callq 0x1e0060
leaq -0x208(%rbp), %rdi
callq 0x1e0060
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1e25f0
jmp 0x504acf
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1e0c00
jmp 0x504ade
leaq -0x188(%rbp), %rdi
callq 0x504ed0
leaq -0x120(%rbp), %rdi
callq 0x1c7d90
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0x100(%rbp), %rdi
callq 0x1dd040
leaq -0xa8(%rbp), %rdi
callq 0x1d4740
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1e0060
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504ded
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504de4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504b86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
jmp 0x504de4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504ddb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504bd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0xd9(%rbp), %rdi
callq 0x1cf450
leaq -0xb8(%rbp), %rdi
callq 0x1e0060
jmp 0x504ddb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504dcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504dc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504db7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504dab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504cac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504ca0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504c94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504c88
movq -0x240(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x1dc900
movq -0x238(%rbp), %rdi
callq 0x1e0ab0
movq -0x230(%rbp), %rdi
callq 0x1c7d90
movq -0x228(%rbp), %rdi
callq 0x1c7d90
movq -0x220(%rbp), %rdi
callq 0x1e0060
jmp 0x504dab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504d9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504cf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1a8(%rbp), %rdi
callq 0x1dc900
jmp 0x504d9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504d2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1e0060
leaq -0x1c8(%rbp), %rdi
callq 0x1d4740
jmp 0x504d9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504d5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1e8(%rbp), %rdi
callq 0x1e0ab0
jmp 0x504d9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x504d93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x1e0060
leaq -0x208(%rbp), %rdi
callq 0x1e0060
leaq -0x188(%rbp), %rdi
callq 0x504ed0
leaq -0x120(%rbp), %rdi
callq 0x1c7d90
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0x100(%rbp), %rdi
callq 0x1dd040
leaq -0xa8(%rbp), %rdi
callq 0x1d4740
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1e0060
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0x48(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,881 | void Omega_h::parallel_for<Omega_h::diffuse_to_exterior(Omega_h::Mesh*, Omega_h::Read<double>*, int, Omega_h::Read<signed char>*)::$_0>(int, Omega_h::diffuse_to_exterior(Omega_h::Mesh*, Omega_h::Read<double>*, int, Omega_h::Read<signed char>*)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x506640
movq -0xc0(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0xa8(%rbp)
movl -0xa4(%rbp), %edi
movl -0xa8(%rbp), %esi
callq 0x506780
jmp 0x504e88
leaq -0xa0(%rbp), %rdi
callq 0x504ed0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x504ed0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,882 | Omega_h::has_interior_verts(Omega_h::Mesh*) | bool has_interior_verts(Mesh* mesh) {
auto dim = mesh->dim();
auto class_dim = mesh->get_array<I8>(VERT, "class_dim");
auto interior = each_eq_to(class_dim, I8(dim));
auto have_local_interior = (get_max(interior) == 1);
auto comm = mesh->comm();
return comm->reduce_or(have_local_interior);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ddc00
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1dfbb0
movq -0xa8(%rbp), %rdx
leaq 0x12e952(%rip), %rsi # 0x6338c6
leaq -0x40(%rbp), %rdi
callq 0x1d5e00
jmp 0x504f7f
movq -0xb0(%rbp), %rsi
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
leaq -0x40(%rbp), %rcx
callq 0x1bf430
jmp 0x504f97
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
leaq -0x41(%rbp), %rdi
callq 0x1cf450
leaq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1bec60
jmp 0x504fb8
movsbl -0xc(%rbp), %edx
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1d3160
jmp 0x504fcb
leaq -0x78(%rbp), %rdi
callq 0x1e0060
leaq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1bec60
jmp 0x504fe6
leaq -0x90(%rbp), %rdi
callq 0x1dbaa0
movb %al, -0xb1(%rbp)
jmp 0x504ffa
leaq -0x90(%rbp), %rdi
callq 0x1e0060
movb -0xb1(%rbp), %al
subb $0x1, %al
sete -0x79(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x1be0a0
jmp 0x505024
leaq -0xa0(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
movzbl -0x79(%rbp), %esi
andl $0x1, %esi
callq 0x1c19a0
movb %al, -0xb2(%rbp)
jmp 0x505047
leaq -0xa0(%rbp), %rdi
callq 0x1cb520
leaq -0x68(%rbp), %rdi
callq 0x1e0060
leaq -0x20(%rbp), %rdi
callq 0x1e0060
movb -0xb2(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x505099
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c4d10
leaq -0x41(%rbp), %rdi
callq 0x1cf450
jmp 0x50511b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x505112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e0060
jmp 0x505112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x505109
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1e0060
jmp 0x505109
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1cb520
leaq -0x68(%rbp), %rdi
callq 0x1e0060
leaq -0x20(%rbp), %rdi
callq 0x1e0060
movq -0x50(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,883 | Omega_h::project_by_fit(Omega_h::Mesh*, Omega_h::Read<double>) | Reals project_by_fit(Mesh* mesh, Reals e_data) {
OMEGA_H_CHECK(mesh->owners_have_all_upward(VERT));
OMEGA_H_CHECK(e_data.size() % mesh->nelems() == 0);
OMEGA_H_CHECK(has_interior_verts(mesh));
auto ncomps = e_data.size() / mesh->nelems();
auto dim = mesh->dim();
auto v_coeffs = get_interior_coeffs(mesh, e_data, ncomps);
auto class_dim = mesh->get_array<I8>(VERT, "class_dim");
auto visited = each_eq_to(class_dim, I8(dim));
while (mesh->comm()->reduce_or(get_min(visited) == 0)) {
diffuse_to_exterior(mesh, &v_coeffs, ncomps * (dim + 1), &visited);
}
return evaluate_coeffs(mesh, v_coeffs, ncomps);
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdx, -0x130(%rbp)
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x1b8740
testb $0x1, %al
jne 0x505170
jmp 0x505172
jmp 0x505193
leaq 0x125eef(%rip), %rdi # 0x62b068
leaq 0x12ddb4(%rip), %rsi # 0x632f34
leaq 0x130751(%rip), %rdx # 0x6358d8
movl $0x89, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x130(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5051d9
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5051eb
movq -0x138(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x13c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1e03e0
movl %eax, %ecx
movl -0x13c(%rbp), %eax
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x505214
jmp 0x505235
leaq 0x125e4d(%rip), %rdi # 0x62b068
leaq 0x130718(%rip), %rsi # 0x63593a
leaq 0x1306af(%rip), %rdx # 0x6358d8
movl $0x8a, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x50(%rbp), %rdi
callq 0x1dec80
testb $0x1, %al
jne 0x505244
jmp 0x505246
jmp 0x505267
leaq 0x125e1b(%rip), %rdi # 0x62b068
leaq 0x13070a(%rip), %rsi # 0x63595e
leaq 0x13067d(%rip), %rdx # 0x6358d8
movl $0x8b, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x130(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x148(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5052ad
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5052bf
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x15c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1e03e0
movl %eax, %ecx
movl -0x15c(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x1ddc00
movq -0x130(%rbp), %rsi
movl %eax, -0x60(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x1cae10
movq -0x158(%rbp), %rsi
movq -0x150(%rbp), %rdx
movl -0x5c(%rbp), %ecx
leaq -0x70(%rbp), %rdi
callq 0x505660
jmp 0x50532e
leaq -0x80(%rbp), %rdi
callq 0x1e0ab0
movq -0x50(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x1dfbb0
movq -0x168(%rbp), %rdx
leaq 0x12e563(%rip), %rsi # 0x6338c6
leaq -0xc0(%rbp), %rdi
callq 0x1d5e00
jmp 0x505371
movq -0x170(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
xorl %edx, %edx
leaq -0xc0(%rbp), %rcx
callq 0x1bf430
jmp 0x50538f
leaq -0xc0(%rbp), %rdi
callq 0x1c4d10
leaq -0xc1(%rbp), %rdi
callq 0x1cf450
leaq -0xe8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1bec60
jmp 0x5053bc
movsbl -0x60(%rbp), %edx
leaq -0xd8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1d3160
jmp 0x5053d5
leaq -0xe8(%rbp), %rdi
callq 0x1e0060
movq -0x50(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1be0a0
jmp 0x5053f3
leaq -0xf8(%rbp), %rdi
callq 0x1d9de0
movq %rax, -0x178(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1bec60
jmp 0x50541b
leaq -0x108(%rbp), %rdi
callq 0x1c61e0
movb %al, -0x179(%rbp)
jmp 0x50542f
movq -0x178(%rbp), %rdi
movb -0x179(%rbp), %al
testb %al, %al
sete %al
movzbl %al, %esi
callq 0x1c19a0
movb %al, -0x17a(%rbp)
jmp 0x505451
leaq -0x108(%rbp), %rdi
callq 0x1e0060
leaq -0xf8(%rbp), %rdi
callq 0x1cb520
movb -0x17a(%rbp), %al
testb $0x1, %al
jne 0x505478
jmp 0x505595
movq -0x50(%rbp), %rdi
movl -0x5c(%rbp), %edx
movl -0x60(%rbp), %eax
incl %eax
imull %eax, %edx
leaq -0x70(%rbp), %rsi
leaq -0xd8(%rbp), %rcx
callq 0x1e27d0
jmp 0x505499
jmp 0x5053e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1e0ab0
jmp 0x50564d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x5054f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x1c4d10
leaq -0xc1(%rbp), %rdi
callq 0x1cf450
jmp 0x505644
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x505638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1e0060
jmp 0x505638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x50562c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x505584
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x1e0060
leaq -0xf8(%rbp), %rdi
callq 0x1cb520
jmp 0x50562c
movq -0x50(%rbp), %rax
movq %rax, -0x188(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1cae10
jmp 0x5055b2
movq -0x188(%rbp), %rsi
movq -0x128(%rbp), %rdi
movl -0x5c(%rbp), %ecx
leaq -0x118(%rbp), %rdx
callq 0x505810
jmp 0x5055d1
leaq -0x118(%rbp), %rdi
callq 0x1e0ab0
leaq -0xd8(%rbp), %rdi
callq 0x1e0060
leaq -0xa0(%rbp), %rdi
callq 0x1e0060
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x120(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x1e0ab0
leaq -0xd8(%rbp), %rdi
callq 0x1e0060
leaq -0xa0(%rbp), %rdi
callq 0x1e0060
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,884 | Omega_h::get_interior_coeffs(Omega_h::Mesh*, Omega_h::Read<double>, int) | static Reals get_interior_coeffs(Mesh* mesh, Reals e_data, Int ncomps) {
if (mesh->dim() == 3) {
return get_interior_coeffs_dim<3>(mesh, e_data, ncomps);
} else if (mesh->dim() == 2) {
return get_interior_coeffs_dim<2>(mesh, e_data, ncomps);
} else if (mesh->dim() == 1) {
return get_interior_coeffs_dim<1>(mesh, e_data, ncomps);
}
OMEGA_H_NORETURN(Reals());
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddc00
cmpl $0x3, %eax
jne 0x5056f4
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1cae10
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1c9a00
jmp 0x5056cc
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5057f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
jmp 0x505802
movq -0x10(%rbp), %rdi
callq 0x1ddc00
cmpl $0x2, %eax
jne 0x505765
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1cae10
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1ca0b0
jmp 0x50573d
leaq -0x50(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5057f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1e0ab0
jmp 0x505802
movq -0x10(%rbp), %rdi
callq 0x1ddc00
cmpl $0x1, %eax
jne 0x5057d0
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1cae10
movq -0x70(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1c4310
jmp 0x5057ae
leaq -0x60(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5057f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1e0ab0
jmp 0x505802
jmp 0x5057d2
jmp 0x5057d4
leaq 0x12588d(%rip), %rdi # 0x62b068
leaq 0x125f87(%rip), %rsi # 0x62b769
leaq 0x1300ef(%rip), %rdx # 0x6358d8
movl $0x3d, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x68(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,885 | Omega_h::evaluate_coeffs(Omega_h::Mesh*, Omega_h::Read<double>, int) | static Reals evaluate_coeffs(Mesh* mesh, Reals v_coeffs, Int ncomps) {
if (mesh->dim() == 3) {
return evaluate_coeffs_dim<3>(mesh, v_coeffs, ncomps);
} else if (mesh->dim() == 2) {
return evaluate_coeffs_dim<2>(mesh, v_coeffs, ncomps);
} else if (mesh->dim() == 1) {
return evaluate_coeffs_dim<1>(mesh, v_coeffs, ncomps);
}
OMEGA_H_NORETURN(Reals());
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddc00
cmpl $0x3, %eax
jne 0x5058a4
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1cae10
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1e2ba0
jmp 0x50587c
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5059a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5059b2
movq -0x10(%rbp), %rdi
callq 0x1ddc00
cmpl $0x2, %eax
jne 0x505915
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1cae10
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1e3b30
jmp 0x5058ed
leaq -0x50(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5059a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5059b2
movq -0x10(%rbp), %rdi
callq 0x1ddc00
cmpl $0x1, %eax
jne 0x505980
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1cae10
movq -0x70(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x1d4170
jmp 0x50595e
leaq -0x60(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5059a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5059b2
jmp 0x505982
jmp 0x505984
leaq 0x1256dd(%rip), %rdi # 0x62b068
leaq 0x125dd7(%rip), %rsi # 0x62b769
leaq 0x12ff3f(%rip), %rdx # 0x6358d8
movl $0x7c, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x68(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,886 | Omega_h::project_by_average(Omega_h::Mesh*, Omega_h::Read<double>) | Reals project_by_average(Mesh* mesh, Reals e_data) {
OMEGA_H_CHECK(mesh->owners_have_all_upward(VERT));
OMEGA_H_CHECK(e_data.size() % mesh->nelems() == 0);
auto ncomps = e_data.size() / mesh->nelems();
auto verts2elems = mesh->ask_up(VERT, mesh->dim());
auto weights = Reals(verts2elems.ab2b.size(), 1.0);
auto avgs = graph_weighted_average(verts2elems, weights, e_data, ncomps);
return mesh->sync_array(VERT, avgs, ncomps);
} | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdx, -0x170(%rbp)
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x1b8740
testb $0x1, %al
jne 0x505a00
jmp 0x505a02
jmp 0x505a23
leaq 0x12565f(%rip), %rdi # 0x62b068
leaq 0x12d524(%rip), %rsi # 0x632f34
leaq 0x12fec1(%rip), %rdx # 0x6358d8
movl $0x98, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x170(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x178(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x505a69
movq -0x178(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x505a7b
movq -0x178(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x17c(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1e03e0
movl %eax, %ecx
movl -0x17c(%rbp), %eax
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x505aa4
jmp 0x505ac5
leaq 0x1255bd(%rip), %rdi # 0x62b068
leaq 0x12fe88(%rip), %rsi # 0x63593a
leaq 0x12fe1f(%rip), %rdx # 0x6358d8
movl $0x99, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x170(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x188(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x505b0b
movq -0x188(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x505b1d
movq -0x188(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x19c(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1e03e0
movl %eax, %ecx
movl -0x19c(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x7c(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1ddc00
movq -0x198(%rbp), %rsi
movl %eax, %ecx
leaq -0xb0(%rbp), %rdi
xorl %edx, %edx
callq 0x1c6130
leaq -0xb0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x505bb7
movq -0x190(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x505bc9
movq -0x190(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x1ac(%rbp)
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0x12b787(%rip), %rsi # 0x63137f
leaq -0xe0(%rbp), %rdi
callq 0x1d5e00
jmp 0x505c06
movl -0x1ac(%rbp), %esi
leaq -0xc0(%rbp), %rdi
movsd 0x1253ed(%rip), %xmm0 # 0x62b008
leaq -0xe0(%rbp), %rdx
callq 0x1d7800
jmp 0x505c29
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0xe1(%rbp), %rdi
callq 0x1cf450
leaq -0x128(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1d21e0
jmp 0x505c56
leaq -0x138(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1cae10
jmp 0x505c6b
movq -0x170(%rbp), %rsi
leaq -0x148(%rbp), %rdi
callq 0x1cae10
jmp 0x505c80
movl -0x7c(%rbp), %r8d
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rsi
leaq -0x138(%rbp), %rdx
leaq -0x148(%rbp), %rcx
callq 0x1da250
jmp 0x505ca7
leaq -0x148(%rbp), %rdi
callq 0x1e0ab0
leaq -0x138(%rbp), %rdi
callq 0x1e0ab0
leaq -0x128(%rbp), %rdi
callq 0x1dd040
movq -0x70(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x158(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1cae10
jmp 0x505ceb
movq -0x1b8(%rbp), %rsi
movq -0x168(%rbp), %rdi
movl -0x7c(%rbp), %r8d
xorl %edx, %edx
leaq -0x158(%rbp), %rcx
callq 0x1dd310
jmp 0x505d0d
leaq -0x158(%rbp), %rdi
callq 0x1e0ab0
leaq -0x108(%rbp), %rdi
callq 0x1e0ab0
leaq -0xc0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb0(%rbp), %rdi
callq 0x1cb510
movq -0x160(%rbp), %rax
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x505d7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0xe1(%rbp), %rdi
callq 0x1cf450
jmp 0x505e51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x505e45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x505df9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x505ded
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1e0ab0
leaq -0x138(%rbp), %rdi
callq 0x1e0ab0
leaq -0x128(%rbp), %rdi
callq 0x1dd040
jmp 0x505e45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x505e39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x1e0ab0
leaq -0x108(%rbp), %rdi
callq 0x1e0ab0
leaq -0xc0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb0(%rbp), %rdi
callq 0x1cb510
movq -0xf0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,887 | Omega_h::derive_element_gradients(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_gradients(Mesh* mesh, Reals vert_values) {
OMEGA_H_CHECK(vert_values.size() == mesh->nverts());
if (mesh->dim() == 3) {
return derive_element_gradients_dim<3>(mesh, vert_values);
} else if (mesh->dim() == 2) {
return derive_element_gradients_dim<2>(mesh, vert_values);
} else if (mesh->dim() == 1) {
return derive_element_gradients_dim<1>(mesh, vert_values);
}
OMEGA_H_NORETURN(Reals());
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x505ed8
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x505ee7
movq -0x80(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x9c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d8940
movl %eax, %ecx
movl -0x9c(%rbp), %eax
cmpl %ecx, %eax
jne 0x505f0c
jmp 0x505f2d
leaq 0x125155(%rip), %rdi # 0x62b068
leaq 0x12fa5d(%rip), %rsi # 0x635977
leaq 0x12f9b7(%rip), %rdx # 0x6358d8
movl $0xda, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x30(%rbp), %rdi
callq 0x1ddc00
cmpl $0x3, %eax
jne 0x505fa1
movq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1cae10
movq -0x90(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x1c4210
jmp 0x505f79
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5060a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5060b8
movq -0x30(%rbp), %rdi
callq 0x1ddc00
cmpl $0x2, %eax
jne 0x506015
movq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1cae10
movq -0x90(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x1da360
jmp 0x505fed
leaq -0x68(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5060a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5060b8
movq -0x30(%rbp), %rdi
callq 0x1ddc00
cmpl $0x1, %eax
jne 0x506083
movq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1cae10
movq -0x90(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x1bcca0
jmp 0x506061
leaq -0x78(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5060a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e0ab0
jmp 0x5060b8
jmp 0x506085
jmp 0x506087
leaq 0x124fda(%rip), %rdi # 0x62b068
leaq 0x1256d4(%rip), %rsi # 0x62b769
leaq 0x12f83c(%rip), %rdx # 0x6358d8
movl $0xe2, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x88(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,888 | Omega_h::derive_element_hessians(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_hessians(Mesh* mesh, Reals vert_gradients) {
OMEGA_H_CHECK(vert_gradients.size() == mesh->nverts() * mesh->dim());
if (mesh->dim() == 3) {
return derive_element_hessians_dim<3>(mesh, vert_gradients);
} else if (mesh->dim() == 2) {
return derive_element_hessians_dim<2>(mesh, vert_gradients);
} else if (mesh->dim() == 1) {
return derive_element_hessians_dim<1>(mesh, vert_gradients);
}
OMEGA_H_NORETURN(Reals());
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x506138
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x506147
movq -0x80(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x9c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d8940
movl %eax, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ddc00
movl -0xa0(%rbp), %ecx
movl %eax, %edx
movl -0x9c(%rbp), %eax
imull %edx, %ecx
cmpl %ecx, %eax
jne 0x506184
jmp 0x5061a5
leaq 0x124edd(%rip), %rdi # 0x62b068
leaq 0x12f80a(%rip), %rsi # 0x63599c
leaq 0x12f73f(%rip), %rdx # 0x6358d8
movl $0xe6, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x30(%rbp), %rdi
callq 0x1ddc00
cmpl $0x3, %eax
jne 0x506219
movq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1cae10
movq -0x90(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x1bff00
jmp 0x5061f1
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506330
movq -0x30(%rbp), %rdi
callq 0x1ddc00
cmpl $0x2, %eax
jne 0x50628d
movq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1cae10
movq -0x90(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x1e1290
jmp 0x506265
leaq -0x68(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506330
movq -0x30(%rbp), %rdi
callq 0x1ddc00
cmpl $0x1, %eax
jne 0x5062fb
movq -0x98(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1cae10
movq -0x90(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x1be0f0
jmp 0x5062d9
leaq -0x78(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506330
jmp 0x5062fd
jmp 0x5062ff
leaq 0x124d62(%rip), %rdi # 0x62b068
leaq 0x12545c(%rip), %rsi # 0x62b769
leaq 0x12f5c4(%rip), %rdx # 0x6358d8
movl $0xee, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x88(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,889 | Omega_h::recover_gradients(Omega_h::Mesh*, Omega_h::Read<double>) | Reals recover_gradients(Mesh* mesh, Reals vert_values) {
auto e_grad = derive_element_gradients(mesh, vert_values);
return project_by_fit(mesh, e_grad);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, %rax
movq -0x80(%rbp), %rsi
movq %rdi, -0x78(%rbp)
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1cae10
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x1d00f0
jmp 0x506395
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x5063b8
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x1d1ba0
jmp 0x5063ce
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506430
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x506427
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,890 | Omega_h::recover_hessians_from_gradients(Omega_h::Mesh*, Omega_h::Read<double>) | Reals recover_hessians_from_gradients(Mesh* mesh, Reals vert_gradients) {
auto e_hess = derive_element_hessians(mesh, vert_gradients);
return project_by_fit(mesh, e_hess);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, %rax
movq -0x80(%rbp), %rsi
movq %rdi, -0x78(%rbp)
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1cae10
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x1dcaf0
jmp 0x506495
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x5064b8
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x1d1ba0
jmp 0x5064ce
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x506527
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,891 | Omega_h::recover_hessians(Omega_h::Mesh*, Omega_h::Read<double>) | Reals recover_hessians(Mesh* mesh, Reals vert_values) {
auto v_grad = recover_gradients(mesh, vert_values);
return recover_hessians_from_gradients(mesh, v_grad);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, %rax
movq -0x80(%rbp), %rsi
movq %rdi, -0x78(%rbp)
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1cae10
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x1cc9a0
jmp 0x506595
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x5065b8
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x1c7340
jmp 0x5065ce
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
jmp 0x506630
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x506627
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,892 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::diffuse_to_exterior(Omega_h::Mesh*, Omega_h::Read<double>*, int, Omega_h::Read<signed char>*)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::diffuse_to_exterior(Omega_h::Mesh*, Omega_h::Read<double>*, int, Omega_h::Read<signed char>*)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x5067b8
jmp 0x506859
movq 0x1f14c9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x506870
movq 0x1f14af(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x50684d
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0xa8(%rbp), %rdi
callq 0x5069b0
jmp 0x506816
jmp 0x506818
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5067dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x504ed0
jmp 0x506862
leaq -0xa8(%rbp), %rdi
callq 0x504ed0
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,893 | Omega_h::Read<double> Omega_h::derive_element_gradients_dim<3>(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_gradients_dim(Mesh* mesh, Reals vert_values) {
auto coords = mesh->coords();
auto ev2v = mesh->ask_elem_verts();
auto out = Write<Real>(mesh->nelems() * dim);
auto f = OMEGA_H_LAMBDA(LO e) {
auto evv2v = gather_verts<dim + 1>(ev2v, e);
auto evv2u = gather_scalars<dim + 1>(vert_values, evv2v);
Vector<dim> du_dxi;
for (Int i = 0; i < dim; ++i) du_dxi[i] = evv2u[i + 1] - evv2u[0];
auto evv2x = gather_vectors<dim + 1, dim>(coords, evv2v);
Matrix<dim, dim> dx_dxi = get_simplex_jacobian<dim>(evv2x);
auto dxi_dx = invert(dx_dxi);
auto du_dx = dxi_dx * du_dxi;
set_vector(out, e, du_dx);
};
parallel_for(mesh->nelems(), f, "derive_element_gradients");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e0da0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c65b0
jmp 0x506f8b
movq -0x10(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0xec(%rbp)
jmp 0x506f9c
movl -0xec(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0xfc(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1dfbb0
movq -0xf8(%rbp), %rdx
leaq 0x12a3b4(%rip), %rsi # 0x63137f
leaq -0x78(%rbp), %rdi
callq 0x1d5e00
jmp 0x506fd6
movl -0xfc(%rbp), %esi
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x1cd090
jmp 0x506feb
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x1d99b0
jmp 0x507016
movq -0xe8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1cae10
jmp 0x507032
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x50704b
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c7e70
jmp 0x50705d
movq -0x10(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0x11c(%rbp)
jmp 0x50706e
movl -0x11c(%rbp), %edi
leaq 0x12ea05(%rip), %rdx # 0x635a80
leaq -0xc0(%rbp), %rsi
callq 0x1d9590
jmp 0x507089
leaq -0xd0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d8720
jmp 0x50709b
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1ccda0
jmp 0x5070b0
leaq -0xd0(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1cfa40
leaq -0x58(%rbp), %rdi
callq 0x1dc900
leaq -0x38(%rbp), %rdi
callq 0x1c7d90
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0xd8(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5071e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5071e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507138
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
jmp 0x5071e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5071d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x50718b
movq -0x118(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x1e0ab0
movq -0x110(%rbp), %rdi
callq 0x1e0ab0
movq -0x108(%rbp), %rdi
callq 0x1c7d90
jmp 0x5071d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5071cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1cfa40
leaq -0x58(%rbp), %rdi
callq 0x1dc900
leaq -0x38(%rbp), %rdi
callq 0x1c7d90
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,894 | Omega_h::Read<double> Omega_h::derive_element_gradients_dim<2>(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_gradients_dim(Mesh* mesh, Reals vert_values) {
auto coords = mesh->coords();
auto ev2v = mesh->ask_elem_verts();
auto out = Write<Real>(mesh->nelems() * dim);
auto f = OMEGA_H_LAMBDA(LO e) {
auto evv2v = gather_verts<dim + 1>(ev2v, e);
auto evv2u = gather_scalars<dim + 1>(vert_values, evv2v);
Vector<dim> du_dxi;
for (Int i = 0; i < dim; ++i) du_dxi[i] = evv2u[i + 1] - evv2u[0];
auto evv2x = gather_vectors<dim + 1, dim>(coords, evv2v);
Matrix<dim, dim> dx_dxi = get_simplex_jacobian<dim>(evv2x);
auto dxi_dx = invert(dx_dxi);
auto du_dx = dxi_dx * du_dxi;
set_vector(out, e, du_dx);
};
parallel_for(mesh->nelems(), f, "derive_element_gradients");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e0da0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c65b0
jmp 0x50724b
movq -0x10(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0xec(%rbp)
jmp 0x50725c
movl -0xec(%rbp), %eax
addl %eax, %eax
movl %eax, -0xfc(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1dfbb0
movq -0xf8(%rbp), %rdx
leaq 0x12a0f7(%rip), %rsi # 0x63137f
leaq -0x78(%rbp), %rdi
callq 0x1d5e00
jmp 0x507293
movl -0xfc(%rbp), %esi
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x1cd090
jmp 0x5072a8
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x1d99b0
jmp 0x5072d3
movq -0xe8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1cae10
jmp 0x5072ef
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x507308
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c7e70
jmp 0x50731a
movq -0x10(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0x11c(%rbp)
jmp 0x50732b
movl -0x11c(%rbp), %edi
leaq 0x12e748(%rip), %rdx # 0x635a80
leaq -0xc0(%rbp), %rsi
callq 0x1ce2c0
jmp 0x507346
leaq -0xd0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d8720
jmp 0x507358
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1ccda0
jmp 0x50736d
leaq -0xd0(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1c4a00
leaq -0x58(%rbp), %rdi
callq 0x1dc900
leaq -0x38(%rbp), %rdi
callq 0x1c7d90
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0xd8(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5074a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x50749d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5073f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
jmp 0x50749d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507494
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507454
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507448
movq -0x118(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x1e0ab0
movq -0x110(%rbp), %rdi
callq 0x1e0ab0
movq -0x108(%rbp), %rdi
callq 0x1c7d90
jmp 0x507494
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1c4a00
leaq -0x58(%rbp), %rdi
callq 0x1dc900
leaq -0x38(%rbp), %rdi
callq 0x1c7d90
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,895 | Omega_h::Read<double> Omega_h::derive_element_gradients_dim<1>(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_gradients_dim(Mesh* mesh, Reals vert_values) {
auto coords = mesh->coords();
auto ev2v = mesh->ask_elem_verts();
auto out = Write<Real>(mesh->nelems() * dim);
auto f = OMEGA_H_LAMBDA(LO e) {
auto evv2v = gather_verts<dim + 1>(ev2v, e);
auto evv2u = gather_scalars<dim + 1>(vert_values, evv2v);
Vector<dim> du_dxi;
for (Int i = 0; i < dim; ++i) du_dxi[i] = evv2u[i + 1] - evv2u[0];
auto evv2x = gather_vectors<dim + 1, dim>(coords, evv2v);
Matrix<dim, dim> dx_dxi = get_simplex_jacobian<dim>(evv2x);
auto dxi_dx = invert(dx_dxi);
auto du_dx = dxi_dx * du_dxi;
set_vector(out, e, du_dx);
};
parallel_for(mesh->nelems(), f, "derive_element_gradients");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e0da0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c65b0
jmp 0x50750b
movq -0x10(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0xec(%rbp)
jmp 0x50751c
movl -0xec(%rbp), %eax
movl %eax, -0xfc(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1dfbb0
movq -0xf8(%rbp), %rdx
leaq 0x129e39(%rip), %rsi # 0x63137f
leaq -0x78(%rbp), %rdi
callq 0x1d5e00
jmp 0x507551
movl -0xfc(%rbp), %esi
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x1cd090
jmp 0x507566
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x1d99b0
jmp 0x507591
movq -0xe8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1cae10
jmp 0x5075ad
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x5075c6
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c7e70
jmp 0x5075d8
movq -0x10(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0x11c(%rbp)
jmp 0x5075e9
movl -0x11c(%rbp), %edi
leaq 0x12e48a(%rip), %rdx # 0x635a80
leaq -0xc0(%rbp), %rsi
callq 0x1bf0c0
jmp 0x507604
leaq -0xd0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d8720
jmp 0x507616
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1ccda0
jmp 0x50762b
leaq -0xd0(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1dab30
leaq -0x58(%rbp), %rdi
callq 0x1dc900
leaq -0x38(%rbp), %rdi
callq 0x1c7d90
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0xd8(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x50775b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5076b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c4d10
leaq -0x79(%rbp), %rdi
callq 0x1cf450
jmp 0x50775b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507706
movq -0x118(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x1e0ab0
movq -0x110(%rbp), %rdi
callq 0x1e0ab0
movq -0x108(%rbp), %rdi
callq 0x1c7d90
jmp 0x507752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x507746
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1dab30
leaq -0x58(%rbp), %rdi
callq 0x1dc900
leaq -0x38(%rbp), %rdi
callq 0x1c7d90
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,896 | Omega_h::Read<double> Omega_h::derive_element_hessians_dim<3>(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_hessians_dim(Mesh* mesh, Reals vert_gradients) {
auto coords = mesh->coords();
auto ev2v = mesh->ask_elem_verts();
auto out = Write<Real>(mesh->nelems() * symm_ncomps(dim));
auto f = OMEGA_H_LAMBDA(LO e) {
auto evv2v = gather_verts<dim + 1>(ev2v, e);
auto evv2u = gather_vectors<dim + 1, dim>(vert_gradients, evv2v);
Matrix<dim, dim> du_dxi;
for (Int i = 0; i < dim; ++i) {
for (Int j = 0; j < dim; ++j) {
du_dxi[i][j] = evv2u[j + 1][i] - evv2u[0][i];
}
}
auto evv2x = gather_vectors<dim + 1, dim>(coords, evv2v);
auto dx_dxi = get_simplex_jacobian<dim>(evv2x);
auto dxi_dx = invert(dx_dxi);
auto du_dx = dxi_dx * du_dxi;
set_symm(out, e, du_dx);
};
parallel_for(mesh->nelems(), f, "derive_element_hessians");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdx, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1e0da0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c65b0
jmp 0x5077cb
movq -0x18(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0xf4(%rbp)
jmp 0x5077dc
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
imull -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xf8(%rbp)
movl -0xf8(%rbp), %ecx
movl -0xf4(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x104(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1dfbb0
movq -0x100(%rbp), %rdx
leaq 0x129b4e(%rip), %rsi # 0x63137f
leaq -0x80(%rbp), %rdi
callq 0x1d5e00
jmp 0x50783c
movl -0x104(%rbp), %esi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x1cd090
jmp 0x507851
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1d99b0
jmp 0x50787f
movq -0xf0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1cae10
jmp 0x50789b
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x5078b4
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x5078c6
movq -0x18(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0x124(%rbp)
jmp 0x5078d7
movl -0x124(%rbp), %edi
leaq 0x12e1b5(%rip), %rdx # 0x635a99
leaq -0xc8(%rbp), %rsi
callq 0x1bb8a0
jmp 0x5078f2
leaq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1d8720
jmp 0x507904
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1ccda0
jmp 0x507919
leaq -0xd8(%rbp), %rdi
callq 0x1dc900
leaq -0xc8(%rbp), %rdi
callq 0x1c8c50
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1c7d90
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0xe0(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507a55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5079a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
jmp 0x507a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507a43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507a03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5079f7
movq -0x120(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x1e0ab0
movq -0x118(%rbp), %rdi
callq 0x1e0ab0
movq -0x110(%rbp), %rdi
callq 0x1c7d90
jmp 0x507a43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507a37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1dc900
leaq -0xc8(%rbp), %rdi
callq 0x1c8c50
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1c7d90
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0x48(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,897 | Omega_h::Read<double> Omega_h::derive_element_hessians_dim<2>(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_hessians_dim(Mesh* mesh, Reals vert_gradients) {
auto coords = mesh->coords();
auto ev2v = mesh->ask_elem_verts();
auto out = Write<Real>(mesh->nelems() * symm_ncomps(dim));
auto f = OMEGA_H_LAMBDA(LO e) {
auto evv2v = gather_verts<dim + 1>(ev2v, e);
auto evv2u = gather_vectors<dim + 1, dim>(vert_gradients, evv2v);
Matrix<dim, dim> du_dxi;
for (Int i = 0; i < dim; ++i) {
for (Int j = 0; j < dim; ++j) {
du_dxi[i][j] = evv2u[j + 1][i] - evv2u[0][i];
}
}
auto evv2x = gather_vectors<dim + 1, dim>(coords, evv2v);
auto dx_dxi = get_simplex_jacobian<dim>(evv2x);
auto dxi_dx = invert(dx_dxi);
auto du_dx = dxi_dx * du_dxi;
set_symm(out, e, du_dx);
};
parallel_for(mesh->nelems(), f, "derive_element_hessians");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdx, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1e0da0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c65b0
jmp 0x507abb
movq -0x18(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0xf4(%rbp)
jmp 0x507acc
movl -0xf4(%rbp), %eax
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %edx
movl %edx, %ecx
incl %ecx
imull %edx, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %edx, %ecx
sarl %ecx
imull %ecx, %eax
movl %eax, -0x104(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1dfbb0
movq -0x100(%rbp), %rdx
leaq 0x129869(%rip), %rsi # 0x63137f
leaq -0x80(%rbp), %rdi
callq 0x1d5e00
jmp 0x507b21
movl -0x104(%rbp), %esi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x1cd090
jmp 0x507b36
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1d99b0
jmp 0x507b64
movq -0xf0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1cae10
jmp 0x507b80
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x507b99
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x507bab
movq -0x18(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0x124(%rbp)
jmp 0x507bbc
movl -0x124(%rbp), %edi
leaq 0x12ded0(%rip), %rdx # 0x635a99
leaq -0xc8(%rbp), %rsi
callq 0x1e2a80
jmp 0x507bd7
leaq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1d8720
jmp 0x507be9
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1ccda0
jmp 0x507bfe
leaq -0xd8(%rbp), %rdi
callq 0x1dc900
leaq -0xc8(%rbp), %rdi
callq 0x1ce9e0
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1c7d90
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0xe0(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507d3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507d31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507c86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
jmp 0x507d31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507d28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507ce8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507cdc
movq -0x120(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x1e0ab0
movq -0x118(%rbp), %rdi
callq 0x1e0ab0
movq -0x110(%rbp), %rdi
callq 0x1c7d90
jmp 0x507d28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507d1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1dc900
leaq -0xc8(%rbp), %rdi
callq 0x1ce9e0
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1c7d90
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0x48(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,898 | Omega_h::Read<double> Omega_h::derive_element_hessians_dim<1>(Omega_h::Mesh*, Omega_h::Read<double>) | Reals derive_element_hessians_dim(Mesh* mesh, Reals vert_gradients) {
auto coords = mesh->coords();
auto ev2v = mesh->ask_elem_verts();
auto out = Write<Real>(mesh->nelems() * symm_ncomps(dim));
auto f = OMEGA_H_LAMBDA(LO e) {
auto evv2v = gather_verts<dim + 1>(ev2v, e);
auto evv2u = gather_vectors<dim + 1, dim>(vert_gradients, evv2v);
Matrix<dim, dim> du_dxi;
for (Int i = 0; i < dim; ++i) {
for (Int j = 0; j < dim; ++j) {
du_dxi[i][j] = evv2u[j + 1][i] - evv2u[0][i];
}
}
auto evv2x = gather_vectors<dim + 1, dim>(coords, evv2v);
auto dx_dxi = get_simplex_jacobian<dim>(evv2x);
auto dxi_dx = invert(dx_dxi);
auto du_dx = dxi_dx * du_dxi;
set_symm(out, e, du_dx);
};
parallel_for(mesh->nelems(), f, "derive_element_hessians");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdx, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1e0da0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c65b0
jmp 0x507d9b
movq -0x18(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0xf4(%rbp)
jmp 0x507dac
movl -0xf4(%rbp), %eax
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %edx
movl %edx, %ecx
incl %ecx
imull %edx, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %edx, %ecx
sarl %ecx
imull %ecx, %eax
movl %eax, -0x104(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1dfbb0
movq -0x100(%rbp), %rdx
leaq 0x129589(%rip), %rsi # 0x63137f
leaq -0x80(%rbp), %rdi
callq 0x1d5e00
jmp 0x507e01
movl -0x104(%rbp), %esi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x1cd090
jmp 0x507e16
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1d99b0
jmp 0x507e44
movq -0xf0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1cae10
jmp 0x507e60
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x507e79
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x507e8b
movq -0x18(%rbp), %rdi
callq 0x1e03e0
movl %eax, -0x124(%rbp)
jmp 0x507e9c
movl -0x124(%rbp), %edi
leaq 0x12dbf0(%rip), %rdx # 0x635a99
leaq -0xc8(%rbp), %rsi
callq 0x1e4590
jmp 0x507eb7
leaq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1d8720
jmp 0x507ec9
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1ccda0
jmp 0x507ede
leaq -0xd8(%rbp), %rdi
callq 0x1dc900
leaq -0xc8(%rbp), %rdi
callq 0x1d4590
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1c7d90
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0xe0(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x50801a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x508011
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507f66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
jmp 0x508011
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x508008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507fc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507fbc
movq -0x120(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x1e0ab0
movq -0x118(%rbp), %rdi
callq 0x1e0ab0
movq -0x110(%rbp), %rdi
callq 0x1c7d90
jmp 0x508008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x507ffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1dc900
leaq -0xc8(%rbp), %rdi
callq 0x1d4590
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1c7d90
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
movq -0x48(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
8,899 | Omega_h::Read<double> Omega_h::get_interior_coeffs_dim<3>(Omega_h::Mesh*, Omega_h::Read<double>, int) | Reals get_interior_coeffs_dim(Mesh* mesh, Reals e_data, Int ncomps) {
auto v2e = mesh->ask_up(VERT, dim);
auto v2ve = v2e.a2ab;
auto ve2e = v2e.ab2b;
auto ev2v = mesh->ask_elem_verts();
auto coords = mesh->coords();
auto owned = mesh->owned(VERT);
auto class_dim = mesh->get_array<I8>(VERT, "class_dim");
auto out = Write<Real>(mesh->nverts() * ncomps * (dim + 1));
auto f = OMEGA_H_LAMBDA(LO v) {
if (!owned[v] || (class_dim[v] != dim)) return;
auto qr = get_cavity_qr_factorization<dim>(v, v2ve, ve2e, ev2v, coords);
for (Int comp = 0; comp < ncomps; ++comp) {
auto coeffs =
fit_cavity_polynomial<dim>(qr, v, v2ve, ve2e, e_data, comp, ncomps);
set_vector(out, v * ncomps + comp, coeffs);
}
};
parallel_for(mesh->nverts(), f, "get_interior_coeffs");
return mesh->sync_array(VERT, Reals(out), ncomps * (dim + 1));
} | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %rdx, -0x1e8(%rbp)
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
xorl %edx, %edx
movl $0x3, %ecx
callq 0x1c6130
movq -0x1d0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1d99b0
jmp 0x50808f
leaq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1d99b0
jmp 0x50809e
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1c65b0
jmp 0x5080b0
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x1e0da0
jmp 0x5080c2
movq -0x10(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
xorl %edx, %edx
callq 0x1b9af0
jmp 0x5080d6
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x1dfbb0
movq -0x1f0(%rbp), %rdx
leaq 0x12b7c4(%rip), %rsi # 0x6338c6
leaq -0xe0(%rbp), %rdi
callq 0x1d5e00
jmp 0x508110
movq -0x1f8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
xorl %edx, %edx
leaq -0xe0(%rbp), %rcx
callq 0x1bf430
jmp 0x50812e
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0xe1(%rbp), %rdi
callq 0x1cf450
movq -0x10(%rbp), %rdi
callq 0x1d8940
movl %eax, -0x1fc(%rbp)
jmp 0x508157
movl -0x1fc(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
shll $0x2, %eax
movl %eax, -0x20c(%rbp)
leaq -0x119(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x1dfbb0
movq -0x208(%rbp), %rdx
leaq 0x1291f2(%rip), %rsi # 0x63137f
leaq -0x118(%rbp), %rdi
callq 0x1d5e00
jmp 0x50819b
movl -0x20c(%rbp), %esi
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rdx
callq 0x1cd090
jmp 0x5081b6
leaq -0x118(%rbp), %rdi
callq 0x1c4d10
leaq -0x119(%rbp), %rdi
callq 0x1cf450
leaq -0x1a8(%rbp), %rdi
movq %rdi, -0x218(%rbp)
leaq -0xb0(%rbp), %rsi
callq 0x1bec60
jmp 0x5081ea
leaq -0x198(%rbp), %rdi
movq %rdi, -0x220(%rbp)
leaq -0xc0(%rbp), %rsi
callq 0x1bec60
jmp 0x508206
leaq -0x188(%rbp), %rdi
movq %rdi, -0x228(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x1d99b0
jmp 0x50821f
leaq -0x178(%rbp), %rdi
movq %rdi, -0x230(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x1d99b0
jmp 0x508238
leaq -0x168(%rbp), %rdi
movq %rdi, -0x238(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x1d99b0
jmp 0x508254
leaq -0x158(%rbp), %rdi
movq %rdi, -0x240(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x1cae10
jmp 0x508270
movq -0x1e8(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, -0x148(%rbp)
leaq -0x140(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x1cae10
jmp 0x508295
leaq -0x130(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1c7e70
jmp 0x5082aa
movq -0x10(%rbp), %rdi
callq 0x1d8940
movl %eax, -0x24c(%rbp)
jmp 0x5082bb
movl -0x24c(%rbp), %edi
leaq 0x12d70a(%rip), %rdx # 0x6359d2
leaq -0x1a8(%rbp), %rsi
callq 0x1c15a0
jmp 0x5082d6
movq -0x10(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x1c7e70
jmp 0x5082f6
leaq -0x1b8(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x1ccda0
jmp 0x50830b
movq -0x258(%rbp), %rsi
movq -0x1e0(%rbp), %rdi
movl -0x1c(%rbp), %r8d
shll $0x2, %r8d
xorl %edx, %edx
leaq -0x1b8(%rbp), %rcx
callq 0x1dd310
jmp 0x508331
leaq -0x1b8(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1c8(%rbp), %rdi
callq 0x1dc900
leaq -0x1a8(%rbp), %rdi
callq 0x1dfed0
leaq -0xf8(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1e0060
leaq -0xb0(%rbp), %rdi
callq 0x1e0060
leaq -0xa0(%rbp), %rdi
callq 0x1e0ab0
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x80(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1c7d90
leaq -0x50(%rbp), %rdi
callq 0x1cb510
movq -0x1d8(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x508437
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0xe1(%rbp), %rdi
callq 0x1cf450
jmp 0x5085c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x50847f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x1c4d10
leaq -0x119(%rbp), %rdi
callq 0x1cf450
jmp 0x5085b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5085a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x50854f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x508543
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x508537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x50852b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x50851f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x508513
movq -0x248(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x1e0ab0
movq -0x240(%rbp), %rdi
callq 0x1e0ab0
movq -0x238(%rbp), %rdi
callq 0x1c7d90
movq -0x230(%rbp), %rdi
callq 0x1c7d90
movq -0x228(%rbp), %rdi
callq 0x1c7d90
movq -0x220(%rbp), %rdi
callq 0x1e0060
movq -0x218(%rbp), %rdi
callq 0x1e0060
jmp 0x5085a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x50859d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x508591
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1c8(%rbp), %rdi
callq 0x1dc900
leaq -0x1a8(%rbp), %rdi
callq 0x1dfed0
leaq -0xf8(%rbp), %rdi
callq 0x1dc900
leaq -0xc0(%rbp), %rdi
callq 0x1e0060
leaq -0xb0(%rbp), %rdi
callq 0x1e0060
leaq -0xa0(%rbp), %rdi
callq 0x1e0ab0
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x80(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1c7d90
leaq -0x50(%rbp), %rdi
callq 0x1cb510
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_recover.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.