name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::HasNewFatalFailureHelper::~HasNewFatalFailureHelper() | HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
original_reporter_);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x3ddd7(%rip), %rax # 0xab1c0
movq %rax, (%rdi)
callq 0x4e0f2
movq 0x10(%rbx), %rbx
movl $0x90, %edi
addq 0x3f9df(%rip), %rdi # 0xacde0
callq 0x76012
movq %rbx, (%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x174ef
nop
| /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-test-part.cc |
testing::internal::(anonymous namespace)::FailureTest::~FailureTest() | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3d04b(%rip), %rax # 0xab740
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x6e710
movq (%rax), %rsi
incq %rsi
callq 0xf5e0
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x6e728
movq (%rax), %rsi
incq %rsi
callq 0xf5e0
leaq 0x3c7d9... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3cf55(%rip), %rax # 0xab798
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x6e85e
movq (%rax), %rsi
incq %rsi
callq 0xf5e0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x6e876
movq (%rax), %rsi
incq %rsi
callq 0xf5e0
movq 0x8(%rb... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
bool testing::internal::ParseStringFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ParseStringFlag(const char* str, const char* flag, String* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
*valu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
xorl %edx, %edx
callq 0x6492d
movq %rax, %r14
testq %rax, %rax
je 0x6ed1a
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xf260
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xfaa0
testq %r14, %r14
setne %al
popq %rbx
popq %r14
popq %r1... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x51f2e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xf260
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf700
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x26c82
movq 0x8(%r... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [100]>(char const (&) [100]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x51f2e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xf260
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf700
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x26c82
movq 0x8(%r... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [13]>(char const (&) [13]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x51f2e
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0xf260
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf700
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x26c82
movq 0x8(%r... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest.h |
testing::Test* testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testing::Test* (testing::internal::TestFactoryBase::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x4e0f2
movq 0x3c2f3(%rip), %rax # 0xacde0
addq %r15, %r14
cmpb $0x1, 0x258(%rax)
jne 0x70b19
testb $0x1, %r12b
je 0x70b07
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
c... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(premature_exit_filepath ?
premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the f... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x11b0e(%rip), %r15 # 0x82bd1
cmovneq %rsi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r15, %rdi
callq 0xf260
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x17d58
cmpq $0x0, 0x8(%r14)
je 0x71118
leaq 0xef4... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::StreamingListener(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&) | StreamingListener(const std::string& host, const std::string& port)
: socket_writer_(new SocketWriter(host, port)) {
Start();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3a43a(%rip), %rax # 0xab9d8
movq %rax, (%rdi)
movl $0x50, %edi
callq 0xf5b0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x73aa0
movq %r15, 0x8(%rbx)
movq %rbx, %rdi
callq 0x73b52
a... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::GetNextRandomSeed(int) | inline int GetNextRandomSeed(int seed) {
GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
<< "Invalid random seed " << seed << " - must be in [1, "
<< kMaxRandomSeed << "].";
const int next_seed = seed + 1;
return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
} | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax # imm = 0x1869F
jb 0x718cd
leaq 0x12381(%rip), %rdx # 0x83bba
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x96, %ecx
callq 0x6c1c8
movq 0x3a784(%rip), %rdi # 0xabfd8
leaq 0x12706(%rip), %rsi # 0x83f61
movl $0x... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-internal-inl.h |
void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*) | void ShuffleRange(internal::Random* random, int begin, int end,
std::vector<E>* v) {
const int size = static_cast<int>(v->size());
GTEST_CHECK_(0 <= begin && begin <= size)
<< "Invalid shuffle range start " << begin << ": must be in range [0, "
<< size << "].";
GTEST_CHECK_(begin <= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x2, %r15
testl %esi, %esi
js 0x71a34
cmpl %ebp, %r15d
jge 0x71acd
leaq 0x1217f(%rip), %rdx # 0x83bba
leaq 0x4(%rsp), %rdi
movl $... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbx
subq $0xf0, %rsp
leaq 0x388fd(%rip), %rax # 0xab4a0
movq %rax, (%rdi)
cmpl $-0x1, 0x34(%rdi)
jne 0x72bbd
addq $0x10, %rdi
addq $0xf0, %rsp
popq %rbx
jmp 0x720e6
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x108f0(%rip), %rsi # 0x834c0
leaq 0x108fc(%rip), %rdx # 0x834d3
leaq 0xd0(%rsp), %rdi... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-death-test.cc |
testing::internal::StreamingListener::OnTestCaseEnd(testing::TestSuite const&) | void OnTestCaseEnd(const TestCase& test_case) override {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
"&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
"ms");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x732a2
leaq 0x8139(%rip), %rcx # 0x7ca00
leaq 0x9db6(%rip), %rsi # 0x7e684
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xb8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8119(%rip), %rax ... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" +
FormatBool(unit_test.Passed()) + "&elapsed_time=" +
StreamableToString(unit_test.elapsed_time()) + "ms");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x70ff0
leaq 0x7d7c(%rip), %rcx # 0x7ca00
leaq 0x99f9(%rip), %rsi # 0x7e684
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xb8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7d5c(%rip), %rax... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&) | void OnTestProgramEnd(const UnitTest& unit_test) override {
// Note that Google Test current only report elapsed time for each
// test iteration, not for the entire test program.
SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
// Notify the streaming server to stop.
socket_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x70ff0
leaq 0x79c6(%rip), %rcx # 0x7ca00
leaq 0x9643(%rip), %rsi # 0x7e684
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x79aa(%rip), %rax # 0x7ca01
leaq 0x9627(%rip), %rd... | /hellige[P]ccs-cpp/external/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | MatcherBase& operator=(MatcherBase&& other) {
if (this == &other) return *this;
Destroy();
vtable_ = other.vtable_;
buffer_ = other.buffer_;
other.vtable_ = nullptr;
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x756d1
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x756b9
cmpq $0x0, 0x18(%rax)
je 0x756b9
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x756b9
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rax
movq %rax, 0x... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest-matchers.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbx
subq $0x10, %rsp
leaq 0x92(%rip), %rsi # 0x77a82
leaq 0xc(%rsp), %rdi
callq 0xfac0
testl %eax, %eax
je 0x77a63
movl %eax, %ebx
leaq 0x1b62(%rip), %rdx # 0x79569
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x706, %ecx # imm = 0x706
callq 0x6c1c8
movq 0x345b6(%rip), %rdi # 0xabfd8
lea... | /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/internal/gtest-port.h |
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq 0x8(%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x780e7
testq %rdx, %rdx
je 0x780ea
pushq %rax
movq 0x8(%rax), %rax
movq (%rsi), %rdi
movq %rax, %rsi
callq 0xf620
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest-matchers.h |
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::Match... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq 0x8(%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x781ed
testq %rdx, %rdx
je 0x781f0
pushq %rax
movq 0x8(%rax), %rax
movq (%rsi), %rdi
movq %rax, %rsi
callq 0xf620
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /hellige[P]ccs-cpp/external/googletest/googletest/include/gtest/gtest-matchers.h |
Medicine::Medicine(int, int, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic... | Medicine(int id, int unitePrice, int quantity, bool isSold, const string &name, const string &companyName,
const string &arrivalDate, const string &expireDate) : id(id), unitePrice(unitePrice), quantity(quantity),
isSold(isSold), name(name... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x40(%rsp), %r12
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movb %r8b, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x10(%rdi)
movq (%r9), %rsi
movq 0x8(%r9), %rdx
add... | /JHM69[P]PMS/main.cpp |
Sale::Sale(int, int, 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&, Medicine const&) | Sale(int id, int quantity, const string &date, const string &customerName, const Medicine &medicine) : id(id),
quantity(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r13
movq %rdi, %r15
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rdi)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq... | /JHM69[P]PMS/main.cpp |
void llvm::cl::apply<llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, char [2], llvm::cl::desc, llvm::cl::value_desc, llvm::cl::initializer<char [2]>, llvm::cl::Formatti... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rbx
movq %rsi, %rdi
callq 0x26280
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1003a0
movups (%r12), %xmm0
movups %xmm... | /llvm/Support/CommandLine.h |
llvm::mcdxbc::PSVRuntimeInfo::~PSVRuntimeInfo() | PSVRuntimeInfo() : DXConStrTabBuilder(StringTableBuilder::DXContainer) {
memset((void *)&BaseData, 0, sizeof(dxbc::PSV::v3::RuntimeInfo));
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x7b8, %rdi # imm = 0x7B8
callq 0x1300d4
movq 0x5a8(%rbx), %rdi
leaq 0x5b8(%rbx), %rax
cmpq %rax, %rdi
je 0x32358
callq 0x26150
movq 0x498(%rbx), %rdi
leaq 0x4a8(%rbx), %rax
cmpq %rax, %rdi
je 0x32370
callq 0x26150
movq 0x448(%rbx), %rdi
leaq 0x458(%rbx)... | /llvm/MC/DXContainerPSVInfo.h |
llvm::SmallVectorTemplateBase<llvm::DXContainerYAML::SignatureElement, false>::moveElementsForGrow(llvm::DXContainerYAML::SignatureElement*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rax,%rax,2), %rsi
shlq $0x5, %rsi
addq %rdi, %rsi
callq 0x32af6
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x32aef
movq (%rbx), %rbx
leaq -0x40(%rbx), %r14
shlq $0x5, %rax
leaq (%rax,%rax,2), %r15
movq -0x50(%rb... | /llvm/ADT/SmallVector.h |
llvm::mcdxbc::PSVSignatureElement const* llvm::SmallVectorTemplateCommon<llvm::mcdxbc::PSVSignatureElement, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::mcdxbc::PSVSignatureElement, false>>(llvm::SmallVectorTemplateBase<llvm::mcdxbc::PSVSignatureElement, false>*, llvm::mcdxbc::PSVSignatur... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x3315c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
addq %rax, %... | /llvm/ADT/SmallVector.h |
void llvm::yaml::IO::processKey<llvm::DXContainerYAML::FileHeader, llvm::yaml::EmptyContext>(char const*, llvm::DXContainerYAML::FileHeader&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0x39b5f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33dc8
movq (%rbx), %ra... | /llvm/Support/YAMLTraits.h |
void llvm::SmallVectorImpl<unsigned int>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x3a3b9
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0x3a3ae
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x3a389
leaq 0x10(%r14), %rsi
movl $0x4, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x10f48a
movl 0x8(%r14), %eax
cmpq %rbx, %rax
je 0x3a3ae
shlq $0x2, %ra... | /llvm/ADT/SmallVector.h |
llvm::yaml::IsResizableBase<llvm::MutableArrayRef<unsigned char>, false>::element(llvm::yaml::IO&, llvm::MutableArrayRef<unsigned char>&, unsigned long) | static type &element(IO &io, T &seq, size_t index) {
if (index >= seq.size()) {
io.setError(Twine("value sequence extends beyond static size (") +
Twine(seq.size()) + ")");
return seq[0];
}
return seq[index];
} | pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq 0x8(%rsi), %rcx
cmpq %rdx, %rcx
jbe 0x3a64b
movq %rdx, %rax
addq (%rbx), %rax
jmp 0x3a691
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
leaq 0x11e50a(%rip), %rcx # 0x158b64
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x10(%rdx)
movw $0xb03, 0x20(%rdx) # imm = 0xB... | /llvm/Support/YAMLTraits.h |
llvm::ELFYAML::appendUniqueSuffix[abi:cxx11](llvm::StringRef, llvm::Twine const&) | std::string llvm::ELFYAML::appendUniqueSuffix(StringRef Name,
const Twine &Msg) {
// Do not add a space when a Name is empty.
std::string Ret = Name.empty() ? "" : Name.str() + ' ';
return Ret + (Twine(SuffixStart) + Msg + Twine(SuffixEnd)).str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x3a6cf
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
testq %rsi, %rsi
je 0x3a6ec
leaq (%rsi,%r15), %rdx
leaq 0x20(%rsp), %rdi
callq 0x2b59e
jmp 0x3a6fa
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq ... | /ObjectYAML/ELFEmitter.cpp |
getDefaultLinkSec(unsigned int) | static StringRef getDefaultLinkSec(unsigned SecType) {
switch (SecType) {
case ELF::SHT_REL:
case ELF::SHT_RELA:
case ELF::SHT_GROUP:
case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
case ELF::SHT_LLVM_ADDRSIG:
return ".symtab";
case ELF::SHT_GNU_versym:
case ELF::SHT_HASH:
case ELF::SHT_GNU_HASH:
retur... | leaq 0x10d28c(%rip), %rax # 0x158fb4
movl $0x7, %edx
cmpl $0x6fff4c02, %edi # imm = 0x6FFF4C02
jg 0x4bd4e
leal -0x2(%rdi), %ecx
cmpl $0x9, %ecx
ja 0x4bd83
leaq 0x10cec4(%rip), %rsi # 0x158c08
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
retq
cmpl $0x6ffffffc, %edi # imm = 0x6FFFFFFC
jg 0x4bd7... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)1, true>>::writeSectionContent(llvm::object::Elf_Shdr_Impl<llvm::object::ELFType<(llvm::endianness)1, true>>&, llvm::ELFYAML::NoteSection const&, (anonymous namespace)::ContiguousBlobAccumulator&) | void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
const ELFYAML::NoteSection &Section,
ContiguousBlobAccumulator &CBA) {
if (!Section.Notes)
return;
uint64_t Offset = CBA.tell();
for (const ELFYAML::NoteEntry &NE : *S... | cmpb $0x1, 0x130(%rsi)
jne 0x4cc93
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, 0x20(%rsp)
leaq 0xa8(%rdx), %r12
movq 0xa8(%rdx), %rax
movq %r12, %rdi
callq *0x50(%rax)
movq %rax, 0x10(%rsp)
movq 0xb8(%rbx), %rax
movq %rax, 0x18(%rsp)
movq... | /ObjectYAML/ELFEmitter.cpp |
(anonymous namespace)::ContiguousBlobAccumulator::padToAlignment(unsigned int) | uint64_t padToAlignment(unsigned Align) {
uint64_t CurrentOffset = getOffset();
if (ReachedLimitErr)
return CurrentOffset;
uint64_t AlignedOffset = alignTo(CurrentOffset, Align == 0 ? 1 : Align);
uint64_t PaddingSize = AlignedOffset - CurrentOffset;
if (!checkLimit(PaddingSize))
return ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0xa8(%rdi), %rax
leaq 0xa8(%rdi), %rbx
movq %rbx, %rdi
callq *0x50(%rax)
cmpq $0x0, 0xe0(%r14)
jne 0x4e6da
addq %r15, %rax
addq 0xc8(%r14), %rax
xorl %ecx, %ecx
subq 0xb8(%r14), %rax
setne %cl
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rdx,%rcx,4), %r1... | /ObjectYAML/ELFEmitter.cpp |
llvm::Error llvm::handleErrorImpl<(anonymous namespace)::ELFState<llvm::object::ELFType<(llvm::endianness)1, false>>::reportError(llvm::Error)::'lambda'(llvm::ErrorInfoBase const&)>(std::unique_ptr<llvm::ErrorInfoBase, std::default_delete<llvm::ErrorInfoBase>>, (anonymous namespace)::ELFState<llvm::object::ELFType<(llv... | Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
HandlerT &&Handler, HandlerTs &&... Handlers) {
if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
std:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
leaq 0x20033e(%rip), %rsi # 0x254420
callq *0x30(%rax)
movq (%r12), %r14
movq $0x0, (%r12)
testb %al, %al
je 0x5415a
movq (%r15), %r12
movq (%r14), %rax
movq %rsp, %r15
mov... | /llvm/Support/Error.h |
llvm::yaml::ScalarBitSetTraits<llvm::ELFYAML::ELF_SHF, void>::bitset(llvm::yaml::IO&, llvm::ELFYAML::ELF_SHF&) | void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(SHF_WRITE);
BCase(SHF_ALLOC);
BCase(SHF_EXCLUDE);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11a702
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rcx
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0xfd74d(%rip), %rsi # 0x15bbe9
movq %r14, %rdi
callq *0xc8(%rax)
testb %al... | /ObjectYAML/ELFYAML.cpp |
llvm::ELFYAML::RelrSection::RelrSection() | Chunk(ChunkKind K, bool Implicit) : Kind(K), IsImplicit(Implicit) {} | movl $0x4, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x28(%rdi)
movb %al, 0x30(%rdi)
movb %al, 0x40(%rdi)
movb %al, 0x50(%rdi)
movb %al, 0x68(%rdi)
movb %al, 0x80(%rdi)
movb %al, 0xa0(%rdi)
movb %al, 0xb0(%rdi)
movb %al, 0xc8(%rdi)
movb %al, 0xd8(%rdi)
movb %al, 0xe8(%rdi)
movb %al... | /llvm/ObjectYAML/ELFYAML.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::ELFYAML::Relocation, std::allocator<llvm::ELFYAML::Relocation>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::ELFYAML::Relocation, std::allocator<llvm::ELFYAML::Relocation>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::ELFYAML::Relocation... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x7bafc
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x4, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
llvm::ELFYAML::RelrSection::~RelrSection() | RelrSection() : Section(ChunkKind::Relr) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1c15ef(%rip), %rax # 0x23d5f8
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x130(%rdi)
jne 0x7c03b
movb $0x0, 0x130(%rbx)
movq 0x118(%rbx), %rdi
testq %rdi, %rdi
je 0x7c03b
movq 0x128(%rbx), %rsi
subq %rdi, %rsi
callq 0x260c0
movl $0x138, %esi # imm = 0x138
movq %rbx, %r... | /llvm/ObjectYAML/ELFYAML.h |
llvm::ELFYAML::GnuHashSection::getEntries() const | std::vector<std::pair<StringRef, bool>> getEntries() const override {
return {{"Header", Header.has_value()},
{"BloomFilter", BloomFilter.has_value()},
{"HashBuckets", HashBuckets.has_value()},
{"HashValues", HashValues.has_value()}};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb 0x130(%rsi), %bpl
movb 0x150(%rsi), %r14b
movb 0x170(%rsi), %r15b
movb 0x190(%rsi), %r12b
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x60, %edi
callq 0x26100
movq %rax, (%rbx)
leaq 0x60(%rax), %rcx
movq %rcx, 0x10(%rbx)... | /llvm/ObjectYAML/ELFYAML.h |
llvm::ELFYAML::SymverSection::~SymverSection() | SymverSection() : Section(ChunkKind::Symver) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1be5ad(%rip), %rax # 0x23d710
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x130(%rdi)
jne 0x7f195
movb $0x0, 0x130(%rbx)
movq 0x118(%rbx), %rdi
testq %rdi, %rdi
je 0x7f195
movq 0x128(%rbx), %rsi
subq %rdi, %rsi
callq 0x260c0
movl $0x138, %esi # imm = 0x138
movq %rbx, %r... | /llvm/ObjectYAML/ELFYAML.h |
llvm::ELFYAML::DependentLibrariesSection::getEntries() const | std::vector<std::pair<StringRef, bool>> getEntries() const override {
return {{"Libraries", Libs.has_value()}};
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x130(%rsi), %bpl
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x18, %edi
callq 0x26100
movq %rax, (%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0xe1ba2(%rip), %rdx # 0x163089
movq %rdx, (%rax)
movq $0x9, 0x8(%rax)
movb %bpl, 0x1... | /llvm/ObjectYAML/ELFYAML.h |
void llvm::yaml::IO::processKeyWithDefault<llvm::ELFYAML::ELF_PF, llvm::yaml::EmptyContext>(char const*, llvm::ELFYAML::ELF_PF&, llvm::ELFYAML::ELF_PF const&, bool, llvm::yaml::EmptyContext&) | void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
const bool sameAsDefault = outputting() && Val == DefaultValue;
if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
movl (%r12), %ecx
cmpl %ecx, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %ecx
leaq 0xf(%rs... | /llvm/Support/YAMLTraits.h |
llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int>>, llvm::StringRef, unsigned int, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, unsigned int>>::moveFromOldBuckets... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x85efe
movq (%r15), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq $-0x1, (%rax)
movq $0x0, 0x8(%rax)
addq $0x18, %rax
cmpq %rcx, %rax
jne 0... | /llvm/ADT/DenseMap.h |
void llvm::yaml::IO::processKeyWithDefault<std::vector<llvm::ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry, std::allocator<llvm::ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::SuccessorEntry>>, llvm::yaml::EmptyContext>(char const*, std::optional<std::vector<llvm::ELFYAML::PGOAnalysisMapEntry::PGOBBEntry::Success... | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movb $0x1, 0xf(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r12d
movb 0x18(%r14), %r13b
movq (%rbx), %rax
movq %rbx, %rdi... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::ELFYAML::VernauxEntry, std::allocator<llvm::ELFYAML::VernauxEntry>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::ELFYAML::VernauxEntry, std::allocator<llvm::ELFYAML::VernauxEntry>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::ELFYAML::Ve... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x88bb0
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::processKeyWithDefault<llvm::ELFYAML::ELF_RSS, llvm::yaml::EmptyContext>(char const*, llvm::ELFYAML::ELF_RSS&, llvm::ELFYAML::ELF_RSS const&, bool, llvm::yaml::EmptyContext&) | void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
const bool sameAsDefault = outputting() && Val == DefaultValue;
if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movb (%r15), %cl
cmpb %cl, (%r14)
sete %cl
andb %al, %cl
movq (%rbx), %rax
movzbl %cl, %ecx
leaq 0x7(%rsp), %r8
leaq 0x8(%rsp), %r9
... | /llvm/Support/YAMLTraits.h |
llvm::format_provider<char*, void>::format(char* const&, llvm::raw_ostream&, llvm::StringRef) | static void format(const T &V, llvm::raw_ostream &Stream, StringRef Style) {
size_t N = StringRef::npos;
if (!Style.empty() && Style.getAsInteger(10, N)) {
assert(false && "Style is not a valid integer");
}
llvm::StringRef S = V;
Stream << S.substr(0, N);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x93abc
leaq 0x8(%rsp), %rax
movq %rdx, %rdi
movq %rcx, %rsi
movl $0xa, %edx
movq %rax, %rcx
callq 0x1109d3
movq $-0x1, %r14
testb %al, %al
jne 0x93ac3
movq 0x8(%rsp), %r14
jmp 0x93ac3
movq $-0x1, %r14
movq (%r15), %r1... | /llvm/Support/FormatProviders.h |
(anonymous namespace)::MachOWriter::writeNameList(llvm::raw_ostream&) | void MachOWriter::writeNameList(raw_ostream &OS) {
for (auto NLE : Obj.LinkEdit.NameList) {
if (is64Bit)
writeNListEntry<MachO::nlist_64>(NLE, OS, Obj.IsLittleEndian);
else
writeNListEntry<MachO::nlist>(NLE, OS, Obj.IsLittleEndian);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
movq 0x138(%rax), %r12
movq 0x140(%rax), %r13
cmpq %r13, %r12
je 0x93e7f
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movl (%r12), %edx
movb 0x4(%r12), %r8b
movb 0x5(%r12), %dil
movzwl 0x6(%r12), %ecx
movq 0x8(%r12), %rax
movq ... | /ObjectYAML/MachOEmitter.cpp |
llvm::yaml::ScalarEnumerationTraits<llvm::minidump::OSPlatform, void>::enumeration(llvm::yaml::IO&, llvm::minidump::OSPlatform&) | void yaml::ScalarEnumerationTraits<OSPlatform>::enumeration(IO &IO,
OSPlatform &Plat) {
#define HANDLE_MDMP_PLATFORM(CODE, NAME) \
IO.enumCase(Plat, #NAME, OSPlatform::NAME);
#include "llvm/BinaryFormat/MinidumpConstants... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0xccdfb(%rip), %rsi # 0x16381a
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0x96a32
movl $0x0, (%rbx)
movq (%r14), %rax
movq %r... | /ObjectYAML/MinidumpYAML.cpp |
void llvm::yaml::IO::processKeyWithDefault<llvm::object::OffloadKind, llvm::yaml::EmptyContext>(char const*, std::optional<llvm::object::OffloadKind>&, std::optional<llvm::object::OffloadKind> const&, bool, llvm::yaml::EmptyContext&) | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x1, 0x7(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r13d
movb 0x2(%r14), %r15b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
test... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::WasmYAML::SegmentInfo, std::allocator<llvm::WasmYAML::SegmentInfo>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::WasmYAML::SegmentInfo, std::allocator<llvm::WasmYAML::SegmentInfo>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::WasmYAML::S... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x5, %rcx
testb %al, %al
cmovel %ebp, %ecx
testl %ecx, %ecx
je... | /llvm/Support/YAMLTraits.h |
llvm::WasmYAML::TargetFeaturesSection::~TargetFeaturesSection() | static bool classof(const Section *S) {
auto C = dyn_cast<CustomSection>(S);
return C && C->Name == "target_features";
} | pushq %rbx
movq %rdi, %rbx
leaq 0x198897(%rip), %rax # 0x23db98
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x58, %rdi
callq 0xa5384
leaq 0x1987c0(%rip), %rax # 0x23dad8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa5335
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x260c0
po... | /llvm/ObjectYAML/WasmYAML.h |
llvm::WasmYAML::TypeSection::~TypeSection() | TypeSection() : Section(wasm::WASM_SEC_TYPE) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1983c3(%rip), %rax # 0x23dbb8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x30, %rdi
callq 0xa5836
leaq 0x1982cc(%rip), %rax # 0x23dad8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa5828
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x260c0
movl $0x48... | /llvm/ObjectYAML/WasmYAML.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::WasmYAML::Import, std::allocator<llvm::WasmYAML::Import>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::WasmYAML::Import, std::allocator<llvm::WasmYAML::Import>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::WasmYAML::Import, std::allocato... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xa5e84
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xba2e8ba3, %eax, %... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_ScalarBitSetTraits<llvm::WasmYAML::LimitFlags>::value, void>::type llvm::yaml::yamlize<llvm::WasmYAML::LimitFlags>(llvm::yaml::IO&, llvm::WasmYAML::LimitFlags&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarBitSetTraits<T>::value, void>
yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
bool DoClear;
if ( io.beginBitSetScalar(DoClear) ) {
if ( DoClear )
Val = T();
ScalarBitSetTraits<T>::bitset(io, Val);
io.endBitSetScalar();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
callq *0xc0(%rax)
testb %al, %al
je 0xa9354
cmpb $0x1, 0x7(%rsp)
jne 0xa933d
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa1ca2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xd0(%rax)
addq $0x8, %rsp
popq %r... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::processKey<llvm::WasmYAML::Opcode, llvm::yaml::EmptyContext>(char const*, llvm::WasmYAML::Opcode&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0xa95f3
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa23a2
movq (%rbx), %ra... | /llvm/Support/YAMLTraits.h |
(anonymous namespace)::writeName(llvm::StringRef, llvm::support::endian::Writer) | static void writeName(StringRef StrName, support::endian::Writer W) {
char Name[XCOFF::NameSize];
memset(Name, 0, XCOFF::NameSize);
char SrcName[] = "";
memcpy(Name, StrName.size() ? StrName.data() : SrcName, StrName.size());
ArrayRef<char> NameRef(Name, XCOFF::NameSize);
W.write(NameRef);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
testq %rdx, %rdx
cmovneq %rdi, %rsi
movq %rax, %rdi
callq 0x26080
xorl %r15d, %r15d
leaq 0x6(%rsp), %r14
movb 0x8(%rsp,%r15), %al
movb %al, 0x6(%rsp)
movl $0x1,... | /ObjectYAML/XCOFFEmitter.cpp |
llvm::Error llvm::codeview::SymbolDeserializer::deserializeAs<llvm::codeview::ProcSym>(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>, llvm::codeview::ProcSym&) | static Error deserializeAs(CVSymbol Symbol, T &Record) {
// If we're just deserializing one record, then don't worry about alignment
// as there's nothing that comes after.
SymbolDeserializer S(nullptr, CodeViewContainer::ObjectFile);
if (auto EC = S.visitSymbolBegin(Symbol))
return EC;
if (au... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x17ca92(%rip), %r15 # 0x23e4f0
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
xorl %r12d, %r12d
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movq %r12... | /llvm/DebugInfo/CodeView/SymbolDeserializer.h |
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::DefRangeSubfieldRegisterSym>(llvm::codeview::DefRangeSubfieldRegisterSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10038, %rsp # imm = 0x10038
movq %rdi, %rbx
movzwl (%rdi), %eax
leaq 0x44(%rsp), %rcx
movw $0x2, (%rcx)
movw %ax, 0x2(%rcx)
leaq 0x18(%rsp), %r14
movq %rcx, (%r14)
movq $0x4, 0x8(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x13efbe
leaq 0x38(%rsp), %r12... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
llvm::codeview::CVRecord<llvm::codeview::SymbolKind> llvm::codeview::SymbolSerializer::writeOneSymbol<llvm::codeview::UsingNamespaceSym>(llvm::codeview::UsingNamespaceSym&, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&, llvm::codeview::CodeViewContainer) | static CVSymbol writeOneSymbol(SymType &Sym, BumpPtrAllocator &Storage,
CodeViewContainer Container) {
RecordPrefix Prefix{uint16_t(Sym.Kind)};
CVSymbol Result(&Prefix, sizeof(Prefix));
SymbolSerializer Serializer(Storage, Container);
consumeError(Serializer.visitSymbolB... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10038, %rsp # imm = 0x10038
movq %rdi, %rbx
movzwl (%rdi), %eax
leaq 0x44(%rsp), %rcx
movw $0x2, (%rcx)
movw %ax, 0x2(%rcx)
leaq 0x18(%rsp), %r14
movq %rcx, (%r14)
movq $0x4, 0x8(%r14)
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x13efbe
leaq 0x38(%rsp), %r12... | /llvm/DebugInfo/CodeView/SymbolSerializer.h |
llvm::yaml::MappingTraits<llvm::DWARFYAML::Data>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::Data&) | void MappingTraits<DWARFYAML::Data>::mapping(IO &IO, DWARFYAML::Data &DWARF) {
void *OldContext = IO.getContext();
DWARFYAML::DWARFContext DWARFCtx;
IO.setContext(&DWARFCtx);
IO.mapOptional("debug_str", DWARF.DebugStrings);
IO.mapOptional("debug_abbrev", DWARF.DebugAbbrev);
IO.mapOptional("debug_aranges", D... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x11a702
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x6(%rsp), %r12
movb %bpl, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x11a708
leaq 0x20(%r15), %rdx
leaq 0x75a2e(%rip), %rsi # 0x1592c9
leaq 0x8(%rsp), %rcx
... | /ObjectYAML/DWARFYAML.cpp |
llvm::yaml::MappingTraits<llvm::DWARFYAML::DebugNameEntry>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::DebugNameEntry&) | void MappingTraits<DWARFYAML::DebugNameEntry>::mapping(
IO &IO, DWARFYAML::DebugNameEntry &DebugNameEntry) {
IO.mapRequired("Name", DebugNameEntry.NameStrp);
IO.mapRequired("Code", DebugNameEntry.Code);
IO.mapOptional("Values", DebugNameEntry.Values);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80070(%rip), %rsi # 0x163c63
leaq 0x5(%rsp), %r8
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x88464
leaq 0x8(%rbx), %rdx
leaq 0x800d6(%rip), %rsi # 0x163ce6
leaq 0x6(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x86afe
addq $0x10, %rbx
leaq ... | /ObjectYAML/DWARFYAML.cpp |
llvm::yaml::MappingTraits<llvm::DWARFYAML::PubSection>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::PubSection&) | void MappingTraits<DWARFYAML::PubSection>::mapping(
IO &IO, DWARFYAML::PubSection &Section) {
IO.mapOptional("Format", Section.Format, dwarf::DWARF32);
IO.mapRequired("Length", Section.Length);
IO.mapRequired("Version", Section.Version);
IO.mapRequired("UnitOffset", Section.UnitOffset);
IO.mapRequired("Un... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsp), %rcx
movb $0x0, (%rcx)
leaq 0x85439(%rip), %rsi # 0x1693ec
leaq 0x2(%rsp), %r9
movq %rbx, %rdx
xorl %r8d, %r8d
callq 0xf06da
leaq 0x8(%rbx), %rdx
leaq 0x8552d(%rip), %rsi # 0x1694fb
leaq 0x3(%rsp), %r8
movq %r14, %rdi
movl $0x1, %e... | /ObjectYAML/DWARFYAML.cpp |
llvm::yaml::MappingTraits<llvm::DWARFYAML::FormValue>::mapping(llvm::yaml::IO&, llvm::DWARFYAML::FormValue&) | void MappingTraits<DWARFYAML::FormValue>::mapping(
IO &IO, DWARFYAML::FormValue &FormValue) {
IO.mapOptional("Value", FormValue.Value);
if (!FormValue.CStr.empty() || !IO.outputting())
IO.mapOptional("CStr", FormValue.CStr);
if (!FormValue.BlockData.empty() || !IO.outputting())
IO.mapOptional("BlockDa... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xfd071(%rip), %rsi # 0x1e125c
leaq 0x5(%rsp), %r8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x86afe
cmpq $0x0, 0x10(%rbx)
jne 0xe420e
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0xe4228
leaq 0x8(%rbx), %rdx
leaq 0x85276(%r... | /ObjectYAML/DWARFYAML.cpp |
void llvm::yaml::IO::processKeyWithDefault<llvm::DWARFYAML::DebugNamesSection, llvm::yaml::EmptyContext>(char const*, std::optional<llvm::DWARFYAML::DebugNamesSection>&, std::optional<llvm::DWARFYAML::DebugNamesSection> const&, bool, llvm::yaml::EmptyContext&) | void IO::processKeyWithDefault(const char *Key, std::optional<T> &Val,
const std::optional<T> &DefaultValue,
bool Required, Context &Ctx) {
assert(!DefaultValue && "std::optional<T> shouldn't have a value!");
void *SaveInfo;
bool UseDefault = true;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movb $0x1, 0x7(%rsp)
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r13d
movb 0x30(%r14), %r12b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
te... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::Abbrev, std::allocator<llvm::DWARFYAML::Abbrev>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::Abbrev, std::allocator<llvm::DWARFYAML::Abbrev>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::DWARFYAML::Abbrev, std::all... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xe92ce
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x4, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::IdxForm, std::allocator<llvm::DWARFYAML::IdxForm>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::IdxForm, std::allocator<llvm::DWARFYAML::IdxForm>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::DWARFYAML::IdxForm, std... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x3, %rcx
testb %al, %al
cmovel %ebp, %ecx
testl %ecx, %ecx
je... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::enumFallback<llvm::yaml::Hex16, llvm::dwarf::Attribute>(llvm::dwarf::Attribute&) | void enumFallback(T &Val) {
if (matchEnumFallback()) {
EmptyContext Context;
// FIXME: Force integral conversion to allow strong typedefs to convert.
FBT Res = static_cast<typename FBT::BaseType>(Val);
yamlize(*this, Res, true, Context);
Val = static_cast<T>(static_cast<typename FBT::B... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0xb0(%rax)
testb %al, %al
je 0xf06d0
movzwl (%rbx), %eax
leaq 0xe(%rsp), %r15
movw %ax, (%r15)
leaq 0xd(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x7a239
movzwl (%r15), %eax
movw %ax, (%rbx... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::PubEntry, std::allocator<llvm::DWARFYAML::PubEntry>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::PubEntry, std::allocator<llvm::DWARFYAML::PubEntry>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::DWARFYAML::PubEntry... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xf0e42
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %... | /llvm/Support/YAMLTraits.h |
void llvm::yaml::IO::processKey<llvm::dwarf::LineNumberOps, llvm::yaml::EmptyContext>(char const*, llvm::dwarf::LineNumberOps&, bool, llvm::yaml::EmptyContext&) | void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
void *SaveInfo;
bool UseDefault;
if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
yamlize(*this, Val, Required, Ctx);
this->postflightKey(SaveInfo);
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0xf(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ecx, %edx
xorl %ecx, %ecx
callq *0x78(%rax)
testb %al, %al
je 0xf1a21
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf1a2a
movq (%rbx), %ra... | /llvm/Support/YAMLTraits.h |
llvm::yaml::ScalarEnumerationTraits<llvm::dwarf::LoclistEntries, void>::enumeration(llvm::yaml::IO&, llvm::dwarf::LoclistEntries&) | static void enumeration(IO &io, dwarf::LoclistEntries &value) {
#include "llvm/BinaryFormat/Dwarf.def"
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, (%rbx)
sete %cl
andb %al, %cl
movq (%r14), %rax
movzbl %cl, %edx
leaq 0x77896(%rip), %rsi # 0x16c84d
movq %r14, %rdi
callq *0xa8(%rax)
testb %al, %al
je 0xf4fca
movl $0x0, (%rbx)
movq (%r14), %rax
movq %r... | /llvm/ObjectYAML/DWARFYAML.h |
llvm::yaml::MappingTraits<llvm::MachOYAML::UniversalBinary>::mapping(llvm::yaml::IO&, llvm::MachOYAML::UniversalBinary&) | void MappingTraits<MachOYAML::UniversalBinary>::mapping(
IO &IO, MachOYAML::UniversalBinary &UniversalBinary) {
if (!IO.getContext()) {
IO.setContext(&UniversalBinary);
IO.mapTag("!fat-mach-o", true);
}
IO.mapRequired("FatHeader", UniversalBinary.Header);
IO.mapRequired("FatArchs", UniversalBinary.F... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11a702
testq %rax, %rax
jne 0xf5cdf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11a708
movq (%rbx), %rax
leaq 0x6d8c4(%rip), %rsi # 0x163593
movl $0xb, %edx
movq %rbx, %rdi
movl $0x1, %ecx
callq *0x60(%rax)
leaq 0x76e2c(%rip), %rsi # 0x16cb12
... | /ObjectYAML/MachOYAML.cpp |
llvm::yaml::MappingTraits<llvm::MachOYAML::RebaseOpcode>::mapping(llvm::yaml::IO&, llvm::MachOYAML::RebaseOpcode&) | void MappingTraits<MachOYAML::RebaseOpcode>::mapping(
IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode) {
IO.mapRequired("Opcode", RebaseOpcode.Opcode);
IO.mapRequired("Imm", RebaseOpcode.Imm);
IO.mapOptional("ExtraData", RebaseOpcode.ExtraData);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x73604(%rip), %rsi # 0x1694b7
leaq 0x5(%rsp), %r8
movq %rbx, %rdx
movl $0x1, %ecx
callq 0xf9a3a
leaq 0x4(%rbx), %rdx
leaq 0x76cd6(%rip), %rsi # 0x16cba6
leaq 0x6(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x36b68
addq $0x8, %rbx
leaq 0... | /ObjectYAML/MachOYAML.cpp |
llvm::yaml::MappingTraits<llvm::MachO::segment_command_64>::mapping(llvm::yaml::IO&, llvm::MachO::segment_command_64&) | void MappingTraits<MachO::segment_command_64>::mapping(
IO &IO, MachO::segment_command_64 &LoadCommand) {
IO.mapRequired("segname", LoadCommand.segname);
IO.mapRequired("vmaddr", LoadCommand.vmaddr);
IO.mapRequired("vmsize", LoadCommand.vmsize);
IO.mapRequired("fileoff", LoadCommand.fileoff);
IO.mapRequir... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rdx
leaq 0x7615f(%rip), %rsi # 0x16ccb3
leaq 0xf(%rsp), %r8
movl $0x1, %ecx
callq 0xfbc8e
leaq 0x18(%rbx), %rdx
leaq 0x76310(%rip), %rsi # 0x16ce7e
leaq 0x10(%rsp), %r8
movq %r14, %rdi
movl $0x1, %ecx
callq 0x90f52
leaq 0x20... | /ObjectYAML/MachOYAML.cpp |
std::enable_if<has_SequenceTraits<std::vector<llvm::MachOYAML::LoadCommand, std::allocator<llvm::MachOYAML::LoadCommand>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::MachOYAML::LoadCommand, std::allocator<llvm::MachOYAML::LoadCommand>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::MachOYA... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xf7744
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xc28f5c29, %eax, %... | /llvm/Support/YAMLTraits.h |
std::enable_if<validatedMappingTraits<llvm::MachOYAML::Section, llvm::yaml::EmptyContext>::value, void>::type llvm::yaml::yamlize<llvm::MachOYAML::Section, llvm::yaml::EmptyContext>(llvm::yaml::IO&, llvm::MachOYAML::Section&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<validatedMappingTraits<T, Context>::value, void>
yamlize(IO &io, T &Val, bool, Context &Ctx) {
if (has_FlowTraits<MappingTraits<T>>::value)
io.beginFlowMapping();
else
io.beginMapping();
if (io.outputting()) {
std::string Err = detail::doValidate(io, Val, Ctx);
if (!Err.empty()) {... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0xfaa27
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xf7478
cmpq $0x0, 0x8(%r15)
je 0xfaa0c
callq 0x11d8a7
movq 0x8(%... | /llvm/Support/YAMLTraits.h |
llvm::MutableBinaryByteStream::writeBytes(unsigned long, llvm::ArrayRef<unsigned char>) | Error writeBytes(uint64_t Offset, ArrayRef<uint8_t> Buffer) override {
if (Buffer.empty())
return Error::success();
if (auto EC = checkOffsetForWrite(Offset, Buffer.size()))
return EC;
uint8_t *DataPtr = const_cast<uint8_t *>(Data.data());
::memcpy(DataPtr + Offset, Buffer.data(), Buffer.s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %r8, %r8
je 0xff316
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rbx, %rdi
movq %r8, %rcx
callq 0xff336
cmpq $0x0, (%rbx)
jne 0xff31d
addq 0x8(%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x26080
mo... | /llvm/Support/BinaryByteStream.h |
llvm::SmallVectorImpl<char>::operator=(llvm::SmallVectorImpl<char> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x106f63
movq %rsi, %r15
movq 0x8(%rsi), %r14
movq 0x8(%rbx), %r12
cmpq %r14, %r12
jae 0x106f18
cmpq %r14, 0x10(%rbx)
jae 0x106f2d
movq $0x0, 0x8(%rbx)
leaq 0x18(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x... | /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [18], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat, llvm::cl::sub>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [18], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl:... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rbx
movq %rsi, %rdi
callq 0x26280
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1003a0
movups (%r12), %xmm0
movups %xmm... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [20], llvm::cl::OptionHidden, llvm::cl::NumOccurrencesFlag, llvm::cl::LocationClass<bool>, llvm::cl::initializer<bool>, llvm::cl::desc>(char const (&) [20], llvm::cl::OptionHidden const&, llvm::cl::NumOccurrencesFlag const&, llvm::cl::LocationClass<bool> const... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x2c076
movq $0x0, 0x80(%r14)
movb $0x0, 0x91(%r14)
leaq 0x132882(%rip), %rax... | /llvm/Support/CommandLine.h |
(anonymous namespace)::ErrorErrorCategory::message[abi:cxx11](int) const | std::string message(int condition) const override {
switch (static_cast<ErrorErrorCode>(condition)) {
case ErrorErrorCode::MultipleErrors:
return "Multiple errors";
case ErrorErrorCode::InconvertibleError:
return "Inconvertible error value. An error has occurred that could "
... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x3, %edx
je 0x10ca6d
cmpl $0x2, %edx
jne 0x10ca7d
leaq 0x61b07(%rip), %rsi # 0x16e56b
leaq 0x61b16(%rip), %rdx # 0x16e581
jmp 0x10ca8b
leaq 0x61a7b(%rip), %rsi # 0x16e4ef
leaq 0x61aef(%rip), %rdx # 0x16e56a
jmp 0x10ca8b
leaq 0x61a... | /Support/Error.cpp |
(anonymous namespace)::RealFile::~RealFile() | RealFile::~RealFile() { close(); } | pushq %rbx
movq %rdi, %rbx
leaq 0x12e4b3(%rip), %rax # 0x241598
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x1214c0
leaq 0x5d068(%rip), %rax # 0x170160
movl (%rax), %eax
movl %eax, 0x8(%rbx)
movq 0x68(%rbx), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x113115
movq (%rax), %rsi
incq %rsi
callq 0x260c0
movq 0x10(%... | /Support/VirtualFileSystem.cpp |
(anonymous namespace)::RealFile::setPath(llvm::Twine const&) | void RealFile::setPath(const Twine &Path) {
RealName = Path.str();
if (auto Status = status())
S = Status.get().copyWithNewName(Status.get(), Path);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x111ab8
leaq 0x68(%rbx), %rdi
movq %r15, %rsi
callq 0x26360
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0x1133a5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x260c0
movq (%rbx), %... | /Support/VirtualFileSystem.cpp |
llvm::yaml::Input::createHNodes(llvm::yaml::Node*) | Input::HNode *Input::createHNodes(Node *N) {
SmallString<128> StringStorage;
switch (N->getType()) {
case Node::NK_Scalar: {
ScalarNode *SN = dyn_cast<ScalarNode>(N);
StringRef KeyStr = SN->getValue(StringStorage);
if (!StringStorage.empty()) {
// Copy string to permanent storage
KeyStr = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r12
movq %rdi, %r14
leaq 0x98(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x80, -0x8(%r13)
movl 0x20(%rsi), %eax
cmpq $0x5, %rax
ja 0x11ab8c
leaq 0x550e1(%rip), %rcx # 0x16fc4... | /Support/YAMLTraits.cpp |
llvm::yaml::ScalarTraits<unsigned char, void>::input(llvm::StringRef, void*, unsigned char&) | StringRef ScalarTraits<uint8_t>::input(StringRef Scalar, void *, uint8_t &Val) {
unsigned long long n;
if (getAsUnsignedInteger(Scalar, 0, n))
return "invalid number";
if (n > 0xFF)
return "out of range number";
Val = n;
return StringRef();
} | pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
leaq 0x8(%rsp), %rcx
xorl %edx, %edx
callq 0x1109d3
testb %al, %al
je 0x11bfe0
movl $0xe, %edx
leaq 0x46c7c(%rip), %rax # 0x162c5a
jmp 0x11c001
movq 0x8(%rsp), %rax
cmpq $0xff, %rax
jbe 0x11bffb
movl $0x13, %edx
leaq 0x50a9f(%rip), %rax # 0x16ca98
jmp 0x11c001
movb %a... | /Support/YAMLTraits.cpp |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [33], llvm::cl::desc, llvm::cl::initializer<bool>>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [33], llvm::cl::desc const&, llvm::cl::initializer<bool> const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x26280
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1003a0
movups (%r14), %xmm0
movups %xmm0, 0x20(%r12)
movq (%rbx), %rax
movb (%rax), %cl
movb %cl, 0x80(%r12)
movb $... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<int, false, llvm::cl::parser<int>>, char [31], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(llvm::cl::opt<int, false, llvm::cl::parser<int>>*, char const (&) [31], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26280
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1003a0
movl (%r12), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
o... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [20], llvm::cl::initializer<bool>, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [20], llvm::cl::initializer<bool> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x26280
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1003a0
movq (%r14), %rax
movb (%rax), %cl
movb %cl, 0x80(%r12)
movb $0x1, 0x91(%r12)
movb (%rax), %al
movb %al, 0x9... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [16], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [16], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26280
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1003a0
movq (%r12), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %a... | /llvm/Support/CommandLine.h |
llvm::cl::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::list<char [13], llvm::cl::desc, llvm::cl::MiscFlags, llvm::cl::OptionHidden>(char const (&) [13], llvm::cl::desc const&,... | explicit list(const Mods &... Ms)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0x1, %esi
xorl %edx, %edx
callq 0x2c076
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x0, 0xb0(%r14)
leaq 0x110854(%rip), %ra... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [16], llvm::cl::desc, llvm::cl::initializer<bool>, llvm::cl::OptionHidden>(char const (&) [16], llvm::cl::desc const&, llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x2c076
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x110727(... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [30], llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [30], llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26280
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1003a0
movl (%r12), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
o... | /llvm/Support/CommandLine.h |
llvm::Registry<llvm::GCStrategy>::Add<(anonymous namespace)::CoreCLRGC>::CtorFn() | static std::unique_ptr<T> CtorFn() { return std::make_unique<V>(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x30, %edi
callq 0x26100
movq %rax, %r14
movq %rax, %rdi
callq 0x12e3a0
leaq 0x113a27(%rip), %rax # 0x242068
movq %rax, (%r14)
movl $0x101, 0x28(%r14) # imm = 0x101
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/Support/Registry.h |
llvm::codeview::AppendingTypeTableBuilder::insertRecordBytes(llvm::ArrayRef<unsigned char>&) | TypeIndex
AppendingTypeTableBuilder::insertRecordBytes(ArrayRef<uint8_t> &Record) {
TypeIndex NewTI = nextTypeIndex();
Record = stabilize(RecordStorage, Record);
SeenRecords.push_back(Record);
return NewTI;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1000, %ebp # imm = 0x1000
addl 0x30(%rdi), %ebp
movq %rsi, %r14
movq 0x8(%rdi), %rdi
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq %r12, %rsi
xorl %edx, %edx
callq 0x309e6
movq %rax, %r13
movq %rax, %rdi
movq %r... | /DebugInfo/CodeView/AppendingTypeTableBuilder.cpp |
llvm::SmallVectorTemplateBase<llvm::ArrayRef<unsigned char>, true>::push_back(llvm::ArrayRef<unsigned char>) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1323c6
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rs... | /llvm/ADT/SmallVector.h |
std::pair<llvm::DenseMapIterator<unsigned int, llvm::StringRef, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::StringRef>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::StringRef, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned in... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x1386d0
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x138684
xorl %ecx, %ecx
jmp 0x1386a5
movq %r14,... | /llvm/ADT/DenseMap.h |
llvm::codeview::detail::GuidAdapter::format(llvm::raw_ostream&, llvm::StringRef) | void GuidAdapter::format(raw_ostream &Stream, StringRef Style) {
assert(Item.size() == 16 && "Expected 16-byte GUID");
struct MSGuid {
support::ulittle32_t Data1;
support::ulittle16_t Data2;
support::ulittle16_t Data3;
support::ubig64_t Data4;
};
const MSGuid *G = reinterpret_cast<const MSGuid *... | pushq %rbx
subq $0x80, %rsp
movq %rsi, %rax
movq 0x8(%rdi), %rbx
movq 0x20(%rsi), %rcx
cmpq 0x18(%rsi), %rcx
jae 0x13921e
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x7b, (%rcx)
jmp 0x13922b
movq %rax, %rdi
movl $0x7b, %esi
callq 0x11ce5a
movl (%rbx), %ecx
leaq 0x68(%rsp), %rsi
movq %rcx, (%rsi)
movq $0x0, 0x8(%r... | /DebugInfo/CodeView/Formatters.cpp |
llvm::Error llvm::codeview::CodeViewRecordIO::mapEnum<llvm::codeview::ThunkOrdinal>(llvm::codeview::ThunkOrdinal&, llvm::Twine const&) | Error mapEnum(T &Value, const Twine &Comment = "") {
if (!isStreaming() && sizeof(Value) > maxFieldLength())
return make_error<CodeViewError>(cv_error_code::insufficient_buffer);
using U = std::underlying_type_t<T>;
U X;
if (isWriting() || isStreaming())
X = static_cast<U>(Value);
if ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0x13bea7
cmpq $0x0, 0x28(%r15)
jne 0x13bea7
cmpq $0x0, 0x30(%r15)
je 0x13beb3
movq %r15, %rdi
callq 0x146196
testl %eax, %eax
je 0x13bf22
movq 0x30(%r15), %rcx
movq 0x38(%r15),... | /llvm/DebugInfo/CodeView/CodeViewRecordIO.h |
llvm::codeview::TypeRecordMapping::~TypeRecordMapping() | explicit TypeRecordMapping(BinaryStreamReader &Reader) : IO(Reader) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x10996d(%rip), %rax # 0x24e5a8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x144c54
callq 0x26150
movl $0x58, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x260c0
| /llvm/DebugInfo/CodeView/TypeRecordMapping.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.