name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 $-0xe
popq %rax
addq $0x8, %rsp
retq
|
/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, ConvertibleToStringViewPrinter,
RawBytesPrinter, FallbackPrinter>::type;
Printer::PrintValue(value, os);
}
|
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 if (val >= 1000.0) {
mulfor6 = 1e2;
} else if (val >= 100.0) {
mulfor6 = 1e3;
} else if (val >= 10.0) {
mulfor6 = 1e4;
} else if (val >= 1.0) {
mulfor6 = 1e5;
} else if (val >= 0.1) {
mulfor6 = 1e6;
} else if (val >= 0.01) {
mulfor6 = 1e7;
} else if (val >= 0.001) {
mulfor6 = 1e8;
} else if (val >= 0.0001) {
mulfor6 = 1e9;
}
if (static_cast<float>(static_cast<int32_t>(val * mulfor6 + 0.5)) /
mulfor6 ==
val)
return 6;
} else if (val < 1e10) {
FloatType divfor6 = 1.0;
if (val >= 1e9) { // 1,000,000,000 to 9,999,999,999
divfor6 = 10000;
} else if (val >= 1e8) { // 100,000,000 to 999,999,999
divfor6 = 1000;
} else if (val >= 1e7) { // 10,000,000 to 99,999,999
divfor6 = 100;
} else if (val >= 1e6) { // 1,000,000 to 9,999,999
divfor6 = 10;
}
if (static_cast<float>(static_cast<int32_t>(val / divfor6 + 0.5)) *
divfor6 ==
val)
return 6;
}
return full;
}
|
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), %xmm0
jbe 0x18f9d
movss 0x5630e(%rip), %xmm0 # 0x6f0c8
movss %xmm0, -0x10(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x56290(%rip), %xmm1 # 0x6f060
ucomisd %xmm1, %xmm0
jb 0x18de8
movss 0x562d6(%rip), %xmm0 # 0x6f0b4
movss %xmm0, -0x10(%rbp)
jmp 0x18f5d
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5626f(%rip), %xmm1 # 0x6f068
ucomisd %xmm1, %xmm0
jb 0x18e11
movss 0x562b1(%rip), %xmm0 # 0x6f0b8
movss %xmm0, -0x10(%rbp)
jmp 0x18f5b
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5624e(%rip), %xmm1 # 0x6f070
ucomisd %xmm1, %xmm0
jb 0x18e3a
movss 0x5628c(%rip), %xmm0 # 0x6f0bc
movss %xmm0, -0x10(%rbp)
jmp 0x18f59
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5622d(%rip), %xmm1 # 0x6f078
ucomisd %xmm1, %xmm0
jb 0x18e63
movss 0x56267(%rip), %xmm0 # 0x6f0c0
movss %xmm0, -0x10(%rbp)
jmp 0x18f57
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5620c(%rip), %xmm1 # 0x6f080
ucomisd %xmm1, %xmm0
jb 0x18e8c
movss 0x56242(%rip), %xmm0 # 0x6f0c4
movss %xmm0, -0x10(%rbp)
jmp 0x18f55
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x561eb(%rip), %xmm1 # 0x6f088
ucomisd %xmm1, %xmm0
jb 0x18eb5
movss 0x5622d(%rip), %xmm0 # 0x6f0d8
movss %xmm0, -0x10(%rbp)
jmp 0x18f53
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x561ca(%rip), %xmm1 # 0x6f090
ucomisd %xmm1, %xmm0
jb 0x18edb
movss 0x561dc(%rip), %xmm0 # 0x6f0b0
movss %xmm0, -0x10(%rbp)
jmp 0x18f51
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x561ac(%rip), %xmm1 # 0x6f098
ucomisd %xmm1, %xmm0
jb 0x18f01
movss 0x561da(%rip), %xmm0 # 0x6f0d4
movss %xmm0, -0x10(%rbp)
jmp 0x18f4f
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5618e(%rip), %xmm1 # 0x6f0a0
ucomisd %xmm1, %xmm0
jb 0x18f27
movss 0x561b0(%rip), %xmm0 # 0x6f0d0
movss %xmm0, -0x10(%rbp)
jmp 0x18f4d
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x56170(%rip), %xmm1 # 0x6f0a8
ucomisd %xmm1, %xmm0
jb 0x18f4b
movss 0x56186(%rip), %xmm0 # 0x6f0cc
movss %xmm0, -0x10(%rbp)
jmp 0x18f4d
jmp 0x18f4f
jmp 0x18f51
jmp 0x18f53
jmp 0x18f55
jmp 0x18f57
jmp 0x18f59
jmp 0x18f5b
jmp 0x18f5d
movss -0x8(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x560e5(%rip), %xmm1 # 0x6f058
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
divss -0x10(%rbp), %xmm0
ucomiss -0x8(%rbp), %xmm0
jne 0x18f98
jp 0x18f98
movl $0x6, -0x4(%rbp)
jmp 0x190a3
jmp 0x1909d
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x56082(%rip), %xmm0 # 0x6f030
ucomisd %xmm1, %xmm0
jbe 0x1909b
movss 0x560f4(%rip), %xmm0 # 0x6f0b4
movss %xmm0, -0x14(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x56062(%rip), %xmm1 # 0x6f038
ucomisd %xmm1, %xmm0
jb 0x18feb
movss 0x560e0(%rip), %xmm0 # 0x6f0c4
movss %xmm0, -0x14(%rbp)
jmp 0x19061
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x56044(%rip), %xmm1 # 0x6f040
ucomisd %xmm1, %xmm0
jb 0x19011
movss 0x560b6(%rip), %xmm0 # 0x6f0c0
movss %xmm0, -0x14(%rbp)
jmp 0x1905f
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x56026(%rip), %xmm1 # 0x6f048
ucomisd %xmm1, %xmm0
jb 0x19037
movss 0x5608c(%rip), %xmm0 # 0x6f0bc
movss %xmm0, -0x14(%rbp)
jmp 0x1905d
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x56008(%rip), %xmm1 # 0x6f050
ucomisd %xmm1, %xmm0
jb 0x1905b
movss 0x56062(%rip), %xmm0 # 0x6f0b8
movss %xmm0, -0x14(%rbp)
jmp 0x1905d
jmp 0x1905f
jmp 0x19061
movss -0x8(%rbp), %xmm0
divss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x55fe1(%rip), %xmm1 # 0x6f058
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
mulss -0x14(%rbp), %xmm0
ucomiss -0x8(%rbp), %xmm0
jne 0x19099
jp 0x19099
movl $0x6, -0x4(%rbp)
jmp 0x190a3
jmp 0x1909b
jmp 0x1909d
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
|
/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, -0x50(%rbp)
jmp 0x1c6f6
movq -0x50(%rbp), %rdi
leaq 0x552a9(%rip), %rsi # 0x719aa
callq 0x484d0
movq %rax, -0x58(%rbp)
jmp 0x1c70c
movq -0x58(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1b750
jmp 0x1c71b
leaq -0x28(%rbp), %rdi
callq 0x130a0
leaq -0x20(%rbp), %rdi
movl $0x13, %esi
callq 0x20d60
movq %rax, -0x60(%rbp)
jmp 0x1c738
leaq -0x20(%rbp), %rdi
callq 0xbe78
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x130a0
jmp 0x1c777
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbe78
movq -0x30(%rbp), %rdi
callq 0xbce0
|
/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();
if (flag != nullptr) {
set_write_fd(flag->write_fd());
return EXECUTE_TEST;
}
int pipe_fd[2];
GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
// Clear the close-on-exec flag on the write end of the pipe, lest
// it be closed when the child process does an exec:
GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
"filter=" + info->test_suite_name() + "." +
info->name();
const std::string internal_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
"internal_run_death_test=" + file_ + "|" +
StreamableToString(line_) + "|" +
StreamableToString(death_test_index) + "|" +
StreamableToString(pipe_fd[1]);
std::vector<std::string> args = GetArgvsForDeathTestChildProcess();
args.push_back(filter_flag);
args.push_back(internal_flag);
DeathTest::set_last_death_test_message("");
CaptureStderr();
// See the comment in NoExecDeathTest::AssumeRole for why the next line
// is necessary.
FlushInfoLog();
std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
const pid_t child_pid = ExecDeathTestSpawnChild(argv.get(), pipe_fd[0]);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
set_child_pid(child_pid);
set_read_fd(pipe_fd[0]);
set_spawned(true);
return OVERSEE_TEST;
}
|
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
callq 0x47430
movq %rax, %rdi
callq 0x47450
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c9bb
movq -0x20(%rbp), %rdi
callq 0x47470
movq -0x600(%rbp), %rdi
movl %eax, %esi
callq 0x47370
movl $0x1, -0x4(%rbp)
jmp 0x1d85e
jmp 0x1c9bd
leaq -0x34(%rbp), %rdi
callq 0xba60
cmpl $-0x1, %eax
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb $0x1, %al
jne 0x1cbc1
leaq -0xf9(%rbp), %rdi
movq %rdi, -0x608(%rbp)
callq 0xbcf0
movq -0x608(%rbp), %rdx
leaq 0x54cb4(%rip), %rsi # 0x716b4
leaq -0xf8(%rbp), %rdi
callq 0x12be0
jmp 0x1ca0e
leaq 0x54bad(%rip), %rdx # 0x715c2
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x46bf0
jmp 0x1ca2a
leaq 0x54c97(%rip), %rdx # 0x716c8
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x46bf0
jmp 0x1ca46
movl $0x550, -0x134(%rbp) # imm = 0x550
leaq -0x130(%rbp), %rdi
leaq -0x134(%rbp), %rsi
callq 0x46d10
jmp 0x1ca65
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x130(%rbp), %rdx
callq 0x46c40
jmp 0x1ca81
leaq 0x562b0(%rip), %rdx # 0x72d38
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x46bf0
jmp 0x1ca9a
leaq 0x54ddf(%rip), %rdx # 0x71880
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x46bf0
jmp 0x1cab0
leaq -0x58(%rbp), %rdi
callq 0x1a150
jmp 0x1cabb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cbb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cb98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cb8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cb80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cb74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cb6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbe78
leaq -0x78(%rbp), %rdi
callq 0xbe78
leaq -0x98(%rbp), %rdi
callq 0xbe78
leaq -0x130(%rbp), %rdi
callq 0xbe78
leaq -0xb8(%rbp), %rdi
callq 0xbe78
leaq -0xd8(%rbp), %rdi
callq 0xbe78
leaq -0xf8(%rbp), %rdi
callq 0xbe78
leaq -0xf9(%rbp), %rdi
callq 0xb760
jmp 0x1d86a
jmp 0x1cbc3
callq 0x46d90
testb $0x1, %al
jne 0x1c9bd
jmp 0x1cbd2
movl -0x30(%rbp), %edi
movl $0x2, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0xb3e0
cmpl $-0x1, %eax
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1c8e0
testb $0x1, %al
jne 0x1cdf0
leaq -0x1f9(%rbp), %rdi
movq %rdi, -0x610(%rbp)
callq 0xbcf0
movq -0x610(%rbp), %rdx
leaq 0x54a97(%rip), %rsi # 0x716b4
leaq -0x1f8(%rbp), %rdi
callq 0x12be0
jmp 0x1cc2b
leaq 0x54990(%rip), %rdx # 0x715c2
leaq -0x1d8(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x46bf0
jmp 0x1cc47
leaq 0x54a7a(%rip), %rdx # 0x716c8
leaq -0x1b8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x46bf0
jmp 0x1cc63
movl $0x553, -0x224(%rbp) # imm = 0x553
leaq -0x220(%rbp), %rdi
leaq -0x224(%rbp), %rsi
callq 0x46d10
jmp 0x1cc82
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
leaq -0x220(%rbp), %rdx
callq 0x46c40
jmp 0x1cc9e
leaq 0x56093(%rip), %rdx # 0x72d38
leaq -0x178(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x46bf0
jmp 0x1ccba
leaq 0x54c07(%rip), %rdx # 0x718c8
leaq -0x158(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x46bf0
jmp 0x1ccd6
leaq -0x158(%rbp), %rdi
callq 0x1a150
jmp 0x1cce4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cdd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cdc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cdbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cdaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cda3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1cd97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xbe78
leaq -0x178(%rbp), %rdi
callq 0xbe78
leaq -0x198(%rbp), %rdi
callq 0xbe78
leaq -0x220(%rbp), %rdi
callq 0xbe78
leaq -0x1b8(%rbp), %rdi
callq 0xbe78
leaq -0x1d8(%rbp), %rdi
callq 0xbe78
leaq -0x1f8(%rbp), %rdi
callq 0xbe78
leaq -0x1f9(%rbp), %rdi
callq 0xb760
jmp 0x1d86a
jmp 0x1cdf2
callq 0x46d90
testb $0x1, %al
jne 0x1cbd2
leaq -0x2e9(%rbp), %rdi
movq %rdi, -0x618(%rbp)
callq 0xbcf0
movq -0x618(%rbp), %rdx
leaq 0x56332(%rip), %rsi # 0x73152
leaq -0x2e8(%rbp), %rdi
callq 0x12be0
jmp 0x1ce2e
leaq 0x54ab7(%rip), %rdx # 0x718ec
leaq -0x2c8(%rbp), %rdi
leaq -0x2e8(%rbp), %rsi
callq 0x46bf0
jmp 0x1ce4a
leaq 0x54aa2(%rip), %rdx # 0x718f3
leaq -0x2a8(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x46bf0
jmp 0x1ce66
movq -0x28(%rbp), %rdi
callq 0x47490
movq %rax, -0x620(%rbp)
jmp 0x1ce78
movq -0x620(%rbp), %rdx
leaq -0x288(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
callq 0x46bf0
jmp 0x1ce94
leaq 0x55e9a(%rip), %rdx # 0x72d35
leaq -0x268(%rbp), %rdi
leaq -0x288(%rbp), %rsi
callq 0x46bf0
jmp 0x1ceb0
movq -0x28(%rbp), %rdi
callq 0x474b0
movq %rax, -0x628(%rbp)
jmp 0x1cec2
movq -0x628(%rbp), %rdx
leaq -0x248(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x46bf0
jmp 0x1cede
leaq -0x268(%rbp), %rdi
callq 0xbe78
leaq -0x288(%rbp), %rdi
callq 0xbe78
leaq -0x2a8(%rbp), %rdi
callq 0xbe78
leaq -0x2c8(%rbp), %rdi
callq 0xbe78
leaq -0x2e8(%rbp), %rdi
callq 0xbe78
leaq -0x2e9(%rbp), %rdi
callq 0xb760
leaq -0x431(%rbp), %rdi
movq %rdi, -0x630(%rbp)
callq 0xbcf0
movq -0x630(%rbp), %rdx
leaq 0x5620b(%rip), %rsi # 0x73152
leaq -0x430(%rbp), %rdi
callq 0x12be0
jmp 0x1cf55
leaq 0x54990(%rip), %rdx # 0x718ec
leaq -0x410(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x46bf0
jmp 0x1cf71
leaq 0x54983(%rip), %rdx # 0x718fb
leaq -0x3f0(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x46bf0
jmp 0x1cf8d
movq -0x600(%rbp), %rax
movq 0x40(%rax), %rdx
leaq -0x3d0(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x46bf0
jmp 0x1cfad
leaq 0x54960(%rip), %rdx # 0x71914
leaq -0x3b0(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
callq 0x46bf0
jmp 0x1cfc9
movq -0x600(%rbp), %rsi
addq $0x48, %rsi
leaq -0x458(%rbp), %rdi
callq 0x46d10
jmp 0x1cfe2
leaq -0x390(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
leaq -0x458(%rbp), %rdx
callq 0x46c40
jmp 0x1cffe
leaq 0x5490f(%rip), %rdx # 0x71914
leaq -0x370(%rbp), %rdi
leaq -0x390(%rbp), %rsi
callq 0x46bf0
jmp 0x1d01a
leaq -0x478(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x46d10
jmp 0x1d02c
leaq -0x350(%rbp), %rdi
leaq -0x370(%rbp), %rsi
leaq -0x478(%rbp), %rdx
callq 0x46c40
jmp 0x1d048
leaq 0x548c5(%rip), %rdx # 0x71914
leaq -0x330(%rbp), %rdi
leaq -0x350(%rbp), %rsi
callq 0x46bf0
jmp 0x1d064
leaq -0x30(%rbp), %rsi
leaq -0x498(%rbp), %rdi
callq 0x46d10
jmp 0x1d076
leaq -0x310(%rbp), %rdi
leaq -0x330(%rbp), %rsi
leaq -0x498(%rbp), %rdx
callq 0x46c40
jmp 0x1d092
leaq -0x498(%rbp), %rdi
callq 0xbe78
leaq -0x330(%rbp), %rdi
callq 0xbe78
leaq -0x350(%rbp), %rdi
callq 0xbe78
leaq -0x478(%rbp), %rdi
callq 0xbe78
leaq -0x370(%rbp), %rdi
callq 0xbe78
leaq -0x390(%rbp), %rdi
callq 0xbe78
leaq -0x458(%rbp), %rdi
callq 0xbe78
leaq -0x3b0(%rbp), %rdi
callq 0xbe78
leaq -0x3d0(%rbp), %rdi
callq 0xbe78
leaq -0x3f0(%rbp), %rdi
callq 0xbe78
leaq -0x410(%rbp), %rdi
callq 0xbe78
leaq -0x430(%rbp), %rdi
callq 0xbe78
leaq -0x431(%rbp), %rdi
callq 0xb760
leaq -0x4b0(%rbp), %rdi
callq 0x474d0
jmp 0x1d13c
leaq -0x4b0(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x47510
jmp 0x1d151
leaq -0x4b0(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x47510
jmp 0x1d166
leaq -0x4d1(%rbp), %rdi
movq %rdi, -0x638(%rbp)
callq 0xbcf0
movq -0x638(%rbp), %rdx
leaq 0x557ee(%rip), %rsi # 0x72975
leaq -0x4d0(%rbp), %rdi
callq 0x12be0
jmp 0x1d195
leaq -0x4d0(%rbp), %rdi
callq 0x1a2f0
jmp 0x1d1a3
leaq -0x4d0(%rbp), %rdi
callq 0xbe78
leaq -0x4d1(%rbp), %rdi
callq 0xb760
callq 0x1c900
jmp 0x1d1c2
callq 0x47340
jmp 0x1d1c9
leaq -0x4e0(%rbp), %rdi
leaq -0x4b0(%rbp), %rsi
callq 0x1b790
jmp 0x1d1de
leaq -0x4e0(%rbp), %rdi
callq 0x47580
movq %rax, %rdi
movl -0x34(%rbp), %esi
callq 0x1d880
movl %eax, -0x63c(%rbp)
jmp 0x1d1fd
movl -0x63c(%rbp), %eax
movl %eax, -0x4e4(%rbp)
jmp 0x1d20b
movl -0x30(%rbp), %edi
callq 0xbe20
movl %eax, -0x640(%rbp)
jmp 0x1d21b
movl -0x640(%rbp), %eax
movl %eax, -0x4e8(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x4e8(%rbp)
movb %al, -0x641(%rbp)
jne 0x1d249
callq 0xb080
cmpl $0x4, (%rax)
sete %al
movb %al, -0x641(%rbp)
movb -0x641(%rbp), %al
testb $0x1, %al
jne 0x1d20b
cmpl $-0x1, -0x4e8(%rbp)
jne 0x1d79c
leaq -0x5c9(%rbp), %rdi
movq %rdi, -0x650(%rbp)
callq 0xbcf0
movq -0x650(%rbp), %rdx
leaq 0x54433(%rip), %rsi # 0x716b4
leaq -0x5c8(%rbp), %rdi
callq 0x12be0
jmp 0x1d28f
leaq 0x5432c(%rip), %rdx # 0x715c2
leaq -0x5a8(%rbp), %rdi
leaq -0x5c8(%rbp), %rsi
callq 0x46bf0
jmp 0x1d2ab
leaq 0x54416(%rip), %rdx # 0x716c8
leaq -0x588(%rbp), %rdi
leaq -0x5a8(%rbp), %rsi
callq 0x46bf0
jmp 0x1d2c7
movl $0x56a, -0x5f4(%rbp) # imm = 0x56A
leaq -0x5f0(%rbp), %rdi
leaq -0x5f4(%rbp), %rsi
callq 0x46d10
jmp 0x1d2e6
leaq -0x568(%rbp), %rdi
leaq -0x588(%rbp), %rsi
leaq -0x5f0(%rbp), %rdx
callq 0x46c40
jmp 0x1d302
leaq 0x55a2f(%rip), %rdx # 0x72d38
leaq -0x548(%rbp), %rdi
leaq -0x568(%rbp), %rsi
callq 0x46bf0
jmp 0x1d31e
leaq 0x54591(%rip), %rdx # 0x718b6
leaq -0x528(%rbp), %rdi
leaq -0x548(%rbp), %rsi
callq 0x46bf0
jmp 0x1d33a
leaq 0x545a4(%rip), %rdx # 0x718e5
leaq -0x508(%rbp), %rdi
leaq -0x528(%rbp), %rsi
callq 0x46bf0
jmp 0x1d356
leaq -0x508(%rbp), %rdi
callq 0x1a150
jmp 0x1d364
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d40d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d401
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d3f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d3e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x268(%rbp), %rdi
callq 0xbe78
leaq -0x288(%rbp), %rdi
callq 0xbe78
leaq -0x2a8(%rbp), %rdi
callq 0xbe78
leaq -0x2c8(%rbp), %rdi
callq 0xbe78
leaq -0x2e8(%rbp), %rdi
callq 0xbe78
leaq -0x2e9(%rbp), %rdi
callq 0xb760
jmp 0x1d86a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d5d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d5c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d5bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d5b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d5a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d58c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d580
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d574
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d55c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d550
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x498(%rbp), %rdi
callq 0xbe78
leaq -0x330(%rbp), %rdi
callq 0xbe78
leaq -0x350(%rbp), %rdi
callq 0xbe78
leaq -0x478(%rbp), %rdi
callq 0xbe78
leaq -0x370(%rbp), %rdi
callq 0xbe78
leaq -0x390(%rbp), %rdi
callq 0xbe78
leaq -0x458(%rbp), %rdi
callq 0xbe78
leaq -0x3b0(%rbp), %rdi
callq 0xbe78
leaq -0x3d0(%rbp), %rdi
callq 0xbe78
leaq -0x3f0(%rbp), %rdi
callq 0xbe78
leaq -0x410(%rbp), %rdi
callq 0xbe78
leaq -0x430(%rbp), %rdi
callq 0xbe78
leaq -0x431(%rbp), %rdi
callq 0xb760
jmp 0x1d850
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d844
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x4d0(%rbp), %rdi
callq 0xbe78
leaq -0x4d1(%rbp), %rdi
callq 0xb760
jmp 0x1d838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d82c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d78b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d77f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d773
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d767
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d75b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d74f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x1d737
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x508(%rbp), %rdi
callq 0xbe78
leaq -0x528(%rbp), %rdi
callq 0xbe78
leaq -0x548(%rbp), %rdi
callq 0xbe78
leaq -0x568(%rbp), %rdi
callq 0xbe78
leaq -0x5f0(%rbp), %rdi
callq 0xbe78
leaq -0x588(%rbp), %rdi
callq 0xbe78
leaq -0x5a8(%rbp), %rdi
callq 0xbe78
leaq -0x5c8(%rbp), %rdi
callq 0xbe78
leaq -0x5c9(%rbp), %rdi
callq 0xb760
jmp 0x1d82c
jmp 0x1d79e
callq 0x46d90
movb %al, -0x651(%rbp)
jmp 0x1d7ab
movb -0x651(%rbp), %al
testb $0x1, %al
jne 0x1d209
jmp 0x1d7bb
movq -0x600(%rbp), %rdi
movl -0x4e4(%rbp), %esi
callq 0x47350
jmp 0x1d7cf
movq -0x600(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x46da0
jmp 0x1d7e0
movq -0x600(%rbp), %rdi
movl $0x1, %esi
callq 0x473c0
jmp 0x1d7f3
movl $0x0, -0x4(%rbp)
leaq -0x4e0(%rbp), %rdi
callq 0x47220
leaq -0x4b0(%rbp), %rdi
callq 0x475b0
leaq -0x310(%rbp), %rdi
callq 0xbe78
leaq -0x248(%rbp), %rdi
callq 0xbe78
jmp 0x1d85e
leaq -0x4e0(%rbp), %rdi
callq 0x47220
leaq -0x4b0(%rbp), %rdi
callq 0x475b0
leaq -0x310(%rbp), %rdi
callq 0xbe78
leaq -0x248(%rbp), %rdi
callq 0xbe78
jmp 0x1d86a
movl -0x4(%rbp), %eax
addq $0x660, %rsp # imm = 0x660
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 InternalRunDeathTestFlag* const flag =
impl->internal_run_death_test_flag();
const int death_test_index =
impl->current_test_info()->increment_death_test_count();
if (flag != nullptr) {
if (death_test_index > flag->index()) {
DeathTest::set_last_death_test_message(
"Death test count (" + StreamableToString(death_test_index) +
") somehow exceeded expected maximum (" +
StreamableToString(flag->index()) + ")");
return false;
}
if (!(flag->file() == file && flag->line() == line &&
flag->index() == death_test_index)) {
*test = nullptr;
return true;
}
}
#ifdef GTEST_OS_WINDOWS
if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new WindowsDeathTest(statement, std::move(matcher), file, line);
}
#elif defined(GTEST_OS_FUCHSIA)
if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
}
#else
if (GTEST_FLAG_GET(death_test_style) == "threadsafe") {
*test = new ExecDeathTest(statement, std::move(matcher), file, line);
} else if (GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new NoExecDeathTest(statement, std::move(matcher));
}
#endif // GTEST_OS_WINDOWS
else { // NOLINT - this is more readable than unbalanced brackets inside #if.
DeathTest::set_last_death_test_message("Unknown death test style \"" +
GTEST_FLAG_GET(death_test_style) +
"\" encountered");
return false;
}
|
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, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x46ab0
movq %rax, %rdi
callq 0x47610
movl %eax, -0x4c(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x1eae0
movl -0x4c(%rbp), %eax
movl %eax, -0x1b4(%rbp)
movq -0x48(%rbp), %rdi
callq 0x47640
movl %eax, %ecx
movl -0x1b4(%rbp), %eax
cmpl %ecx, %eax
jle 0x1ea93
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x46d10
movq -0x1c0(%rbp), %rdx
leaq 0x53030(%rip), %rsi # 0x71916
leaq -0xd0(%rbp), %rdi
callq 0x47660
jmp 0x1e8f4
leaq 0x5302e(%rip), %rdx # 0x71929
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x46bf0
jmp 0x1e910
movq -0x48(%rbp), %rdi
callq 0x47640
movl %eax, -0x1c4(%rbp)
jmp 0x1e921
movl -0x1c4(%rbp), %eax
movl %eax, -0x124(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x124(%rbp), %rsi
callq 0x46d10
jmp 0x1e942
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x46c40
jmp 0x1e95e
leaq 0x53e38(%rip), %rdx # 0x7279d
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x46bf0
jmp 0x1e977
leaq -0x70(%rbp), %rdi
callq 0x1a2f0
jmp 0x1e982
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0x90(%rbp), %rdi
callq 0xbe78
leaq -0x120(%rbp), %rdi
callq 0xbe78
leaq -0xb0(%rbp), %rdi
callq 0xbe78
leaq -0xd0(%rbp), %rdi
callq 0xbe78
leaq -0xf0(%rbp), %rdi
callq 0xbe78
movb $0x0, -0x1(%rbp)
jmp 0x1ed69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ea82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ea76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ea6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ea5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ea52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0x90(%rbp), %rdi
callq 0xbe78
leaq -0x120(%rbp), %rdi
callq 0xbe78
leaq -0xb0(%rbp), %rdi
callq 0xbe78
leaq -0xd0(%rbp), %rdi
callq 0xbe78
leaq -0xf0(%rbp), %rdi
callq 0xbe78
jmp 0x1ed77
movq -0x48(%rbp), %rdi
callq 0x476b0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x46a40
testb $0x1, %al
jne 0x1eaae
jmp 0x1eaca
movq -0x48(%rbp), %rdi
callq 0x476c0
cmpl -0x2c(%rbp), %eax
jne 0x1eaca
movq -0x48(%rbp), %rdi
callq 0x47640
cmpl -0x4c(%rbp), %eax
je 0x1eade
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1ed69
jmp 0x1eae0
leaq 0x83d31(%rip), %rdi # 0xa2818
leaq 0x52a8b(%rip), %rsi # 0x71579
callq 0x46a40
testb $0x1, %al
jne 0x1eafc
jmp 0x1ebd1
movl $0x50, %edi
callq 0xb690
movq -0x1b0(%rbp), %rsi
movq %rax, -0x1d8(%rbp)
movb $0x1, -0x141(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x46b00
jmp 0x1eb34
movq -0x1d0(%rbp), %rsi
movq -0x1d8(%rbp), %rdi
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
leaq -0x140(%rbp), %rdx
callq 0x476e0
jmp 0x1eb58
movq -0x1d8(%rbp), %rcx
movb $0x0, -0x141(%rbp)
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x140(%rbp), %rdi
callq 0x46b40
jmp 0x1ed65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ebb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x46b40
testb $0x1, -0x141(%rbp)
jne 0x1ebbb
jmp 0x1ebcc
movq -0x1d8(%rbp), %rdi
movl $0x50, %esi
callq 0xb6c0
jmp 0x1ed77
leaq 0x83c40(%rip), %rdi # 0xa2818
leaq 0x53081(%rip), %rsi # 0x71c60
callq 0x46a40
testb $0x1, %al
jne 0x1ebed
jmp 0x1ecba
movl $0x40, %edi
callq 0xb690
movq -0x1b0(%rbp), %rsi
movq %rax, -0x1e8(%rbp)
movb $0x1, -0x161(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x46b00
jmp 0x1ec25
movq -0x1e0(%rbp), %rsi
movq -0x1e8(%rbp), %rdi
leaq -0x160(%rbp), %rdx
callq 0x47790
jmp 0x1ec41
movq -0x1e8(%rbp), %rcx
movb $0x0, -0x161(%rbp)
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x160(%rbp), %rdi
callq 0x46b40
jmp 0x1ed63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ec99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x46b40
testb $0x1, -0x161(%rbp)
jne 0x1eca4
jmp 0x1ecb5
movq -0x1e8(%rbp), %rdi
movl $0x40, %esi
callq 0xb6c0
jmp 0x1ed77
leaq 0x52c8e(%rip), %rsi # 0x7194f
leaq 0x83b50(%rip), %rdx # 0xa2818
leaq -0x1a8(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x47820
movq -0x1f0(%rbp), %rsi
leaq 0x52c81(%rip), %rdx # 0x7196a
leaq -0x188(%rbp), %rdi
callq 0x46bf0
jmp 0x1ecf7
leaq -0x188(%rbp), %rdi
callq 0x1a2f0
jmp 0x1ed05
leaq -0x188(%rbp), %rdi
callq 0xbe78
leaq -0x1a8(%rbp), %rdi
callq 0xbe78
movb $0x0, -0x1(%rbp)
jmp 0x1ed69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
jmp 0x1ed55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xbe78
leaq -0x1a8(%rbp), %rdi
callq 0xbe78
jmp 0x1ed77
jmp 0x1ed65
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 == ::std::string::npos) {
parsed.push_back(str.substr(pos));
break;
} else {
parsed.push_back(str.substr(pos, colon - pos));
pos = colon + 1;
}
}
dest->swap(parsed);
}
|
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
movb -0x9(%rbp), %al
movq -0x38(%rbp), %rdx
movsbl %al, %esi
callq 0xb9d0
movq %rax, -0x50(%rbp)
cmpq $-0x1, -0x50(%rbp)
jne 0x1f006
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq $-0x1, %rcx
callq 0xb6f0
jmp 0x1efbe
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x49b30
jmp 0x1efcd
leaq -0x70(%rbp), %rdi
callq 0xbe78
jmp 0x1f06e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1f08d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbe78
jmp 0x1f08d
movq -0x8(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
subq %rdx, %rcx
leaq -0x90(%rbp), %rdi
callq 0xb6f0
jmp 0x1f023
leaq -0x30(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x49b30
jmp 0x1f035
leaq -0x90(%rbp), %rdi
callq 0xbe78
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1f069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xbe78
jmp 0x1f08d
jmp 0x1ef6a
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x49b60
leaq -0x30(%rbp), %rdi
callq 0x475b0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x475b0
movq -0x40(%rbp), %rdi
callq 0xbce0
nop
|
/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
je 0x1f585
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x78(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xbcf0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movb $0x1, -0x3a(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x12be0
jmp 0x1f570
movq -0x68(%rbp), %rdi
movb $0x1, -0x4d(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x47ae0
jmp 0x1f583
jmp 0x1f596
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x47b30
jmp 0x1f594
jmp 0x1f596
testb $0x1, -0x4d(%rbp)
jne 0x1f59e
jmp 0x1f5a7
leaq -0x38(%rbp), %rdi
callq 0xbe78
testb $0x1, -0x3a(%rbp)
jne 0x1f5af
jmp 0x1f5b8
leaq -0x39(%rbp), %rdi
callq 0xb760
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1f5f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x1f5e7
jmp 0x1f5f0
leaq -0x38(%rbp), %rdi
callq 0xbe78
jmp 0x1f5f2
testb $0x1, -0x3a(%rbp)
jne 0x1f5fa
jmp 0x1f603
leaq -0x39(%rbp), %rdi
callq 0xb760
jmp 0x1f605
movq -0x48(%rbp), %rdi
callq 0xbce0
nop
|
/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.string() + "_" + StreamableToString(number) + "." + extension;
}
return ConcatPaths(directory, FilePath(file));
}
|
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
movq -0x18(%rbp), %rdi
callq 0x47cc0
movq %rax, -0x170(%rbp)
jmp 0x1f7b4
movq -0x170(%rbp), %rsi
leaq 0x53573(%rip), %rdx # 0x72d35
leaq -0x88(%rbp), %rdi
callq 0x47c40
jmp 0x1f7d0
movq -0x28(%rbp), %rdx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x46bf0
jmp 0x1f7e6
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb8f0
leaq -0x68(%rbp), %rdi
callq 0xbe78
leaq -0x88(%rbp), %rdi
callq 0xbe78
jmp 0x1f9a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1fa25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xbe78
jmp 0x1fa25
movq -0x18(%rbp), %rdi
callq 0x47cc0
movq %rax, -0x178(%rbp)
jmp 0x1f859
movq -0x178(%rbp), %rsi
leaq 0x52225(%rip), %rdx # 0x71a8c
leaq -0x118(%rbp), %rdi
callq 0x47c40
jmp 0x1f875
leaq -0x138(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x46d10
jmp 0x1f887
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x138(%rbp), %rdx
callq 0x46c40
jmp 0x1f8a3
leaq 0x5348b(%rip), %rdx # 0x72d35
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x46bf0
jmp 0x1f8bf
movq -0x28(%rbp), %rdx
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x46bf0
jmp 0x1f8d8
leaq -0x48(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xb8f0
leaq -0xb8(%rbp), %rdi
callq 0xbe78
leaq -0xd8(%rbp), %rdi
callq 0xbe78
leaq -0xf8(%rbp), %rdi
callq 0xbe78
leaq -0x138(%rbp), %rdi
callq 0xbe78
leaq -0x118(%rbp), %rdi
callq 0xbe78
jmp 0x1f9a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1f99b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1f98f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x1f983
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0xbe78
leaq -0xf8(%rbp), %rdi
callq 0xbe78
leaq -0x138(%rbp), %rdi
callq 0xbe78
leaq -0x118(%rbp), %rdi
callq 0xbe78
jmp 0x1fa25
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x158(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x47ae0
jmp 0x1f9c6
movq -0x180(%rbp), %rsi
movq -0x168(%rbp), %rdi
leaq -0x158(%rbp), %rdx
callq 0x1fa40
jmp 0x1f9e2
leaq -0x158(%rbp), %rdi
callq 0x47cd0
leaq -0x48(%rbp), %rdi
callq 0xbe78
movq -0x160(%rbp), %rax
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x47cd0
leaq -0x48(%rbp), %rdi
callq 0xbe78
movq -0x90(%rbp), %rdi
callq 0xbce0
nopw (%rax,%rax)
|
/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(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xb6f0
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movb $0x1, -0x31(%rbp)
callq 0x47ae0
jmp 0x1fbf9
jmp 0x1fc0c
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x47b30
jmp 0x1fc0a
jmp 0x1fc0c
testb $0x1, -0x31(%rbp)
jne 0x1fc14
jmp 0x1fc1d
leaq -0x30(%rbp), %rdi
callq 0xbe78
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x1fc3b
jmp 0x1fc44
leaq -0x30(%rbp), %rdi
callq 0xbe78
jmp 0x1fc46
movq -0x40(%rbp), %rdi
callq 0xbce0
nop
|
/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
const FilePath& path(*this);
#endif
#ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode;
if ((attributes != kInvalidFileAttributes) &&
(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
result = true;
}
#else
posix::StatStruct file_stat{};
result =
posix::Stat(path.c_str(), &file_stat) == 0 && posix::IsDir(file_stat);
#endif // GTEST_OS_WINDOWS_MOBILE
return result;
}
|
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, %eax
cmpl $0x0, %ecx
movb %al, -0xa9(%rbp)
jne 0x1fd17
leaq -0xa8(%rbp), %rdi
callq 0x47e10
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
|
/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 -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x48080
jmp 0x20470
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x48190
jmp 0x2047f
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x481d0
jmp 0x2048e
leaq -0x28(%rbp), %rdi
callq 0x48200
leaq -0x48(%rbp), %rdi
callq 0x48120
leaq -0x68(%rbp), %rdi
callq 0xbe78
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x20503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x204fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x204f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x48200
leaq -0x48(%rbp), %rdi
callq 0x48120
leaq -0x68(%rbp), %rdi
callq 0xbe78
movq -0x80(%rbp), %rdi
callq 0x5ced0
movq -0x70(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x48080
jmp 0x20a30
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x483c0
jmp 0x20a3f
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x48400
jmp 0x20a4e
leaq -0x28(%rbp), %rdi
callq 0x48430
leaq -0x48(%rbp), %rdi
callq 0x48120
leaq -0x68(%rbp), %rdi
callq 0xbe78
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x20ac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x20aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x20ab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x48430
leaq -0x48(%rbp), %rdi
callq 0x48120
leaq -0x68(%rbp), %rdi
callq 0xbe78
movq -0x80(%rbp), %rdi
callq 0x5cfb0
movq -0x70(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 0xbe78
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x14840
nopw %cs:(%rax,%rax)
|
/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
<< "\n Actual: " << actual_predicate_value;
if (actual_message[0] != '\0') msg << " (" << actual_message << ")";
msg << "\nExpected: " << expected_predicate_value;
return msg.GetString();
}
|
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(%rbp)
callq 0x28170
movq -0x58(%rbp), %rdi
leaq 0x50f94(%rip), %rsi # 0x721f3
callq 0x4a610
movq %rax, -0x50(%rbp)
jmp 0x2126a
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15a60
movq %rax, -0x70(%rbp)
jmp 0x2127d
movq -0x70(%rbp), %rdi
leaq 0x50f76(%rip), %rsi # 0x721fe
callq 0x15870
movq %rax, -0x78(%rbp)
jmp 0x21293
movq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x15a60
jmp 0x212a2
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x21308
leaq 0x4e155(%rip), %rsi # 0x6f40a
leaq -0x38(%rbp), %rdi
callq 0x15ad0
movq %rax, -0x80(%rbp)
jmp 0x212c4
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15a60
movq %rax, -0x88(%rbp)
jmp 0x212da
movq -0x88(%rbp), %rdi
leaq 0x514b5(%rip), %rsi # 0x7279d
callq 0x46e90
jmp 0x212ef
jmp 0x21308
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x130a0
jmp 0x21358
leaq 0x50efb(%rip), %rsi # 0x7220a
leaq -0x38(%rbp), %rdi
callq 0x15870
movq %rax, -0x90(%rbp)
jmp 0x21321
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15a60
jmp 0x21333
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b750
jmp 0x21342
leaq -0x38(%rbp), %rdi
callq 0x130a0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 + ":" + StreamableToString(line) + ":";
#endif // _MSC_VER
}
|
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, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xbcf0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x12be0
jmp 0x214f0
leaq -0x39(%rbp), %rdi
callq 0xb760
cmpl $0x0, -0x14(%rbp)
jge 0x2154f
movq -0xc0(%rbp), %rdi
leaq 0x51977(%rip), %rdx # 0x72e84
leaq -0x38(%rbp), %rsi
callq 0x47c40
jmp 0x21518
movl $0x1, -0x50(%rbp)
jmp 0x21621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xb760
jmp 0x21643
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2163a
leaq 0x5192e(%rip), %rdx # 0x72e84
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x47c40
jmp 0x21568
leaq -0xb0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x46d10
jmp 0x2157a
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x46c40
jmp 0x21593
movq -0xc0(%rbp), %rdi
leaq 0x518e3(%rip), %rdx # 0x72e84
leaq -0x70(%rbp), %rsi
callq 0x46bf0
jmp 0x215ac
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0xb0(%rbp), %rdi
callq 0xbe78
leaq -0x90(%rbp), %rdi
callq 0xbe78
movl $0x1, -0x50(%rbp)
jmp 0x21621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x21613
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x21607
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0xb0(%rbp), %rdi
callq 0xbe78
leaq -0x90(%rbp), %rdi
callq 0xbe78
jmp 0x2163a
leaq -0x38(%rbp), %rdi
callq 0xbe78
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xbe78
movq -0x48(%rbp), %rdi
callq 0xbce0
nopl (%rax)
|
/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 ]"
: "[ FATAL ]";
GetStream() << ::std::endl
<< marker << " " << FormatFileLocation(file, line).c_str()
<< ": ";
}
|
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 0x2186c
cmpl $0x1, -0xc(%rbp)
jne 0x2183c
leaq 0x5026d(%rip), %rax # 0x71aa3
movq %rax, -0x70(%rbp)
jmp 0x21864
cmpl $0x2, -0xc(%rbp)
jne 0x2184f
leaq 0x50264(%rip), %rax # 0x71aad
movq %rax, -0x78(%rbp)
jmp 0x2185c
leaq 0x50261(%rip), %rax # 0x71ab7
movq %rax, -0x78(%rbp)
jmp 0x2185c
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x17df0
movq %rax, %rdi
movq 0x80721(%rip), %rsi # 0xa1fa8
callq 0xb710
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xb670
movq %rax, %rdi
leaq 0x50923(%rip), %rsi # 0x721c5
callq 0xb670
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x21470
movq -0x90(%rbp), %rdi
callq 0xb290
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xb670
movq %rax, -0x80(%rbp)
jmp 0x218e6
movq -0x80(%rbp), %rdi
leaq 0x51447(%rip), %rsi # 0x72d38
callq 0xb670
jmp 0x218f8
leaq -0x48(%rbp), %rdi
callq 0xbe78
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xbe78
movq -0x50(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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 0x217f0
movq -0x40(%rbp), %rdi
callq 0x17df0
movq %rax, %rdi
leaq 0x51ab7(%rip), %rsi # 0x734b9
callq 0xb670
movq %rax, -0x38(%rbp)
jmp 0x21a0d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq %rax, -0x48(%rbp)
jmp 0x21a20
movq -0x48(%rbp), %rdi
leaq 0x51a98(%rip), %rsi # 0x734c3
callq 0xb670
jmp 0x21a32
leaq -0x1c(%rbp), %rdi
callq 0x21930
jmp 0x21a54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x21930
jmp 0x21a9d
movl $0x28, %edi
callq 0xb690
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %esi
callq 0x52020
jmp 0x21a72
movq -0x50(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0xb6c0
movq -0x28(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 until we cannot read further or the
// pre-determined file size is reached.
do {
bytes_last_read =
fread(buffer + bytes_read, 1, file_size - bytes_read, file);
bytes_read += bytes_last_read;
} while (bytes_last_read > 0 && bytes_read < file_size);
const std::string content(buffer, bytes_read);
delete[] buffer;
return content;
}
|
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 -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xb7e0
movq -0x20(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
subq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0xbb50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x59(%rbp)
jbe 0x21c2f
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x21be7
movb $0x0, -0x31(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x32(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xbcf0
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0xb800
jmp 0x21c6e
leaq -0x32(%rbp), %rdi
callq 0xb760
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x21c8e
movq -0x80(%rbp), %rdi
callq 0xb9a0
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x21cba
jmp 0x21cb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x32(%rbp), %rdi
callq 0xb760
jmp 0x21cc7
movq -0x58(%rbp), %rdi
callq 0xbe78
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xbce0
|
/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_flag;
}
|
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
leaq -0xa(%rbp), %rdi
callq 0xb760
leaq 0x4f5cd(%rip), %rdi # 0x71b71
callq 0x488f0
movq %rax, -0x90(%rbp)
jmp 0x225b2
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x22682
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xbcf0
movq -0x98(%rbp), %rdx
leaq 0x4f59a(%rip), %rsi # 0x71b81
leaq -0x68(%rbp), %rdi
callq 0x12be0
jmp 0x225f2
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x46bf0
jmp 0x22605
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb8f0
leaq -0x48(%rbp), %rdi
callq 0xbe78
leaq -0x68(%rbp), %rdi
callq 0xbe78
leaq -0x69(%rbp), %rdi
callq 0xb760
jmp 0x22682
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0xb760
jmp 0x226ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x226a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x22677
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xbe78
leaq -0x69(%rbp), %rdi
callq 0xb760
jmp 0x226a5
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x22695
movq -0x80(%rbp), %rdi
callq 0xbe78
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xbe78
movq -0x18(%rbp), %rdi
callq 0xbce0
nopw (%rax,%rax)
|
/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.type() == TestPartResult::kSkip ? "Skipped"
: result.type() == TestPartResult::kFatalFailure
? "Fatal failure"
: "Non-fatal failure")
<< ":\n"
<< result.message() << std::endl;
}
|
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)
callq 0x21470
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xb5d0
movq %rax, -0x48(%rbp)
jmp 0x23777
movq -0x48(%rbp), %rdi
leaq 0x4ea43(%rip), %rsi # 0x721c5
callq 0xb670
movq %rax, -0x68(%rbp)
jmp 0x2378d
movq -0x10(%rbp), %rdi
callq 0x48ec0
movl %eax, -0x6c(%rbp)
jmp 0x2379b
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
jne 0x237b0
leaq 0x4e3df(%rip), %rax # 0x71b89
movq %rax, -0x78(%rbp)
jmp 0x23814
movq -0x10(%rbp), %rdi
callq 0x48ec0
movl %eax, -0x7c(%rbp)
jmp 0x237be
movl -0x7c(%rbp), %eax
cmpl $0x3, %eax
jne 0x237d6
leaq 0x4e3c4(%rip), %rax # 0x71b91
movq %rax, -0x88(%rbp)
jmp 0x23809
movq -0x10(%rbp), %rdi
callq 0x48ec0
movl %eax, -0x8c(%rbp)
jmp 0x237e7
movl -0x8c(%rbp), %edx
leaq 0x4e3b3(%rip), %rax # 0x71ba7
leaq 0x4e39e(%rip), %rcx # 0x71b99
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb670
movq %rax, -0x98(%rbp)
jmp 0x2382a
movq -0x98(%rbp), %rdi
leaq 0x4dfd7(%rip), %rsi # 0x7180f
callq 0xb670
movq %rax, -0xa0(%rbp)
jmp 0x23846
movq -0x10(%rbp), %rdi
callq 0x48ed0
movq %rax, -0xa8(%rbp)
jmp 0x23858
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0xb670
movq %rax, -0xb0(%rbp)
jmp 0x23874
movq -0xb0(%rbp), %rdi
movq 0x7e726(%rip), %rsi # 0xa1fa8
callq 0xb710
movq %rax, -0xb8(%rbp)
jmp 0x23890
leaq -0x30(%rbp), %rdi
callq 0xbe78
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbe78
movq -0x38(%rbp), %rdi
callq 0xbce0
nopw (%rax,%rax)
|
/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_ = true;
std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
Message errors;
std::set<std::string> tests;
for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
name_it != name_vec.end(); ++name_it) {
const std::string& name = *name_it;
if (tests.count(name) != 0) {
errors << "Test " << name << " is listed more than once.\n";
continue;
}
if (registered_tests_.count(name) != 0) {
tests.insert(name);
} else {
errors << "No test named " << name
<< " can be found in this test suite.\n";
}
}
for (RegisteredTestIter it = registered_tests_.begin();
it != registered_tests_.end(); ++it) {
if (tests.count(it->first) == 0) {
errors << "You forgot to list test " << it->first << ".\n";
}
}
const std::string& errors_str = errors.GetString();
if (!errors_str.empty()) {
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
errors_str.c_str());
fflush(stderr);
posix::Abort();
}
return registered_tests;
}
|
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(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0xbcf0
movq -0x180(%rbp), %rsi
movq -0x178(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x12be0
jmp 0x23bc8
movl -0x1c(%rbp), %edx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x12c90
jmp 0x23bda
movq -0x188(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x240d0
jmp 0x23bec
leaq -0x50(%rbp), %rdi
callq 0x12fa0
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0x71(%rbp), %rdi
callq 0xb760
movq -0x190(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x24150
leaq -0xa8(%rbp), %rdi
callq 0x28170
jmp 0x23c2f
leaq -0xd8(%rbp), %rdi
callq 0x48ff0
leaq -0xa0(%rbp), %rdi
callq 0x49010
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x49040
leaq -0xa0(%rbp), %rdi
callq 0x490c0
movq %rax, -0xf0(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x49080
testb $0x1, %al
jne 0x23c90
jmp 0x23e68
leaq -0xe0(%rbp), %rdi
callq 0x490f0
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x49110
movq %rax, -0x198(%rbp)
jmp 0x23cbf
movq -0x198(%rbp), %rax
cmpq $0x0, %rax
je 0x23d9b
leaq 0x4df11(%rip), %rsi # 0x71be8
leaq -0xa8(%rbp), %rdi
callq 0x484d0
movq %rax, -0x1a0(%rbp)
jmp 0x23cec
movq -0x1a0(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0x15b10
movq %rax, -0x1a8(%rbp)
jmp 0x23d08
movq -0x1a8(%rbp), %rdi
leaq 0x4ded8(%rip), %rsi # 0x71bee
callq 0x46ef0
jmp 0x23d1d
jmp 0x23e57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x23d65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x23d5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12fa0
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0x71(%rbp), %rdi
callq 0xb760
jmp 0x240c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x240b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x240a1
movq -0x190(%rbp), %rdi
addq $0x8, %rdi
movq -0xf8(%rbp), %rsi
callq 0x49170
movq %rax, -0x1b0(%rbp)
jmp 0x23dbb
movq -0x1b0(%rbp), %rax
cmpq $0x0, %rax
je 0x23e06
movq -0xf8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x491d0
movb %dl, -0x1b9(%rbp)
movq %rax, -0x1b8(%rbp)
jmp 0x23dea
movb -0x1b9(%rbp), %al
movq -0x1b8(%rbp), %rcx
movq %rcx, -0x108(%rbp)
movb %al, -0x100(%rbp)
jmp 0x23e55
leaq 0x4ddfd(%rip), %rsi # 0x71c0a
leaq -0xa8(%rbp), %rdi
callq 0x49220
movq %rax, -0x1c8(%rbp)
jmp 0x23e22
movq -0x1c8(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0x15b10
movq %rax, -0x1d0(%rbp)
jmp 0x23e3e
movq -0x1d0(%rbp), %rdi
leaq 0x4ddcd(%rip), %rsi # 0x71c19
callq 0x49260
jmp 0x23e53
jmp 0x23e55
jmp 0x23e57
leaq -0xe0(%rbp), %rdi
callq 0x492a0
jmp 0x23c61
movq -0x190(%rbp), %rdi
addq $0x8, %rdi
callq 0x492c0
movq %rax, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x492f0
movq -0x190(%rbp), %rdi
addq $0x8, %rdi
callq 0x49340
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x492f0
leaq -0x110(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x49310
testb $0x1, %al
jne 0x23ed8
jmp 0x23f73
leaq -0x110(%rbp), %rdi
callq 0x49370
movq %rax, %rsi
leaq -0xd8(%rbp), %rdi
callq 0x49110
movq %rax, -0x1d8(%rbp)
jmp 0x23efc
movq -0x1d8(%rbp), %rax
cmpq $0x0, %rax
jne 0x23f60
leaq 0x4dd2c(%rip), %rsi # 0x71c3c
leaq -0xa8(%rbp), %rdi
callq 0x49390
movq %rax, -0x1e0(%rbp)
jmp 0x23f25
leaq -0x110(%rbp), %rdi
callq 0x49370
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
callq 0x15b10
movq %rax, -0x1e8(%rbp)
jmp 0x23f49
movq -0x1e8(%rbp), %rdi
leaq 0x4e943(%rip), %rsi # 0x7289a
callq 0x15ad0
jmp 0x23f5e
jmp 0x23f60
jmp 0x23f62
leaq -0x110(%rbp), %rdi
callq 0x493d0
jmp 0x23e92
leaq -0x150(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1b750
jmp 0x23f88
leaq -0x150(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
callq 0xbc70
testb $0x1, %al
jne 0x24056
movq 0x7e017(%rip), %rax # 0xa1fc8
movq (%rax), %rax
movq %rax, -0x1f0(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x170(%rbp), %rdi
callq 0x21470
jmp 0x23fd0
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xb290
movq %rax, -0x200(%rbp)
movq -0x130(%rbp), %rdi
callq 0xb290
movq -0x1f0(%rbp), %rdi
movq -0x200(%rbp), %rdx
movq %rax, %rcx
leaq 0x4dc47(%rip), %rsi # 0x71c55
xorl %eax, %eax
callq 0xbac0
movq -0x1f8(%rbp), %rdi
callq 0xbe78
movq 0x7dfa0(%rip), %rax # 0xa1fc8
movq (%rax), %rdi
callq 0xb890
jmp 0x24032
callq 0x48590
jmp 0x24039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x150(%rbp), %rdi
callq 0xbe78
jmp 0x240a1
movq -0x28(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x150(%rbp), %rdi
callq 0xbe78
leaq -0xd8(%rbp), %rdi
callq 0x49400
leaq -0xa8(%rbp), %rdi
callq 0x130a0
leaq -0xa0(%rbp), %rdi
callq 0x475b0
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
leaq -0xd8(%rbp), %rdi
callq 0x49400
leaq -0xa8(%rbp), %rdi
callq 0x130a0
leaq -0xa0(%rbp), %rdi
callq 0x475b0
movq -0x80(%rbp), %rdi
callq 0xbce0
nop
|
/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()) {
return user_msg_string;
}
return gtest_msg + "\n" + user_msg_string;
}
|
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(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb2c0
jmp 0x24aad
movl $0x1, -0x48(%rbp)
jmp 0x24b43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x24b59
movq -0x10(%rbp), %rdi
callq 0xbc70
testb $0x1, %al
jne 0x24ad9
jmp 0x24af1
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb2c0
jmp 0x24ae8
movl $0x1, -0x48(%rbp)
jmp 0x24b43
movq -0x10(%rbp), %rsi
leaq 0x4de78(%rip), %rdx # 0x72974
leaq -0x68(%rbp), %rdi
callq 0x47c40
jmp 0x24b07
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x47d10
jmp 0x24b1a
leaq -0x68(%rbp), %rdi
callq 0xbe78
movl $0x1, -0x48(%rbp)
jmp 0x24b43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xbe78
jmp 0x24b59
leaq -0x38(%rbp), %rdi
callq 0xbe78
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xbe78
movq -0x40(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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 never instantiated. None of the test cases "
"will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
"ones provided expand to nothing."
"\n\n"
"Ideally, TEST_P definitions should only ever be included as part of "
"binaries that intend to use them. (As opposed to, for example, being "
"placed in a library that may be linked in to get other utilities.)";
const char kMissingTestCase[] = //
" is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
"defined via TEST_P . No test cases will run."
"\n\n"
"Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
"code that always depend on code that provides TEST_P. Failing to do "
"so is often an indication of dead code, e.g. the last TEST_P was "
"removed but the rest got left behind.";
std::string message =
"Parameterized test suite " + name +
(has_test_p ? kMissingInstantiation : kMissingTestCase) +
"\n\n"
"To suppress this error for this test suite, insert the following line "
"(in a non-header) in the namespace it is defined in:"
"\n\n"
"GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
name + ");";
std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
RegisterTest( //
"GoogleTestVerification", full_name.c_str(),
nullptr, // No type parameter.
nullptr, // No value parameter.
location.file.c_str(), location.line, [message, location] {
return new FailureTest(location, message,
kErrorOnUninstantiatedParameterizedTest);
});
}
|
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(%rbp), %rdi
callq 0x495c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x49560
testb $0x1, %al
jne 0x24cfb
jmp 0x24d00
jmp 0x24f0e
leaq -0x1b0(%rbp), %rdi
leaq 0x4f2d2(%rip), %rsi # 0x73fe0
movl $0x17a, %edx # imm = 0x17A
callq 0xb550
leaq -0x310(%rbp), %rdi
leaq 0x4f43a(%rip), %rsi # 0x74160
movl $0x15c, %edx # imm = 0x15C
callq 0xb550
movq -0x8(%rbp), %rdx
leaq -0x3b0(%rbp), %rdi
leaq 0x4d174(%rip), %rsi # 0x71eb6
callq 0x47820
testb $0x1, -0x11(%rbp)
je 0x24d5d
leaq -0x1b0(%rbp), %rax
movq %rax, -0x458(%rbp)
jmp 0x24d6b
leaq -0x310(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x458(%rbp), %rdx
leaq -0x390(%rbp), %rdi
leaq -0x3b0(%rbp), %rsi
callq 0x46bf0
jmp 0x24d87
leaq 0x4d323(%rip), %rdx # 0x720b1
leaq -0x370(%rbp), %rdi
leaq -0x390(%rbp), %rsi
callq 0x46bf0
jmp 0x24da3
movq -0x8(%rbp), %rdx
leaq -0x350(%rbp), %rdi
leaq -0x370(%rbp), %rsi
callq 0x47d10
jmp 0x24dbc
leaq 0x4d10d(%rip), %rdx # 0x71ed0
leaq -0x330(%rbp), %rdi
leaq -0x350(%rbp), %rsi
callq 0x46bf0
jmp 0x24dd8
leaq -0x350(%rbp), %rdi
callq 0xbe78
leaq -0x370(%rbp), %rdi
callq 0xbe78
leaq -0x390(%rbp), %rdi
callq 0xbe78
leaq -0x3b0(%rbp), %rdi
callq 0xbe78
movq -0x8(%rbp), %rdx
leaq 0x4d0c0(%rip), %rsi # 0x71ed3
leaq -0x400(%rbp), %rdi
callq 0x47820
jmp 0x24e21
leaq 0x4ddfc(%rip), %rdx # 0x72c24
leaq -0x3e0(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0x46bf0
jmp 0x24e3d
leaq -0x400(%rbp), %rdi
callq 0xbe78
leaq -0x3e0(%rbp), %rdi
callq 0xb290
movq -0x450(%rbp), %rdi
movq %rax, -0x478(%rbp)
callq 0xb290
movq %rax, %rcx
movq -0x450(%rbp), %rax
movq %rcx, -0x470(%rbp)
movl 0x20(%rax), %eax
movl %eax, -0x464(%rbp)
leaq -0x448(%rbp), %rdi
movq %rdi, -0x460(%rbp)
leaq -0x330(%rbp), %rsi
callq 0xb2c0
jmp 0x24e9e
movq -0x450(%rbp), %rsi
leaq -0x428(%rbp), %rdi
callq 0x495f0
jmp 0x24eb3
movl -0x464(%rbp), %r9d
movq -0x470(%rbp), %r8
movq -0x478(%rbp), %rsi
movq %rsp, %rax
leaq -0x448(%rbp), %rcx
movq %rcx, (%rax)
leaq 0x4d01d(%rip), %rdi # 0x71ef9
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x25050
jmp 0x24eea
leaq -0x448(%rbp), %rdi
callq 0x252b0
leaq -0x3e0(%rbp), %rdi
callq 0xbe78
leaq -0x330(%rbp), %rdi
callq 0xbe78
addq $0x480, %rsp # imm = 0x480
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
jmp 0x24f89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
jmp 0x24f7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
jmp 0x24f71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
leaq -0x350(%rbp), %rdi
callq 0xbe78
leaq -0x370(%rbp), %rdi
callq 0xbe78
leaq -0x390(%rbp), %rdi
callq 0xbe78
leaq -0x3b0(%rbp), %rdi
callq 0xbe78
jmp 0x25038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
jmp 0x2502c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
leaq -0x400(%rbp), %rdi
callq 0xbe78
jmp 0x2502c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
jmp 0x25020
movq -0x460(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
callq 0xbe78
jmp 0x25020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3b8(%rbp)
movl %eax, -0x3bc(%rbp)
leaq -0x448(%rbp), %rdi
callq 0x252b0
leaq -0x3e0(%rbp), %rdi
callq 0xbe78
leaq -0x330(%rbp), %rdi
callq 0xbe78
movq -0x3b8(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 '"
<< test_suite_name << "'";
}
}
|
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(%rbp), %rdi
callq 0x12be0
jmp 0x254b7
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x496f0
movq %rax, -0x88(%rbp)
jmp 0x254cd
movq -0x88(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x39(%rbp), %rdi
callq 0xb760
movq -0x78(%rbp), %rdi
callq 0x49750
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x49720
testb $0x1, %al
jne 0x2550a
jmp 0x2554d
leaq -0x18(%rbp), %rdi
callq 0x49780
movb $0x1, 0x48(%rax)
jmp 0x255ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2553f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x39(%rbp), %rdi
callq 0xb760
jmp 0x255f8
leaq 0x4c816(%rip), %rdx # 0x71d6a
leaq -0x5c(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x2, %esi
movl $0x23d, %ecx # imm = 0x23D
callq 0x217f0
movq -0x98(%rbp), %rdi
callq 0x17df0
movq %rax, -0x90(%rbp)
jmp 0x25583
movq -0x90(%rbp), %rdi
leaq 0x4c97f(%rip), %rsi # 0x71f10
callq 0xb670
movq %rax, -0xa0(%rbp)
jmp 0x2559f
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb670
movq %rax, -0xa8(%rbp)
jmp 0x255b8
movq -0xa8(%rbp), %rdi
leaq 0x4c96f(%rip), %rsi # 0x71f35
callq 0xb670
jmp 0x255cd
leaq -0x5c(%rbp), %rdi
callq 0x21930
jmp 0x255ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x5c(%rbp), %rdi
callq 0x21930
jmp 0x255f8
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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), %rdi
callq 0x47ae0
jmp 0x25c59
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x47ea0
jmp 0x25c68
leaq -0x48(%rbp), %rdi
callq 0x47cd0
leaq -0x60(%rbp), %rdi
callq 0x475b0
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f500
jmp 0x25c89
leaq -0x28(%rbp), %rdi
callq 0x47cd0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x25cd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x25cd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x47cd0
leaq -0x60(%rbp), %rdi
callq 0x475b0
leaq -0x28(%rbp), %rdi
callq 0x47cd0
movq -0x68(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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 original
// working directory first.
const char* const original_dir =
UnitTest::GetInstance()->original_working_dir();
// We can safely call chdir() as it's a direct system call.
if (chdir(original_dir) != 0) {
DeathTestAbort(std::string("chdir(\"") + original_dir +
"\") failed: " + GetLastErrnoDescription());
return EXIT_FAILURE;
}
// We can safely call execv() as it's almost a direct system call. We
// cannot use execvp() as it's a libc function and thus potentially
// unsafe. Since execv() doesn't search the PATH, the user must
// invoke the test program via a valid path that contains at least
// one path separator.
execv(args->argv[0], args->argv);
DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
original_dir + " failed: " + GetLastErrnoDescription());
return EXIT_FAILURE;
}
|
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
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2d1(%rbp)
movb -0x2d1(%rbp), %al
testb $0x1, %al
jne 0x415a9
cmpl $-0x1, -0x14(%rbp)
jne 0x41803
leaq -0xf9(%rbp), %rdi
movq %rdi, -0x2e0(%rbp)
callq 0xbcf0
movq -0x2e0(%rbp), %rdx
leaq 0x300a8(%rip), %rsi # 0x716b4
leaq -0xf8(%rbp), %rdi
callq 0x12be0
jmp 0x4161a
leaq 0x2ffa1(%rip), %rdx # 0x715c2
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x46bf0
jmp 0x41636
leaq 0x3008b(%rip), %rdx # 0x716c8
leaq -0xb8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x46bf0
jmp 0x41652
movl $0x49c, -0x134(%rbp) # imm = 0x49C
leaq -0x130(%rbp), %rdi
leaq -0x134(%rbp), %rsi
callq 0x46d10
jmp 0x41671
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x130(%rbp), %rdx
callq 0x46c40
jmp 0x4168d
leaq 0x316a4(%rip), %rdx # 0x72d38
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x46bf0
jmp 0x416a6
leaq 0x31dd0(%rip), %rdx # 0x7347d
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x46bf0
jmp 0x416bc
leaq 0x30222(%rip), %rdx # 0x718e5
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x46bf0
jmp 0x416d2
leaq -0x38(%rbp), %rdi
callq 0x1a150
jmp 0x416dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x417a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x58(%rbp), %rdi
callq 0xbe78
leaq -0x78(%rbp), %rdi
callq 0xbe78
leaq -0x98(%rbp), %rdi
callq 0xbe78
leaq -0x130(%rbp), %rdi
callq 0xbe78
leaq -0xb8(%rbp), %rdi
callq 0xbe78
leaq -0xd8(%rbp), %rdi
callq 0xbe78
leaq -0xf8(%rbp), %rdi
callq 0xbe78
leaq -0xf9(%rbp), %rdi
callq 0xb760
jmp 0x41b90
jmp 0x41805
callq 0x46d90
testb $0x1, %al
jne 0x415a7
callq 0x245b0
movq %rax, %rdi
callq 0x265f0
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rdi
callq 0xbb20
cmpl $0x0, %eax
je 0x419a0
leaq -0x1c1(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0xbcf0
movq -0x2e8(%rbp), %rdx
leaq 0x31c37(%rip), %rsi # 0x73493
leaq -0x1c0(%rbp), %rdi
callq 0x12be0
jmp 0x4186a
movq -0x140(%rbp), %rdx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x46bf0
jmp 0x41886
leaq 0x31c0e(%rip), %rdx # 0x7349b
leaq -0x180(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x46bf0
jmp 0x418a2
leaq -0x1e8(%rbp), %rdi
callq 0x1a000
jmp 0x418b0
leaq -0x160(%rbp), %rdi
leaq -0x180(%rbp), %rsi
leaq -0x1e8(%rbp), %rdx
callq 0x46c40
jmp 0x418cc
leaq -0x160(%rbp), %rdi
callq 0x1a150
jmp 0x418da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x4198f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41983
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x4196b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x4195f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xbe78
leaq -0x1e8(%rbp), %rdi
callq 0xbe78
leaq -0x180(%rbp), %rdi
callq 0xbe78
leaq -0x1a0(%rbp), %rdi
callq 0xbe78
leaq -0x1c0(%rbp), %rdi
callq 0xbe78
leaq -0x1c1(%rbp), %rdi
callq 0xb760
jmp 0x41b90
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq (%rsi), %rdi
callq 0xb610
leaq -0x2a9(%rbp), %rdi
movq %rdi, -0x2f0(%rbp)
callq 0xbcf0
movq -0x2f0(%rbp), %rdx
leaq 0x31ad7(%rip), %rsi # 0x734a7
leaq -0x2a8(%rbp), %rdi
callq 0x12be0
jmp 0x419de
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq -0x288(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
callq 0x46bf0
jmp 0x419fd
leaq 0x31aaa(%rip), %rdx # 0x734ae
leaq -0x268(%rbp), %rdi
leaq -0x288(%rbp), %rsi
callq 0x46bf0
jmp 0x41a19
movq -0x140(%rbp), %rdx
leaq -0x248(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x46bf0
jmp 0x41a35
leaq 0x31a61(%rip), %rdx # 0x7349d
leaq -0x228(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x46bf0
jmp 0x41a51
leaq -0x2d0(%rbp), %rdi
callq 0x1a000
jmp 0x41a5f
leaq -0x208(%rbp), %rdi
leaq -0x228(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
callq 0x46c40
jmp 0x41a7b
leaq -0x208(%rbp), %rdi
callq 0x1a150
jmp 0x41a89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
jmp 0x41b3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x108(%rbp)
movl %eax, -0x10c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0xbe78
leaq -0x2d0(%rbp), %rdi
callq 0xbe78
leaq -0x228(%rbp), %rdi
callq 0xbe78
leaq -0x248(%rbp), %rdi
callq 0xbe78
leaq -0x268(%rbp), %rdi
callq 0xbe78
leaq -0x288(%rbp), %rdi
callq 0xbe78
leaq -0x2a8(%rbp), %rdi
callq 0xbe78
leaq -0x2a9(%rbp), %rdi
callq 0xb760
movq -0x108(%rbp), %rdi
callq 0xbce0
nopl (%rax)
|
/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 0x4faeb
jmp 0x4faf0
jmp 0x4fbb2
leaq 0x23d3a(%rip), %rdx # 0x73831
leaq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x83, %ecx
callq 0x217f0
movq -0x30(%rbp), %rdi
callq 0x17df0
movq %rax, %rdi
leaq 0x240fc(%rip), %rsi # 0x73c1d
callq 0xb670
movq %rax, -0x28(%rbp)
jmp 0x4fb2c
movq -0x28(%rbp), %rdi
leaq 0x2411d(%rip), %rsi # 0x73c54
callq 0xb670
movq %rax, -0x38(%rbp)
jmp 0x4fb42
movq -0x38(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xbcc0
movq %rax, -0x40(%rbp)
jmp 0x4fb54
movq -0x40(%rbp), %rdi
leaq 0x2410a(%rip), %rsi # 0x73c69
callq 0xb670
movq %rax, -0x48(%rbp)
jmp 0x4fb6a
movq -0x48(%rbp), %rdi
movl $0x1869f, %esi # imm = 0x1869F
callq 0xbcc0
movq %rax, -0x50(%rbp)
jmp 0x4fb7e
movq -0x50(%rbp), %rdi
leaq 0x240f3(%rip), %rsi # 0x73c7c
callq 0xb670
jmp 0x4fb90
leaq -0x8(%rbp), %rdi
callq 0x21930
jmp 0x4fbb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x21930
jmp 0x4fbdd
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1869f, -0x18(%rbp) # imm = 0x1869F
jle 0x4fbce
movl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4fbd4
movl -0x18(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
|
/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 global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
}
|
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 (ParseGoogleTestFlag(arg)) {
remove_flag = true;
#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
} else if (ParseFlag(arg, "flagfile", &flagfile_value)) {
GTEST_FLAG_SET(flagfile, flagfile_value);
LoadFlagsFromFile(flagfile_value);
remove_flag = true;
#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
} else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
// Both help flag and unrecognized Google Test flags (excluding
// internal ones) trigger help display.
g_help_flag = true;
}
if (remove_flag) {
// Shift the remainder of the argv list left by one. Note
// that argv has (*argc + 1) elements, the last one always being
// NULL. The following loop moves the trailing NULL element as
// well.
for (int j = i; j != *argc; j++) {
argv[j] = argv[j + 1];
}
// Decrements the argument count.
(*argc)--;
// We also need to decrement the iterator as we just removed
// an element.
i--;
}
}
if (g_help_flag) {
// We print the help here instead of in RUN_ALL_TESTS(), as the
// latter may not be called at all if the user is using Google
// Test with another testing framework.
PrintColorEncoded(kColorEncodedHelpMessage);
}
}
|
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
callq 0x6e8b0
jmp 0x50349
leaq -0x58(%rbp), %rdi
callq 0xb290
movq %rax, -0x70(%rbp)
movb $0x0, -0x71(%rbp)
movq -0x70(%rbp), %rdi
callq 0x45b60
movb %al, -0x79(%rbp)
jmp 0x50368
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x50371
jmp 0x503a5
movb $0x1, -0x71(%rbp)
jmp 0x50423
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x504bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbe78
jmp 0x504bb
movq -0x70(%rbp), %rdi
leaq 0x219b1(%rip), %rsi # 0x71d61
leaq -0x30(%rbp), %rdx
callq 0x463b0
movb %al, -0x7a(%rbp)
jmp 0x503be
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x503c7
jmp 0x503ea
leaq 0x52582(%rip), %rdi # 0xa2950
leaq -0x30(%rbp), %rsi
callq 0xb070
jmp 0x503d9
leaq -0x30(%rbp), %rdi
callq 0x46400
jmp 0x503e4
movb $0x1, -0x71(%rbp)
jmp 0x50421
leaq -0x58(%rbp), %rdi
leaq 0x23ba2(%rip), %rsi # 0x73f97
callq 0x46a40
testb $0x1, %al
jne 0x50415
movq -0x70(%rbp), %rdi
callq 0x465f0
movb %al, -0x7b(%rbp)
jmp 0x5040c
movb -0x7b(%rbp), %al
testb $0x1, %al
jne 0x50415
jmp 0x5041f
leaq 0x52485(%rip), %rax # 0xa28a1
movb $0x1, (%rax)
jmp 0x50421
jmp 0x50423
testb $0x1, -0x71(%rbp)
je 0x50476
movl -0x34(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x50462
movq -0x10(%rbp), %rax
movl -0x78(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x78(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x5042f
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbe78
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x50323
leaq 0x5240d(%rip), %rax # 0xa28a1
testb $0x1, (%rax)
je 0x504a9
leaq 0x20580(%rip), %rdi # 0x70a20
callq 0x466a0
jmp 0x504a7
jmp 0x504a9
leaq -0x30(%rbp), %rdi
callq 0xbe78
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xbe78
movq -0x60(%rbp), %rdi
callq 0xbce0
nopl (%rax)
|
/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 (ParseGoogleTestFlag(arg)) {
remove_flag = true;
#if GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
} else if (ParseFlag(arg, "flagfile", &flagfile_value)) {
GTEST_FLAG_SET(flagfile, flagfile_value);
LoadFlagsFromFile(flagfile_value);
remove_flag = true;
#endif // GTEST_USE_OWN_FLAGFILE_FLAG_ && GTEST_HAS_FILE_SYSTEM
} else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
// Both help flag and unrecognized Google Test flags (excluding
// internal ones) trigger help display.
g_help_flag = true;
}
if (remove_flag) {
// Shift the remainder of the argv list left by one. Note
// that argv has (*argc + 1) elements, the last one always being
// NULL. The following loop moves the trailing NULL element as
// well.
for (int j = i; j != *argc; j++) {
argv[j] = argv[j + 1];
}
// Decrements the argument count.
(*argc)--;
// We also need to decrement the iterator as we just removed
// an element.
i--;
}
}
if (g_help_flag) {
// We print the help here instead of in RUN_ALL_TESTS(), as the
// latter may not be called at all if the user is using Google
// Test with another testing framework.
PrintColorEncoded(kColorEncodedHelpMessage);
}
}
|
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
callq 0x6e9a0
jmp 0x50519
leaq -0x58(%rbp), %rdi
callq 0xb290
movq %rax, -0x70(%rbp)
movb $0x0, -0x71(%rbp)
movq -0x70(%rbp), %rdi
callq 0x45b60
movb %al, -0x79(%rbp)
jmp 0x50538
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x50541
jmp 0x50575
movb $0x1, -0x71(%rbp)
jmp 0x505eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x50683
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbe78
jmp 0x50683
movq -0x70(%rbp), %rdi
leaq 0x217e1(%rip), %rsi # 0x71d61
leaq -0x30(%rbp), %rdx
callq 0x463b0
movb %al, -0x7a(%rbp)
jmp 0x5058e
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x50597
jmp 0x505ba
leaq 0x523b2(%rip), %rdi # 0xa2950
leaq -0x30(%rbp), %rsi
callq 0xb070
jmp 0x505a9
leaq -0x30(%rbp), %rdi
callq 0x46400
jmp 0x505b4
movb $0x1, -0x71(%rbp)
jmp 0x505e9
leaq -0x58(%rbp), %rdi
leaq 0x239d2(%rip), %rsi # 0x73f97
callq 0x46a40
testb $0x1, %al
jne 0x505dd
movq -0x70(%rbp), %rdi
callq 0x465f0
testb $0x1, %al
jne 0x505dd
jmp 0x505e7
leaq 0x522bd(%rip), %rax # 0xa28a1
movb $0x1, (%rax)
jmp 0x505e9
jmp 0x505eb
testb $0x1, -0x71(%rbp)
je 0x5063e
movl -0x34(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5062a
movq -0x10(%rbp), %rax
movl -0x78(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x78(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x505f7
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xbe78
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x504f3
leaq 0x52245(%rip), %rax # 0xa28a1
testb $0x1, (%rax)
je 0x50671
leaq 0x203b8(%rip), %rdi # 0x70a20
callq 0x466a0
jmp 0x5066f
jmp 0x50671
leaq -0x30(%rbp), %rdi
callq 0xbe78
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xbe78
movq -0x60(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
nop
|
/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::InitializeSymbolizer(g_argvs[0].c_str());
// When using the Abseil Flags library, set the program usage message to the
// help message, but remove the color-encoding from the message first.
absl::SetProgramUsageMessage(absl::StrReplaceAll(
kColorEncodedHelpMessage,
{{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
#endif // GTEST_HAS_ABSL
ParseGoogleTestFlagsOnly(argc, argv);
GetUnitTestImpl()->PostFlagParsingInit();
}
|
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
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x50742
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6e8b0
movq -0x50(%rbp), %rsi
leaq 0x52260(%rip), %rdi # 0xa2970
callq 0x49b30
jmp 0x50717
leaq -0x38(%rbp), %rdi
callq 0xbe78
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x506e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
jmp 0x50762
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40f30
callq 0x46a90
movq %rax, %rdi
callq 0x3f6d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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::InitializeSymbolizer(g_argvs[0].c_str());
// When using the Abseil Flags library, set the program usage message to the
// help message, but remove the color-encoding from the message first.
absl::SetProgramUsageMessage(absl::StrReplaceAll(
kColorEncodedHelpMessage,
{{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
#endif // GTEST_HAS_ABSL
ParseGoogleTestFlagsOnly(argc, argv);
GetUnitTestImpl()->PostFlagParsingInit();
}
|
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
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x50812
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x6e9a0
movq -0x50(%rbp), %rsi
leaq 0x52190(%rip), %rdi # 0xa2970
callq 0x49b30
jmp 0x507e7
leaq -0x38(%rbp), %rdi
callq 0xbe78
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x507b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
jmp 0x50832
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40f60
callq 0x46a90
movq %rax, %rdi
callq 0x3f6d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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 $0x1, %al
jne 0x509ef
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xbcf0
movq -0x108(%rbp), %rdx
leaq 0x20d7a(%rip), %rsi # 0x716b4
leaq -0xc8(%rbp), %rdi
callq 0x12be0
jmp 0x50948
leaq 0x20c73(%rip), %rdx # 0x715c2
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x46bf0
jmp 0x50964
leaq 0x20d5d(%rip), %rdx # 0x716c8
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x46bf0
jmp 0x50980
movl $0x19e, -0xf4(%rbp) # imm = 0x19E
leaq -0xf0(%rbp), %rdi
leaq -0xf4(%rbp), %rsi
callq 0x46d10
jmp 0x5099f
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0x46c40
jmp 0x509b8
leaq 0x22379(%rip), %rdx # 0x72d38
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x46bf0
jmp 0x509ce
leaq 0x232ad(%rip), %rdx # 0x73c82
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x46bf0
jmp 0x509e4
leaq -0x28(%rbp), %rdi
callq 0x1a150
jmp 0x509ef
jmp 0x509f1
callq 0x46d90
movb %al, -0x109(%rbp)
jmp 0x509fe
movb -0x109(%rbp), %al
testb $0x1, %al
jne 0x508f8
jmp 0x50a0e
movq -0x100(%rbp), %rdi
addq $0x10, %rdi
callq 0x46b40
movq -0x100(%rbp), %rdi
callq 0x50ef0
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq %rax, %rdi
callq 0x14840
nopl (%rax,%rax)
|
/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, typename = typename std::remove_reference<
M>::type::is_gtest_matcher>
Matcher(M&& m) // NOLINT
: internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
}
// Allows the user to write str instead of Eq(str) sometimes, where
// str is a std::string object.
Matcher(const std::string& s); // NOLINT
// Allows the user to write "foo" instead of Eq("foo") sometimes.
Matcher(const char* s); // NOLINT
// Allows the user to pass absl::string_views or std::string_views directly.
Matcher(internal::StringView s); // NOLINT
}
|
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 global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
}
|
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, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)
|
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 downcast.
#endif
}
|
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 $0x1, %al
jne 0x59cd7
jmp 0x59cd9
jmp 0x59d33
leaq 0x19977(%rip), %rdx # 0x73657
leaq -0xc(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x4b0, %ecx # imm = 0x4B0
callq 0x217f0
movq -0x30(%rbp), %rdi
callq 0x17df0
movq %rax, %rdi
leaq 0x19cad(%rip), %rsi # 0x739b7
callq 0xb670
jmp 0x59d11
leaq -0xc(%rbp), %rdi
callq 0x21930
jmp 0x59d33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x21930
jmp 0x59d74
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x59d62
movq -0x38(%rbp), %rdi
leaq 0x47b7c(%rip), %rsi # 0xa18c8
leaq 0x47b85(%rip), %rdx # 0xa18d8
xorl %eax, %eax
movl %eax, %ecx
callq 0xb810
movq %rax, -0x40(%rbp)
jmp 0x59d6a
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x59d6a
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xbce0
nopl (%rax)
|
/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()) +
"&message=" + UrlEncode(test_part_result.message()));
}
|
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)
movq -0x18(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x3d540
movq -0x140(%rbp), %rdx
leaq 0x18d11(%rip), %rsi # 0x73b73
leaq -0xb8(%rbp), %rdi
callq 0x47660
jmp 0x5ae70
leaq 0x18d17(%rip), %rdx # 0x73b8e
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x46bf0
jmp 0x5ae8c
movq -0x10(%rbp), %rdi
callq 0x48ea0
movl %eax, -0x10c(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0x10c(%rbp), %rsi
callq 0x46d10
jmp 0x5aeb0
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x46c40
jmp 0x5aec9
leaq 0x18cc5(%rip), %rdx # 0x73b95
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x46bf0
jmp 0x5aedf
movq -0x10(%rbp), %rdi
callq 0x48ed0
movq %rax, %rsi
leaq -0x130(%rbp), %rdi
callq 0x3d540
jmp 0x5aef9
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x130(%rbp), %rdx
callq 0x46c40
jmp 0x5af0f
movq -0x138(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5bc50
jmp 0x5af21
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x130(%rbp), %rdi
callq 0xbe78
leaq -0x58(%rbp), %rdi
callq 0xbe78
leaq -0x78(%rbp), %rdi
callq 0xbe78
leaq -0x108(%rbp), %rdi
callq 0xbe78
leaq -0x98(%rbp), %rdi
callq 0xbe78
leaq -0xb8(%rbp), %rdi
callq 0xbe78
leaq -0xd8(%rbp), %rdi
callq 0xbe78
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b073
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b067
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b05b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b04f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b03d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x5b031
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x130(%rbp), %rdi
callq 0xbe78
leaq -0x58(%rbp), %rdi
callq 0xbe78
leaq -0x78(%rbp), %rdi
callq 0xbe78
leaq -0x108(%rbp), %rdi
callq 0xbe78
leaq -0x98(%rbp), %rdi
callq 0xbe78
leaq -0xb8(%rbp), %rdi
callq 0xbe78
leaq -0xd8(%rbp), %rdi
callq 0xbe78
movq -0xe0(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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 0x5bec0
movq -0xf0(%rbp), %rdx
leaq 0x18ab5(%rip), %rsi # 0x73b9f
leaq -0x90(%rbp), %rdi
callq 0x47660
jmp 0x5b0f8
leaq 0x18ab6(%rip), %rdx # 0x73bb5
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x46bf0
jmp 0x5b111
movq -0x10(%rbp), %rdi
callq 0x47430
movq %rax, %rdi
callq 0x4d880
movq %rax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x4d800
jmp 0x5b13e
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x46c40
jmp 0x5b154
leaq 0x18a69(%rip), %rdx # 0x73bc4
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x46bf0
jmp 0x5b16a
movq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5bc50
jmp 0x5b17c
leaq -0x30(%rbp), %rdi
callq 0xbe78
leaq -0x50(%rbp), %rdi
callq 0xbe78
leaq -0xe0(%rbp), %rdi
callq 0xbe78
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0x90(%rbp), %rdi
callq 0xbe78
leaq -0xb0(%rbp), %rdi
callq 0xbe78
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x5b270
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x5b264
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x5b25b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x5b24f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x5b246
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbe78
leaq -0x50(%rbp), %rdi
callq 0xbe78
leaq -0xe0(%rbp), %rdi
callq 0xbe78
leaq -0x70(%rbp), %rdi
callq 0xbe78
leaq -0x90(%rbp), %rdi
callq 0xbe78
leaq -0xb0(%rbp), %rdi
callq 0xbe78
movq -0xb8(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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 0x5bec0
movq -0xf8(%rbp), %rdx
leaq 0x1870c(%rip), %rsi # 0x73be1
leaq -0x98(%rbp), %rdi
callq 0x47660
jmp 0x5b4e3
leaq 0x186cb(%rip), %rdx # 0x73bb5
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x46bf0
jmp 0x5b4fc
movq -0x10(%rbp), %rdi
callq 0x30f00
movq %rax, -0x108(%rbp)
jmp 0x5b50e
movq -0x108(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x4d800
jmp 0x5b531
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x46c40
jmp 0x5b547
leaq 0x18676(%rip), %rdx # 0x73bc4
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x46bf0
jmp 0x5b55d
movq -0x100(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5bc50
jmp 0x5b56f
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x58(%rbp), %rdi
callq 0xbe78
leaq -0xe8(%rbp), %rdi
callq 0xbe78
leaq -0x78(%rbp), %rdi
callq 0xbe78
leaq -0x98(%rbp), %rdi
callq 0xbe78
leaq -0xb8(%rbp), %rdi
callq 0xbe78
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5b663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5b657
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5b64e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5b642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5b639
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbe78
leaq -0x58(%rbp), %rdi
callq 0xbe78
leaq -0xe8(%rbp), %rdi
callq 0xbe78
leaq -0x78(%rbp), %rdi
callq 0xbe78
leaq -0x98(%rbp), %rdi
callq 0xbe78
leaq -0xb8(%rbp), %rdi
callq 0xbe78
movq -0xc0(%rbp), %rdi
callq 0xbce0
nopl (%rax,%rax)
|
/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_(WARNING) << "stream_result_to: failed to stream to "
<< host_name_ << ":" << port_num_;
}
}
|
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), %rdi
movq %rdi, -0x50(%rbp)
movl $0x3, %esi
movl $0x445, %ecx # imm = 0x445
callq 0x217f0
movq -0x50(%rbp), %rdi
callq 0x17df0
movq %rax, %rdi
leaq 0x181be(%rip), %rsi # 0x73a24
callq 0xb670
movq %rax, -0x48(%rbp)
jmp 0x5b871
movq -0x48(%rbp), %rdi
leaq 0x181c9(%rip), %rsi # 0x73a45
callq 0xb670
jmp 0x5b883
leaq -0x14(%rbp), %rdi
callq 0x21930
jmp 0x5b8a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x21930
jmp 0x5b98b
movq -0x10(%rbp), %rdi
callq 0xbb60
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb290
movl -0x54(%rbp), %edi
movq %rax, %rsi
movq -0x30(%rbp), %rdx
callq 0xb220
cmpq -0x30(%rbp), %rax
je 0x5b982
leaq 0x17f46(%rip), %rdx # 0x73831
leaq -0x34(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x1, %esi
movl $0x44a, %ecx # imm = 0x44A
callq 0x217f0
movq -0x68(%rbp), %rdi
callq 0x17df0
movq %rax, %rdi
leaq 0x18166(%rip), %rsi # 0x73a7b
callq 0xb670
movq %rax, -0x60(%rbp)
jmp 0x5b920
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x10, %rsi
callq 0xb5d0
movq %rax, -0x70(%rbp)
jmp 0x5b937
movq -0x70(%rbp), %rdi
leaq 0x17542(%rip), %rsi # 0x72e84
callq 0xb670
movq %rax, -0x78(%rbp)
jmp 0x5b94d
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x30, %rsi
callq 0xb5d0
jmp 0x5b960
leaq -0x34(%rbp), %rdi
callq 0x21930
jmp 0x5b982
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x21930
jmp 0x5b98b
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
nop
|
/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(%rbp)
movl $0x3, %esi
movl $0x455, %ecx # imm = 0x455
callq 0x217f0
movq -0x38(%rbp), %rdi
callq 0x17df0
movq %rax, %rdi
leaq 0x18025(%rip), %rsi # 0x73a24
callq 0xb670
movq %rax, -0x30(%rbp)
jmp 0x5ba0a
movq -0x30(%rbp), %rdi
leaq 0x1808d(%rip), %rsi # 0x73aa2
callq 0xb670
jmp 0x5ba1c
leaq -0xc(%rbp), %rdi
callq 0x21930
jmp 0x5ba3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x21930
jmp 0x5ba5b
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0xbe20
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
nop
|
/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 -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x12be0
jmp 0x5c941
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5c9b0
jmp 0x5c950
leaq -0x30(%rbp), %rdi
callq 0xbe78
leaq -0x31(%rbp), %rdi
callq 0xb760
jmp 0x5c992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5c987
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbe78
leaq -0x31(%rbp), %rdi
callq 0xb760
jmp 0x5c998
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/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 -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x5cb30
jmp 0x5ca91
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5cb00
jmp 0x5caa0
leaq -0x30(%rbp), %rdi
callq 0xbc50
leaq -0x31(%rbp), %rdi
callq 0xbd10
jmp 0x5cae2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5cad7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbc50
leaq -0x31(%rbp), %rdi
callq 0xbd10
jmp 0x5cae8
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xbce0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/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 it is more specific than the generic ones
// in ::testing::internal, it will be picked by the compiler in the
// following statement - exactly what we want.
PrintTo(value, os);
}
|
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 global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
}
|
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, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&> const&)
|
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 want to get their impl back when
// they call GetDescriber().
// We use std::get on a tuple as a workaround of not having `if constexpr`.
return std::get<(
std::is_convertible<decltype(&P::Get(m)),
const MatcherDescriberInterface*>::value
? 1
: 0)>(std::make_tuple(&m, &P::Get(m)));
}
|
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, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
/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 global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
}
|
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 global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
}
|
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 global
// namespace, but not other namespaces, including the testing
// namespace which Google Test's Message class is in.
//
// To allow STL containers (and other types that has a << operator
// defined in the global namespace) to be used in Google Test
// assertions, testing::Message must access the custom << operator
// from the global namespace. With this using declaration,
// overloads of << defined in the global namespace and those
// visible via Koenig lookup are both exposed in this function.
using ::operator<<;
*ss_ << val;
return *this;
}
|
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(death_test_use_fork, death_test_use_fork_);
GTEST_FLAG_SET(filter, filter_);
GTEST_FLAG_SET(fail_fast, fail_fast_);
GTEST_FLAG_SET(internal_run_death_test, internal_run_death_test_);
GTEST_FLAG_SET(list_tests, list_tests_);
GTEST_FLAG_SET(output, output_);
GTEST_FLAG_SET(brief, brief_);
GTEST_FLAG_SET(print_time, print_time_);
GTEST_FLAG_SET(print_utf8, print_utf8_);
GTEST_FLAG_SET(random_seed, random_seed_);
GTEST_FLAG_SET(repeat, repeat_);
GTEST_FLAG_SET(recreate_environments_when_repeating,
recreate_environments_when_repeating_);
GTEST_FLAG_SET(shuffle, shuffle_);
GTEST_FLAG_SET(stack_trace_depth, stack_trace_depth_);
GTEST_FLAG_SET(stream_result_to, stream_result_to_);
GTEST_FLAG_SET(throw_on_failure, throw_on_failure_);
}
|
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, %cl
leaq 0x3b797(%rip), %rax # 0xa28a5
movb %cl, (%rax)
addq $0x8, %rsi
leaq 0x3b78d(%rip), %rdi # 0xa28a8
callq 0xb070
jmp 0x67122
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
leaq 0x3b6e7(%rip), %rdi # 0xa2818
callq 0xb070
jmp 0x67138
movq -0x10(%rbp), %rsi
movb 0x48(%rsi), %cl
andb $0x1, %cl
leaq 0x3b6ef(%rip), %rax # 0xa2838
movb %cl, (%rax)
addq $0x50, %rsi
leaq 0x3b772(%rip), %rdi # 0xa28c8
callq 0xb070
jmp 0x6715d
movq -0x10(%rbp), %rsi
movb 0x49(%rsi), %cl
andb $0x1, %cl
leaq 0x3b734(%rip), %rax # 0xa28a2
movb %cl, (%rax)
addq $0x70, %rsi
leaq 0x3b6c5(%rip), %rdi # 0xa2840
callq 0xb070
jmp 0x67182
movq -0x10(%rbp), %rsi
movb 0x90(%rsi), %cl
andb $0x1, %cl
leaq 0x3b753(%rip), %rax # 0xa28e9
movb %cl, (%rax)
addq $0x98, %rsi
leaq 0x3b74a(%rip), %rdi # 0xa28f0
callq 0xb070
jmp 0x671ad
movq -0x10(%rbp), %rsi
movb 0xb8(%rsi), %cl
andb $0x1, %cl
leaq 0x3b74f(%rip), %rax # 0xa2910
movb %cl, (%rax)
movb 0xb9(%rsi), %cl
andb $0x1, %cl
leaq 0x3b73e(%rip), %rax # 0xa2911
movb %cl, (%rax)
movb 0xba(%rsi), %cl
andb $0x1, %cl
leaq 0x3b6bb(%rip), %rax # 0xa28a0
movb %cl, (%rax)
movl 0xbc(%rsi), %ecx
leaq 0x3b720(%rip), %rax # 0xa2914
movl %ecx, (%rax)
movl 0xc0(%rsi), %ecx
leaq 0x3b715(%rip), %rax # 0xa2918
movl %ecx, (%rax)
movb 0xc4(%rsi), %cl
andb $0x1, %cl
leaq 0x3b707(%rip), %rax # 0xa291c
movb %cl, (%rax)
movb 0xc5(%rsi), %cl
andb $0x1, %cl
leaq 0x3b6f7(%rip), %rax # 0xa291e
movb %cl, (%rax)
movl 0xc8(%rsi), %ecx
leaq 0x3b6ea(%rip), %rax # 0xa2920
movl %ecx, (%rax)
addq $0xd0, %rsi
leaq 0x3b6e2(%rip), %rdi # 0xa2928
callq 0xb070
jmp 0x6724d
movq -0x10(%rbp), %rdi
movb 0xf0(%rdi), %cl
andb $0x1, %cl
leaq 0x3b6e7(%rip), %rax # 0xa2948
movb %cl, (%rax)
addq $0xd0, %rdi
callq 0xbe78
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0xbe78
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0xbe78
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xbe78
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0xbe78
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xbe78
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x14840
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/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())) {
// We create the exception message on the heap because VC++ prohibits
// creation of objects with destructors on stack in functions using __try
// (see error C2712).
std::string* exception_message =
FormatSehExceptionMessage(GetExceptionCode(), location);
internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
*exception_message);
delete exception_message;
return static_cast<Result>(0);
}
#else
(void)location;
return (object->*method)();
#endif // GTEST_HAS_SEH
}
|
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
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x678c2
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x48(%rbp)
jmp 0x678ca
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/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>()) {
assert(CompiledModel && "The CompiledModel should be valid");
// Set up the model_selector past all the InputSpecs in all cases.
// - if the model doesn't have such a feature, but the user requested it,
// we report error. Same if the model supports it but the user didn't
// specify it
// - finally, we compute the MD5 hash of the user input and set the value
// of the model selector to {high, low}
bool InputIsPresent = true;
populateTensor(InputSpec.size(),
TensorSpec::createSpec<uint64_t>("model_selector", {2}),
Options.FeedPrefix, InputIsPresent);
// If we hit the "report an error" cases outlined above, continue with the
// set up in case there's some custom diagnostics handler installed and it
// doesn't promptly exit.
if (Options.ModelSelector.empty() && InputIsPresent)
Ctx.emitError(
"A model selector was not specified but the underlying model "
"requires selecting one because it exposes a model_selector input");
uint64_t High = 0;
uint64_t Low = 0;
if (!Options.ModelSelector.empty()) {
if (!InputIsPresent)
Ctx.emitError("A model selector was specified but the underlying model "
"does not expose a model_selector input");
const auto Hash = MD5::hash(arrayRefFromStringRef(Options.ModelSelector));
High = Hash.high();
Low = Hash.low();
}
getTensor<uint64_t>(InputSpec.size())[0] = High;
getTensor<uint64_t>(InputSpec.size())[1] = Low;
// At this point, the model selector is set up. If the user didn't provide
// one, but the model has a model_selector, it'll be set to (0, 0) which
// the composite model should treat as error as part of its implementation
// (but that should only matter if there is a custom handler that doesn't
// exit on error)
for (size_t I = 0; I < InputSpec.size(); ++I)
populateTensor(I, InputSpec[I], Options.FeedPrefix, InputIsPresent);
ResultIndex = CompiledModel->LookupResultIndex(Options.FetchPrefix.str() +
DecisionName.str());
assert(ResultIndex >= 0 && "Cannot find DecisionName in inlining model");
}
|
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 0x98(%rsp), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x1ef9d5a
andq $0x0, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r15)
leaq 0x5108088(%rip), %rax # 0x5894360
addq $0x10, %rax
movq %rax, (%r15)
orl $-0x1, 0x48(%r15)
pushq $0x1
popq %rdi
callq 0x7808d0
movq %rax, 0x50(%r15)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x47c3bf6(%rip), %rsi # 0x4f4fef6
leaq 0x47c3bfd(%rip), %rdx # 0x4f4ff04
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x7fa87c
leaq 0x10(%rsp), %rdx
movq $0x2, -0x8(%rdx)
leaq 0x30(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x1efbe90
callq 0x26e5f06
pushq $0x8
popq %r8
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movl %eax, %ecx
movq %r12, %r9
callq 0x26e60c6
movups (%rbx), %xmm0
leaq 0x70(%rsp), %rsi
movups %xmm0, (%rsi)
movq %r14, 0x10(%rsi)
movw $0x405, 0x20(%rsi) # imm = 0x405
leaq 0x50(%rsp), %rdi
callq 0x2b6085c
nop
|
/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)
movups %xmm0, 0xb8(%rbx)
movq $0x0, 0xc8(%rbx)
leaq 0x510116a(%rip), %rax # 0x58f7c08
addq $0x10, %rax
movq %rax, 0xd0(%rbx)
movups %xmm0, 0xd8(%rbx)
leaq 0x660d(%rip), %rax # 0x7fd0c4
movq %rax, 0xf0(%rbx)
leaq 0x6601(%rip), %rax # 0x7fd0c6
movq %rax, 0xe8(%rbx)
movq %r15, %rdi
callq 0x7802c0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2b1e814
nop
|
/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
movq 0x10(%rdx), %rax
cmpb $0x1, %cl
jne 0x82d5fc
leaq -0xfd(%rax), %rcx
cmpq $-0x1fd, %rcx # imm = 0xFE03
setb %cl
testb $0x3, %al
setne %al
orb %cl, %al
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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, %eax
btl %eax, %ecx
setb %al
jmp 0x82fae2
xorl %eax, %eax
addq $0x8, %rsp
retq
nop
|
/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, %eax
btl %eax, %ecx
setb %al
jmp 0x82fb76
xorl %eax, %eax
addq $0x8, %rsp
retq
nop
|
/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)
return false;
return VectorList.NumElements == NumElements;
}
|
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 = MatchOperandParserImpl(Operands, Mnemonic);
if (ResTy.isSuccess())
return false;
// If there wasn't a custom match, try the generic matcher below. Otherwise,
// there was a match, but an error occurred, in which case, just return that
// the operand parsing failed.
if (ResTy.isFailure())
return true;
switch (getLexer().getKind()) {
default:
Error(Parser.getTok().getLoc(), "unexpected token in operand");
return true;
case AsmToken::Identifier: {
// If we've seen a branch mnemonic, the next operand must be a label. This
// is true even if the label is a register name. So "br r1" means branch to
// label "r1".
bool ExpectLabel = Mnemonic == "b" || Mnemonic == "bl";
if (!ExpectLabel) {
if (!tryParseRegisterWithWriteBack(Operands))
return false;
int Res = tryParseShiftRegister(Operands);
if (Res == 0) // success
return false;
else if (Res == -1) // irrecoverable error
return true;
// If this is VMRS, check for the apsr_nzcv operand.
if (Mnemonic == "vmrs" &&
Parser.getTok().getString().equals_insensitive("apsr_nzcv")) {
S = Parser.getTok().getLoc();
Parser.Lex();
Operands.push_back(ARMOperand::CreateToken("APSR_nzcv", S, *this));
return false;
}
}
// Fall though for the Identifier case that is not a register or a
// special name.
[[fallthrough]];
}
case AsmToken::LParen: // parenthesized expressions like (_strcmp-4)
case AsmToken::Integer: // things like 1f and 2b as a branch targets
case AsmToken::String: // quoted label names.
case AsmToken::Dot: { // . as a branch target
// This was not a register so parse other operands that start with an
// identifier (like labels) as expressions and create them as immediates.
const MCExpr *IdVal;
S = Parser.getTok().getLoc();
if (getParser().parseExpression(IdVal))
return true;
E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
Operands.push_back(ARMOperand::CreateImm(IdVal, S, E, *this));
return false;
}
case AsmToken::LBrac:
return parseMemory(Operands);
case AsmToken::LCurly: {
bool AllowOutOfBoundReg = Mnemonic == "vlldm" || Mnemonic == "vlstm";
return parseRegisterList(Operands, !Mnemonic.starts_with("clr"), false,
AllowOutOfBoundReg);
}
case AsmToken::Dollar:
case AsmToken::Hash: {
// #42 -> immediate
// $ 42 -> immediate
// $foo -> symbol name
// $42 -> symbol name
S = Parser.getTok().getLoc();
// Favor the interpretation of $-prefixed operands as symbol names.
// Cases where immediates are explicitly expected are handled by their
// specific ParseMethod implementations.
auto AdjacentToken = getLexer().peekTok(/*ShouldSkipSpace=*/false);
bool ExpectIdentifier = Parser.getTok().is(AsmToken::Dollar) &&
(AdjacentToken.is(AsmToken::Identifier) ||
AdjacentToken.is(AsmToken::Integer));
if (!ExpectIdentifier) {
// Token is not part of identifier. Drop leading $ or # before parsing
// expression.
Parser.Lex();
}
if (Parser.getTok().isNot(AsmToken::Colon)) {
bool IsNegative = Parser.getTok().is(AsmToken::Minus);
const MCExpr *ImmVal;
if (getParser().parseExpression(ImmVal))
return true;
const MCConstantExpr *CE = dyn_cast<MCConstantExpr>(ImmVal);
if (CE) {
int32_t Val = CE->getValue();
if (IsNegative && Val == 0)
ImmVal = MCConstantExpr::create(std::numeric_limits<int32_t>::min(),
getContext());
}
E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
Operands.push_back(ARMOperand::CreateImm(ImmVal, S, E, *this));
// There can be a trailing '!' on operands that we want as a separate
// '!' Token operand. Handle that here. For example, the compatibility
// alias for 'srsdb sp!, #imm' is 'srsdb #imm!'.
if (Parser.getTok().is(AsmToken::Exclaim)) {
Operands.push_back(ARMOperand::CreateToken(
Parser.getTok().getString(), Parser.getTok().getLoc(), *this));
Parser.Lex(); // Eat exclaim token
}
return false;
}
// w/ a ':' after the '#', it's just like a plain ':'.
[[fallthrough]];
}
case AsmToken::Colon: {
S = Parser.getTok().getLoc();
// ":lower16:", ":upper16:", ":lower0_7:", ":lower8_15:", ":upper0_7:" and
// ":upper8_15:", expression prefixes
// FIXME: Check it's an expression prefix,
// e.g. (FOO - :lower16:BAR) isn't legal.
ARMMCExpr::VariantKind RefKind;
if (parsePrefix(RefKind))
return true;
const MCExpr *SubExprVal;
if (getParser().parseExpression(SubExprVal))
return true;
const MCExpr *ExprVal = ARMMCExpr::create(RefKind, SubExprVal,
getContext());
E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
Operands.push_back(ARMOperand::CreateImm(ExprVal, S, E, *this));
return false;
}
case AsmToken::Equal: {
S = Parser.getTok().getLoc();
if (Mnemonic != "ldr") // only parse for ldr pseudo (e.g. ldr r0, =val)
return Error(S, "unexpected token in operand");
Parser.Lex(); // Eat '='
const MCExpr *SubExprVal;
if (getParser().parseExpression(SubExprVal))
return true;
E = SMLoc::getFromPointer(Parser.getTok().getLoc().getPointer() - 1);
// execute-only: we assume that assembly programmers know what they are
// doing and allow literal pool creation here
Operands.push_back(
ARMOperand::CreateConstantPoolImm(SubExprVal, S, E, *this));
return false;
}
}
}
|
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(%rax)
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl $0x10, %eax
jle 0x87bdec
leal -0x11(%rax), %ecx
cmpl $0xb, %ecx
ja 0x87be0f
leaq 0x2961146(%rip), %rax # 0x31dce04
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x13, (%rax)
jne 0x87c255
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r13
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rbp
movq %r14, %rdi
xorl %esi, %esi
callq 0x8792dc
cmpl $-0x1, %eax
je 0x87c534
movl %eax, %r12d
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rbp
movl (%rax), %eax
cmpl $0xa, %eax
je 0x87bd4c
cmpl $0x14, %eax
je 0x87c62f
cmpl $0x1a, %eax
jne 0x87ca65
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0xa, (%rax)
jne 0x87c808
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x28c3276
movq %rax, 0x18(%rsp)
movq 0x8(%r14), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28c3cba
movb $0x1, %bpl
testb %al, %al
jne 0x87c7f3
movq 0x48(%rsp), %rax
cmpb $0x1, (%rax)
jne 0x87ca79
movq 0x10(%rax), %rax
cmpq $0x3f, %rax
jle 0x87ca9c
cmpq $0x40, %rax
je 0x87cdf4
cmpq $0x80, %rax
je 0x87cdfb
cmpq $0x100, %rax # imm = 0x100
jne 0x87cf39
movl $0x20, %ebp
jmp 0x87ce00
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jb 0x87ccfc
cmpl $0x2, %eax
je 0x87c1b3
cmpl $0xa, %eax
je 0x87c066
jmp 0x87c0e4
cmpl $0x26, %eax
jne 0x87c0e4
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r13
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x20(%rsp), %rsi
movl $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movl $0x1, 0x20(%rsi)
movq $0x0, 0x18(%rsi)
movq (%rax), %r8
movl $0x1, %edx
movq %rax, %rdi
xorl %ecx, %ecx
callq *0x20(%r8)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x1b, (%rax)
jne 0x87be82
movl 0x20(%rsp), %eax
cmpl $0x2, %eax
je 0x87be8e
cmpl $0x4, %eax
je 0x87be8e
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
movl (%rax), %r12d
cmpl $0xa, %r12d
je 0x87c046
movq %r13, 0x18(%rsp)
movq %r15, %rdi
callq 0x28c37fc
movl (%rax), %r13d
movq 0x8(%r14), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28c3cba
movl %eax, %ebp
testb %al, %al
jne 0x87c046
movq %rbx, 0x8(%rsp)
movq 0x48(%rsp), %rax
cmpb $0x1, (%rax)
jne 0x87bf0a
cmpl $0xd, %r13d
jne 0x87bf0a
movl 0x10(%rax), %eax
testq %rax, %rax
jne 0x87bf0a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq $-0x80000000, %rdi # imm = 0x80000000
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x28e1cba
movq %rax, 0x48(%rsp)
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq -0x1(%rax), %rcx
movq 0x48(%rsp), %rsi
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movq 0x18(%rsp), %rdx
movq %r14, 0x18(%rsp)
movq %r14, %r8
callq 0x87bb7a
movq (%r13), %rax
xorl %r14d, %r14d
movq %r14, (%r13)
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movl $0x1, %edx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r14, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r13), %rdi
testq %rdi, %rdi
je 0x87bf8b
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x23, (%rax)
movq 0x18(%rsp), %r14
jne 0x87c046
movq %r15, %rdi
callq 0x28c37fc
movq 0x8(%rax), %rbx
movq 0x10(%rax), %rax
movq %rax, 0x58(%rsp)
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq 0x58(%rsp), %rdx
movq %rax, %rcx
movq %r14, %r8
callq 0x87b936
movq (%r13), %rax
xorl %ebx, %ebx
movq %rbx, (%r13)
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movl $0x1, %edx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x816f8e
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rsp), %rdx
movl 0x8(%rdx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %rbx, (%rax)
movq 0x8(%rsp), %rbx
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r13), %rdi
testq %rdi, %rdi
je 0x87c03a
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
cmpl $0x41, 0x40(%rsp)
jb 0x87c05c
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x87c05c
callq 0x7802b0
cmpl $0xa, %r12d
jne 0x87c7f3
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r12
movq 0x8(%r14), %r13
movq (%r13), %rax
movq %r13, %rdi
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0x26, (%rax)
jne 0x87c09d
movq (%r13), %rax
movq %r13, %rdi
callq *0xb8(%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0xb8(%rax)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0x2, (%rax)
movq %r12, 0x8(%rsp)
jne 0x87c232
movq %r13, %rdi
callq 0x28c37fc
cmpl $0x2, (%rax)
jne 0x87c27c
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
jmp 0x87c2ab
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x2340a2e(%rip), %rcx # 0x2bbcb29
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r14), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x28c388c
jmp 0x87bc8a
cmpq $0x5, %r13
jne 0x87c24e
leaq 0x2963d55(%rip), %rsi # 0x31dfe85
movq %r12, %rdi
movq %r13, %rdx
callq 0x780c70
testl %eax, %eax
je 0x87c4ee
leaq 0x2963d41(%rip), %rsi # 0x31dfe8b
movq %r12, %rdi
movq %r13, %rdx
callq 0x780c70
testl %eax, %eax
sete %al
jmp 0x87c4f0
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %rbp
cmpq $0x3, %r13
jne 0x87c192
leaq 0x475820e(%rip), %rsi # 0x4fd438d
movq %r12, %rdi
movq %r13, %rdx
callq 0x780c70
testl %eax, %eax
je 0x87c548
leaq 0x2340990(%rip), %rax # 0x2bbcb29
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r14), %rdi
movq %rbp, %rsi
jmp 0x87cf75
cmpq $0x2, %r13
je 0x87c1df
cmpq $0x1, %r13
jne 0x87c1f9
leaq 0x328f7a1(%rip), %rsi # 0x3b0b967
movq %r12, %rdi
movq %r13, %rdx
callq 0x780c70
testl %eax, %eax
je 0x87c5fa
cmpq $0x2, %r13
jne 0x87c1f9
leaq 0x3f4af58(%rip), %rsi # 0x47c713e
movq %r12, %rdi
movq %r13, %rdx
callq 0x780c70
testl %eax, %eax
je 0x87c5fa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x881a2a
testb %al, %al
je 0x87ccf0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x881dda
testl %eax, %eax
je 0x87ccf0
cmpl $-0x1, %eax
jne 0x87c5a0
movb $0x1, %bpl
xorl %eax, %eax
jmp 0x87ccf4
movq %r13, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x29642ce(%rip), %rcx # 0x31e0517
jmp 0x87c3c5
xorl %eax, %eax
jmp 0x87c4f0
leaq 0x29641c3(%rip), %rax # 0x31e041f
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq 0x8(%r14), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x28c3a70
jmp 0x87cf7f
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdx
xorl %esi, %esi
movq %rdx, %rdi
addq $-0x1, %rdi
setb %sil
adcq $0x0, %rcx
cmpq %rsi, %rdi
movl $0x1, %eax
cmovaeq %rdi, %rax
cmpq %rdx, %rax
cmovaeq %rdx, %rax
subq %rsi, %rax
leaq 0x48(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rdi
movq %rdx, (%rdi)
leaq 0x4ecdd1a(%rip), %r12 # 0x5749fe0
movq %r12, %rsi
callq 0x885414
testb %al, %al
jne 0x87c357
leaq 0x4ecdd13(%rip), %r12 # 0x5749ff0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x885414
testb %al, %al
jne 0x87c357
leaq 0x4ecdd0b(%rip), %r12 # 0x574a000
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x885414
testb %al, %al
jne 0x87c357
leaq 0x4ecdd03(%rip), %r12 # 0x574a010
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x885414
testb %al, %al
jne 0x87c357
leaq 0x4ecdcfb(%rip), %r12 # 0x574a020
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x885414
testb %al, %al
jne 0x87c357
leaq 0x4ecdcf3(%rip), %rbp # 0x574a030
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x885414
leaq 0x4ecdcef(%rip), %r12 # 0x574a040
testb %al, %al
cmovneq %rbp, %r12
leaq 0x4ecdce2(%rip), %rax # 0x574a040
cmpq %rax, %r12
je 0x87c3ae
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl (%rax), %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq $0x5, %rcx
ja 0x87c384
leaq 0x29a4527(%rip), %rax # 0x32208a8
movl (%rax,%rcx,4), %eax
movzbl 0xc(%r12), %ecx
orl %eax, %ecx
cmpl $-0x1, %ecx
je 0x87c4a3
movq %r13, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x29641dc(%rip), %rcx # 0x31e0588
jmp 0x87c3c5
movq %r13, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x29641a6(%rip), %rcx # 0x31e056b
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r14), %rdi
xorl %r12d, %r12d
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x28c388c
movb $0x1, %al
movb $0x1, %bpl
testb %al, %al
jne 0x87c7f3
movq 0x8(%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x28c3cba
movl %eax, %ebp
testb %al, %al
jne 0x87c7f3
movq 0x20(%rsp), %r13
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %r12d, %edi
movq %r13, %rsi
movq %rax, %rdx
callq 0x192c97c
leaq 0x8(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq -0x1(%rax), %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %r14, %r8
callq 0x87bb7a
movq (%r15), %rax
movq %rbx, %r12
xorl %ebx, %ebx
movq %rbx, (%r15)
leaq 0x48(%rsp), %r14
movq %rax, (%r14)
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x816f8e
movq (%r12), %rcx
movl 0x8(%r12), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %rbx, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%r12)
jmp 0x87cddd
movl 0x8(%r12), %r12d
movq (%r13), %rax
movq %r13, %rdi
callq *0xb8(%rax)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0xa, (%rax)
jne 0x87c601
movq (%r13), %rax
movq %r13, %rdi
callq *0xb8(%rax)
movq 0x8(%r14), %rdi
movl $0x26, %esi
callq 0x28c3ab4
xorl %eax, %eax
jmp 0x87c3e9
movb $0x1, %al
movb $0x1, %cl
cmpq $0x3, %r13
jb 0x87c512
movzwl (%r12), %ecx
xorl $0x6c63, %ecx # imm = 0x6C63
movzbl 0x2(%r12), %edx
xorl $0x72, %edx
orw %cx, %dx
setne %cl
movzbl %cl, %edx
movzbl %al, %r8d
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8821fe
movq %rbp, %rdi
callq 0x28c3276
leaq 0x296462d(%rip), %rcx # 0x31e0b70
jmp 0x87cf60
movq %rbp, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq 0x8(%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x28c3cba
movl %eax, %ebp
testb %al, %al
jne 0x87c7f3
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq -0x1(%rax), %rcx
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %r8
callq 0x882f64
jmp 0x87c460
cmpq $0x4, %r13
jne 0x87c5fa
leaq 0x2963129(%rip), %rsi # 0x31df6d6
movq %r12, %rdi
movq %r13, %rdx
callq 0x780c70
testl %eax, %eax
jne 0x87c5fa
movq %r15, %rdi
callq 0x28c37fc
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
cmpq $0x9, %rax
jne 0x87c5fa
leaq 0x2965e97(%rip), %rsi # 0x31e247a
leaq 0x20(%rsp), %rdi
movl $0x9, %edx
callq 0x2b56644
testl %eax, %eax
je 0x87cc6a
movb $0x1, %al
jmp 0x87ccf4
movq %r13, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x2963fa7(%rip), %rcx # 0x31e05bf
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r14), %rdi
jmp 0x87c3da
movq %rbp, %rdi
callq 0x28c327c
movq %rax, %rbp
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movl $0xb0, %edi
callq 0x7808d0
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
movq %r13, %rdx
xorl %r13d, %r13d
movq %r13, 0x18(%rax)
movb $0x0, 0x20(%rax)
leaq 0x4ecd284(%rip), %rcx # 0x57498f8
movq %rcx, (%rax)
movl $0xb, 0x30(%rax)
leaq 0x60(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movq %rcx, 0x50(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, 0x58(%rax)
movq %r14, 0x80(%rax)
movl %r12d, 0x88(%rax)
movups %xmm0, 0x90(%rax)
movq %r13, 0xa0(%rax)
andb $-0x2, 0xa8(%rax)
movq %rdx, 0x38(%rax)
movq %rbp, 0x40(%rax)
movq %r13, 0x48(%rax)
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r13, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x87c708
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x23, (%rax)
jne 0x87c7f1
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r12
movl $0xb0, %edi
callq 0x7808d0
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
xorl %r13d, %r13d
movq %r13, 0x18(%rax)
movb $0x0, 0x20(%rax)
leaq 0x4ecd1a1(%rip), %rcx # 0x57498f8
movq %rcx, (%rax)
movl $0x22, 0x30(%rax)
leaq 0x60(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movq %r13, 0x48(%rax)
movq %rcx, 0x50(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, 0x58(%rax)
movq %r14, 0x80(%rax)
leaq 0x4835c2f(%rip), %rcx # 0x50b23bf
movq %rcx, 0x88(%rax)
movl $0x1, 0x90(%rax)
movq %r12, 0x38(%rax)
movq %r12, 0x40(%rax)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r13, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x87c7e5
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x26, (%rax)
movq %r13, 0x58(%rsp)
je 0x87c845
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x1b, (%rax)
je 0x87c845
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x11, (%rax)
je 0x87c845
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x4, (%rax)
jne 0x87cabf
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x26, (%rax)
je 0x87c85f
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x1b, (%rax)
jne 0x87c86b
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rdi
callq 0x28c37fc
movl (%rax), %r13d
movq 0x8(%r14), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28c3cba
movb $0x1, %bpl
testb %al, %al
jne 0x87c7f3
movq 0x48(%rsp), %rbp
xorl %eax, %eax
cmpb $0x1, (%rbp)
cmoveq %rbp, %rax
testq %rax, %rax
je 0x87c8ea
cmpl $0xd, %r13d
jne 0x87c8e7
movl 0x10(%rax), %ecx
movq %rax, %rbp
testq %rcx, %rcx
jne 0x87c8ea
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq $-0x80000000, %rdi # imm = 0x80000000
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x28e1cba
movq %rax, %rbp
movl $0xb0, %edi
callq 0x7808d0
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
xorl %r13d, %r13d
movq %r13, 0x18(%rax)
movb $0x0, 0x20(%rax)
leaq 0x4eccfe3(%rip), %rcx # 0x57498f8
movq %rcx, (%rax)
movl $0xb, 0x30(%rax)
leaq 0x60(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movq %rcx, 0x50(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, 0x58(%rax)
movq %r14, 0x80(%rax)
movl %r12d, 0x88(%rax)
movq %rbp, 0x90(%rax)
movups %xmm0, 0x98(%rax)
andb $-0x2, 0xa8(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq %r13, 0x48(%rax)
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r13, (%rax)
leal 0x1(%rdx), %eax
movq %rbx, %r13
movl %eax, 0x8(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x87c9b6
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x28c37fc
movl (%rax), %ebx
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
cmpl $0x14, %ebx
jne 0x87cf54
callq 0x28c327c
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x23, (%rax)
jne 0x87c7f1
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x48359b2(%rip), %rsi # 0x50b23bf
leaq 0x10(%rsp), %r12
movl $0x1, %edx
movq %r12, %rdi
movq %rax, %rcx
movq %r14, %r8
callq 0x87b936
movq (%r12), %rax
xorl %ebx, %ebx
movq %rbx, (%r12)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x816f8e
movq (%r13), %rcx
movl 0x8(%r13), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %rbx, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%r13)
jmp 0x87c7d7
movq %rbp, %rdi
callq 0x28c3276
leaq 0x29639c7(%rip), %rcx # 0x31e043b
jmp 0x87cf60
leaq 0x2963411(%rip), %rax # 0x31dfe91
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r14), %rdi
movq 0x8(%rsp), %rsi
jmp 0x87cf75
movl $0x2, %ebp
cmpq $0x10, %rax
je 0x87ce00
cmpq $0x20, %rax
jne 0x87cf39
movl $0x4, %ebp
jmp 0x87ce00
movq %r15, %rdi
callq 0x28c37fc
movl (%rax), %eax
movl %eax, 0x18(%rsp)
cmpl $0xd, %eax
je 0x87cadf
movq %r15, %rdi
callq 0x28c37fc
cmpl $0xc, (%rax)
jne 0x87caeb
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %rbp
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x8792dc
movl %eax, 0x6c(%rsp)
cmpl $-0x1, %eax
je 0x87cf45
movq %rbx, 0x8(%rsp)
movl %r13d, 0x10(%rsp)
movl %r13d, 0x60(%rsp)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x1a, (%rax)
jne 0x87cb5d
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
leaq 0x10(%rsp), %rsi
leaq 0x60(%rsp), %rdx
movq %r14, %rdi
callq 0x88499c
movb $0x1, %bpl
testb %al, %al
jne 0x87c7f3
movq %r15, %rdi
callq 0x28c37fc
movl (%rax), %ebx
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x14, %ebx
jne 0x87cf51
xorl %r13d, %r13d
cmpl $0xd, 0x18(%rsp)
sete %r13b
movq %rax, %rdi
callq 0x28c327c
movq %rax, 0x70(%rsp)
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
movl 0x10(%rsp), %r8d
movl 0x60(%rsp), %r9d
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movl %r12d, %esi
xorl %edx, %edx
movl 0x6c(%rsp), %ecx
xorl %ebx, %ebx
pushq %rbx
movq %r14, 0x20(%rsp)
pushq %r14
pushq 0x80(%rsp)
pushq 0x70(%rsp)
pushq %r13
pushq $0x0
callq 0x8851c0
addq $0x30, %rsp
movq (%rbp), %rax
movq %rbx, (%rbp)
xorl %r14d, %r14d
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl $0x1, %edx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r14, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x87cc28
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x23, (%rax)
jne 0x87c7f1
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x483576f(%rip), %rsi # 0x50b23bf
leaq 0x48(%rsp), %r12
movl $0x1, %edx
movq %r12, %rdi
movq %rax, %rcx
movq 0x18(%rsp), %r8
jmp 0x87ceed
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
leaq 0x29631eb(%rip), %rsi # 0x31dfe7b
leaq 0x48(%rsp), %r13
movl $0x9, %edx
movq %r13, %rdi
movq %r12, %rcx
movq %r14, %r8
callq 0x87b936
movq (%r13), %rax
xorl %ebp, %ebp
movq %rbp, (%r13)
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %rbp, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x87ccf0
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
xorl %ebp, %ebp
testb %al, %al
je 0x87c7f3
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r12
movq 0x8(%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x28c3cba
movl %eax, %ebp
testb %al, %al
jne 0x87c7f3
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
movq %rax, %r15
decq %r15
movq 0x20(%rsp), %r13
movl $0xb0, %edi
callq 0x7808d0
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
xorl %edx, %edx
movq %rdx, 0x18(%rax)
movb $0x0, 0x20(%rax)
leaq 0x4eccb8c(%rip), %rcx # 0x57498f8
movq %rcx, (%rax)
movl $0x7, 0x30(%rax)
leaq 0x60(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, 0x58(%rax)
movq %r14, 0x80(%rax)
movq %r13, 0x88(%rax)
movq %r12, 0x38(%rax)
movq %r15, 0x40(%rax)
leaq 0x48(%rsp), %r14
movq %rax, (%r14)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
xorl %ecx, %ecx
movq %rcx, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x87c7f3
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x87c7f3
movl $0x8, %ebp
jmp 0x87ce00
movl $0x10, %ebp
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
callq 0x28c37fc
movl (%rax), %ebx
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
cmpl $0x14, %ebx
jne 0x87cf54
callq 0x28c327c
movq %rbp, %rbx
movq %rax, %rbp
movq (%r15), %rax
movq %r15, %rdi
callq *0xb8(%rax)
leaq 0x10(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq 0x18(%rsp)
pushq %r14
pushq %rbp
pushq %r13
pushq $0x0
pushq %rbx
callq 0x8851c0
addq $0x30, %rsp
leaq 0x10(%rsp), %rcx
movq (%rcx), %rax
xorl %r13d, %r13d
movq %r13, (%rcx)
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl $0x1, %edx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r13, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x87ceb2
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x28c37fc
cmpl $0x23, (%rax)
jne 0x87c7f1
movq %r15, %rdi
callq 0x28c37fc
movq %rax, %rdi
callq 0x28c3276
leaq 0x48354e5(%rip), %rsi # 0x50b23bf
leaq 0x10(%rsp), %r12
movl $0x1, %edx
movq %r12, %rdi
movq %rax, %rcx
movq %r14, %r8
callq 0x87b936
movq (%r12), %rax
xorl %ebx, %ebx
movq %rbx, (%r12)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
movl $0x1, %edx
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x816f8e
movq (%r12), %rcx
movl 0x8(%r12), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %rbx, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%r12)
jmp 0x87c7d7
leaq 0x2963514(%rip), %rax # 0x31e0454
jmp 0x87ca80
leaq 0x2963c24(%rip), %rax # 0x31e0b70
jmp 0x87c199
movq %rax, %rdi
callq 0x28c3276
leaq 0x233f9b1(%rip), %rcx # 0x2bbc911
leaq 0x20(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r14), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x28c388c
movl %eax, %ebp
jmp 0x87c7f3
|
/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;
}
if (J->first < Enc)
break;
std::swap(*I, *J);
}
return true;
}
|
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(%rcx,%rdx), %esi
cmpl 0x8(%rsp), %esi
je 0x885352
jb 0x885389
movq -0x8(%rcx,%rdx), %rdi
movl %esi, -0x8(%rcx,%rdx)
movl -0xc(%rcx,%rdx), %esi
movq %rdi, -0x10(%rcx,%rdx)
movl %esi, -0x4(%rcx,%rdx)
addq $-0x8, %rdx
cmpq $0x8, %rdx
jne 0x885324
jmp 0x885389
movl 0x8(%rbx), %eax
movq %rax, %rsi
shlq $0x3, %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
testq %rsi, %rsi
jle 0x885382
addq %rdx, %rcx
incq %rsi
movq (%rcx), %rdx
movq %rdx, -0x8(%rcx)
addq $0x8, %rcx
decq %rsi
cmpq $0x1, %rsi
jg 0x88536e
decl %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
|
/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, ListIndex, ARM::SP);
bool ListContainsLR = listContainsReg(Inst, ListIndex, ARM::LR);
bool ListContainsPC = listContainsReg(Inst, ListIndex, ARM::PC);
if (!IsARPop && ListContainsSP)
return Error(
Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
"SP may not be in the register list");
if (ListContainsPC && ListContainsLR)
return Error(
Operands[getRegListInd(Operands, MnemonicOpsEndInd)]->getStartLoc(),
"PC and LR may not be in the register list simultaneously");
return false;
}
|
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 %rdi, %r11
shlq $0x4, %r11
addq %r14, %r11
addq $0x18, %r11
movq %r15, %r14
cmpq %r15, %rax
je 0x897dd1
leaq 0x1(%r14), %r15
cmpl $0x10, (%r11)
leaq 0x10(%r11), %r11
jne 0x897dbb
cmpq %rax, %r14
setb %r11b
movl %r10d, %ebp
cmpl %r8d, %eax
jbe 0x897e25
movq 0x10(%rsi), %r14
movq %rdi, %r15
shlq $0x4, %r15
movb $0x1, %bpl
cmpl $0xd, 0x8(%r14,%r15)
je 0x897e25
leaq 0x1(%rdi), %r12
movq %rdi, %r15
shlq $0x4, %r15
addq %r15, %r14
addq $0x18, %r14
movq %r12, %r15
cmpq %r12, %rax
je 0x897e1e
leaq 0x1(%r15), %r12
cmpl $0xd, (%r14)
leaq 0x10(%r14), %r14
jne 0x897e08
cmpq %rax, %r15
setb %bpl
cmpl %r8d, %eax
jbe 0x897e6b
movq 0x10(%rsi), %rsi
movq %rdi, %r8
shlq $0x4, %r8
movb $0x1, %r10b
cmpl $0xe, 0x8(%rsi,%r8)
je 0x897e6b
leaq 0x1(%rdi), %r8
shlq $0x4, %rdi
addq %rdi, %rsi
addq $0x18, %rsi
movq %r8, %rdi
cmpq %r8, %rax
je 0x897e64
leaq 0x1(%rdi), %r8
cmpl $0xe, (%rsi)
leaq 0x10(%rsi), %rsi
jne 0x897e4f
cmpq %rax, %rdi
setb %r10b
xorb $0x1, %r11b
orb %r9b, %r11b
je 0x897eab
andb %r10b, %bpl
cmpb $0x1, %bpl
jne 0x897ed9
movl 0x8(%rdx), %eax
cmpl %ecx, %eax
jbe 0x897ef5
movq (%rdx), %rsi
movl %ecx, %edi
movq (%rsi,%rdi,8), %r8
cmpl $0x12, 0x30(%r8)
movl %ecx, %r8d
movl %edi, %ecx
cmovnel %r8d, %ecx
je 0x897ea7
incq %rdi
cmpq %rdi, %rax
jne 0x897e89
xorl %ecx, %ecx
movl %ecx, %eax
jmp 0x897ef7
movl 0x8(%rdx), %eax
cmpl %ecx, %eax
jbe 0x897edd
movq (%rdx), %rsi
movl %ecx, %edi
movq (%rsi,%rdi,8), %r8
cmpl $0x12, 0x30(%r8)
movl %ecx, %r8d
movl %edi, %ecx
cmovnel %r8d, %ecx
je 0x897ed5
incq %rdi
cmpq %rdi, %rax
jne 0x897eb7
xorl %ecx, %ecx
movl %ecx, %eax
jmp 0x897edf
xorl %eax, %eax
jmp 0x897f2a
xorl %eax, %eax
movq (%rdx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq 0x294a086(%rip), %rcx # 0x31e1f79
jmp 0x897f0b
xorl %eax, %eax
movq (%rdx), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq 0x294a091(%rip), %rcx # 0x31e1f9c
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%rbx), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x28c388c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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;
}
clearFeatureBits(Mips::FeatureVirt, "virt");
getTargetStreamer().emitDirectiveSetNoVirt();
Parser.Lex(); // Consume the EndOfStatement.
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, %rdi
callq 0x8add6a
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmpq *0xb8(%rax)
leaq 0x298235c(%rip), %rax # 0x3230c63
movq %rsp, %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %r14, %rdi
callq 0x8aac52
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/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
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x28fa3ce
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x8a46c6
movq 0x20(%r14), %rax
movq %rax, 0x38(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x28(%rbx)
movups %xmm0, 0x18(%rbx)
movq 0x138(%rbx), %rax
movl 0x140(%rbx), %ecx
movq -0x8(%rax,%rcx,8), %rax
movq 0xf8(%r12), %rcx
movq %rcx, 0x28(%rax)
movups 0xd8(%r12), %xmm0
movups 0xe8(%r12), %xmm1
movups %xmm1, 0x18(%rax)
movups %xmm0, 0x8(%rax)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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, %rsp
popq %rbx
popq %r14
jmp 0x821b42
|
/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 *0xa8(%rax)
addq $0x28, %rsp
retq
|
/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.bitcastToAPInt().getZExtValue();
}
return ImmOp64;
}
|
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 %r15, %rdi
callq 0x815f90
cmpl $0x41, 0x8(%r15)
setb %al
movq (%r15), %rdi
cmovaeq %rdi, %r15
movq (%r15), %rbx
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x8ba65b
callq 0x7802b0
movq %r14, %rdi
callq 0x81603c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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 (FeaturesRequired & ActiveFeatures) == FeaturesRequired;
}
|
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), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
andq %rcx, (%rsp,%rax,8)
incq %rax
cmpq $0x5, %rax
jne 0x8cb699
movq %rsp, %rdi
movl $0x28, %edx
movq %r14, %rsi
callq 0x780c70
testl %eax, %eax
sete %al
jmp 0x8cb6c7
movb $0x1, %al
jmp 0x8cb6c7
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::move(LHS)));
return ParseStatus::Success;
}
if (!LHS->isIntReg())
return Error(LHS->getStartLoc(), "invalid register kind for this operand");
AsmToken Tok = getLexer().getTok();
// The plus token may be followed by a register or an immediate value, the
// minus one is always interpreted as sign for the immediate value
if (Tok.is(AsmToken::Plus) || Tok.is(AsmToken::Minus)) {
(void)Parser.parseOptionalToken(AsmToken::Plus);
std::unique_ptr<SparcOperand> RHS;
if (!parseSparcAsmOperand(RHS).isSuccess())
return ParseStatus::NoMatch;
if (RHS->isReg() && !RHS->isIntReg())
return Error(RHS->getStartLoc(),
"invalid register kind for this operand");
Operands.push_back(
RHS->isImm()
? SparcOperand::MorphToMEMri(LHS->getReg(), std::move(RHS))
: SparcOperand::MorphToMEMrr(LHS->getReg(), std::move(RHS)));
return ParseStatus::Success;
}
Operands.push_back(SparcOperand::CreateMEMr(LHS->getReg(), S, E));
return ParseStatus::Success;
}
|
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, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r12
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x8d5c6f
movq 0x8(%rsp), %rax
xorl %r14d, %r14d
movq %r14, 0x8(%rsp)
movq 0x48(%rax), %rcx
movl $0x4, 0x30(%rax)
movq $0x9e, 0x48(%rax)
movq %rcx, 0x50(%rax)
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r14, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x8d5bd3
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x8d5bd3
cmpl $0x1, 0x30(%r12)
jne 0x8d5cb8
cmpl $0x1, 0x4c(%r12)
jne 0x8d5cb8
movq 0x8(%r15), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rsi
movups (%rsi), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsp)
movl 0x20(%rsi), %eax
addq $0x18, %rsi
movl %eax, 0x30(%rsp)
cmpl $0x40, %eax
ja 0x8d5cf1
movq (%rsi), %rax
movq %rax, 0x28(%rsp)
jmp 0x8d5cfb
movq (%r12), %rax
movq %r12, %rdi
callq *0x50(%rax)
leaq 0x299983e(%rip), %rcx # 0x326f507
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r15), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x28c388c
movzbl %al, %r14d
jmp 0x8d5bd3
leaq 0x28(%rsp), %rdi
callq 0x2b11114
movl 0x10(%rsp), %eax
andl $-0x2, %eax
cmpl $0xc, %eax
jne 0x8d5da5
movq 0x130(%r15), %rdi
movl $0xc, %esi
callq 0x28c3ab4
movq %rsp, %rsi
movq $0x0, (%rsi)
movq %r15, %rdi
xorl %edx, %edx
callq 0x8d618c
movl $0x2, %r14d
testl %eax, %eax
jne 0x8d5ec8
movq (%rsp), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x8d5d65
cmpl $0x1, 0x30(%r14)
jne 0x8d5e95
cmpl $0x1, 0x4c(%r14)
jne 0x8d5e95
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
movl %eax, %r15d
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movl %eax, %ebp
movq (%rsp), %r14
movq $0x0, (%rsp)
testb %r15b, %r15b
je 0x8d5e31
movq 0x48(%r14), %rcx
movl $0x4, 0x30(%r14)
xorl %eax, %eax
jmp 0x8d5e44
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movl %eax, %ebp
movl $0x58, %edi
callq 0x7808d0
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
xorl %r14d, %r14d
movq %r14, 0x18(%rax)
movb $0x0, 0x20(%rax)
leaq 0x4e752b4(%rip), %rcx # 0x574b090
movq %rcx, (%rax)
movl $0x3, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movl %ebp, 0x48(%rax)
movl $0x9e, 0x4c(%rax)
movq %r14, 0x50(%rax)
leaq 0x38(%rsp), %r15
movq %rax, (%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq %r14, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rdi
jmp 0x8d5ecc
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movl $0x3, 0x30(%r14)
xorl %ecx, %ecx
movl %ebp, 0x48(%r14)
movl %eax, 0x4c(%r14)
movq %rcx, 0x50(%r14)
leaq 0x38(%rsp), %r15
movq %r14, (%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x816f8e
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq (%rax), %rsi
movq %rsi, (%rcx,%rdx,8)
movq $0x0, (%rax)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rbx)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x8d5e90
movq (%rdi), %rax
callq *0x8(%rax)
xorl %r14d, %r14d
jmp 0x8d5ec8
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
leaq 0x2999662(%rip), %rcx # 0x326f507
leaq 0x38(%rsp), %rdx
movq %rcx, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
movq 0x8(%r15), %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x28c388c
movzbl %al, %r14d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8d5ed7
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x41, 0x30(%rsp)
jb 0x8d5bd3
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8d5bd3
callq 0x7802b0
jmp 0x8d5bd3
|
/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(getMemScale()));
Inst.addOperand(MCOperand::createReg(getMemIndexReg()));
addExpr(Inst, getMemDisp());
Inst.addOperand(MCOperand::createReg(getMemSegReg()));
}
|
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
callq 0x821b42
movq 0x78(%rbx), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fc948
movl 0x70(%rbx), %edx
movq %r15, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x821b42
nop
|
/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
shlq $0x5, %r12
addq (%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x94c095
movq %r12, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq *%rax
movups 0x10(%r15), %xmm0
movups %xmm0, 0x10(%r12)
addq $0x20, %r15
addq $0x20, %r12
cmpq %r14, %r15
jne 0x94c066
addl %r13d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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::FPR32RegClass)
SubReg = AArch64::sub_32;
else
SubReg = AArch64::ssub;
break;
case 64:
SubReg = AArch64::dsub;
break;
default:
LLVM_DEBUG(
dbgs() << "Couldn't find appropriate subregister for register class.");
return false;
}
return true;
}
|
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 $0x0, 0x8(%rdi)
callq 0x2b60e74
movq %rax, %rcx
addq $-0x8, %rcx
rolq $0x3d, %rcx
xorl %eax, %eax
cmpq $0x7, %rcx
ja 0x94dff1
leaq 0x2a55e84(%rip), %rdx # 0x33a3e44
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, %eax
jmp 0x94dfed
xorl %eax, %eax
cmpq 0x4fadf4f(%rip), %r14 # 0x58fbf28
setne %al
addl $0xf, %eax
jmp 0x94dfed
movl $0x7, %eax
jmp 0x94dfed
movl $0x2, %eax
movl %eax, (%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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() == TargetOpcode::G_CONSTANT && OpIdx == -1 &&
"Expected G_CONSTANT");
std::optional<int64_t> CstVal =
getIConstantVRegSExtVal(MI.getOperand(0).getReg(), MRI);
assert(CstVal && "Expected constant value");
MIB.addImm(*CstVal);
}
|
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)
movq $0x0, 0x8(%rdx)
movq %rax, 0x10(%rdx)
callq 0x1d3c22c
addq $0x20, %rsp
popq %rbx
retq
|
/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->getValueType(0);
SDValue Chain = N->getOperand(0);
// Optimize addressing mode.
SDValue Base, Offset;
unsigned Opc;
std::tie(Opc, Base, Offset) = findAddrModeSVELoadStore(
N, Opc_rr, Opc_ri, N->getOperand(IsIntr ? 3 : 2),
CurDAG->getTargetConstant(0, DL, MVT::i64), Scale);
SDValue Ops[] = {N->getOperand(IsIntr ? 2 : 1), // Predicate
Base, // Memory operand
Offset, Chain};
const EVT ResTys[] = {MVT::Untyped, MVT::Other};
SDNode *Load = CurDAG->getMachineNode(Opc, DL, ResTys, Ops);
SDValue SuperReg = SDValue(Load, 0);
for (unsigned i = 0; i < NumVecs; ++i)
ReplaceUses(SDValue(N, i), CurDAG->getTargetExtractSubreg(
AArch64::zsub0 + i, DL, VT, SuperReg));
// Copy chain
unsigned ChainIdx = NumVecs;
ReplaceUses(SDValue(N, ChainIdx), SDValue(Load, 1));
CurDAG->RemoveDeadNode(N);
}
|
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 0x2a757d8
movl 0x44(%rbx), %eax
leaq 0x28(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq %rcx, %rdx
movq 0x30(%rbx), %rax
movb (%rax), %cl
movb %cl, 0x1b(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x28(%rbx), %r13
movups (%r13), %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x78(%r13), %r15
addq $0x50, %r13
movq 0x38(%r14), %rdi
movl $0x0, (%rsp)
xorl %r12d, %r12d
xorl %esi, %esi
movl $0x8, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x17645fe
leaq 0x70(%rsp), %rcx
movq %rax, (%rcx)
movl %edx, 0x8(%rcx)
cmpb $0x0, 0x110(%rsp)
cmovneq %r15, %r13
movl %ebp, 0x8(%rsp)
movl $0x50, %eax
movq %rbx, %r15
movl $0x28, %ebx
cmovneq %rax, %rbx
movq %rcx, (%rsp)
leaq 0x90(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl 0x20(%rsp), %ecx
movl 0x24(%rsp), %r8d
movq %r13, %r9
callq 0x9e21fc
movl 0x20(%rbp), %esi
movq 0x10(%rbp), %rax
movl 0x18(%rbp), %ecx
movq (%rbp), %rdx
movl 0x8(%rbp), %edi
movq 0x28(%r15), %r8
movl 0x8(%r8,%rbx), %r9d
movl %r9d, 0x8(%rbp)
movq (%r8,%rbx), %r8
movq %r8, (%rbp)
movq %rax, 0x10(%rbp)
movl %ecx, 0x18(%rbp)
movq %rdx, 0x20(%rbp)
movl %edi, 0x28(%rbp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rbp)
movl 0x48(%rsp), %eax
movl %eax, 0x38(%rbp)
movups 0x2a28b33(%rip), %xmm0 # 0x34049f0
leaq 0x70(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movups 0x2a28b13(%rip), %xmm0 # 0x34049e0
movaps %xmm0, (%rax)
movq 0x38(%r14), %rdi
movq %rbp, 0x60(%rsp)
movq $0x4, 0x68(%rsp)
movups 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rcx
movl $0x2, %r8d
leaq 0x28(%rsp), %rdx
callq 0x178f8fa
movq %rax, %r13
movl 0x1c(%rsp), %edx
testl %edx, %edx
je 0x9dbf6c
movzbl 0x1b(%rsp), %ebp
movq 0x38(%r14), %rdi
leal 0x27(%r12), %esi
movq %r13, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x28(%rsp), %rdx
movl %ebp, %ecx
movq 0x38(%rsp), %r8
callq 0x178f996
movq %rax, %rbx
movl %edx, %r8d
movq 0x38(%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
movq %rax, %rcx
callq 0x178f032
movq %rbx, %rdi
callq 0x17a4218
movl 0x1c(%rsp), %edx
incl %r12d
cmpl %r12d, %edx
jne 0x9dbf10
movq 0x38(%r14), %rdi
movq %r15, %rsi
movq %r13, %rcx
movl $0x1, %r8d
callq 0x178f032
movq %r13, %rdi
callq 0x17a4218
movq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x1761ad8
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x9dbfa9
leaq 0x28(%rsp), %rdi
callq 0x2a758fc
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, %rdi
je 0xa79934
callq 0x780910
movq %rbx, %rdi
popq %rbx
jmp 0x2a8b596
nop
|
/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, %rax
jne 0xae98ae
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movb %dl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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>(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)));
}
return false;
}
|
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), %rsi
callq 0x933112
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xaedb87
movq -0x20(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa5cdfe
movq (%rbx), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0xaedb6c
movq %r15, (%rcx)
testb %al, %al
je 0xaedb85
addq $0x8, %rbx
movq -0x40(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x933112
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 extract subvectors from vectors");
int NumSubElts = SubVTy->getNumElements();
assert((!isa<FixedVectorType>(VTy) ||
(Index + NumSubElts) <=
(int)cast<FixedVectorType>(VTy)->getNumElements()) &&
"SK_ExtractSubvector index out of range");
InstructionCost Cost = 0;
// Subvector extraction cost is equal to the cost of extracting element from
// the source type plus the cost of inserting them into the result vector
// type.
for (int i = 0; i != NumSubElts; ++i) {
Cost +=
thisT()->getVectorInstrCost(Instruction::ExtractElement, VTy,
CostKind, i + Index, nullptr, nullptr);
Cost += thisT()->getVectorInstrCost(Instruction::InsertElement, SubVTy,
CostKind, i, nullptr, nullptr);
}
return Cost;
}
|
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, 0x10(%rsp)
movq 0x20(%rsp), %r12
movl 0xc(%rsp), %ebx
leal (%rcx,%r14), %r8d
xorl %ecx, %ecx
movq %rcx, (%rsp)
movq %r12, %rdi
movl $0x3d, %esi
movq %rax, %rdx
movl %ebx, %ecx
xorl %r9d, %r9d
callq 0xaf657a
movq %rax, %r15
movl %edx, 0x14(%rsp)
addq %rbp, %rax
sarq $0x3f, %rax
btcq $0x3f, %rax
addq %rbp, %r15
cmovoq %rax, %r15
xorl %eax, %eax
movq %rax, (%rsp)
movq %r12, %rdi
movl $0x3e, %esi
movq 0x18(%rsp), %rdx
movl %ebx, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0xaf657a
movl 0x10(%rsp), %esi
leaq (%r15,%rax), %rcx
sarq $0x3f, %rcx
btcq $0x3f, %rcx
addq %rax, %r15
movq 0x28(%rsp), %rax
cmovoq %rcx, %r15
movq 0x30(%rsp), %rcx
movl 0x14(%rsp), %edi
cmpl $0x1, %edi
cmovel %edi, %r13d
cmpl $0x1, %edx
cmovel %edx, %r13d
incl %r14d
movq %r15, %rbp
cmpl %r14d, %esi
jne 0xafa638
jmp 0xafa6dc
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %r15, %rax
movl %r13d, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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<UniformityInfoWrapperPass>().getUniformityInfo();
const auto *TranformInfo =
&getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
return AMDGPUUnifyDivergentExitNodesImpl(TranformInfo).run(F, DT, PDT, UA);
}
|
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
cmpq %rcx, (%rdx)
jne 0xafb960
movq 0x8(%rdx), %rdi
je 0xafb96a
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0xafb953
movq (%rdi), %rax
leaq 0x4eaa774(%rip), %rsi # 0x59a60e8
callq *0x60(%rax)
movq %rax, %r14
addq $0x20, %r14
jmp 0xafb983
xorl %r14d, %r14d
movq 0x8(%r15), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x4e94fb1(%rip), %rcx # 0x5990948
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0xafb9a4
movq 0x8(%rdx), %rdi
je 0xafb9ae
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0xafb997
movq (%rdi), %rax
leaq 0x4e94f90(%rip), %rsi # 0x5990948
callq *0x60(%rax)
movq %rax, %r12
movq 0x8(%r15), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x4ea694e(%rip), %rcx # 0x59a2320
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0xafb9df
movq 0x8(%rdx), %rdi
je 0xafb9e9
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0xafb9d2
movq (%rdi), %rax
leaq 0x4ea692d(%rip), %rsi # 0x59a2320
callq *0x60(%rax)
movq %rax, %r13
movq 0x8(%r15), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x4ea66d7(%rip), %rcx # 0x59a20e4
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0xafba1a
movq 0x8(%rdx), %rdi
je 0xafba24
movq %rsi, %rdx
cmpq %rax, %rsi
jne 0xafba0d
addq $0x28, %r13
addq $0x20, %r12
movq (%rdi), %rax
leaq 0x4ea66ae(%rip), %rsi # 0x59a20e4
callq *0x60(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x26e4986
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0xafa9de
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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, %ecx
movq %rbx, %rdi
callq 0x2b4ed86
movl 0x8(%rbx), %r13d
cmpl %r14d, %ebp
je 0xafbff2
leaq (,%r13,8), %r12
addq (%rbx), %r12
movq %r15, %rdi
movl %r14d, %esi
callq 0x2a5329a
movq %rax, (%r12)
incl %r14d
addq $0x8, %r12
cmpl %r14d, %ebp
jne 0xafbfd7
addl 0x4(%rsp), %r13d
movl %r13d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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)
movq 0x10(%r13), %rsi
movq 0x28(%rsp), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xafc07c
imulq $0x38, %rcx, %rdx
xorl %edi, %edi
movq (%r15,%rdi), %r8
subq -0x8(%r15,%rdi), %r8
shrq $0x3, %r8
addl %r8d, %eax
addq $0x38, %rdi
cmpq %rdi, %rdx
jne 0xafc061
movl %eax, %eax
leaq 0x70(%rsp), %rdx
movq (%rsi), %rsi
testq %rcx, %rcx
je 0xafc0ad
imulq $0x38, %rcx, %rcx
xorl %edi, %edi
xorl %r8d, %r8d
movq (%r15,%rdi), %r9
subq -0x8(%r15,%rdi), %r9
shrq $0x3, %r9
addl %r9d, %r8d
addq $0x38, %rdi
cmpq %rdi, %rcx
jne 0xafc092
jmp 0xafc0b0
xorl %r8d, %r8d
addq %r14, %rax
notq %rax
shlq $0x5, %rax
movq %rbp, %rcx
addq %rax, %rcx
addl %ebx, %r8d
movups (%rdx), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
movl $0x38, %edx
callq 0x2a511b0
movq $0x0, 0x48(%rbp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
movq 0x18(%rsp), %r9
callq 0x2a55948
movq %rbp, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.getOccupancy(ST);
if (TryMaximizeOccupancy && Occ < TgtOcc)
Occ = tryMaximizeOccupancy(TgtOcc);
TgtOcc = std::min(Occ, TgtOcc);
LLVM_DEBUG(dbgs() << "Scheduling using default scheduler, "
"target occupancy = "
<< TgtOcc << '\n');
unsigned FinalOccupancy = std::min(Occ, MFI->getOccupancy());
for (auto *R : Regions) {
BuildDAG DAG(*R, *this);
const auto ILPSchedule = makeGCNILPScheduler(DAG.getBottomRoots(), *this);
const auto RP = getSchedulePressure(*R, ILPSchedule);
LLVM_DEBUG(printSchedRP(dbgs(), R->MaxPressure, RP));
if (RP.getOccupancy(ST) < TgtOcc) {
LLVM_DEBUG(dbgs() << "Didn't fit into target occupancy O" << TgtOcc);
if (R->BestSchedule.get() &&
R->BestSchedule->MaxPressure.getOccupancy(ST) >= TgtOcc) {
LLVM_DEBUG(dbgs() << ", scheduling minimal register\n");
scheduleBest(*R);
}
} else {
scheduleRegion(*R, ILPSchedule, RP);
LLVM_DEBUG(printSchedResult(dbgs(), R, RP));
FinalOccupancy = std::min(FinalOccupancy, RP.getOccupancy(ST));
}
}
MFI->limitOccupancy(FinalOccupancy);
}
|
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, %r13d
jmp 0xaff71d
movl 0x3a8(%r12), %r13d
movq %rbx, %rdi
movl %r13d, %esi
callq 0xaffe3c
movq 0x14a0(%rbx), %rax
movq (%rax), %rdi
addq $0x14, %rdi
movq %r14, %rsi
callq 0xb00064
cmpl %r13d, %eax
setae %cl
xorb $0x1, %bpl
orb %cl, %bpl
jne 0xaff758
movq %rbx, %rdi
movl %r13d, %esi
callq 0xaffee4
cmpl %eax, %r13d
cmovael %eax, %r13d
movl %r13d, 0x4(%rsp)
movq %r12, 0x10(%rsp)
movl 0x3a8(%r12), %ecx
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl %eax, (%rsp)
movq 0x14a0(%rbx), %r13
movq 0x14a8(%rbx), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, %r13
je 0xaff88a
movq %r14, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %r15
leaq 0x38(%rsp), %r14
movq 0x8(%rsp), %r12
movq (%r13), %rbp
movq %rbp, %rsi
movq %rbx, %rdx
callq 0xb000c2
movq 0xa8(%rsp), %rsi
movl 0xb0(%rsp), %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0xd00690
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0xb0016a
movq %r14, %rdi
movq %r12, %rsi
callq 0xb00064
cmpl 0x4(%rsp), %eax
jae 0xaff823
movq 0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xaff84a
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
callq 0xb00064
cmpl 0x4(%rsp), %eax
jb 0xaff84a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xaffb6e
jmp 0xaff84a
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xb00392
movq %r14, %rdi
movq %r12, %rsi
callq 0xb00064
movl (%rsp), %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
movl %ecx, (%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xaff861
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
callq 0xb00276
movq %rbp, %rdi
addq $0x8, %r13
cmpq 0x18(%rsp), %r13
leaq 0x20(%rsp), %r15
leaq 0x38(%rsp), %r14
jne 0xaff7ae
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
cmpl %ecx, 0x3a8(%rax)
jbe 0xaff8a0
movl %ecx, 0x3a8(%rax)
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x8(%rax), %rax
testb $0x8, 0x2c(%rax)
jne 0xb100b3
movq 0x8(%rax), %rax
jmp 0xb10093
cmpq %rcx, %rax
setne 0xaa8(%rbx)
je 0xb10192
movq 0xa90(%rbx), %r14
movq 0xa98(%rbx), %r15
cmpq %r14, %r15
je 0xb10110
movq %r14, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0xb100f8
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%r12)
addq $0x8, %r12
cmpq %r15, %r12
jne 0xb100e9
movq %r14, 0xa98(%rbx)
movq 0xaa0(%rbx), %rax
movq 0xa68(%rbx), %rcx
movq %rcx, 0xaa0(%rbx)
movq 0xa90(%rbx), %rcx
movq 0xa98(%rbx), %rdx
movups 0xa58(%rbx), %xmm0
movups %xmm0, 0xa90(%rbx)
movq %rcx, 0xa58(%rbx)
movq %rdx, 0xa60(%rbx)
movq %rax, 0xa68(%rbx)
movq %rsp, %r14
movq %r14, %rdi
movl $0x2, %esi
callq 0xcaa634
cmpq $0x0, (%r14)
je 0xb1017b
leaq 0xa58(%rbx), %rdi
movq %rsp, %rsi
callq 0x91b1ba
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb1018a
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x1d8501a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 (%rcx,%rcx,2), %rdi
shlq $0x3, %rdi
addq (%r14), %rdi
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
subq %rcx, %rax
addq $-0x18, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
xorl %esi, %esi
callq 0x780240
movl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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>>::FindAndConstruct(unsigned int const&)
|
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 %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movq $0x0, 0x14(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::detail::DenseMapPair<unsigned int, llvm::GCNRegPressure>>::InsertIntoBucketImpl<unsigned int>(unsigned int const&, unsigned int const&, llvm::detail::DenseMapPair<unsigned int, llvm::GCNRegPressure>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0xb132b9
incl 0x8(%rbx)
cmpl $-0x1, (%rax)
je 0xb132ad
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0xb132da
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb131e0
movq (%r15), %rax
jmp 0xb132a2
nop
|
/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::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>>>, unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>>>::InsertIntoBucketImpl<unsigned int>(unsigned int const&, unsigned int const&, llvm::detail::DenseMapPair<unsigned int, std::vector<llvm::MachineInstr*, std::allocator<llvm::MachineInstr*>>>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0xb211c3
incl 0x8(%rbx)
cmpl $-0x1, (%rax)
je 0xb211b7
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0xb211e4
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb210f2
movq (%r15), %rax
jmp 0xb211ac
nop
|
/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
retq
|
/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 CostKind) {
InstructionCost Cost = TTI::TCC_Free;
// In the basic model we take into account GEP instructions only
// (although here can come alloca instruction, a value, constants and/or
// constant expressions, PHIs, bitcasts ... whatever allowed to be used as a
// pointer). Typically, if Base is a not a GEP-instruction and all the
// pointers are relative to the same base address, all the rest are
// either GEP instructions, PHIs, bitcasts or constants. When we have same
// base, we just calculate cost of each non-Base GEP as an ADD operation if
// any their index is a non-const.
// If no known dependecies between the pointers cost is calculated as a sum
// of costs of GEP instructions.
for (const Value *V : Ptrs) {
const auto *GEP = dyn_cast<GetElementPtrInst>(V);
if (!GEP)
continue;
if (Info.isSameBase() && V != Base) {
if (GEP->hasAllConstantIndices())
continue;
Cost += static_cast<T *>(this)->getArithmeticInstrCost(
Instruction::Add, GEP->getType(), CostKind,
{TTI::OK_AnyValue, TTI::OP_None}, {TTI::OK_AnyValue, TTI::OP_None},
std::nullopt);
} else {
SmallVector<const Value *> Indices(GEP->indices());
Cost += static_cast<T *>(this)->getGEPCost(GEP->getSourceElementType(),
GEP->getPointerOperand(),
Indices, AccessTy, CostKind);
}
}
return Cost;
}
|
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, 0x24(%rsp)
xorl %ebx, %ebx
movq (%r13,%r15), %r14
cmpb $0x3f, (%r14)
jne 0xb24cf5
cmpq 0x48(%rsp), %r14
je 0xb24c59
movq 0x40(%rsp), %rax
movl (%rax), %eax
andl $0x1, %eax
je 0xb24c59
movq %r14, %rdi
callq 0x2a57a4a
testb %al, %al
jne 0xb24cf5
movq 0x8(%r14), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0xd, %esi
movl 0xe0(%rsp), %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xb24d28
leaq (%rbx,%rax), %rcx
sarq $0x3f, %rcx
btcq $0x3f, %rcx
addq %rax, %rbx
cmovoq %rcx, %rbx
cmpl $0x1, %edx
movl 0x24(%rsp), %eax
cmovel %edx, %eax
movl %eax, 0x24(%rsp)
jmp 0xb24cf5
movl 0x4(%r14), %eax
shll $0x5, %eax
movq %r14, %rsi
subq %rax, %rsi
addq $0x20, %rsi
leaq 0x60(%rsp), %rbp
movq %rbp, 0x50(%rsp)
movabsq $0x600000000, %rax # imm = 0x600000000
movq %rax, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
movq %r14, %rdx
callq 0x91d6f4
movq 0x48(%r14), %rsi
movl 0x4(%r14), %eax
shll $0x5, %eax
subq %rax, %r14
movq (%r14), %rdx
movq 0x50(%rsp), %rcx
movl 0x58(%rsp), %r8d
movl 0xe0(%rsp), %eax
movl %eax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %r9
callq 0xb247f0
leaq (%rbx,%rax), %rcx
sarq $0x3f, %rcx
btcq $0x3f, %rcx
addq %rax, %rbx
cmovoq %rcx, %rbx
cmpl $0x1, %edx
movl 0x24(%rsp), %eax
cmovel %edx, %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
cmpq %rbp, %rdi
je 0xb24cf5
callq 0x780910
addq $0x8, %r15
cmpq %r15, %r12
jne 0xb24bc8
jmp 0xb24d0e
xorl %ebx, %ebx
movl $0x0, 0x24(%rsp)
movq %rbx, %rax
movl 0x24(%rsp), %edx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 const*, void>, llvm::detail::DenseSetPair<llvm::MachineBasicBlock const*>>::moveFromOldBuckets(llvm::detail::DenseSetPair<llvm::MachineBasicBlock const*>*, llvm::detail::DenseSetPair<llvm::MachineBasicBlock const*>*)
|
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::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
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
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %edx, %edx
movdqa 0x207c2c6(%rip), %xmm1 # 0x2bb5020
movdqa 0x207c2ce(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0xb38dae
movq $-0x1000, (%rax,%rdx,8) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0xb38dc6
movq $-0x1000, 0x8(%rax,%rdx,8) # imm = 0xF000
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0xb38d6a
cmpq %rbx, %r14
je 0xb38e13
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0xb38e0a
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xb38aba
movq 0x8(%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
incl 0x8(%r15)
addq $0x8, %r14
cmpq %rbx, %r14
jne 0xb38ddf
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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;
case AMDGPU::V_ADDC_U32_e64:
case AMDGPU::V_SUBB_U32_e64:
case AMDGPU::V_SUBBREV_U32_e64: {
const MachineOperand *Src1
= getNamedOperand(MI, AMDGPU::OpName::src1);
if (!Src1->isReg() || !RI.isVGPR(MRI, Src1->getReg()))
return false;
// Additional verification is needed for sdst/src2.
return true;
}
case AMDGPU::V_MAC_F16_e64:
case AMDGPU::V_MAC_F32_e64:
case AMDGPU::V_MAC_LEGACY_F32_e64:
case AMDGPU::V_FMAC_F16_e64:
case AMDGPU::V_FMAC_F16_t16_e64:
case AMDGPU::V_FMAC_F32_e64:
case AMDGPU::V_FMAC_F64_e64:
case AMDGPU::V_FMAC_LEGACY_F32_e64:
if (!Src2->isReg() || !RI.isVGPR(MRI, Src2->getReg()) ||
hasModifiersSet(MI, AMDGPU::OpName::src2_modifiers))
return false;
break;
case AMDGPU::V_CNDMASK_B32_e64:
break;
}
}
const MachineOperand *Src1 = getNamedOperand(MI, AMDGPU::OpName::src1);
if (Src1 && (!Src1->isReg() || !RI.isVGPR(MRI, Src1->getReg()) ||
hasModifiersSet(MI, AMDGPU::OpName::src1_modifiers)))
return false;
// We don't need to check src0, all input types are legal, so just make sure
// src0 isn't using any modifiers.
if (hasModifiersSet(MI, AMDGPU::OpName::src0_modifiers))
return false;
// Can it be shrunk to a valid 32 bit opcode?
if (!hasVALU32BitEncoding(MI.getOpcode()))
return false;
// Check output modifiers
return !hasModifiersSet(MI, AMDGPU::OpName::omod) &&
!hasModifiersSet(MI, AMDGPU::OpName::clamp) &&
!hasModifiersSet(MI, AMDGPU::OpName::byte_sel);
}
|
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 $0x17, %esi
callq 0x19130e0
cmpw $-0x1, %ax
sete %dl
movq 0x20(%r14), %rcx
testq %rcx, %rcx
sete %sil
orb %dl, %sil
je 0xb63b0c
movq %r14, %rsi
movl $0x33, %edx
callq 0xb639ba
testb %al, %al
jne 0xb63b9c
movzwl 0x44(%r14), %esi
movq %rbx, %rdi
callq 0xb63962
testb %al, %al
je 0xb63b9c
movq %r14, %rsi
movl $0x39, %edx
callq 0xb639ba
testb %al, %al
jne 0xb63b9c
movq %r14, %rsi
movl $0x32, %edx
callq 0xb639ba
testb %al, %al
jne 0xb63b9c
movq %r14, %rsi
movl $0x3c, %edx
callq 0xb639ba
xorb $0x1, %al
jmp 0xb63b9e
xorl %eax, %eax
cmpl $0x1f6a, %r12d # imm = 0x1F6A
jg 0xb63b48
leal -0x1e70(%r12), %edx
cmpl $0x11, %edx
ja 0xb63aed
movl $0x28421, %esi # imm = 0x28421
btl %edx, %esi
jb 0xb63b5f
cmpl $0x146a, %r12d # imm = 0x146A
je 0xb63bba
cmpl $0x1cd5, %r12d # imm = 0x1CD5
je 0xb63a39
jmp 0xb63b9e
movswq %ax, %rax
movl %eax, %eax
shlq $0x5, %rax
addq %rax, %rcx
cmpb $0x0, (%rcx)
jne 0xb63b9c
leaq 0x50(%rbx), %rdi
movl 0x4(%rcx), %edx
movq %r15, %rsi
callq 0xbeef32
testb %al, %al
je 0xb63b9c
movq %r14, %rsi
movl $0x34, %edx
callq 0xb639ba
testb %al, %al
je 0xb63a63
jmp 0xb63b9c
leal -0x1f6b(%r12), %edx
cmpl $0x9, %edx
ja 0xb63ba8
movl $0x221, %esi # imm = 0x221
btl %edx, %esi
jae 0xb63ba8
movswq %cx, %rax
movl %eax, %eax
shlq $0x5, %rax
addq %rax, %r13
cmpb $0x0, (%r13)
jne 0xb63b9c
leaq 0x50(%rbx), %rdi
movl 0x4(%r13), %edx
movq %r15, %rsi
callq 0xbeef32
testb %al, %al
je 0xb63b9c
movq %r14, %rsi
movl $0x3b, %edx
callq 0xb639ba
testb %al, %al
je 0xb63a39
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpl $0x224f, %r12d # imm = 0x224F
je 0xb63bba
cmpl $0x224a, %r12d # imm = 0x224A
jne 0xb63b9e
movl %r12d, %edi
movl $0x17, %esi
callq 0x19130e0
movswq %ax, %rcx
movl %ecx, %eax
shlq $0x5, %rax
addq %rax, %r13
xorl %eax, %eax
cmpw $-0x1, %cx
movl $0x0, %ecx
cmovneq %r13, %rcx
cmpb $0x0, (%rcx)
jne 0xb63b9e
addq $0x50, %rbx
movl 0x4(%rcx), %edx
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xbeef32
nop
|
/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 MII = Inst;
const DebugLoc &DL = Inst.getDebugLoc();
MachineOperand &Dest = Inst.getOperand(0);
MachineOperand &Src0 = Inst.getOperand(1);
MachineOperand &Src1 = Inst.getOperand(2);
Register NewDest = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
Register Interm = MRI.createVirtualRegister(&AMDGPU::SReg_32_XM0RegClass);
MachineInstr &Not = *BuildMI(MBB, MII, DL, get(AMDGPU::S_NOT_B32), Interm)
.add(Src1);
MachineInstr &Op = *BuildMI(MBB, MII, DL, get(Opcode), NewDest)
.add(Src0)
.addReg(Interm);
Worklist.insert(&Not);
Worklist.insert(&Op);
MRI.replaceRegWith(Dest.getReg(), NewDest);
addUsersToMoveToVALUWorklist(NewDest, MRI, Worklist);
}
|
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 0x33ea440(%rip), %r14 # 0x3f5b4b8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1d82fd6
movl %eax, 0x1c(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1d82fd6
movl %eax, %r14d
movq 0x38(%r12), %rsi
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0xb710bd
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x2a757d8
movq 0x20(%rsp), %rax
leaq 0x40(%rax), %rbp
movq 0x10(%rsp), %rsi
movq %rsi, 0x58(%rsp)
testq %rsi, %rsi
je 0xb710ee
leaq 0x10(%rsp), %rbx
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a759cc
movq $0x0, (%rbx)
xorps %xmm0, %xmm0
leaq 0x58(%rsp), %rbx
movups %xmm0, 0x8(%rbx)
movq $-0x24460, %rcx # imm = 0xFFFDBBA0
movq 0x28(%rsp), %rax
addq 0x8(%rax), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl %r14d, 0x30(%rsp)
movl %r14d, %r8d
callq 0x90f593
movq %rdx, %r14
movq %rdx, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x1d3c22c
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xb71143
leaq 0x58(%rsp), %rdi
callq 0x2a758fc
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0xb71157
leaq 0x10(%rsp), %rdi
callq 0x2a758fc
movq 0x38(%r12), %rsi
movq %rsi, 0x8(%rsp)
testq %rsi, %rsi
je 0xb71175
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x2a757d8
movq 0x20(%rsp), %rax
leaq 0x20(%rax), %rbp
movq 0x8(%rsp), %rsi
movq %rsi, 0x40(%rsp)
testq %rsi, %rsi
je 0xb711a6
leaq 0x8(%rsp), %rbx
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a759cc
movq $0x0, (%rbx)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rbx
movups %xmm0, 0x8(%rbx)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x34(%rsp), %eax
shlq $0x5, %rax
subq %rax, %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movl 0x1c(%rsp), %r8d
callq 0x90f593
movq %rax, %r13
movq %rdx, %r12
movq %rdx, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x1d3c22c
leaq 0x58(%rsp), %rdx
movq $0x0, 0x8(%rdx)
movl $0x0, (%rdx)
movl 0x30(%rsp), %eax
movl %eax, 0x4(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdx)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1d3c22c
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xb7122b
leaq 0x40(%rsp), %rdi
callq 0x2a758fc
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0xb7123f
leaq 0x8(%rsp), %rdi
callq 0x2a758fc
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb6ac5a
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb6ac5a
movq 0x20(%rsp), %rax
movl 0x4(%rax), %esi
movq %r15, %rdi
movl 0x1c(%rsp), %ebp
movl %ebp, %edx
callq 0x1d83524
movq 0x28(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb71292
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 > MaxImm) {
if (Imm <= MaxImm + 64) {
// Use an SOffset inline constant for 4..64
Overflow = Imm - MaxImm;
Imm = MaxImm;
} else {
// Try to keep the same value in SOffset for adjacent loads, so that
// the corresponding register contents can be re-used.
//
// Load values with all low-bits (except for alignment bits) set into
// SOffset, so that a larger range of values can be covered using
// s_movk_i32.
//
// Atomic operations fail to work correctly when individual address
// components are unaligned, even if their sum is aligned.
uint32_t High = (Imm + Alignment.value()) & ~MaxOffset;
uint32_t Low = (Imm + Alignment.value()) & MaxOffset;
Imm = Low;
Overflow = High - Alignment.value();
}
}
if (Overflow > 0) {
// There is a hardware bug in SI and CI which prevents address clamping in
// MUBUF instructions from working correctly with SOffsets. The immediate
// offset is unaffected.
if (ST.getGeneration() <= AMDGPUSubtarget::SEA_ISLANDS)
return false;
// It is not possible to set immediate in SOffset field on some targets.
if (ST.hasRestrictedSOffset())
return false;
}
ImmOffset = Imm;
SOffset = Overflow;
return true;
}
|
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, %ecx
jbe 0xb7315d
leal 0x40(%r8), %ebx
cmpl %esi, %ebx
jae 0xb73162
movl %r10d, %ecx
notl %ecx
addl %r11d, %esi
andl %esi, %ecx
andl %r10d, %esi
subl %r11d, %ecx
jmp 0xb7315f
xorl %ecx, %ecx
movl %esi, %r8d
testl %ecx, %ecx
je 0xb73179
cmpl $0x7, %r9d
jl 0xb73175
cmpb $0x0, 0x2fb(%rdi)
je 0xb73179
xorl %eax, %eax
jmp 0xb73180
movl %r8d, (%rax)
movl %ecx, (%rdx)
movb $0x1, %al
popq %rbx
retq
|
/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
// on VI.
// FIXME: This assumption is currently wrong. On VI we still use
// MUBUF instructions for the r + i addressing mode. As currently
// implemented, the MUBUF instructions only work on buffer < 4GB.
// It may be possible to support > 4GB buffers with MUBUF instructions,
// by setting the stride value in the resource descriptor which would
// increase the size limit to (stride * 4GB). However, this is risky,
// because it has never been validated.
return isLegalFlatAddressingMode(AM, AMDGPUAS::FLAT_ADDRESS);
}
return isLegalMUBUFAddressingMode(AM);
}
|
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 == MVT::v16i16 ||
VT == MVT::v16f16 || VT == MVT::v8f32 || VT == MVT::v16f32 ||
VT == MVT::v32f32 || VT == MVT::v32f16 || VT == MVT::v32i16 ||
VT == MVT::v4bf16 || VT == MVT::v8bf16 || VT == MVT::v16bf16 ||
VT == MVT::v32bf16);
SDValue Lo0, Hi0;
SDValue Op0 = Op.getOperand(0);
std::tie(Lo0, Hi0) = Op0.getValueType().isVector()
? DAG.SplitVectorOperand(Op.getNode(), 0)
: std::pair(Op0, Op0);
SDValue Lo1, Hi1;
std::tie(Lo1, Hi1) = DAG.SplitVectorOperand(Op.getNode(), 1);
SDValue Lo2, Hi2;
std::tie(Lo2, Hi2) = DAG.SplitVectorOperand(Op.getNode(), 2);
SDLoc SL(Op);
auto ResVT = DAG.GetSplitDestVTs(VT);
SDValue OpLo = DAG.getNode(Opc, SL, ResVT.first, Lo0, Lo1, Lo2,
Op->getFlags());
SDValue OpHi = DAG.getNode(Opc, SL, ResVT.second, Hi0, Hi1, Hi2,
Op->getFlags());
return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(Op), VT, OpLo, OpHi);
}
|
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, 0x88(%rsp)
movq 0x28(%rsi), %rax
movq (%rax), %r15
movl 0x8(%rax), %r12d
movl 0xc(%rax), %ebp
movq 0x30(%r15), %rcx
movq %r12, %rdx
shlq $0x4, %rdx
movb (%rcx,%rdx), %al
movq 0x8(%rcx,%rdx), %rcx
movb %al, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
testb %al, %al
je 0xb87f80
addb $-0x11, %al
cmpb $-0x53, %al
setb %al
jmp 0xb87f8a
leaq 0x38(%rsp), %rdi
callq 0x1e89dde
testb %al, %al
je 0xb87fa2
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xa5add4
jmp 0xb87fbe
movq %r15, 0x60(%rsp)
movl %r12d, 0x68(%rsp)
movl %ebp, 0x6c(%rsp)
movq %r15, 0x70(%rsp)
movl %r12d, 0x78(%rsp)
movl %ebp, 0x7c(%rsp)
leaq 0x60(%rsp), %r15
movq (%r15), %rax
movq %rax, 0x98(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x4c(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0xb0(%rsp)
movl 0x18(%r15), %eax
movl %eax, 0x58(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0xa5add4
movq (%r15), %rax
movq %rax, 0x90(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x48(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0xa8(%rsp)
movl 0x18(%r15), %eax
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x2, %ecx
callq 0xa5add4
movq (%r15), %r12
movl 0x8(%r15), %r13d
movq 0x10(%r15), %rax
movq %rax, 0xa0(%rsp)
movl 0x18(%r15), %eax
movl %eax, 0x50(%rsp)
movq 0x48(%r14), %rsi
movq %rsi, 0x38(%rsp)
testq %rsi, %rsi
je 0xb88074
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
callq 0x2a757d8
movl 0x44(%r14), %eax
leaq 0x38(%rsp), %rcx
movl %eax, 0x8(%rcx)
leaq 0x60(%rsp), %rbp
leaq 0x80(%rsp), %rdx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x1794306
movq 0x8(%rbp), %r8
movq 0x98(%rsp), %rax
movq %rax, 0x138(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x140(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x128(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x130(%rsp)
movq %r12, 0x118(%rsp)
movl %r13d, 0x120(%rsp)
movl 0x1c(%r14), %r9d
movl (%rbp), %ecx
movups 0x118(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
movups 0x128(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x138(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl 0x5c(%rsp), %r15d
movl %r15d, %esi
leaq 0x38(%rsp), %rdx
callq 0x177fb74
movq %rax, %r12
movl %edx, %r13d
movq 0x18(%rbp), %r8
movq 0xb0(%rsp), %rax
movq %rax, 0x108(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x110(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xf8(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x100(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0xe8(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0xf0(%rsp)
movl 0x1c(%r14), %r9d
movl 0x10(%rbp), %ecx
movups 0xe8(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
movups 0xf8(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x108(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
leaq 0x38(%rsp), %rdx
callq 0x177fb74
movq %rax, %r15
movl %edx, %ebp
movq 0x48(%r14), %rsi
movq %rsi, 0xb8(%rsp)
testq %rsi, %rsi
je 0xb881e4
leaq 0xb8(%rsp), %rdi
movl $0x1, %edx
callq 0x2a757d8
movl 0x44(%r14), %eax
leaq 0xb8(%rsp), %r14
movl %eax, 0x8(%r14)
movq 0x88(%rsp), %r8
movq %r12, 0xd8(%rsp)
movl %r13d, 0xe0(%rsp)
movq %r15, 0xc8(%rsp)
movl %ebp, 0xd0(%rsp)
movl 0x80(%rsp), %ecx
movups 0xc8(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0xd8(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x9e, %esi
movq %r14, %rdx
callq 0x17638a8
movq %rax, %rbx
movl %edx, %ebp
movq (%r14), %rsi
testq %rsi, %rsi
je 0xb88265
leaq 0xb8(%rsp), %rdi
callq 0x2a758fc
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
je 0xb88279
leaq 0x38(%rsp), %rdi
callq 0x2a758fc
movq %rbx, %rax
movl %ebp, %edx
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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",
DL.getDebugLoc());
DAG.getContext()->diagnose(BadIntrin);
return DAG.getUNDEF(VT);
}
|
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 # 0x58d0ac8
addq $0x10, %rax
movq %rax, -0x18(%r15)
leaq 0x28fe895(%rip), %rax # 0x349b324
movq %rax, 0x10(%r15)
movw $0x103, 0x30(%r15) # imm = 0x103
movq 0x40(%r14), %rdi
movq %rsp, %rsi
callq 0x2a60432
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x9fbc02
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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(Instruction::FAdd, L, R, FMF))
return V;
Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
return Insert(I, Name);
}
|
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, %r9
pushq %rax
pushq %rax
pushq %r15
callq 0x2a4c484
addq $0x48, %rsp
jmp 0xbaf73d
movq 0x50(%r14), %rdi
movl 0x68(%r14), %r8d
movq (%rdi), %rax
movl $0xe, %esi
movq %r13, %rdx
movq %r12, %rcx
callq *0x28(%rax)
movq %rax, %rbp
testq %rax, %rax
jne 0xbaf736
movq %rsp, %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movl $0xe, %edi
movq %r13, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2a59e3e
movl 0x68(%r14), %ecx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x931ef2
movq %rax, %rbp
movq 0x58(%r14), %rdi
movq 0x38(%r14), %rcx
movq 0x40(%r14), %r8
movq (%rdi), %rax
movq %rbp, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x932018
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/IR/IRBuilder.h
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.