name string | code string | asm string | file string |
|---|---|---|---|
f_outer | static inline void f_outer(uint64_t h[8], uint8_t blk[128], uint64_t offset_hi,
uint64_t offset_lo, unsigned final)
{
uint64_t m[16];
for (unsigned i = 0; i < 16; i++)
m[i] = GET_64BIT_LSB_FIRST(blk + 8*i);
f(h, m, offset_hi, offset_lo, final);
smemclr(m, sizeof(m));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0xb0(%rsp), %rdi
movl $0x80, %edx
callq 0xe9d0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movq %rbx, 0x28(%rsp)
mo... | /codexns[P]putty/crypto/blake2.c |
blowfish_lsb_encrypt_ecb | void blowfish_lsb_encrypt_ecb(void *vblk, int len, BlowfishContext * ctx)
{
unsigned char *blk = (unsigned char *)vblk;
uint32_t xL, xR, out[2];
assert((len & 7) == 0);
while (len > 0) {
xL = GET_32BIT_LSB_FIRST(blk);
xR = GET_32BIT_LSB_FIRST(blk + 4);
blowfish_encrypt(xL, xR, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
testb $0x7, %bpl
jne 0x458ca
testl %ebp, %ebp
jle 0x458bf
movq %rdx, %rbx
movq %rdi, %r14
addl $0x8, %ebp
movq %rsp, %r15
movl (%r14), %edi
movl 0x4(%r14), %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x458e9
movl (%rsp), %eax
movl %eax, (%r14)
movl 0... | /codexns[P]putty/crypto/blowfish.c |
blowfish_ssh_setkey | static void blowfish_ssh_setkey(ssh_cipher *cipher, const void *key)
{
struct blowfish_ctx *ctx = container_of(cipher, struct blowfish_ctx, ciph);
blowfish_setkey(&ctx->context, key, ctx->ciph.vt->padded_keybytes);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x1050(%rdi), %r14
movq (%rdi), %rax
movswl 0x50(%rax), %ebp
addq $-0x50, %rdi
leaq 0x2b2a6(%rip), %rsi # 0x713f0
movl $0x12, %ecx
rep movsl (%rsi), %es:(%rdi)
leaq -0xc50(%r15), %r12
leaq -0x850(%r15... | /codexns[P]putty/crypto/blowfish.c |
blowfish_ssh2_decrypt_blk | static void blowfish_ssh2_decrypt_blk(ssh_cipher *cipher, void *blk, int len)
{
struct blowfish_ctx *ctx = container_of(cipher, struct blowfish_ctx, ciph);
blowfish_msb_decrypt_cbc(blk, len, &ctx->context);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
testb $0x7, %r12b
jne 0x4652c
movl -0x8(%rdi), %r13d
movl -0x4(%rdi), %ebx
testl %r12d, %r12d
movq %rdi, 0x8(%rsp)
jle 0x4650a
movq %rsi, %rbp
leaq -0x1050(%rdi), %rax
movq %rax, 0x10(%rsp)
addq $0x7, %rbp
addl $0x8, %r1... | /codexns[P]putty/crypto/blowfish.c |
blowfish_ssh2_sdctr | static void blowfish_ssh2_sdctr(ssh_cipher *cipher, void *blk, int len)
{
struct blowfish_ctx *ctx = container_of(cipher, struct blowfish_ctx, ciph);
blowfish_msb_sdctr(blk, len, &ctx->context);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
testb $0x7, %bpl
jne 0x465df
movl -0x8(%rdi), %r14d
movl -0x4(%rdi), %r15d
testl %ebp, %ebp
movq %rdi, 0x10(%rsp)
jle 0x465c3
movq %rsi, %r12
leaq -0x1050(%rdi), %r13
addq $0x7, %r12
addl $0x8, %ebp
leaq 0x8(%rsp), %rbx
m... | /codexns[P]putty/crypto/blowfish.c |
blowfish_decrypt | static void blowfish_decrypt(uint32_t xL, uint32_t xR, uint32_t *output,
BlowfishContext * ctx)
{
uint32_t *S0 = ctx->S0;
uint32_t *S1 = ctx->S1;
uint32_t *S2 = ctx->S2;
uint32_t *S3 = ctx->S3;
uint32_t *P = ctx->P;
uint32_t t;
ROUND(17);
ROUND(16);
ROUN... | xorl 0x1044(%rcx), %edi
movl %edi, %eax
shrl $0x18, %eax
movl %edi, %r9d
shrl $0xe, %r9d
movl $0x3fc, %r8d # imm = 0x3FC
andl %r8d, %r9d
movl 0x400(%rcx,%r9), %r9d
addl (%rcx,%rax,4), %r9d
movl %edi, %r10d
shrl $0x8, %r10d
movl $0xff, %eax
andl %eax, %r10d
xorl 0x800(%rcx,%r10,4), %r9d
movl %edi, %r10d
andl ... | /codexns[P]putty/crypto/blowfish.c |
poly_genresult | static void poly_genresult(ssh2_mac *mac, unsigned char *blk)
{
struct ccp_context *ctx = container_of(mac, struct ccp_context, mac_if);
poly1305_finalise(&ctx->mac, blk);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x78(%rdi), %r15
movl -0x28(%rdi), %edx
testl %edx, %edx
je 0x46abb
leaq -0x38(%r14), %rsi
movq %r15, %rdi
callq 0x46de4
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %eax, %eax
xorl %edx, %edx
movzbl (%r15,%rdx... | /codexns[P]putty/crypto/chacha20-poly1305.c |
ccp_new | static ssh_cipher *ccp_new(const ssh_cipheralg *alg)
{
struct ccp_context *ctx = snew(struct ccp_context);
BinarySink_INIT(ctx, poly_BinarySink_write);
poly1305_init(&ctx->mac);
ctx->ciph.vt = alg;
return &ctx->ciph;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x1, %edi
movl $0x1a0, %esi # imm = 0x1A0
xorl %edx, %edx
callq 0x60434
leaq 0x170(%rax), %rcx
leaq 0x3b0(%rip), %rdx # 0x46fc1
movq %rdx, 0x170(%rax)
movq %r14, 0x178(%rax)
movq %rcx, 0x180(%rax)
xorps %xmm0, %xmm0
movups %xmm0, ... | /codexns[P]putty/crypto/chacha20-poly1305.c |
poly_BinarySink_write | static void poly_BinarySink_write(BinarySink *bs, const void *blkv, size_t len)
{
struct ccp_context *ctx = BinarySink_DOWNCAST(bs, struct ccp_context);
const unsigned char *blk = (const unsigned char *)blkv;
/* First 4 bytes are the IV */
while (ctx->mac_initialised < 4 && len) {
ctx->mac_iv[7... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl -0x68(%rdi), %eax
cmpl $0x4, %eax
setge %cl
testq %rdx, %rdx
setne %bpl
sete %sil
orb %cl, %sil
jne 0x47027
movl $0x7, %ecx
subl %eax, %ecx
movl %eax, %esi
movb (%r14), %al
incq %r14
movl %ecx, %edi
m... | /codexns[P]putty/crypto/chacha20-poly1305.c |
chacha20_round | static INLINE void chacha20_round(struct chacha20 *ctx)
{
int i;
uint32_t copy[16];
/* Take a copy */
memcpy(copy, ctx->state, sizeof(copy));
/* A circular rotation for a 32bit number */
#define rotl(x, shift) x = ((x << shift) | (x >> (32 - shift)))
/* What to do for each quarter round opera... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movdqu (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x20(%rdi), %xmm2
movq %rdi, 0x60(%rsp)
movups 0x30(%rdi), %xmm3
movaps %xmm1, 0x20(%rsp)
movdqa %xmm0, 0x10(%rsp)
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movl 0x20(%rsp), %e... | /codexns[P]putty/crypto/chacha20-poly1305.c |
des3_sdctr_encrypt_decrypt | static void des3_sdctr_encrypt_decrypt(ssh_cipher *ciph, void *vdata, int len)
{
struct des3_sdctr_ctx *ctx = container_of(
ciph, struct des3_sdctr_ctx, ciph);
uint8_t *data = (uint8_t *)vdata;
uint8_t iv_buf[8];
for (; len > 0; len -= 8, data += 8) {
/* Format the counter value into the... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
testl %edx, %edx
jle 0x48295
movq %rsi, %r14
movq 0x18(%rsp), %rax
leaq -0x188(%rax), %rcx
movq %rcx, 0x30(%rsp)
leaq -0x108(%rax), %rcx
movq %rcx, 0x28(%rsp)
addq $-0x88, %rax
movq %rax, 0x20(%rsp)
addl $0x8, %edx
... | /codexns[P]putty/crypto/des.c |
des_round | static inline LR des_round(LR in, const des_keysched *sched, size_t round)
{
LR out;
out.L = in.R;
out.R = in.L ^ des_f(in.R, sched->k7531[round], sched->k6420[round]);
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rcx
shrq $0x20, %rcx
movl (%rsi,%rdx,4), %eax
movl %ecx, %r8d
roll $0x4, %r8d
xorl %ecx, %eax
xorl 0x40(%rsi,%rdx,4), %r8d
movl %r8d, %esi
shrl $0x8, %esi
movl %eax, %edx
shrl $0x8, %edx
movl $0xfc00fc, %r9d # imm = 0xFC00FC
movl %edx, %r10d
andl %r9d, %r10d
movl $0x... | /codexns[P]putty/crypto/des.c |
dh_setup_gex | dh_ctx *dh_setup_gex(mp_int *pval, mp_int *gval)
{
dh_ctx *ctx = snew(dh_ctx);
ctx->p = mp_copy(pval);
ctx->g = mp_copy(gval);
dh_init(ctx);
return ctx;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
xorl %edx, %edx
callq 0x60434
movq %rax, %r15
movq %r14, %rdi
callq 0x4d478
movq %rax, 0x10(%r15)
movq %rbx, %rdi
callq 0x4d478
movq %rax, 0x20(%r15)
movq 0x10(%r15), %rdi
movl $0x1, %esi
callq 0x4e808
movq %rax, 0x18(%r15... | /codexns[P]putty/crypto/diffie-hellman.c |
dsa_new_pub | static ssh_key *dsa_new_pub(const ssh_keyalg *self, ptrlen data)
{
BinarySource src[1];
struct dsa_key *dsa;
BinarySource_BARE_INIT_PL(src, data);
if (!ptrlen_eq_string(get_string(src), "ssh-dss"))
return NULL;
dsa = snew(struct dsa_key);
dsa->sshk.vt = &ssh_dsa;
dsa->p = get_mp_ss... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rdi
movq %rsi, (%rdi)
movq %rdx, 0x10(%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x18(%rdi)
movq %rdi, 0x20(%rdi)
callq 0x601ab
leaq 0x2bdc1(%rip), %rcx # 0x74e39
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x60c64
testb %al, %al
je 0x49120
movl $0x1, %edi
mov... | /codexns[P]putty/crypto/dsa.c |
dsa_new_priv_openssh | static ssh_key *dsa_new_priv_openssh(const ssh_keyalg *self,
BinarySource *src)
{
struct dsa_key *dsa;
dsa = snew(struct dsa_key);
dsa->sshk.vt = &ssh_dsa;
dsa->p = get_mp_ssh2(src);
dsa->q = get_mp_ssh2(src);
dsa->g = get_mp_ssh2(src);
dsa->y = get_mp_... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movl $0x1, %edi
movl $0x30, %esi
xorl %edx, %edx
callq 0x60434
movq %rax, %r14
leaq 0x28(%rax), %rbx
leaq 0x4a9a9(%rip), %rax # 0x93c28
movq %rax, 0x28(%r14)
movq 0x20(%r15), %rdi
callq 0x4dbe2
movq %rax, (%r14)
movq 0x20(%r15), %rdi
callq 0x4dbe2
movq %rax, 0x8(%r14... | /codexns[P]putty/crypto/dsa.c |
dsa_public_blob | static void dsa_public_blob(ssh_key *key, BinarySink *bs)
{
struct dsa_key *dsa = container_of(key, struct dsa_key, sshk);
put_stringz(bs, "ssh-dss");
put_mp_ssh2(bs, dsa->p);
put_mp_ssh2(bs, dsa->q);
put_mp_ssh2(bs, dsa->g);
put_mp_ssh2(bs, dsa->y);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
leaq 0x2b6ab(%rip), %rsi # 0x74e39
callq 0x5feef
movq 0x10(%rbx), %rdi
movq -0x28(%r14), %rsi
callq 0x4dae4
movq 0x10(%rbx), %rdi
movq -0x20(%r14), %rsi
callq 0x4dae4
movq 0x10(%rbx), %rdi
movq -0x18(%r14), %rsi
callq 0x4dae4
mov... | /codexns[P]putty/crypto/dsa.c |
dsa_components | static key_components *dsa_components(ssh_key *key)
{
struct dsa_key *dsa = container_of(key, struct dsa_key, sshk);
key_components *kc = key_components_new();
key_components_add_text(kc, "key_type", "DSA");
assert(dsa->p);
key_components_add_mp(kc, "p", dsa->p);
key_components_add_mp(kc, "q", ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x5f918
movq %rax, %rbx
leaq 0x29464(%rip), %rsi # 0x72d18
leaq 0x29e2f(%rip), %rdx # 0x736ea
movq %rax, %rdi
callq 0x5f93a
movq -0x28(%r14), %rdx
testq %rdx, %rdx
je 0x49937
leaq 0x2f67f(%rip), %rsi # 0x78f52
movq %rbx, %rdi
callq 0x5fa0e
movq -0x20(%r... | /codexns[P]putty/crypto/dsa.c |
ecdsa_public | WeierstrassPoint *ecdsa_public(mp_int *private_key, const ssh_keyalg *alg)
{
const struct ecsign_extra *extra =
(const struct ecsign_extra *)alg->extra;
struct ec_curve *curve = extra->curve();
assert(curve->type == EC_WEIERSTRASS);
mp_int *priv_reduced = mp_mod(private_key, curve->p);
Weie... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb8(%rsi), %rax
callq *(%rax)
cmpl $0x0, (%rax)
jne 0x49a4d
movq %rax, %r14
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x4f226
movq %rax, %rbx
movq 0x38(%r14), %rdi
movq %rax, %rsi
callq 0x5b6e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ceb2
movq %r14, %rax
addq $0... | /codexns[P]putty/crypto/ecc-ssh.c |
eddsa_new_priv_openssh | static ssh_key *eddsa_new_priv_openssh(
const ssh_keyalg *alg, BinarySource *src)
{
const struct ecsign_extra *extra =
(const struct ecsign_extra *)alg->extra;
struct ec_curve *curve = extra->curve();
assert(curve->type == EC_EDWARDS);
ptrlen pubkey_pl = get_string(src);
ptrlen privkey_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r14
movq 0xb8(%rdi), %rax
callq *(%rax)
cmpl $0x2, (%rax)
jne 0x49e4c
movq %rax, %rbx
movq 0x20(%r13), %rdi
callq 0x601ab
movq %rax, %r12
movq %rdx, %r15
movq 0x20(%r13), %rdi
callq 0x601ab
movq 0x20(%r13), %r... | /codexns[P]putty/crypto/ecc-ssh.c |
eddsa_sign | static void eddsa_sign(ssh_key *key, ptrlen data,
unsigned flags, BinarySink *bs)
{
struct eddsa_key *ek = container_of(key, struct eddsa_key, sshk);
const struct ecsign_extra *extra =
(const struct ecsign_extra *)ek->sshk.vt->extra;
assert(ek->privateKey);
/*
* EdDS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, -0x8(%rdi)
je 0x4a15c
movq %r8, %rbx
movq %rdi, %r15
leaq -0x18(%rdi), %r14
movq (%rdi), %rax
movq 0xb8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rax), %rdi
callq *(%rdi)
movq %rax,... | /codexns[P]putty/crypto/ecc-ssh.c |
eddsa_openssh_blob | static void eddsa_openssh_blob(ssh_key *key, BinarySink *bs)
{
struct eddsa_key *ek = container_of(key, struct eddsa_key, sshk);
assert(ek->curve->type == EC_EDWARDS);
/* Encode the public and private points as strings */
strbuf *pub_sb = strbuf_new();
put_epoint(pub_sb, ek->publicKey, ek->curve, f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq -0x18(%rdi), %rax
cmpl $0x2, (%rax)
jne 0x4a4bb
movq %rdi, %rbp
callq 0x6145c
movq %rax, %rbx
leaq 0x18(%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
callq 0x4b147
movq %rbx, 0x18(%r... | /codexns[P]putty/crypto/ecc-ssh.c |
ec_ed25519 | static struct ec_curve *ec_ed25519(void)
{
static struct ec_curve curve = { 0 };
static bool initialised = false;
if (!initialised)
{
mp_int *p = MP_LITERAL(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed);
mp_int *d = MP_LITERAL(0x52036cee2b6ffe738cc740797779e8980070... | cmpb $0x0, 0x4e872(%rip) # 0x99c58
jne 0x4b4fd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x27dbf(%rip), %rdi # 0x731c0
callq 0x4d463
movq %rax, %r14
leaq 0x27df3(%rip), %rdi # 0x73203
callq 0x4d463
movq %rax, %r15
leaq 0x27e27(%rip), %rdi # 0x73246
callq 0x4... | /codexns[P]putty/crypto/ecc-ssh.c |
initialise_mcurve | static void initialise_mcurve(
struct ec_curve *curve, mp_int *p, mp_int *a, mp_int *b,
mp_int *G_x, unsigned log2_cofactor)
{
initialise_common(curve, EC_MONTGOMERY, p, 0);
curve->m.mc = ecc_montgomery_curve(p, a, b);
curve->m.log2_cofactor = log2_cofactor;
curve->m.G = ecc_montgomery_point_n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl $0x1, (%rdi)
movq %rsi, %rdi
callq 0x4d478
movq %rax, 0x28(%rbx)
movq %r13, %rdi
callq 0x4d527
movq %rax, 0x18(%rbx)
addq $0x7, %rax
shrq $0x3,... | /codexns[P]putty/crypto/ecc-ssh.c |
hmac_key | static void hmac_key(ssh2_mac *mac, ptrlen key)
{
struct hmac *ctx = container_of(mac, struct hmac, mac);
const uint8_t *kp;
size_t klen;
strbuf *sb = NULL;
if (key.len > ctx->hashalg->blocklen) {
/*
* RFC 2104 section 2: if the key exceeds the block length of
* the under... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq -0x30(%rdi), %rax
cmpq %rdx, 0x30(%rax)
jae 0x4c4fc
callq 0x614d5
movq %rax, %r15
movq -0x30(%rbx), %rax
movq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x61380
movq -0x30(%rbx), %rdi
movq 0x8(%r15), %rcx
movq %r12, ... | /codexns[P]putty/crypto/hmac.c |
mp_resize | mp_int *mp_resize(mp_int *mp, size_t newmaxbits)
{
mp_int *copy = mp_new(newmaxbits);
mp_copy_into(copy, mp);
mp_free(mp);
return copy;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3f(%rsi), %rdi
shrq $0x6, %rdi
callq 0x4cd78
movq %rax, %r14
movq (%rax), %rax
movq 0x8(%r14), %rdi
movq (%rbx), %r12
movq 0x8(%rbx), %rsi
cmpq %r12, %rax
cmovbq %rax, %r12
leaq (,%r12,8), %r15
movq %r15, %rdx
callq 0xe640
addq 0x8(%r14), %r1... | /codexns[P]putty/crypto/mpint.c |
mp_from_integer | mp_int *mp_from_integer(uintmax_t n)
{
mp_int *x = mp_make_sized(
(sizeof(n) + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES);
for (size_t i = 0; i < x->nw; i++)
x->w[i] = n >> (i * BIGNUM_INT_BITS);
return x;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
movl $0x8, %edx
callq 0x60434
movq %rax, %r14
movq $0x1, (%rax)
leaq 0x10(%rax), %rdi
movq %rdi, 0x8(%rax)
movl $0x8, %esi
callq 0x611ac
movq (%r14), %rdx
testq %rdx, %rdx
je 0x4cfb1
movq 0x8(%r14), %rax
leaq 0x1(%rdx), %rcx
andq $-0x2, %... | /codexns[P]putty/crypto/mpint.c |
mp_cond_swap | void mp_cond_swap(mp_int *x0, mp_int *x1, unsigned swap)
{
assert(x0->nw == x1->nw);
volatile BignumInt mask = -(BignumInt)(1 & swap);
for (size_t i = 0; i < x0->nw; i++) {
BignumInt diff = (x0->w[i] ^ x1->w[i]) & mask;
x0->w[i] ^= diff;
x1->w[i] ^= diff;
}
} | pushq %rax
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x4d145
andl $0x1, %edx
negq %rdx
movq %rdx, (%rsp)
testq %rax, %rax
je 0x4d143
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movq (%rdx,%rsi,8), %r8
xorq %rdi, %r8
andq (%rsp), %r8
xorq %r8, %rdi
movq %rdi, (%rcx,%rsi,8)
xorq %r8, ... | /codexns[P]putty/crypto/mpint.c |
mp_gcd_into | void mp_gcd_into(mp_int *a, mp_int *b, mp_int *gcd, mp_int *A, mp_int *B)
{
/*
* Identify shared factors of 2. To do this we OR the two numbers
* to get something whose lowest set bit is in the right place,
* remove all higher bits by ANDing it with its own negation, and
* use mp_get_nbits to fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
movq (%rsi), %rdi
cmpq %rdi, %rax
cmovaq %rax, %rdi
callq 0x4cd78
movq %rax, %rbp
movq (%rax), %rax
testq %rax, %rax
je 0x501bb
movq (%r13), %rc... | /codexns[P]putty/crypto/mpint.c |
keccak_accumulate | static void keccak_accumulate(keccak_state *s, const void *vdata, size_t len)
{
const unsigned char *data = (const unsigned char *)vdata;
while (len >= s->bytes_wanted - s->bytes_got) {
size_t b = s->bytes_wanted - s->bytes_got;
memcpy(s->bytes + s->bytes_got, data, b);
len -= b;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x198(%rdi), %rdi
movq 0x1a0(%r14), %rcx
subq %rdi, %rcx
cmpq %rdx, %rcx
jbe 0x58d59
movq %rdi, %rbp
jmp 0x58fa2
leaq 0xc8(%r14), %rax
movq %rax, (%rsp)
leaq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
xor... | /codexns[P]putty/crypto/sha3.c |
ecc_weierstrass_point_new_identity | WeierstrassPoint *ecc_weierstrass_point_new_identity(WeierstrassCurve *wc)
{
WeierstrassPoint *wp = ecc_weierstrass_point_new_empty(wc);
size_t bits = mp_max_bits(wc->p);
wp->X = mp_new(bits);
wp->Y = mp_new(bits);
wp->Z = mp_new(bits);
return wp;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
xorl %edx, %edx
callq 0x60434
movq %rax, %r14
movq %rbx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rdi
callq 0x4cfc4
movq %rax, %rbx
movq %rax, %rdi
callq 0x4cdf0
movq %rax, (%r14)
movq %rbx, %... | /codexns[P]putty/crypto/ecc-arithmetic.c |
conf_set_str | void conf_set_str(Conf *conf, int primary, const char *value)
{
struct conf_entry *entry = snew(struct conf_entry);
assert(subkeytypes[primary] == TYPE_NONE);
assert(valuetypes[primary] == TYPE_STR);
entry->key.primary = primary;
entry->value.u.stringval = dupstr(value);
conf_insert(conf, entry... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
xorl %edx, %edx
callq 0x60434
movq %rax, %r15
movslq %ebp, %rax
leaq 0x187c9(%rip), %rcx # 0x77450
cmpl $0x0, (%rcx,%rax,4)
jne 0x5ecbe
leaq 0x1847c(%rip), %rcx # 0x77110
cmpl ... | /codexns[P]putty/utils/conf.c |
BinarySource_get_bool | static bool BinarySource_data_avail(BinarySource *src, size_t wanted)
{
if (src->err)
return false;
if (wanted <= src->len - src->pos)
return true;
src->err = BSE_OUT_OF_DATA;
return false;
} | cmpl $0x0, 0x18(%rdi)
jne 0x600f6
movq 0x8(%rdi), %rax
cmpq %rax, 0x10(%rdi)
jne 0x600f9
movl $0x1, 0x18(%rdi)
xorl %eax, %eax
retq
movq (%rdi), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x8(%rdi)
cmpb $0x0, (%rcx,%rax)
setne %al
retq
| /codexns[P]putty/utils/marshal.c |
safemalloc | void *safemalloc(size_t factor1, size_t factor2, size_t addend)
{
if (factor1 > SIZE_MAX / factor2)
goto fail;
size_t product = factor1 * factor2;
if (addend > SIZE_MAX)
goto fail;
if (product > SIZE_MAX - addend)
goto fail;
size_t size = product + addend;
if (size == 0... | pushq %rax
movq %rdx, %rcx
movq %rsi, %rax
mulq %rdi
jo 0x60462
imulq %rdi, %rsi
movq %rcx, %rax
addq %rsi, %rax
jb 0x60462
cmpq $0x1, %rax
adcq %rcx, %rsi
movq %rsi, %rdi
callq 0xe240
testq %rax, %rax
je 0x60462
popq %rcx
retq
callq 0x6082c
| /codexns[P]putty/utils/memory.c |
nullstrcmp | int nullstrcmp(const char *a, const char *b)
{
if (a == NULL && b == NULL)
return 0;
if (a == NULL)
return -1;
if (b == NULL)
return +1;
return strcmp(a, b);
} | testq %rsi, %rsi
sete %cl
xorl %edx, %edx
movq %rdi, %rax
orq %rsi, %rax
sete %dl
decl %edx
testq %rdi, %rdi
sete %r8b
movl $0x1, %eax
cmovel %edx, %eax
orb %cl, %r8b
je 0xe750
retq
| /codexns[P]putty/utils/nullstrcmp.c |
prepare_session | void prepare_session(Conf *conf)
{
char *hostbuf = dupstr(conf_get_str(conf, CONF_host));
char *host = hostbuf;
char *p, *q;
/*
* Trim leading whitespace from the hostname.
*/
host += strspn(host, " \t");
/*
* See if host is of the form user@host, and separate out the
* use... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5e5c5
movq %rax, %rdi
callq 0x5f644
movq %rax, %r14
leaq 0x16fad(%rip), %rsi # 0x78081
movq %rax, %rdi
callq 0xe630
leaq (%r14,%rax), %r15
cmpb $0x0, (%r14,%rax)
je 0x61115
movq %r15, %rdi
movl $0x40, %esi
callq 0xe460
te... | /codexns[P]putty/utils/sessprep.c |
smemeq | unsigned smemeq(const void *av, const void *bv, size_t len)
{
const unsigned char *a = (const unsigned char *)av;
const unsigned char *b = (const unsigned char *)bv;
unsigned val = 0;
while (len-- > 0) {
val |= *a++ ^ *b++;
}
/* Now val is 0 iff we want to return 1, and in the range
... | testq %rdx, %rdx
je 0x61213
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rsi,%rax), %r8b
xorb (%rdi,%rax), %r8b
movzbl %r8b, %r8d
orl %r8d, %ecx
incq %rax
cmpq %rax, %rdx
jne 0x611f1
movl $0x100, %eax # imm = 0x100
subl %ecx, %eax
shrl $0x8, %eax
retq
movl $0x1, %eax
retq
nopl (%rax)
| /codexns[P]putty/utils/smemeq.c |
strbuf_BinarySink_write | static void strbuf_BinarySink_write(
BinarySink *bs, const void *data, size_t len)
{
strbuf *buf_o = BinarySink_DOWNCAST(bs, strbuf);
memcpy(strbuf_append(buf_o, len), data, len);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x20(%rdi), %rsi
movq -0x18(%rdi), %rdi
movq -0x8(%r15), %rcx
incq %rcx
movzbl 0x18(%r15), %r9d
movl $0x1, %edx
movq %rbx, %r8
callq 0x604ab
movq %rax, -0x18(%r15)
movq %rax, -0x10(%r15)
movq -0x8(%r15), %rcx
leaq (%rax,%rcx), %rdi
a... | /codexns[P]putty/utils/strbuf.c |
tempseat_output | static size_t tempseat_output(Seat *seat, SeatOutputType type,
const void *data, size_t len)
{
TempSeat *ts = container_of(seat, TempSeat, seat);
bufchain_add(&ts->output, data, len);
if (!(ts->outchunk_tail && ts->outchunk_tail->type == type)) {
struct output_chunk *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq -0x48(%rdi), %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5d170
movq -0x18(%r15), %rax
testq %rax, %rax
je 0x61956
cmpl %ebp, 0x8(%rax)
jne 0x61956
movq 0x10(%rax), %r12
jmp 0x6198a
xorl %r12d, %r... | /codexns[P]putty/utils/tempseat.c |
tempseat_prompt_descriptions | static const SeatDialogPromptDescriptions *tempseat_prompt_descriptions(
Seat *seat)
{
/* It might be OK to put this in the 'unreachable' category, but I
* think it's equally good to put it here, which allows for
* someone _preparing_ a prompt right now that they intend to
* present once the Temp... | movq -0x50(%rdi), %rdi
movq (%rdi), %rax
jmpq *0x78(%rax)
| /codexns[P]putty/utils/tempseat.c |
add234_internal | static void *add234_internal(tree234 * t, void *e, int index)
{
node234 *n, **np, *left, *right;
void *orig_e = e;
int c, lcount, rcount;
LOG(("adding node %p to tree %p\n", e, t));
if (t->root == NULL) {
t->root = snew(node234);
t->root->elems[1] = t->root->elems[2] = NULL;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x61ffd
movl %edx, %ebp
movq %rax, %r13
testl %ebp, %ebp
js 0x61c90
cmpq $0x0, 0x8(%r13)
je 0x61ced
movl 0x28(%r13), %eax
cmpl %eax, %ebp
jle 0x61ce9
notl %eax
addl %e... | /codexns[P]putty/utils/tree234.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, 0x224c9(%rip) # 0x3759c
jne 0x150d7
jmp 0x1513d
leaq 0x17fcd(%rip), %rdi # 0x2d0ab
callq *-0x8(%rbp)
movq %rax, 0x230f8(%rip) # 0x381e0
leaq 0x17fd1(%rip), %rdi # 0x2d0c0
callq *-0x8(%rbp)
movq %rax, 0x22647(%rip) # 0x37740... | /drobilla[P]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, 0x21e81(%rip) # 0x375a4
jne 0x1572a
jmp 0x15829
leaq 0x18050(%rip), %rdi # 0x2d781
callq *-0x8(%rbp)
movq %rax, 0x22b15(%rip) # 0x38250
leaq 0x18055(%rip), %rdi # 0x2d797
callq *-0x8(%rbp)
movq %rax, 0x22384(%rip) # 0x37ad0... | /drobilla[P]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 0x15d60
cmpl $0x0, %eax
jne 0x159bb
movl $0x0, -0x4(%rbp)
jmp 0x159fd
leaq 0x1803d(%rip), %rdi # 0x2d9ff
callq 0x15e30
movl %eax, 0x230b3(%rip) # 0x38a80
leaq 0x1803e(%rip), %rdi # 0x2da12
callq 0x15e30
movl %eax, 0x2309d(%rip) # 0x38a7c
leaq 0x1803e(%ri... | /drobilla[P]glfw/deps/glad.c |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
ctxconfig->source != GLFW_EGL_CONTEXT_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context creation API %i",
ctxconfig->... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x36001, 0x4(%rax) # imm = 0x36001
je 0x15fdc
movq -0x10(%rbp), %rax
cmpl $0x36002, 0x4(%rax) # imm = 0x36002
je 0x15fdc
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movl $0x10003, %edi # imm = 0x10003
leaq 0... | /drobilla[P]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... | /drobilla[P]glfw/src/context.c |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return GLFW_FALSE;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16c55
jmp 0x16c74
leaq 0x174a1(%rip), %rdi # 0x2e0fd
leaq 0x17422(%rip), %rsi # 0x2e085
movl $0x282, %edx # imm = 0x282
leaq 0x174a0(%rip), %rcx # 0x2e10f
callq 0x10200
leaq 0x21f7d(%rip), %rax # 0x... | /drobilla[P]glfw/src/context.c |
glfwMakeContextCurrent | GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFWwindow* previous = _glfwPlatformGetCurrentContext();
_GLFW_REQUIRE_INIT();
if (window && window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x26940
movq %rax, -0x18(%rbp)
leaq 0x21d24(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x16eeb
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x171... | /drobilla[P]glfw/src/context.c |
glfwSwapBuffers | GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return;
}
window->context.swapBuffers(w... | 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 0x16fdd
jmp 0x16ffc
leaq 0x17092(%rip), %rdi # 0x2e076
leaq 0x1709a(%rip), %rsi # 0x2e085
movl $0x261, %edx # imm = 0x261
leaq 0x170e3(%rip), %rcx # 0x2e0da
cal... | /drobilla[P]glfw/src/context.c |
glfwGetProcAddress | GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
{
_GLFWwindow* window;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
window = _glfwPlatformGetCurrentContext();
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT, NULL);
return NULL;
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x170d5
jmp 0x170f4
leaq 0x170a0(%rip), %rdi # 0x2e17c
leaq 0x16fa2(%rip), %rsi # 0x2e085
movl $0x2c3, %edx # imm = 0x2C3
leaq 0x1709e(%rip), %rcx # 0x2e18d
callq 0x10200
leaq 0x21afd(%rip), %rax # 0x... | /drobilla[P]glfw/src/context.c |
glfwInputError | void _glfwInputError(int error, const char* format, ...)
{
if (_glfwErrorCallback)
{
char buffer[8192];
const char* description;
if (format)
{
int count;
va_list vl;
va_start(vl, format);
count = vsnprintf(buffer, sizeof(buffer), ... | pushq %rbp
movq %rsp, %rbp
subq $0x20f0, %rsp # imm = 0x20F0
testb %al, %al
je 0x171b7
movaps %xmm0, -0x20c0(%rbp)
movaps %xmm1, -0x20b0(%rbp)
movaps %xmm2, -0x20a0(%rbp)
movaps %xmm3, -0x2090(%rbp)
movaps %xmm4, -0x2080(%rbp)
movaps %xmm5, -0x2070(%rbp)
movaps %xmm6, -0x2060(%rbp)
movaps %xmm7, -0x2050(%rbp)... | /drobilla[P]glfw/src/init.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
_glfw.initialized = GLFW_TRUE;
_glfw.timerOffset = _glfwPlatformGetTimerValue();
// Not all wi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x21889(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
je 0x1737d
movl $0x1, -0x4(%rbp)
jmp 0x173d7
leaq 0x21874(%rip), %rdi # 0x38bf8
xorl %esi, %esi
movl $0xe88, %edx # imm = 0xE88
callq 0x100f0
callq 0x1d820
cmpl $0x0, %eax
jne 0x173a8
callq 0x173e0
movl $... | /drobilla[P]glfw/src/init.c |
glfwSetTime | GLFWAPI void glfwSetTime(double time)
{
_GLFW_REQUIRE_INIT();
if (time != time || time < 0.0 || time > 18446744073.0)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
return;
}
_glfw.timerOffset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatfor... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x1f8f4(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1931e
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
jmp 0x193e9
movsd -0x8(%rbp), %xmm0
ucomisd -0x8(%rbp), %xmm0
jne 0x19349
jp ... | /drobilla[P]glfw/src/input.c |
glfwFreeMonitor | void _glfwFreeMonitor(_GLFWmonitor* monitor)
{
if (monitor == NULL)
return;
_glfwFreeGammaArrays(&monitor->originalRamp);
_glfwFreeGammaArrays(&monitor->currentRamp);
free(monitor->modes);
free(monitor->name);
free(monitor);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x196b5
jmp 0x196f1
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x19780
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x19780
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10410
movq -0x8(%rbp), %rax
movq (%rax), %rdi
call... | /drobilla[P]glfw/src/monitor.c |
glfwAllocMonitor | _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM)
{
_GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
monitor->widthMM = widthMM;
monitor->heightMM = heightMM;
if (name)
monitor->name = strdup(name);
return monitor;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, %edi
movl $0xa0, %esi
callq 0x107b0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpq $... | /drobilla[P]glfw/src/monitor.c |
glfwChooseVideoMode | const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
const GLFWvidmode* desired)
{
int i;
unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
unsigned int rateDiff, leastRateDiff = UINT_MAX;
unsigned int colorDiff, leastColorDiff = UINT_MAX;
const GLFWv... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19a20
cmpl $0x0, %eax
jne 0x1... | /drobilla[P]glfw/src/monitor.c |
compareVideoModes | static int compareVideoModes(const void* fp, const void* sp)
{
const GLFWvidmode* fm = fp;
const GLFWvidmode* sm = sp;
const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
const int farea = fm->width * fm->height;
const int sar... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
addl 0xc(%rcx), %eax
movq -0x20(%rbp), %rcx
addl 0x10(%rcx), %eax
movl %eax, -0x2c(%rbp)... | /drobilla[P]glfw/src/monitor.c |
glfwGetMonitorPos | GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorPos(monitor, xpos, ypos);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19d45
jmp 0x19d64
leaq 0x14cde(%rip), %rdi # 0x2ea2a
leaq 0x14c5d(%rip), %rsi # 0x2e9b0
movl $0x11e, %edx # imm = 0x... | /drobilla[P]glfw/src/monitor.c |
glfwGetMonitorPhysicalSize | GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (widthMM)
*widthMM = 0;
if (heightMM)
*heightMM = 0;
_GLFW_REQUIRE_INIT();
if (widthMM)
*widthMM = mo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19de5
jmp 0x19e04
leaq 0x14c3e(%rip), %rdi # 0x2ea2a
leaq 0x14bbd(%rip), %rsi # 0x2e9b0
movl $0x12d, %edx # imm = 0x... | /drobilla[P]glfw/src/monitor.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = m... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19f91
jmp 0x19fb0
leaq 0x14a92(%rip), %rdi # 0x2ea2a
leaq 0x14a11(%rip), %rsi # 0x2e9b0
movl $0x14f, %edx # imm = 0x14F
leaq 0x14b2e(%rip... | /drobilla[P]glfw/src/monitor.c |
glfwSetGamma | GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
{
int i;
unsigned short values[256];
GLFWgammaramp ramp;
_GLFW_REQUIRE_INIT();
if (gamma != gamma || gamma <= 0.f || gamma > FLT_MAX)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid gamma value %f", gamma);
return;
... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
leaq 0x1eafd(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1a115
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
jmp 0x1a25c
movss -0xc(%rbp),... | /drobilla[P]glfw/src/monitor.c |
glfwSetGammaRamp | GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(ramp != NULL);
assert(ramp->red != NULL);
assert(ramp->green != NULL);
assert(ramp->blue != NULL);
if (ramp->size <= 0)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a291
jmp 0x1a2b0
leaq 0x14792(%rip), %rdi # 0x2ea2a
leaq 0x14711(%rip), %rsi # 0x2e9b0
movl $0x19e, %edx # imm = 0x19E
leaq 0x148e8(%rip),... | /drobilla[P]glfw/src/monitor.c |
glfwGetRequiredInstanceExtensions | GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count)
{
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return NULL;
if (!_glfw.vk.extensions[0])
return NULL;
*count = 2;
return (const char**) _glfw.vk.extensions;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq 0x1e12b(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1aaec
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
movq $0x0, -0x8(%rbp)
jmp 0x1ab3f
mov... | /drobilla[P]glfw/src/vulkan.c |
glfwGetInstanceProcAddress | GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
const char* procname)
{
GLFWvkproc proc;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return NULL;
proc = (GLFWvkproc) vkGetInstanceProcAddr(inst... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x1e091(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1ab86
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
movq $0x0, -0x8(%rbp)
jmp 0x1abe5
movl $0x2, %edi
callq... | /drobilla[P]glfw/src/vulkan.c |
glfwGetPhysicalDevicePresentationSupport | GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
{
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADE... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq 0x1dfee(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1ac28
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
movl $0x0, -0x4(%rbp)
jmp 0x1ac8... | /drobilla[P]glfw/src/vulkan.c |
glfwInputWindowFocus | void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
{
if (window->callbacks.focus)
window->callbacks.focus((GLFWwindow*) window, focused);
if (!focused)
{
int key, button;
for (key = 0; key <= GLFW_KEY_LAST; key++)
{
if (window->keys[key] == GLFW... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2b8(%rax)
je 0x1add1
movq -0x8(%rbp), %rax
movq 0x2b8(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
cmpl $0x0, -0xc(%rbp)
jne 0x1ae68
movl $0x0, -0x10(%rbp)
cmpl $0x15c, -0x10... | /drobilla[P]glfw/src/window.c |
glfwCreateWindow | GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
const char* title,
GLFWmonitor* monitor,
GLFWwindow* share)
{
_GLFWfbconfig fbconfig;
_GLFWctxconfig ctxconfig;
_GLFWwndconfig wndconfig;... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1b076
jmp 0x1b095
leaq 0x142bb(%rip), %rdi # 0x2f338
leaq 0x142c2(%rip), %rsi # 0x2f346
movl $0x84, %... | /drobilla[P]glfw/src/window.c |
glfwDestroyWindow | GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT();
// Allow closing of NULL (to match the behavior of free)
if (window == NULL)
return;
// Clear all callbacks to avoid exposing a half torn-down window object
memset(&... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1d7ad(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1b465
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
jmp 0x1b4f5
cmpq $0x0, -0x10(%rbp)... | /drobilla[P]glfw/src/window.c |
glfwDefaultWindowHints | void glfwDefaultWindowHints(void)
{
_GLFW_REQUIRE_INIT();
memset(&_glfw.hints, 0, sizeof(_glfw.hints));
// The default is OpenGL with minimum version 1.0
_glfw.hints.context.client = GLFW_OPENGL_API;
_glfw.hints.context.source = GLFW_NATIVE_CONTEXT_API;
_glfw.hints.context.major = 1;
_glf... | pushq %rbp
movq %rsp, %rbp
leaq 0x1d6ed(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1b525
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
jmp 0x1b64a
leaq 0x1d6cc(%rip), %rdi # 0x38bf8
addq $0x8, %rdi
xorl %esi, %esi
movl $0xc8, %edx
callq 0x100f0
leaq... | /drobilla[P]glfw/src/window.c |
glfwWindowHint | GLFWAPI void glfwWindowHint(int hint, int value)
{
_GLFW_REQUIRE_INIT();
switch (hint)
{
case GLFW_RED_BITS:
_glfw.hints.framebuffer.redBits = value;
break;
case GLFW_GREEN_BITS:
_glfw.hints.framebuffer.greenBits = value;
break;
case G... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x1d593(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1b67f
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
jmp 0x1bc83
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
s... | /drobilla[P]glfw/src/window.c |
glfwWindowHintPointer | GLFWAPI void glfwWindowHintPointer(int hint, void* value)
{
_GLFW_REQUIRE_INIT();
switch (hint)
{
case GLFW_NATIVE_PARENT_HANDLE:
_glfw.hints.window.nativeParent = value;
break;
default:
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window hint %i", hint);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1cf52(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x1bcbd
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
jmp 0x1bcf0
movl -0x4(%rbp), %eax
subl $0x2000a, %eax ... | /drobilla[P]glfw/src/window.c |
glfwSetWindowPos | GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformSetWindowPos(window, xpos, ypos);
} | 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 0x1c023
jmp 0x1c042
leaq 0x1204c(%rip), %rdi # 0x2e076
leaq 0x13315(%rip), %rsi # 0x2f346
movl $0x1f3, %edx # imm = 0x1... | /drobilla[P]glfw/src/window.c |
glfwGetWindowSize | GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowSize(window, width, height);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c0b5
jmp 0x1c0d4
leaq 0x11fba(%rip), %rdi # 0x2e076
leaq 0x13283(%rip), %rsi # 0x2f346
movl $0x200, %edx # imm = 0x... | /drobilla[P]glfw/src/window.c |
glfwSetWindowSizeLimits | GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (minwidth != GLFW... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c1ea
jmp 0x1c209
leaq 0x11e85(%rip), %rdi # 0x2e076
leaq 0x1314e(%rip), %rsi # 0x... | /drobilla[P]glfw/src/window.c |
glfwMaximizeWindow | GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformMaximizeWindow(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 0x1c65d
jmp 0x1c67c
leaq 0x11a12(%rip), %rdi # 0x2e076
leaq 0x12cdb(%rip), %rsi # 0x2f346
movl $0x297, %edx # imm = 0x297
leaq 0x130fd(%rip), %rcx # 0x2f774
cal... | /drobilla[P]glfw/src/window.c |
glfwShowWindow | GLFWAPI void glfwShowWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformShowWindow(window);
_glfwPlatformFocusWindow(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 0x1c6dd
jmp 0x1c6fc
leaq 0x11992(%rip), %rdi # 0x2e076
leaq 0x12c5b(%rip), %rsi # 0x2f346
movl $0x2a4, %edx # imm = 0x2A4
leaq 0x130a3(%rip), %rcx # 0x2f79a
cal... | /drobilla[P]glfw/src/window.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 0x1c75d
jmp 0x1c77c
leaq 0x11912(%rip), %rdi # 0x2e076
leaq 0x12bdb(%rip), %rsi # 0x2f346
movl $0x2b2, %edx # imm = 0x2B2
leaq 0x13045(%rip), %rcx # 0x2f7bc
cal... | /drobilla[P]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 ... | /drobilla[P]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 0x10730
xorl %eax, %eax
movl %eax, %edi
callq 0x103b0
movq %rax, %rcx
leaq 0x1b3b8(%rip), %rax # 0x38bf8
movq %rcx, 0x548(%rax)
leaq 0x1b3aa(%rip), %rax # 0x38bf8
cmpq $0x0, 0x548(%rax)
jne 0x1d8a7
leaq 0x1249d(%rip), %rdi # 0x2fcfc
callq 0x10610
movq %rax, ... | /drobilla[P]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 0x1b1ae(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rdi
leaq 0x1b1a0(%rip), %rax # 0x38bf8
movq 0x558(%rax), %rsi
leaq 0x1b192(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rax
movq 0xe8(%rax), %rax
leaq 0x1b17d(%rip), %r... | /drobilla[P]glfw/src/x11_init.c |
initExtensions | static GLFWbool initExtensions(void)
{
_glfw.x11.vidmode.handle = dlopen("libXxf86vm.so.1", RTLD_LAZY | RTLD_GLOBAL);
if (_glfw.x11.vidmode.handle)
{
_glfw.x11.vidmode.QueryExtension = (PFN_XF86VidModeQueryExtension)
dlsym(_glfw.x11.vidmode.handle, "XF86VidModeQueryExtension");
_... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1222d(%rip), %rdi # 0x2fd7c
movl $0x101, %esi # imm = 0x101
callq 0x10570
movq %rax, %rcx
leaq 0x1b095(%rip), %rax # 0x38bf8
movq %rcx, 0xc68(%rax)
leaq 0x1b087(%rip), %rax # 0x38bf8
cmpq $0x0, 0xc68(%rax)
je 0x1dc78
leaq 0x1b072(%rip), %rax ... | /drobilla[P]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 0x1a6ea(%rip), %rax # 0x38bf8
movq 0x578(%rax), %rdi
leaq 0x11cea(%rip), %rsi # 0x30206
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x10210
cmpq $0x0, %rax
je 0x1e53a
movl $0x0, -0x4(%rb... | /drobilla[P]glfw/src/x11_init.c |
getSupportedAtom | static Atom getSupportedAtom(Atom* supportedAtoms,
unsigned long atomCount,
const char* atomName)
{
unsigned long i;
const Atom atom = XInternAtom(_glfw.x11.display, atomName, False);
for (i = 0; i < atomCount; i++)
{
if (supportedAtom... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x18b2d(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x107d0
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
... | /drobilla[P]glfw/src/x11_init.c |
glfwPollMonitorsX11 | void _glfwPollMonitorsX11(void)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
int i, j, disconnectedCount, screenCount = 0;
_GLFWmonitor** disconnected;
XineramaScreenInfo* screens = NULL;
XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.disp... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x18aa9(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbe8(%rax)
je 0x20568
leaq 0x18a95(%rip), %rax # 0x38bf8
cmpl $0x0, 0xc00(%rax)
jne 0x20568
movl $0x0, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x18a72(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rdi
leaq 0x18a64(%rip), %... | /drobilla[P]glfw/src/x11_monitor.c |
glfwSetVideoModeX11 | GLFWbool _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
XRROutputInfo* oi;
GLFWvidmode current;
const GLFWvidmode* best;
RRMode n... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq 0x185cd(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbe8(%rax)
je 0x20856
leaq 0x185b9(%rip), %rax # 0x38bf8
cmpl $0x0, 0xc00(%rax)
jne 0x20856
movq $0x0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
cal... | /drobilla[P]glfw/src/x11_monitor.c |
glfwPlatformGetVideoMode | void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x18371(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbe8(%rax)
je 0x2094e
leaq 0x1835d(%rip), %rax # 0x38bf8
cmpl $0x0, 0xc00(%rax)
jne 0x2094e
leaq 0x18349(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rdi
leaq 0x1833b(%rip), %r... | /drobilla[P]glfw/src/x11_monitor.c |
vidmodeFromModeInfo | static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
const XRRCrtcInfo* ci)
{
GLFWvidmode mode;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
mode.width = mi->height;
mode.height = mi->width;
}
else
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x20(%rax), %eax
cmpl $0x2, %eax
je 0x20ae2
movq -0x10(%rbp), %rax
movzwl 0x20(%rax), %eax
cmpl $0x8, %eax
jne 0x20afb
movq -0x20(%rbp), %rax
movq -0x8(%rb... | /drobilla[P]glfw/src/x11_monitor.c |
glfwRestoreVideoModeX11 | void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
if (monitor->x11.oldMode == None)
return;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x1... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x18074(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbe8(%rax)
je 0x20c91
leaq 0x18060(%rip), %rax # 0x38bf8
cmpl $0x0, 0xc00(%rax)
jne 0x20c91
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x20bb8
jmp 0x20c91
leaq 0x18039(%rip), %rax ... | /drobilla[P]glfw/src/x11_monitor.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 0x17e67(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbe8(%rax)
je 0x20f40
leaq 0x17e53(%rip), %rax # 0x38bf8
cmpl $0x0, 0xc00(%rax)
jne 0x20f40
leaq 0x17e3f(%rip), %rax # 0x38bf8
movq... | /drobilla[P]glfw/src/x11_monitor.c |
glfwPlatformSetGammaRamp | void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
memcpy(gamma->green, r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x17ad1(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbe8(%rax)
je 0x211e7
leaq 0x17abd(%rip), %rax # 0x38bf8
cmpl $0x0, 0xbfc(%rax)
jne 0x211e7
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x100e0
movq %rax, -0x18(%rbp)
mo... | /drobilla[P]glfw/src/x11_monitor.c |
glfwGetWindowPropertyX11 | unsigned long _glfwGetWindowPropertyX11(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetW... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
leaq 0x17844(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %r15
movq -0x38(%rbp), %r... | /drobilla[P]glfw/src/x11_window.c |
waitForEvent | static GLFWbool waitForEvent(double* timeout)
{
fd_set fds;
const int fd = ConnectionNumber(_glfw.x11.display);
int count = fd + 1;
#if defined(__linux__)
if (_glfw.linjs.inotify > fd)
count = _glfw.linjs.inotify + 1;
#endif
for (;;)
{
FD_ZERO(&fds);
FD_SET(fd, &fds);
#i... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
leaq 0x17552(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
leaq 0x1752c(%rip), %rax # 0x38bf8
movl 0xd88(%rax), %... | /drobilla[P]glfw/src/x11_window.c |
acquireMonitor | static GLFWbool acquireMonitor(_GLFWwindow* window)
{
GLFWbool status;
if (_glfw.x11.saver.count == 0)
{
// Remember old screen saver settings
XGetScreenSaver(_glfw.x11.display,
&_glfw.x11.saver.timeout,
&_glfw.x11.saver.interval,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x16695(%rip), %rax # 0x38bf8
cmpl $0x0, 0xc20(%rax)
jne 0x225cc
leaq 0x16685(%rip), %rax # 0x38bf8
movq 0x548(%rax), %rdi
leaq 0x16677(%rip), %r8 # 0x38bf8
addq $0x548, %r8 # imm = 0x548
addq $0x6d8, %r8 # imm =... | /drobilla[P]glfw/src/x11_window.c |
glfwInitGLX | GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(__CYGWIN__)
"libGL-1.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
if (_glfw.glx.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.glx.handle = dl... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x103c1(%rip), %rax # 0x36d30
movq %rax, -0x20(%rbp)
movq 0x103be(%rip), %rax # 0x36d38
movq %rax, -0x18(%rbp)
movq 0x103bb(%rip), %rax # 0x36d40
movq %rax, -0x10(%rbp)
leaq 0x12268(%rip), %rax # 0x38bf8
cmpq $0x0, 0xca8(%rax)
je 0x269a6
movl $0x1, -0x4(%... | /drobilla[P]glfw/src/glx_context.c |
glfwChooseVisualGLX | GLFWbool _glfwChooseVisualGLX(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
GLXFBConfig native;
XVisualInfo* result;
if (!chooseGLXFBConfig(fbconfig, &native))
{
_glfwInputError(GLFW_FOR... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27b40
cmpl $0x0, %eax
jne 0x28186
movl $0x10009, %edi # imm = 0x10009
leaq 0x950f(%rip), %rsi # 0x31685
movb $0x0, %... | /drobilla[P]glfw/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->context.glx.window... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1094d(%rip), %rax # 0x38bf8
cmpl $0x0, (%rax)
jne 0x282ca
movl $0x10001, %edi # imm = 0x10001
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x17170
movq $0x0, -0x8(%rbp)
jmp 0x2830... | /drobilla[P]glfw/src/glx_context.c |
glfwInitEGL | GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#else
"libEGL.so.1",
#endif
NULL
};
if (_glfw.egl.handle)
return GLFW_TRUE;
for (i = 0; s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xe9e1(%rip), %rax # 0x36d50
movq %rax, -0x20(%rbp)
movq 0xe9de(%rip), %rax # 0x36d58
movq %rax, -0x18(%rbp)
leaq 0x10873(%rip), %rax # 0x38bf8
cmpq $0x0, 0xe00(%rax)
je 0x2839b
movl $0x1, -0x4(%rbp)
jmp 0x289ba
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax... | /drobilla[P]glfw/src/egl_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbp
movq %rsp, %rbp
leaq 0x1021d(%rip), %rax # 0x38bf8
cmpq $0x0, 0xdd8(%rax)
je 0x28a15
leaq 0x1020c(%rip), %rax # 0x38bf8
movq 0xe30(%rax), %rax
leaq 0x101fe(%rip), %rcx # 0x38bf8
movq 0xdd8(%rcx), %rdi
callq *%rax
leaq 0x101ee(%rip), %rax # 0x38bf8
movq $0x0, 0xdd8(%rax)
leaq 0x101dc(%rip), %r... | /drobilla[P]glfw/src/egl_context.c |
getEGLErrorString | static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0xffffd000, %eax # imm = 0xFFFFD000
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xe, %eax
ja 0x28b57
movq -0x18(%rbp), %rax
leaq 0x8ef7(%rip), %rcx # 0x31970
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x62e1(%rip), ... | /drobilla[P]glfw/src/egl_context.c |
chooseEGLConfig | static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* desired,
EGLConfig* result)
{
EGLConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xf52d(%rip), %rax # 0x38bf8
movq 0xe10(%rax), %rax
leaq 0xf51f(%rip), %rcx # 0x38bf8
movq 0xdd8(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
leaq -0x40(%rbp), %rcx
callq *%rax
... | /drobilla[P]glfw/src/egl_context.c |
makeContextCurrentEGL | static void makeContextCurrentEGL(_GLFWwindow* window)
{
if (window)
{
if (!eglMakeCurrent(_glfw.egl.display,
window->context.egl.surface,
window->context.egl.surface,
window->context.egl.handle))
{
_... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29a15
leaq 0xf24e(%rip), %rax # 0x38bf8
movq 0xe60(%rax), %rax
leaq 0xf240(%rip), %rcx # 0x38bf8
movq 0xdd8(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x288(%rcx), %rsi
movq -0x8(%rbp), %rcx
movq 0x288(%rcx), %rdx
movq -0... | /drobilla[P]glfw/src/egl_context.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.