name string | code string | asm string | file string |
|---|---|---|---|
ncnn::Input::Input() | Input::Input()
{
one_blob_only = true;
support_inplace = true;
support_vulkan = true;
support_packing = true;
support_bf16_storage = true;
support_image_storage = true;
} | pushq %rbx
movq %rdi, %rbx
callq 0x5c026
leaq 0x24b578(%rip), %rax # 0x44f978
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0xf(%rbx)
movb %al, 0xc(%rbx)
movl $0x1010101, 0x8(%rbx) # imm = 0x1010101
popq %rbx
retq
| /ysh329[P]ncnn/src/layer/input.cpp |
ncnn::LRN::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
squa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %rbp
movl 0x2c(%rsi), %esi
movl 0x30(%rbp), %ecx
movl 0x38(%rbp), %r13d
movq 0x10(%rbp), %r15
leaq 0x90(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm... | /ysh329[P]ncnn/src/layer/lrn.cpp |
virtual thunk to ncnn::Pooling_x86::create_pipeline(ncnn::Option const&) | int Pooling_x86::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
}
return 0;
} | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x209a4c
xorl %eax, %eax
popq %rcx
retq
nop
| /ysh329[P]ncnn/src/layer/x86/pooling_x86.cpp |
ncnn::Pooling_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int w = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
cmpl $0x0, 0x100(%r15,%rax)
je 0x209ae3
movq %r13, %rsi
movq %rbp, %rcx
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
pop... | /ysh329[P]ncnn/src/layer/x86/pooling_x86.cpp |
ncnn::PReLU_x86_avx512::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int PReLU_x86_avx512::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int dims = bottom_top_blob.dims;
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
if (dims == 1)
{
const int size = ... | pushq %r14
pushq %rbx
movl 0x18(%rsi), %ecx
movl 0x28(%rsi), %r8d
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %edx
cmpl $0x3, %r8d
je 0x210e66
cmpl $0x2, %r8d
je 0x210cf9
cmpl $0x1, %r8d
jne 0x2111e1
imull %eax, %ecx
movq (%rdi), %r9
movq -0x18(%r9), %rax
cmpl $0x2, 0xd0(%rdi,%rax)
movq (%rsi), %r8
movq 0xd8(%rdi,%rax), %r1... | /ysh329[P]ncnn/build_O2/src/layer/x86/prelu_x86_avx512.cpp |
ncnn::BinaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace BinaryOp_x86_fma_functor;
if (op_type == Operation_ADD)
return binary_op_scalar_inplace<binary_op_add>(bottom_top_blob, b, opt);
if (op_type == Operation_SUB)
return binary_op_scalar_inpl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xe0, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %eax
cmpq $0x8, %rax
ja 0x2a9b9c
movq %rsi, %r14
leaq 0x122d22(%rip), %rcx # 0x3cc188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%r... | /ysh329[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
virtual thunk to ncnn::BinaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace BinaryOp_x86_fma_functor;
if (op_type == Operation_ADD)
return binary_op_scalar_inplace<binary_op_add>(bottom_top_blob, b, opt);
if (op_type == Operation_SUB)
return binary_op_scalar_inpl... | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x2a942c
xorl %eax, %eax
popq %rcx
retq
| /ysh329[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
virtual thunk to ncnn::DeformableConv2D_x86_avx::create_pipeline(ncnn::Option const&) | int DeformableConv2D_x86_avx::create_pipeline(const Option& opt)
{
const int in_c = weight_data_size / (num_output * kernel_h * kernel_w);
{
Mat weight_3d = weight_data.reshape(kernel_w * kernel_h, in_c, num_output);
weight_data_t.create(in_c, kernel_w * kernel_h, num_output);
if (weight... | movq (%rdi), %rax
addq -0x30(%rax), %rdi
jmp 0x3bfcee
| /ysh329[P]ncnn/build_O2/src/layer/x86/deformableconv2d_x86_avx.cpp |
xLearn::Solver::checker(xLearn::HyperParam&) | void Solver::checker(HyperParam& hyper_param) {
if (!checker_.check_param(hyper_param)) {
Color::print_error("Arguments error");
exit(0);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
addq $0x210, %rdi # imm = 0x210
callq 0x34f4c
testb %al, %al
je 0x2eb99
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rbx
leaq 0x27a29(%rip), %rsi # 0x565d3
leaq 0x27a31(%rip), %rdx # 0x565e2
movq %rbx, %rdi
movq %r14, -0x10(%r... | /aksnzhy[P]xlearn/src/solver/solver.cc |
xLearn::Solver::StartWork() | void Solver::StartWork() {
if (hyper_param_.is_train) {
LOG(INFO) << "Start training work.";
start_train_work();
} else {
LOG(INFO) << "Start inference work.";
start_prediction_work();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, (%rdi)
movq %rdi, %rbx
jne 0x2ecae
leaq 0x40(%rsp), %r14
movl $0x0, 0xc(%rsp)
movq %r14, -0x10(%r14)
leaq 0x278f5(%rip), %rsi # 0x56512
leaq 0x27945(%rip), %rdx # 0x56569
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)... | /aksnzhy[P]xlearn/src/solver/solver.cc |
xLearn::Solver::start_train_work() | void Solver::start_train_work() {
int epoch = hyper_param_.num_epoch;
bool early_stop = hyper_param_.early_stop &&
!hyper_param_.cross_validation;
int stop_window = hyper_param_.stop_window;
bool quiet = hyper_param_.quiet &&
!hyper_param_.cross_validation;
bool save_model = t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movb 0x1ee(%rdi), %bl
movb 0x1f4(%rdi), %r14b
movl 0xb0(%rdi), %ebp
movl 0x1f8(%rdi), %r12d
movq %rdi, %r15
xorb $0x1, %bl
andb %bl, %r14b
andb 0x2(%rdi), %bl
addq $0x140, %rdi # imm = 0x140
leaq 0x2a474(%rip), %rsi # 0x59... | /aksnzhy[P]xlearn/src/solver/solver.cc |
xLearn::Solver::start_prediction_work() | void Solver::start_prediction_work() {
Color::print_action("Start to predict ...");
Predictor pdc;
pdc.Initialize(reader_[0],
model_,
loss_,
hyper_param_.output_file,
hyper_param_.sign,
hyper_param_.sigmoid,
hype... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0x38(%rsp), %r15
movq %rdi, %rbx
movq %r15, -0x10(%r15)
leaq 0x274be(%rip), %rsi # 0x56b0d
leaq 0x274cb(%rip), %rdx # 0x56b21
leaq 0x28(%rsp), %rdi
callq 0x2a9a2
leaq 0x10(%rsp), %rsi
movl $0x1, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x20, (%rsi)
movq 0x3d92e... | /aksnzhy[P]xlearn/src/solver/solver.cc |
Color::print_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void print_error(const std::string &out) {
Color::Modifier red(Color::FG_RED);
Color::Modifier bold(Color::BOLD);
Color::Modifier reset(Color::RESET);
std::cout << red << bold << "[ ERROR ] "
<< out << reset << std::endl;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x3d554(%rip), %rdi # 0x6cfb0
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rbx
movl $0x1f, (%rsi)
movl $0x1, (%r15)
movl $0x0, (%rbx)
callq 0x2aa81
movq %rax, %rdi
movq %r15, %rsi
callq 0x2aa81
leaq 0x270b4(%rip), %rsi # 0x56b4... | /aksnzhy[P]xlearn/src/base/format_print.h |
xLearn::Trainer::SaveModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SaveModel(const std::string& filename) {
CHECK_NE(filename.empty(), true);
CHECK_NE(filename.compare("none"), 0);
model_->Serialize(filename);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x8(%rsi)
movq %rsi, %rbx
je 0x30a6a
leaq 0x28819(%rip), %rsi # 0x59259
movq %rdi, %r14
movq %rbx, %rdi
callq 0x28120
testl %eax, %eax
je 0x30bcc
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp... | /aksnzhy[P]xlearn/src/solver/trainer.h |
xLearn::Model::~Model() | ~Model() { free_model(); } | pushq %rbx
movq %rdi, %rbx
callq 0x52144
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x31699
callq 0x28440
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x316ab
popq %rbx
jmp 0x28440
popq %rbx
retq
movq %rax, %rdi
callq 0x2faf3
nop
| /aksnzhy[P]xlearn/src/data/model_parameters.h |
xLearn::Checker::Initialize(bool, int, char**) | void Checker::Initialize(bool is_train, int argc, char* argv[]) {
is_train_ = is_train;
if (is_train_) { // for training
menu_.push_back(std::string("-s"));
menu_.push_back(std::string("-x"));
menu_.push_back(std::string("-v"));
menu_.push_back(std::string("-p"));
menu_.push_back(std::string("-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x18(%rsp), %r15
movq %rcx, 0x30(%rsp)
movl %edx, %ebp
movq %rdi, %r14
movb %sil, 0x30(%rdi)
testl %esi, %esi
je 0x32f9a
movq %r15, -0x10(%r15)
leaq 0x265fd(%rip), %rsi # 0x58fa7
leaq 0x265f8(%rip), %rdx # 0x58fa9
leaq 0x8(%... | /aksnzhy[P]xlearn/src/solver/checker.cc |
xLearn::Checker::check_train_param(xLearn::HyperParam&) | bool Checker::check_train_param(HyperParam& hyper_param) {
bool bo = true;
/*********************************************************
* Check file path *
*********************************************************/
if (hyper_param.from_file) {
if (!FileExist(hyper_par... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpb $0x1, 0x1ec(%rsi)
movq %rsi, %rbx
jne 0x35122
movq 0xc8(%rbx), %rdi
callq 0x368b3
movl %eax, %ebp
testb %al, %al
jne 0x3504d
movq 0xc8(%rbx), %rdx
leaq 0x240b8(%rip), %rsi # 0x59052
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq ... | /aksnzhy[P]xlearn/src/solver/checker.cc |
xLearn::OndiskReader::Samples(xLearn::DMatrix*&) | index_t OndiskReader::Samples(DMatrix* &matrix) {
// Convert MB to Byte
uint64 read_byte = block_size_ * 1024 * 1024;
// Read a block of data from disk file
size_t ret = ReadDataFromDisk(file_ptr_, block_, read_byte);
if (ret == 0) {
matrix = nullptr;
return 0;
} else if (ret == read_byte) {
// ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xc8(%rdi), %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc0(%rdi), %rsi
movq 0xd8(%rdi), %rdi
shlq $0x14, %r12
movq %r12, %rdx
callq 0x3c660
testq %rax, %rax
je 0x3bd4d
movq %rax, %r15
cmpq %r12, %rax
jne 0x3bd20
movq 0xc0(%r14), %rax
movq 0xd8(%r14), %rdi
incq... | /aksnzhy[P]xlearn/src/reader/reader.cc |
xLearn::FromDMReader::Initialize(xLearn::DMatrix*&) | void FromDMReader::Initialize(xLearn::DMatrix* &dmatrix) {
this->data_ptr_ = dmatrix;
has_label_ = this->data_ptr_->has_label;
num_samples_ = this->data_ptr_->row_length;
data_samples_.ReAlloc(num_samples_, has_label_);
// for shuffle
order_.resize(num_samples_);
for (int i = 0; i < order_.size(); ++i) {... | pushq %rbx
movq (%rsi), %rax
movq %rdi, %rbx
movq %rax, 0xd8(%rdi)
movzbl 0x60(%rax), %edx
movb %dl, 0x98(%rdi)
movl 0x10(%rax), %esi
movl %esi, 0xe0(%rdi)
addq $0x28, %rdi
callq 0x3cf5e
movl 0xe0(%rbx), %esi
leaq 0xe8(%rbx), %rdi
callq 0x3cfe8
movq 0xe8(%rbx), %rax
movq 0xf0(%rbx), %rdx
subq %rax, %rdx
je 0x3be3a
vpmo... | /aksnzhy[P]xlearn/src/reader/reader.cc |
GetLine(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline void GetLine(FILE *file, std::string &str_line) {
CHECK_NOTNULL(file);
scoped_array<char> line(new char[kMaxLineSize]);
CHECK_NOTNULL(fgets(line.get(), kMaxLineSize, file));
int read_len = strlen(line.get());
if (line[read_len-1] != '\n') {
LOG(FATAL) << "Encountered a too-long line: \
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x3c1a7
movq %rdi, %r15
movl $0xa00000, %edi # imm = 0xA00000
movq %rsi, %rbx
callq 0x28040
movl $0xa00000, %esi # imm = 0xA00000
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r15, %rdx
callq 0x28700
testq %rax, %rax
je 0... | /aksnzhy[P]xlearn/src/base/file_util.h |
xLearn::Reader::CreateParser(char const*) | Parser* CreateParser(const char* format_name) {
return CREATE_PARSER(format_name);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movb 0x305f1(%rip), %al # 0x6d618
movq %rsi, %rbx
testb %al, %al
je 0x3d073
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
movq %r14, %rdi
callq 0x281a0
leaq 0x30596(%rip), %rdi # 0x6d5e0
movq %r14, %rsi
callq 0x3fd8c
leaq 0x18(%rsp), %rcx
movq %rax, %rbx
movq ... | /aksnzhy[P]xlearn/src/reader/reader.h |
xLearn::DMatrix::Serialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Serialize(const std::string& filename) {
CHECK_NE(filename.empty(), true);
CHECK_EQ(row_length, row.size());
CHECK_EQ(row_length, Y.size());
CHECK_EQ(row_length, norm.size());
#ifndef _MSC_VER
FILE* file = OpenFileOrDie(filename.c_str(), "w");
#else
FILE* file = OpenFileOrDie(filename.c_str... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
cmpq $0x0, 0x8(%rsi)
movq %rsi, %r15
je 0x3d1bb
movq 0x20(%rdi), %rcx
movl 0x10(%rdi), %eax
leaq 0x10(%rdi), %r14
movq %rdi, %rbx
subq 0x18(%rdi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x3d31d
movq 0x38(%rbx), %rcx
subq 0x30(%rbx), %rcx
sarq $0x... | /aksnzhy[P]xlearn/src/data/data_structure.h |
xLearn::OndiskReader::SetShuffle(bool) | void inline SetShuffle(bool shuffle) {
if (shuffle == true) {
LOG(ERR) << "Cannot set shuffle for OndiskReader.";
}
this->shuffle_ = false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x3da47
leaq 0x40(%rsp), %r14
movl $0x2, 0xc(%rsp)
movq %r14, -0x10(%r14)
leaq 0x191c3(%rip), %rsi # 0x56b83
leaq 0x19212(%rip), %rdx # 0x56bd9
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
l... | /aksnzhy[P]xlearn/src/reader/reader.h |
xLearn::FromDMReader::SetShuffle(bool) | virtual inline void SetShuffle(bool shuffle) {
this->shuffle_ = shuffle;
if (shuffle_ && !order_.empty()) {
srand(this->seed_);
random_shuffle(order_.begin(), order_.end());
}
} | movb %sil, 0x99(%rdi)
testl %esi, %esi
je 0x3dbbe
pushq %r15
pushq %r14
pushq %rbx
movq 0xe8(%rdi), %rax
movq %rdi, %rbx
cmpq 0xf0(%rdi), %rax
je 0x3dbb9
movl 0xd0(%rbx), %edi
callq 0x28450
movq 0xe8(%rbx), %r14
movq 0xf0(%rbx), %rbx
cmpq %rbx, %r14
je 0x3dbb9
leaq 0x4(%r14), %rax
cmpq %rbx, %rax
je 0x3dbb9
movl $0x4, ... | /aksnzhy[P]xlearn/src/reader/reader.h |
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)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /devkitPro[P]curl/lib/warnless.c |
ga_put_ | void FATR ga_put_(Integer *g_a, Integer *ilo, Integer *ihi,
Integer *jlo, Integer *jhi, void *buf, Integer *ld)
{
Integer lo[2], hi[2];
lo[0]=*ilo;
lo[1]=*jlo;
hi[0]=*ihi;
hi[1]=*jhi;
wnga_put(*g_a, lo, hi, buf, ld);
} | subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq ... | /GlobalArrays[P]ga/global/src/fapi.c |
nga_sadd_patch_ | void FATR nga_sadd_patch_(Real *alpha, Integer *g_a, Integer *alo, Integer *ahi, Real *beta, Integer *g_b, Integer *blo, Integer *bhi, Integer *g_c, Integer *clo, Integer *chi)
{
Integer atype, btype, ctype;
pnga_inquire_type(*g_a, &atype);
pnga_inquire_type(*g_b, &btype);
pnga_inquire_type(*g_c, &ctyp... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
l... | /GlobalArrays[P]ga/global/src/fapi.c |
nga_zadd_patch_ | void FATR nga_zadd_patch_(DoubleComplex *alpha, Integer *g_a, Integer *alo, Integer *ahi, DoubleComplex *beta, Integer *g_b, Integer *blo, Integer *bhi, Integer *g_c, Integer *clo, Integer *chi)
{
Integer atype, btype, ctype;
pnga_inquire_type(*g_a, &atype);
pnga_inquire_type(*g_b, &btype);
pnga_inquir... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
l... | /GlobalArrays[P]ga/global/src/fapi.c |
pnga_elem_divide | void pnga_elem_divide(Integer g_a, Integer g_b, Integer g_c){
Integer atype, andim;
Integer btype, bndim;
Integer ctype, cndim;
Integer alo[MAXDIM],ahi[MAXDIM];
Integer blo[MAXDIM],bhi[MAXDIM];
Integer clo[MAXDIM],chi[MAXDIM];
pnga_inquire(g_a, &atype, &andim, ahi);
pnga_inquire(g_b, &bt... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rdi
leaq 0x120(%rsp), %rcx
leaq 0x1c8(%rsp), %rsi
leaq 0x1c0(%rsp), %rdx
callq 0xcea30
movq 0x1d8(%rsp), %rdi
leaq 0xa0(%rsp), %rcx
leaq 0x1b8(%rsp), %rsi
leaq 0x1b0(%rsp), %rdx
callq 0xcea... | /GlobalArrays[P]ga/global/src/elem_alg.c |
pnga_step_max_patch | void pnga_step_max_patch(g_a, alo, ahi, g_b, blo, bhi, result)
Integer g_a, *alo, *ahi; /* patch of g_a */
Integer g_b, *blo, *bhi; /* patch of g_b */
void *result;
#if 0
Integer op; /* operations */
#endif
{
double dresult;
long lresult;
Integer atype;
Integer andim, adims[MAX... | subq $0x1a8, %rsp # imm = 0x1A8
movq 0x1b0(%rsp), %rax
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq %rdx, 0x190(%rsp)
movq %rcx, 0x188(%rsp)
movq %r8, 0x180(%rsp)
movq %r9, 0x178(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x178a21(%rip), %rax # 0x18d300
movl (%rax), %eax
movl %eax, 0x68(%rsp)
leaq 0x178a18(%r... | /GlobalArrays[P]ga/global/src/elem_alg.c |
ngai_elem3_patch_ | static void ngai_elem3_patch_(Integer g_a, Integer *alo, Integer *ahi, int op)
/*do some preprocess jobs for stepMax and stepMax2*/
{
Integer i;
Integer atype;
Integer andim, adims[MAXDIM];
Integer loA[MAXDIM], hiA[MAXDIM], ldA[MAXDIM];
char *A_ptr;
Integer me= pnga_nodeid();
Integer num_blocks;
int l... | subq $0x4c8, %rsp # imm = 0x4C8
movq %rdi, 0x4c0(%rsp)
movq %rsi, 0x4b8(%rsp)
movq %rdx, 0x4b0(%rsp)
movl %ecx, 0x4ac(%rsp)
movb $0x0, %al
callq 0xd4900
movq %rax, 0x380(%rsp)
leaq 0x1782e4(%rip), %rax # 0x18d300
movl (%rax), %eax
movl %eax, 0x374(%rsp)
leaq 0x1782d8(%rip), %rax # 0x18d304
movl (%rax),... | /GlobalArrays[P]ga/global/src/elem_alg.c |
ma_table_verify | public Boolean ma_table_verify(handle, caller)
Integer handle; /* to verify */
char *caller; /* name of calling routine */
{
Boolean badhandle; /* is handle invalid? */
badhandle = MA_FALSE;
/* if handle is invalid, construct an error message */
if ((handle < 0) ||
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0xad476
movq 0x18(%rsp), %rax
cmpq 0xe54ed(%rip), %rax # 0x192948
jge 0xad476
movq 0xe54ec(%rip), %rax # 0x192950
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0xad49b
movq... | /GlobalArrays[P]ga/ma/table.c |
ga_f2c_get_cmd_args | void ga_f2c_get_cmd_args(int *argc, char ***argv)
{
Integer i=0;
int iargc=F2C_IARGC();
char **iargv=NULL;
if (iargc > F2C_GETARG_ARGV_MAX) {
printf("ga_f2c_get_cmd_args: too many cmd line args");
armci_msg_abort(1);
}
iargv = (char**)malloc(sizeof(char*)*F2C_GETARG_ARGV_MAX);
... | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq $0x0, 0x210(%rsp)
movb $0x0, %al
callq 0xade50
movl %eax, 0x20c(%rsp)
movq $0x0, 0x200(%rsp)
cmpl $0xff, 0x20c(%rsp)
jle 0xadd42
leaq 0xc5ec6(%rip), %rdi # 0x173bf7
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0xb2080... | /GlobalArrays[P]ga/gaf2c/gaf2c.c |
PARMCI_Memget | void PARMCI_Memget(size_t bytes, armci_meminfo_t *meminfo, int memflg)
{
void *myptr=NULL;
void *armci_ptr=NULL; /* legal ARCMI ptr used in ARMCI data xfer ops*/
size_t size = bytes;
int rank;
comex_group_rank(COMEX_GROUP_WORLD, &rank);
if(size<=0) comex_error("PARMCI_Memget: size must be > 0"... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
leaq 0x4(%rsp), %rsi
callq 0xb7e90
cmpq $0x0, 0x8(%rsp)
ja 0xaf055
movq 0x8(%rsp), %rax
movl %eax, %esi
leaq 0xc4e16(%rip), %rdi #... | /GlobalArrays[P]ga/comex/src-armci/armci.c |
comex_get_igroup_from_group | comex_igroup_t* comex_get_igroup_from_group(comex_group_t id)
{
comex_igroup_t *current_group_list_item = group_list;
assert(group_list != NULL);
while (current_group_list_item != NULL) {
if (current_group_list_item->id == id) {
return current_group_list_item;
}
current_... | subq $0x18, %rsp
movl %edi, 0xc(%rsp)
leaq 0xdac01(%rip), %rax # 0x192a00
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0xdabf3(%rip), %rax # 0x192a00
cmpq $0x0, (%rax)
je 0xb7e15
jmp 0xb7e34
leaq 0xbd5b9(%rip), %rdi # 0x1753d5
leaq 0xbd5c5(%rip), %rsi # 0x1753e8
movl $0x22, %edx
leaq 0xbd614(%rip), %rcx ... | /GlobalArrays[P]ga/comex/src-mpi/groups.c |
GAsizeof | Integer GAsizeof(Integer type)
{
switch (type) {
case C_DBL : return (sizeof(double));
case C_INT : return (sizeof(int));
case C_SCPL : return (sizeof(SingleComplex));
case C_DCPL : return (sizeof(DoubleComplex));
case C_FLOAT : return (sizeof(float));
case C_LONG : return (sizeof(... | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, -0x18(%rsp)
subq $0xf, %rax
ja 0xb86b3
movq -0x18(%rsp), %rax
leaq 0xbcfdd(%rip), %rcx # 0x175624
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x4, -0x8(%rsp)
jmp 0xb... | /GlobalArrays[P]ga/global/src/base.c |
pnga_proc_topology | void pnga_proc_topology(Integer g_a, Integer proc, Integer* subscript)
{
Integer d, index, ndim, ga_handle = GA_OFFSET + g_a;
ga_check_handleM(g_a, "nga_proc_topology");
ndim = GA[ga_handle].ndim;
index = proc;
for(d=0; d<ndim; d++){
subscript[d] = index% GA[ga_handle].nblock[d];
index /= ... | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq 0x230(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x200(%rsp)
movq 0x230(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
cmpq $0x0, %rax
jl 0xbdbe6
movq 0x230(%rsp), %rax
add... | /GlobalArrays[P]ga/global/src/base.c |
pnga_access_ghost_ptr | void pnga_access_ghost_ptr(Integer g_a, Integer dims[],
void* ptr, Integer ld[])
{
char *lptr;
Integer handle = GA_OFFSET + g_a;
Integer i, lo[MAXDIM], hi[MAXDIM];
Integer ndim = GA[handle].ndim;
Integer me = pnga_nodeid();
pnga_distribution(g_a, me, lo, hi);
for (i=0; i < ndim; i++) {... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x228(%rsp)
leaq 0x95f74(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm ... | /GlobalArrays[P]ga/global/src/ghosts.c |
NGA_Set_data64 | void NGA_Set_data64(int g_a, int ndim, int64_t dims[], int type)
{
Integer aa, nndim, ttype;
Integer _ga_dims[MAXDIM];
COPYC2F(dims,_ga_dims, ndim);
aa = (Integer)g_a;
nndim = (Integer)ndim;
ttype = (Integer)type;
wnga_set_data(aa, nndim, _ga_dims, ttype);
} | subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movl %esi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x70(%rsp), %eax
jge 0x139d04
movq 0x68(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movl 0x70(%rsp), %eax
subl 0xc(%rsp), %eax
subl $0x1, %eax
cltq
movq... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_block_cyclic | void NGA_Set_block_cyclic(int g_a, int dims[])
{
Integer aa, ndim;
Integer _ga_dims[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(dims,_ga_dims, ndim);
wnga_set_block_cyclic(aa, _ga_dims);
} | subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movslq 0x64(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc08a0
movq %rax, 0x48(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq 0x48(%rsp), %rax
jge 0x13a1eb
movq 0x58(%rsp), %rax
movslq 0xc(%rsp), %rcx
movslq (%rax,%rcx,4), %rcx
movq... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Scan_add | void GA_Scan_add(int g_a, int g_b, int g_sbit, int lo,
int hi, int excl)
{
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer s = (Integer)g_sbit;
Integer x = (Integer)excl;
Integer alo = lo+1;
Integer ahi = hi+1;
wnga_scan_add(a, b, s, alo, ahi, x);
} | subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movl %r9d, 0x30(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x28(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movslq 0x3c(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0x30(%rsp), %rax
movq %rax... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Median_patch64 | void GA_Median_patch64(int g_a, int64_t *alo, int64_t *ahi,
int g_b, int64_t *blo, int64_t *bhi,
int g_c, int64_t *clo, int64_t *chi,
int g_m, int64_t *mlo, int64_t *mhi){
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer c = (In... | pushq %r15
pushq %r14
pushq %rbx
subq $0x2c0, %rsp # imm = 0x2C0
movq 0x308(%rsp), %rax
movq 0x300(%rsp), %rax
movl 0x2f8(%rsp), %eax
movq 0x2f0(%rsp), %rax
movq 0x2e8(%rsp), %rax
movl 0x2e0(%rsp), %eax
movl %edi, 0x2bc(%rsp)
movq %rsi, 0x2b0(%rsp)
movq %rdx, 0x2a8(%rsp)
movl %ecx, 0x2a4(%rsp)
movq %r8, 0x29... | /GlobalArrays[P]ga/global/src/capi.c |
ddb_ap | void ddb_ap(long ndims, double * qedims, Integer * ardims, Integer * pedims,
long npes, long npdivs, long * pdivs)
{
long bq;
long i, k, g;
long idim;
for(idim=0;idim<ndims-1;idim++){
g = dd_lk(pdivs,npdivs,qedims[idim]);
bq = pdivs[g] ;
... | subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x1520a6
movq 0x70(%rsp), %rdi
movq 0x38(%rsp), %... | /GlobalArrays[P]ga/global/src/decomp.c |
cs_strerror | CAPSTONE_EXPORT
const char *cs_strerror(cs_err code)
{
switch(code) {
default:
return "Unknown error code";
case CS_ERR_OK:
return "OK (CS_ERR_OK)";
case CS_ERR_MEM:
return "Out of memory (CS_ERR_MEM)";
case CS_ERR_ARCH:
return "Invalid architecture (CS_ERR_ARCH)";
case CS_ERR_HANDLE:
return "... | cmpl $0xb, %edi
ja 0x43512
movl %edi, %eax
leaq 0x7eec6(%rip), %rcx # 0xc23d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x7eee7(%rip), %rax # 0xc2400
retq
| /bughoho[P]capstone/cs.c |
cs_option | CAPSTONE_EXPORT
cs_err cs_option(csh ud, cs_opt_type type, size_t value)
{
struct cs_struct *handle;
archs_enable();
// cs_option() can be called with NULL handle just for CS_OPT_MEM
// This is supposed to be executed before all other APIs (even cs_open())
if (type == CS_OPT_MEM) {
cs_opt_mem *mem = (cs_opt_mem... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x43479
cmpl $0x4, %ebp
jne 0x436d9
movq (%rbx), %rax
movq %rax, 0x150a07(%rip) # 0x1940b0
movq 0x8(%rbx), %rax
movq %rax, 0x150a04(%rip) # 0x1940b8
movq 0x10(%rbx), %rax
movq %rax, 0x150a01(%rip) # 0x1940c0
movq 0x18(%rbx),... | /bughoho[P]capstone/cs.c |
cs_free | CAPSTONE_EXPORT
void cs_free(cs_insn *insn, size_t count)
{
size_t i;
// free all detail pointers
for (i = 0; i < count; i++)
cs_mem_free(insn[i].detail);
// then free pointer to cs_insn array
cs_mem_free(insn);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x43d8c
movq %rsi, %r14
leaq 0xe8(%rbx), %r15
movq (%r15), %rdi
callq *0x150348(%rip) # 0x1940c8
addq $0xf0, %r15
decq %r14
jne 0x43d77
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x15032e(%rip) # 0x1940c8
| /bughoho[P]capstone/cs.c |
cs_reg_write | CAPSTONE_EXPORT
bool cs_reg_write(csh ud, const cs_insn *insn, unsigned int reg_id)
{
struct cs_struct *handle;
if (!ud)
return false;
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle->detail) {
handle->errnum = CS_ERR_DETAIL;
return false;
}
if(!insn->id) {
handle->errnum = CS_ERR_SKIPDATA;
r... | testq %rdi, %rdi
je 0x44111
cmpl $0x0, 0x68(%rdi)
je 0x44101
cmpl $0x0, (%rsi)
je 0x4410a
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x44101
movzbl 0x21(%rcx), %esi
testq %rsi, %rsi
je 0x44111
movzbl 0xd(%rcx), %edi
movb $0x1, %al
cmpl %edx, %edi
je 0x44100
leaq -0x1(%rsi), %rax
xorl %r8d, %r8d
movq %r8, %rdi
cmpq %r8, ... | /bughoho[P]capstone/cs.c |
printInt64Bang | void printInt64Bang(SStream *O, int64_t val)
{
if (val >= 0) {
if (val > HEX_THRESHOLD)
SStream_concat(O, "#0x%"PRIx64, val);
else
SStream_concat(O, "#%"PRIu64, val);
} else {
if (val <- HEX_THRESHOLD)
SStream_concat(O, "#-0x%"PRIx64, -val);
else
SStream_concat(O, "#-%"PRIu64, -val);
}
} | movq %rsi, %rax
testq %rsi, %rsi
js 0x44787
cmpq $0xa, %rax
jb 0x4479c
leaq 0x7de81(%rip), %rsi # 0xc2606
jmp 0x447a3
movq %rax, %rdx
negq %rdx
cmpq $-0xa, %rax
ja 0x447a8
leaq 0x7de78(%rip), %rsi # 0xc2612
jmp 0x447af
leaq 0x7de6a(%rip), %rsi # 0xc260d
movq %rax, %rdx
jmp 0x447af
leaq 0x7de6b(%rip), %rsi ... | /bughoho[P]capstone/SStream.c |
printInt32Bang | void printInt32Bang(SStream *O, int32_t val)
{
if (val >= 0) {
if (val > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", val);
else
SStream_concat(O, "#%u", val);
} else {
if (val <- HEX_THRESHOLD)
SStream_concat(O, "#-0x%x", -val);
else
SStream_concat(O, "#-%u", -val);
}
} | movl %esi, %eax
testl %esi, %esi
js 0x44854
cmpl $0xa, %eax
jb 0x44866
leaq 0x908e4(%rip), %rsi # 0xd5136
jmp 0x4486d
movl %eax, %edx
negl %edx
cmpl $-0xa, %eax
ja 0x44871
leaq 0x908c2(%rip), %rsi # 0xd5126
jmp 0x44878
leaq 0x908d1(%rip), %rsi # 0xd513e
movl %eax, %edx
jmp 0x44878
leaq 0x908b7(%rip), %rsi ... | /bughoho[P]capstone/SStream.c |
LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>&, unsigned int) | static ImGuiStorage::ImGuiStoragePair* LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>& data, ImGuiID key)
{
ImGuiStorage::ImGuiStoragePair* first = data.Data;
ImGuiStorage::ImGuiStoragePair* last = data.Data + data.Size;
size_t count = (size_t)(last - first);
while (count > 0)
{
size_t ... | movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
testq %rcx, %rcx
je 0x26336
movq %rcx, %rdx
shrq %rdx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %esi, (%rax,%rdi)
jae 0x26331
notq %rdx
addq %rcx, %rdx
addq %rdi, %rax
addq $0x10, %rax
movq %rdx, %rcx
jmp 0x2630d
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGuiStorage::GetFloatRef(unsigned int, float) | float* ImGuiStorage::GetFloatRef(ImGuiID key, float default_val)
{
ImGuiStoragePair* it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, ImGuiStoragePair(key, default_val));
return &it->val_f;
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x26306
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x26438
cmpl %ebp, (%rax)
je 0x26455
leaq 0x8(%rsp), %rdx
movl %ebp, (%rdx)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rdx)
movq %rbx, %rd... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGuiStorage::GetVoidPtrRef(unsigned int, void*) | void** ImGuiStorage::GetVoidPtrRef(ImGuiID key, void* default_val)
{
ImGuiStoragePair* it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, ImGuiStoragePair(key, default_val));
return &it->val_p;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x26306
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x26489
cmpl %ebp, (%rax)
je 0x2649d
movq %rsp, %rdx
movl %ebp, (%rdx)
movq %r14, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x... | /binji[P]binjgb/third_party/imgui/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0xb6ac6(%rip), %r15 # 0xdd4d8
cmpb $0x1, 0x32b4(%r15)
jne 0x26a25
andl $0x0, (%r14)
jmp 0x26b66
movq 0x1d18(%r15), %r12
movq 0x21a0(%r15), %rax
leaq 0x207(%rax), %rcx
leaq 0xcc(%r12), %rdx
te... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::PushStyleVar(int, ImVec2 const&) | void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
{
ImGuiContext& g = *GImGui;
ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
g.StyleVar... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x271f7
cmpl $0x8, (%rax)
jne 0x2728f
cmpl $0x2, 0x4(%rax)
jne 0x2728f
movq 0xb6285(%rip), %r14 # 0xdd4d8
movl 0x8(%rax), %r15d
leaq 0x1eb8(%r14), %rdi
movsd 0x1640(%r14,%r15), %xmm0
leaq 0xc(%rsp), %rsi
movl %ebp, (%... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::RenderText(ImVec2, char const*, char const*, bool) | void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
// Hide anything after a '##' string
const char* text_display_end;
if (hide_text_after_hash)
{
text_display_end = Fin... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, 0x18(%rsp)
movq 0xb6119(%rip), %r13 # 0xdd4d8
movq 0x1d18(%r13), %r15
testl %edx, %edx
je 0x273da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27372
movq %rax, %r14
jmp 0x273ed
testq %r14, %r14
jne 0x273... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::RenderTextClippedEx(ImDrawList*, ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_display_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Perform CPU side clipping for single clipped element to avoid using scissor state
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0x88(%rsp), %rbp
movq (%rsi), %r15
movq %r15, 0x10(%rsp)
movd %r15d, %xmm7
shrq $0x20, %r15
testq %r9, %r9
je 0x276f3
movsd (%r9), %xmm0
jmp 0x2770... | /binji[P]binjgb/third_party/imgui/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 %r14
pushq %rbx
pushq %rax
movaps %xmm0, %xmm2
movq %rsi, %rax
movq %rdi, %rbx
movq 0xb5c5f(%rip), %r14 # 0xdd4d8
testl %edx, %edx
je 0x27894
movq %rbx, %rdi
movq %rax, %rsi
movss %xmm2, 0x4(%rsp)
callq 0x27372
movss 0x4(%rsp), %xmm2
movss 0x1a88(%r14), %xmm0
cmpq %rbx, %rax
je 0x278d7
movq 0x1a80(%r14), %rdi... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::GetMouseDragDelta(int, float) | ImVec2 ImGui::GetMouseDragDelta(ImGuiMouseButton button, float lock_threshold)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
if (lock_threshold < 0.0f)
lock_threshold = g.IO.MouseDragThreshold;
if (g.IO.MouseDown[button] || g.IO.MouseReleased[butto... | pushq %r15
pushq %r14
pushq %rbx
cmpl $0x5, %edi
jae 0x34229
movq 0xa9336(%rip), %r14 # 0xdd4d8
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x341b0
movss 0x38(%r14), %xmm0
movl %edi, %r15d
cmpb $0x0, 0x128(%r14,%r15)
jne 0x341cc
xorps %xmm2, %xmm2
cmpb $0x1, 0x42a(%r14,%r15)
jne 0x34220
movss 0x490(%r14,%r15,4), %x... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetItemAllowOverlap() | void ImGui::SetItemAllowOverlap()
{
ImGuiContext& g = *GImGui;
ImGuiID id = g.LastItemData.ID;
if (g.HoveredId == id)
g.HoveredIdAllowOverlap = true;
if (g.ActiveId == id)
g.ActiveIdAllowOverlap = true;
} | movq 0xa90ac(%rip), %rax # 0xdd4d8
movl 0x1dd8(%rax), %ecx
cmpl %ecx, 0x1d58(%rax)
jne 0x34441
movb $0x1, 0x1d60(%rax)
cmpl %ecx, 0x1d6c(%rax)
jne 0x34450
movb $0x1, 0x1d79(%rax)
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::BeginGroup() | void ImGui::BeginGroup()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
g.GroupStack.resize(g.GroupStack.Size + 1);
ImGuiGroupData& group_data = g.GroupStack.back();
group_data.WindowID = window->ID;
group_data.BackupCursorPos = window->DC.CursorPos;
group_data.BackupCu... | pushq %r15
pushq %r14
pushq %rbx
movq 0xa4552(%rip), %r14 # 0xdd4d8
movq 0x1d18(%r14), %r15
leaq 0x1ef8(%r14), %rbx
movl 0x1ef8(%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x49b1a
movq %rbx, %rdi
callq 0x4a6ca
movl 0x8(%r15), %ecx
movl %ecx, (%rax)
movq 0x110(%r15), %rcx
movq %rcx, 0x4(%rax)
movq 0x128(%r15), %rcx
... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetScrollFromPosX(ImGuiWindow*, float, float) | void ImGui::SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio)
{
IM_ASSERT(center_x_ratio >= 0.0f && center_x_ratio <= 1.0f);
window->ScrollTarget.x = IM_FLOOR(local_x + window->Scroll.x); // Convert local position to scroll offset
window->ScrollTargetCenterRatio.x = center_x_ratio;... | xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jb 0x390d2
movss 0x6432e(%rip), %xmm2 # 0x9d3d4
ucomiss %xmm1, %xmm2
jb 0x390d2
addss 0x94(%rdi), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xa4(%rdi)
movss %xmm1, 0xac(%rdi)
andl $0x0, 0xb4(%rdi)
retq
pushq %rax
leaq 0x672e0(%rip), %rdi # 0xa03ba
lea... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetScrollFromPosY(ImGuiWindow*, float, float) | void ImGui::SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio)
{
IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
const float decoration_up_height = window->TitleBarHeight() + window->MenuBarHeight(); // FIXME: Would be nice to have a more standardized access to our scrollab... | pushq %rbx
subq $0x20, %rsp
movaps %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jb 0x3916e
movss 0x642c8(%rip), %xmm0 # 0x9d3d4
ucomiss %xmm1, %xmm0
jb 0x3916e
movq %rdi, %rbx
movss %xmm1, 0xc(%rsp)
callq 0x4a228
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4a252
addss 0x8(%rsp), %xmm0
movaps 0x10(%rs... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetScrollHereX(float) | void ImGui::SetScrollHereX(float center_x_ratio)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
float spacing_x = ImMax(window->WindowPadding.x, g.Style.ItemSpacing.x);
float target_pos_x = ImLerp(g.LastItemData.Rect.Min.x - spacing_x, g.LastItemData.Rect.Max.x + spacing_x, center_x... | pushq %rbx
subq $0x10, %rsp
movaps %xmm0, %xmm1
movq 0xa4242(%rip), %rax # 0xdd4d8
movq 0x1d18(%rax), %rbx
movss 0x78(%rbx), %xmm0
movss 0x168c(%rax), %xmm2
movaps %xmm2, %xmm3
cmpless %xmm0, %xmm3
andps %xmm3, %xmm0
andnps %xmm2, %xmm3
orps %xmm0, %xmm3
movaps %xmm3, (%rsp)
movss 0x1de4(%rax), %xmm2
subss %xmm3, %... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::BeginTooltipEx(int, int) | void ImGui::BeginTooltipEx(ImGuiWindowFlags extra_flags, ImGuiTooltipFlags tooltip_flags)
{
ImGuiContext& g = *GImGui;
if (g.DragDropWithinSource || g.DragDropWithinTarget)
{
// The default tooltip position is a little offset to give space to see the context menu (it's also clamped within the curre... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0xa4116(%rip), %r14 # 0xdd4d8
cmpb $0x0, 0x20fd(%r14)
jne 0x393d8
movl %esi, %ebp
cmpb $0x1, 0x20fe(%r14)
jne 0x3943f
movss 0x16f8(%r14), %xmm0
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
mulps 0x63ec5(%rip), %xmm0 # 0x9d2b0
movsd... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::NavCalcPreferredRefPos() | static ImVec2 ImGui::NavCalcPreferredRefPos()
{
ImGuiContext& g = *GImGui;
if (g.NavDisableHighlight || !g.NavDisableMouseHover || !g.NavWindow)
{
// Mouse (we need a fallback in case the mouse becomes invalid after being used)
if (IsMousePosValid(&g.IO.MousePos))
return g.IO.Mou... | pushq %r14
pushq %rbx
pushq %rax
movq 0xa3e0f(%rip), %r14 # 0xdd4d8
cmpb $0x0, 0x1fd2(%r14)
jne 0x39777
cmpb $0x1, 0x1fd3(%r14)
jne 0x39777
movq 0x1f88(%r14), %rax
testq %rax, %rax
je 0x39777
movl 0x1fc8(%r14), %ecx
shlq $0x4, %rcx
movss 0x167c(%r14), %xmm0
mulss 0x63d3b(%rip), %xmm0 # 0x9d44c
movsd 0x3b8(%rax,%... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::ClosePopupToLevel(int, bool) | void ImGui::ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup)
{
ImGuiContext& g = *GImGui;
IMGUI_DEBUG_LOG_POPUP("ClosePopupToLevel(%d), restore_focus_to_window_under_popup=%d\n", remaining, restore_focus_to_window_under_popup);
IM_ASSERT(remaining >= 0 && remaining < g.OpenPopupSta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x3986b
movl %edi, %r14d
movq 0xa3d1a(%rip), %r13 # 0xdd4d8
cmpl %edi, 0x1f08(%r13)
jle 0x3986b
movl %esi, %ebp
leaq 0x1f08(%r13), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x4a100
movq 0x10(%rax), %rbx
movq %r12, %rd... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::ClosePopupsExceptModals() | void ImGui::ClosePopupsExceptModals()
{
ImGuiContext& g = *GImGui;
int popup_count_to_keep;
for (popup_count_to_keep = g.OpenPopupStack.Size; popup_count_to_keep > 0; popup_count_to_keep--)
{
ImGuiWindow* window = g.OpenPopupStack[popup_count_to_keep - 1].Window;
if (!window || window->... | pushq %rbp
pushq %r14
pushq %rbx
movq 0xa3c43(%rip), %rbx # 0xdd4d8
movl 0x1f08(%rbx), %ebp
addq $0x1f08, %rbx # imm = 0x1F08
movl %ebp, %r14d
testl %ebp, %ebp
jle 0x398c6
leal -0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4a100
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x398c6
testb $0x8, 0xf(%... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetNavID(unsigned int, ImGuiNavLayer, unsigned int, ImRect const&) | void ImGui::SetNavID(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.NavWindow != NULL);
IM_ASSERT(nav_layer == ImGuiNavLayer_Main || nav_layer == ImGuiNavLayer_Menu);
g.NavId = id;
g.NavLayer = nav_layer;
g.NavFocusSc... | pushq %rax
movq 0xa32af(%rip), %r8 # 0xdd4d8
movq 0x1f88(%r8), %rax
testq %rax, %rax
je 0x3a269
cmpl $0x2, %esi
jae 0x3a288
movl %edi, 0x1f90(%r8)
movl %esi, 0x1fc8(%r8)
movl %edx, 0x1f94(%r8)
movl %esi, %edx
movl %edi, 0x3b0(%rax,%rdx,4)
shlq $0x4, %rdx
movups (%rcx), %xmm0
movups %xmm0, 0x3b8(%rax,%rdx)
popq %ra... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::NavInitRequestApplyResult() | void ImGui::NavInitRequestApplyResult()
{
// In very rare cases g.NavWindow may be null (e.g. clearing focus after requesting an init request, which does happen when releasing Alt while clicking on void)
ImGuiContext& g = *GImGui;
if (!g.NavWindow)
return;
// Apply result from previous navigati... | pushq %rbx
movq 0xa2db8(%rip), %rbx # 0xdd4d8
cmpq $0x0, 0x1f88(%rbx)
je 0x3a764
movl 0x1fc8(%rbx), %esi
movl 0x1fd8(%rbx), %edi
leaq 0x1fdc(%rbx), %rcx
xorl %edx, %edx
callq 0x3a221
movb $0x1, 0x1fd0(%rbx)
cmpb $0x1, 0x1fd6(%rbx)
jne 0x3a764
movw $0x1, 0x1fd1(%rbx)
movb $0x1, 0x1fd3(%rbx)
popq %rbx
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::BeginDragDropTarget() | bool ImGui::BeginDragDropTarget()
{
ImGuiContext& g = *GImGui;
if (!g.DragDropActive)
return false;
ImGuiWindow* window = g.CurrentWindow;
if (!(g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredRect))
return false;
ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWind... | pushq %r14
pushq %rbx
pushq %rax
movq 0xa2575(%rip), %r14 # 0xdd4d8
cmpb $0x1, 0x20fc(%r14)
jne 0x3afd1
movl 0x1de0(%r14), %eax
testb $0x1, %al
je 0x3afd1
movq 0x1d28(%r14), %rcx
testq %rcx, %rcx
je 0x3afd1
movq 0x1d18(%r14), %rdi
movq 0x390(%rdi), %rdx
cmpq 0x390(%rcx), %rdx
jne 0x3afd1
cmpb $0x0, 0xcc(%rdi)
jne 0... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::AcceptDragDropPayload(char const*, int) | const ImGuiPayload* ImGui::AcceptDragDropPayload(const char* type, ImGuiDragDropFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiPayload& payload = g.DragDropPayload;
IM_ASSERT(g.DragDropActive); // Not called between BeginDragDropTarget() and ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xa24a1(%rip), %r13 # 0xdd4d8
cmpb $0x0, 0x20fc(%r13)
je 0x3b1a7
cmpl $-0x1, 0x2124(%r13)
je 0x3b1c6
movl %esi, %ebp
movq %rdi, %rsi
movq 0x1d18(%r13), %r14
leaq 0x2110(%r13), %rbx
testq %rdi, %rdi
je 0x3b07b
movq %rbx, %rdi
cal... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::EndDragDropTarget() | void ImGui::EndDragDropTarget()
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.DragDropActive);
IM_ASSERT(g.DragDropWithinTarget);
g.DragDropWithinTarget = false;
} | pushq %rax
movq 0xa22cf(%rip), %rax # 0xdd4d8
cmpb $0x0, 0x20fc(%rax)
je 0x3b224
cmpb $0x0, 0x20fe(%rax)
je 0x3b243
movb $0x0, 0x20fe(%rax)
popq %rax
retq
leaq 0x63322(%rip), %rdi # 0x9e54d
leaq 0x62b5f(%rip), %rsi # 0x9dd91
leaq 0x65b2a(%rip), %rcx # 0xa0d63
movl $0x2b33, %edx # imm = 0x2B33
... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::LogBegin(ImGuiLogType, int) | void ImGui::LogBegin(ImGuiLogType type, int auto_open_depth)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT(g.LogEnabled == false);
IM_ASSERT(g.LogFile == NULL);
IM_ASSERT(g.LogBuffer.empty());
g.LogEnabled = true;
g.LogType = type;
g.LogNextPrefix = g.LogN... | pushq %rax
movq 0xa2123(%rip), %rax # 0xdd4d8
cmpb $0x0, 0x32b4(%rax)
jne 0x3b422
cmpq $0x0, 0x32c0(%rax)
jne 0x3b441
cmpl $0x2, 0x32c8(%rax)
jge 0x3b460
movq 0x1d18(%rax), %rcx
movb $0x1, 0x32b4(%rax)
movl %edi, 0x32b8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x32d8(%rax)
movl 0x190(%rcx), %ecx
movl %ecx, 0x32f0(%ra... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::LogToTTY(int) | void ImGui::LogToTTY(int auto_open_depth)
{
ImGuiContext& g = *GImGui;
if (g.LogEnabled)
return;
IM_UNUSED(auto_open_depth);
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
LogBegin(ImGuiLogType_TTY, auto_open_depth);
g.LogFile = stdout;
#endif
} | pushq %rbx
movq 0xa203b(%rip), %rbx # 0xdd4d8
cmpb $0x0, 0x32b4(%rbx)
jne 0x3b4c1
movl %edi, %esi
pushq $0x1
popq %rdi
callq 0x3b3ad
movq 0xa1b21(%rip), %rax # 0xdcfd8
movq (%rax), %rax
movq %rax, 0x32c0(%rbx)
popq %rbx
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockSpace(unsigned int, ImVec2 const&, int, ImGuiWindowClass const*) | ImGuiID ImGui::DockSpace(ImGuiID id, const ImVec2& size_arg, ImGuiDockNodeFlags flags, const ImGuiWindowClass* window_class)
{
ImGuiContext* ctx = GImGui;
ImGuiContext& g = *ctx;
ImGuiWindow* window = GetCurrentWindow();
if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
return 0;
//... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq 0x9d3fa(%rip), %r12 # 0xdd4d8
movq 0x1d18(%r12), %r15
movb $0x1, 0xc9(%r15)
xorl %eax, %eax
testb $0x40, 0x8(%r12)
je 0x403c4
btl $0xa, %edx
jb 0x403d6
movl %edi, %ebx
movq %rsi, 0x8(%rsp)
testl %edi, %... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockContextAddNode(ImGuiContext*, unsigned int) | static ImGuiDockNode* ImGui::DockContextAddNode(ImGuiContext* ctx, ImGuiID id)
{
// Generate an ID for the new node (the exact ID value doesn't matter as long as it is not already used) and add the first window.
if (id == 0)
id = DockContextGenNodeID(ctx);
else
IM_ASSERT(DockContextFindNodeB... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x404ae
movl %esi, %ebp
leaq 0x3220(%rbx), %rdi
callq 0x2638a
testq %rax, %rax
je 0x404b8
leaq 0x65647(%rip), %rdi # 0xa5add
leaq 0x5d8f4(%rip), %rsi # 0x9dd91
leaq 0x65664(%rip), %rcx # 0xa5b08
movl $0x32b3, %edx # imm = 0x32B3
... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockNodeTreeUpdateSplitter(ImGuiDockNode*) | const ImWchar* ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin) // find beginning-of-line
{
while (buf_mid_line > buf_begin && buf_mid_line[-1] != '\n')
buf_mid_line--;
return buf_mid_line;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x47b0e
movq %rdi, %r15
movq 0x28(%rdi), %rbx
testb $0x2, 0xbd(%r14)
je 0x47afd
testb $0x2, 0xbd(%rbx)
je 0x47af5
movslq 0x60(%r15), %r12
cmpq $-0x1, %r12
je 0x47f38
movq 0x95ae6(%rip), %rax ... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
DockNodeFindInfo(ImGuiDockNode*, ImGuiDockNodeTreeInfo*) | static void DockNodeFindInfo(ImGuiDockNode* node, ImGuiDockNodeTreeInfo* info)
{
if (node->Windows.Size > 0)
{
if (info->FirstNodeWithWindows == NULL)
info->FirstNodeWithWindows = node;
info->CountNodesWithWindows++;
}
if (node->IsCentralNode())
{
IM_ASSERT(info->... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x30(%r14)
jle 0x481d4
cmpq $0x0, 0x8(%rbx)
jne 0x481d1
movq %r14, 0x8(%rbx)
incl 0x10(%rbx)
testb $0x8, 0x11(%r14)
je 0x481eb
cmpq $0x0, (%rbx)
jne 0x48219
cmpq $0x0, 0x20(%r14)
jne 0x48238
movq %r14, (%rbx)
cmpl $0x2, 0x10(%rbx)
jl 0x481f7
cm... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
DockNodeTreeUpdateSplitterFindTouchingNode(ImGuiDockNode*, ImGuiAxis, int, ImVector<ImGuiDockNode*>*) | static void DockNodeTreeUpdateSplitterFindTouchingNode(ImGuiDockNode* node, ImGuiAxis axis, int side, ImVector<ImGuiDockNode*>* touching_nodes)
{
if (node->IsLeafNode())
{
touching_nodes->push_back(node);
return;
}
if (node->ChildNodes[0]->IsVisible)
if (node->SplitAxis != axis |... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x482c6
testb $0x2, 0xbd(%rdi)
je 0x4829f
testl %ebp, %ebp
je 0x48292
cmpl %r14d, 0x60(%r15)
jne 0x48292
movq 0x28(%r15), %rax
testb $0x2, 0xbd(%rax)
jne 0x48... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockNodeCalcTabBarLayout(ImGuiDockNode const*, ImRect*, ImRect*, ImVec2*, ImVec2*) | static void ImGui::DockNodeCalcTabBarLayout(const ImGuiDockNode* node, ImRect* out_title_rect, ImRect* out_tab_bar_rect, ImVec2* out_window_menu_button_pos, ImVec2* out_close_button_pos)
{
ImGuiContext& g = *GImGui;
ImGuiStyle& style = g.Style;
ImRect r = ImRect(node->Pos.x, node->Pos.y, node->Pos.x + node... | movq 0x951f2(%rip), %rax # 0xdd4d8
movsd 0x48(%rdi), %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0 # xmm0 = xmm0[1,1],xmm1[1,1]
movss 0x50(%rdi), %xmm2
addss %xmm1, %xmm2
movss 0x1a88(%rax), %xmm5
movaps %xmm0, %xmm4
addss %xmm5, %xmm4
movss 0x1680(%rax), %xmm3
addss %xmm3, %xmm3
addss %xmm4, %xmm3
testq... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
DockNodeIsDropAllowedOne(ImGuiWindow*, ImGuiWindow*) | static bool DockNodeIsDropAllowedOne(ImGuiWindow* payload, ImGuiWindow* host_window)
{
if (host_window->DockNodeAsHost && host_window->DockNodeAsHost->IsDockSpace() && payload->BeginOrderWithinContext < host_window->BeginOrderWithinContext)
return false;
ImGuiWindowClass* host_class = host_window->Dock... | movq 0x408(%rsi), %rax
testq %rax, %rax
je 0x48445
testb $0x4, 0x11(%rax)
je 0x48445
movzwl 0xd6(%rdi), %ecx
cmpw 0xd6(%rsi), %cx
jl 0x4847c
leaq 0x64(%rax), %rcx
addq $0x14, %rsi
testq %rax, %rax
cmovneq %rcx, %rsi
movl (%rsi), %ecx
movl 0x14(%rdi), %edx
movb $0x1, %al
cmpl %edx, %ecx
je 0x4846d
testl %ecx, %ecx
je 0x... | /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImVector<ImGuiStorage::ImGuiStoragePair>::insert(ImGuiStorage::ImGuiStoragePair const*, ImGuiStorage::ImGuiStoragePair const&) | inline T* insert(const T* it, const T& v) { IM_ASSERT(it >= Data && it <= Data + Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(_grow_capacity(Size + 1)); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(T)); memcpy(&Data[off], &v, sizeo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
ja 0x48712
movq %rdi, %r14
movslq (%rdi), %rcx
movq %rcx, %rax
shlq $0x4, %rax
addq %rsi, %rax
cmpq %rbx, %rax
jb 0x48712
movq %rdx, %r15
subq %rsi, %rbx
movq %rbx, %r12
sarq $0x4, %r12
cmpl 0x4(%r14), %ecx
jne 0... | /binji[P]binjgb/third_party/imgui/imgui.h |
ImGuiWindowTempData::~ImGuiWindowTempData() | struct IMGUI_API ImGuiWindowTempData
{
// Layout
ImVec2 CursorPos; // Current emitting position, in absolute coordinates.
ImVec2 CursorPosPrevLine;
ImVec2 CursorStartPos; // Initial position after Begin(), generally ~ window positio... | pushq %rbx
movq %rdi, %rbx
addq $0xd0, %rdi
callq 0x4afea
leaq 0xc0(%rbx), %rdi
callq 0x4afea
addq $0x88, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x4aad0
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGuiContext::ImGuiContext(ImFontAtlas*) | ImGuiContext(ImFontAtlas* shared_font_atlas)
{
Initialized = false;
ConfigFlagsCurrFrame = ConfigFlagsLastFrame = ImGuiConfigFlags_None;
FontAtlasOwnedByContext = shared_font_atlas ? false : true;
Font = NULL;
FontSize = FontBaseSize = 0.0f;
IO.Fonts = shared_font_atl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x24aa4
leaq 0x1560(%rbx), %r14
movl $0xe0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x241f0
leaq 0x1640(%rbx), %rdi
callq 0x2482c
leaq 0x1a90(%rbx), %rdi
callq 0x4d2ac
andq $0x0, 0... | /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGuiViewportP::ImGuiViewportP() | ImGuiViewportP() { Idx = -1; LastFrameActive = DrawListsLastFrame[0] = DrawListsLastFrame[1] = LastFrontMostStampCount = -1; LastNameHash = 0; Alpha = LastAlpha = 1.0f; PlatformMonitor = -1; PlatformWindowCreated = false; Window = NULL; DrawLists[0] = DrawLists[1] = NULL; LastPlatformPos = LastPlatfo... | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0xa0, %rdi
movl $0x90, %edx
xorl %esi, %esi
callq 0x241f0
orq $-0x1, 0x88(%rbx)
movaps 0x53674(%rip), %xmm0 # 0x9d260
m... | /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImChunkStream<ImGuiWindowSettings>::next_chunk(ImGuiWindowSettings*) | T* next_chunk(T* p) { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; } | pushq %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %al
leaq 0x4(%rcx), %rdx
cmpq %rsi, %rdx
seta %dl
testb %dl, %al
jne 0x4a870
movslq (%rdi), %rax
addq %rax, %rcx
cmpq %rsi, %rcx
jbe 0x4a870
movslq -0x4(%rsi), %rax
addq %rsi, %rax
leaq 0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x4a86c
cmpq %rcx, %rax
jb 0x4a86e
leaq 0x59... | /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImChunkStream<ImGuiTableSettings>::next_chunk(ImGuiTableSettings*) | T* next_chunk(T* p) { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; } | pushq %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %al
leaq 0x4(%rcx), %rdx
cmpq %rsi, %rdx
seta %dl
testb %dl, %al
jne 0x4ad2a
movslq (%rdi), %rax
addq %rax, %rcx
cmpq %rsi, %rcx
jbe 0x4ad2a
movslq -0x4(%rsi), %rax
addq %rsi, %rax
leaq 0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x4ad26
cmpq %rcx, %rax
jb 0x4ad28
leaq 0x58... | /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGuiInputTextState::~ImGuiInputTextState() | struct IMGUI_API ImGuiInputTextState
{
ImGuiID ID; // widget id owning the text state
int CurLenW, CurLenA; // we need to maintain our buffer length in both UTF-8 and wchar format. UTF-8 length is valid even if TextA is not.
ImVector<ImWchar> ... | pushq %rbx
movq %rdi, %rbx
addq $0x30, %rdi
callq 0x4b12c
leaq 0x20(%rbx), %rdi
callq 0x4b12c
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x485c2
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImVector<ImGuiWindow*>::insert(ImGuiWindow* const*, ImGuiWindow* const&) | inline T* insert(const T* it, const T& v) { IM_ASSERT(it >= Data && it <= Data + Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(_grow_capacity(Size + 1)); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(T)); memcpy(&Data[off], &v, sizeo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
ja 0x4b631
movq %rdi, %r14
movslq (%rdi), %rcx
leaq (%rsi,%rcx,8), %rax
cmpq %rbx, %rax
jb 0x4b631
movq %rdx, %r15
subq %rsi, %rbx
movq %rbx, %r12
sarq $0x3, %r12
cmpl 0x4(%r14), %ecx
jne 0x4b5f4
leal 0x1(%rcx), ... | /binji[P]binjgb/third_party/imgui/imgui.h |
ImGuiTabBar::~ImGuiTabBar() | struct IMGUI_API ImGuiTabBar
{
ImVector<ImGuiTabItem> Tabs;
ImGuiTabBarFlags Flags;
ImGuiID ID; // Zero for tab-bars used by docking
ImGuiID SelectedTabId; // Selected tab/window
ImGuiID NextSelectedTabId; // Next selected tab/... | pushq %rbx
movq %rdi, %rbx
addq $0x88, %rdi
callq 0x4b12c
movq %rbx, %rdi
popq %rbx
jmp 0x4c5ec
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGui::StyleColorsDark(ImGuiStyle*) | void ImGui::StyleColorsDark(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
colors[ImGui... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4c829
callq 0x26f92
movq %rax, %rbx
movaps 0x50b20(%rip), %xmm0 # 0x9d350
movups %xmm0, 0xc8(%rbx)
movaps 0x5a9c2(%rip), %xmm0 # 0xa7200
movups %xmm0, 0xd8(%rbx)
movaps 0x5a9c4(%rip), %xmm0 # 0xa7210
... | /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImGui::StyleColorsClassic(ImGuiStyle*) | void ImGui::StyleColorsClassic(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
colors[Im... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4cbc5
callq 0x26f92
movq %rax, %rbx
movaps 0x5a894(%rip), %xmm0 # 0xa7460
movups %xmm0, 0xc8(%rbx)
movaps 0x5a896(%rip), %xmm0 # 0xa7470
movups %xmm0, 0xd8(%rbx)
movaps 0x5a898(%rip), %xmm0 ... | /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImGui::StyleColorsLight(ImGuiStyle*) | void ImGui::StyleColorsLight(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
colors[ImGu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4cf4e
callq 0x26f92
movq %rax, %rbx
movaps 0x5a73b(%rip), %xmm0 # 0xa7690
movups %xmm0, 0xc8(%rbx)
movaps 0x5a50d(%rip), %xmm0 # 0xa7470
movups %xmm0, 0xd8(%rbx)
movaps 0x5a72f(%rip), %xmm0 ... | /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImDrawListSharedData::ImDrawListSharedData() | ImDrawListSharedData::ImDrawListSharedData()
{
memset(this, 0, sizeof(*this));
for (int i = 0; i < IM_ARRAYSIZE(ArcFastVtx); i++)
{
const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(ArcFastVtx);
ArcFastVtx[i] = ImVec2(ImCos(a), ImSin(a));
}
ArcFastRadiusCutoff = IM_DRAWLIS... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x241f0
cmpq $0x30, %r14
je 0x4d314
cvtsi2ss %r14d, %xmm0
addss %xmm0, %xmm0
mulss 0x5a5f7(%rip), %xmm0 # 0xa78d0
divss 0x5a5f3(%rip), %xmm0 # 0xa78d4
movss %xmm0, (%rsp)
callq 0x244... | /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImBitArraySetBitRange(unsigned int*, int, int) | inline void ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)
{
n2--;
while (n <= n2)
{
int a_mod = (n & 31);
int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
arr[... | leal -0x1(%rdx), %eax
movl %eax, %r8d
andl $0x1f, %r8d
incl %r8d
pushq $0x20
popq %r9
pushq $-0x1
popq %r10
cmpl %edx, %esi
jge 0x64776
movl %esi, %ecx
orl $0x1f, %ecx
cmpl %ecx, %eax
movl %r8d, %ecx
cmovgl %r9d, %ecx
movq %r10, %r11
shlq %cl, %r11
notl %r11d
movl %esi, %ecx
shrl %cl, %r11d
shll %cl, %r11d
movl %esi, %... | /binji[P]binjgb/third_party/imgui/imgui_internal.h |
init_emulator | Result init_emulator(Emulator* e, const EmulatorInit* init) {
static u8 s_initial_wave_ram[WAVE_RAM_SIZE] = {
0x60, 0x0d, 0xda, 0xdd, 0x50, 0x0f, 0xad, 0xed,
0xc0, 0xde, 0xf0, 0x0d, 0xbe, 0xef, 0xfe, 0xed,
};
CHECK(SUCCESS(get_cart_infos(e)));
log_cart_info(e->cart_info);
MMAP_STATE.rom_base[0] = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movq 0x30(%rdi), %rax
movq %rsp, %rcx
movq %rax, 0x20(%rsp)
movq %rax, (%rcx)
leaq 0x38(%rdi), %r12
xorl %esi, %esi
pushq $0x1
popq %rbp
movq %r12, 0x18(%rsp)
xorl %r14d, %r14d
... | /binji[P]binjgb/src/emulator.c |
write_apu | static void write_apu(Emulator* e, MaskedAddress addr, u8 value) {
if (e->config.log_apu_writes || !APU.initialized) {
if (e->apu_log.write_count < MAX_APU_LOG_FRAME_WRITES) {
ApuWrite* write = &e->apu_log.writes[e->apu_log.write_count++];
write->addr = addr;
write->value = value;
}
}
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0x82ae7
movq 0x82d00(%rbx), %rax
cmpq $0x3ff, %rax # imm = 0x3FF
ja 0x82af0
leaq 0x1(%rax), %rcx
movq %rcx, 0x82d00(%rbx)
movb %r15b, 0x82500(%rbx,%rax,2)
movb %bpl, 0x82501(%rbx,%... | /binji[P]binjgb/src/emulator.c |
randomize_buffer | static void randomize_buffer(u32* seed, u8* buffer, u32 size) {
while (size >= sizeof(u32)) {
u32 x = random_u32(seed);
memcpy(buffer, &x, sizeof(x));
buffer += sizeof(u32);
size -= sizeof(u32);
}
if (size > 0) {
u32 x = random_u32(seed);
switch (size) {
case 3: *buffer++ = x & 0xff;... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x4, %ebp
jb 0x84563
movq %r14, %rdi
callq 0x8ea9f
movl %eax, (%rbx)
addq $0x4, %rbx
addl $-0x4, %ebp
jmp 0x8454b
testl %ebp, %ebp
je 0x84571
movq %r14, %rdi
callq 0x8ea9f
movb %al, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| /binji[P]binjgb/src/emulator.c |
calculate_next_ppu_intr | static void calculate_next_ppu_intr(Emulator* e) {
if (LCDC.display) {
/* TODO: Looser bounds on sync points. This syncs at every state
* transition, even though we often won't need to sync that often. */
PPU.next_intr_ticks = PPU.sync_ticks + PPU.state_ticks;
} else {
PPU.next_intr_ticks = INVALID... | cmpl $0x0, 0x33838(%rdi)
je 0x8458e
movl 0x33a68(%rdi), %eax
addq 0x33828(%rdi), %rax
jmp 0x84591
pushq $-0x1
popq %rax
movq %rax, 0x33830(%rdi)
movq 0x33638(%rdi), %rcx
movq 0x33668(%rdi), %rdx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movq %rdx, 0x33c08(%rdi)
retq
| /binji[P]binjgb/src/emulator.c |
emulator_read_state | Result emulator_read_state(Emulator* e, const FileData* file_data) {
CHECK_MSG(file_data->size == sizeof(EmulatorState),
"save state file is wrong size: %ld, expected %ld.\n",
(long)file_data->size, (long)sizeof(EmulatorState));
EmulatorState* new_state = (EmulatorState*)file_data->data;
C... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpq $0x30bc0, 0x8(%rsi) # imm = 0x30BC0
jne 0x847dd
movq (%r14), %r14
cmpl $0x6b57a7e2, (%r14) # imm = 0x6B57A7E2
jne 0x8481d
movq %rdi, %rbx
addq $0x3060, %rdi # imm = 0x3060
movl $0x30bc0, %edx # imm = 0x30BC0
movq %r14, %rsi
callq 0x24070
m... | /binji[P]binjgb/src/emulator.c |
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.