name string | code string | asm string | file string |
|---|---|---|---|
main | int main(int argc, char ** argv) {
std::string model_path;
int ngl = 99;
int n_ctx = 2048;
// parse command line arguments
for (int i = 1; i < argc; i++) {
try {
if (strcmp(argv[i], "-m") == 0) {
if (i + 1 < argc) {
model_path = argv[++i];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp # imm = 0x3C8
movq %rsi, %r14
leaq 0x160(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x2, %edi
setge %al
jl 0x28a1
movl %edi, %ebp
movl $0x1, %ebx
movl $0x800, 0x7c(%rsp) # imm = 0x80... | /ggerganov[P]llama/examples/simple-chat/simple-chat.cpp |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::PartialReduxExpr<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::member_mean<double>, 1> const, Eigen::CwiseNullaryOp<Eigen::internal::sca... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x18(%rsi), %r14
movsd 0x28(%rsi), %xmm2
cmpq %r14, 0x8(%rdi)
jne 0x1278e
cmpq $0x1, 0x10(%rbx)
je 0x127b6
movsd %xmm2, 0x8(%rsp)
testq %r14, %r14
js 0x128dc
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq ... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
ArtificialPopulation::update() | void ArtificialPopulation::update() {
while(current_time < clock->getCurrentTime()) {
resetOutput();
annOutput = ann->predict(annInput);
for(int i = 0; i < numberOfOutputNeurons; i++) {
output[i] = new ValueEvent(annOutput(0, i));
logger->logValue((long)this, i, Event... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movsd 0x48(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rdi), %rdi
callq 0x15972
ucomisd (%rsp), %xmm0
jbe 0x148c5
leaq 0x68(%rbx), %r14
leaq 0x20(%rsp), %r15
leaq 0xf463(%rip), %r12 # 0x23bc8
movq %rbx, %rdi
callq 0x... | /haukri[P]MasterProject/Network/Population/ArtificialPopulation.cpp |
Precond | static int Precond(sunrealtype t, N_Vector c, N_Vector fc, sunbooleantype jok,
sunbooleantype* jcurPtr, sunrealtype gamma, void* user_data)
{
sunrealtype*** P;
sunindextype ier;
sunindextype** pivot;
int i, if0, if00, ig, igx, igy, j, jj, jx, jy;
int *jxr, *jyr, ngrp, ngx, ngy, mxmp, mp, fl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %rbx
movapd %xmm1, 0x30(%rsp)
movq %rcx, %r14
movq %rsi, %r15
movq 0x988(%r8), %r12
callq 0x2370
movq %rax, 0x28(%rsp)
movq 0x980(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2200
testl %eax, %eax
js 0x3c16
movq %r14, 0x... | /opencor[P]sundials/examples/arkode/C_serial/ark_KrylovDemo_prec.c |
higan::Logger::~Logger() | Logger::~Logger()
{
*buffer_.WriteBegin() = '\n';
buffer_.AddWriteIndex(1);
g_output_func(buffer_.ReadBegin(), buffer_.ReadableSize());
if (level_ == FATAL)
{
g_flush_func();
abort();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x121f0
movq -0x10(%rbp), %rdi
movb $0xa, (%rax)
movl $0x1, %esi
callq 0x12260
jmp 0x128ec
movq -0x10(%rbp), %rdi
callq 0x121d0
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x122b0
movq -0x18(%rbp... | /HiganFish[P]higan/higan/base/Logger.cpp |
higan::System::MakeDirIfNotExist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | bool System::MakeDirIfNotExist(const std::string& dir_path, bool loop_create)
{
if (dir_path.empty())
{
return false;
}
int result = mkdir(dir_path.c_str(), S_IRWXU | S_IRGRP | S_IROTH);
if (result == -1)
{
if (errno == EEXIST)
{
return true;
}
else if (errno == ENOENT)
{
if (!loop_create)
{... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x114c0
testb $0x1, %al
jne 0x160c3
jmp 0x160cc
movb $0x0, -0x1(%rbp)
jmp 0x161d0
movq -0x10(%rbp), %rdi
callq 0x11110
movq %rax, %rdi
movl $0x1e4, %esi # imm = ... | /HiganFish[P]higan/higan/base/System.cpp |
higan::LogFile::GetFileName[abi:cxx11]() | std::string LogFile::GetFileName()
{
time_t now = time(nullptr);
struct tm* tm_now = localtime(&now);
char buffer[32];
strftime(buffer, sizeof buffer, ".%Y%m%d-%H%M%S.", tm_now);
std::string result_name = log_dir_ + "/" + log_prefix_;
result_name.append(buffer);
result_name += "log";
return result_name;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x11290
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x11210
movq %rax, -0x20(... | /HiganFish[P]higan/higan/base/LogFile.cpp |
higan::FileForRead::ReadFileToBuffer(higan::Buffer*) | ssize_t FileForRead::ReadFileToBuffer(Buffer* buffer)
{
if (!buffer)
{
return -1;
}
size_t result = -1;
if (file_status_ == FileStatus::OPEN_SUCCESS)
{
result = buffer->ReadFromFd(read_fd_);
}
else
{
result = -1;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17a29
movq $-0x1, -0x8(%rbp)
jmp 0x17a67
movq -0x28(%rbp), %rax
movq $-0x1, -0x20(%rbp)
cmpl $0x2, 0xb0(%rax)
jne 0x17a57
movq -0x28(%rbp), %rax
movq -0x18... | /HiganFish[P]higan/higan/base/File.cpp |
higan::Buffer::CopyExDataToBuffer(char const*, unsigned long) | void Buffer::CopyExDataToBuffer(const char* exbuffer, size_t ex_len)
{
size_t drop_len = read_idx_ - DEFAULT_READ_INDEX;
/**
* 可以将已读的内容丢弃来 从远buffer_中得到足够的空间
* 无法得到则扩容
*/
if (drop_len >= ex_len)
{
std::copy(ReadBegin(), ReadBegin() + ReadableSize(), &buffer_[DEFAULT_READ_INDEX]);
write_idx_ -= drop_len;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x18(%rax), %rax
subq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x181ee
movq -0x28(%rbp), %rdi
callq 0x18250
movq -0x... | /HiganFish[P]higan/higan/base/Buffer.cpp |
KDReports::TableBreakingSettingsDialog::qt_metacall(QMetaObject::Call, int, void**) | int KDReports::TableBreakingSettingsDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDialog::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x26200
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x27a... | /KDAB[P]KDReports/build_O0/src/kdreports_autogen/NRD2APHKSC/moc_KDReportsTableBreakingSettingsDialog.cpp |
KDReports::ChartElement::setChart(KDChart::Chart*) | void KDReports::ChartElement::setChart(KDChart::Chart *chart)
{
#ifdef HAVE_KDCHART
if (d->m_deleteChart)
delete d->m_chart;
d->m_chart = chart;
d->m_deleteChart = false;
#else
Q_UNUSED(chart);
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| /KDAB[P]KDReports/src/KDReports/KDReportsChartElement.cpp |
KDReports::TableLayout::decorationSize(QVariant const&) const | QSize KDReports::TableLayout::decorationSize(const QVariant &cellDecoration) const
{
QImage img = qvariant_cast<QImage>(cellDecoration);
if (!img.isNull()) {
return img.size();
}
QPixmap pix = qvariant_cast<QPixmap>(cellDecoration);
if (!pix.isNull()) {
return pix.size();
}
r... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x463b0
movq -0x68(%rbp), %rdi
callq 0x24000
movb %al, -0x59(%rbp)
jmp 0x92c0a
movb -0x59(%rbp), %al
testb $0... | /KDAB[P]KDReports/src/KDReports/KDReportsTableLayout.cpp |
ImGuiIO::ImGuiIO() | ImGuiIO::ImGuiIO()
{
// Most fields are initialized with zero
memset(this, 0, sizeof(*this));
// Settings
ConfigFlags = ImGuiConfigFlags_None;
BackendFlags = ImGuiBackendFlags_None;
DisplaySize = ImVec2(-1.0f, -1.0f);
DeltaTime = 1.0f/60.0f;
IniSavingRate = 5.0f;
IniFilename = "imgu... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
callq 0x2c260
movq -0x60(%rbp), %rdi
addq $0xb0, %rdi
callq 0x2c260
movq -0x60(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
callq 0x2c260
movq -0x60(%rbp), %rdi
addq $0x3ac, %rdi ... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImTextCharFromUtf8(unsigned int*, char const*, char const*) | int ImTextCharFromUtf8(unsigned int* out_char, const char* in_text, const char* in_text_end)
{
unsigned int c = (unsigned int)-1;
const unsigned char* str = (const unsigned char*)in_text;
if (!(*str & 0x80))
{
c = (unsigned int)(*str++);
*out_char = c;
return 1;
}
if ((*s... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xbf9a
movq -0x30(%rbp), %rax
movq %rax, %rcx
add... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImTriangleBarycentricCoords(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, float&, float&, float&) | void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w)
{
ImVec2 v0 = b - a;
ImVec2 v1 = c - a;
ImVec2 v2 = p - a;
const float denom = v0.x * v1.y - v1.x * v0.y;
out_v = (v2.x * v1.y - v1.x * v2.y) / denom;
ou... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xc4b0
movlpd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%r... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImStrdupcpy(char*, unsigned long*, char const*) | char* ImStrdupcpy(char* dst, size_t* p_dst_size, const char* src)
{
size_t dst_buf_size = p_dst_size ? *p_dst_size : strlen(dst) + 1;
size_t src_size = strlen(src) + 1;
if (dst_buf_size < src_size)
{
IM_FREE(dst);
dst = (char*)IM_ALLOC(src_size);
if (p_dst_size)
*p_ds... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcc28
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xcc39
movq -0x8(%rbp), %rdi
callq 0x7490
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
mov... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImStrTrimBlanks(char*) | void ImStrTrimBlanks(char* buf)
{
char* p = buf;
while (p[0] == ' ' || p[0] == '\t') // Leading blanks
p++;
char* p_start = p;
while (*p != 0) // Find end of string
p++;
while (p > p_start && (p[-1] == ' ' || p[-1] == '\t')) // Trailing blanks
p--... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x19(%rbp)
je 0xcfa5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImHashData(void const*, unsigned long, unsigned int) | ImU32 ImHashData(const void* data_p, size_t data_size, ImU32 seed)
{
ImU32 crc = ~seed;
const unsigned char* data = (const unsigned char*)data_p;
const ImU32* crc32_lut = GCrc32LookupTable;
while (data_size-- != 0)
crc = (crc >> 8) ^ crc32_lut[(crc & 0xFF) ^ *data++];
return ~crc;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xace09(%rip), %rax # 0xba010
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImTextCountUtf8BytesFromStr(unsigned short const*, unsigned short const*) | int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* in_text_end)
{
int bytes_count = 0;
while ((!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c = (unsigned int)(*in_text++);
if (c < 0x80)
bytes_count++;
else
bytes_count ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd9cd
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0xd9db
movq -0x8(%rbp), %rax
cmpw $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x1... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGuiStorage::BuildSortByKey() | void ImGuiStorage::BuildSortByKey()
{
struct StaticFunc
{
static int IMGUI_CDECL PairCompareByID(const void* lhs, const void* rhs)
{
// We can't just do a subtraction because qsort uses signed integers and subtracting our ID doesn't play well with that.
if (((const Pair*)... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, (%rax)
jle 0xe1f5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq (%rax), %rsi
movl $0x10, %edx
leaq 0x10(%rip), %rcx # 0xe200
callq 0x7800
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGuiTextFilter::Build() | void ImGuiTextFilter::Build()
{
Filters.resize(0);
TextRange input_range(InputBuf, InputBuf+strlen(InputBuf));
input_range.split(',', &Filters);
CountGrep = 0;
for (int i = 0; i != Filters.Size; i++)
{
TextRange& f = Filters[i];
while (f.b < f.e && ImCharIsBlankA(f.b[0]))
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x100, %rdi # imm = 0x100
xorl %esi, %esi
callq 0x2c670
movq -0x30(%rbp), %rdi
callq 0x7490
movq -0x30(%rbp), %rsi
movq %rsi, %rdx
addq %rax, %rdx
leaq -0x18(%rbp), %rdi
callq 0x2c730
movq -0x... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGuiTextBuffer::appendfv(char const*, __va_list_tag*) | void ImGuiTextBuffer::appendfv(const char* fmt, va_list args)
{
va_list args_copy;
va_copy(args_copy, args);
int len = ImFormatStringV(NULL, 0, fmt, args); // FIXME-OPT: could do a first pass write attempt, likely successful on first pass.
if (len <= 0)
{
va_end(args_copy);
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x10(%rbp), %rdx
movq -0x... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::CalcListClipping(int, float, int*, int*) | void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (g.LogEnabled)
{
// If logging is active, do not perform any clipping
*out_items_display_star... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0xeeb91(%rip), %rax # 0xfdd60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1a08(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x2ee0(%rax)
je 0... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGuiListClipper::Step() | bool ImGuiListClipper::Step()
{
if (ItemsCount == 0 || ImGui::GetCurrentWindowRead()->SkipItems)
{
ItemsCount = -1;
return false;
}
if (StepNo == 0) // Step 0: the clipper let you process the first element, regardless of it being visible or not, so we can measure the element height.
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x8(%rax)
je 0xf468
callq 0x2c900
testb $0x1, 0x83(%rax)
je 0xf47c
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
movb $0x0, -0x1(%rbp)
jmp 0xf5d1
movq -0x20(%rbp), %rax
cm... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::LogRenderedText(ImVec2 const*, char const*, char const*) | void ImGui::LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (!text_end)
text_end = FindRenderedTextEnd(text, text_end);
const bool log_new_line = ref_pos && (ref_pos->y > g.LogLinePosY + 1);
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0xee5b5(%rip), %rax # 0xfdd60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1a08(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf7d6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::CalcTextSize(char const*, char const*, bool, float) | ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
ImGuiContext& g = *GImGui;
const char* text_display_end;
if (hide_text_after_double_hash)
text_display_end = FindRenderedTextEnd(text, text_end); // Hide anything after a '#... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movss %xmm0, -0x20(%rbp)
movq 0xee00d(%rip), %rax # 0xfdd60
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0xfd70
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf5e0... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::RenderCheckMark(ImVec2, unsigned int, float) | void ImGui::RenderCheckMark(ImVec2 pos, ImU32 col, float sz)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
float thickness = ImMax(sz / 5.0f, 1.0f);
sz -= thickness*0.5f;
pos += ImVec2(thickness*0.25f, thickness*0.25f);
float third = sz / 3.0f;
float bx = pos.x + thir... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movlpd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq 0xed764(%rip), %rax # 0xfdd60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x1a08(%rax), %rax
movq %rax, -0x20(%rbp)
movss -0x10(%rbp), %xmm0
movss 0xa982c(%rip), %xmm1 # 0xb9e48
divss %... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGuiWindow::ImGuiWindow(ImGuiContext*, char const*) | ImGuiWindow::ImGuiWindow(ImGuiContext* context, const char* name)
: DrawListInst(&context->DrawListSharedData)
{
Name = ImStrdup(name);
ID = ImHashStr(name);
IDStack.push_back(ID);
Flags = ImGuiWindowFlags_None;
Pos = ImVec2(0.0f, 0.0f);
Size = SizeFull = ImVec2(0.0f, 0.0f);
SizeContents... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x10, %rdi
callq 0x2c260
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x2c260
movq -0x90(%rbp), %rdi
addq $0x20, %rdi
callq 0x2c260
movq -0x90(%rbp), %rdi
a... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::ItemAdd(ImRect const&, unsigned int, ImRect const*) | bool ImGui::ItemAdd(const ImRect& bb, ImGuiID id, const ImRect* nav_bb_arg)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (id != 0)
{
// Navigation processing runs prior to clipping early-out
// (a) So that NavInitRequest can be honored, for newly opened window... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq 0xebfc6(%rip), %rax # 0xfdd60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x1a08(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x11e77
movq -0x30(%rbp), %rax
movl 0x13c(%rax), ... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::CalcWrapWidthForPos(ImVec2 const&, float) | float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
if (wrap_pos_x < 0.0f)
return 0.0f;
ImGuiWindow* window = GImGui->CurrentWindow;
if (wrap_pos_x == 0.0f)
wrap_pos_x = GetWorkRectMax().x;
else if (wrap_pos_x > 0.0f)
wrap_pos_x += window->Pos.x - window->Scr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x129c7
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x12a48
movq 0xeb392(%rip), %rax # 0xfdd60
movq 0x1a08(%rax), %rax
movq %rax, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
xorp... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::FocusTopMostWindowUnderOne(ImGuiWindow*, ImGuiWindow*) | void ImGui::FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window)
{
ImGuiContext& g = *GImGui;
int start_idx = g.WindowsFocusOrder.Size - 1;
if (under_this_window != NULL)
{
int under_this_window_idx = FindWindowFocusIndex(under_this_window);
if (under_t... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xe64f9(%rip), %rax # 0xfdd60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x19c0(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1789f
movq -0x8(%rbp), %rdi
callq 0x211f0
movl %eax, -0x... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::SetNextWindowSize(ImVec2 const&, int) | void ImGui::SetNextWindowSize(const ImVec2& size, ImGuiCond cond)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
g.NextWindowData.SizeVal = size;
g.NextWindowData.SizeCond = cond ? cond : ImGuiCond_Alw... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0xe640a(%rip), %rax # 0xfdd60
movq %rax, -0x18(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
je 0x17970
movl -0xc(%rbp), %edi
callq 0x223f0
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne ... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
SettingsHandlerWindow_ReadLine(ImGuiContext*, ImGuiSettingsHandler*, void*, char const*) | static void SettingsHandlerWindow_ReadLine(ImGuiContext* ctx, ImGuiSettingsHandler*, void* entry, const char* line)
{
ImGuiContext& g = *ctx;
ImGuiWindowSettings* settings = (ImGuiWindowSettings*)entry;
float x, y;
int i;
if (sscanf(line, "Pos=%f,%f", &x, &y) == 2) settings->Pos = ImVec2(x, ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xa2d04(%rip), %rsi # 0xbdc07
leaq -0x34(%rbp), %rdx
leaq -0x3... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::End() | void ImGui::End()
{
ImGuiContext& g = *GImGui;
if (g.CurrentWindowStack.Size <= 1 && g.FrameScopePushedImplicitWindow)
{
IM_ASSERT(g.CurrentWindowStack.Size > 1 && "Calling End() too many times!");
return; // FIXME-ERRORHANDLING
}
IM_ASSERT(g.CurrentWindowStack.Size > 0);
ImGui... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xe2421(%rip), %rax # 0xfdd60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x19e0(%rax)
jg 0x1b9a2
movq -0x8(%rbp), %rax
testb $0x1, 0x2(%rax)
je 0x1b9a2
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x19e0(%rcx)
movb %al, -0x11(%rbp)
jle 0x1b973
movb $0... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::NavUpdateWindowingList() | void ImGui::NavUpdateWindowingList()
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.NavWindowingTarget != NULL);
if (g.NavWindowingTimer < NAV_WINDOWING_LIST_APPEAR_DELAY)
return;
if (g.NavWindowingList == NULL)
g.NavWindowingList = FindWindowByName("###NavWindowingList");
SetNextWindowS... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0xe22be(%rip), %rax # 0xfdd60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1ba0(%rax)
je 0x1bab6
jmp 0x1bad5
leaq 0xa201a(%rip), %rdi # 0xbdad7
leaq 0x9eaef(%rip), %rsi # 0xba5b3
movl $0x209d, %edx # imm = 0x209D
leaq 0xa2026(%rip), %rcx... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
ImGui::Render() | void ImGui::Render()
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.Initialized);
if (g.FrameCountEnded != g.FrameCount)
EndFrame();
g.FrameCountRendered = g.FrameCount;
// Gather ImDrawList to render (for each active window)
g.IO.MetricsRenderVertices = g.IO.MetricsRenderIndices = g.IO.Metr... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0xe1dd1(%rip), %rax # 0xfdd60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0x1bf9e
jmp 0x1bfbd
leaq 0x9ec66(%rip), %rdi # 0xbac0b
leaq 0x9e607(%rip), %rsi # 0xba5b3
movl $0xf6c, %edx # imm = 0xF6C
leaq 0x9f5e8(%rip), %rcx #... | /kidanger[P]vpe/imgui-1.70/imgui.cpp |
stbtt_GetGlyphBitmapBoxSubpixel(stbtt_fontinfo const*, int, float, float, float, float, int*, int*, int*, int*) | STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y,float shift_x, float shift_y, int *ix0, int *iy0, int *ix1, int *iy1)
{
int x0=0,y0=0,x1,y1; // =0 suppresses compiler warning
if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) {
// e.g. sp... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movss %xmm3, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%r... | /kidanger[P]vpe/imgui-1.70/imstb_truetype.h |
ImFont::AddGlyph(unsigned short, float, float, float, float, float, float, float, float, float) | void ImFont::AddGlyph(ImWchar codepoint, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x)
{
Glyphs.resize(Glyphs.Size + 1);
ImFontGlyph& glyph = Glyphs.back();
glyph.Codepoint = (ImWchar)codepoint;
glyph.X0 = x0;
glyph.Y0 = y0;
glyph.X1 = x1;
g... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movss 0x10(%rbp), %xmm8
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movss %xmm0, -0x10(%rbp)
movss %xmm1, -0x14(%rbp)
movss %xmm2, -0x18(%rbp)
movss %xmm3, -0x1c(%rbp)
movss %xmm4, -0x20(%rbp)
movss %xmm5, -0x24(%rbp)
movss %xmm6, -0x28(%rbp)
movss %xmm7, -0x2c(%... | /kidanger[P]vpe/imgui-1.70/imgui_draw.cpp |
ImFontAtlasBuildFinish(ImFontAtlas*) | void ImFontAtlasBuildFinish(ImFontAtlas* atlas)
{
// Render into our custom data block
ImFontAtlasBuildRenderDefaultTexData(atlas);
// Register custom rectangle glyphs
for (int i = 0; i < atlas->CustomRects.Size; i++)
{
const ImFontAtlas::CustomRect& r = atlas->CustomRects[i];
if (r... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40e30
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x40d52
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %esi
callq 0x4c9e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %r... | /kidanger[P]vpe/imgui-1.70/imgui_draw.cpp |
ImFontAtlas::GetGlyphRangesChineseFull() | const ImWchar* ImFontAtlas::GetGlyphRangesChineseFull()
{
static const ImWchar ranges[] =
{
0x0020, 0x00FF, // Basic Latin + Latin Supplement
0x2000, 0x206F, // General Punctuation
0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
0x31F0, 0x31FF, // Katakana Ph... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x7d761(%rip), %rax # 0xbebc0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kidanger[P]vpe/imgui-1.70/imgui_draw.cpp |
ImFontAtlas::GetGlyphRangesCyrillic() | const ImWchar* ImFontAtlas::GetGlyphRangesCyrillic()
{
static const ImWchar ranges[] =
{
0x0020, 0x00FF, // Basic Latin + Latin Supplement
0x0400, 0x052F, // Cyrillic + Cyrillic Supplement
0x2DE0, 0x2DFF, // Cyrillic Extended-A
0xA640, 0xA69F, // Cyrillic Extended-B
0,
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x7f8e1(%rip), %rax # 0xc0eb0
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kidanger[P]vpe/imgui-1.70/imgui_draw.cpp |
clipp::parameter clipp::required<char const (&) [3], char const (&) [11]>(char const (&) [3], char const (&) [11]) | inline parameter
required(String&& flag, Strings&&... flags)
{
return parameter{std::forward<String>(flag), std::forward<Strings>(flags)...}
.required(true).blocking(false).repeatable(false);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30f0
leaq (%rax,%r15), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf978
leaq 0x20(%rsp),... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::parameter clipp::option<char const (&) [3], char const (&) [8]>(char const (&) [3], char const (&) [8]) | inline parameter
option(String&& flag, Strings&&... flags)
{
return parameter{std::forward<String>(flag), std::forward<Strings>(flags)...}
.required(false).blocking(false).repeatable(false);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30f0
leaq (%rax,%r15), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf978
leaq 0x20(%rsp),... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::parameter clipp::option<char const (&) [3], char const (&) [11]>(char const (&) [3], char const (&) [11]) | inline parameter
option(String&& flag, Strings&&... flags)
{
return parameter{std::forward<String>(flag), std::forward<Strings>(flags)...}
.required(false).blocking(false).repeatable(false);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30f0
leaq (%rax,%r15), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf978
leaq 0x20(%rsp),... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::make_man_page(clipp::group const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, clipp::doc_formatting const&) | inline man_page
make_man_page(const group& cli,
doc_string progname = "",
const doc_formatting& fmt = doc_formatting{})
{
man_page man;
man.append_section("SYNOPSIS", usage_lines(cli,progname,fmt).str());
man.append_section("OPTIONS", documentation(cli,fmt).str());
return man... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x668, %rsp # imm = 0x668
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::group::group<clipp::parameter>(clipp::group, clipp::parameter) | explicit
group(group p1, P2 p2, Ps... ps):
children_{}, exclusive_{false}, joinable_{false}, scoped_{true}
{
push_back(std::move(p1), std::move(p2), std::move(ps)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movw $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x32(%rdi)
movb $0x1, 0x42(%rdi)
callq 0x9634
addq $0x8, %rsp
po... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::group& clipp::group::push_back<clipp::group, clipp::parameter>(clipp::group&&, clipp::parameter&&) | group&
push_back(Param1&& param1, Param2&& param2, Params&&... params)
{
children_.reserve(children_.size() + 2 + sizeof...(params));
push_back(std::forward<Param1>(param1));
push_back(std::forward<Param2>(param2), std::forward<Params>(params)...);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdi), %r12
movq 0x30(%rdi), %rax
subq 0x28(%rdi), %rax
sarq $0x3, %rax
movabsq $0xf83e0f83e0f83e1, %rsi # imm = 0xF83E0F83E0F83E1
imulq %rax, %rsi
addq $0x2, %rsi
movq %r12, %rdi
callq 0x8a58
movq %r12, %rd... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::parser::missed() const | missing_events missed() const {
missing_events misses;
misses.reserve(missCand_.size());
for(auto i = missCand_.begin(); i != missCand_.end(); ++i) {
misses.emplace_back(&(i->pos->as_param()), i->index);
}
return misses;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xd0(%rsi), %rsi
subq 0xc8(%r14), %rsi
sarq $0x5, %rsi
callq 0x11b36
movq 0xc8(%r14), %r12
cmpq 0xd0(%r14), %r12
je 0x9c2e
movq %rsp, %r15
movq 0x8(%r12), %rax
movq -... | /openglobus[P]openglobusddm/include/clipp.h |
clipp::detail::match_t::match_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, clipp::detail::scoped_dfs_traverser) | match_t(arg_string s, scoped_dfs_traverser p):
str_{std::move(s)}, pos_{std::move(p)}
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rcx
leaq 0x10(%rsi), %rax
cmpq %rax, %rcx
je 0xb222
movq %rcx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0xb229
movups (%rax), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%r... | /openglobus[P]openglobusddm/include/clipp.h |
bool clipp::parser::try_match_full<clipp::detail::select_values>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, clipp::detail::select_values const&) | bool try_match_full(const arg_string& arg, const ParamSelector& select)
{
auto match = detail::full_match(pos_, arg, select);
if(!match) return false;
add_match(match);
return true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
callq 0xb13e
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x105bf
leaq 0x110(%rsp), %r14
movq %r... | /openglobus[P]openglobusddm/include/clipp.h |
main | int main(int argc, char* argv[])
{
sx_tm_init();
uint64_t start_tm = sx_tm_now();
puts("Calculating fibonacci sequence ...");
uint32_t a = 0;
uint32_t b = 1;
int N = 100000;
for (int i = 0; i < N; i++) {
uint32_t f = a + b;
a = b;
b = f;
}
uint64_t delta_tm =... | pushq %rbx
subq $0x10, %rsp
callq 0x11cc
callq 0x120d
movq %rax, %rbx
leaq 0xe7f(%rip), %rdi # 0x2004
callq 0x1030
movq %rbx, %rdi
callq 0x1272
movq %rax, %rbx
movq %rax, %rdi
callq 0x1423
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x13cf
movaps %xmm0, %xmm1
leaq 0xe72(%rip), %rdi # 0x2027
movsd 0x8(%rsp)... | /septag[P]sx/tests/test-timer.c |
sx_tm_since | uint64_t sx_tm_since(uint64_t start_ticks)
{
return stm_since(start_ticks);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0xabcdabcd, 0x2dcd(%rip) # imm = 0xABCDABCD
jne 0x12c0
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
imulq $0x3b9aca00, (%r14), %rcx # imm = 0x3B9ACA00
addq 0x8(%r14), %rcx
subq 0x2dac(%rip), %rcx # 0x4058
subq %rbx, %rcx
movl $0x1, %... | /septag[P]sx/src/timer.c |
sx_tm_laptime | uint64_t sx_tm_laptime(uint64_t* last_ticks)
{
return stm_laptime(last_ticks);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1342
cmpl $0xabcdabcd, 0x2d5b(%rip) # imm = 0xABCDABCD
jne 0x1361
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
imulq $0x3b9aca00, (%r14), %rax # imm = 0x3B9ACA00
addq 0x8(%r14), %rax
subq 0x2d3a(%rip), %rax # 0x4058
m... | /septag[P]sx/src/timer.c |
sx_tm_round_to_common_refresh_rate | uint64_t sx_tm_round_to_common_refresh_rate(uint64_t duration)
{
return stm_round_to_common_refresh_rate(duration);
} | xorl %ecx, %ecx
leaq 0xdb7(%rip), %rdx # 0x2140
movl %ecx, %r8d
shlq $0x4, %r8
movq (%r8,%rdx), %rsi
testq %rsi, %rsi
je 0x13cb
addq %rdx, %r8
movq 0x8(%r8), %r8
movq %rsi, %r9
subq %r8, %r9
cmpq %rdi, %r9
setae %r9b
addq %rsi, %r8
cmpq %rdi, %r8
setbe %r8b
orb %r9b, %r8b
movzbl %r8b, %r8d
addl %r8d, %ecx
testb %... | /septag[P]sx/src/timer.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | movq %rdi, %rax
retq
| /devkitPro[P]curl/lib/warnless.c |
curlx_uztoso | curl_off_t curlx_uztoso(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#elif defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable:4310) /* cast truncates constant value */
#endif
DEBUGASSERT(uznum <= (size_t) CU... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /devkitPro[P]curl/lib/warnless.c |
curlx_uztoul | unsigned long curlx_uztoul(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_LONG < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
#endif
return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG)... | movq %rdi, %rax
retq
| /devkitPro[P]curl/lib/warnless.c |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return (uns... | movq %rdi, %rax
retq
| /devkitPro[P]curl/lib/warnless.c |
npf_vpprintf | int npf_vpprintf(npf_putc pc, void *pc_ctx, char const *format, va_list args) {
npf_format_spec_t fs;
char const *cur = format;
npf_cnt_putc_ctx_t pc_cnt;
pc_cnt.pc = pc;
pc_cnt.ctx = pc_ctx;
pc_cnt.n = 0;
while (*cur) {
int const fs_len = (*cur != '%') ? 0 : npf_parse_format_spec(cur, &fs);
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movl $0x20, %edi
movl %eax, 0x24(%rsp)
movl %eax, 0x14(%rsp)
movl %eax, 0x10(%rsp)
movq %rcx, 0x48(%rsp)
movzbl (%rbp), %eax
cmpl $0x25, %eax
je 0x4dfb
mov... | /charlesnicholson[P]nanoprintf/tests/../nanoprintf.h |
npf_vsnprintf | int npf_vsnprintf(char *buffer, size_t bufsz, char const *format, va_list vlist) {
npf_bufputc_ctx_t bufputc_ctx;
bufputc_ctx.dst = buffer;
bufputc_ctx.len = bufsz;
bufputc_ctx.cur = 0;
npf_putc const pc = buffer ? npf_bufputc : npf_bufputc_nop;
int const n = npf_vpprintf(pc, &bufputc_ctx, format, vlist);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
movq $0x0, 0x10(%r15)
testq %rdi, %rdi
sete %r13b
leaq 0x42(%rip), %rax # 0x5654
leaq 0x55(%rip), %r12 # 0x566e
cmovneq %rax, %r12
movq ... | /charlesnicholson[P]nanoprintf/tests/../nanoprintf.h |
(anonymous namespace)::require_conform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, ...) | void require_conform(const std::string& expected, char const *fmt, ...) {
char buf[256];
std::string sys_printf_result; {
va_list args;
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args);
va_end(args);
buf[sizeof(buf)-1] = '\0';
sys_printf_result = buf;
}
std::string npf_resul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %r15
movq %rdi, 0x48(%rsp)
leaq 0x90(%rsp), %rbp
movq %rdx, 0x10(%rbp)
movq %rcx, 0x18(%rbp)
movq %r8, 0x20(%rbp)
movq %r9, 0x28(%rbp)
testb %al, %al
je 0x6c29
movaps %xmm0, 0xc0(%rsp)
movaps %xmm1, 0... | /charlesnicholson[P]nanoprintf/tests/conformance.cc |
doctest::String doctest::detail::stringifyBinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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&, char const*, std::__... | String stringifyBinaryExpr(const DOCTEST_REF_WRAP(L) lhs, const char* op,
const DOCTEST_REF_WRAP(R) rhs) {
return (DOCTEST_STRINGIFY(lhs)) + op + (DOCTEST_STRINGIFY(rhs));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x704b
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x73a6
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x78ca
movq %rsp, %rdi
movq %r14, %rsi
callq 0x704b
leaq 0x48(%r... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::skipPathFromFilename(char const*) | const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
if(getContextOptions()->no_path_in_filenames) {
auto back = std::strrchr(file, '\\');
auto forward = std::strrchr(file, '/');
if(back || forward) {
if(back > forward)
for... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1d17d(%rip), %rax # 0x25398
cmpb $0x1, 0x7c(%rax)
jne 0x8253
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x43d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x43d0
cmpq %rax, %r14
movq %rax, %rcx
cmovaq %r14, %rcx
orq %rax, %r14
je 0x8253
incq %rcx
movq %... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::operator<(doctest::Approx const&, double) | bool operator<(const Approx& lhs, double rhs) { return lhs.m_value < rhs && lhs != rhs; } | movsd 0x10(%rdi), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x88d6
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x11c9b(%rip), %xmm3 # 0x1a550
andpd %xmm3, %xmm2
andpd %xmm3, %xmm0
andpd %xmm3, %xmm1
maxsd %xmm0, %xmm1
addsd 0x8(%rdi), %xmm1
mulsd (%rdi), %xmm1
ucomisd %xmm2, %xmm1
setbe %al
retq
xorl %eax, %eax
retq
| /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::TestCase::TestCase(void (*)(), char const*, unsigned int, doctest::detail::TestSuite const&, doctest::String const&, int) | TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
const String& type, int template_id) {
m_file = file;
m_line = line;
m_name = nullptr; // will be later overridden in operator*
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x30(%rsp)
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, %cl
movb %cl, 0x17(%rdi)
leaq 0x58(%rdi), %rdx
movq %rdx, 0x8(%rsp)
movb %al, 0x58(%rd... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::TestCase::TestCase(doctest::detail::TestCase const&) | TestCase::TestCase(const TestCase& other)
: TestCaseData() {
*this = other;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x17(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movb $0x17, %al
movb %al, 0x17(%rdi)
leaq 0x58(%rdi), %r15
xorl %ecx, %ecx
movb %cl, 0x... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::TestCase::operator=(doctest::detail::TestCase const&) | TestCase& TestCase::operator=(const TestCase& other) {
TestCaseData::operator=(other);
m_test = other.m_test;
m_type = other.m_type;
m_template_id = other.m_template_id;
m_full_name = other.m_full_name;
if(m_template_id != -1)
m_name =... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7454
movups 0x18(%r14), %xmm0
movups 0x28(%r14), %xmm1
movups 0x38(%r14), %xmm2
movups %xmm0, 0x18(%rbx)
movups %xmm1, 0x28(%rbx)
movups %xmm2, 0x38(%rbx)
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
leaq... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::TestCase::operator<(doctest::detail::TestCase const&) const | bool TestCase::operator<(const TestCase& other) const {
// this will be used only to differentiate between test cases - not relevant for sorting
if(m_line != other.m_line)
return m_line < other.m_line;
const int name_cmp = strcmp(m_name, other.m_name);
if(name_cmp != 0)
... | movl 0x18(%rsi), %eax
cmpl %eax, 0x18(%rdi)
jne 0x982a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x44a0
testl %eax, %eax
je 0x982e
shrl $0x1f, %eax
jmp 0x9864
setb %al
retq
cmpb $0x0, 0x17(%rbx)
movq %rbx, %rsi
jns 0x983a
movq (%rbx), %rsi
cmpb $0... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::isDebuggerActive() | ~ErrnoGuard() { errno = m_oldErrno; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
callq 0x4050
movq %rax, %rbx
movl (%rax), %ebp
leaq 0x11091(%rip), %rsi # 0x1a959
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x4620
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::registerExceptionTranslatorImpl(doctest::detail::IExceptionTranslator const*) | void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
getExceptionTranslators().end())
getExceptionTranslators().push_back(et);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rdi, (%rbx)
callq 0x9a44
movq 0x1bf89(%rip), %r14 # 0x25968
callq 0x9a44
movq 0x1bf85(%rip), %rsi # 0x25970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x17a32
movq %rax, %rbx
callq 0x9a44
cmpq 0x1bf6b(%rip), %rbx # 0x25970
jne 0x9a3c
callq 0x9a44
movq 0x1bf5... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::ContextScopeBase::ContextScopeBase(doctest::detail::ContextScopeBase&&) | ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) noexcept {
if (other.need_to_destroy) {
other.destroy();
}
other.need_to_destroy = false;
g_infoContexts.push_back(this);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ae17(%rip), %rax # 0x248c0
movq %rax, (%rdi)
movb $0x1, 0x8(%rdi)
cmpb $0x1, 0x8(%rsi)
jne 0x9abe
movq %r14, %rdi
callq 0x9af4
movb $0x0, 0x8(%r14)
callq 0x15c12
movq %fs:0x0, %rax
leaq -0x30(%rax), %rdi
movq %rsp, %rsi
movq %rbx, (%rsi)
callq... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::ContextScopeBase::destroy() | void ContextScopeBase::destroy() {
#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
if(std::uncaught_exceptions() > 0) {
#else
if(std::uncaught_exception()) {
#endif
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, %rbx
callq 0x4410
testl %eax, %eax
jle 0x9bc6
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x4490
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movl $0x10f8, %ebx # imm = 0x10F8
addq 0x1b863(%rip), %rbx... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::IExceptionTranslator::~IExceptionTranslator() | bool MessageBuilder::log() {
if (!logged) {
m_string = tlssPop();
logged = true;
}
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context s... | retq
nop
| /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::IExceptionTranslator::~IExceptionTranslator() | bool MessageBuilder::log() {
if (!logged) {
m_string = tlssPop();
logged = true;
}
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context s... | ud2
| /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::Context::Context(int, char const* const*) | Context::Context(int argc, const char* const* argv)
: p(new detail::ContextState) {
parseArgs(argc, argv, true);
if(argc)
p->binary_name = argv[0];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1190, %edi # imm = 0x1190
callq 0x4370
movq %rax, %r15
xorl %eax, %eax
movq %rax, (%r15)
movb %al, 0x8(%r15)
movb $0x17, %cl
movb %cl, 0x1f(%r15)
movq %rax, 0x20(%r15)
movb %al, 0x28... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::parseOption(int, char const* const*, char const*, doctest::String*, doctest::String const&) | bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
const String& defaultVal = String()) {
if(value)
*value = defaultVal;
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
// offset (normally 3 for "dt-") to skip prefix
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
testq %rcx, %rcx
je 0xc0d7
movq %rbx, %rdi
movq %r8, %rsi
callq 0x7454
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xd8d9
testb %al, %al
je 0xc0f9
movb $0x1, %al
addq $0x... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::Context::setOption(char const*, char const*) | void Context::setOption(const char* option, const char* value) {
auto argv = String("-") + option + "=" + value;
auto lvalue = argv.c_str();
parseArgs(1, &lvalue);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0x72de
movb $0x2d, (%rax)
movq %r15, %rdi
callq 0x4150
movq %rax, %r12
leaq 0x60(%rsp), %rdi
movl %r12d, %esi
callq 0x72de
movl %r12d, %edx
movq %rax, %rdi
movq %r15, ... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::FatalConditionHandler::reset() | static void reset() {
if(isSet) {
// Set signals back to previous values -- hopefully nobody overwrote them in the meantime
for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
... | cmpb $0x1, 0x18507(%rip) # 0x25a00
jne 0xd54a
pushq %r15
pushq %r14
pushq %rbx
leaq 0x18519(%rip), %rbx # 0x25a20
xorl %r14d, %r14d
leaq 0x174cf(%rip), %r15 # 0x249e0
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4430
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0xd511
leaq 0x184d... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::registerReporterImpl(char const*, int, doctest::IReporter* (*)(doctest::ContextOptions const&), bool) | void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
if(isReporter)
getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
else
getListeners().insert(reporterMap::value_type(reporterMap::key_typ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0xd66d
callq 0xd40b
leaq 0x10(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r14, %rdi
callq 0x4150
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x72de
movl %r12d, %edx
movq %ra... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::parseOptionImpl(int, char const* const*, char const*, doctest::String*) | bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
// going from the end to the beginning and stopping on the first occurrence from the end
for(int i = argc; i > 0; --i) {
auto index = i - 1;
auto temp = std::strstr(argv[index], patt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
testl %edi, %edi
setg %bl
jle 0xd98c
movq %rcx, %r14
movq %rdx, %r15
movl %edi, %r12d
movq %rcx, (%rsp)
movq 0x20(%rsp), %rax
movq -0x8(%rax,%r12,8), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4090
testq %rax, %ra... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::FatalConditionHandler::handleSignal(int) | static void handleSignal(int sig) {
const char* name = "<unknown signal>";
for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
SignalDefs& def = signalDefs[i];
if(sig == def.id) {
name = def.name;
break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xd5ee(%rip), %r14 # 0x1b025
movl $0x8, %ecx
leaq 0x16f9d(%rip), %rax # 0x249e0
movl -0x8(%rcx,%rax), %edx
cmpl %edi, %edx
jne 0xda4f
movq (%rcx,%rax), %r14
cmpl %edi, %edx
je 0xda60
leaq 0x10(%rcx), %rdx
cmpq $0x58, %rcx
m... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::report_query(doctest::QueryData const&) | void report_query(const QueryData& in) override {
test_run_start();
if(opt.list_reporters) {
for(auto& curr : getListeners())
xml.scopedElement("Listener")
.writeAttribute("priority", curr.first.first)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0x40(%rsp)
movq 0x78(%rbx), %rax
cmpb $0x1, 0x86(%rax)
jne 0xdf70
callq 0xd421
movq 0x17ccd(%rip), %rbx # 0x259e0
leaq 0x17cb6(%rip), %rax # 0x259d0
cm... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_run_start() | void test_run_start() override {
xml.writeDeclaration();
// remove .exe extension - mainly to have the same output on UNIX and Windows
std::string binary_name = skipPathFromFilename(opt.binary_name.c_str());
#ifdef DOCTEST_PLATFORM_WINDOWS
if(binary_name.rfind(".ex... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0xcceb(%rip), %rsi # 0x1b3b6
movl $0x27, %edx
callq 0x43e0
movq 0x78(%rbx), %rdi
cmpb $0x0, 0x1f(%rdi)
jns 0xe6e5
movq 0x8(%rdi), %rdi
jmp 0xe6e9
addq $0x8, %rdi
c... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_run_end(doctest::TestRunStats const&) | void test_run_end(const TestRunStats& p) override {
if(tc) // the TestSuite tag - only if there has been at least 1 test case
xml.endElement();
xml.scopedElement("OverallResultsAsserts")
.writeAttribute("successes", p.numAsserts - p.numAssertsFailed)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x80(%rdi)
je 0xed99
leaq 0x8(%r15), %rdi
callq 0x10170
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc634(%rip), %rsi # 0x1b3de
leaq 0xc642(%rip), %rdx # 0x1b3f3
leaq 0x8(%rsp),... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_end(doctest::CurrentTestCaseStats const&) | void test_case_end(const CurrentTestCaseStats& st) override {
xml.startElement("OverallResultsAsserts")
.writeAttribute("successes",
st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
.writeAttribute("failures", st.numAs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xc313(%rip), %rsi # 0x1b3de
leaq 0xc321(%rip), %rdx # 0x1b3f3
movq %rsp, %rdi
callq 0x707c
leaq 0x8(%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::test_case_exception(doctest::TestCaseException const&) | void test_case_exception(const TestCaseException& e) override {
DOCTEST_LOCK_MUTEX(mutex)
xml.scopedElement("Exception")
.writeAttribute("crash", e.is_crash)
.writeText(e.error_string.c_str());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x44f0
testl %eax, %eax
jne 0xf461
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc10c(%rip), %rsi # 0x1b47a
leaq 0xc10e(%rip), %rdx # 0x1b483
leaq 0x38(%rsp), %rdi
cal... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::log_assert(doctest::AssertData const&) | void log_assert(const AssertData& rb) override {
if(!rb.m_failed && !opt.success)
return;
DOCTEST_LOCK_MUTEX(mutex)
xml.startElement("Expression")
.writeAttribute("success", !rb.m_failed)
.writeAttribute("type", assert... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r12
movq %rdi, %r13
cmpb $0x0, 0x28(%rsi)
jne 0xf711
movq 0x78(%r13), %rax
cmpb $0x1, 0x6c(%rax)
jne 0xfc16
leaq 0x50(%r13), %rdi
movq %rdi, 0x60(%rsp)
callq 0x44f0
testl %eax, %eax
jne 0xfc28
leaq 0x10(%rsp), %rax
movq %rax,... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::log_message(doctest::MessageData const&) | void log_message(const MessageData& mb) override {
DOCTEST_LOCK_MUTEX(mutex)
xml.startElement("Message")
.writeAttribute("type", failureString(mb.m_severity))
.writeAttribute("filename", skipPathFromFilename(mb.m_file))
.writeAtt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r12
movq %rdi, %r14
addq $0x50, %rdi
movq %rdi, 0x48(%rsp)
callq 0x44f0
testl %eax, %eax
jne 0xffb4
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xb727(%rip), %rsi # 0x1b4aa
leaq 0xb727(%rip), %rdx # 0x1b4b1
le... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlReporter::log_contexts() | void log_contexts() {
int num_contexts = get_num_active_contexts();
if(num_contexts) {
auto contexts = get_active_contexts();
std::stringstream ss;
for(int i = 0; i < num_contexts; ++i) {
contexts[i]->stringif... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
callq 0x15c12
movq %fs:-0x28, %r13
subq %fs:-0x30, %r13
shrq $0x3, %r13
testl %r13d, %r13d
je 0x1140c
callq 0xd56e
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4260
testl %r13d, %r13d
jle ... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::XmlWriter::~XmlWriter() | XmlWriter::~XmlWriter() {
while( !m_tags.empty() )
endElement();
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x114b0
movq %rbx, %rdi
callq 0x10170
jmp 0x1149c
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x114c8
movq (%rax), %rsi
incq %rsi
callq 0x4390
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x1826e
movq %rax, %rdi
callq 0x163f0
| /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::test_case_start(doctest::TestCaseData const&) | void test_case_start(const TestCaseData& in) override {
testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
timer.start();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x17(%rsi)
movq %rsi, %rdi
jns 0x11f81
movq (%r14), %rdi
callq 0x820d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x16c2e
movq 0x20(%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x16c2e
leaq 0x98(%rbx), ... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::log_assert(doctest::AssertData const&) | void log_assert(const AssertData& rb) override {
if(!rb.m_failed) // report only failures & ignore the `success` option
return;
DOCTEST_LOCK_MUTEX(mutex)
std::ostringstream os;
os << skipPathFromFilename(rb.m_file) << (opt.gnu_file_line ? ":" : "(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
cmpb $0x1, 0x28(%rsi)
jne 0x12908
movq %rsi, %r15
movq %rdi, %r14
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x44f0
testl %eax, %eax
jne 0x1291a
leaq 0x80(%rsp), %rdi
movq %rbx, 0x10(%rsp)
callq 0x4490
movq 0x1... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::log_assert(doctest::AssertData const&) | void log_assert(const AssertData& rb) override {
if((!rb.m_failed && !opt.success) || tc->m_no_output)
return;
DOCTEST_LOCK_MUTEX(mutex)
logTestStart();
file_line_to_stream(rb.m_file, rb.m_line, " ");
successOrFailColoredStringToStr... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0x28(%rsi)
jne 0x151f5
movq 0x60(%rbx), %rax
cmpb $0x1, 0x6c(%rax)
jne 0x151ff
movq 0x68(%rbx), %rax
cmpb $0x0, 0x3a(%rax)
je 0x15205
popq %rbx
popq %r14
popq %r15
retq
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x44f0
testl %eax, %eax
jne 0x1... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::file_line_to_stream(char const*, int, char const*) | virtual void file_line_to_stream(const char* file, int line,
const char* tail = "") {
s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
<< (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %r15, %rdi
movl $0x17, %esi
callq 0x7c99
movq %r12, %rdi
callq 0x820d
testq %rax, %rax
je 0x1543a
movq %rax, %r12
movq %rax, %rdi
callq 0x4150
movq %r15, %rdi
movq %r12, %rsi
... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
float Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<float, float>, Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<float>, Eigen::Map<Eigen::Matrix<float, 1, -1, 1, 1, -1>, 0, Eigen::Stride<0, 0>> const>>, 3, 0>::run<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<f... | explicit variable_if_dynamic(T value = 0) EIGEN_NO_THROW : m_value(value) {} | movq 0x10(%rdx), %rax
leaq 0x7(%rax), %rsi
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %rsi
movq %rax, %rdx
cmovsq %r8, %rdx
movq 0x8(%rdi), %rcx
cmpq $0x7, %r8
jae 0x49e2f
movss (%rcx), %xmm0
mulss %xmm0, %xmm0
cmpq $0x2, %rax
jl 0x49eba
movl $0x1, %edx
movss (%rcx,%rdx,4), %xmm1
mulss %xmm1, %xmm1
addss %xmm1,... | /ebu[P]libear/submodules/eigen/Eigen/src/Core/util/XprHelper.h |
ear::get_polar_extent_core() | std::unique_ptr<PolarExtentCore> get_polar_extent_core() {
auto dispatcher = xsimd::dispatch<arch_list>(GetPolarExtentCore{});
return dispatcher();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc6cf5(%rip), %rax # 0x110bc0
movb (%rax), %al
testb %al, %al
je 0x49f11
leaq 0xc6ce0(%rip), %rax # 0x110bb8
movq (%rax), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movl %ecx, 0x8(%rsp)
shrq $0x26, %rax
cmpl $0x1db, %eax # imm = 0x1DB
jae 0x49f00
leaq 0x8(... | /ebu[P]libear/src/object_based/polar_extent_simd.cpp |
xsimd::detail::supported_arch::supported_arch() | inline supported_arch() noexcept
{
memset(this, 0, sizeof(supported_arch));
#if defined(__aarch64__) || defined(_M_ARM64)
neon = 1;
neon64 = 1;
best = neon64::version();
#elif defined(__ARM_NEON) || defined(_M_ARM)
#if defined(__linux__) && (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ebp, %ebp
xorl %ecx, %ecx
movl $0x1, %eax
cpuid
movl %edx, %eax
shrl $0x1a, %eax
btl $0x1a, %edx
movl $0x27d8, %esi # imm = 0x27D8
cmovael %ebp, %esi
leal (%rcx,%rcx), %edx
andl $0x2, %edx
movl %ecx, %r8d
andl $0x1, %r8d
negl %r8d
andl $0... | /ebu[P]libear/submodules/xsimd/include/xsimd/memory/../config/./xsimd_cpuid.hpp |
ear::GainCalculatorObjectsImpl::GainCalculatorObjectsImpl(ear::Layout const&) | GainCalculatorObjectsImpl::GainCalculatorObjectsImpl(const Layout& layout)
: _layout(layout),
_pointSourcePanner(configurePolarPanner(_layout.withoutLfe())),
_polarExtentPanner(_pointSourcePanner),
_isLfe(copy_vector<decltype(_isLfe)>(layout.isLfe())),
_pvTmp(_pointSourcePanner->nu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x36f84
movb $0x0, 0x38(%rbx)
cmpb $0x1, ... | /ebu[P]libear/src/object_based/gain_calculator_objects.cpp |
ear::GainCalculatorObjectsImpl::calculate(ear::ObjectsTypeMetadata const&, ear::OutputGains&, ear::OutputGains&, std::function<void (ear::Warning const&)> const&) | void GainCalculatorObjectsImpl::calculate(const ObjectsTypeMetadata& metadata,
OutputGains& direct,
OutputGains& diffuse,
const WarningCB&) {
if (metadata.cartesian) throw not_implemen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
cmpb $0x1, 0x38(%rsi)
je 0x4a7f2
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x4ad84
leaq 0x68(%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4ae52
cmpb $0x1, 0x50(%r14)
je 0x4a8... | /ebu[P]libear/src/object_based/gain_calculator_objects.cpp |
ear::throw_if_not_implemented::operator()(ear::CartesianPosition const&) const | void operator()(const CartesianPosition&) const {
throw not_implemented("cartesian");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x64b52(%rip), %rsi # 0xaf937
leaq 0x64b54(%rip), %rdx # 0xaf940
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
c... | /ebu[P]libear/src/object_based/gain_calculator_objects.cpp |
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.