name string | code string | asm string | file string |
|---|---|---|---|
common_sampler_clone(common_sampler*) | struct common_sampler * common_sampler_clone(common_sampler * gsmpl) {
return new common_sampler {
/* .params = */ gsmpl->params,
/* .grmr = */ llama_sampler_clone(gsmpl->grmr),
/* .chain = */ llama_sampler_clone(gsmpl->chain),
/* .prev = */ gsmpl->prev,
/* .cur = */ ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1a0, %edi # imm = 0x1A0
callq 0x23280
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x96e02
movq 0x120(%r14), %rdi
callq 0x23e70
movq %rax, 0x120(%rbx)
movq 0x128(%r14), %rdi
callq 0x23e70
movq %rax, 0x128(%rbx)
movups 0x130(%r14), %xmm0
movups... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_sample(common_sampler*, llama_context*, int, bool) | llama_token common_sampler_sample(struct common_sampler * gsmpl, struct llama_context * ctx, int idx, bool grammar_first) {
gsmpl->set_logits(ctx, idx);
auto & grmr = gsmpl->grmr;
auto & chain = gsmpl->chain;
auto & cur_p = gsmpl->cur_p; // initialized by set_logits
if (grammar_first) {
l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x134d60
leaq 0x180(%rbx), %r14
testl %r12d, %r12d
je 0x133bc3
movq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0x23420
movq 0x128(%rbx), %rdi
movq %r14, %rsi
callq 0x234... | /ggerganov[P]llama/common/sampling.cpp |
common_sampler_sample_and_accept_n(common_sampler*, llama_context*, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, bool) | std::vector<llama_token> common_sampler_sample_and_accept_n(struct common_sampler * gsmpl, struct llama_context * ctx, const std::vector<int> & idxs, const llama_tokens & draft, bool grammar_first) {
GGML_ASSERT(idxs.size() == draft.size() + 1 && "idxs.size() must be draft.size() + 1");
std::vector<llama_token... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
movq 0x8(%r8), %rax
subq (%r8), %rax
sarq $0x2, %rsi
sarq $0x2, %rax
incq %rax
cmpq %rax, %rsi
jne 0x133e31
movl %r9d, %ebp
movq %r8, %r13
movq %rcx, %r12
movq ... | /ggerganov[P]llama/common/sampling.cpp |
testing::Message::operator<<(wchar_t*) | Message& Message::operator <<(wchar_t* wide_c_str) {
return *this << internal::String::ShowWideCString(wide_c_str);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xfc96
movq (%rbx), %rdi
addq $0x10, %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x7570
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd15
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7490
movq %rbx, %... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xfdff
movq (%rsi), %r13
leaq 0x18(%rsp), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
cmpl $0x0, (%r13,%rbp,4)
je 0xfdda
leaq (,%rbp,4), %rsi
addq %r13, %rsi
movl %r15d, %edx
subl %e... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != NULL ?
new ::std::string(*other.message_) :
static_cast< ::std::string*>(NULL)) {
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %al
movb %al, (%rdi)
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0xff6d
movl $0x20, %edi
callq 0x7460
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xad62
jmp 0xff70
xorl %r14d, %... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult::operator!() const | AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_);
if (message_.get() != NULL)
negation << *message_;
return negation;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rsi), %al
xorb $0x1, %al
movb %al, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0xffd6
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x294e4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %e... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionFailure(testing::Message const&) | AssertionResult AssertionFailure(const Message& message) {
return AssertionFailure() << message;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x2956a
movq %r14, %rdi
movq %rax, %rsi
callq 0xff30
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb00a
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
const std::vector<size_t>& right) {
std::vector<std::vector<double> > costs(
left.size() + 1, std::vector<double>(right.size() + 1));
std::vector<std::vector<EditType> > best_move(
le... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
incq %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2963e
subq %r14, %r12
sarq $0x3, %... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>,... | std::vector<EditType> CalculateOptimalEdits(
const std::vector<std::string>& left,
const std::vector<std::string>& right) {
std::vector<size_t> left_ids, right_ids;
{
InternalStrings intern_table;
for (size_t i = 0; i < left.size(); ++i) {
left_ids.push_back(intern_table.GetId(left[i]));
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x50(%rsp)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x60(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | size_t GetId(const std::string& str) {
IdMap::iterator it = ids_.find(str);
if (it != ids_.end()) return it->second;
size_t id = ids_.size();
return ids_[str] = id;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2d480
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x106bb
movq 0x40(%rax), %r15
jmp 0x106cd
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d404
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
| /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::CreateUnifiedDiff(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std... | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
const std::vector<std::string>& right,
size_t context) {
const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
size_t l_i = 0, r_i = 0, edit_i = 0;
std::stringstream s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rcx, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
leaq 0x10(%rsp), %rdi
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa8(%rsp)
callq 0x104ca
leaq 0xb0(%rsp), %rdi
callq 0x7330
leaq 0x50(%rsp), %r12
leaq 0x68(%rsp), %rbp
xorl %ebx... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*) | void PushLine(char edit, const char* line) {
switch (edit) {
case ' ':
++common_;
FlushEdits();
hunk_.push_back(std::make_pair(' ', line));
break;
case '-':
++removes_;
hunk_removes_.push_back(std::make_pair('-', line));
break;
case '+':
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x10c9f
cmpl $0x2b, %ebp
je 0x10c8d
cmpl $0x20, %ebp
jne 0x10cd3
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x28066
movl $0x38, %r12d
movl $0x28, %r15d
jmp 0x10caf
incq 0x10(%rbx)
movl $0x50, %r12d
movl... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::~Hunk() | Hunk(size_t left_start, size_t right_start)
: left_start_(left_start),
right_start_(right_start),
adds_(),
removes_(),
common_() {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x58(%rdi), %rdi
cmpq %r14, %rdi
je 0x10d06
movq (%rdi), %r15
movl $0x20, %esi
callq 0x7490
movq %r15, %rdi
cmpq %r14, %r15
jne 0x10cf1
leaq 0x40(%rbx), %r14
movq 0x40(%rbx), %rdi
cmpq %r14, %rdi
je 0x10d28
movq (%rdi), %r15
movl $0x20, %esi
ca... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | AssertionResult EqFailure(const char* lhs_expression,
const char* rhs_expression,
const std::string& lhs_value,
const std::string& rhs_value,
bool ignoring_case) {
Message msg;
msg << "Expected equality of these ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xfbd0
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x24862(%rip), %rsi # 0x355ef
movl $0x22, ... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::vector<std::string> SplitEscapedString(const std::string& str) {
std::vector<std::string> lines;
size_t start = 0, end = str.size();
if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
++start;
--end;
}
bool escaped = false;
for (size_t i = start; i + 1 < end; ++i) {
if (escaped) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x110b7
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x110b7
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
le... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::GetBoolAssertionFailureMessage[abi:cxx11](testing::AssertionResult const&, char const*, char const*, char const*) | std::string GetBoolAssertionFailureMessage(
const AssertionResult& assertion_result,
const char* expression_text,
const char* actual_predicate_value,
const char* expected_predicate_value) {
const char* actual_message = assertion_result.message();
Message msg;
msg << "Value of: " << expression_text... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x111e9
movq (%rax), %r13
jmp 0x111f0
leaq 0x24b21(%rip), %r13 # 0x35d11
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xfbd0
... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::DoubleNearPredFormat(char const*, char const*, char const*, double, double, double) | AssertionResult DoubleNearPredFormat(const char* expr1,
const char* expr2,
const char* abs_error_expr,
double val1,
double val2,
double... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
subsd %xmm1, %xmm0
andpd 0x230c6(%rip), %xmm0 # 0x34450
movsd %xmm2, 0x20(%rsp)
movlpd %xmm0, 0x18(%rsp)
ucomisd %xmm0, %xmm2
jae 0x114ed
leaq 0x40(%rsp)... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRCASENE(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
const char* s2_expression,
const char* s1,
const char* s2) {
if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
return AssertionSuccess();
} el... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x1217d
testq %r8, %r8
je 0x1222e
movq %rcx, %rdi
movq %r8, %rsi
callq 0x7500
testl %eax, %eax
sete %al
testb %al, %al
je 0x1222e
leaq ... | /wdeconinck[P]cpp_bindgen/build_O1/_deps/googletest-src/googletest/src/gtest.cc |
Utilities::read_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | vector<string> Utilities::read_file(string file_path) {
vector<string> vec;
ifstream myFile(file_path);
string line;
if(myFile.is_open()){
while(getline(myFile,line)){
vec.push_back(line);
}
}else{
cout << "Can not open the file" << endl;
}
myFile.close();... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rsi, -0x258(%rbp)
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4eb0
movq -0x258(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3460
jmp ... | /SabraTech[P]Compiler/Utilities.cpp |
Phase2::get_first_sets(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | unordered_set<string> Phase2::get_first_sets(string non_terminal) {
if (visited.find(non_terminal) != visited.end()) {
return first[non_terminal];
}
visited.insert(non_terminal);
if (terminals.find(non_terminal) != terminals.end()) {
return first[non_terminal];
}
vector<vector<st... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdx, -0x1f0(%rbp)
movq %rsi, %rax
movq -0x1f0(%rbp), %rsi
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rcx
movq %rcx, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
addq $0... | /SabraTech[P]Compiler/Phase2.cpp |
bloaty::RangeMapTest_UnknownSize2_Test::RangeMapTest_UnknownSize2_Test() | TEST_F(RangeMapTest, UnknownSize2) {
// This case is slightly weird, but we do consider the "100" below to be a
// hard fact even if the size is unknown, so the "[95, 105]: bar" range
// doesn't override it.
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(95, 10, "bar");
AssertMainMapEquals({
{95... | pushq %rbx
movq %rdi, %rbx
callq 0x2127c6
leaq 0x18(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
leaq 0x48(%rbx), %rax
movl %ecx, 0x48(%rbx)
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movq %rax, 0x60(%rbx)
movq %rcx, 0x68(%rbx... | /google[P]bloaty/tests/range_map_test.cc |
bloaty::RangeMapTest_UnknownSize3_Test::RangeMapTest_UnknownSize3_Test() | TEST_F(RangeMapTest, UnknownSize3) {
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(150, kUnknownSize, "bar");
// This tells us the ultimate size of "foo", and we keep the "foo" label even
// though the new label is "baz".
map_.AddRange(100, 100, "baz");
AssertMainMapEquals({
{100, 150, kNoTrans... | pushq %rbx
movq %rdi, %rbx
callq 0x2127c6
leaq 0x18(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
leaq 0x48(%rbx), %rax
movl %ecx, 0x48(%rbx)
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movq %rax, 0x60(%rbx)
movq %rcx, 0x68(%rbx... | /google[P]bloaty/tests/range_map_test.cc |
bloaty::ArgParser::TryParseOption(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>*) | bool TryParseOption(string_view flag, string_view* val) {
assert(flag.size() > 1);
bool is_long = flag[1] == '-';
string_view arg = Arg();
if (TryParseFlag(flag)) {
if (IsDone()) {
THROWF("option '$0' requires an argument", flag);
}
*val = ConsumeArg();
return true;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpq $0x1, %rsi
jbe 0x8c570
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movb 0x1(%rdx), %r12b
callq 0x8c97c
movq %rax, (%rsp)
movq %rdx, %r15
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x8c3b4
testb %al, %a... | /google[P]bloaty/src/bloaty.cc |
bloaty::Options::add_data_source(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void Options::add_data_source(const std::string& value) {
data_source_.Add()->assign(value);
// @@protoc_insertion_point(field_add:bloaty.Options.data_source)
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rdi), %r15
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x8c62c
movslq 0x50(%r14), %rcx
movl (%rax), %esi
cmpl %esi, %ecx
jge 0x8c632
leal 0x1(%rcx), %edx
movl %edx, 0x50(%r14)
movq 0x8(%rax,%rcx,8), %rdi
jmp 0x8c6a5
movl 0x54(%r14), %esi
jmp 0x8c... | /google[P]bloaty/build_O3/src/bloaty.pb.h |
bloaty::ArgParser::TryParseUint64Option(std::basic_string_view<char, std::char_traits<char>>, unsigned long*) | bool TryParseUint64Option(string_view flag, uint64_t* val) {
string_view val_str;
if (!TryParseOption(flag, &val_str)) {
return false;
}
try {
*val = std::stoull(std::string(val_str), nullptr, 0);
} catch (...) {
THROWF("option '$0' had non-integral argument: $1", flag, val_str);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
callq 0x8c3fa
movl %eax, %ebp
testb %al, %al
je 0x8c793
movq %rbx, 0x20(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rax
movq ... | /google[P]bloaty/src/bloaty.cc |
google::protobuf::io::EpsCopyOutputStream::WriteStringMaybeAliased(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char*) | uint8* WriteStringMaybeAliased(uint32 num, const std::string& s, uint8* ptr) {
std::ptrdiff_t size = s.size();
if (PROTOBUF_PREDICT_FALSE(
size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
return WriteStringMaybeAliasedOutline(num, s, ptr);
}
ptr = UnsafeVarint((num << ... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x8(%rdx), %r14
cmpq $0x7f, %r14
jg 0x97f62
movq (%rdi), %rcx
leal (,%rsi,8), %eax
cmpl $0x80, %eax
jae 0x97ebb
subq %rbx, %rcx
addq $0xe, %rcx
cmpq %r14, %rcx
jl 0x97f62
orl $0x2, %eax
movl %eax, %ecx
jmp 0x97f00
movl $0x2, %r8d
cmpl $0x4000, %eax # imm =... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream.h |
void google::protobuf::internal::RepeatedPtrFieldBase::Clear<google::protobuf::RepeatedPtrField<bloaty::CustomDataSource>::TypeHandler>() | void RepeatedPtrFieldBase::Clear() {
const int n = current_size_;
GOOGLE_DCHECK_GE(n, 0);
if (n > 0) {
void* const* elements = rep_->elements;
int i = 0;
do {
TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
} while (i < n);
current_size_ = 0;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
js 0x9859a
testq %r14, %r14
je 0x985de
movq %rdi, %rbx
movq 0x10(%rdi), %r15
xorl %r12d, %r12d
movq 0x8(%r15,%r12,8), %rdi
incq %r12
callq 0x96b0a
cmpq %r12, %r14
jne 0x9857f
movl $0x0, 0x8(%rbx)
jmp 0x985de
leaq 0x1a2... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::TypeHandler>(void**, void**, int, int) | void RepeatedPtrFieldBase::MergeFromInnerLoop(void** our_elems,
void** other_elems, int length,
int already_allocated) {
// Split into two loops, over ranges [0, allocated) and [allocated, length),
// to avoid a branch withi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
cmpl %ecx, %r8d
movq %rcx, (%rsp)
movl %ecx, %eax
cmovll %r8d, %eax
testl %eax, %eax
jle 0x9882c
movl %eax, %ebx
xorl %r13d, %r13d
movq (%r12,%r13,8), %rsi
movq (%r15,%r13,8), %rd... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFrom<google::protobuf::RepeatedPtrField<bloaty::CustomDataSource>::TypeHandler>(google::protobuf::internal::RepeatedPtrFieldBase const&) | inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
GOOGLE_DCHECK_NE(&other, this);
if (other.current_size_ == 0) return;
MergeFromInternal(other,
&RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdi, %rsi
jne 0x98a27
leaq 0x1a2a09(%rip), %rdx # 0x23b3f3
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x660, %ecx # imm = 0x660
callq 0x1885e8
leaq 0x1a2acb(%rip), %rsi # 0x23b4d3
movq %r... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
void google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<bloaty::Regex>::TypeHandler>(void**, void**, int, int) | void RepeatedPtrFieldBase::MergeFromInnerLoop(void** our_elems,
void** other_elems, int length,
int already_allocated) {
// Split into two loops, over ranges [0, allocated) and [allocated, length),
// to avoid a branch withi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, (%rsp)
cmpl %ecx, %r8d
movq %rcx, %r12
movl %ecx, %eax
cmovll %r8d, %eax
testl %eax, %eax
jle 0x98dca
movl %eax, %ebx
xorl %r13d, %r13d
movq (%r15,%r13,8), %rdi
movq (%r14,%r13,8), %rs... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/repeated_field.h |
bloaty::(anonymous namespace)::ElfFile::ElfFile(std::basic_string_view<char, std::char_traits<char>>) | ElfFile(string_view data) : data_(data) {
ok_ = Initialize();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, 0xe0(%rdi)
movdqu %xmm0, 0xf0(%rdi)
movdqu %xmm0, 0x68(%rdi)
movdqu %xmm0, 0x78(%rdi)
movdqu %xmm0, 0x88(%rdi)
cmpq $0x10, %rsi
jb 0x99005
cmpl $0x464c457f, ... | /google[P]bloaty/src/elf.cc |
bloaty::(anonymous namespace)::ReadELFSymbols(bloaty::InputFile const&, bloaty::RangeSink*, std::map<std::basic_string_view<char, std::char_traits<char>>, std::pair<unsigned long, unsigned long>, std::less<std::basic_string_view<char, std::char_traits<char>>>, std::allocator<std::pair<std::basic_string_view<char, std::... | static void ReadELFSymbols(const InputFile& file, RangeSink* sink,
SymbolTable* table, bool disassemble) {
bool is_object = IsObjectFile(file.data());
DisassemblyInfo info;
DisassemblyInfo* infop = &info;
bool capstone_available = ReadElfArchMode(file, &info.arch, &info.mode);
ForE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq 0x30(%r14), %rsi
callq 0x9a6b6
movl %eax, %r12d
xorps %xmm0, %xmm0
leaq 0xb8(%rsp), %rax
movaps %xmm0, -0x18(%rax)
xorl ... | /google[P]bloaty/src/elf.cc |
void bloaty::macho::ParseSymbolsFromSymbolTable<nlist_64>(bloaty::macho::LoadCommand const&, std::map<std::basic_string_view<char, std::char_traits<char>>, std::pair<unsigned long, unsigned long>, std::less<std::basic_string_view<char, std::char_traits<char>>>, std::allocator<std::pair<std::basic_string_view<char, std:... | const T* GetStructPointer(string_view data) {
if (sizeof(T) > data.size()) {
THROW("Premature EOF reading Mach-O data.");
}
return reinterpret_cast<const T*>(data.data());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpq $0x17, 0x8(%rdi)
jbe 0xa0f21
movq %rdx, %r13
movq %rsi, %rbp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movl 0x8(%rax), %r15d
movl 0xc(%rax), %r14d
movq %r14, %rcx
shlq $0x4, %rcx
leaq (%rcx,%r15), %rdx
cmpq %rsi, %rdx
ja 0xa0f43
m... | /google[P]bloaty/src/macho.cc |
bloaty::sourcemap::SourceMapObjectFile::ProcessFileToSink(bloaty::RangeSink*) const | void addToSink(RangeSink* sink) const {
auto name = sink->data_source() == DataSource::kInlines
? source_file + ":" + std::to_string(source_line)
: source_file;
sink->AddFileRange("sourcemap", name, col, length);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl 0xe8(%rsi), %eax
decl %eax
cmpl $0x2, %eax
jae 0xa1d2f
movq 0x8(%rdi), %rcx
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0xa1d40
movq %rsi, %rbx
movq 0x30(%rcx), %rcx
incq %rcx
leaq 0x8(%rsp), %rdi
movq %rcx, 0x8(%rdi)
decq %rax
movq %... | /google[P]bloaty/src/source_map.cc |
bloaty::wasm::ParseSections(bloaty::RangeSink*) | void ParseSections(RangeSink* sink) {
ForEachSection(sink->input_file().data(), [sink](const Section& section) {
sink->AddFileRange("wasm_sections", section.name, section.data);
});
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movups 0x28(%rax), %xmm0
leaq 0x8(%rsp), %r14
movups %xmm0, (%r14)
movq %r14, %rdi
callq 0xa2d20
cmpq $0x0, (%r14)
je 0xa2e20
leaq 0x30(%rsp), %r13
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x199f30(%rip), %r... | /google[P]bloaty/src/webassembly.cc |
bloaty::wasm::ReadCodeSection(bloaty::wasm::Section const&, std::unordered_map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> co... | void ReadCodeSection(const Section& section, const IndexedNames& names,
uint32_t num_imports, RangeSink* sink) {
string_view data = section.contents;
uint32_t count = ReadVarUInt32(&data);
for (uint32_t i = 0; i < count; i++) {
string_view func = data;
uint32_t size = ReadVarUInt32(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movups 0x38(%rdi), %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
xorl %r12d, %r12d
movl $0x20, %esi
xorl %edi, %edi
callq 0xa2c14
movq %rax, 0x90(%rsp)
testl %eax, %eax... | /google[P]bloaty/src/webassembly.cc |
bloaty::wasm::ReadDataSection(bloaty::wasm::Section const&, std::unordered_map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> co... | void ReadDataSection(const Section& section, const IndexedNames& names,
RangeSink* sink) {
string_view data = section.contents;
uint32_t count = ReadVarUInt32(&data);
for (uint32_t i = 0; i < count; i++) {
string_view segment = data;
uint32_t mode = ReadVarUInt32(&data);
if (mode... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x90(%rsp)
movups 0x38(%rdi), %xmm0
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
xorl %r15d, %r15d
movl $0x20, %esi
xorl %edi, %edi
callq 0xa2c14
movq %rax, 0x88(%rsp)
testl %eax, %eax
je 0xa3aa1
leaq 0x50(%... | /google[P]bloaty/src/webassembly.cc |
bloaty::wasm::ParseSymbols(bloaty::RangeSink*) | void ParseSymbols(RangeSink* sink) {
// First pass: read the custom naming section to get function names.
std::unordered_map<int, std::string> func_names;
std::unordered_map<int, std::string> dataseg_names;
uint32_t num_imports = 0;
ForEachSection(sink->input_file().data(),
[&func_names, &da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0xc0(%rsp), %rax
movq %rax, -0x30(%rax)
movl $0x1, %ecx
movq %rcx, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edx # imm = 0x3F800000
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%r... | /google[P]bloaty/src/webassembly.cc |
char const* __cxxabiv1::(anonymous namespace)::parse_block_invoke<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_block_invoke(const char* first, const char* last, C& db)
{
if (last - first >= 13)
{
const char test[] = "_block_invoke";
const char* t = first;
for (int i = 0; i < 13; ++i, ++t)
{
if (*t != test[i])
return first;
}
if... | movq %rdi, %rax
movq %rsi, %rdi
subq %rax, %rdi
cmpq $0xd, %rdi
jl 0xa5f76
pushq %rbx
leaq 0xd(%rax), %rbx
xorl %edi, %edi
leaq 0x1977bb(%rip), %r8 # 0x23d6b8
movb (%rax,%rdi), %r9b
cmpb (%rdi,%r8), %r9b
jne 0xa5f75
incq %rdi
cmpq $0xd, %rdi
jne 0xa5efd
cmpq %rsi, %rbx
je 0xa5f4d
cmpb $0x5f, (%rbx)
jne 0xa5f32
leaq... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_name<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&, bool*) | const char*
parse_name(const char* first, const char* last, C& db,
bool* ends_with_template_args)
{
if (last - first >= 2)
{
const char* t0 = first;
// extension: ignore L here
if (*t0 == 'L')
++t0;
switch (*t0)
{
case 'N':
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r12
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x2, %rax
jl 0xa7f21
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r13
xorl %eax, %eax
cmpb $0x4c, (%r12)
sete %al
leaq (%r12,%rax), %rdx
movzbl (%r12,%rax), %eax
cmpl $0x5a, %eax
movq ... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
_cxxabiv1::(anonymous namespace)::parse_number(char const*, char const*) | const char*
parse_number(const char* first, const char* last)
{
if (first != last)
{
const char* t = first;
if (*t == 'n')
++t;
if (t != last)
{
if (*t == '0')
{
first = t+1;
}
else if ('1' <= *t && *t <=... | movq %rdi, %rax
cmpq %rsi, %rdi
je 0xa81d2
xorl %ecx, %ecx
cmpb $0x6e, (%rax)
sete %cl
leaq (%rax,%rcx), %rdx
cmpq %rsi, %rdx
je 0xa81d2
movb (%rdx), %dil
cmpb $0x30, %dil
jne 0xa81d3
incq %rdx
movq %rdx, %rax
retq
addb $-0x31, %dil
cmpb $0x8, %dil
ja 0xa81d2
addq %rcx, %rax
incq %rax
cmpq %rsi, %rax
je 0xa81fa
movsbl ... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_prefix_expression<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db::String const&, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db)
{
const char* t1 = parse_expression(first, last, db);
if (t1 != first)
{
if (db.names.empty())
return first;
db.names.back().first = op + "(" + db.names.back().move_full... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
movq %rcx, %rdx
callq 0xaa6b4
cmpq %r15, %rax
je 0xad34c
movq %rax, %rbx
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jne 0xad361
movq %r15, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r1... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_const_cast_expr<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_const_cast_expr(const char* first, const char* last, C& db)
{
if (last - first >= 3 && first[0] == 'c' && first[1] == 'c')
{
const char* t = parse_type(first+2, last, db);
if (t != first+2)
{
const char* t1 = parse_expression(t, last, db);
if (t1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r15
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x3, %rax
jl 0xad948
cmpb $0x63, (%r15)
jne 0xad948
cmpb $0x63, 0x1(%r15)
jne 0xad948
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x2(%r15), %r13
movq %r13, %rdi
ca... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_new_expr<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_new_expr(const char* first, const char* last, C& db)
{
if (last - first >= 4)
{
const char* t = first;
bool parsed_gs = false;
if (t[0] == 'g' && t[1] == 's')
{
t += 2;
parsed_gs = true;
}
if (t[0] == 'n' && (t[1] == 'w' |... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdi, %r15
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x4, %rax
jl 0xaf09e
movq %rdx, %rbx
movq %rsi, %r12
movb (%r15), %al
xorl %ebp, %ebp
cmpb $0x67, %al
jne 0xaf022
cmpb $0x73, 0x1(%r15)
sete %bpl
leaq (%r15,... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_arrow_expr<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_arrow_expr(const char* first, const char* last, C& db)
{
if (last - first >= 3 && first[0] == 'p' && first[1] == 't')
{
const char* t = parse_expression(first+2, last, db);
if (t != first+2)
{
const char* t1 = parse_expression(t, last, db);
if (t... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r15
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x3, %rax
jl 0xaf83d
cmpb $0x70, (%r15)
jne 0xaf83d
cmpb $0x74, 0x1(%r15)
jne 0xaf83d
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x2(%r15), %r13
movq %r13, %rdi
callq 0xaa6b4
cmpq %r13, %rax
je 0xaf83... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_typeid_expr<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_typeid_expr(const char* first, const char* last, C& db)
{
if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i'))
{
const char* t;
if (first[1] == 'e')
t = parse_expression(first+2, last, db);
else
t = parse_type(first+2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x3, %rax
jl 0xb0af1
cmpb $0x74, (%r15)
jne 0xb0af1
movq %rdx, %r14
movzbl 0x1(%r15), %eax
cmpl $0x69, %eax
je 0xb0acf
cmpl $0x65, %eax
jne 0xb0af1
leaq 0x2(%r15), %rdi
movq %r14, %rd... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
char const* __cxxabiv1::(anonymous namespace)::parse_simple_id<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_simple_id(const char* first, const char* last, C& db)
{
if (first != last)
{
const char* t = parse_source_name(first, last, db);
if (t != first)
{
const char* t1 = parse_template_args(t, last, db);
if (t1 != t)
{
if (d... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
cmpq %rsi, %rdi
je 0xb2bf4
movq %rdx, %r14
movq %rsi, %rbx
movq %r15, %rdi
callq 0xb2c21
movq %rax, %r12
cmpq %r15, %rax
je 0xb2bf1
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa89a0
movq %rax, %rbx
cmpq %r12, %rax
je 0xb2bec
movq 0... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
bloaty::ReadDWARFAddressRanges(bloaty::dwarf::File const&, bloaty::RangeSink*)::FilenameMap::~FilenameMap() | FilenameMap(const dwarf::File& file)
: info_reader_(file),
missing_("[DWARF is missing filename]") {} | pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rdi
leaq 0xc8(%rbx), %rax
cmpq %rax, %rdi
je 0xb7932
movq (%rax), %rsi
incq %rsi
callq 0x6d6d0
leaq 0x80(%rbx), %rdi
callq 0xb7b82
leaq 0x48(%rbx), %rdi
callq 0xb7fee
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xb7b82
| /google[P]bloaty/src/dwarf.cc |
bloaty::ReadEhFrame(std::basic_string_view<char, std::char_traits<char>>, bloaty::RangeSink*) | void ReadEhFrame(string_view data, RangeSink* sink) {
string_view remaining = data;
struct CIEInfo {
int version = 0;
uint32_t code_align = 0;
int32_t data_align = 0;
uint8_t fde_encoding = 0;
uint8_t lsda_encoding = 0;
bool is_signal_handler = false;
bool has_augmentation_length = fals... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x68(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
leaq 0x38(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x3f800000, 0x10(%rax) # imm = 0x3F800000
movups %xmm0, 0... | /google[P]bloaty/src/eh_frame.cc |
bloaty::dwarf::AttrValue::ParseAttr(bloaty::dwarf::CU const&, unsigned short, std::basic_string_view<char, std::char_traits<char>>*) | AttrValue AttrValue::ParseAttr(const CU& cu, uint16_t form, string_view* data) {
switch (form) {
case DW_FORM_indirect: {
uint16_t indirect_form = ReadLEB128<uint16_t>(data);
if (indirect_form == DW_FORM_indirect) {
THROW("indirect attribute has indirect form type");
}
return Parse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x184e18(%rip), %r12 # 0x23dd14
movzwl %bp, %edi
leal -0x1(%rdi), %eax
cmpl $0x2b, %eax
ja 0xb8f31
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
callq 0... | /google[P]bloaty/src/dwarf/attr.cc |
unsigned short bloaty::dwarf::ReadLEB128<unsigned short>(std::basic_string_view<char, std::char_traits<char>>*) | T ReadLEB128(std::string_view* data) {
typedef typename std::conditional<std::is_signed<T>::value, int64_t,
uint64_t>::type Int64Type;
Int64Type val = ReadLEB128Internal(std::is_signed<T>::value, data);
if (val > std::numeric_limits<T>::max() ||
val < std::numeric_limits<... | pushq %rax
movq %rdi, %rsi
xorl %edi, %edi
callq 0xb97aa
cmpq $0x10000, %rax # imm = 0x10000
jae 0xb9554
popq %rcx
retq
leaq 0x18475e(%rip), %rdi # 0x23dcb9
movl $0x25, %esi
callq 0xa2a0c
| /google[P]bloaty/src/dwarf/dwarf_util.h |
bloaty::dwarf::InfoReader::GetCUIter(bloaty::dwarf::InfoReader::Section, unsigned long) | CUIter InfoReader::GetCUIter(Section section, uint64_t offset) {
string_view data;
if (section == Section::kDebugInfo) {
data = dwarf_.debug_info;
} else {
data = dwarf_.debug_types;
}
SkipBytes(offset, &data);
return CUIter(section, data);
} | movq (%rsi), %rax
leaq 0xd0(%rax), %rsi
leaq 0x30(%rax), %r8
testl %edx, %edx
cmoveq %r8, %rsi
movq (%rsi), %rsi
subq %rcx, %rsi
jb 0xb9bb2
leaq 0xd8(%rax), %r8
addq $0x38, %rax
testl %edx, %edx
cmovneq %r8, %rax
addq (%rax), %rcx
movl %edx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rdi, %rax
retq
pushq %... | /google[P]bloaty/src/dwarf/debug_info.cc |
bloaty::dwarf::LineInfoReader::ReadLineInfo() | bool LineInfoReader::ReadLineInfo() {
// Final step of last DW_LNS_copy / special opcode.
info_.discriminator = 0;
info_.basic_block = false;
info_.prologue_end = false;
info_.epilogue_begin = false;
// Final step of DW_LNE_end_sequence.
info_.end_sequence = false;
string_view data = remaining_;
wh... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq $0x0, 0xa4(%rdi)
movups 0x78(%rdi), %xmm0
movaps %xmm0, (%rsp)
movq (%rsp), %rax
testq %rax, %rax
je 0xbb4b0
leaq 0xa0(%rbx), %rbp
leaq 0x30(%rbx), %rcx
movq %rcx, 0x40(%rsp)
leaq 0x10(%rbx), %r15
leaq 0x182f8e(%rip)... | /google[P]bloaty/src/dwarf/line_info.cc |
unsigned char bloaty::dwarf::ReadLEB128<unsigned char>(std::basic_string_view<char, std::char_traits<char>>*) | T ReadLEB128(std::string_view* data) {
typedef typename std::conditional<std::is_signed<T>::value, int64_t,
uint64_t>::type Int64Type;
Int64Type val = ReadLEB128Internal(std::is_signed<T>::value, data);
if (val > std::numeric_limits<T>::max() ||
val < std::numeric_limits<... | pushq %rax
movq %rdi, %rsi
xorl %edi, %edi
callq 0xb97aa
cmpq $0x100, %rax # imm = 0x100
jae 0xbb585
popq %rcx
retq
leaq 0x18272d(%rip), %rdi # 0x23dcb9
movl $0x25, %esi
callq 0xa2a0c
| /google[P]bloaty/src/dwarf/dwarf_util.h |
re2::RE2::RE2(char const*) | RE2::RE2(const char* pattern) {
Init(pattern, DefaultOptions);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
movl $0x1, 0x20(%rdi)
movw $0x0, 0x24(%rdi)
movb $0x1, 0x26(%rdi)
movq $0x800000, 0x28(%rdi) # imm = 0x800000
movabsq $0x100000000, ... | /google[P]bloaty/third_party/re2/re2/re2.cc |
re2::RE2::MaxSubmatch(re2::StringPiece const&) | size_type size() const { return size_; } | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jle 0xbce4a
movq (%rdi), %rdx
addq %rdx, %rcx
xorl %eax, %eax
cmpb $0x5c, (%rdx)
jne 0xbce41
incq %rdx
cmpq %rcx, %rdx
jae 0xbce41
movsbl (%rdx), %esi
addl $-0x30, %esi
cmpl %eax, %esi
movl %eax, %edi
cmovgl %esi, %edi
cmpl $0xa, %esi
cmovbl %edi, %eax
incq %rdx
cmpq %rcx, %rdx
jb ... | /google[P]bloaty/third_party/re2/re2/stringpiece.h |
re2::RE2::CheckRewriteString(re2::StringPiece const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const | bool RE2::CheckRewriteString(const StringPiece& rewrite,
std::string* error) const {
int max_token = -1;
for (const char *s = rewrite.data(), *end = s + rewrite.size();
s < end; s++) {
int c = *s;
if (c != '\\') {
continue;
}
if (++s == end) {
*error =... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
jle 0xbe0fc
movq (%rsi), %rcx
addq %rcx, %rax
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpb $0x5c, (%rcx)
jne 0xbe0f2
incq %rcx
cmpq %rax, %rcx
je 0xbe143
movsbl (%rcx), %esi
cmpl $0x5c, %esi
je 0xbe0f2
addl $-0x30, %esi... | /google[P]bloaty/third_party/re2/re2/re2.cc |
re2::runetochar(char*, int const*) | int
runetochar(char *str, const Rune *rune)
{
/* Runes are signed, so convert to unsigned for range check. */
unsigned long c;
/*
* one character sequence
* 00000-0007F => 00-7F
*/
c = *rune;
if(c <= Rune1) {
str[0] = static_cast<char>(c);
return 1;
}
/*
* two character sequence
* 0080-07FF => T2... | movl (%rsi), %ecx
cmpl $0x7f, %ecx
ja 0xc3363
movb %cl, (%rdi)
movl $0x1, %eax
retq
cmpl $0x7ff, %ecx # imm = 0x7FF
ja 0xc3383
movl %ecx, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rdi)
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%rdi)
movl $0x2, %eax
retq
cmpl $0x110000, %ecx # imm = 0x11000... | /google[P]bloaty/third_party/re2/util/rune.cc |
re2::Compiler::AddSuffixRecursive(int, int) | int Compiler::AddSuffixRecursive(int root, int id) {
DCHECK(inst_[root].opcode() == kInstAlt ||
inst_[root].opcode() == kInstByteRange);
Frag f = FindByteRange(root, id);
if (IsNoMatch(f)) {
int alt = AllocInst(1);
if (alt < 0)
return 0;
inst_[alt].InitAlt(root, id);
return alt;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
callq 0xc4d1e
movq %rax, %r12
testl %r12d, %r12d
je 0xc4bdc
movq %r12, %r15
shrq $0x20, %r15
movl %ebx, %r13d
je 0xc4c14
movslq %r12d, %rax
shlq $0x3, %rax
movq 0x38(%r14), %rcx
testb $0x1, %r15b... | /google[P]bloaty/third_party/re2/re2/compile.cc |
re2::Compiler::AddRuneRangeUTF8(int, int, bool) | void Compiler::AddRuneRangeUTF8(Rune lo, Rune hi, bool foldcase) {
if (lo > hi)
return;
// Pick off 80-10FFFF as a common special case
// that can bypass the slow rune_cache_.
if (lo == 0x80 && hi == 0x10ffff && !reversed_) {
Add_80_10ffff();
return;
}
// Split range into same-length sized ran... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, %esi
jg 0xc50ef
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, %r13d
xorl $0x10ffff, %r13d # imm = 0x10FFFF
movl $0x7f, %r14d
movzbl %cl, %eax
movl %eax, 0x4(%rsp)
movl %esi, %eax
xorl $0x80, %eax
orl %r13d, %eax
jne 0xc4f0... | /google[P]bloaty/third_party/re2/re2/compile.cc |
re2::IsAnchorStart(re2::Regexp**, int) | static bool IsAnchorStart(Regexp** pre, int depth) {
Regexp* re = *pre;
Regexp* sub;
// The depth limit makes sure that we don't overflow
// the stack on a deeply nested regexp. As the comment
// above says, IsAnchorStart is conservative, so returning
// a false negative is okay. The exact limit is somewh... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
cmpl $0x4, %esi
setge %cl
orb %al, %cl
je 0xc59f7
xorl %eax, %eax
jmp 0xc5b22
movq %rdi, %r14
movzbl (%rbx), %eax
cmpl $0x12, %eax
je 0xc5ad3
movl %esi, %ebp
cmpl $0xb, %eax
je 0xc5ac6
cmpl $0x... | /google[P]bloaty/third_party/re2/re2/compile.cc |
re2::Compiler::Finish() | Prog* Compiler::Finish() {
if (failed_)
return NULL;
if (prog_->start() == 0 && prog_->start_unanchored() == 0) {
// No possible matches; keep Fail instruction only.
ninst_ = 1;
}
// Hand off the array to Prog.
prog_->inst_ = std::move(inst_);
prog_->size_ = ninst_;
prog_->Optimize();
pro... | cmpb $0x0, 0x20(%rdi)
je 0xc5d09
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpl $0x0, 0x8(%r14)
jne 0xc5d29
cmpl $0x0, 0xc(%r14)
jne 0xc5d29
movl $0x1, 0x40(%rbx)
movq 0x38(%rbx), %rax
movq $0x0, 0x38(%rbx)
movq 0x60(%r14), %rdi
movq %rax, 0x60(%r14)
testq %rdi, %rdi
je... | /google[P]bloaty/third_party/re2/re2/compile.cc |
re2::DFA::~DFA() | DFA::~DFA() {
delete q0_;
delete q1_;
ClearCache();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0xc6f2e
movq %r14, %rdi
callq 0xc92ca
movq %r14, %rdi
callq 0x6d670
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0xc6f47
movq %r14, %rdi
callq 0xc92ca
movq %r14, %rdi
callq 0x6d670
movq %rbx, %rdi
callq 0xc6fa4
leaq 0xb0(%rbx), %rdi... | /google[P]bloaty/third_party/re2/re2/dfa.cc |
re2::DFA::RunWorkqOnEmptyString(re2::DFA::Workq*, re2::DFA::Workq*, unsigned int) | void clear() {
size_ = 0;
} | movl $0x0, (%rdx)
movl 0x28(%rdx), %eax
movl %eax, 0x30(%rdx)
cmpl $0x0, (%rsi)
je 0xc7aac
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rsi), %r13
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl (%r13), %edx
... | /google[P]bloaty/third_party/re2/util/sparse_set.h |
re2::DFA::RunStateOnByte(re2::DFA::State*, int) | DFA::State* DFA::RunStateOnByte(State* state, int c) {
//mutex_.AssertHeld();
if (state <= SpecialStateMax) {
if (state == FullMatchState) {
// It is convenient for routines like PossibleMatchRange
// if we implement RunStateOnByte for FullMatchState:
// once you get into this state you never... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
cmpq $0x2, %rsi
jbe 0xc7cde
movl %edx, %r14d
movq %rdi, %r15
movq (%rdi), %rax
cmpl $0x100, %edx # imm = 0x100
jne 0xc7d2c
movl 0x14(%rax), %eax
jmp 0xc7d37
testq %rbx, %rbx
je 0xc7d9b... | /google[P]bloaty/third_party/re2/re2/dfa.cc |
re2::Prog::GetDFA(re2::Prog::MatchKind) | DFA* Prog::GetDFA(MatchKind kind) {
// For a forward DFA, half the memory goes to each DFA.
// However, if it is a "many match" DFA, then there is
// no counterpart with which the memory must be shared.
//
// For a reverse DFA, all the memory goes to the
// "longest match" DFA, because RE2 never does revers... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x3, %esi
je 0xc8653
testl %esi, %esi
jne 0xc86b1
leaq 0x194(%rbx), %rdi
leaq 0x8(%rsp), %rax
movq %rbx, (%rax)
leaq 0x7(%rsp), %rcx
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq 0x4ac962(%rip), %r14 # 0x574f88
movq %rdx, %fs... | /google[P]bloaty/third_party/re2/re2/dfa.cc |
re2::DFA::BuildAllStates(std::function<void (int const*, bool)> const&) | int DFA::BuildAllStates(const Prog::DFAStateCallback& cb) {
if (!ok())
return 0;
// Pick out start state for unanchored search
// at beginning of text.
RWLocker l(&cache_mutex_);
SearchParams params(StringPiece(), StringPiece(), &l);
params.anchored = false;
if (!AnalyzeSearch(¶ms) ||
param... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
xorl %ebx, %ebx
cmpb $0x0, 0xc(%rdi)
jne 0xc8d34
movq %rsi, %r15
movq %rdi, %r14
addq $0x68, %rdi
movq %rdi, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
callq 0x6d630
testl %eax, %eax
jne 0xc8d48
xorps %xmm0, %xmm0
leaq 0x... | /google[P]bloaty/third_party/re2/re2/dfa.cc |
re2::SparseArray<re2::NFA::Thread*>::~SparseArray() | SparseArray<Value>::~SparseArray() {
DebugCheckInvariants();
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0xcc148
callq 0x6d670
movq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xcc15e
callq 0x6d670
movq $0x0, 0x10(%rbx)
popq %rbx
retq
| /google[P]bloaty/third_party/re2/util/sparse_array.h |
re2::Regexp::ParseState::FinishRegexp(re2::Regexp*) | Regexp* Regexp::ParseState::FinishRegexp(Regexp* re) {
if (re == NULL)
return NULL;
re->down_ = NULL;
if (re->op_ == kRegexpCharClass && re->ccb_ != NULL) {
CharClassBuilder* ccb = re->ccb_;
re->ccb_ = NULL;
re->cc_ = ccb->GetCharClass();
delete ccb;
}
return re;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0xccfe1
movq $0x0, 0x10(%rbx)
cmpb $0x14, (%rbx)
jne 0xccfe1
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0xccfe1
movq $0x0, 0x20(%rbx)
movq %r14, %rdi
callq 0xc0ea4
movq %rax, 0x18(%rbx)
leaq 0x10(%r14), %rdi
callq 0xc1162
movq %r14, %rdi
callq 0x6d670
... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::MaybeConcatString(int, re2::Regexp::ParseFlags) | bool Regexp::ParseState::MaybeConcatString(int r, ParseFlags flags) {
Regexp* re1;
Regexp* re2;
if ((re1 = stacktop_) == NULL || (re2 = re1->down_) == NULL)
return false;
if (re1->op_ != kRegexpLiteral && re1->op_ != kRegexpLiteralString)
return false;
if (re2->op_ != kRegexpLiteral && re2->op_ != kR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rbx
testq %rbx, %rbx
je 0xcd1e6
movq 0x10(%rbx), %r12
testq %r12, %r12
je 0xcd1e6
movb (%rbx), %al
leal -0x3(%rax), %ecx
cmpb $0x1, %cl
ja 0xcd1e6
movl %edx, %ebp
movb (%r12), %cl
leal -0x3(%rcx), %edx
cmpb $0x1, %dl
ja 0xcd1... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::PushLiteral(int) | bool Regexp::ParseState::PushLiteral(Rune r) {
// Do case folding if needed.
if ((flags_ & FoldCase) && CycleFoldRune(r) != r) {
Regexp* re = new Regexp(kRegexpCharClass, flags_ & ~FoldCase);
re->ccb_ = new CharClassBuilder;
Rune r1 = r;
do {
if (!(flags_ & NeverNL) || r != '\n') {
re-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl (%rdi), %r15d
testb $0x1, %r15b
je 0xcd30b
movl %ebp, %edi
callq 0xcd2b8
cmpl %ebp, %eax
jne 0xcd376
btl $0xb, %r15d
setae %al
cmpl $0xa, %ebp
setne %cl
orb %al, %cl
jne 0xcd33f
movl $0x28, %edi
callq 0x6df20
movq %rax, %r14
mov... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::RepetitionWalker::ShortVisit(re2::Regexp*, int) | int RepetitionWalker::ShortVisit(Regexp* re, int parent_arg) {
// This should never be called, since we use Walk and not
// WalkExponential.
LOG(DFATAL) << "RepetitionWalker::ShortVisit called";
return 0;
} | pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x1719b0(%rip), %rsi # 0x23f059
movq %rsp, %rdi
movl $0x231, %edx # imm = 0x231
callq 0xbee08
leaq 0x8(%rsp), %rdi
leaq 0x1719f6(%rip), %rsi # 0x23f0b8
movl $0x23, %edx
callq 0x6d7c0
movq %rsp, %rdi
callq 0xbeebe
xorl %eax, %eax
addq $0x180, %r... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::DoLeftParen(re2::StringPiece const&) | bool Regexp::ParseState::DoLeftParen(const StringPiece& name) {
Regexp* re = new Regexp(kLeftParen, flags_);
re->cap_ = ++ncap_;
if (name.data() != NULL)
re->name_ = new std::string(name);
return PushRegexp(re);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x6df20
movq %rax, %rbx
movl (%r14), %edx
movq %rax, %rdi
movl $0x16, %esi
callq 0xbf384
movl 0x28(%r14), %eax
incl %eax
movl %eax, 0x28(%r14)
movl %eax, 0x18(%rbx)
movq (%r15), %r13
testq %r13, %r13
je 0xcd8f4... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::ParseCCCharacter(re2::StringPiece*, int*, re2::StringPiece const&, re2::RegexpStatus*) | bool Regexp::ParseState::ParseCCCharacter(StringPiece* s, Rune *rp,
const StringPiece& whole_class,
RegexpStatus* status) {
if (s->size() == 0) {
status->set_code(kRegexpMissingBracket);
status->set_error_arg(whole_class);
... | cmpq $0x0, 0x8(%rsi)
je 0xcf04f
movq (%rsi), %rax
cmpb $0x5c, (%rax)
jne 0xcf061
movl 0x2c(%rdi), %ecx
movq %rsi, %rdi
movq %rdx, %rsi
movq %r8, %rdx
jmp 0xcf077
movl $0x5, (%r8)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%r8)
xorl %eax, %eax
retq
pushq %rax
movq %rdx, %rdi
movq %r8, %rdx
callq 0xcedbb
testl %eax, %eax
set... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Prog::DumpUnanchored[abi:cxx11]() | std::string Prog::DumpUnanchored() {
if (did_flatten_)
return FlattenedProgToString(this, start_unanchored_);
Workq q(size_);
AddToQueue(&q, start_unanchored_);
return ProgToString(this, &q);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x3(%rsi)
jne 0xd0f9c
movl 0xc(%r14), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd0cc6
jmp 0xd0ff8
movl 0x10(%r14), %esi
movq %rsp, %rdi
callq 0xc9b38
movslq 0xc(%r14), %rax
testq %rax, %rax
je 0xd0fe2
movq 0x20(%rsp), %rcx
testq %rcx, ... | /google[P]bloaty/third_party/re2/re2/prog.cc |
DecodeLDR | static DecodeStatus DecodeLDR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Cond;
unsigned Rn = fieldFromInstruction_4(Val, 16, 4);
unsigned Rt = fieldFromInstruction_4(Val, 12, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
Rm |= (f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x8(%rsp)
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
movl %esi, %r14d
shrl $0xc, %r14d
andl $0xf, %r14d
movl %esi, %eax
andl $0xf, %eax
movq %rax, 0x10(%rsp)
movl %esi, %r12d
shrl $0x17, %r12d
movl $0x1, %eax
andl %ea... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeVCVTQ | static DecodeStatus DecodeVCVTQ(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Vm, imm, cmode, op;
unsigned Vd = (fieldFromInstruction_4(Insn, 12, 4) << 0);
Vd |= (fieldFromInstruction_4(Insn, 22, 1) << 4);
Vm = (fieldFromInstruction_4(Insn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
shrl $0x5, %r15d
andl $0x1, %r15d
movl %esi, %eax
andl $0x380f00, %eax # imm = 0x380F00
cmpl $0xf00, %eax # imm = 0xF00
jne 0xe37bb
xorl %r14d, %r14d
testl %r15d, %r15d
jne 0xe3831
movq %rbx, %rdi
... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeThumbBLTargetOperand | static DecodeStatus DecodeThumbBLTargetOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
// Val is passed in as S:J1:J2:imm10:imm11
// Note no trailing zero after imm11. Also the J1 and J2 values are from
// the encoded instruction. So here change to I1 and I2 values via:
// I1 = NOT(... | movl %esi, %eax
shrl %eax
xorl %esi, %eax
movl %esi, %ecx
shrl $0x2, %ecx
xorl %esi, %ecx
andl $0x9fffff, %esi # imm = 0x9FFFFF
andl $0x400000, %eax # imm = 0x400000
orl %esi, %eax
andl $0x200000, %ecx # imm = 0x200000
orl %eax, %ecx
shll $0x8, %ecx
sarl $0x7, %ecx
xorl $0xc00000, %ecx #... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeT2AddrModeImm12 | static DecodeStatus DecodeT2AddrModeImm12(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
unsigned imm = fieldFromInstruction_4(Val, 0, 12);
// Thumb stores cannot use PC as dest register.
switch (MC... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0xd, %r14d
andl $0xf, %r14d
callq 0xd7224
addl $0xfffff5cb, %eax # imm = 0xFFFFF5CB
cmpl $0x15, %eax
ja 0xe561d
movl $0x204001, %ecx # imm = 0x204001
btl %eax, %ecx
jae 0xe561d
xorl %eax, %eax
cmpl $0xf, %r14d
je 0xe56... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeAddrMode6Operand | static DecodeStatus DecodeAddrMode6Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned align = fieldFromInstruction_4(Val, 4, 2);
if (!Check(&S, DecodeGPRRegisterClass(Inst, Rm, Address, D... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
andl $0xf, %eax
shrl $0x4, %ebx
andl $0x3, %ebx
leaq 0x1843fc(%rip), %rcx # 0x26aab0
movzwl (%rcx,%rax,2), %esi
callq 0xd72a7
movl $0x4, %esi
movl %ebx, %ecx
shll %cl, %esi
testl %ebx, %ebx
cmovel %ebx, %esi
movq %r14, %rdi
callq 0xd72d... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
printRegisterList | static void printRegisterList(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned i, e;
#ifndef CAPSTONE_DIET
uint8_t access = 0;
#endif
SStream_concat0(O, "{");
#ifndef CAPSTONE_DIET
if (MI->csh->detail) {
access = get_op_access(MI->csh, MCInst_getOpcode(MI), MI->ac_idx);
}
#endif
for (i = OpNum, e = MCInst_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x18199e(%rip), %rsi # 0x272ade
movq %rdx, %rdi
callq 0xd72fa
movq 0x320(%rbx), %r13
xorl %ebp, %ebp
cmpl $0x0, 0x60(%r13)
je 0xf1182
movq %rbx, %rdi
callq 0xd7224
movzbl 0x32... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMInstPrinter.c |
printVectorListTwoAllLanes | static void printVectorListTwoAllLanes(MCInst *MI, unsigned OpNum,
SStream *O, MCRegisterInfo *MRI)
{
#ifndef CAPSTONE_DIET
uint8_t access;
#endif
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
unsigned Reg0 = MCRegisterInfo_getSubReg(MRI, Reg, ARM_dsub_0);
unsigned Reg1 = MCRegisterInfo_getSubReg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0xd722b
movq %rax, %rdi
callq 0xd7274
movl %eax, %ebp
movq %r12, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0xdb6de
movl %eax, %r15d
movq %r12, %rdi
movl %ebp, %esi
movl $0x... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMInstPrinter.c |
printAddrModeTBB | static void printAddrModeTBB(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
MCOperand *MO2 = MCInst_getOperand(MI, Op+1);
SStream_concat0(O, "[");
set_mem_access(MI, true);
printRegName(MI->csh, O, MCOperand_getReg(MO1));
if (MI->csh->detail)
MI->flat_insn->detail->arm.operan... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0xd722b
movq %rax, %r12
movq %rbx, %rdi
movl $0x1, %esi
callq 0xd722b
movq %rax, %r15
leaq 0x1bc9ae(%rip), %rsi # 0x2b220f
movq %r14, %rdi
callq 0xd72fa
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf6073
movq 0x32... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMInstPrinter.c |
DecodeCacheOpR6 | static DecodeStatus DecodeCacheOpR6(MCInst *Inst,
unsigned Insn, uint64_t Address, MCRegisterInfo *Decoder)
{
int Offset = fieldFromInstruction(Insn, 7, 9);
unsigned Hint = fieldFromInstruction(Insn, 16, 5);
unsigned Base = fieldFromInstruction(Insn, 21, 5);
Base = getReg(Decoder, Mips_GPR32RegClassID, Base);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r15d
shrl $0x7, %r15d
andl $0x1ff, %r15d # imm = 0x1FF
movl %esi, %r12d
shrl $0x10, %r12d
andl $0x1f, %r12d
movq %rdx, %rdi
movl $0x8, %esi
callq 0xdb73e
movq (%rax), %rax
shrl $0x14, %r14d
andl $0x3e, %r14d
mo... | /google[P]bloaty/third_party/capstone/arch/Mips/MipsDisassembler.c |
Mips_map_register | mips_reg Mips_map_register(unsigned int r)
{
// for some reasons different Mips modes can map different register number to
// the same Mips register. this function handles the issue for exposing Mips
// operands by mapping internal registers to 'public' register.
static const unsigned int map[] = { 0,
MIPS_REG_AT... | xorl %eax, %eax
cmpl $0x189, %edi # imm = 0x189
ja 0x121345
movl %edi, %eax
leaq 0x1c9e4e(%rip), %rcx # 0x2eb190
movl (%rcx,%rax,4), %eax
retq
nop
| /google[P]bloaty/third_party/capstone/arch/Mips/MipsMapping.c |
printMemRegReg | static void printMemRegReg(MCInst *MI, unsigned OpNo, SStream *O)
{
// When used as the base register, r0 reads constant zero rather than
// the value contained in the register. For this reason, the darwin
// assembler requires that we print r0 as 0 (no r) when used as the base.
if (MCOperand_getReg(MCInst_getOper... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xd722b
movq %rax, %rdi
callq 0xd7274
cmpl $0x55, %eax
jne 0x136210
leaq 0x1bfa70(%rip), %rsi # 0x2f5c76
movq %rbx, %rdi
callq 0xd72fa
jmp 0x13621d
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x12411c
leaq 0x258333(%rip)... | /google[P]bloaty/third_party/capstone/arch/PowerPC/PPCInstPrinter.c |
set_mem_access | static void set_mem_access(MCInst *MI, bool status)
{
if (MI->csh->detail != CS_OPT_ON)
return;
MI->csh->doing_mem = status;
if (status) {
MI->flat_insn->detail->ppc.operands[MI->flat_insn->detail->ppc.op_count].type = PPC_OP_MEM;
MI->flat_insn->detail->ppc.operands[MI->flat_insn->detail->ppc.op_count].mem.b... | movq 0x320(%rdi), %rax
cmpl $0x3, 0x60(%rax)
jne 0x1365c4
movb %sil, 0x6c(%rax)
movq 0x310(%rdi), %rax
movq 0xf0(%rax), %rax
testb %sil, %sil
je 0x1365c1
movzbl 0x61(%rax), %ecx
leaq (%rcx,%rcx,2), %rcx
movl $0x3, 0x68(%rax,%rcx,8)
movq 0x310(%rdi), %rax
movq 0xf0(%rax), %rax
movzbl 0x61(%rax), %ecx
leaq (%rcx,%rcx,2),... | /google[P]bloaty/third_party/capstone/arch/PowerPC/PPCInstPrinter.c |
PPC_map_register | ppc_reg PPC_map_register(unsigned int r)
{
static unsigned int map[] = { 0,
0, PPC_REG_CARRY, PPC_REG_CTR, 0, PPC_REG_LR,
0, PPC_REG_VRSAVE, PPC_REG_R0, 0, PPC_REG_CR0,
PPC_REG_CR1, PPC_REG_CR2, PPC_REG_CR3, PPC_REG_CR4, PPC_REG_CR5,
PPC_REG_CR6, PPC_REG_CR7, PPC_REG_CTR, PPC_REG_F0, PPC_REG_F1,
PPC_REG_F2, ... | xorl %eax, %eax
cmpl $0x135, %edi # imm = 0x135
ja 0x136742
movl %edi, %eax
leaq 0x1bfe61(%rip), %rcx # 0x2f65a0
movl (%rcx,%rax,4), %eax
retq
| /google[P]bloaty/third_party/capstone/arch/PowerPC/PPCMapping.c |
set_mem_access | static void set_mem_access(MCInst *MI, bool status)
{
if (MI->csh->detail != CS_OPT_ON)
return;
MI->csh->doing_mem = status;
if (status) {
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_count].type = SPARC_OP_MEM;
MI->flat_insn->detail->sparc.operands[MI->flat_insn->detail->sparc.op_co... | movq 0x320(%rdi), %rax
cmpl $0x3, 0x60(%rax)
jne 0x1558a6
movb %sil, 0x6c(%rax)
movq 0x310(%rdi), %rax
movq 0xf0(%rax), %rax
testb %sil, %sil
je 0x1558a3
movzbl 0x60(%rax), %ecx
shll $0x4, %ecx
movl $0x3, 0x68(%rax,%rcx)
movq 0x310(%rdi), %rax
movq 0xf0(%rax), %rax
movzbl 0x60(%rax), %ecx
shll $0x4, %ecx
movb $0x0, 0x7... | /google[P]bloaty/third_party/capstone/arch/Sparc/SparcInstPrinter.c |
decodeBDAddr12Operand | static DecodeStatus decodeBDAddr12Operand(MCInst *Inst, uint64_t Field,
const unsigned *Regs)
{
uint64_t Base = Field >> 12;
uint64_t Disp = Field & 0xfff;
//assert(Base < 16 && "Invalid BDAddr12");
MCOperand_CreateReg0(Inst, Base == 0 ? 0 : Regs[Base]);
MCOperand_CreateImm0(Inst, Disp);
return MCDisassembler... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
cmpq $0x1000, %rbx # imm = 0x1000
jb 0x15b103
movq %rbx, %rax
shrq $0xc, %rax
movl (%rdx,%rax,4), %esi
andl $0xfff, %ebx # imm = 0xFFF
movq %r14, %rdi
callq 0xd72a7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq ... | /google[P]bloaty/third_party/capstone/arch/SystemZ/SystemZDisassembler.c |
printCond4Operand | static void printCond4Operand(MCInst *MI, int OpNum, SStream *O)
{
static const char *const CondNames[] = {
"o", "h", "nle", "l", "nhe", "lh", "ne",
"e", "nlh", "he", "nl", "le", "nh", "no"
};
uint64_t Imm = MCOperand_getImm(MCInst_getOperand(MI, OpNum));
// assert(Imm > 0 && Imm < 15 && "Invalid condition");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0xd722b
movq %rax, %rdi
callq 0xd727c
movq %rax, %r14
leaq 0x2f7a58(%rip), %rax # 0x453b24
movslq -0x4(%rax,%r14,4), %rsi
addq %rax, %rsi
movq %r15, %rdi
callq 0xd72fa
movq 0x320(%rbx), %rax
cmpl $0x0, 0x60(%rax)
je 0x15c0fb
movq 0x310(%rbx), %ra... | /google[P]bloaty/third_party/capstone/arch/SystemZ/SystemZInstPrinter.c |
Decode2OpInstructionFail | static DecodeStatus Decode2OpInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
const void *Decoder)
{
// Try and decode as a 3R instruction.
unsigned Opcode = fieldFromInstruction_4(Insn, 11, 5);
switch (Opcode) {
case 0x0:
MCInst_setOpcode(Inst, XCore_STW_2rus);
return Decode2RUSInstruction(I... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
shrl $0xb, %eax
andl $0x1f, %eax
cmpl $0x19, %eax
ja 0x15e3d4
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x326357(%rip), %rcx # 0x4846b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movl $0xe6, %esi
jmp 0x15e486
movq %r14, %rdi
movl ... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreDisassembler.c |
printOperand | static void printOperand(MCInst *MI, int OpNum, SStream *O)
{
if (OpNum >= MI->size)
return;
_printOperand(MI, MCInst_getOperand(MI, OpNum), O);
} | movzbl 0x4(%rdi), %eax
cmpl %esi, %eax
jle 0x15f34e
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0xd722b
movq %rax, %r15
movq %rax, %rdi
callq 0xd725c
testb %al, %al
je 0x15f2af
movq %r15, %rdi
callq 0xd7274
movl %eax, %r15d
leal -0x1(%r15), %eax
leaq 0x326800(%rip), %rcx # 0x485a50
movzbl ... | /google[P]bloaty/third_party/capstone/arch/XCore/XCoreInstPrinter.c |
compare_nof_true_bits | static int DECL_SPEC compare_nof_true_bits(const void *aptr, const void *bptr)
{
uint a = ((const opcode_struct*)aptr)->mask;
uint b = ((const opcode_struct*)bptr)->mask;
a = ((a & 0xAAAA) >> 1) + (a & 0x5555);
a = ((a & 0xCCCC) >> 2) + (a & 0x3333);
a = ((a & 0xF0F0) >> 4) + (a & 0x0F0F);
a = ((a & 0xFF00) >> 8... | movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %eax
movl %ecx, %esi
shrl %esi
movl $0x5555, %edx # imm = 0x5555
andl %edx, %esi
andl %edx, %ecx
addl %esi, %ecx
movl %ecx, %edi
shrl $0x2, %edi
movl $0x3333, %esi # imm = 0x3333
andl %esi, %edi
andl %esi, %ecx
addl %edi, %ecx
movl %ecx, %r8d
shrl $0x4, %r8d
movl... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_addx_rr_16 | static void d68000_addx_rr_16(m68k_info *info)
{
build_rr(info, M68K_INS_ADDX, 2, 0);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x6, %esi
callq 0xd721d
movb $0x2, 0x118(%rbx)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, 0x110(%rbx)
movl $0x1, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
incl %edx
movl %edx, 0x30(%rbx)
movl %eax, 0x9c(%rb... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_asr_r_16 | static void d68000_asr_r_16(m68k_info *info)
{
build_r(info, M68K_INS_ASR, 2);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0xa, %esi
callq 0xd721d
movb $0x2, 0x118(%rbx)
movabsq $0x200000001, %rax # imm = 0x200000001
movq %rax, 0x110(%rbx)
movl $0x1, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
shrl $0x9, %edx
andl $0x7, %edx
incl %edx
movl %edx, 0x30(%rbx)
mov... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_asl_r_8 | static void d68000_asl_r_8(m68k_info *info)
{
build_r(info, M68K_INS_ASL, 1);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x9, %esi
callq 0xd721d
movb $0x2, 0x118(%rbx)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x110(%rbx)
movl $0x1, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
shrl $0x9, %edx
andl $0x7, %edx
incl %edx
movl %edx, 0x30(%rbx)
mov... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_dbra | static void d68000_dbra(m68k_info *info)
{
build_dbxx(info, M68K_INS_DBRA, 0, make_int_16(read_imm_16(info)));
} | movl 0x20(%rdi), %eax
movl %eax, %edx
subl 0x10(%rdi), %edx
andl 0x2c(%rdi), %edx
leaq 0x2(%rdx), %rsi
movl $0xaaaa, %ecx # imm = 0xAAAA
cmpq %rsi, 0x8(%rdi)
jb 0x161adf
movq (%rdi), %rcx
movzwl (%rcx,%rdx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
addl $0x2, %eax
movl %eax, 0x20(%rdi)
movswl %cx, %edx
andl $0xff... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
d68000_lsl_r_32 | static void d68000_lsl_r_32(m68k_info *info)
{
build_r(info, M68K_INS_LSL, 4);
} | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl $0x117, %esi # imm = 0x117
callq 0xd721d
movb $0x2, 0x118(%rbx)
movabsq $0x400000001, %rax # imm = 0x400000001
movq %rax, 0x110(%rbx)
movl $0x1, %eax
movl %eax, 0x64(%rbx)
movl 0x24(%rbx), %ecx
movl %ecx, %edx
shrl $0x9, %edx
andl $0x7, %edx
incl %ed... | /google[P]bloaty/third_party/capstone/arch/M68K/M68KDisassembler.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.