name string | code string | asm string | file string |
|---|---|---|---|
bios_u8 | static inline int bios_u8(struct envy_bios *bios, unsigned int offs, uint8_t *res) {
if (offs >= bios->length) {
*res = 0;
ENVY_BIOS_ERR("requested OOB u8 at 0x%04x\n", offs);
return -EFAULT;
}
*res = bios->data[offs];
return 0;
} | movl %esi, %eax
cmpl %esi, 0x8(%rdi)
jbe 0x72594
movq (%rdi), %rcx
movl %eax, %eax
movb (%rcx,%rax), %al
movb %al, (%rdx)
xorl %eax, %eax
retq
pushq %rax
movb $0x0, (%rdx)
movq 0x7a51(%rip), %rcx # 0x79ff0
movq (%rcx), %rdi
leaq 0x3c0e(%rip), %rsi # 0x761b7
movl %eax, %edx
xorl %eax, %eax
callq 0x69150
pushq ... | /polachok[P]envytools/nvbios/bios.h |
void testing::internal::PrintWithFallback<long long>(long long const&, std::ostream*) | void PrintWithFallback(const T& value, ::std::ostream* os) {
using Printer = typename FindFirstPrinter<
T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
ProtobufPrinter,
internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
ConvertibleToIntegerPrinter, Converti... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18910
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-printers.h |
int testing::internal::AppropriateResolution<float>(float) | int AppropriateResolution(FloatType val) {
int full = std::numeric_limits<FloatType>::max_digits10;
if (val < 0) val = -val;
if (val < 1000000) {
FloatType mulfor6 = 1e10;
if (val >= 100000.0) { // 100,000 to 999,999
mulfor6 = 1.0;
} else if (val >= 10000.0) {
mulfor6 = 1e1;
} else i... | pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movl $0x9, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x18da0
movss -0x8(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x8(%rbp)
movss 0x56308(%rip), %xmm0 # 0x6f0b0
ucomiss -0x8(%rbp), ... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-printers.h |
testing::internal::GetThreadCount() | size_t GetThreadCount() {
const std::string filename =
(Message() << "/proc/" << getpid() << "/stat").GetString();
return ReadProcFileField<size_t>(filename, 19);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x28170
movq -0x48(%rbp), %rdi
leaq 0x552d3(%rip), %rsi # 0x719a3
callq 0x48450
movq %rax, -0x40(%rbp)
jmp 0x1c6db
callq 0xbb00
movq -0x40(%rbp), %rdi
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x48490
movq %rax... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.cc |
testing::internal::ExecDeathTest::AssumeRole() | DeathTest::TestRole ExecDeathTest::AssumeRole() {
const UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const TestInfo* const info = impl->current_test_info();
const int death_test_index = info->result()->death_test_count();
... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x600(%rbp)
callq 0x46a90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x473e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x47410
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement,
Matcher<const std::string&> matcher,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const Internal... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdx, -0x1b0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
callq 0x46a90
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x473e0
movq %rax, -0x4... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-death-test.cc |
testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, 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>>>>*) | void SplitString(const ::std::string& str, char delimiter,
::std::vector< ::std::string>* dest) {
::std::vector< ::std::string> parsed;
::std::string::size_type pos = 0;
while (::testing::internal::AlwaysTrue()) {
const ::std::string::size_type colon = str.find(delimiter, pos);
if (colon ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x47930
movq $0x0, -0x38(%rbp)
callq 0x28130
movb %al, -0x91(%rbp)
jmp 0x1ef77
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x1ef86
jmp 0x1f06e
movq -0x8(%rbp), %rdi
mov... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::FilePath::RemoveDirectoryName() const | FilePath FilePath::RemoveDirectoryName() const {
const char* const last_sep = FindLastPathSeparator();
return last_sep ? FilePath(last_sep + 1) : *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1f420
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, -0x3a(%rbp)
movb $0x0, -0x4d(%rbp)
cmpq $0x0, %rax
j... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*) | FilePath FilePath::MakeFileName(const FilePath& directory,
const FilePath& base_name, int number,
const char* extension) {
std::string file;
if (number == 0) {
file = base_name.string() + "." + extension;
} else {
file =
base_name.str... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xba70
cmpl $0x0, -0x1c(%rbp)
jne 0x1f847
mo... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::RemoveTrailingPathSeparator() const | FilePath FilePath::RemoveTrailingPathSeparator() const {
return IsDirectory() ? FilePath(pathname_.substr(0, pathname_.length() - 1))
: *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1fec0
movb $0x0, -0x31(%rbp)
testb $0x1, %al
jne 0x1fbc2
jmp 0x1fbfb
movq -0x50(%rbp), %rdi
callq 0xbb60
movq -0x50... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::DirectoryExists() const | bool FilePath::DirectoryExists() const {
bool result = false;
#ifdef GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this
: RemoveTrailingPathSeparator());
#else
c... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x9(%rbp)
movq %rax, -0x18(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0xb3a0
movq -0x18(%rbp), %rdi
callq 0x47b60
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x47de0
movl %eax, %ecx
xorl %eax, %... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x48140
movq -0x80(%rbp), %rax
leaq 0x8106d(%rip), %rcx # 0xa14b8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xb2c0
jmp 0x20461
leaq... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x48370
movq -0x80(%rbp), %rax
leaq 0x80b0d(%rip), %rcx # 0xa1518
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xb2c0
jmp 0x20a21
leaq... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-matchers.cc |
testing::internal::RE::~RE() | RE::~RE() {
if (is_valid_) {
// regfree'ing an invalid regex might crash because the content
// of the regex is undefined. Since the regex's are essentially
// the same, one cannot be valid (or invalid) without the other
// being so too.
regfree(&partial_regex_);
regfree(&full_regex_);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x20(%rax)
je 0x20e9a
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0xb6a0
jmp 0x20e89
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xb6a0
jmp 0x20e98
jmp 0x20e9a
movq -0x10(%rbp), %rdi
callq 0xbe... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14710
movq %rax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::FormatFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0) {
return file_name + ":";
}
#ifdef _MSC_VER
return file_name + "(" + StreamableToString(line) + "):";
#else
return file_name + ":" + StreamableToStri... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x214ae
leaq 0x4efcb(%rip), %rax # 0x70470
movq %rax, -0xc8(%rbp)
jmp 0x214b9
movq -0x10(%rbp), %rax
movq %rax, -0x... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.cc |
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker = severity == GTEST_INFO ? "[ INFO ]"
: severity == GTEST_WARNING ? "[WARNING]"
: severity == GTEST_ERROR ? "[ ERROR ]"
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0xc(%rbp)
jne 0x21829
leaq 0x50276(%rip), %rax # 0x71a99
movq %rax, -0x68(%rbp)
jmp 0... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.cc |
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) | static void CaptureStream(int fd, const char* stream_name,
CapturedStream** stream) {
if (*stream != nullptr) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x21a54
leaq 0x50028(%rip), %rdx # 0x71a00
leaq -0x1c(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x3, %esi
movl $0x47d, %ecx # imm = 0x47D
callq 0x217f... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21b60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb040
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.cc |
testing::internal::OutputFlagAlsoCheckEnvVar[abi:cxx11]() | std::string OutputFlagAlsoCheckEnvVar() {
std::string default_value_for_output_flag = "";
const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
if (nullptr != xml_output_file_env) {
default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
}
return default_value_for_output_f... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xbcf0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x503e8(%rip), %rsi # 0x72975
callq 0x12be0
jmp 0x22594
l... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-port.cc |
testing::operator<<(std::ostream&, testing::TestPartResult const&) | std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os << internal::FormatFileLocation(result.file_name(),
result.line_number())
<< " "
<< (result.type() == TestPartResult::kSuccess ? "Success"
: result.t... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48e50
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48ea0
movq -0x60(%rbp), %rsi
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
call... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-test-part.cc |
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*) | const char* TypedTestSuitePState::VerifyRegisteredTestNames(
const char* test_suite_name, const char* file, int line,
const char* registered_tests) {
RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
registered_ =... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x180(%rb... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-typed-test.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b750
leaq -0x38(%rbp), %rdi
callq 0xbc70
testb $0x1, %al
jne 0x24a9e
jmp 0x24aca
movq -0x78... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool) | void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
bool has_test_p) {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
if (ignored.find(name) != ignored.end()) return;
const char kMissingInstantiation[] = //
" is defined via TEST_P, but nev... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rsi, -0x450(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
callq 0x24bc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x49590
movq %rax, -0x28(%rbp)
movq -0x20(... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::RegisterInstantiation(char const*) | void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
const char* test_suite_name) {
auto it = suites_.find(std::string(test_suite_name));
if (it != suites_.end()) {
it->second.instantiated = true;
} else {
GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
<... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xbcf0
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x38(%... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::GetCurrentExecutableName() | FilePath GetCurrentExecutableName() {
FilePath result;
#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)
result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
result.Set(FilePath(GetArgvs()[0]));
#endif // GTEST_OS_WINDOWS
return result.RemoveDirectoryName();
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x47e30
leaq -0x60(%rbp), %rdi
callq 0x21d20
jmp 0x25c3e
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0x471c0
movq %rax, %rsi
leaq -0x48(%rbp), %rd... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::ExecDeathTestChildMain(void*) | static int ExecDeathTestChildMain(void* child_arg) {
ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the... | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x415a9
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0xbe20
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x2d1(%rbp)
jne 0x415d7
callq 0xb080
cmp... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-death-test.cc |
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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
xorl %eax, %eax
movl $0x1, %ecx
cmpl -0x4(%rbp), %ecx
movb %al, -0x19(%rbp)
jg 0x4fad7
cmpl $0x1869f, -0x4(%rbp) # imm = 0x1869F
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb $0x1, %al
jne 0... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-internal-inl.h |
testing::Message& testing::Message::operator<<<char [19]>(char const (&) [19]) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15970
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-message.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xba70
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5048d
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x58(%rbp), %rdi
c... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xba70
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x50655
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x58(%rbp), %rdi
c... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3fc20
testb $0x1, %al
jne 0x506bb
jmp 0x506c0
jmp 0x5075c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x506ce
jmp 0x5075c
leaq 0x5229b(%rip), %rdi # 0xa2970
callq 0x6ea20
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
mov... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<wchar_t>(int*, wchar_t**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3fc20
testb $0x1, %al
jne 0x5078b
jmp 0x50790
jmp 0x5082c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x5079e
jmp 0x5082c
leaq 0x521cb(%rip), %rdi # 0xa2970
callq 0x6ea20
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
mov... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq 0x505d7(%rip), %rcx # 0xa0ec8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x100(%rbp), %rax
cmpl $-0x1, 0x34(%rax)
sete %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-death-test.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::~Matcher() | class GTEST_API_ Matcher<const internal::StringView&>
: public internal::MatcherBase<const internal::StringView&> {
public:
Matcher() {}
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<const internal::StringView&>(impl) {}
template <typename M, type... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x482e0
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0xb6c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-matchers.h |
testing::Message& testing::Message::operator<<<char [61]>(char const (&) [61]) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15970
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x59caf
callq 0xb7b0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x47c17(%rip), %rsi # 0xa18d8
callq 0x59dc0
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | void OnTestPartResult(const TestPartResult& test_part_result) override {
const char* file_name = test_part_result.file_name();
if (file_name == nullptr) file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48e50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5ae3d
leaq 0x17b3c(%rip), %rax # 0x72975
movq %rax, -0x18(%rbp)
mo... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x47430
movq %rax, %rdi
callq 0x4d7c0
movq -0xf8(%rbp), %rsi
movzbl %al, %edx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0... | /LLNL[P]camp/extern/blt/thirdparty_builtin/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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30f60
movq -0x100(%rbp), %rsi
movzbl %al, %edx
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5bec... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Send(const std::string& message) override {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const auto len = static_cast<size_t>(message.length());
if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
GTEST_LOG_(WARNIN... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb $0x1, %al
jne 0x5b833
jmp 0x5b835
jmp 0x5b8a8
leaq 0x17ff5(%rip), %rdx # 0x73831
leaq -0x14(%rbp)... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb $0x1, %al
jne 0x5b9cc
jmp 0x5b9ce
jmp 0x5ba3e
leaq 0x17e5c(%rip), %rdx # 0x73831
leaq -0xc(%rbp), %rdi
movq %rdi, -0x38(... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*) | static void Print(const char* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(std::string(str), os);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5c919
movq -0x10(%rbp), %rdi
leaq 0x12b16(%rip), %rsi # 0x6f428
callq 0xb670
jmp 0x5c992
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xbcf0
movq -... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-printers.h |
testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*) | static void Print(const wchar_t* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(::std::wstring(str), os);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5ca69
movq -0x10(%rbp), %rdi
leaq 0x129c6(%rip), %rsi # 0x6f428
callq 0xb670
jmp 0x5cae2
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb310
movq -... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-printers.h |
testing::internal::UniversalPrinter<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>::Print(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::ostream*) | static void Print(const T& value, ::std::ostream* os) {
// By default, ::testing::internal::PrintTo() is used for printing
// the value.
//
// Thanks to Koenig look-up, if T is a class and has its own
// PrintTo() function defined in its namespace, that function will
// be visible here. Since i... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5cc10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-printers.h |
testing::Message& testing::Message::operator<<<long>(long const&) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15970
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xbd60
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-message.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, s... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5eae0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5ed30
leaq -0x18(%rbp), %rdi
callq 0x5ed10
movq (%rax), %rax
addq $0x30, ... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-matchers.h |
testing::Message& testing::Message::operator<<<char [100]>(char const (&) [100]) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15970
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [106]>(char const (&) [106]) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15970
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [29]>(char const (&) [29]) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15970
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::GTestFlagSaver::~GTestFlagSaver() | ~GTestFlagSaver() {
GTEST_FLAG_SET(also_run_disabled_tests, also_run_disabled_tests_);
GTEST_FLAG_SET(break_on_failure, break_on_failure_);
GTEST_FLAG_SET(catch_exceptions, catch_exceptions_);
GTEST_FLAG_SET(color, color_);
GTEST_FLAG_SET(death_test_style, death_test_style_);
GTEST_FLAG_SET(deat... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movb (%rsi), %cl
andb $0x1, %cl
leaq 0x3b7b3(%rip), %rax # 0xa28a3
movb %cl, (%rax)
movb 0x1(%rsi), %cl
andb $0x1, %cl
leaq 0x3b7a5(%rip), %rax # 0xa28a4
movb %cl, (%rax)
movb 0x2(%rsi), %cl
andb $0x1,... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest-internal-inl.h |
testing::Test* testing::internal::HandleSehExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testing::Test* (testing::internal::TestFactoryBase::*)(), char const*) | Result HandleSehExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
const char* location) {
#if GTEST_HAS_SEH
__try {
return (object->*method)();
} __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT
GetExceptionCode())) {
//... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdx
ad... | /LLNL[P]camp/extern/blt/thirdparty_builtin/googletest/googletest/src/gtest.cc |
llvm::ReleaseModeModelRunner<llvm::NoopSavedModelImpl>::ReleaseModeModelRunner<std::vector<llvm::TensorSpec, std::allocator<llvm::TensorSpec>>>(llvm::LLVMContext&, std::vector<llvm::TensorSpec, std::allocator<llvm::TensorSpec>> const&, llvm::StringRef, llvm::EmbeddedModelRunnerOptions const&) | ReleaseModeModelRunner(LLVMContext &Ctx, const FType &InputSpec,
StringRef DecisionName,
const EmbeddedModelRunnerOptions &Options = {})
: MLModelRunner(Ctx, MLModelRunner::Kind::Release, InputSpec.size() + 1),
CompiledModel(std::make_unique<TGen>()) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rax
subq (%rdx), %rax
pushq $0x50
popq %rcx
cqto
idivq %rcx
incq %rax
leaq 0x51080f5(%rip), %rcx # 0x5894390
addq $0x10, %rcx
movq %rcx, (%rdi)
movq %rsi, 0x8(%rdi)
movl $0x1, 0x10(%rdi)
addq $0x18, %rdi
leaq ... | /llvm/Analysis/ReleaseModeModelRunner.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 [16], llvm::cl::desc>(char const (&) [16], llvm::cl::desc const&) | explicit list(const Mods &... Ms)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x7fca88
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movb $0x0, 0xb0(%rbx)
leaq 0x4f50922(%rip), %rax # 0x57473a0
addq $0x10, %rax
movq %rax, (%rbx)
... | /llvm/Support/CommandLine.h |
llvm::DiagnosticPredicate (anonymous namespace)::AArch64Operand::isSImmScaled<7, 4>() const | DiagnosticPredicate isSImmScaled() const {
return isImmScaled<Bits, Scale>(true);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
movl $0x2, %ebx
testb %al, %al
jne 0x82d5bd
cmpl $0x2, 0x30(%r14)
jne 0x82d5fc
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, 0x30(%r14)
je 0x82d5fc
movq 0x48(%r14), %rdx
movb (%rdx), %cl
cmpb $0x1, %cl
jne 0x82d5dc
mov... | /Target/AArch64/AsmParser/AArch64AsmParser.cpp |
bool (anonymous namespace)::AArch64Operand::isFPRasZPR<23u>() const | bool isFPRasZPR() const {
return Kind == k_Register && Reg.Kind == RegKind::Scalar &&
AArch64MCRegisterClasses[Class].contains(getReg());
} | xorl %eax, %eax
cmpl $0x4, 0x30(%rdi)
jne 0x82fae6
cmpl $0x0, 0x4c(%rdi)
jne 0x82fae6
pushq %rax
movq (%rdi), %rax
callq *0x38(%rax)
movl %eax, %ecx
shrl $0x3, %ecx
leaq 0x4fc0f21(%rip), %rdx # 0x57f09e0
movzwl 0x2f6(%rdx), %esi
cmpl %esi, %ecx
jae 0x82fae0
movq 0x2e8(%rdx), %rdx
movzbl (%rdx,%rcx), %ecx
andl $0x7, %... | /Target/AArch64/AsmParser/AArch64AsmParser.cpp |
bool (anonymous namespace)::AArch64Operand::isFPRasZPR<75u>() const | bool isFPRasZPR() const {
return Kind == k_Register && Reg.Kind == RegKind::Scalar &&
AArch64MCRegisterClasses[Class].contains(getReg());
} | xorl %eax, %eax
cmpl $0x4, 0x30(%rdi)
jne 0x82fb7a
cmpl $0x0, 0x4c(%rdi)
jne 0x82fb7a
pushq %rax
movq (%rdi), %rax
callq *0x38(%rax)
movl %eax, %ecx
shrl $0x3, %ecx
leaq 0x4fc0e8d(%rip), %rdx # 0x57f09e0
movzwl 0x976(%rdx), %esi
cmpl %esi, %ecx
jae 0x82fb74
movq 0x968(%rdx), %rdx
movzbl (%rdx,%rcx), %ecx
andl $0x7, %... | /Target/AArch64/AsmParser/AArch64AsmParser.cpp |
bool (anonymous namespace)::AArch64Operand::isTypedVectorList<((anonymous namespace)::RegKind)2, 3u, 0u, 8u, 1u>() const | bool isTypedVectorList() const {
if (Kind != k_VectorList)
return false;
if (VectorList.Count != NumRegs)
return false;
if (VectorList.RegisterKind != VectorKind)
return false;
if (VectorList.ElementWidth != ElementWidth)
return false;
if (VectorList.Stride != Stride)
r... | xorl %eax, %eax
cmpl $0x8, 0x30(%rdi)
jne 0x82fd3b
cmpl $0x3, 0x4c(%rdi)
jne 0x82fd3b
cmpl $0x2, 0x5c(%rdi)
jne 0x82fd3b
cmpl $0x8, 0x58(%rdi)
jne 0x82fd3b
cmpl $0x1, 0x50(%rdi)
jne 0x82fd3b
cmpl $0x0, 0x54(%rdi)
sete %al
retq
| /Target/AArch64/AsmParser/AArch64AsmParser.cpp |
(anonymous namespace)::ARMAsmParser::parseOperand(llvm::SmallVectorImpl<std::unique_ptr<llvm::MCParsedAsmOperand, std::default_delete<llvm::MCParsedAsmOperand>>>&, llvm::StringRef) | bool ARMAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
MCAsmParser &Parser = getParser();
SMLoc S, E;
// Check if the current operand has a custom associated parser, if so, try to
// custom parse the operand, or fallback to the general approach.
ParseStatus ResTy = MatchOperandParserI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
callq 0x87eb6c
testl %eax, %eax
je 0x87c7f1
cmpl $0x1, %eax
jne 0x87bc92
movb $0x1, %bpl
jmp 0x87c7f3
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x28... | /Target/ARM/AsmParser/ARMAsmParser.cpp |
(anonymous namespace)::ARMAsmParser::isThumbTwo() const | bool isThumbTwo() const {
return isThumb() && getSTI().hasFeature(ARM::FeatureThumb2);
} | pushq %rbx
movq %rdi, %rbx
callq 0x28c4372
testb $0x20, 0xef(%rax)
jne 0x87dd52
xorl %eax, %eax
jmp 0x87dd62
movq %rbx, %rdi
callq 0x28c4372
movb 0xe9(%rax), %al
andb $0x1, %al
popq %rbx
retq
| /Target/ARM/AsmParser/ARMAsmParser.cpp |
insertNoDuplicates(llvm::SmallVectorImpl<std::pair<unsigned int, unsigned int>>&, unsigned int, unsigned int) | static bool
insertNoDuplicates(SmallVectorImpl<std::pair<unsigned, unsigned>> &Regs,
unsigned Enc, unsigned Reg) {
Regs.emplace_back(Enc, Reg);
for (auto I = Regs.rbegin(), J = I + 1, E = Regs.rend(); J != E; ++I, ++J) {
if (J->first == Enc) {
Regs.erase(J.base());
return false;
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
leaq 0xc(%rsp), %rcx
movl %edx, (%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x8853ce
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rcx,%rdx,8), %rsi
addq $-0x8, %rsi
movb $0x1, %al
cmpq %rcx, %rsi
je 0x885389
shlq $0x3, %rdx
movl -0x10(... | /Target/ARM/AsmParser/ARMAsmParser.cpp |
(anonymous namespace)::ARMAsmParser::validatetLDMRegList(llvm::MCInst const&, llvm::SmallVectorImpl<std::unique_ptr<llvm::MCParsedAsmOperand, std::default_delete<llvm::MCParsedAsmOperand>>> const&, unsigned int, unsigned int, bool) | bool ARMAsmParser::validatetLDMRegList(const MCInst &Inst,
const OperandVector &Operands,
unsigned MnemonicOpsEndInd,
unsigned ListIndex, bool IsARPop) {
bool ListContainsSP = listContainsReg(Inst, Lis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x18(%rsi), %eax
movl %r8d, %edi
cmpl %r8d, %eax
seta %r10b
movl %r10d, %r11d
jbe 0x897dd8
movq 0x10(%rsi), %r14
movq %rdi, %r15
shlq $0x4, %r15
movb $0x1, %r11b
cmpl $0x10, 0x8(%r14,%r15)
je 0x897dd8
leaq 0x1(%rdi), %r15
movq ... | /Target/ARM/AsmParser/ARMAsmParser.cpp |
llvm::SmallSet<llvm::FeatureBitset, 4u, std::less<llvm::FeatureBitset>>::count(llvm::FeatureBitset const&) const | size_type count(const T &V) const {
if (isSmall()) {
// Since the collection is small, just do a linear search.
return vfind(V) == Vector.end() ? 0 : 1;
} else {
return Set.count(V);
}
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xd8(%rdi)
je 0x8986f0
leaq 0xb0(%rbx), %rdi
callq 0x898c48
addq $0xb8, %rbx
cmpq %rbx, %rax
jmp 0x898709
movq %rbx, %rdi
callq 0x898c06
movl 0x8(%rbx), %ecx
leaq (%rcx,%rcx,4), %rcx
shlq $0x3, %rcx
addq (%rbx), %rcx
cmpq %rcx, %rax
setne %al
movzbl %al, %eax
popq %rbx
retq
nop
| /llvm/ADT/SmallSet.h |
LLVMInitializeBPFAsmParser | LLVM_EXTERNAL_VISIBILITY void LLVMInitializeBPFAsmParser() {
RegisterMCAsmParser<BPFAsmParser> X(getTheBPFTarget());
RegisterMCAsmParser<BPFAsmParser> Y(getTheBPFleTarget());
RegisterMCAsmParser<BPFAsmParser> Z(getTheBPFbeTarget());
} | pushq %rbx
callq 0x19f405c
leaq 0x19(%rip), %rbx # 0x89c376
movq %rbx, 0x70(%rax)
callq 0x19f4020
movq %rbx, 0x70(%rax)
callq 0x19f403e
movq %rbx, 0x70(%rax)
popq %rbx
retq
nop
| /Target/BPF/AsmParser/BPFAsmParser.cpp |
(anonymous namespace)::MipsAsmParser::parseSetNoVirtDirective() | bool MipsAsmParser::parseSetNoVirtDirective() {
MCAsmParser &Parser = getParser();
Parser.Lex(); // Eat "novirt".
// If this is not the end of the statement, report an error.
if (getLexer().isNot(AsmToken::EndOfStatement)) {
reportParseError("unexpected token, expected end of statement");
return false;... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb8(%rax)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0x9, (%rax)
jne 0x8ae900
leaq 0x467b5ff(%rip), %rdx # 0x4f29ec3
movl $0x32, %esi
movl $0x4, %ecx
movq %r14... | /Target/Mips/AsmParser/MipsAsmParser.cpp |
(anonymous namespace)::MipsAsmParser::setFeatureBits(unsigned long, llvm::StringRef) | void setFeatureBits(uint64_t Feature, StringRef FeatureString) {
if (!(getSTI().hasFeature(Feature))) {
MCSubtargetInfo &STI = copySTI();
setAvailableFeatures(
ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
AssemblerOptions.back()->setFeatures(STI.getFeatureBits());
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x28c4372
movl %r12d, %ecx
shrl $0x6, %ecx
movq 0xd8(%rax,%rcx,8), %rax
btq %r12, %rax
jb 0x8af150
movq %rbx, %rdi
callq 0x28c434c
movq %rax, %r12
movq %rsp, %r13
movq %r13, %rdi... | /Target/Mips/AsmParser/MipsAsmParser.cpp |
(anonymous namespace)::MipsOperand::addGPR32ZeroAsmRegOperands(llvm::MCInst&, unsigned int) const | void addGPR32ZeroAsmRegOperands(MCInst &Inst, unsigned N) const {
assert(N == 1 && "Invalid number of operands!");
Inst.addOperand(MCOperand::createReg(getGPR32Reg()));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %rdi
movl 0x40(%r14), %esi
movq 0x60(%r14), %rdx
callq 0x8a93a6
movq 0x58(%r14), %rax
movq 0x18(%rax), %rax
movl 0x40(%r14), %ecx
movq 0x100(%rax), %rax
movzwl (%rax,%rcx,2), %edx
addq $0x10, %rbx
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8... | /Target/Mips/AsmParser/MipsAsmParser.cpp |
(anonymous namespace)::MipsAsmParser::warnIfNoMacro(llvm::SMLoc) | iterator begin() { return (iterator)this->BeginX; } | movq 0x138(%rdi), %rax
movl 0x140(%rdi), %ecx
movq -0x8(%rax,%rcx,8), %rax
cmpb $0x0, 0x5(%rax)
jne 0x8b5983
subq $0x28, %rsp
leaq 0x297c598(%rip), %rax # 0x3231ef9
movq %rsp, %rdx
movq %rax, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
callq... | /llvm/ADT/SmallVector.h |
convertIntToDoubleImm(unsigned long) | static uint64_t convertIntToDoubleImm(uint64_t ImmOp64) {
// If ImmOp64 is AsmToken::Integer type (all bits set to zero in the
// exponent field), convert it to double (e.g. 1 to 1.0)
if ((Hi_32(ImmOp64) & 0x7ff00000) == 0) {
APFloat RealVal(APFloat::IEEEdouble(), ImmOp64);
ImmOp64 = RealVal.bitcastToAPIn... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
testq %rax, %rdi
jne 0x8ba663
callq 0x2b061f6
movq %rsp, %r15
movq %rbx, (%r15)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8ba670
leaq 0x10(%rsp), %rsi
movq %... | /Target/Mips/AsmParser/MipsAsmParser.cpp |
llvm::RISCVSysReg::SysReg::haveRequiredFeatures(llvm::FeatureBitset const&) const | bool haveRequiredFeatures(const FeatureBitset &ActiveFeatures) const {
// Not in 32-bit mode.
if (isRV32Only && ActiveFeatures[RISCV::Feature64Bit])
return false;
// No required feature associated with the system register.
if (FeaturesRequired.none())
return true;
return (FeaturesRequire... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x1, 0x48(%rdi)
jne 0x8cb664
testb $0x4, (%rbx)
jne 0x8cb6c5
leaq 0x20(%r15), %r14
addq $0x48, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x821aa9
cmpq %r15, %rax
je 0x8cb6c1
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14)... | /Target/RISCV/MCTargetDesc/RISCVBaseInfo.h |
(anonymous namespace)::SparcAsmParser::parseMEMOperand(llvm::SmallVectorImpl<std::unique_ptr<llvm::MCParsedAsmOperand, std::default_delete<llvm::MCParsedAsmOperand>>>&) | ParseStatus SparcAsmParser::parseMEMOperand(OperandVector &Operands) {
SMLoc S, E;
std::unique_ptr<SparcOperand> LHS;
if (!parseSparcAsmOperand(LHS).isSuccess())
return ParseStatus::NoMatch;
// Single immediate operand
if (LHS->isImm()) {
Operands.push_back(SparcOperand::MorphToMEMri(Sparc::G0, std:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
xorl %edx, %edx
callq 0x8d618c
movl $0x2, %r14d
testl %eax, %eax
je 0x8d5bf3
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x8d5be3
movq (%rdi), %rax
callq *0x8(%rax)
movl %r14d, %ea... | /Target/Sparc/AsmParser/SparcAsmParser.cpp |
llvm::X86Operand::addMemOperands(llvm::MCInst&, unsigned int) const | void addMemOperands(MCInst &Inst, unsigned N) const {
assert((N == 5) && "Invalid number of operands!");
if (getMemBaseReg())
Inst.addOperand(MCOperand::createReg(getMemBaseReg()));
else
Inst.addOperand(MCOperand::createReg(getMemDefaultBaseReg()));
Inst.addOperand(MCOperand::createImm(getMe... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x80(%rdi), %edx
testl %edx, %edx
cmovel 0x84(%rdi), %edx
leaq 0x10(%rsi), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x821b42
movl 0x8c(%rbx), %edx
movq %r15, %rdi
movl $0x2, %esi
callq 0x821b42
movl 0x88(%rbx), %edx
movq %r15, %rdi
movl $0x1, %esi
... | /Target/X86/AsmParser/X86Operand.h |
void llvm::SmallVectorImpl<std::function<void (llvm::MachineInstrBuilder&)>>::append<std::function<void (llvm::MachineInstrBuilder&)> const*, void>(std::function<void (llvm::MachineInstrBuilder&)> const*, std::function<void (llvm::MachineInstrBuilder&)> const*) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r13
subq %rsi, %r13
sarq $0x5, %r13
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %eax
addq %r13, %rsi
cmpq %rax, %rsi
jbe 0x94c056
movq %rbx, %rdi
callq 0x94c0b0
cmpq %r14, %r15
je 0x94c0a2
movl 0x8(%rbx), %r12d
s... | /llvm/ADT/SmallVector.h |
getSubRegForClass(llvm::TargetRegisterClass const*, llvm::TargetRegisterInfo const&, unsigned int&) | static bool getSubRegForClass(const TargetRegisterClass *RC,
const TargetRegisterInfo &TRI, unsigned &SubReg) {
switch (TRI.getRegSizeInBits(*RC)) {
case 8:
SubReg = AArch64::bsub;
break;
case 16:
SubReg = AArch64::hsub;
break;
case 32:
if (RC != &AArch64::FPR32... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x110(%rsi), %rax
subq 0x108(%rsi), %rax
movq 0x120(%rsi), %rcx
shrq $0x3, %rax
imull 0x130(%rsi), %eax
movq (%rdi), %rdx
movzwl 0x18(%rdx), %edx
addl %eax, %edx
shlq $0x4, %rdx
movl (%rcx,%rdx), %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movb... | /Target/AArch64/GISel/AArch64InstructionSelector.cpp |
(anonymous namespace)::AArch64InstructionSelector::renderTruncImm(llvm::MachineInstrBuilder&, llvm::MachineInstr const&, int) const | void AArch64InstructionSelector::renderTruncImm(MachineInstrBuilder &MIB,
const MachineInstr &MI,
int OpIdx) const {
const MachineRegisterInfo &MRI = MI.getParent()->getParent()->getRegInfo();
assert(MI.getOpcode() == Ta... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x18(%rdx), %rax
movq 0x20(%rdx), %rcx
movq 0x20(%rax), %rax
movq 0x28(%rax), %rsi
movl 0x4(%rcx), %edi
callq 0x15e547c
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movl $0xfff00000, %ecx # imm = 0xFFF00000
movq %rsp, %rdx
andl (%rdx), %ecx
incl %ecx
movl %ecx, (%rdx)
mo... | /Target/AArch64/GISel/AArch64InstructionSelector.cpp |
(anonymous namespace)::AArch64DAGToDAGISel::SelectPredicatedLoad(llvm::SDNode*, unsigned int, unsigned int, unsigned int, unsigned int, bool) | void AArch64DAGToDAGISel::SelectPredicatedLoad(SDNode *N, unsigned NumVecs,
unsigned Scale, unsigned Opc_ri,
unsigned Opc_rr, bool IsIntr) {
assert(Scale < 5 && "Invalid scaling value.");
SDLoc DL(N);
EVT VT = N->getValu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, 0x20(%rsp)
movl %r8d, 0x24(%rsp)
movl %ecx, %ebp
movl %edx, 0x1c(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
movq %rsi, 0x28(%rsp)
testq %rsi, %rsi
je 0x9dbdc6
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x2a75... | /Target/AArch64/AArch64ISelDAGToDAG.cpp |
(anonymous namespace)::AArch64LoadStoreOpt::~AArch64LoadStoreOpt() | AArch64LoadStoreOpt() : MachineFunctionPass(ID) {
initializeAArch64LoadStoreOptPass(*PassRegistry::getPassRegistry());
} | pushq %rbx
movq %rdi, %rbx
leaq 0x4ce2891(%rip), %rax # 0x575c180
movq %rax, (%rdi)
movq 0x100(%rdi), %rdi
leaq 0x110(%rbx), %rax
cmpq %rax, %rdi
je 0xa7990a
callq 0x780910
movq 0xb0(%rbx), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0xa79922
callq 0x780910
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rd... | /Target/AArch64/AArch64LoadStoreOptimizer.cpp |
llvm::SmallPtrSetImpl<llvm::AnalysisKey*>::insert(llvm::AnalysisKey*) | std::pair<iterator, bool> insert(PtrType Ptr) {
auto p = insert_imp(PtrTraits::getAsVoidPointer(Ptr));
return std::make_pair(makeIterator(p.first), p.second);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x91dbe2
movq 0x8(%r14), %rcx
xorl %esi, %esi
cmpq (%r14), %rcx
sete %sil
movl 0x10(%r14,%rsi,4), %esi
leaq (%rcx,%rsi,8), %rcx
cmpq %rax, %rcx
je 0xae98bd
cmpq $-0x2, (%rax)
jb 0xae98bd
addq $0x8, %rax
cmpq %rcx, %ra... | /llvm/ADT/SmallPtrSet.h |
bool llvm::PatternMatch::BinaryOp_match<llvm::PatternMatch::cstval_pred_ty<llvm::PatternMatch::is_all_ones, llvm::ConstantInt, true>, llvm::PatternMatch::match_combine_and<llvm::PatternMatch::IntrinsicID_match, llvm::PatternMatch::Argument_match<llvm::PatternMatch::bind_ty<llvm::Value>>>, 30u, true>::match<llvm::Value>... | inline bool match(unsigned Opc, OpTy *V) {
if (V->getValueID() == Value::InstructionVal + Opc) {
auto *I = cast<BinaryOperator>(V);
return (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) ||
(Commutable && L.match(I->getOperand(1)) &&
R.match(I->getOperand(0)));
}
... | pushq %r15
pushq %r14
pushq %rbx
cmpb $0x3b, (%rsi)
jne 0xaedb85
movq %rsi, %r14
movq %rdi, %rbx
movq -0x40(%rsi), %r15
movq %r15, %rsi
callq 0xa5cdfe
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0xaedb31
movq %r15, (%rcx)
testb %al, %al
je 0xaedb4a
leaq 0x8(%rbx), %rdi
movq -0x20(%r14)... | /llvm/IR/PatternMatch.h |
llvm::BasicTTIImplBase<llvm::GCNTTIImpl>::getExtractSubvectorOverhead(llvm::VectorType*, llvm::TargetTransformInfo::TargetCostKind, int, llvm::FixedVectorType*) | InstructionCost getExtractSubvectorOverhead(VectorType *VTy,
TTI::TargetCostKind CostKind,
int Index,
FixedVectorType *SubVTy) {
assert(VTy && SubVTy &&
"Can only extr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rax
movl 0x20(%r8), %esi
testl %esi, %esi
je 0xafa6d6
movq %rdi, 0x20(%rsp)
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r8, 0x18(%rsp)
movl %edx, 0xc(%rsp)
movq %rcx, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movl %esi, ... | /llvm/CodeGen/BasicTTIImpl.h |
(anonymous namespace)::AMDGPUUnifyDivergentExitNodes::runOnFunction(llvm::Function&) | bool AMDGPUUnifyDivergentExitNodes::runOnFunction(Function &F) {
DominatorTree *DT = nullptr;
if (RequireAndPreserveDomTree)
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
const auto &PDT =
getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
const auto &UA = getAnalysis<Uniformi... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x4e8c47a(%rip), %rax # 0x5987db0
cmpb $0x1, 0x80(%rax)
jne 0xafb980
movq 0x8(%r15), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x4eaa795(%rip), %rcx # 0x59a60e8
leaq 0x10(%rdx), %rsi
c... | /Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp |
void llvm::SmallVectorImpl<llvm::BasicBlock*>::append<llvm::SuccIterator<llvm::Instruction, llvm::BasicBlock>, void>(llvm::SuccIterator<llvm::Instruction, llvm::BasicBlock>, llvm::SuccIterator<llvm::Instruction, llvm::BasicBlock>) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl %r8d, %eax
subl %edx, %eax
movl %eax, 0x4(%rsp)
cltq
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
addq %rax, %rdx
cmpq %rcx, %rdx
jbe 0xafbfc3
leaq 0x10(%rbx), %rsi
movl $0x8, ... | /llvm/ADT/SmallVector.h |
llvm::CallInst::Create(llvm::FunctionType*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&, llvm::InsertPosition) | static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
const Twine &NameStr,
InsertPosition InsertBefore = nullptr) {
return new (ComputeNumOperands(Args.size()))
CallInst(Ty, Func, Args, std::nullopt, NameStr, InsertBefore);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movl $0x28, %r15d
leal 0x1(%rcx), %ebx
movl $0x58, %edi
movl %ebx, %esi
callq 0x2a9ec74
movq %rax, %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp... | /llvm/IR/Instructions.h |
llvm::GCNUpwardRPTracker::reset(llvm::MachineInstr const&) | void reset(const MachineInstr &MI) {
reset(MI.getMF()->getRegInfo(), LIS.getInstructionIndex(MI).getDeadSlot());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1d3de64
movq 0x28(%rax), %r15
movq (%r14), %rax
movq 0x20(%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa8c610
andq $-0x8, %rax
leaq 0x6(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb00730
| /Target/AMDGPU/GCNRegPressure.h |
llvm::GCNIterativeScheduler::scheduleILP(bool) | void GCNIterativeScheduler::scheduleILP(
bool TryMaximizeOccupancy) {
const auto &ST = MF.getSubtarget<GCNSubtarget>();
SIMachineFunctionInfo *MFI = MF.getInfo<SIMachineFunctionInfo>();
auto TgtOcc = MFI->getMinAllowedOccupancy();
sortRegionsByPressure(TgtOcc);
auto Occ = Regions.front()->MaxPressure.getOc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x10(%rax), %r14
movq 0x30(%rax), %r12
cmpb $0x0, 0x72(%r12)
jne 0xaff6fe
cmpb $0x0, 0x73(%r12)
je 0xaff715
movl 0x3a8(%r12), %eax
cmpl $0x4, %eax
movl $0x4, %r13d
cmovbl %eax, %... | /Target/AMDGPU/GCNIterativeScheduler.cpp |
llvm::GCNPostScheduleDAGMILive::schedule() | void GCNPostScheduleDAGMILive::schedule() {
HasIGLPInstrs = hasIGLPInstrs(this);
if (HasIGLPInstrs) {
SavedMutations.clear();
SavedMutations.swap(Mutations);
addMutation(createIGroupLPDAGMutation(AMDGPU::SchedulingPhase::PostRA));
}
ScheduleDAGMI::schedule();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x380(%rdi), %rax
movq 0x388(%rdi), %rcx
cmpq %rcx, %rax
je 0xb100c3
movzwl 0x44(%rax), %edx
andl $-0x5, %edx
cmpl $0xe49, %edx # imm = 0xE49
je 0xb100c3
testq %rax, %rax
je 0xb100b7
testb $0x4, (%rax)
je 0xb100b7
jmp 0xb100bd
movq 0... | /Target/AMDGPU/GCNSchedStrategy.cpp |
void llvm::SmallVectorImpl<llvm::GCNRegPressure>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0xb12787
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0xb1277c
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0xb12729
leaq 0x10(%r14), %rsi
movl $0x18, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2b4ed86
movl 0x8(%r14), %ecx
cmpq %rbx, %rcx
je 0xb1277c
leaq (%r... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::GCNRegPressure, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::GCNRegPressure>>, unsigned int, llvm::GCNRegPressure, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::GCNRegPressure>>::Find... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0xb131e0
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0xb131d5
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0xb1326c
movl (%rbx), %ecx
movl %ecx, (%rax)
xorps %xm... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<unsigned int, llvm::GCNRegPressure>* llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::GCNRegPressure, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::GCNRegPressure>>, unsigned int, llvm::GCNRegPressure, llvm::DenseMapInfo<unsigned int, void>, llvm:... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0xb132b7
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>>* llvm::DenseMapBase<llvm::DenseMap<unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::ve... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0xb211c1
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
llvm::R600TargetMachine::getTargetTransformInfo(llvm::Function const&) const | TargetTransformInfo
R600TargetMachine::getTargetTransformInfo(const Function &F) const {
return TargetTransformInfo(R600TTIImpl(this, F));
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xb30400
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb23338
movq 0x30(%r14), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0xb2332d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r14... | /Target/AMDGPU/R600TargetMachine.cpp |
llvm::TargetTransformInfoImplCRTPBase<llvm::R600TTIImpl>::getPointersChainCost(llvm::ArrayRef<llvm::Value const*>, llvm::Value const*, llvm::TargetTransformInfo::PointersChainInfo const&, llvm::Type*, llvm::TargetTransformInfo::TargetCostKind) | InstructionCost getPointersChainCost(ArrayRef<const Value *> Ptrs,
const Value *Base,
const TTI::PointersChainInfo &Info,
Type *AccessTy,
TTI::TargetCostKind CostKi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
testq %rdx, %rdx
je 0xb24d04
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x30(%rsp)
leaq -0x8(%rdi), %rax
movq %rax, 0x28(%rsp)
shlq $0x3, %r12
xorl %r15d, %r15d
movl $0x0, 0... | /llvm/Analysis/TargetTransformInfoImpl.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseSetPair<llvm::MachineBasicBlock const*>>, llvm::MachineBasicBlock const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MachineBasicBlock co... | 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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0xb38dcf
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
n... | /llvm/ADT/DenseMap.h |
llvm::SIInstrInfo::canShrink(llvm::MachineInstr const&, llvm::MachineRegisterInfo const&) const | bool SIInstrInfo::canShrink(const MachineInstr &MI,
const MachineRegisterInfo &MRI) const {
const MachineOperand *Src2 = getNamedOperand(MI, AMDGPU::OpName::src2);
// Can't shrink instruction with three operands.
if (Src2) {
switch (MI.getOpcode()) {
default: return false;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x44(%rsi), %r12d
movl %r12d, %edi
movl $0x18, %esi
callq 0x19130e0
movl %eax, %ecx
cmpw $-0x1, %ax
sete %al
movq 0x20(%r14), %r13
testq %r13, %r13
sete %dl
orb %al, %dl
je 0xb63acb
movzwl 0x44(%r14), %edi
movl... | /Target/AMDGPU/SIInstrInfo.cpp |
llvm::SIInstrInfo::splitScalarBinOpN2(llvm::SIInstrWorklist&, llvm::MachineInstr&, unsigned int) const | void SIInstrInfo::splitScalarBinOpN2(SIInstrWorklist &Worklist,
MachineInstr &Inst,
unsigned Opcode) const {
MachineBasicBlock &MBB = *Inst.getParent();
MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
MachineBasicBlock::iterator M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, 0x34(%rsp)
movq %rdx, %r12
movq %rsi, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x18(%rdx), %r13
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%r13), %rax
movq 0x28(%rax), %r15
leaq 0x4bf7277(%rip), %rbx # 0x57682e8
leaq... | /Target/AMDGPU/SIInstrInfo.cpp |
llvm::SIInstrInfo::splitMUBUFOffset(unsigned int, unsigned int&, unsigned int&, llvm::Align) const | bool SIInstrInfo::splitMUBUFOffset(uint32_t Imm, uint32_t &SOffset,
uint32_t &ImmOffset, Align Alignment) const {
const uint32_t MaxOffset = SIInstrInfo::getMaxMUBUFImmOffset(ST);
const uint32_t MaxImm = alignDown(MaxOffset, Alignment.value());
uint32_t Overflow = 0;
if (Imm ... | pushq %rbx
movq %rcx, %rax
movq 0x1e0(%rdi), %rdi
movl 0x1f8(%rdi), %r9d
cmpl $0xb, %r9d
movl $0x7fffff, %ecx # imm = 0x7FFFFF
movl $0xfff, %r10d # imm = 0xFFF
cmovgel %ecx, %r10d
movl $0x1, %r11d
movl %r8d, %ecx
shlq %cl, %r11
movl %r11d, %r8d
negl %r8d
andl %r10d, %r8d
movl %esi, %ecx
subl %r8d, %ec... | /Target/AMDGPU/SIInstrInfo.cpp |
llvm::SITargetLowering::isLegalGlobalAddressingMode(llvm::TargetLoweringBase::AddrMode const&) const | bool SITargetLowering::isLegalGlobalAddressingMode(const AddrMode &AM) const {
if (Subtarget->hasFlatGlobalInsts())
return isLegalFlatAddressingMode(AM, AMDGPUAS::GLOBAL_ADDRESS);
if (!Subtarget->hasAddr64() || Subtarget->useFlatForGlobal()) {
// Assume the we will use FLAT for all global memory accesses
... | movq 0x4e100(%rdi), %rax
cmpb $0x1, 0x2e8(%rax)
jne 0xb78b84
movl $0x1, %edx
jmp 0xb78b04
cmpl $0x6, 0x1f8(%rax)
jg 0xb78b96
cmpb $0x1, 0x273(%rax)
jne 0xb78b9d
xorl %edx, %edx
jmp 0xb78b04
jmp 0xb78ba2
| /Target/AMDGPU/SIISelLowering.cpp |
llvm::SITargetLowering::splitTernaryVectorOp(llvm::SDValue, llvm::SelectionDAG&) const | SDValue SITargetLowering::splitTernaryVectorOp(SDValue Op,
SelectionDAG &DAG) const {
unsigned Opc = Op.getOpcode();
EVT VT = Op.getValueType();
assert(VT == MVT::v4i16 || VT == MVT::v4f16 || VT == MVT::v8i16 ||
VT == MVT::v8f16 || VT == MVT::v4f32 || VT == M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %rbx
movq %rsi, %r14
movl 0x18(%rsi), %eax
movl %eax, 0x5c(%rsp)
movq 0x30(%rsi), %rax
movl %edx, %ecx
shlq $0x4, %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rax,%rcx), %rax
movb %dl, 0x80(%rsp)
movq %rax, 0... | /Target/AMDGPU/SIISelLowering.cpp |
emitRemovedIntrinsicError(llvm::SelectionDAG&, llvm::SDLoc const&, llvm::EVT) | static SDValue emitRemovedIntrinsicError(SelectionDAG &DAG, const SDLoc &DL,
EVT VT) {
DiagnosticInfoUnsupported BadIntrin(DAG.getMachineFunction().getFunction(),
"intrinsic not supported on subtarget",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq (%rax), %r12
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2a23d30
movl $0x14, -0x10(%r15)
movb $0x0, -0xc(%r15)
movq %r12, -0x8(%r15)
leaq 0x4d34048(%rip), %rax # 0x58d0a... | /Target/AMDGPU/SIISelLowering.cpp |
llvm::IRBuilderBase::CreateFAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*) | Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
L, R, nullptr, Name, FPMD);
if (Value *V = Folder.FoldBinOpFMF(I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
cmpb $0x1, 0x6c(%rdi)
jne 0xbaf6be
subq $0x8, %rsp
xorl %eax, %eax
movq %r14, %rdi
movl $0x63, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %rbx,... | /llvm/IR/IRBuilder.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.