name string | code string | asm string | file string |
|---|---|---|---|
benchmark::internal::BenchmarkImp::ThreadPerCpu() | void BenchmarkImp::ThreadPerCpu() {
static int num_cpus = NumCPUs();
thread_counts_.push_back(num_cpus);
} | pushq %rbx
movq %rdi, %rbx
movb 0x27246(%rip), %al # 0x429c8
testb %al, %al
je 0x1b7b6
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x1b7a2
movl 0x2722a(%rip), %eax # 0x429c0
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rbx)
popq %rbx
retq
addq $0x68, %rbx
leaq 0x27213(%rip), %rdx # 0x429c0
movq %r... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::Benchmark::Benchmark(char const*) | Benchmark::Benchmark(const char* name)
: imp_(new BenchmarkImp(name))
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x25fac(%rip), %rax # 0x417e8
movq %rax, (%rdi)
movl $0x80, %edi
callq 0x19480
movq %rax, %r14
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x19160
xorl %eax, %eax
movl %eax, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xm... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::Benchmark::Benchmark(benchmark::internal::Benchmark const&) | Benchmark::Benchmark(Benchmark const& other)
: imp_(new BenchmarkImp(*other.imp_))
{
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x25f22(%rip), %rax # 0x417e8
movq %rax, (%rdi)
movl $0x80, %edi
callq 0x19480
movq %rax, %rbx
movq 0x8(%r15), %r15
leaq 0x10(%rax), %r13
movq %r13, (%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rax, %r... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::Benchmark::Arg(int) | Benchmark* Benchmark::Arg(int x) {
CHECK(imp_->ArgsCnt() == -1 || imp_->ArgsCnt() == 1);
imp_->Arg(x);
return this;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq 0x30(%rax), %rcx
je 0x1b9ad
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movabsq $0x3fffffffc, %rcx # imm = 0x3FFFFFFFC
andq %rcx, %rax
cmpq %rcx, %rax
je 0x1b9ad
cmpq $0x4, %rax
jne 0x1b9c7
callq 0x22a92
mov... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::Benchmark::Range(int, int) | Benchmark* Benchmark::Range(int start, int limit) {
CHECK(imp_->ArgsCnt() == -1 || imp_->ArgsCnt() == 1);
imp_->Range(start, limit);
return this;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq 0x30(%rax), %rcx
je 0x1ba3f
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movabsq $0x3fffffffc, %rcx # imm = 0x3FFFFFFFC
andq %rcx, %rax
cmpq %rcx, %rax
je 0x1ba3f
cmpq $0x4, ... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::Benchmark::Ranges(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&) | Benchmark* Benchmark::Ranges(const std::vector<std::pair<int, int>>& ranges)
{
CHECK(imp_->ArgsCnt() == -1 || imp_->ArgsCnt() == static_cast<int>(ranges.size()));
imp_->Ranges(ranges);
return this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq 0x30(%rax), %rcx
je 0x1bace
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movq %rax, %rcx
notq %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
je 0x1bace
shrq $0x2, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x3, %rcx... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::Benchmark::Args(std::vector<int, std::allocator<int>> const&) | Benchmark* Benchmark::Args(const std::vector<int>& args) {
CHECK(imp_->ArgsCnt() == -1 || imp_->ArgsCnt() == static_cast<int>(args.size()));
imp_->Args(args);
return this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq 0x30(%rax), %rcx
je 0x1bbea
movq 0x8(%rcx), %rax
subq (%rcx), %rax
movq %rax, %rcx
notq %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
je 0x1bbea
shrq $0x2, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::State::SkipWithError(char const*) | void State::SkipWithError(const char* msg) {
CHECK(msg);
error_occurred_ = true;
error_message_type expected_no_error_msg = nullptr;
error_message.compare_exchange_weak(expected_no_error_msg,
const_cast<error_message_type>(msg));
started_ = finished_ = true;
total_iterations_ = max_iterations;
timer_m... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x1c241
movq %rsi, %r14
movq %rdi, %rbx
callq 0x22a92
movb $0x1, %bpl
movb %bpl, 0x3c(%rbx)
xorl %eax, %eax
lock
cmpxchgq %r14, 0x267f4(%rip) # 0x429d8
movw $0x101, (%rbx) # imm = 0x101
movq 0x48(%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x2... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::State::SetIterationTime(double) | void State::SetIterationTime(double seconds)
{
CHECK(running_benchmark);
timer_manager->SetIterationTime(seconds);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
cmpb $0x0, 0x2673a(%rip) # 0x429d0
je 0x1c307
callq 0x22a92
movq 0x266cc(%rip), %rbx # 0x42970
movq %rsp, %r14
movq %rbx, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x1e4e6
movb $0x1, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db8c
te... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::State::SetLabel(char const*) | void State::SetLabel(const char* label) {
CHECK(running_benchmark);
MutexLock l(GetBenchmarkLock());
*GetReportLabel() = label;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x26678(%rip) # 0x429d0
je 0x1c3cf
movq %rsi, %rbx
callq 0x22a92
movb 0x266c8(%rip), %al # 0x42a30
testb %al, %al
je 0x1c3fd
leaq 0x26691(%rip), %rax # 0x42a08
movq %rsp, %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x1e4e6
m... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::RunSpecifiedBenchmarks(benchmark::BenchmarkReporter*, benchmark::BenchmarkReporter*) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* console_reporter,
BenchmarkReporter* file_reporter) {
std::string spec = FLAGS_benchmark_filter;
if (spec.empty() || spec == "all")
spec = "."; // Regexp that matches all benchmarks
std::vector<internal::Benchmark::Instance> benc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x1a0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x2647d(%rip), %rsi # 0x428e0
movq 0x2647e(%rip), %rdx # 0x428e8
addq %rsi, %rdx
leaq 0x190(%rsp), %rbx
movq %rbx, %rdi
... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::(anonymous namespace)::CreateReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, benchmark::ConsoleReporter::OutputOptions) | std::unique_ptr<BenchmarkReporter>
CreateReporter(std::string const& name, ConsoleReporter::OutputOptions allow_color) {
typedef std::unique_ptr<BenchmarkReporter> PtrType;
if (name == "console") {
return PtrType(new ConsoleReporter(allow_color));
} else if (name == "json") {
return PtrType(new JSONReport... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16aa2(%rip), %rsi # 0x34220
movq %r14, %rdi
callq 0x190c0
testl %eax, %eax
je 0x1d7d9
leaq 0x16a97(%rip), %rsi # 0x34228
movq %r14, %rdi
callq 0x190c0
testl %eax, %eax
je 0x1d806
leaq 0x17197(%rip), %rsi # 0x3493b
movq %... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::PrintUsageAndExit() | void PrintUsageAndExit() {
fprintf(stdout,
"benchmark"
" [--benchmark_list_tests={true|false}]\n"
" [--benchmark_filter=<regex>]\n"
" [--benchmark_min_time=<min_time>]\n"
" [--benchmark_repetitions=<num_repetitions>]\n"
" ... | pushq %rax
movq 0x24684(%rip), %rax # 0x41f10
movq (%rax), %rcx
leaq 0x16e29(%rip), %rdi # 0x346bf
movl $0x1c6, %esi # imm = 0x1C6
movl $0x1, %edx
callq 0x19860
xorl %edi, %edi
callq 0x19550
| /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::internal::ParseCommandLineFlags(int*, char**) | void ParseCommandLineFlags(int* argc, char** argv) {
using namespace benchmark;
for (int i = 1; i < *argc; ++i) {
if (
ParseBoolFlag(argv[i], "benchmark_list_tests",
&FLAGS_benchmark_list_tests) ||
ParseStringFlag(argv[i], "benchmark_filter",
&FLAGS_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, (%rdi)
jl 0x1da4e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %r13
movl $0x1, %ebp
leaq 0x25000(%rip), %r12 # 0x428d9
movslq %ebp, %r15
movq (%rbx,%r15,8), %rdi
leaq 0x16f9f(%rip), %rsi # 0x34886
movq %r12, %rdx
ca... | /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::Initialize(int*, char**) | void Initialize(int* argc, char** argv) {
internal::ParseCommandLineFlags(argc, argv);
internal::SetLogLevel(FLAGS_v);
// TODO remove this. It prints some output the first time it is called.
// We don't want to have this ouput printed during benchmarking.
MyCPUUsage();
// The first call to walltime::Now ini... | pushq %rax
callq 0x1d8ac
movl 0x24e12(%rip), %edi # 0x42968
callq 0x22a84
callq 0x234f8
popq %rax
jmp 0x23e2c
| /jtomschroeder[P]lambda/vendor/benchmark/src/benchmark.cc |
benchmark::BenchmarkReporter::PrintBasicContext(std::ostream*, benchmark::BenchmarkReporter::Context const&) | void BenchmarkReporter::PrintBasicContext(std::ostream *out_ptr,
Context const &context) {
CHECK(out_ptr) << "cannot be null";
auto& Out = *out_ptr;
Out << "Run on (" << context.num_cpus << " X " << context.mhz_per_cpu
<< " MHz CPU " << ((context.num_cpus > 1... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x22b90
callq 0x22a92
movq %rax, %rdi
jmp 0x22bbb
leaq 0x12481(%rip), %rsi # 0x35018
leaq 0x12482(%rip), %rdx # 0x35020
leaq 0x124e5(%rip), %rcx # 0x3508a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x27, %r... | /jtomschroeder[P]lambda/vendor/benchmark/src/reporter.cc |
benchmark::ExponentToPrefix[abi:cxx11](long, bool) | std::string ExponentToPrefix(int64_t exponent, bool iec) {
if (exponent == 0) return "";
const int64_t index = (exponent > 0 ? exponent - 1 : -exponent - 1);
if (index >= kUnitsSize) return "";
const char* array =
(exponent > 0 ? (iec ? kBigIECUnits : kBigSIUnits) : kSmallSIUnits);
if (iec)
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x22fc7
leaq -0x1(%rsi), %rcx
testq %rsi, %rsi
movq %rsi, %rax
notq %rax
cmovgq %rcx, %rax
cmpq $0x9, %rax
jl 0x22fee
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x11eff(%rip), %rdx # 0x34ed4
movq %rbx, %rdi
movq %rdx,... | /jtomschroeder[P]lambda/vendor/benchmark/src/string_util.cc |
benchmark::ToBinaryStringFullySpecified[abi:cxx11](double, double, int) | std::string ToBinaryStringFullySpecified(double value, double threshold,
int precision) {
std::string mantissa;
int64_t exponent;
ToExponentAndMantissa(value, threshold, precision, 1024.0, &mantissa,
&exponent);
return mantissa + ExponentToPrefix(... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %eax
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movsd 0x120ba(%rip), %xmm2 # 0x351c0
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movl %eax, %edi
callq 0x22dac
movq (%rsp), %rsi
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
c... | /jtomschroeder[P]lambda/vendor/benchmark/src/string_util.cc |
benchmark::StringPrintFImp[abi:cxx11](char const*, __va_list_tag*) | std::string StringPrintFImp(const char *msg, va_list args)
{
// we might need a second shot at this, so pre-emptivly make a copy
va_list args_cp;
va_copy(args_cp, args);
// TODO(ericwf): use std::array for first attempt to avoid one memory
// allocation guess what the size might be
std::array<char, 256> lo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rax
leaq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
leaq 0x30(%rsp), %rdi
movl $0x100, %esi # imm = 0x100
m... | /jtomschroeder[P]lambda/vendor/benchmark/src/string_util.cc |
benchmark::ReplaceAll(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReplaceAll(std::string* str, const std::string& from,
const std::string& to) {
std::size_t start = 0;
while((start = str->find(from, start)) != std::string::npos) {
str->replace(start, from.length(), to);
start += to.length();
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rsi
movq 0x8(%r14), %rcx
xorl %edx, %edx
callq 0x197a0
cmpq $-0x1, %rax
je 0x234ea
movq %rax, %r12
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %r15, %rdi
movq %r12, %rsi
callq 0x194f0... | /jtomschroeder[P]lambda/vendor/benchmark/src/string_util.cc |
benchmark::ChildrenCPUUsage() | double ChildrenCPUUsage() {
#ifndef BENCHMARK_OS_WINDOWS
struct rusage ru;
if (getrusage(RUSAGE_CHILDREN, &ru) == 0) {
return (static_cast<double>(ru.ru_utime.tv_sec) +
static_cast<double>(ru.ru_utime.tv_usec) * 1e-6 +
static_cast<double>(ru.ru_stime.tv_sec) +
static_cast<dou... | subq $0x98, %rsp
leaq 0x8(%rsp), %rsi
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x19260
xorpd %xmm0, %xmm0
testl %eax, %eax
jne 0x23732
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rsp), %xmm0
cvtsi2sdq 0x10(%rsp), %xmm1
movsd 0x11b03(%rip), %xmm2 # 0x35210
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq 0x18(%rsp)... | /jtomschroeder[P]lambda/vendor/benchmark/src/sysinfo.cc |
benchmark::CpuScalingEnabled() | bool CpuScalingEnabled() {
#ifndef BENCHMARK_OS_WINDOWS
// On Linux, the CPUfreq subsystem exposes CPU information as files on the
// local file system. If reading the exported files fails, then we may not be
// running on Linux, so we silently ignore all the read errors.
for (int cpu = 0, num_cpus = NumCPUs();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0x0, 0xc(%rsp)
leaq 0x1f0bb(%rip), %rdi # 0x42bdc
leaq -0x3d0(%rip), %rsi # 0x23758
callq 0x23cf4
movl 0x1e954(%rip), %r14d # 0x42488
testl %r14d, %r14d
jle 0x23c15
leaq 0x28(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0x1081... | /jtomschroeder[P]lambda/vendor/benchmark/src/sysinfo.cc |
benchmark::(anonymous namespace)::ReadIntFromFile(char const*, long*) | bool ReadIntFromFile(const char* file, long* value) {
bool ret = false;
int fd = open(file, O_RDONLY);
if (fd != -1) {
char line[1024];
char* err;
memset(line, '\0', sizeof(line));
CHECK(read(fd, line, sizeof(line) - 1));
const long temp_value = strtol(line, &err, 10);
if (line[0] != '\0' ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rsi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %eax, %eax
callq 0x19330
cmpl $-0x1, %eax
je 0x23cb4
movl %eax, %ebx
leaq 0x10(%rsp), %r15
movl $0x400, %edx # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x19240
... | /jtomschroeder[P]lambda/vendor/benchmark/src/sysinfo.cc |
benchmark::walltime::(anonymous namespace)::UseCpuCycleClock() | bool UseCpuCycleClock() {
bool useWallTime = !CpuScalingEnabled();
if (useWallTime) {
VLOG(1) << "Using the CPU cycle clock to provide walltime::Now().\n";
} else {
VLOG(1) << "Using std::chrono to provide walltime::Now().\n";
}
return useWallTime;
} | pushq %r14
pushq %rbx
pushq %rax
callq 0x23b04
movl %eax, %ebx
callq 0x22a8b
testb %bl, %bl
je 0x23fec
testl %eax, %eax
jle 0x23ff7
callq 0x22b19
jmp 0x23ffc
testl %eax, %eax
jle 0x24045
callq 0x22b19
jmp 0x2404a
callq 0x22a92
movq %rax, %r14
leaq 0x10a4d(%rip), %rsi # 0x34a53
movl $0x7, %edx
movq %rax, %rdi
callq ... | /jtomschroeder[P]lambda/vendor/benchmark/src/walltime.cc |
benchmark::LocalDateTimeString[abi:cxx11]() | std::string LocalDateTimeString() {
return DateTimeString(true);
} | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
callq 0x19070
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps %... | /jtomschroeder[P]lambda/vendor/benchmark/src/walltime.cc |
benchmark::walltime::(anonymous namespace)::WallTimeImp::WallTimeImp() | WallTimeImp::WallTimeImp()
: base_walltime_(0.0), base_cycletime_(0),
cycles_per_second_(0), seconds_per_cycle_(0.0),
last_adjust_time_(0), drift_adjust_(0),
max_interval_cycles_(0) {
const double kMaxErrorInterval = 100e-6;
cycles_per_second_ = static_cast<int64_t>(CyclesPerSecond());
CHECK... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%rdi)
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
callq 0x2373a
cvttsd2si %xmm0, %rax
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x242d5
callq 0x22a92
xorps %xmm0, %xmm0
cvtsi2sdq 0x10(%rbx), %xmm0
movsd 0xffa7(%rip), %xmm1 ... | /jtomschroeder[P]lambda/vendor/benchmark/src/walltime.cc |
benchmark::GetBigOString[abi:cxx11](benchmark::BigO) | std::string GetBigOString(BigO complexity) {
switch (complexity) {
case oN:
return "N";
case oNSquared:
return "N^2";
case oNCubed:
return "N^3";
case oLogN:
return "lgN";
case oNLogN:
return "NlgN";
case o1:
return "(1)";
default:
return "f(N)";
... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
decl %esi
cmpl $0x5, %esi
ja 0x243a8
leaq 0x11279(%rip), %rax # 0x355b8
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x112de(%rip), %rsi # 0x3562d
leaq 0x112da(%rip), %rdx # 0x35630
jmp 0x243b6
leaq 0x112ca(%rip), %rsi # 0x... | /jtomschroeder[P]lambda/vendor/benchmark/src/complexity.cc |
benchmark::MinimalLeastSq(std::vector<int, std::allocator<int>> const&, std::vector<double, std::allocator<double>> const&, double (*)(int)) | LeastSq MinimalLeastSq(const std::vector<int>& n,
const std::vector<double>& time,
BigOFunc* fitting_curve) {
double sigma_gn = 0.0;
double sigma_gn_squared = 0.0;
double sigma_time = 0.0;
double sigma_time_gn = 0.0;
// Calculate least square fitting parameter
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rdx, %rcx
subq %rax, %rcx
je 0x24475
xorpd %xmm0, %xmm0
xorpd %xmm3, %xmm3
xorl %r13d, %r13d
movsd %xmm3, 0x8(%rsp)
movapd %xmm0, 0x10(%rsp... | /jtomschroeder[P]lambda/vendor/benchmark/src/complexity.cc |
benchmark::ComputeStats(std::vector<benchmark::BenchmarkReporter::Run, std::allocator<benchmark::BenchmarkReporter::Run>> const&) | std::vector<BenchmarkReporter::Run> ComputeStats(
const std::vector<BenchmarkReporter::Run>& reports) {
typedef BenchmarkReporter::Run Run;
std::vector<Run> results;
auto error_count =
std::count_if(reports.begin(), reports.end(),
[](Run const& run) { return run.error_occurred; });
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
pxor %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
movabsq $-0x2c8590b21642c859, %rbp # imm = 0xD37A6F4DE9BD37A7
cmpq %r13, %r12
j... | /jtomschroeder[P]lambda/vendor/benchmark/src/complexity.cc |
benchmark::Regex::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool Regex::Match(const std::string& str) {
if (!init_) {
return false;
}
return std::regex_search(str, re_);
} | pushq %rbx
subq $0x20, %rsp
cmpb $0x1, (%rdi)
jne 0x25bb6
movq %rdi, %rcx
addq $0x8, %rcx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
xorl %r8d, %r8d
callq 0x30d92
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25bb8
ca... | /jtomschroeder[P]lambda/vendor/benchmark/src/re_std.cc |
benchmark::FormatString[abi:cxx11](char const*, __va_list_tag*) | std::string FormatString(const char *msg, va_list args) {
// we might need a second shot at this, so pre-emptivly make a copy
va_list args_cp;
va_copy(args_cp, args);
std::size_t size = 256;
char local_buff[256];
auto ret = std::vsnprintf(local_buff, size, msg, args_cp);
va_end(args_cp);
// currently... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdx), %rax
leaq 0x10(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
leaq 0x30(%rsp), %rdi
movl $0x100, %esi # im... | /jtomschroeder[P]lambda/vendor/benchmark/src/colorprint.cc |
testing::TestSuite::GetMutableTestInfo(int) | TestInfo* TestSuite::GetMutableTestInfo(int i) {
const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
} | pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x44b1d
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x44b1d
movl %esi, %eax
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x44b2d
movl %eax, %eax
movq 0x30(%rdi), %rcx
movq (... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | void XmlUnitTestResultPrinter::OutputXmlAttribute(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_na... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x4933f
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r15, %rdx
callq 0x66f87
cmpq -0x58(%rbp), %rax
jne 0x49259
... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
int value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movl %ecx, -0x30(%rbp)
leaq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x4933f
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, %rdx
call... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void JsonUnitTestResultPrinter::PrintJsonTestList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
int total_tests = 0;
for (auto test_suite : test_suites) {
total_tests += test_s... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0xf6f3c(%rip), %rsi # 0x14694b
leaq 0xf6f3f(%rip), %rdx # 0x146955
leaq -0x88(%rbp), %rdi
callq 0x39a72
leaq -0x38(%rbp), %rax
mov... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::GetMutableTestSuite(int) | TestSuite* UnitTest::GetMutableTestSuite(int i) {
return impl()->GetMutableSuiteCase(i);
} | pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x503eb
movq 0xd0(%rax), %rdx
movq 0xd8(%rax), %rdi
subq %rdx, %rdi
shrq $0x2, %rdi
cmpl %esi, %edi
jle 0x503eb
movl %esi, %ecx
movl (%rdx,%rcx,4), %ecx
testl %ecx, %ecx
js 0x503fe
movl %ecx, %ecx
movq 0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_suite() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x62726
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x627cc
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x390d5
nop
| /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_case() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x62726
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x627cc
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x390d5
nop
| /Kuree[P]kratos/extern/googletest/googletest/src/gtest.cc |
testing::internal::InDeathTestChild() | bool InDeathTestChild() {
# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
// On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag.
return !GTEST_FLAG_GET(internal_run_death_test).empty();
# else
if (GTEST_FLAG_GET(death_test_style) == "threadsafe")
return ... | pushq %rbp
movq %rsp, %rbp
leaq 0x17238c(%rip), %rdi # 0x1c4e20
leaq 0xf43cd(%rip), %rsi # 0x146e68
callq 0x321c0
leaq 0x172359(%rip), %rcx # 0x1c4e00
xorl %edx, %edx
cmpq $0x0, 0x8(%rcx)
setne %dl
testl %eax, %eax
movzbl 0x172387(%rip), %eax # 0x1c4e41
cmovel %edx, %eax
andb $0x1, %al
popq %rbp
retq
nop
| /Kuree[P]kratos/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTest::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 DeathTest::Create(const char* statement,
Matcher<const std::string&> matcher, const char* file,
int line, DeathTest** test) {
return GetUnitTestImpl()->death_test_factory()->Create(
statement, std::move(matcher), file, line, test);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x3b51e
movq 0x17214a(%rip), %rax # 0x1c4df0
movq 0x240(%rax), %rdi
leaq 0x163644(%rip), %rax # 0x1b62f8
addq $0x10, %rax
leaq -0... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason) | void DeathTestImpl::Abort(AbortReason reason) {
// The parent process considers the death test to be a failure if
// it finds any data in our pipe. So, here we write a single flag byte
// to the pipe, then exit.
const char status_ch =
reason == TEST_DID_NOT_DIE ? kDeathTestLived :
reason == TEST_TH... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
movl $0x4c, %ecx
cmovnel %eax, %ecx
leaq -0x29(%rbp), %r14
movb %cl, (%r14)
movl 0x38(%rbx)... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-death-test.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(char const*) | Matcher<const std::string&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15c773(%rip), %r14 # 0x1b5f88
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x38bfe
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15c639(%rip), %r14 # 0x1b5fb8
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(char const*) | Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15c4c3(%rip), %r14 # 0x1b5fb8
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x38bfe
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const internal::StringView&>::Matcher(const std::string& s) {
*this = Eq(s);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15c389(%rip), %r14 # 0x1b5fe8
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x60(%rbp), %... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(char const*) | Matcher<const internal::StringView&>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15c213(%rip), %r14 # 0x1b5fe8
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x38bfe
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15c0a9(%rip), %r14 # 0x1b5fe8
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq -0x60(%rbp), %rdi
movq %rdx, %rsi
movq %rax, %... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(char const*) | Matcher<internal::StringView>::Matcher(const char* s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15bdef(%rip), %r14 # 0x1b6018
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x38bfe
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x60(%rbp), %rsi
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<internal::StringView>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x15bc85(%rip), %r14 # 0x1b6018
addq $0x10, %r14
movq %r14, (%rdi)
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq -0x60(%rbp), %rdi
movq %rdx, %rsi
movq %rax, %... | /Kuree[P]kratos/extern/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_);
}
f... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x5a507
leaq 0x50(%rbx), %rdi
callq 0x32760
leaq 0x10(%rbx), %rdi
callq 0x32760
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x32960
movq %rax, %rdi
callq 0x390d5
nop
| /Kuree[P]kratos/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x32f10
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x32300
leaq 0xa(%rax), %r12
movq %r12, %rdi
callq 0x32040
movq %rax, %r14
leaq 0xeccb9(%rip), %rdx # 0x147289
movq %rax, %rdi... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::GTestLog::~GTestLog() | GTestLog::~GTestLog() {
GetStream() << ::std::endl;
if (severity_ == GTEST_FATAL) {
fflush(stderr);
posix::Abort();
}
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1696de(%rip), %rdi # 0x1c3fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x32720
movsbl %al, %esi
movq 0x1696c3(%rip), %rdi # 0x1c3fe0
callq 0x32050
movq %rax, %rdi
callq 0x32520
cmpl $0x3, (%rbx)
je 0x5a936
addq $0x8, %rs... | /Kuree[P]kratos/extern/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %edi, %r14d
cmpq $0x0, (%rdx)
je 0x5aa1e
movq %rsi, %r15
leaq 0xec944(%rip), %rdx # 0x1472d9
leaq -0x24(%rbp), %rdi
movl $0x3, %esi
movl $0x49b, %ecx # imm = 0x49B
callq 0x5a7ac
movq 0x169631(%rip... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::ReadEntireFile[abi:cxx11](_IO_FILE*) | std::string ReadEntireFile(FILE* file) {
const size_t file_size = GetFileSize(file);
char* const buffer = new char[file_size];
size_t bytes_last_read = 0; // # of bytes read in the last fread()
size_t bytes_read = 0; // # of bytes read so far
fseek(file, 0, SEEK_SET);
// Keeps reading the file unt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x32860
movq %r14, %rdi
callq 0x32030
movq %rax, %r12
movq %rax, %rdi
callq 0x32040
movq %rax, %r15
movq %r14, %rdi
xorl %e... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x3f612
movq (%r15), %rdi
addq $0x10, %rdi
leaq 0xec503(%rip), %rsi # 0x1471c7
movl $0x6, %r15d
movl $0x6, %edx
callq 0x328b0
movq -0x30(%rbp), %r12
ad... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-port.cc |
testing::internal::PrintBytesInObjectTo(unsigned char const*, unsigned long, std::ostream*) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
ostream* os) {
PrintBytesInObjectToImpl(obj_bytes, count, os);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x32510
leaq 0xed175(%rip), %rsi # 0x147f96
movl $0xe, %edx
movq %rax, %rdi
callq 0x328b0
cmpq $0x83, %r14
ja 0x5ae3e
movq %r15, %rdi
xorl %esi, %esi
jmp 0x5ae72
movl $0x40, %... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t, std::ostream*) | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq (%rsi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsi,%rax)
leaq 0xec55b(%rip), %rsi # 0x147440
movl $0x2, %edx
movq %rbx, %rdi
callq 0x328b0
mo... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(unsigned __int128, std::ostream*) | void PrintTo(__uint128_t v, ::std::ostream* os) {
if (v == 0) {
*os << "0";
return;
}
// Buffer large enough for ceil(log10(2^128))==39 and the null terminator
char buf[40];
char* p = buf + sizeof(buf);
// Some configurations have a __uint128_t, but no support for built in
// division. Do manual... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x5b031
leaq -0x19(%rbp), %r14
movb $0x0, (%r14)
je 0x5b010
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $0x1999999999999999, %r10 # imm = 0x1999999999999999
movabsq $0x... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char const*, std::ostream*) | void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x5b20a
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x325d0
leaq 0xed0dd(%rip), %rsi # 0x1482c0
movl $0xd, %edx
movq %rax, %rdi
callq 0x328b0
movq %r14, %rdi
callq 0x32300
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
p... | /Kuree[P]kratos/extern/googletest/googletest/src/gtest-printers.cc |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, s... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
popq %rbp
retq
nop
| /Kuree[P]kratos/extern/googletest/googletest/include/gtest/gtest-matchers.h |
decltype(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::MatcherBase<std::basic_string_v... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq (%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x68402
testq %rdx, %rdx
je 0x68405
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rdi
movq 0x8(%rax), %rsi
callq 0x327c0
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
| /Kuree[P]kratos/extern/googletest/googletest/include/gtest/gtest-matchers.h |
kratos::Generator::from_verilog(kratos::Context*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std:... | Generator &Generator::from_verilog(Context *context, const std::string &src_file,
const std::string &top_name,
const std::vector<std::string> &lib_files,
const std::map<std::string, PortType> &port_types) {
if (... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %r8, -0x38(%rbp)
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xce8e0
testb %al, %al
je 0x68944
movq %rbx, %rdi
movq %r14, -0x60(%rbp)
movq %r14, %rs... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int, bool) | Var &Generator::var(const std::string &var_name, uint32_t width, uint32_t size, bool is_signed) {
const auto &lst = std::vector<uint32_t>{size};
return var(var_name, width, lst, is_signed);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq -0x30(%rbp), %rsi
movl %ecx, (%rsi)
leaq -0x48(%rbp), %r13
leaq -0x29(%rbp), %rcx
movl $0x1, %edx
movq %r13, %rdi
callq 0x7181e
movq %r12, %rdi
movq %r... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::call(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<kratos::Var>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>,... | FunctionCallVar &Generator::call(const std::string &func_name,
const std::map<std::string, std::shared_ptr<Var>> &args,
bool has_return) {
if (funcs_.find(func_name) == funcs_.end())
throw UserException(::format("function {0} not found", func... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb %cl, -0x21(%rbp)
leaq 0x3b8(%rdi), %r12
movq %r12, %rdi
callq 0x791ba
leaq 0x3c0(%rbx), %rcx
cmpq %rcx, %rax
je 0x6a868
movq %r12, %rdi
movq %r15, %rsi
callq 0x71966
movq (%rax), ... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::call(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::shared_ptr<kratos::Var>, std::allocator<std::shared_ptr<kratos::Var>>> const&) | FunctionCallVar &Generator::call(const std::string &func_name,
const std::vector<std::shared_ptr<Var>> &args) {
if (funcs_.find(func_name) == funcs_.end())
throw UserException(::format("function {0} not found", func_name));
auto func_def = funcs_.at(func_name);
if (!... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x3b8(%rdi), %r15
movq %r15, %rdi
callq 0x791ba
leaq 0x3c0(%r12), %rcx
cmpq %rcx, %rax
je 0x6abf0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x71966
movq (%rax), %rcx
movq %... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::property(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<kratos::Sequence> const&) | std::shared_ptr<Property> Generator::property(const std::string &property_name,
const std::shared_ptr<Sequence> &sequence) {
if (properties_.find(property_name) != properties_.end())
throw UserException(::format("Property {0} already exists in {1}", property_nam... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x4b8(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x7aa22
leaq 0x4c0(%r13), %rcx
cmpq %rcx, %rax
jne 0x6b2a9
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r1... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_child_generators() | std::vector<std::shared_ptr<Generator>> Generator::get_child_generators() {
std::vector<std::shared_ptr<Generator>> result;
if (is_external_) return result;
result.reserve(children_.size());
for (auto const &n : children_names_) {
result.emplace_back(children_.at(n));
}
return result;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpb $0x0, 0x2d9(%rsi)
jne 0x6bd85
movq %rsi, %r14
movq 0x228(%rsi), %rsi
movq %rbx, %rdi
callq 0x71b64
movq 0x248(%r14), %r15
movq 0x250(%r14), %r12
cmpq %r12, %r15
je 0x... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::remove_port(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Generator::remove_port(const std::string &port_name) {
if (has_port(port_name)) {
ports_.erase(port_name);
remove_var(port_name);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x130(%rdi), %r15
movq %r15, %rdi
callq 0x753b0
leaq 0x138(%r14), %rcx
cmpq %rcx, %rax
je 0x6c69a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7dd30
movq %r15, %rdi
movq %rax, %rsi
callq 0x7dde2
movq %r14, %rdi
movq %... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_param(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::shared_ptr<Param> Generator::get_param(const std::string ¶m_name) const {
if (params_.find(param_name) == params_.end()) return nullptr;
return params_.at(param_name);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x160(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x7e1a0
addq $0x168, %r12 # imm = 0x168
cmpq %r12, %rax
je 0x6cb6b
movq %r15, %rdi
movq %r14, %rsi
callq 0x71e1c
movq (%rax), %rc... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_interface(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::shared_ptr<InterfaceRef> Generator::get_interface(const std::string &interface_name) const {
return interfaces_.find(interface_name) != interfaces_.end() ? interfaces_.at(interface_name)
: nullptr;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x488(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x7f7e4
addq $0x490, %r12 # imm = 0x490
cmpq %r12, %rax
je 0x6dc9d
movq %r15, %rdi
movq %r14, %rsi
callq 0x71fe8
movq (%rax), %rc... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::var_packed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<kratos::PackedStruct> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&) | VarPackedStruct &Generator::var_packed(const std::string &var_name,
const std::shared_ptr<PackedStruct> &packed_struct_,
const std::vector<uint32_t> &size) {
if (vars_.find(var_name) != vars_.end())
throw VarException(::format("{0... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x100(%rdi), %r15
movq %r15, %rdi
callq 0x7544e
leaq 0x108(%r12), %rcx
cmpq %rcx, %rax
jne 0x6f9fc
leaq -0x78(%rbp), %rcx
movq %r12, (%rcx)
leaq -0x48(%... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::var_packed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<kratos::PackedStruct> const&, unsigned int) | VarPackedStruct &Generator::var_packed(const std::string &var_name,
const std::shared_ptr<PackedStruct> &packed_struct_,
uint32_t size) {
return var_packed(var_name, packed_struct_, std::vector<uint32_t>{size});
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x28(%rbp), %rsi
movl %ecx, (%rsi)
leaq -0x40(%rbp), %r12
leaq -0x21(%rbp), %rcx
movl $0x1, %edx
movq %r12, %rdi
callq 0x7181e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
mov... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_ports[abi:cxx11](kratos::PortType) const | std::vector<std::string> Generator::get_ports(kratos::PortType type) const {
std::vector<std::string> result;
auto port_names = get_port_names();
for (auto const &port_name : port_names) {
auto port = get_port(port_name);
if (port->port_type() == type) result.emplace_back(port_name);
}
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
addq $0x130, %rsi # imm = 0x130
leaq -0x70(%rbp), %rdi
callq 0x7361c
leaq -0x68(%rbp), %r13
... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::add_bundle_port_def(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, kratos::PortBundleDefinition const&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int> const&) | std::shared_ptr<PortBundleRef> Generator::add_bundle_port_def(
const std::string &port_name, const PortBundleDefinition &def,
const std::pair<std::string, uint32_t> &debug_info) {
auto ref = add_bundle_port_def(port_name, def);
auto definition = def.definition();
for (auto const &iter : definition) ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
callq 0x70720
addq $0x20, %r15
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0x74a0c
leaq -0x70(%rbp), %rax
movq 0x10(%rax), %r15
cmpq %rax, %r15
je 0x70a4a
leaq -0x38(%rbp), ... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_bundle_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::shared_ptr<PortBundleRef> Generator::get_bundle_ref(const std::string &port_name) {
if (!has_port_bundle(port_name)) {
throw UserException(port_name + " not found in " + name);
}
return port_bundle_mapping_.at(port_name);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c8(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x754ec
leaq 0x1d0(%r14), %rcx
cmpq %rcx, %rax
je 0x70b1f
movq %r12, %rdi
movq %r15, %rsi
callq 0x7248e
movq (%rax), %rcx
m... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_child_comment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string Generator::get_child_comment(const std::string &child_name) const {
if (children_comments_.find(child_name) != children_comments_.end())
return children_comments_.at(child_name);
return "";
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x298, %r15 # imm = 0x298
movq %r15, %rdi
movq %rdx, %rsi
callq 0x8141e
testq %rax, %rax
je 0x70c28
movq %r15, %rdi
movq %r14, %rsi
callq 0x8141e
testq %rax, %rax
je 0x70c4f
leaq 0x10(... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_named_block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::shared_ptr<StmtBlock> Generator::get_named_block(const std::string &block_name) const {
if (!has_named_block(block_name)) return nullptr;
return named_blocks_.at(block_name);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x320, %r15 # imm = 0x320
movq %r15, %rdi
movq %rdx, %rsi
callq 0x74f52
testq %rax, %rax
je 0x70ccd
movq %r15, %rdi
movq %r14, %rsi
callq 0x74f52
testq %rax, %rax
je 0x70ce7
movq 0x28(... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_block_name[abi:cxx11](kratos::Stmt const*) const | std::optional<std::string> Generator::get_block_name(const Stmt *stmt) const {
for (auto const &[name_, s] : named_blocks_) {
if (s.get() == stmt) {
return name_;
}
}
return std::nullopt;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x330, %r14 # imm = 0x330
movq (%r14), %r14
testq %r14, %r14
je 0x70d39
cmpq %rdx, 0x28(%r14)
jne 0x70d08
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
c... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::add_named_block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<kratos::StmtBlock> const&) | void Generator::add_named_block(const std::string &block_name,
const std::shared_ptr<StmtBlock> &block) {
if (has_named_block(block_name))
throw StmtException(::format("{0} already exists in {1}", block_name, name), {block.get()});
named_blocks_.emplace(block_name, block)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x320(%rdi), %rbx
movq %rbx, %rdi
callq 0x74f52
testq %rax, %rax
jne 0x70d8c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::named_blocks_labels[abi:cxx11]() const | std::unordered_set<std::string> Generator::named_blocks_labels() const {
std::unordered_set<std::string> result;
result.reserve(named_blocks_.size());
for (auto const &iter : named_blocks_) result.emplace(iter.first);
return result;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movsd 0x338(%rsi), %xmm0
unpcklps 0xd392d(%rip), %xmm0 # x... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::get_auxiliary_var(unsigned int, bool) | std::shared_ptr<Var> Generator::get_auxiliary_var(uint32_t width, bool signed_) {
if (auxiliary_vars_.find(width) != auxiliary_vars_.end()) {
return auxiliary_vars_.at(width);
}
auto v = std::make_shared<Var>(this, "", width, 1, signed_);
auxiliary_vars_.emplace(width, v);
return v;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r9d
movq %rdi, %rbx
movl %edx, -0x28(%rbp)
movb %cl, -0x21(%rbp)
movl %edx, %eax
movq 0x450(%rsi), %r8
movq 0x458(%rsi), %rcx
xorl %r11d, %r11d
xorl %edx, %edx
divq %rcx
movq (%r8,%rdx,8), %rax
testq %rax, %rax
je 0x7141... | /Kuree[P]kratos/src/generator.cc |
kratos::Generator::is_auxiliary_var(std::shared_ptr<kratos::Var> const&) | bool Generator::is_auxiliary_var(const std::shared_ptr<Var> &var) {
return auxiliary_vars_.find(var->width()) != auxiliary_vars_.end() &&
auxiliary_vars_.at(var->width()) == var;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl %eax, %ecx
movl %eax, %eax
movq 0x450(%r14), %rdi
movq 0x458(%r14), %r8
xorl %r10d, %r10d
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x7... | /Kuree[P]kratos/src/generator.cc |
kratos::IRNode::~IRNode() | virtual ~IRNode() = default; | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x149850(%rip), %rax # 0x1baff8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x50, %rdi
callq 0x733fa
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x717d0
movq (%rax), %rsi
incq %rsi
callq 0x32780
addq $0x8, %rbx
movq %rbx, %rdi
addq... | /Kuree[P]kratos/src/ir.hh |
kratos::check_direction(kratos::Port const*, kratos::Port*, bool) | void inline check_direction(const Port *port1, Port *port2, bool same_direction = false) {
auto port1_dir = port1->port_direction();
PortDirection correct_dir;
if (same_direction)
correct_dir = port1_dir;
else if (port1_dir == PortDirection::In)
correct_dir = PortDirection ::Out;
els... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl 0x270(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
testl %edx, %edx
cmovnel %eax, %ecx
cmpl %ecx, 0x270(%rsi)
jne 0x7207e
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %... | /Kuree[P]kratos/src/generator.cc |
std::shared_ptr<kratos::AssignStmt> kratos::Stmt::as<kratos::AssignStmt>() | std::shared_ptr<T> as() {
return std::static_pointer_cast<T>(shared_from_this());
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x68, %rsi
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x3ac80
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x72214
movq 0x151d52(%rip), %rcx # 0x1c3f58
cmpb $0x0, (%rcx)
je 0... | /Kuree[P]kratos/src/stmt.hh |
kratos::Generator::~Generator() | ~Generator() override = default; | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x144088(%rip), %rax # 0x1b65c8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x528, %rdi # imm = 0x528
callq 0x727c4
leaq 0x4e8(%rbx), %rdi
callq 0x72870
leaq 0x4b8(%rbx), %rdi
callq 0x72926
leaq 0x488(%rbx), %rdi
callq 0x729cc
leaq 0x450(%... | /Kuree[P]kratos/src/generator.hh |
kratos::InterfaceRef::InterfaceRef(std::shared_ptr<kratos::IDefinition>, kratos::Generator*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | explicit InterfaceRef(std::shared_ptr<IDefinition> instance, Generator *gen, std::string name)
: definition_(std::move(instance)), gen_(gen), name_(std::move(name)) {} | pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %r8
movq %rax, 0x8(%rsi)
movq %r8, 0x8(%rdi)
movq %rax, (%rsi)
leaq 0x40(%rdi), %rax
movq %rax, 0x10(%rdi)
movl $0x1, %eax
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x3f80000... | /Kuree[P]kratos/src/interface.hh |
kratos::PortBundleRef::PortBundleRef(kratos::Generator*, kratos::PortBundleDefinition) | PortBundleRef(Generator *generator, PortBundleDefinition def)
: generator(generator), definition_(std::move(def)) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x142b51(%rip), %rax # 0x1c35e8
addq $0x10, %rax
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq (%rdx), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x80ac3
movq %rdx,... | /Kuree[P]kratos/src/port.hh |
kratos::is_relational_op(kratos::ExprOp) | bool is_relational_op(ExprOp op) {
static std::unordered_set<ExprOp> ops = {ExprOp::LessThan, ExprOp::GreaterThan,
ExprOp::LessEqThan, ExprOp::GreaterEqThan,
ExprOp::Eq, ExprOp::Neq};
return ops.find(op) != ops.e... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movb 0x142ba2(%rip), %al # 0x1c4ee8
testb %al, %al
je 0x823c1
movq 0x142b67(%rip), %rdi # 0x1c4eb8
xorl %r9d, %r9d
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
movq 0x142b4d(%rip), %rax # 0x1c4eb0
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je ... | /Kuree[P]kratos/src/expr.cc |
kratos::is_unary_op(kratos::ExprOp) | bool is_unary_op(ExprOp op) {
static std::unordered_set<ExprOp> ops = {ExprOp::UXor, ExprOp::UPlus, ExprOp::UOr,
ExprOp::UNot, ExprOp::UXor, ExprOp::UInvert,
ExprOp::UMinus};
return ops.find(op) != ops.end();
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movb 0x1428f0(%rip), %al # 0x1c4fa8
testb %al, %al
je 0x82733
movq 0x1428b5(%rip), %rdi # 0x1c4f78
xorl %r9d, %r9d
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
movq 0x14289b(%rip), %rax # 0x1c4f70
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je ... | /Kuree[P]kratos/src/expr.cc |
kratos::Var::width() const | uint32_t Var::width() const {
uint32_t w = (width_param_ && type_ != VarType::Slice)
? Simulator::static_evaluate_expr(width_param_)
: var_width_;
for (auto const &i : size_) w *= i;
return w;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1e8(%rdi), %rdi
testq %rdi, %rdi
je 0x827fd
cmpl $0x2, 0x168(%rbx)
je 0x827fd
callq 0xfc1fe
jmp 0x82803
movl 0x98(%rbx), %eax
movq 0xa0(%rbx), %rcx
movq 0xa8(%rbx), %rdx
cmpq %rdx, %rcx
je 0x8281f
imull (%rcx), %eax
addq $0x4, %rcx
jmp 0x82811
addq... | /Kuree[P]kratos/src/expr.cc |
kratos::Var::r_or() const | Expr &Var::r_or() const {
auto var = generator()->get_var(name);
return generator()->expr(ExprOp::UOr, const_cast<Var *>(this), nullptr);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x78(%rbx), %rdx
leaq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x69534
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movl $0x3, %esi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x69d68
movq %ra... | /Kuree[P]kratos/src/expr.cc |
kratos::Var::r_and() const | Expr &Var::r_and() const {
auto var = generator()->get_var(name);
return generator()->expr(ExprOp::UAnd, const_cast<Var *>(this), nullptr);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x78(%rbx), %rdx
leaq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x69534
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movl $0x5, %esi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x69d68
movq %ra... | /Kuree[P]kratos/src/expr.cc |
kratos::Var::r_xor() const | Expr &Var::r_xor() const {
auto var = generator()->get_var(name);
return generator()->expr(ExprOp::UXor, const_cast<Var *>(this), nullptr);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x78(%rbx), %rdx
leaq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x69534
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movl $0x6, %esi
movq %rax, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x69d68
movq %ra... | /Kuree[P]kratos/src/expr.cc |
kratos::Var::duplicate(unsigned int) const | Expr &Var::duplicate(uint32_t count) const {
auto expr = std::make_shared<VarDuplicated>(const_cast<Var *>(this), count);
generator()->add_expr(expr);
return *expr;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x3c(%rbp), %r8
movl %esi, (%r8)
leaq -0x38(%rbp), %rcx
movq %rdi, (%rcx)
leaq -0x20(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x28(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rsi
callq 0x94afe
movq (%r14), %rsi
movq %r14, %rdi
cal... | /Kuree[P]kratos/src/expr.cc |
kratos::Var::to_string[abi:cxx11]() const | std::string Var::to_string() const { return name; } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x78(%rsi), %rax
movq 0x80(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x3903c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Kuree[P]kratos/src/expr.cc |
kratos::Var::handle_name[abi:cxx11](kratos::Generator*) const | std::string Var::handle_name(kratos::Generator *scope) const {
// subtract the scope
auto gen_name = scope->handle_name();
auto var_name = handle_name();
auto pos = var_name.find(gen_name);
if (pos != 0) {
throw VarException(
::format("{0} is not accessible from {1}", gen_name, g... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0x6efb2
movq (%r14), %rax
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq *0x100(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rcx
leaq -0x60(%rbp), %r... | /Kuree[P]kratos/src/expr.cc |
kratos::check_parent_param(kratos::Param const*, kratos::Generator const*, bool) | bool check_parent_param(const Param *param, const Generator *parent, bool check_param) {
bool correct = true;
if (!param || param->generator() != parent) correct = false;
if (!correct && check_param)
throw UserException(
::format("Unable to copy var definition since the width parametriz... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
testq %rdi, %rdi
je 0x844d9
movq %rsi, %r14
movq (%rdi), %rax
callq *0x68(%rax)
cmpq %r14, %rax
je 0x844dd
xorl %eax, %eax
jmp 0x844df
movb $0x1, %al
xorb $0x1, %bl
orb %al, %bl
je 0x844ef
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
re... | /Kuree[P]kratos/src/expr.cc |
kratos::VarSlice::to_string[abi:cxx11]() const | std::string VarSlice::to_string() const {
auto const &parent_name = parent_var->to_string();
if (high == low) {
if (high == 0 && parent_var->width() == 1) {
return parent_name;
}
return ::format("{0}[{1}]", parent_name, high);
} else {
return ::format("{0}[{1}:{2}... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x270(%rsi), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0xf8(%rax)
movl 0x278(%r14), %eax
movl 0x27c(%r14), %ecx
cmpl %eax, %ecx
jne 0x850f6
testq %rcx, %rcx
jne 0x85125
movq 0x270(%r14), %rdi
movq (%rdi), %... | /Kuree[P]kratos/src/expr.cc |
kratos::VarSlice::get_var_root_parent() const | const Var *VarSlice::get_var_root_parent() const {
Var *parent = parent_var;
while (parent->type() == VarType::Slice) {
parent = parent->as<VarSlice>()->parent_var;
}
return parent;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x270(%rdi), %rbx
cmpl $0x2, 0x168(%rbx)
jne 0x851ea
leaq -0x20(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x90bd8
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x270(%rax), %rbx
testq %rdi, %rdi
je 0x851e1
callq 0x3913e
cmpl $0x2, 0x168... | /Kuree[P]kratos/src/expr.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.