name string | code string | asm string | file string |
|---|---|---|---|
ncnn::deformableconv2d_pack8to4_avx(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, int, int, int, int, int, int, int, int, int, ncnn::Mat const&, ncnn::Option const&) | static void deformableconv2d_pack8to4_avx(const std::vector<Mat>& bottom_blobs, Mat& top_blob, const Mat& weight_data_packed, const Mat& bias_data, int kernel_w, int kernel_h, int dilation_w, int dilation_h, int stride_w, int stride_h, int pad_left, int pad_top, int activation_type, const Mat& activation_params, const ... | pushq %r14
pushq %rbx
subq $0x3af8, %rsp # imm = 0x3AF8
movq 0x3b50(%rsp), %rax
movq 0x3b48(%rsp), %rax
movl 0x3b40(%rsp), %eax
movl 0x3b38(%rsp), %eax
movl 0x3b30(%rsp), %eax
movl 0x3b28(%rsp), %eax
movl 0x3b20(%rsp), %eax
movl 0x3b18(%rsp), %eax
movl 0x3b10(%rsp), %eax
movq %rdi, 0x960(%rsp)
movq %rsi, 0x95... | /Tencent[P]ncnn/src/layer/x86/deformableconv2d_pack8to4.h |
create_activation_layer(int, ncnn::Mat const&, ncnn::Option const&) | static ncnn::Layer* create_activation_layer(int activation_type, const ncnn::Mat& activation_params, const ncnn::Option& opt)
{
ncnn::Layer* activation = 0;
if (activation_type == 1)
{
activation = ncnn::create_layer_cpu(ncnn::LayerType::ReLU);
ncnn::ParamDict pd;
activation->load_... | subq $0x128, %rsp # imm = 0x128
movl %edi, 0xd4(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq $0x0, 0xb8(%rsp)
cmpl $0x1, 0xd4(%rsp)
jne 0x1d54cc8
movl $0x1a, %edi
callq 0x89670
movq %rax, 0xb8(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x78060
movq 0x40(%rsp), %rsi
movq 0xb8(%rsp), %rd... | /Tencent[P]ncnn/src/layer/fused_activation.h |
ncnn::deformableconv2d_pack8to1_avx(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Mat const&, int, int, int, int, int, int, int, int, int, ncnn::Mat const&, ncnn::Option const&) | static void deformableconv2d_pack8to1_avx(const std::vector<Mat>& bottom_blobs, Mat& top_blob, const Mat& weight_data_packed, const Mat& bias_data, int kernel_w, int kernel_h, int dilation_w, int dilation_h, int stride_w, int stride_h, int pad_left, int pad_top, int activation_type, const Mat& activation_params, const ... | subq $0xcd8, %rsp # imm = 0xCD8
movq 0xd20(%rsp), %rax
movq 0xd18(%rsp), %rax
movl 0xd10(%rsp), %eax
movl 0xd08(%rsp), %eax
movl 0xd00(%rsp), %eax
movl 0xcf8(%rsp), %eax
movl 0xcf0(%rsp), %eax
movl 0xce8(%rsp), %eax
movl 0xce0(%rsp), %eax
movq %rdi, 0x5e8(%rsp)
movq %rsi, 0x5e0(%rsp)
movq %rdx, 0x5d8(%rsp)
m... | /Tencent[P]ncnn/src/layer/x86/deformableconv2d_pack8to1.h |
ncnn::GLU::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int GLU::forward(const Mat& bottom_blob, Mat& top_blob,
const Option& opt) const
{
int dims = bottom_blob.dims;
int positive_axis = axis < 0 ? dims + axis : axis;
if (dims == 1)
{ // ignore axis
int w = bottom_blob.w;
int out_w = w / 2;
top_blob.create(out_w, ... | subq $0x928, %rsp # imm = 0x928
movq %rdi, 0x428(%rsp)
movq %rsi, 0x420(%rsp)
movq %rdx, 0x418(%rsp)
movq %rcx, 0x410(%rsp)
movq 0x428(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x420(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x40c(%rsp)
cmpl $0x0, 0xd0(%rax)
jge 0x1de24b0
movq 0x100(%rsp), %rcx
movl 0x40c(%... | /Tencent[P]ncnn/src/layer/glu.cpp |
ncnn::Unfold::make_padding(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | void Unfold::make_padding(const Mat& bottom_blob, Mat& bottom_blob_bordered, const Option& opt) const
{
int w = bottom_blob.w;
int h = bottom_blob.h;
const int kernel_extent_w = dilation_w * (kernel_w - 1) + 1;
const int kernel_extent_h = dilation_h * (kernel_h - 1) + 1;
bottom_blob_bordered = bot... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
movq %rcx, 0x130(%rsp)
movq 0x148(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq 0x140(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x12c(%rsp)
movq 0x140(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x128(%rsp)
movl... | /Tencent[P]ncnn/src/layer/unfold.cpp |
ncnn::get_value_bounded(ncnn::Mat const&, int, int, int) | static float get_value_bounded(const Mat& image, int x, int y, int z)
{
return in_bounds(image, x, y, z) ? image.depth(z).row(y)[x] : 0.f;
} | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x80(%rsp), %rdi
movl 0x7c(%rsp), %esi
movl 0x78(%rsp), %edx
movl 0x74(%rsp), %ecx
callq 0x1df5780
movb $0x0, 0x27(%rsp)
testb $0x1, %al
jne 0x1df53c2
jmp 0x1df5534
movq 0x80(%rsp), %r... | /Tencent[P]ncnn/src/layer/gridsample.cpp |
ncnn::gridsample_nearest_apply_interpolation_p1(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_nearest_apply_interpolation_p1(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int outd = dst.d;
const int grid_size = outw * outh * outd;
#pragma omp parallel for nu... | subq $0x3a8, %rsp # imm = 0x3A8
movq %rdi, 0x1a8(%rsp)
movq %rsi, 0x1a0(%rsp)
movq %rdx, 0x198(%rsp)
movq %rcx, 0x190(%rsp)
movq 0x1a0(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x18c(%rsp)
movq 0x1a0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x188(%rsp)
movq 0x1a0(%rsp), %rax
movl 0x30(%rax), %eax
movl... | /Tencent[P]ncnn/src/layer/x86/gridsample_nearest_apply_interpolation.h |
ncnn::cubic_interp1d(float&, float&, float&, float&, float) | static inline void cubic_interp1d(float& coeffs0, float& coeffs1, float& coeffs2, float& coeffs3, float fx)
{
const float A = -0.75f;
float fx0 = fx + 1;
float fx1 = fx;
float fx2 = 1 - fx;
// float fx3 = 2 - fx;
coeffs0 = A * fx0 * fx0 * fx0 - 5 * A * fx0 * fx0 + 8 * A * fx0 - 4 * A;
coef... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movss %xmm0, -0x24(%rsp)
movss 0xacb66(%rip), %xmm0 # 0x1eada48
movss %xmm0, -0x28(%rsp)
movss 0x97134(%rip), %xmm0 # 0x1e98024
addss -0x24(%rsp), %xmm0
movss %xmm0, -0x2c(%rsp)
movss -0x24(%rsp), %xmm0
movss %xmm0, -0x30(%... | /Tencent[P]ncnn/src/layer/x86/gridsample_bicubic_apply_interpolation.h |
void ncnn::gridsample_2d_nearest_compute_blob<(ncnn::GridSample::PaddingMode)1, false>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int) | void gridsample_2d_nearest_compute_blob(const Mat& src, const Mat& grid, Mat& offset_value, int permute_fusion)
{
const int grid_size = grid.w * grid.h;
float* offset_ptr = offset_value.channel(0);
grid_sample_unormalize<align_corner> unormalize;
compute_coord<pd, align_corner> get_coord;
if (per... | subq $0x4f8, %rsp # imm = 0x4F8
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movl %ecx, 0x23c(%rsp)
movq 0x248(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0x248(%rsp), %rcx
imull 0x30(%rcx), %eax
movl %eax, 0x238(%rsp)
movq 0x240(%rsp), %rax
leaq 0x1e8(%rsp), %rcx
movq %rcx, 0x3a8(%rsp)
mo... | /Tencent[P]ncnn/src/layer/x86/gridsample_nearest_compute_blob.h |
void ncnn::gridsample_2d_nearest_compute_blob<(ncnn::GridSample::PaddingMode)2, false>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int) | void gridsample_2d_nearest_compute_blob(const Mat& src, const Mat& grid, Mat& offset_value, int permute_fusion)
{
const int grid_size = grid.w * grid.h;
float* offset_ptr = offset_value.channel(0);
grid_sample_unormalize<align_corner> unormalize;
compute_coord<pd, align_corner> get_coord;
if (per... | subq $0x4f8, %rsp # imm = 0x4F8
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movl %ecx, 0x23c(%rsp)
movq 0x248(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0x248(%rsp), %rcx
imull 0x30(%rcx), %eax
movl %eax, 0x238(%rsp)
movq 0x240(%rsp), %rax
leaq 0x1e8(%rsp), %rcx
movq %rcx, 0x3a8(%rsp)
mo... | /Tencent[P]ncnn/src/layer/x86/gridsample_nearest_compute_blob.h |
void ncnn::gridsample_2d_bicubic_compute_blob<(ncnn::GridSample::PaddingMode)1, true>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int) | void gridsample_2d_bicubic_compute_blob(const Mat& src, const Mat& grid, Mat& offset_value, int permute_fusion)
{
const int grid_size = grid.w * grid.h;
float* offset_value_ptr = offset_value.channel(0);
grid_sample_unormalize<align_corner> unormalize;
compute_coord<pd, align_corner> get_coord;
i... | subq $0x578, %rsp # imm = 0x578
movq %rdi, 0x2d0(%rsp)
movq %rsi, 0x2c8(%rsp)
movq %rdx, 0x2c0(%rsp)
movl %ecx, 0x2bc(%rsp)
movq 0x2c8(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0x2c8(%rsp), %rcx
imull 0x30(%rcx), %eax
movl %eax, 0x2b8(%rsp)
movq 0x2c0(%rsp), %rax
leaq 0x268(%rsp), %rcx
movq %rcx, 0x428(%rsp)
mo... | /Tencent[P]ncnn/src/layer/x86/gridsample_bicubic_compute_blob.h |
void ncnn::gridsample_3d_nearest_compute_blob<(ncnn::GridSample::PaddingMode)2, false>(ncnn::Mat const&, ncnn::Mat const&, ncnn::Mat&, int) | void gridsample_3d_nearest_compute_blob(const Mat& src, const Mat& grid, Mat& offset_value, int permute_fusion)
{
const int grid_size = grid.w * grid.h * grid.d;
float* offset_ptr = offset_value.channel(0);
grid_sample_unormalize<align_corner> unormalize;
compute_coord<pd, align_corner> get_coord;
... | subq $0x628, %rsp # imm = 0x628
movq %rdi, 0x2d8(%rsp)
movq %rsi, 0x2d0(%rsp)
movq %rdx, 0x2c8(%rsp)
movl %ecx, 0x2c4(%rsp)
movq 0x2d0(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0x2d0(%rsp), %rcx
imull 0x30(%rcx), %eax
movq 0x2d0(%rsp), %rcx
imull 0x34(%rcx), %eax
movl %eax, 0x2c0(%rsp)
movq 0x2c8(%rsp), %rax
le... | /Tencent[P]ncnn/src/layer/x86/gridsample_nearest_compute_blob.h |
ncnn::gridsample_2d_bilinear_apply_interpolation_p8(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_2d_bilinear_apply_interpolation_p8(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int grid_size = outw * outh;
#pragma omp parallel for num_threads(opt.num_threads)
... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xb20, %rsp # imm = 0xB20
movq %rdi, 0x438(%rsp)
movq %rsi, 0x430(%rsp)
movq %rdx, 0x428(%rsp)
movq %rcx, 0x420(%rsp)
movq 0x430(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x41c(%rsp)
movq 0x430(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x418(%rsp)
movq... | /Tencent[P]ncnn/src/layer/x86/gridsample_bilinear_apply_interpolation.h |
ncnn::gridsample_2d_bilinear_apply_interpolation_p4(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_2d_bilinear_apply_interpolation_p4(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int grid_size = outw * outh;
#pragma omp parallel for num_threads(opt.num_threads)
... | subq $0x778, %rsp # imm = 0x778
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq %rdx, 0x2b0(%rsp)
movq %rcx, 0x2a8(%rsp)
movq 0x2b8(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x2a4(%rsp)
movq 0x2b8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x2a0(%rsp)
movq 0x2b8(%rsp), %rax
movl 0x30(%rax), %eax
movl... | /Tencent[P]ncnn/src/layer/x86/gridsample_bilinear_apply_interpolation.h |
ncnn::gridsample_2d_bilinear_apply_interpolation_p1(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_2d_bilinear_apply_interpolation_p1(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int grid_size = outw * outh;
#pragma omp parallel for num_threads(opt.num_threads)
... | subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq %rdx, 0x1c8(%rsp)
movq %rcx, 0x1c0(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x1bc(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x30(%rax), %eax
movl... | /Tencent[P]ncnn/src/layer/x86/gridsample_bilinear_apply_interpolation.h |
ncnn::cubic_interp1d(float&, float&, float&, float&, float) | static inline void cubic_interp1d(float& coeffs0, float& coeffs1, float& coeffs2, float& coeffs3, float fx)
{
const float A = -0.75f;
float fx0 = fx + 1;
float fx1 = fx;
float fx2 = 1 - fx;
// float fx3 = 2 - fx;
coeffs0 = A * fx0 * fx0 * fx0 - 5 * A * fx0 * fx0 + 8 * A * fx0 - 4 * A;
coef... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
vmovss %xmm0, -0x24(%rsp)
vmovss 0x5beb6(%rip), %xmm0 # 0x1eada48
vmovss %xmm0, -0x28(%rsp)
vmovss 0x46484(%rip), %xmm0 # 0x1e98024
vaddss -0x24(%rsp), %xmm0, %xmm0
vmovss %xmm0, -0x2c(%rsp)
vmovss -0x24(%rsp), %xmm0
vmovss... | /Tencent[P]ncnn/src/layer/x86/gridsample_bicubic_apply_interpolation.h |
ncnn::gridsample_nearest_apply_interpolation_p8(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_nearest_apply_interpolation_p8(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int outd = dst.d;
const int grid_size = outw * outh * outd;
#pragma omp parallel for nu... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x4c0, %rsp # imm = 0x4C0
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq %rdx, 0x200(%rsp)
movq %rcx, 0x1f8(%rsp)
movq 0x208(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x1f4(%rsp)
movq 0x208(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1f0(%rsp)
movq... | /Tencent[P]ncnn/src/layer/x86/gridsample_nearest_apply_interpolation.h |
ncnn::gridsample_3d_bilinear_apply_interpolation_p8(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_3d_bilinear_apply_interpolation_p8(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int outd = dst.d;
const int grid_size = outw * outh * outd;
#pragma omp parallel fo... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x12a0, %rsp # imm = 0x12A0
movq %rdi, 0x698(%rsp)
movq %rsi, 0x690(%rsp)
movq %rdx, 0x688(%rsp)
movq %rcx, 0x680(%rsp)
movq 0x690(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x67c(%rsp)
movq 0x690(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x678(%rsp)
mov... | /Tencent[P]ncnn/src/layer/x86/gridsample_bilinear_apply_interpolation.h |
ncnn::gridsample_2d_bilinear_apply_interpolation_p1(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_2d_bilinear_apply_interpolation_p1(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int grid_size = outw * outh;
#pragma omp parallel for num_threads(opt.num_threads)
... | subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq %rdx, 0x1c8(%rsp)
movq %rcx, 0x1c0(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x1bc(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x30(%rax), %eax
movl... | /Tencent[P]ncnn/src/layer/x86/gridsample_bilinear_apply_interpolation.h |
ncnn::gridsample_2d_bilinear_apply_interpolation_p1(ncnn::Mat const&, ncnn::Mat&, ncnn::Mat const&, ncnn::Option const&) | static void gridsample_2d_bilinear_apply_interpolation_p1(const Mat& src, Mat& dst, const Mat& offset_value, const Option& opt)
{
const int channels = dst.c;
const int outw = dst.w;
const int outh = dst.h;
const int grid_size = outw * outh;
#pragma omp parallel for num_threads(opt.num_threads)
... | subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, 0x1d8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq %rdx, 0x1c8(%rsp)
movq %rcx, 0x1c0(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x1bc(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x30(%rax), %eax
movl... | /Tencent[P]ncnn/src/layer/x86/gridsample_bilinear_apply_interpolation.h |
ncnn::cubic_interp1d(float&, float&, float&, float&, float) | static inline void cubic_interp1d(float& coeffs0, float& coeffs1, float& coeffs2, float& coeffs3, float fx)
{
const float A = -0.75f;
float fx0 = fx + 1;
float fx1 = fx;
float fx2 = 1 - fx;
// float fx3 = 2 - fx;
coeffs0 = A * fx0 * fx0 * fx0 - 5 * A * fx0 * fx0 + 8 * A * fx0 - 4 * A;
coef... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
vmovss %xmm0, -0x24(%rsp)
vmovss 0x32db6(%rip), %xmm0 # 0x1eada48
vmovss %xmm0, -0x28(%rsp)
vmovss 0x1d384(%rip), %xmm0 # 0x1e98024
vaddss -0x24(%rsp), %xmm0, %xmm0
vmovss %xmm0, -0x2c(%rsp)
vmovss -0x24(%rsp), %xmm0
vmovss... | /Tencent[P]ncnn/src/layer/x86/gridsample_bicubic_apply_interpolation.h |
ncnn::CopyTo::resolve_copyto_offset(ncnn::Mat const&, int&, int&, int&, int&) const | void CopyTo::resolve_copyto_offset(const Mat& self_blob, int& _woffset, int& _hoffset, int& _doffset, int& _coffset) const
{
int w = self_blob.w;
int h = self_blob.h;
int d = self_blob.d;
int channels = self_blob.c;
int dims = self_blob.dims;
bool numpy_style_slice = !starts.empty();
if (nu... | subq $0x68, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, -0x50(%rsp)
movq 0x38(%rsp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x14(%rsp)
movq 0x38(%rsp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x10(%r... | /Tencent[P]ncnn/src/layer/copyto.cpp |
ncnn::Erf::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Erf::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;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* ptr =... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0xa4(%rsp)
movq 0xb0(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x9c(%rsp)
movl 0xa4(%rs... | /Tencent[P]ncnn/src/layer/erf.cpp |
ncnn::rmsnorm(float*, float const*, float, int, int) | static void rmsnorm(float* ptr, const float* gamma_ptr, float eps, int elemcount, int elempack)
{
const int size = elemcount * elempack;
#if __SSE2__
#if __AVX__
#if __AVX512F__
__m512 _rms_avx512 = _mm512_set1_ps(0.f);
#endif // __AVX512F__
__m256 _rms_avx = _mm256_set1_ps(0.f);
#endif // __AVX__
__m1... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xd00, %rsp # imm = 0xD00
movq %rdi, 0x2e8(%rsp)
movq %rsi, 0x2e0(%rsp)
vmovss %xmm0, 0x2dc(%rsp)
movl %edx, 0x2d8(%rsp)
movl %ecx, 0x2d4(%rsp)
movl 0x2d8(%rsp), %eax
movl 0x2d4(%rsp), %ecx
imull %ecx, %eax
movl %eax, 0x2d0(%rsp)
movl $0x0, 0x2fc(%rsp)
vmovs... | /Tencent[P]ncnn/build_O0/src/layer/x86/rmsnorm_x86_fma.cpp |
ncnn::InverseSpectrogram::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int InverseSpectrogram::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// https://github.com/librosa/librosa/blob/main/librosa/core/spectrum.py#L630
// TODO custom window
// TODO output length
const int frames = bottom_blob.h;
const int freqs = bottom_blob.c;
// asse... | subq $0xdd8, %rsp # imm = 0xDD8
movq %rdi, 0x5d8(%rsp)
movq %rsi, 0x5d0(%rsp)
movq %rdx, 0x5c8(%rsp)
movq %rcx, 0x5c0(%rsp)
movq 0x5d8(%rsp), %rax
movq %rax, 0x2f8(%rsp)
movq 0x5d0(%rsp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x5bc(%rsp)
movq 0x5d0(%rsp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x5b8(%rsp)
mov... | /Tencent[P]ncnn/src/layer/inversespectrogram.cpp |
ncnn::eval_list_expression(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<int, std::allocator<int>>&) | int eval_list_expression(const std::string& expr, const std::vector<Mat>& blobs, std::vector<int>& outlist)
{
// /(0w,2),*(0h,2),0c
// split by , ( )
//
// /
// 0w
// 2
// -------------------
// *
// 0h
// 2
// -------------------
... | subq $0x518, %rsp # imm = 0x518
movq %rdi, 0x3e0(%rsp)
movq %rsi, 0x3d8(%rsp)
movq %rdx, 0x3d0(%rsp)
leaq 0x3b8(%rsp), %rdi
callq 0x1caa700
leaq 0x398(%rsp), %rdi
callq 0x245e0
movq $0x0, 0x390(%rsp)
movq 0x390(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x3e0(%rsp), %rdi
callq 0x24230
movq %rax, %rcx
movq 0x190... | /Tencent[P]ncnn/src/expression.cpp |
void Eigen::internal::resize_if_allowed<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, double, double>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::internal::assign_op<double, double> const&) | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbx
cmpq %r14, 0x8(%rdi)
jne 0x49ead
movq %rbx, %rax
movq %r14, %rcx
cmpq %rbx, 0x10(%r15)
je 0x49ec3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x46820
movq 0x8(%r15), %rcx
movq 0x10... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>, 1, -1, false> const>>, 0, 0>::run(Eigen::internal::redux_evaluator<E... | Scalar run(const Derived &mat, const Func& func)
{
eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
Scalar res;
res = mat.coeffByOuterInner(0, 0);
for(Index i = 1; i < mat.innerSize(); ++i)
res = func(res, mat.coeffByOuterInner(0, i));
for(Index i = 1; i < mat.o... | pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jle 0x4b6c1
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movsd (%rdx), %xmm0
andpd 0x17a0b(%rip), %xmm0 # 0x630a0
decq %rax
leaq (%rdx,%rcx,8), %rdx
shlq $0x3, %rcx
movapd 0x179f8(%rip), %xmm1 # 0x630a0
subq $0x1, %rax
jb 0x4b6b... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/Redux.h |
Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 1, -1, false> const>>, 0, 0>::run(Eigen::internal::redux_evaluator... | Scalar run(const Derived &mat, const Func& func)
{
eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
Scalar res;
res = mat.coeffByOuterInner(0, 0);
for(Index i = 1; i < mat.innerSize(); ++i)
res = func(res, mat.coeffByOuterInner(0, i));
for(Index i = 1; i < mat.o... | pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jle 0x4d207
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movsd (%rdx), %xmm0
mulsd %xmm0, %xmm0
decq %rax
leaq (%rdx,%rcx,8), %rdx
shlq $0x3, %rcx
subq $0x1, %rax
jb 0x4d205
movsd (%rdx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
ad... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/Redux.h |
Eigen::internal::gemm_blocking_space<0, double, double, -1, -1, -1, 4, false>::gemm_blocking_space(long, long, long, long, bool) | gemm_blocking_space(Index rows, Index cols, Index depth, Index num_threads, bool l3_blocking)
{
this->m_mc = Transpose ? cols : rows;
this->m_nc = Transpose ? rows : cols;
this->m_kc = depth;
if(l3_blocking)
{
computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_k... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %rsi
movq %rax, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
movq %rcx, 0x20(%rbx)
testl %r9d, %r9d
je 0x4d59f
leaq 0x18(%rbx), %rdx
jmp 0x4d5a9
leaq -0x10(%rbp), %rax
movq %rdx... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::queryCacheSizes_intel_direct(int&, int&, int&) | inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3)
{
int abcd[4];
l1 = l2 = l3 = 0;
int cache_id = 0;
int cache_type = 0;
do {
abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
EIGEN_CPUID(abcd,0x4,cache_id);
cache_type = (abcd[0] & 0x0F) >> 0;
if(cache_type==1||cache_type==3) // da... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r8
andl $0x0, (%rdx)
andl $0x0, (%rsi)
andl $0x0, (%rdi)
xorl %r10d, %r10d
movl $0x4, %r9d
movl %r9d, %eax
movl %r10d, %ecx
xchgq %rbx, %r11
cpuid
xchgq %rbx, %r11
movl %eax, %edx
andl $0xd, %edx
cmpl $0x1, %edx
jne 0x4e29c
movl %eax, %ebx
shrl $0x5, %ebx
and... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/util/Memory.h |
Eigen::selfadjoint_product_selector<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 1, false>::run(Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, ... | static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
{
typedef typename MatrixType::Scalar Scalar;
typedef internal::blas_traits<OtherType> OtherBlasTraits;
typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
typedef typename internal... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdx), %xmm0
leaq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rdi), %r15
movq 0x10(%rsi), %r12
leaq -0x68(%rbp), %r13
pushq $0x1
popq %r8
movq %r13, %rdi
movq %r15, %rsi
movq %r... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/products/SelfadjointProduct.h |
void Eigen::TriangularBase<Eigen::SelfAdjointView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>>::evalToLazy<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>&) const | void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other) const
{
other.derived().resize(this->rows(), this->cols());
internal::call_triangular_assignment_loop<Derived::Mode,(Derived::Mode&SelfAdjoint)==0 /* SetOpposite */>(other.derived(), derived().nestedExpression());
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x46820
movq (%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x46b20
| /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/TriangularMatrix.h |
Eigen::internal::gemm_pack_rhs<double, long, Eigen::internal::blas_data_mapper<double, long, 0, 0>, 4, 0, false, true>::operator()(double*, Eigen::internal::blas_data_mapper<double, long, 0, 0> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
EIGEN_UNUSED_VARIABLE(stride);
EIGEN_UNUSED_VARIABL... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rax
subq %rcx, %rax
movq %rax, -0x50(%rbp)
jl 0x51616
movq 0x10(%rbp), %r10
cmpq %r9, %r10
jg 0x51616
movq %rdx, %r11
pushq $0x4
popq %rdi
movq %r8, -0x48(%rbp)
movq %r8, %rax
cqto
idivq %rdi
leaq (,%rax,4), %r... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const> const>::CwiseBinaryOp(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Cwise... | CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
: m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
{
EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
// require the sizes to match
EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
... | movq %rsi, (%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x8(%rdi)
movsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x18(%rdi)
movq 0x8(%rsi), %rax
cmpq (%rdx), %rax
jne 0x5243a
movq 0x10(%rsi), %rax
cmpq 0x8(%rdx), %rax
jne 0x5243a
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x163c3(%rip), %rdi # 0x68808
leaq 0x163f5(%rip), %rsi # 0... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/CwiseBinaryOp.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Diagonal<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Diagonal<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0> const&, Eigen::internal... | 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rcx
leaq -0x68(%rbp), %r15
movq %rcx, 0x8(%r15)
movq 0x8(%rax), %rax
movq %rax, 0x10(%r15)
callq 0x46f70
movq (%r14), %rax
leaq -0x28(%rbp), %rcx
movq %rax, (%rcx)
leaq -0x48(%rbp... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::Assignment<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::HouseholderSequence<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1>, Eigen::internal::assign_op<double, double>, Eigen::internal::EigenBase2EigenBase, void>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, E... | void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
eigen_assert(... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rax), %rdx
cmpq %rdx, 0x8(%rdi)
jne 0x5523a
cmpq %rdx, 0x10(%rbx)
jne 0x5523a
movq %rdx, %rax
movq %rdx, %rcx
jmp 0x55254
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x46820
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Diagonal<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::assign_op<double, double>>(Eigen::Diagonal<Eigen::Matrix<double, -1, -1, 0, -1, -1>,... | 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movsd 0x10(%rsi), %xmm0
leaq -0x28(%rbp), %r15
movsd %xmm0, (%r15)
callq 0x46160
movq (%r14), %rax
movq (%rax), %rcx
leaq -0x68(%rbp), %rdx
movq %rcx, 0x8(%rdx)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdx)
leaq -0... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
void Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, 1, true>>, Eigen::internal::evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::s... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void assignPacket(Index index)
{
m_functor.template assignPacket<StoreMode>(&m_dst.coeffRef(index), m_src.template packet<LoadMode,PacketType>(index));
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq (%rax), %rax
movupd 0x8(%rcx), %xmm0
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
movq 0x18(%rcx), %rcx
movupd (%rcx,%rsi,8), %xmm1
mulpd %xmm0, %xmm1
movapd (%rax,%rsi,8), %xmm0
subpd %xmm1, %xmm0
movapd %xmm0, (%rax,%rsi,8)
popq %rbp
retq
| /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
Eigen::Matrix<double, -1, 1, 0, -1, 1>& Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>>::_set_noalias<Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Map... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
{
// I don't think we need this resize call since the lazyAssign will anyways resize
// and lazyAssign will be called by the assign selector.
//_resize_to_match(other);
// the 'false' below... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x9(%rbp), %rdx
callq 0x44be0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/PlainObjectBase.h |
void Eigen::internal::unaligned_dense_assignment_loop<false>::run<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>>, Eigen::internal::evaluator<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>>, Eigen::inte... | EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void run(Kernel &kernel,
Index start,
Index end)
#endif
{
for (Index index = start; index < end; ++index)
kernel.assignCoeff(index);
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rdx, %rsi
jge 0x58d3f
movq (%rax), %rdi
movq (%rcx), %r8
movsd (%rdi,%rsi,8), %xmm0
movsd (%r8,%rsi,8), %xmm1
movsd %xmm1, (%rdi,%rsi,8)
movsd %xmm0, (%r8,%rsi,8)
incq %rsi
jmp 0x58d19
popq %rbp
retq
nop
| /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::gemm_pack_rhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 0>, 4, 0, false, true>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 0> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
EIGEN_UNUSED_VARIABLE(stride);
EIGEN_UNUSED_VARIABL... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rax
subq %rcx, %rax
movq %rax, -0x50(%rbp)
jl 0x5a602
movq 0x10(%rbp), %r10
cmpq %r9, %r10
jg 0x5a602
movq %rdx, %r11
pushq $0x4
popq %rdi
movq %r8, -0x48(%rbp)
movq %r8, %rax
cqto
idivq %rdi
leaq (,%rax,4), %r... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::internal::Assignment<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Product<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, -1,... | static EIGEN_STRONG_INLINE
void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
// FIXME shall we handle nested_eva... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0x8(%rax), %rsi
movq 0x10(%rdx), %rax
cmpq %rsi, 0x8(%rdi)
jne 0x5b8d4
cmpq %rax, 0x10(%r14)
je 0x5b8e3
movq %r14, %rdi
movq %rax, %rdx
callq 0x46820
movq 0x8(%rbx), %rdx
movq %r14, %rdi
movq %rb... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/ProductEvaluators.h |
Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::evaluator<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>>, Eigen::internal::div_assign_... | void run(Kernel &kernel)
{
const Index size = kernel.size();
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
packetSize = unpacket_traits<PacketType>::size,
dstIsAli... | pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rcx
movabsq $0x2, %rsi
movq %rcx, %rax
cqto
idivq %rsi
addq %rax, %rax
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x5cd25
movq (%rdi), %rsi
movq 0x8(%rdi), %r8
movq (%rsi), %rsi
movsd (%r8), %xmm0
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
movapd (%rsi... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Transpose<E... | EIGEN_STRONG_INLINE run(Kernel &kernel)
{
for(Index outer = 0; outer < kernel.outerSize(); ++outer) {
for(Index inner = 0; inner < kernel.innerSize(); ++inner) {
kernel.assignCoeffByOuterInner(outer, inner);
}
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %r14d, %r14d
cmpq 0x10(%rax), %r14
jge 0x60adb
xorl %r15d, %r15d
cmpq 0x8(%rax), %r15
jge 0x60ad6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x43840
incq %r15
movq 0x18(%rbx), %rax
jmp 0x60ab9
in... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
Eigen::Matrix<double, -1, -1, 0, -1, -1>& Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::_set_noalias<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>>(Eigen::DenseBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen... | EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE Derived& _set_noalias(const DenseBase<OtherDerived>& other)
{
// I don't think we need this resize call since the lazyAssign will anyways resize
// and lazyAssign will be called by the assign selector.
//_resize_to_match(other);
// the 'false' below... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x9(%rbp), %rdx
callq 0x46cf0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/PlainObjectBase.h |
void Eigen::internal::resize_if_allowed<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, double, double>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<doubl... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %r14
movq 0x10(%rcx), %rbx
cmpq %r14, 0x8(%rdi)
jne 0x615c9
movq %rbx, %rax
movq %r14, %rcx
cmpq %rbx, 0x10(%r15)
je 0x615df
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
double vector[2] const Eigen::internal::product_evaluator<Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, 8, Eigen::DenseShape, Eigen::DenseShape, double, double>::packet<0, double vector[2]>(long, long) const | const PacketType packet(Index row, Index col) const
{
PacketType res;
typedef etor_product_packet_impl<bool(int(Flags)&RowMajorBit) ? RowMajor : ColMajor,
Unroll ? int(InnerSize) : Dynamic,
LhsEtorType, RhsEtorType, PacketType, LoadMode... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rdi), %rax
movq 0x30(%rdi), %r8
leaq 0x20(%rdi), %rcx
leaq -0x20(%rbp), %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movq %rbx, %r9
callq 0x448e0
movaps (%rbx), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/ProductEvaluators.h |
void Eigen::internal::resize_if_allowed<Eigen::Matrix<double, -1, -1, 1, -1, -1>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 1, -1, -1>>, double, double>(Eigen::Matrix<double, -1, -1, 1, -1, -1>&, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Ei... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows(... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rsi), %r14
movq 0x8(%rsi), %rbx
cmpq %r14, 0x8(%rdi)
jne 0x62299
movq %rbx, %rax
movq %r14, %rcx
cmpq %rbx, 0x10(%r15)
je 0x622af
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x46180
movq 0x8(%r15), %rcx
movq 0x10(%r1... | /MacWen[P]CMAES/include/../3rdParty/Eigen/src/Core/AssignEvaluator.h |
main | int main(int argc, char** argv)
{
Slot* slots;
GLFWmonitor* monitor = NULL;
int ch, i, width, height, count = 1;
setlocale(LC_ALL, "");
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
printf("Library initialized\n");
glfwSetMonitorCallback(monitor_... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x6, %edi
leaq 0x3fe3d(%rip), %rsi # 0x53971
callq 0x138e0
leaq 0x5b0(%rip), %rdi # 0x140f0
callq 0x1af30
callq 0x1aa30
cmpl $0x0, %eax
jne 0x13b59... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
mouse_button_callback | static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
{
Slot* slot = glfwGetWindowUserPointer(window);
printf("%08x to %i at %0.3f: Mouse button %i (%s) (with%s) was %s\n",
counter++, slot->number, glfwGetTime(), button,
get_button_name(button),
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x229d0
movq %rax, -0x20(%rbp)
movl 0x4aaa8(%rip), %eax # 0x5f230
movl %eax, -0x48(%rbp)
addl $0x1, %eax
movl %eax, 0x4aa9c(%rip) # 0x5f230
movq -0x20... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
drop_callback | static void drop_callback(GLFWwindow* window, int count, const char** paths)
{
int i;
Slot* slot = glfwGetWindowUserPointer(window);
printf("%08x to %i at %0.3f: Drop input\n",
counter++, slot->number, glfwGetTime());
for (i = 0; i < count; i++)
printf(" %i: \"%s\"\n", i, paths[i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x229d0
movq %rax, -0x28(%rbp)
movl 0x4a56a(%rip), %eax # 0x5f230
movl %eax, -0x30(%rbp)
addl $0x1, %eax
movl %eax, 0x4a55e(%rip) # 0x5f230
movq -0x28(%rbp), %rax
movl 0x8(%... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
get_button_name | static const char* get_button_name(int button)
{
switch (button)
{
case GLFW_MOUSE_BUTTON_LEFT:
return "left";
case GLFW_MOUSE_BUTTON_RIGHT:
return "right";
case GLFW_MOUSE_BUTTON_MIDDLE:
return "middle";
default:
{
static c... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x14d6b
jmp 0x14d57
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x14d78
jmp 0x14d61
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x14d85
jmp 0x14d92
leaq 0x3ed77(%rip), %rax # 0x53ae9
movq %... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
get_mods_name | static const char* get_mods_name(int mods)
{
static char name[512];
if (mods == 0)
return " no mods";
name[0] = '\0';
if (mods & GLFW_MOD_SHIFT)
strcat(name, " shift");
if (mods & GLFW_MOD_CONTROL)
strcat(name, " control");
if (mods & GLFW_MOD_ALT)
strcat(name,... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x14df1
leaq 0x1fae7(%rip), %rax # 0x348cf
movq %rax, -0x8(%rbp)
jmp 0x14eb7
movb $0x0, 0x4a458(%rip) # 0x5f250
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14e16
leaq 0x4a446(%rip), %rdi # 0x5f250
leaq... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
get_action_name | static const char* get_action_name(int action)
{
switch (action)
{
case GLFW_PRESS:
return "pressed";
case GLFW_RELEASE:
return "released";
case GLFW_REPEAT:
return "repeated";
}
return "caused unknown action";
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x14f04
jmp 0x14ee3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x14ef7
jmp 0x14eed
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x14f11
jmp 0x14f1e
leaq 0x1fa0f(%rip), %rax # 0x3490d
movq %rax, -0x8(%rbp)
j... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
get_key_name | static const char* get_key_name(int key)
{
switch (key)
{
// Printable keys
case GLFW_KEY_A: return "A";
case GLFW_KEY_B: return "B";
case GLFW_KEY_C: return "C";
case GLFW_KEY_D: return "D";
case GLFW_KEY_E: ... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x20, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x13c, %eax # imm = 0x13C
ja 0x156c7
movq -0x18(%rbp), %rax
leaq 0x1f0ab(%rip), %rcx # 0x34004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1fb85(%rip), %r... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
get_character_string | static const char* get_character_string(int codepoint)
{
// This assumes UTF-8, which is stupid
static char result[6 + 1];
int length = wctomb(result, codepoint);
if (length == -1)
length = 0;
result[length] = '\0';
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x49d5b(%rip), %rdi # 0x5f450
callq 0x13790
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x1570a
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x49d3b(%rip), %rax # 0x5f450
movb $0x0, (%rax,%rcx)
leaq 0x49d30(%... | /Konf[P]LearnOpenGL-CLion/glfw/tests/events.c |
getopt | int getopt(int argc, char* const argv[], const char* optstring) {
int optchar = -1;
const char* optdecl = NULL;
optarg = NULL;
opterr = 0;
optopt = 0;
/* Unspecified, but we need it to avoid overrunning the argv bounds. */
if (optind >= argc)
goto no_more_optchars;
/* If, when getopt() is called ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x28(%rbp)
movq $0x0, 0x49cfb(%rip) # 0x5f458
movl $0x0, 0x49cf9(%rip) # 0x5f460
movl $0x0, 0x49cf3(%rip) # 0x5f464
movl 0x48d99(%rip), %ea... | /Konf[P]LearnOpenGL-CLion/glfw/deps/getopt.c |
gladLoadGLLoader | int gladLoadGLLoader(GLADloadproc load) {
GLVersion.major = 0; GLVersion.minor = 0;
glGetString = (PFNGLGETSTRINGPROC)load("glGetString");
if(glGetString == NULL) return 0;
if(glGetString(GL_VERSION) == NULL) return 0;
find_coreGL();
load_GL_VERSION_1_0(load);
load_GL_VERSION_1_1(load);
load_GL_VERSION_1_2(load... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, 0x4983a(%rip) # 0x5f470
movl $0x0, 0x49834(%rip) # 0x5f474
leaq 0x1f176(%rip), %rdi # 0x34dbd
callq *-0x10(%rbp)
movq %rax, 0x49827(%rip) # 0x5f478
cmpq $0x0, 0x4981f(%rip) # 0x5f478
jne 0x15c67
movl $0x0, -0x4(%rbp)
jmp 0... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
find_coreGL | static void find_coreGL(void) {
/* Thank you @elmindreda
* https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176
* https://github.com/glfw/glfw/blob/master/src/context.c#L36
*/
int i, major, minor;
const char* version;
const char* prefixes[] = {
"OpenGL ES-CM "... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x47fa1(%rip), %rax # 0x5dd00
movq %rax, -0x40(%rbp)
movq 0x47f9e(%rip), %rax # 0x5dd08
movq %rax, -0x38(%rbp)
movq 0x47f9b(%rip), %rax # 0x5dd10
movq %rax, -0x30(%rbp)
movq 0x47f98(%rip), %rax # 0x5dd18
movq %rax, -0x28(%rbp)
movl $0x1f02, %edi ... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_1_1 | static void load_GL_VERSION_1_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_1) return;
glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays");
glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements");
glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
glad_glPolygonOffset = (PFNGLPO... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x47fc1(%rip) # 0x5f484
jne 0x174ca
jmp 0x176c8
leaq 0x1e7c0(%rip), %rdi # 0x35c91
callq *-0x8(%rbp)
movq %rax, 0x482ad(%rip) # 0x5f788
leaq 0x1e7bc(%rip), %rdi # 0x35c9e
callq *-0x8(%rbp)
movq %rax, 0x48914(%rip) # 0x5fe00... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_1_4 | static void load_GL_VERSION_1_4(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_4) return;
glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate");
glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays");
glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMulti... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x47a0d(%rip) # 0x5f490
jne 0x17a8a
jmp 0x17da9
leaq 0x1e7c3(%rip), %rdi # 0x36254
callq *-0x8(%rbp)
movq %rax, 0x47b65(%rip) # 0x5f600
leaq 0x1e7c6(%rip), %rdi # 0x36268
callq *-0x8(%rbp)
movq %rax, 0x48c0c(%rip) # 0x606b8... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_1_5 | static void load_GL_VERSION_1_5(GLADloadproc load) {
if(!GLAD_GL_VERSION_1_5) return;
glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries");
glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries");
glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery");
glad_glBeginQuery = (PFNGLBEGINQUERYPROC... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x476d1(%rip) # 0x5f494
jne 0x17dca
jmp 0x17f0d
leaq 0x1e7a6(%rip), %rdi # 0x36577
callq *-0x8(%rbp)
movq %rax, 0x47d6d(%rip) # 0x5fb48
leaq 0x1e7a2(%rip), %rdi # 0x36584
callq *-0x8(%rbp)
movq %rax, 0x48194(%rip) # 0x5ff80... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_2_1 | static void load_GL_VERSION_2_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_2_1) return;
glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv");
glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv");
glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x46f19(%rip) # 0x5f49c
jne 0x18587
jmp 0x185ed
leaq 0x1e742(%rip), %rdi # 0x36cd0
callq *-0x8(%rbp)
movq %rax, 0x47b48(%rip) # 0x600e0
leaq 0x1e746(%rip), %rdi # 0x36ce5
callq *-0x8(%rbp)
movq %rax, 0x47097(%rip) # 0x5f640... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_3_0 | static void load_GL_VERSION_3_0(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_0) return;
glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski");
glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v");
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v");
glad_glEnablei = (PFNG... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x46e8d(%rip) # 0x5f4a0
jne 0x1861a
jmp 0x18bae
leaq 0x1e72d(%rip), %rdi # 0x36d4e
callq *-0x8(%rbp)
movq %rax, 0x470c5(%rip) # 0x5f6f0
leaq 0x1e729(%rip), %rdi # 0x36d5b
callq *-0x8(%rbp)
movq %rax, 0x4832c(%rip) # 0x60968... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_3_1 | static void load_GL_VERSION_3_1(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_1) return;
glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced");
glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced");
glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load(... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x468d1(%rip) # 0x5f4a4
jne 0x18bda
jmp 0x18cd9
leaq 0x1e7c5(%rip), %rdi # 0x373a6
callq *-0x8(%rbp)
movq %rax, 0x47565(%rip) # 0x60150
leaq 0x1e7ca(%rip), %rdi # 0x373bc
callq *-0x8(%rbp)
movq %rax, 0x46dd4(%rip) # 0x5f9d0... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_VERSION_3_2 | static void load_GL_VERSION_3_2(GLADloadproc load) {
if(!GLAD_GL_VERSION_3_2) return;
glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex");
glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex");
glad_glDrawElemen... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x467b5(%rip) # 0x5f4a8
jne 0x18cfa
jmp 0x18e3d
leaq 0x1e7af(%rip), %rdi # 0x374b0
callq *-0x8(%rbp)
movq %rax, 0x46d3d(%rip) # 0x5fa48
leaq 0x1e7b7(%rip), %rdi # 0x374c9
callq *-0x8(%rbp)
movq %rax, 0x46914(%rip) # 0x5f630... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
find_extensionsGL | static int find_extensionsGL(void) {
if (!get_exts()) return 0;
GLAD_GL_ARB_multisample = has_ext("GL_ARB_multisample");
GLAD_GL_ARB_robustness = has_ext("GL_ARB_robustness");
GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
free_exts();
return 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x19210
cmpl $0x0, %eax
jne 0x18e6b
movl $0x0, -0x4(%rbp)
jmp 0x18ead
leaq 0x1e7b2(%rip), %rdi # 0x37624
callq 0x192e0
movl %eax, 0x47b03(%rip) # 0x60980
leaq 0x1e7b3(%rip), %rdi # 0x37637
callq 0x192e0
movl %eax, 0x47aed(%rip) # 0x6097c
leaq 0x1e7b3(%ri... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
load_GL_ARB_robustness | static void load_GL_ARB_robustness(GLADloadproc load) {
if(!GLAD_GL_ARB_robustness) return;
glad_glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC)load("glGetGraphicsResetStatusARB");
glad_glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC)load("glGetnTexImageARB");
glad_glReadnPixelsARB = (PFNGLREADNPIX... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x47a79(%rip) # 0x6097c
jne 0x18f0a
jmp 0x1905e
leaq 0x1e759(%rip), %rdi # 0x3766a
callq *-0x8(%rbp)
movq %rax, 0x47a75(%rip) # 0x60990
leaq 0x1e764(%rip), %rdi # 0x37686
callq *-0x8(%rbp)
movq %rax, 0x47a6c(%rip) # 0x60998... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
get_exts | static int get_exts(void) {
#ifdef _GLAD_IS_SOME_NEW_VERSION
if(max_loaded_major < 3) {
#endif
exts = (const char *)glGetString(GL_EXTENSIONS);
#ifdef _GLAD_IS_SOME_NEW_VERSION
} else {
int index;
num_exts_i = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
if (num_ext... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x3, 0x478b9(%rip) # 0x60ad8
jge 0x19238
movl $0x1f03, %edi # imm = 0x1F03
callq *0x4624c(%rip) # 0x5f478
movq %rax, 0x478ad(%rip) # 0x60ae0
jmp 0x192d0
movl $0x0, 0x478a6(%rip) # 0x60ae8
movl $0x821d, %edi # imm = 0x821D
leaq 0x... | /Konf[P]LearnOpenGL-CLion/glfw/deps/glad.c |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->share)
{
if (ctxconfig->client == GLFW_NO_API ||
ctxconfig->share->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return GLFW_FALSE;
}... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1948f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x19471
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x1f0(%rax)
jne 0x1948d
movl $0x1000a, %edi # imm = 0x1000A
xorl %eax, %eax
movl... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwChooseFBConfig | const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
const _GLFWfbconfig* alternatives,
unsigned int count)
{
unsigned int i;
unsigned int missing, leastMissing = UINT_MAX;
unsigned int colorDiff, leastColorD... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x40(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwRefreshContextAttribs | GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig)
{
int i;
_GLFWwindow* previous;
const char* version;
const char* prefixes[] =
{
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x44196(%rip), %rax # 0x5dd20
movq %rax, -0x50(%rbp)
movq 0x44193(%rip), %rax # 0x5dd28
movq %rax, -0x48(%rbp)
movq 0x44190(%rip), %rax # 0x5dd30
movq %rax, -0x40(%rbp)
movq 0x4418d(%rip), %rax # 0x5dd38
movq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwGetKeyName | GLFWAPI const char* glfwGetKeyName(int key, int scancode)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (key != GLFW_KEY_UNKNOWN)
{
if (key != GLFW_KEY_KP_EQUAL &&
(key < GLFW_KEY_KP_0 || key > GLFW_KEY_KP_ADD) &&
(key < GLFW_KEY_APOSTROPHE || key > GLFW_KEY_WORLD_2))
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
leaq 0x45013(%rip), %rax # 0x60af8
cmpl $0x0, (%rax)
jne 0x1bb04
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x1a780
movq $0x0, -0x8(%rbp)
jmp 0x1bb55
cmpl $-0x1, -0xc(%rbp)... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1bc00
jmp 0x1bc1f
leaq 0x1c0d5(%rip), %rdi # 0x37cdc
leaq 0x376e2(%rip), %rsi # 0x532f0
movl $0x255, %edx # imm = 0x255
leaq 0x377cc(%rip... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Inval... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1bce0
jmp 0x1bcff
leaq 0x1bff5(%rip), %rdi # 0x37cdc
leaq 0x37602(%rip), %rsi # 0x532f0
movl $0x26c, %edx # imm = 0x26C
leaq 0x3770e(%rip... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwHideWindow | GLFWAPI void glfwHideWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformHideWindow(window);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x221fd
jmp 0x2221c
leaq 0x15ad8(%rip), %rdi # 0x37cdc
leaq 0x32543(%rip), %rsi # 0x5474e
movl $0x306, %edx # imm = 0x306
leaq 0x32b54(%rip), %rcx # 0x54d6b
cal... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwGetWindowAttrib | GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (attrib)
{
case GLFW_FOCUSED:
return _glfwPlatformWindowFocused(window);
case GLFW_ICONIFIED:
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x222f0
jmp 0x2230f
leaq 0x159e5(%rip), %rdi # 0x37cdc
leaq 0x32450(%rip), %rsi # 0x5474e
movl $0x31d, %edx # imm = 0x31D
leaq 0x32aa6(%rip... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowAttrib | GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
value = value ? GLFW_TRUE : GLFW_FALSE;
if (attrib == GLFW_AUTO_ICONIFY)
window->autoIconify = value;
else if (attri... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22633
jmp 0x22652
leaq 0x156a2(%rip), %rdi # 0x37cdc
leaq 0x3210d(%rip), %rsi # 0x5474e
movl $0x356, %edx # imm = 0x3... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowMonitor | GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
GLFWmonitor* mh,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
_GLFWwindow* window = (_GLFWwindow*) wh;
_GLFWm... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je ... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwPlatformInit | int _glfwPlatformInit(void)
{
#if !defined(X_HAVE_UTF8_STRING)
// HACK: If the current locale is "C" and the Xlib UTF-8 functions are
// unavailable, apply the environment's locale in the hope that it's
// both available and not "C"
// This is done because the "C" locale breaks wide ch... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x136f0
callq 0x135c0
xorl %eax, %eax
movl %eax, %edi
callq 0x13340
movq %rax, %rcx
leaq 0x3d683(%rip), %rax # 0x60af8
movq %rcx, 0x1feb8(%rax)
leaq 0x3d675(%rip), %rax # 0x60af8
cmpq $0x0, 0x1feb8(%rax)
jne 0x234dc
leaq 0x31ebb(%rip), %rdi # 0x5534f
callq 0... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
getSystemContentScale | static void getSystemContentScale(float* xscale, float* yscale)
{
// NOTE: Default to the display-wide DPI as we don't currently have a policy
// for which monitor a window is considered to be on
float xdpi = DisplayWidth(_glfw.x11.display, _glfw.x11.screen) *
25.4f / DisplayWidthMM(_glfw.x11.... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3d471(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rax
movq 0xe8(%rax), %rax
leaq 0x3d45c(%rip), %rcx # 0x60af8
movslq 0x1fec0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
cvtsi2ssl 0x18(%rax), %xmm0
movss 0x31bc5(%rip)... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
initExtensions | static GLFWbool initExtensions(void)
{
_glfw.x11.vidmode.handle = _glfw_dlopen("libXxf86vm.so.1");
if (_glfw.x11.vidmode.handle)
{
_glfw.x11.vidmode.QueryExtension = (PFN_XF86VidModeQueryExtension)
_glfw_dlsym(_glfw.x11.vidmode.handle, "XF86VidModeQueryExtension");
_glfw.x11.vidm... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x31b8e(%rip), %rdi # 0x553dd
movl $0x1, %esi
callq 0x13510
movq %rax, %rcx
leaq 0x3d295(%rip), %rax # 0x60af8
movq %rcx, 0x206b8(%rax)
leaq 0x3d287(%rip), %rax # 0x60af8
cmpq $0x0, 0x206b8(%rax)
je 0x23978
leaq 0x3d272(%rip), %rax # 0x60af8
movq 0x206b8(... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
createHelperWindow | static Window createHelperWindow(void)
{
XSetWindowAttributes wa;
wa.event_mask = PropertyChangeMask;
return XCreateWindow(_glfw.x11.display, _glfw.x11.root,
0, 0, 1, 1, 0, 0,
InputOnly,
DefaultVisual(_glfw.x11.display, _glfw.x11.sc... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq $0x400000, -0x28(%rbp) # imm = 0x400000
leaq 0x3c08e(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rdi
leaq 0x3c080(%rip), %rax # 0x60af8
movq 0x1fec8(%rax), %rsi
leaq 0x3c072(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rax
movq 0xe8(%rax), %rax
leaq 0x3c05d(%ri... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
hasUsableInputMethodStyle | static GLFWbool hasUsableInputMethodStyle(void)
{
unsigned int i;
GLFWbool found = GLFW_FALSE;
XIMStyles* styles = NULL;
if (XGetIMValues(_glfw.x11.im, XNQueryInputStyle, &styles, NULL) != NULL)
return GLFW_FALSE;
for (i = 0; i < styles->count_styles; i++)
{
if (styles->suppo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x3bf7a(%rip), %rax # 0x60af8
movq 0x1fef0(%rax), %rdi
leaq 0x30f3e(%rip), %rsi # 0x55aca
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x131e0
cmpq $0x0, %rax
je 0x24baa
movl $0x0, -0x4(%... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.c |
glfwPlatformGetVideoModes | GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
{
GLFWvidmode* result;
*count = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
int i, j;
XRRScreenResources* sr;
XRRCrtcInfo* ci;
XRROutputInfo* oi;
sr = XRRGetScr... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq 0x394e7(%rip), %rax # 0x60af8
cmpl $0x0, 0x20558(%rax)
je 0x27802
leaq 0x394d3(%rip), %rax # 0x60af8
cmpl $0x0, 0x2057c(%rax)
jne 0x27802
leaq 0x394bf(%rip), %rax # 0x60af8
... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwPushSelectionToManagerX11 | void _glfwPushSelectionToManagerX11(void)
{
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD_MANAGER,
_glfw.x11.SAVE_TARGETS,
None,
_glfw.x11.helperWindowHandle,
CurrentTime);
for (;;)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq 0x38cf6(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rdi
leaq 0x38ce8(%rip), %rax # 0x60af8
movq 0x20520(%rax), %rsi
leaq 0x38cda(%rip), %rax # 0x60af8
movq 0x20528(%rax), %rdx
leaq 0x38ccc(%rip), %rax # 0x60af8
movq 0x1fed8(%rax), %r8
xorl %eax, %eax
movl ... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
releaseMonitor | static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver se... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x29373
jmp 0x29406
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1e920
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowTitle | void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
{
#if defined(X_HAVE_UTF8_STRING)
Xutf8SetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#else
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x376ce(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x340(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movq $0x0, (%rsp)
movq $0x0,... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformFocusWindow | void _glfwPlatformFocusWindow(_GLFWwindow* window)
{
if (_glfw.x11.NET_ACTIVE_WINDOW)
sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
else
{
XRaiseWindow(_glfw.x11.display, window->x11.handle);
XSetInputFocus(_glfw.x11.display, window->x11.handle,
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x36685(%rip), %rax # 0x60af8
cmpq $0x0, 0x20488(%rax)
je 0x2a4ae
movq -0x8(%rbp), %rdi
leaq 0x36670(%rip), %rax # 0x60af8
movq 0x20488(%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rcx
movq %r9, %r8
movq $0x0, (%rsp... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowDecorated | void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
{
if (enabled)
{
XDeleteProperty(_glfw.x11.display,
window->x11.handle,
_glfw.x11.MOTIF_WM_HINTS);
}
else
{
struct
{
unsigned long flags;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2a963
leaq 0x361bc(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x340(%rax), %rsi
leaq 0x361a3(%rip), %rax # 0x60af8
movq 0x204a0(%rax), %rdx
callq 0x133c0
jmp 0x2a9c6
... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowFloating | void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
{
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
return;
if (_glfwPlatformWindowVisible(window))
{
const Atom action = enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
sendEventToWM(window,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x36112(%rip), %rax # 0x60af8
cmpq $0x0, 0x20438(%rax)
je 0x2aa01
leaq 0x36101(%rip), %rax # 0x60af8
cmpq $0x0, 0x20440(%rax)
jne 0x2aa06
jmp 0x2ac23
movq -0x8(%rbp), %rdi
callq 0x299a0
cmpl $0x0, %eax
je 0x2aa6b
movl -... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformGetWindowOpacity | float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
{
float opacity = 1.f;
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
{
CARD32* value = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_WINDOW_OPACITY... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss 0x2867c(%rip), %xmm0 # 0x532c0
movss %xmm0, -0xc(%rbp)
leaq 0x35ea8(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rdi
leaq 0x35e9a(%rip), %rax # 0x60af8
movq 0x20480(%rax), %rsi
callq 0x13970
cmpq $0x0, %rax
je 0x2acd7
movq $0x0, -0x18(%rbp... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetCursorPos | void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
{
// Store the new position so it can be recognized later
window->x11.warpCursorPosX = (int) x;
window->x11.warpCursorPosY = (int) y;
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
cvttsd2si -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x378(%rax)
cvttsd2si -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x37c(%rax)
leaq 0x348ad(%rip), %rax # 0x60af8
movq 0x1feb8(%rax),... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
updateCursorImage | static void updateCursorImage(_GLFWwindow* window)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_g... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x34001, 0x74(%rax) # imm = 0x34001
jne 0x2c770
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2c750
leaq 0x343cd(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x340(%rax), %rsi
movq -0x8(%... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
encodeUTF8 | static size_t encodeUTF8(char* s, unsigned int ch)
{
size_t count = 0;
if (ch < 0x80)
s[count++] = (char) ch;
else if (ch < 0x800)
{
s[count++] = (ch >> 6) | 0xc0;
s[count++] = (ch & 0x3f) | 0x80;
}
else if (ch < 0x10000)
{
s[count++] = (ch >> 12) | 0xe0;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x80, -0xc(%rbp)
jae 0x2c8cc
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x2ca3f
cmpl $0x800, -0xc(%rb... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformCreateStandardCursor | int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
{
cursor->x11.handle = XCreateFontCursor(_glfw.x11.display,
translateCursorShape(shape));
if (!cursor->x11.handle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Fai... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x34012(%rip), %rax # 0x60af8
movq 0x1feb8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x2cb50
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x13060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
getSelectionString | static const char* getSelectionString(Atom selection)
{
size_t i;
char** selectionString = NULL;
const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
if (selection == _glfw.x11.PRIMARY)
selectionString = &_glfw.x11.pri... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
leaq 0x33db7(%rip), %rax # 0x60af8
movq 0x20538(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x1f, -0x38(%rbp)
movq $0x2, -0x48(%rbp)
movq -0x20(%rbp), %rax
leaq 0x33d91(%rip), %rcx ... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformCreateWindowSurface | VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
_GLFWwindow* window,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
{
if (_glfw.vk.KHR_xcb_surface && _glfw.x11... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x33736(%rip), %rax # 0x60af8
cmpl $0x0, 0x1fea0(%rax)
je 0x2d4e7
leaq 0x33722(%rip), %rax # 0x60af8
cmpq $0x0, 0x206a0(%rax)
je 0x2d4e7
leaq 0x3370d(%rip), %rax # 0x6... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
decodeUTF8 | static unsigned int decodeUTF8(const char** s)
{
unsigned int ch = 0, count = 0;
static const unsigned int offsets[] =
{
0x00000000u, 0x00003080u, 0x000e2080u,
0x03c82080u, 0xfa082080u, 0x82082080u
};
do
{
ch = (ch << 6) + (unsigned char) **s;
(*s)++;
cou... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.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.