name
stringlengths 1
4.98k
| code
stringlengths 61
2.07M
| asm
stringlengths 57
12.9M
| file
stringlengths 18
192
|
|---|---|---|---|
store
|
static void store(Type *t) {
printfln(" pop rdi"); // rhsの結果
printfln(" pop rax"); // 左辺の変数のアドレス
if (t->kind == TY_BOOL) {
// booleanの場合はrdiが
// 0のときは0
// それ以外は固定で1をrdiに設定する
printfln(" cmp rdi, 0");
// cmp の比較で rdi != 0 のときだけ rdiの下位8bit に1をセット
printfln(" setne dil");
// rdiの上位56bitはクリアして1を代入
printfln(" movzb rdi, dil");
}
int sz = t->size;
// 左辺の変数にrhsの結果を代入
if (sz == 1) {
printfln(" mov [rax], dil");
} else if (sz == 2) {
printfln(" mov [rax], di");
} else if (sz == 4) {
printfln(" mov [rax], edi");
} else if (sz == 8) {
printfln(" mov [rax], rdi");
} else {
assert(false);
}
printfln(" push rdi"); // この代入結果自体もスタックに積む(右結合でどんどん左に伝搬していくときの右辺値になる)
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x838f(%rip), %rdi # 0xbd9a
xorl %eax, %eax
callq 0x27b5
leaq 0x7a4f(%rip), %rdi # 0xb468
xorl %eax, %eax
callq 0x27b5
cmpl $0x2, (%rbx)
jne 0x3a4f
leaq 0x8378(%rip), %rdi # 0xbda4
xorl %eax, %eax
callq 0x27b5
leaq 0x8377(%rip), %rdi # 0xbdb1
xorl %eax, %eax
callq 0x27b5
leaq 0x8375(%rip), %rdi # 0xbdbd
xorl %eax, %eax
callq 0x27b5
movl 0x4(%rbx), %eax
decl %eax
cmpl $0x8, %eax
jae 0x3a89
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x3a89
movl %eax, %eax
leaq 0x7708(%rip), %rcx # 0xb174
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x27b5
leaq 0x83a3(%rip), %rdi # 0xbe24
xorl %eax, %eax
popq %rbx
jmp 0x27b5
leaq 0x7892(%rip), %rdi # 0xb322
leaq 0x7863(%rip), %rsi # 0xb2fa
leaq 0x8373(%rip), %rcx # 0xbe11
movl $0x48, %edx
callq 0x20d0
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/codegen.c
|
inc
|
static void inc(Type *ty) {
printfln(" pop rax");
// ポインタの場合はそのポインタが指す先の型のサイズ分インクリメントする。(int *x; x++ が4バイト先に進むような場合)
// ポインタでない場合は単に値を1増やす int i = 0; i++; でiが1になる みたいな場合
printfln(" add rax, %ld\n", ty->ptr_to ? ty->ptr_to->size : 1);
printfln(" push rax");
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x79b5(%rip), %rdi # 0xb468
xorl %eax, %eax
callq 0x27b5
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x3ac8
movl 0x4(%rax), %esi
jmp 0x3acd
movl $0x1, %esi
leaq 0x8398(%rip), %rdi # 0xbe6c
xorl %eax, %eax
callq 0x27b5
leaq 0x78d1(%rip), %rdi # 0xb3b3
xorl %eax, %eax
popq %rbx
jmp 0x27b5
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/codegen.c
|
type_info_helper
|
int type_info_helper(char *buf, int offset, Type *type) {
int n = 0;
#pragma clang diagnostic ignored "-Wswitch"
switch (type->kind) {
case TY_VOID:
n += sprintf(buf + offset, "void");
break;
case TY_INT:
n += sprintf(buf + offset, "int");
break;
case TY_CHAR:
n += sprintf(buf + offset, "char");
break;
case TY_SHORT:
n += sprintf(buf + offset, "short");
break;
case TY_LONG:
n += sprintf(buf + offset, "long");
break;
case TY_PTR:
n += sprintf(buf + offset, "*");
n += type_info_helper(buf, offset + n, type->ptr_to);
break;
case TY_ARRAY:
// int x[2][3]と宣言された配列の場合
//
// TY_ARRAY
// array_size: 2
// ptr_to ---------> TY_ARRAY
// array_size: 3
// ptr_to --------> TY_INT
//
// と、「「intのサイズ3の配列」のサイズ2の配列」という構造になるので、
n += sprintf(buf + offset, "[%ld]", type->array_size);
n += type_info_helper(buf, offset + n, type->ptr_to);
break;
case TY_STRUCT:
n += sprintf(buf + offset, "struct (size %d) {", type->size);
for (Member *m = type->members; m; m = m->next) {
n += type_info_helper(buf, offset + n, m->ty);
n += sprintf(buf + offset + n, " %s (offset %d)", m->name, m->offset);
if (m->next) {
n += sprintf(buf + offset + n, " ");
}
}
n += sprintf(buf + offset + n, "}");
break;
}
return n;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %rbx
movabsq $0x100000000, %r13 # imm = 0x100000000
leaq 0x8425(%rip), %rdx # 0xbf98
leaq 0x8785(%rip), %rsi # 0xc2ff
xorl %ebp, %ebp
movslq %r14d, %r15
leaq (%rbx,%r15), %rax
shlq $0x20, %r15
jmp 0x3b9e
movw $0x2a, (%rax)
movq 0x10(%r12), %r12
addq %r13, %r15
incl %r14d
incq %rax
incl %ebp
movl (%r12), %ecx
cmpl $0x7, %ecx
je 0x3b89
decl %ecx
cmpl $0x8, %ecx
ja 0x3cea
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
sarq $0x20, %r15
addq %rbx, %r15
movq 0x18(%r12), %rdx
movq %r15, %rdi
movq %rsi, %r15
xorl %eax, %eax
callq 0x21c0
movq %r15, %rsi
leaq 0x83ba(%rip), %rdx # 0xbf98
addl %eax, %r14d
movq 0x10(%r12), %r12
addl %eax, %ebp
jmp 0x3b7c
sarq $0x20, %r15
movl $0x746e69, (%rbx,%r15) # imm = 0x746E69
movl $0x3, %eax
jmp 0x3cec
sarq $0x20, %r15
movb $0x0, 0x4(%rbx,%r15)
movl $0x64696f76, (%rbx,%r15) # imm = 0x64696F76
jmp 0x3ce3
sarq $0x20, %r15
movw $0x74, 0x4(%rbx,%r15)
movl $0x726f6873, (%rbx,%r15) # imm = 0x726F6873
movl $0x5, %eax
jmp 0x3cec
sarq $0x20, %r15
addq %rbx, %r15
movl 0x4(%r12), %edx
leaq 0x86bd(%rip), %rsi # 0xc305
movq %r15, %rdi
xorl %eax, %eax
callq 0x21c0
movl %eax, %r13d
movq 0x20(%r12), %r12
testq %r12, %r12
je 0x3caf
leal (%r14,%r13), %esi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x3b4e
addl %r13d, %eax
movslq %eax, %r13
leaq (%r15,%r13), %rdi
movq 0x10(%r12), %rdx
movl 0x18(%r12), %ecx
leaq 0x868d(%rip), %rsi # 0xc318
xorl %eax, %eax
callq 0x21c0
addl %eax, %r13d
cmpq $0x0, (%r12)
je 0x3caf
movslq %r13d, %r13
movw $0x20, (%r15,%r13)
incl %r13d
movq (%r12), %r12
jmp 0x3c5a
movslq %r13d, %rax
movw $0x7d, (%r15,%rax)
incl %eax
jmp 0x3cec
sarq $0x20, %r15
movb $0x0, 0x4(%rbx,%r15)
movl $0x676e6f6c, (%rbx,%r15) # imm = 0x676E6F6C
jmp 0x3ce3
sarq $0x20, %r15
movb $0x0, 0x4(%rbx,%r15)
movl $0x72616863, (%rbx,%r15) # imm = 0x72616863
movl $0x4, %eax
jmp 0x3cec
xorl %eax, %eax
addl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/debug.c
|
node_ast
|
char *node_ast(Node *node) {
char buf[10000];
int n = 0;
if (!node) {
return NULL;
}
switch (node->kind) {
case ND_DUMMY:
break;
case ND_ADD:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(+ %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_PTR_ADD:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(ptr+ %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_SUB:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(- %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_PTR_SUB:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(ptr- %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_PTR_DIFF:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(ptr-diff %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_MUL:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(* %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_DIV:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(/ %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_BIT_XOR:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(^ %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_BIT_OR:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(| %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_BIT_AND:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(& %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_AND:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(&& %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_OR:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(|| %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_LT:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(< %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_LTE:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(<= %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_EQL:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(== %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_NOT_EQL:
{
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(!= %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_ASSIGN:
{
assert(node->lhs);
assert(node->rhs);
char *l = node_ast(node->lhs);
char *r = node_ast(node->rhs);
n = sprintf(buf, "(let %s %s)", l, r);
char *ret = my_strndup(buf, n);
free(l);
free(r);
return ret;
}
case ND_VAR:
n = sprintf(buf, "(%cvar %s)", node->var->is_local ? 'l' : 'g', node->var->name);
return my_strndup(buf, n);
case ND_RETURN:
{
char *l = node_ast(node->lhs);
n = sprintf(buf, "(return %s)", l);
free(l);
return my_strndup(buf, n);
}
case ND_WHILE:
{
char *cond = node_ast(node->cond);
char *body = node_ast(node->body);
n = sprintf(buf, "(while (cond %s) (body %s))", cond, body);
char *ret = my_strndup(buf, n);
free(cond);
free(body);
return ret;
}
case ND_BLOCK:
{
int i = 0;
char *tmp_bufs[1000];
n += sprintf(buf, "(block ");
for (Node *nd = node->body; nd; nd = nd->next) {
tmp_bufs[i] = node_ast(nd);
n += sprintf(buf + n, "%s", tmp_bufs[i]);
if (nd->next) {
n += sprintf(buf + n, " ");
}
i++;
}
for (int j = 0; j < i; j++) {
free(tmp_bufs[j]);
}
n += sprintf(buf + n, ")");
return my_strndup(buf, n);
}
case ND_IF:
{
char *cond = node_ast(node->cond);
char *then = node_ast(node->then);
char *els = node_ast(node->els);
n = sprintf(buf, "(if (cond %s) (then %s) (else %s))", node_ast(node->cond), node_ast(node->then), node_ast(node->els));
char *ret = my_strndup(buf, n);
free(cond);
free(then);
free(els);
return ret;
}
case ND_FOR:
{
char *init = node_ast(node->init);
char *cond = node_ast(node->cond);
char *inc = node_ast(node->inc);
char *body = node_ast(node->body);
n = sprintf(buf, "(for (init %s) (cond %s) (inc %s) (body %s))", node_ast(node->init), node_ast(node->cond), node_ast(node->inc), node_ast(node->body));
char *ret = my_strndup(buf, n);
free(init);
free(cond);
free(inc);
free(body);
return ret;
}
case ND_CALL:
{
char *tmp_bufs[1000];
n = sprintf(buf, "(call (name %s)", node->funcname);
int i = 0;
for (Node *p = node->arg; p; p = p->next) {
char *tmp = tmp_bufs[i] = node_ast(p);
n += sprintf(buf + n, " %s", tmp);
i++;
}
n += sprintf(buf + n, ")");
char *ret = my_strndup(buf, n);
for (int j = 0; j < i; j++) {
free(tmp_bufs[j]);
}
return ret;
}
case ND_ADDR:
{
char *l = node_ast(node->lhs);
n = sprintf(buf, "(addr %s)", l);
char *ret = my_strndup(buf, n);
free(l);
return ret;
}
case ND_DEREF:
{
char *l = node_ast(node->lhs);
n = sprintf(buf, "(deref %s)", l);
char *ret = my_strndup(buf, n);
free(l);
return ret;
}
case ND_VAR_DECL:
{
char *ti = type_info(node->var->type);
n += sprintf(buf, "(decl (%s %s)", ti, node->var->name);
if (node->initializer) {
n += sprintf(buf + n, " (init %s)", node_ast(node->initializer));
}
n += sprintf(buf + n, ")");
char *ret = my_strndup(buf, n);
free(ti);
return ret;
}
case ND_EXPR_STMT:
{
char *l = node_ast(node->lhs);
n += sprintf(buf, "(expr-stmt %s)", l);
char *ret = my_strndup(buf, n);
free(l);
return ret;
}
case ND_NUM:
n += sprintf(buf, "(num %ld)", node->val);
return my_strndup(buf, n);
case ND_MEMBER:
{
char *l = node_ast(node->lhs);
n += sprintf(buf, "(member %s %s)", l, node->member->name);
char *ret = my_strndup(buf, n);
free(l);
return ret;
}
case ND_NOT:
{
char *l = node_ast(node->lhs);
n += sprintf(buf, "(! %s)", l);
char *ret = my_strndup(buf, n);
free(l);
return ret;
}
case ND_BIT_NOT:
{
char *l = node_ast(node->lhs);
n += sprintf(buf, "(~ %s)", l);
char *ret = my_strndup(buf, n);
free(l);
return ret;
}
case ND_BREAK:
n += sprintf(buf, "(break)");
return my_strndup(buf, n);
case ND_CONTINUE:
n += sprintf(buf, "(continue)");
return my_strndup(buf, n);
case ND_GOTO:
n += sprintf(buf, "(goto %s)", node->label_name);
return my_strndup(buf, n);
case ND_SWITCH:
{
char *cond = node_ast(node->lhs);
char *body = node_ast(node->body);
n += sprintf(buf, "(switch %s %s)", cond, body);
free(cond);
free(body);
return my_strndup(buf, n);
}
case ND_CASE:
{
char *stmt = node_ast(node->lhs);
if (node->is_default_case) {
n += sprintf(buf, "(default %s)", stmt);
} else {
n += sprintf(buf, "(case (cond %ld) %s)", node->case_cond_val, stmt);
}
free(stmt);
return my_strndup(buf, n);
}
case ND_NULL:
return "(ND_NULL)";
}
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4668, %rsp # imm = 0x4668
testq %rdi, %rdi
je 0x3d7e
movq %rdi, %rbx
movl (%rdi), %eax
decl %eax
cmpl $0x30, %eax
ja 0x3d7e
leaq 0x826b(%rip), %rcx # 0xbfbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x85af(%rip), %rsi # 0xc328
jmp 0x43b5
xorl %ebx, %ebx
jmp 0x4593
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
cmpb $0x1, 0xb0(%rbx)
jne 0x452c
leaq 0x878f(%rip), %rsi # 0xc534
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
jmp 0x4549
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x45a8
cmpq $0x0, 0x20(%rbx)
je 0x45c7
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8621(%rip), %rsi # 0xc40d
jmp 0x43b5
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8620(%rip), %rsi # 0xc430
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8547(%rip), %rsi # 0xc37b
jmp 0x43b5
movq 0x88(%rbx), %rdx
leaq 0x8655(%rip), %rsi # 0xc49c
xorl %r12d, %r12d
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x21c0
movl %eax, %r14d
movq 0x70(%rbx), %rbx
testq %rbx, %rbx
je 0x3ea3
leaq 0x8718(%rip), %r15 # 0xc581
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x3d28
movq %rax, 0x2720(%rsp,%r12,8)
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %r14d
incq %r12
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x3e6c
movslq %r14d, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
callq 0x4ae3
movq %rax, %rbx
testl %r12d, %r12d
je 0x4593
movl %r12d, %r14d
xorl %r15d, %r15d
movq 0x2720(%rsp,%r15,8), %rdi
callq 0x2030
incq %r15
cmpq %r15, %r14
jne 0x3ecb
jmp 0x4593
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x40(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
movq 0x48(%rbx), %rdi
callq 0x3d28
movq %rax, %r12
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r13
movq 0x40(%rbx), %rdi
callq 0x3d28
movq %rax, %rbp
movq 0x48(%rbx), %rdi
callq 0x3d28
leaq 0x851b(%rip), %rsi # 0xc44c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
movq %rbp, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
movq %r12, %rdi
jmp 0x44bc
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x840c(%rip), %rsi # 0xc399
jmp 0x43b5
movabsq $0x756e69746e6f6328, %rax # imm = 0x756E69746E6F6328
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl $0x296575, 0x7(%rdi) # imm = 0x296575
movl $0xa, %esi
jmp 0x458b
movq 0x78(%rbx), %rax
movq (%rax), %rdi
callq 0x3cfd
movq %rax, %r14
movq 0x78(%rbx), %rax
movq 0x8(%rax), %rcx
leaq 0x84ee(%rip), %rsi # 0xc4c1
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebp
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x4013
movslq %ebp, %rax
leaq (%rsp,%rax), %rbx
addq $0x10, %rbx
callq 0x3d28
leaq 0x84cb(%rip), %rsi # 0xc4cf
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %ebp
movslq %ebp, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
jmp 0x44b1
movabsq $0x206b636f6c6228, %rax # imm = 0x206B636F6C6228
movq %rax, 0x10(%rsp)
movq 0x28(%rbx), %rbx
movl $0x7, %r15d
testq %rbx, %rbx
je 0x457a
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x3d28
movq %rax, 0x2720(%rsp,%r12,8)
movslq %r15d, %r15
leaq (%rsp,%r15), %r14
addq $0x10, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x20a0
subl %r14d, %eax
addl %eax, %r15d
cmpq $0x0, 0x30(%rbx)
je 0x455c
movslq %r15d, %r15
movw $0x20, 0x10(%rsp,%r15)
incl %r15d
movq 0x30(%rbx), %rbx
incq %r12
testq %rbx, %rbx
jne 0x404e
jmp 0x455f
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x82cc(%rip), %rsi # 0xc38f
jmp 0x43b5
movq 0x78(%rbx), %rax
movzbl 0x14(%rax), %ecx
leal (%rcx,%rcx,4), %edx
addl $0x67, %edx
movq 0x8(%rax), %rcx
leaq 0x8338(%rip), %rsi # 0xc419
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
jmp 0x441c
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x822b(%rip), %rsi # 0xc33f
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x83ae(%rip), %rsi # 0xc4da
jmp 0x449a
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x98(%rbx), %rax
movq 0x10(%rax), %rcx
leaq 0x83a4(%rip), %rsi # 0xc4f3
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21c0
jmp 0x44ac
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x81e2(%rip), %rsi # 0xc367
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x81dc(%rip), %rsi # 0xc385
jmp 0x43b5
movq 0x58(%rbx), %rdi
callq 0x3d28
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, (%rsp)
movq 0x60(%rbx), %rdi
callq 0x3d28
movq %rax, %r12
movq 0x28(%rbx), %rdi
callq 0x3d28
movq %rax, %r13
movq 0x58(%rbx), %rdi
callq 0x3d28
movq %rax, %rbp
movq 0x38(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
movq 0x28(%rbx), %rdi
callq 0x3d28
leaq 0x825a(%rip), %rsi # 0xc46f
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2030
movq (%rsp), %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movq %r13, %rdi
jmp 0x44bc
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80b3(%rip), %rsi # 0xc332
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80ce(%rip), %rsi # 0xc371
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80e8(%rip), %rsi # 0xc3af
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80d9(%rip), %rsi # 0xc3c4
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x80c0(%rip), %rsi # 0xc3cf
jmp 0x43b5
movq 0x80(%rbx), %rdx
leaq 0x81c7(%rip), %rsi # 0xc4e9
jmp 0x440d
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8003(%rip), %rsi # 0xc349
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x7fef(%rip), %rsi # 0xc356
jmp 0x43b5
leaq 0x81e6(%rip), %rbx # 0xc556
jmp 0x4593
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8010(%rip), %rsi # 0xc3a4
jmp 0x43b5
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x3d28
movq %rax, %r15
leaq 0x8004(%rip), %rsi # 0xc3b9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %r15, %rdi
jmp 0x44bc
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x810f(%rip), %rsi # 0xc509
jmp 0x449a
movq 0xa0(%rbx), %rdx
leaq 0x810e(%rip), %rsi # 0xc51b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
jmp 0x458b
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x80c9(%rip), %rsi # 0xc502
jmp 0x449a
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %rbx
leaq 0x7fd6(%rip), %rsi # 0xc424
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2030
movq %r14, %rdi
jmp 0x450f
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x8031(%rip), %rsi # 0xc4b6
jmp 0x449a
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
leaq 0x8012(%rip), %rsi # 0xc4ac
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
movq %rbx, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
jmp 0x4593
movq 0x18(%rbx), %rdi
callq 0x3d28
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x3d28
movq %rax, %rbx
leaq 0x8040(%rip), %rsi # 0xc525
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebp
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r15, %rdi
movl %ebp, %esi
jmp 0x458b
movabsq $0x296b6165726228, %rax # imm = 0x296B6165726228
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movl $0x7, %esi
jmp 0x458b
movq 0xa8(%rbx), %rdx
leaq 0x8007(%rip), %rsi # 0xc541
leaq 0x10(%rsp), %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x21c0
movl %eax, %ebx
movq %r14, %rdi
callq 0x2030
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
jmp 0x458b
incq %r12
movl %r12d, %ebx
xorl %r14d, %r14d
movq 0x2720(%rsp,%r14,8), %rdi
callq 0x2030
incq %r14
cmpq %r14, %rbx
jne 0x4565
movslq %r15d, %rsi
movw $0x29, 0x10(%rsp,%rsi)
incl %esi
leaq 0x10(%rsp), %rdi
callq 0x4ae3
movq %rax, %rbx
movq %rbx, %rax
addq $0x4668, %rsp # imm = 0x4668
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7e2b(%rip), %rdi # 0xc3da
leaq 0x7e2e(%rip), %rsi # 0xc3e4
leaq 0x7e2f(%rip), %rcx # 0xc3ec
movl $0x14d, %edx # imm = 0x14D
callq 0x20d0
leaq 0x7e35(%rip), %rdi # 0xc403
leaq 0x7e0f(%rip), %rsi # 0xc3e4
leaq 0x7e10(%rip), %rcx # 0xc3ec
movl $0x14e, %edx # imm = 0x14E
callq 0x20d0
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/debug.c
|
node_ast_helper
|
char *node_ast_helper(Node *body) {
char *tmp_bufs[1000];// 文の数
char buf[10000];// ast dumpの文字列バッファ
int n = 0;
int i = 0;
n += sprintf(buf + n, "\n");
for (Node *nd = body; nd; nd = nd->next) {
char *tmp = tmp_bufs[i] = node_ast(nd);
n += sprintf(buf + n, "## %s\n", tmp);
}
char *ret = my_strndup(buf, n);
for (int j = 0; j < i; j++) {
free(tmp_bufs[j]);
}
return ret;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x2710, %rsp # imm = 0x2710
movw $0xa, (%rsp)
testq %rdi, %rdi
je 0x4635
movq %rdi, %r14
movl $0x1, %ebx
leaq 0x7f54(%rip), %r15 # 0xc560
movq %r14, %rdi
callq 0x3d28
movslq %ebx, %rbx
leaq (%rsp,%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %ebx
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x460c
jmp 0x463a
movl $0x1, %ebx
movq %rsp, %rdi
movl %ebx, %esi
callq 0x4ae3
addq $0x2710, %rsp # imm = 0x2710
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/debug.c
|
function_body_ast
|
char *function_body_ast(Function *f) {
int n = 0;
char buf[10000];
char *ti = type_info(f->return_type);
n = sprintf(buf + n, "(def (%s) %s (", ti, f->name);
free(ti);
int i = 0;
VarList* reverse_params = NULL;
// f->paramsは最後の引数からのリンクリストになってるのでダンプ用には逆順にする。
for (VarList *cur = f->params; cur; cur = cur->next) {
VarList *vl = calloc(1, sizeof(VarList));
vl->next = reverse_params;
vl->var = cur->var;
reverse_params = vl;
}
// 逆順にしたリストからastダンプ
for (VarList *p = reverse_params; p; p = p->next) {
char *ti = type_info(p->var->type);
n += sprintf(buf + n, "%s %s", ti, p->var->name);
free(ti);
if (p->next) {
n += sprintf(buf + n, " ");
}
}
// 逆順のリストはもういらないので捨てる。(そこに紐づくLVar は別途freeされるので無視する)
VarList *rp = reverse_params;
while (rp) {
VarList *tmp = rp->next;
free(rp);
rp = tmp;
}
char *body_ast = node_ast_helper(f->body);
n += sprintf(buf + n, ") ( %s", body_ast);
n += sprintf(buf + n, "## ))");
free(body_ast);
return my_strndup(buf, n);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e38, %rsp # imm = 0x4E38
movq %rdi, %r12
movq 0x8(%rdi), %rdx
leaq 0x2720(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3b4e
movq %r14, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %r15
movq 0x10(%r12), %rcx
leaq 0x7ed5(%rip), %rsi # 0xc569
leaq 0x10(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
movl %eax, %r14d
movq %r15, %rdi
callq 0x2030
movq 0x28(%r12), %rbx
testq %rbx, %rbx
je 0x477b
movq %r12, 0x8(%rsp)
xorl %r15d, %r15d
movq %r15, %r12
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %rax, %r15
movq %r12, (%rax)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r15)
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x46c4
leaq 0x2720(%rsp), %r12
leaq 0x7e7d(%rip), %r13 # 0xc578
movq %r15, %rbx
movq 0x8(%rbx), %rax
movq (%rax), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x3b4e
movq %r12, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, %rbp
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x21c0
addl %eax, %r14d
movq %rbp, %rdi
callq 0x2030
cmpq $0x0, (%rbx)
je 0x4763
movslq %r14d, %r14
movw $0x20, 0x10(%rsp,%r14)
incl %r14d
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x46fe
movq 0x8(%rsp), %r12
movq (%r15), %rbx
movq %r15, %rdi
callq 0x2030
movq %rbx, %r15
testq %rbx, %rbx
jne 0x4768
movq 0x18(%r12), %rdi
callq 0x45e6
movq %rax, %rbx
movslq %r14d, %r14
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
leaq 0x7de4(%rip), %rsi # 0xc57e
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
leal (%rax,%r14), %ecx
movslq %ecx, %rcx
movl $0x29202323, 0x10(%rsp,%rcx) # imm = 0x29202323
movw $0x29, 0x14(%rsp,%rcx)
leal (%rax,%r14), %ebp
addl $0x5, %ebp
movq %rbx, %rdi
callq 0x2030
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x4ae3
addq $0x4e38, %rsp # imm = 0x4E38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/debug.c
|
dump_globals
|
void dump_globals(VarList *vars) {
VarList *v = vars;
while (v) {
Node *dummy = calloc(1, sizeof(Node));
dummy->kind = ND_VAR_DECL; // ローカル変数の宣言のダンプを使い回す
dummy->var = v->var;
printf("## %s\n", node_ast(dummy));
v = v->next;
}
}
|
testq %rdi, %rdi
je 0x485e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7d6e(%rip), %r14 # 0xc58b
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x20, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x78(%rax)
movq %rax, %rdi
callq 0x3d28
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x481d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/debug.c
|
error_at
|
void error_at(char *loc, char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
int column = get_pos_by_line(loc);
fprintf(stderr, "file: %s\n", filename);
fprintf(stderr, "%s\n", get_error_lines(loc));
fprintf(stderr, "%*s", column, "");
fprintf(stderr, "^ ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
exit(1);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x48e3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rsi, 0x10(%r14)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%r14)
callq 0x49a9
movl %eax, %ebp
movq 0xb6e7(%rip), %r13 # 0xfff8
movq (%r13), %rdi
leaq 0xbb54(%rip), %rax # 0x10470
movq (%rax), %rdx
leaq 0x7d76(%rip), %rsi # 0xc69c
xorl %eax, %eax
callq 0x2120
movq (%r13), %r12
movq %r15, %rdi
callq 0x49d0
leaq 0x7c25(%rip), %rsi # 0xc565
movq %r12, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2120
movq (%r13), %rdi
leaq 0x7d4e(%rip), %rsi # 0xc6a6
leaq 0x752c(%rip), %rcx # 0xbe8b
movl %ebp, %edx
xorl %eax, %eax
callq 0x2120
movq (%r13), %rcx
leaq 0x7d37(%rip), %rdi # 0xc6aa
movl $0x2, %esi
movl $0x1, %edx
callq 0x21e0
movq (%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21b0
movq (%r13), %rsi
movl $0xa, %edi
callq 0x20f0
movl $0x1, %edi
callq 0x21d0
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
consume_end
|
static Token *consume(char *op) {
Token *tk = token;
if (!peek_token(op)) {
return NULL;
}
token = token->next;
return tk;
}
|
pushq %r15
pushq %r14
pushq %rbx
leaq 0x7b76(%rip), %rdi # 0xc6ad
callq 0x51eb
leaq 0xb93d(%rip), %rbx # 0x10480
movq (%rbx), %r14
testb %al, %al
je 0x4b55
movq %r14, %r15
movq 0x8(%r15), %r14
movb $0x1, %al
jmp 0x4b7e
leaq 0x7b53(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x4b7c
movq 0x8(%r14), %r15
movq %r15, (%rbx)
leaq 0x7b3a(%rip), %rdi # 0xc6ad
callq 0x51eb
testb %al, %al
jne 0x4b4d
xorl %eax, %eax
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
peek_end
|
bool peek_end() {
Token *tmp = token;
bool result = false;
if (consume("}")) {
result = true;
} else if (consume(",") && consume("}")) {
result = true;;
}
token = tmp;
return result;
}
|
pushq %r15
pushq %r14
pushq %rbx
leaq 0xb8ed(%rip), %rbx # 0x10480
movq (%rbx), %r14
leaq 0x7b10(%rip), %rdi # 0xc6ad
callq 0x51eb
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x4bdb
leaq 0x7afe(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x4bd9
movq 0x8(%r14), %r15
movq %r15, (%rbx)
leaq 0x7ae5(%rip), %rdi # 0xc6ad
callq 0x51eb
movl %eax, %ecx
testq %r15, %r15
setne %al
andb %cl, %al
jmp 0x4bdb
xorl %eax, %eax
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
program
|
Program *program() {
Function head = {};
Function *cur = &head;
while (!at_eof()) {
switch(next_decl()) {
case NEXT_DECL_FUNCTION_DEF:
{
Function *f = function_def_or_decl();
if (f) {
cur->next = f;
cur = cur->next;
}
}
break;
case NEXT_DECL_GLOBAL_VAR_OR_TYPEDEF:
global_var_decl();
break;
default:
// ここには来ないはず
assert(false);
}
}
Program *program = calloc(1, sizeof(Program));
program->global_var = globals;
program->functions = head.next;
return program;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq $0x0, 0x30(%rsp)
leaq 0xb87b(%rip), %rax # 0x10480
movq (%rax), %r12
cmpl $0x1e, (%r12)
jne 0x4c16
xorl %ebx, %ebx
jmp 0x516e
leaq 0x30(%rsp), %r15
leaq 0x8(%rsp), %rbp
leaq 0x794f(%rip), %rbx # 0xc576
movl $0x0, 0x8(%rsp)
movq %rbp, %rdi
callq 0x522f
cmpl $0x1, 0x8(%rsp)
je 0x4d30
movq %rax, %r14
leaq 0x7a6e(%rip), %rdi # 0xc6ba
callq 0x51eb
testb %al, %al
jne 0x4d30
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
callq 0x58f5
movq %rbx, %rdi
callq 0x51eb
testb %al, %al
je 0x4d30
leaq 0xb803(%rip), %rax # 0x10480
movq %r12, (%rax)
movq $0x0, 0xb7c5(%rip) # 0x10450
leaq 0x1c(%rsp), %rdi
callq 0x522f
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x58f5
movq %rax, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r13
movq %r14, 0x8(%rax)
movq 0x10(%rsp), %r12
movq %r12, 0x10(%rax)
movq %r14, %rdi
callq 0x9e59
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x761c
movb $0x0, 0x20(%rax)
movq 0xb75c(%rip), %rax # 0x10440
movq %rax, 0x20(%rsp)
movq 0xb748(%rip), %rax # 0x10438
movq %rax, 0x28(%rsp)
incl 0xb735(%rip) # 0x10430
movq %rbx, %rdi
leaq 0xb77b(%rip), %rbx # 0x10480
callq 0x5b5c
leaq 0x7878(%rip), %rdi # 0xc589
callq 0x51eb
movq (%rbx), %r14
testb %al, %al
je 0x4e52
movq 0x8(%r14), %rax
movq %rax, (%rbx)
xorl %r12d, %r12d
jmp 0x5008
leaq 0xb749(%rip), %rbx # 0x10480
movq %r12, (%rbx)
movl $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x522f
movq %rax, %r14
leaq 0x7964(%rip), %rdi # 0xc6ba
callq 0x51eb
movq (%rbx), %r13
testb %al, %al
je 0x4d6e
movq 0x8(%r13), %rax
movq %rax, (%rbx)
jmp 0x5040
movq %r14, %rdi
movq %rbp, %rsi
callq 0x58f5
movq %rax, %r14
movl 0x10(%rsp), %ebp
cmpl $0x1, %ebp
jne 0x4dd1
leaq 0x792e(%rip), %rdi # 0xc6ba
callq 0x5b5c
movq 0x8(%rsp), %r12
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %r12, 0x8(%rax)
movq 0xb690(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movl 0xb677(%rip), %ecx # 0x10430
movl %ecx, 0x2c(%rax)
movq %rax, 0xb67d(%rip) # 0x10440
movq %r14, 0x18(%rax)
leaq 0x8(%rsp), %rbp
jmp 0x5040
movq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x761c
movq %rax, %r12
cmpl $0x2, %ebp
sete 0x20(%rax)
cmpl $0x4, %ebp
je 0x4e13
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %r12, 0x8(%rax)
movq 0xb61f(%rip), %rcx # 0x10428
movq %rcx, (%rax)
movq %rax, 0xb615(%rip) # 0x10428
cmpl $0x4, 0x10(%rsp)
leaq 0x8(%rsp), %rbp
je 0x4e84
leaq 0x7adb(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x4e79
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x76f2
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r12)
jmp 0x4e84
cmpl $0xa, (%r14)
jne 0x4e95
movq 0x8(%r14), %r12
movq %r12, (%rbx)
leaq 0x7723(%rip), %rdi # 0xc589
callq 0x51eb
testb %al, %al
je 0x4e95
movq 0x8(%r12), %rax
jmp 0x4d25
cmpb $0x1, 0xc(%r14)
je 0x519d
leaq 0x782f(%rip), %rdi # 0xc6ba
callq 0x5b5c
jmp 0x5040
movq %r14, (%rbx)
xorl %edi, %edi
callq 0x522f
movq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x58f5
cmpl $0x8, (%rax)
jne 0x4eba
movq 0x10(%rax), %rdi
callq 0x9de4
movq 0x40(%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x761c
movq %rax, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %r14, 0x8(%rax)
movq 0xb567(%rip), %rcx # 0x10450
movq %rcx, (%rax)
movq %rax, 0xb55d(%rip) # 0x10450
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %rax, %rbp
movq %r14, 0x8(%rax)
leaq 0x7679(%rip), %rdi # 0xc589
callq 0x51eb
testb %al, %al
je 0x4f21
movq %rbp, %r14
jmp 0x4fcc
leaq 0x7787(%rip), %rdi # 0xc6af
callq 0x5b5c
leaq 0x7c50(%rip), %rdi # 0xcb84
callq 0x51eb
testb %al, %al
jne 0x4fde
xorl %edi, %edi
callq 0x522f
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x58f5
cmpl $0x8, (%rax)
jne 0x4f63
movq 0x10(%rax), %rdi
callq 0x9de4
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x761c
movq %rax, %r12
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %r12, 0x8(%rax)
movq 0xb4be(%rip), %rcx # 0x10450
movq %rcx, (%rax)
movq %rax, 0xb4b4(%rip) # 0x10450
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %rax, %r14
movq %r12, 0x8(%rax)
movq %rbp, (%rax)
leaq 0x75cd(%rip), %rdi # 0xc589
callq 0x51eb
movq %r14, %rbp
testb %al, %al
je 0x4f21
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
xorl %r12d, %r12d
movq %r14, %rbp
jmp 0x4fff
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movb $0x1, 0x35(%r13)
leaq 0x7595(%rip), %rdi # 0xc589
callq 0x5b5c
movl $0x38, %r12d
movq %rbp, 0x28(%r13)
leaq 0x8(%rsp), %rbp
leaq 0x76ab(%rip), %rdi # 0xc6ba
callq 0x51eb
testb %al, %al
je 0x5060
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0xb412(%rip) # 0x10440
movq 0x28(%rsp), %rax
movq %rax, 0xb3fe(%rip) # 0x10438
decl 0xb3f0(%rip) # 0x10430
movq %r15, %r13
movq (%rbx), %r12
cmpl $0x1e, (%r12)
movq %r13, %r15
leaq 0x7521(%rip), %rbx # 0xc576
jne 0x4c27
jmp 0x5169
leaq 0x72af(%rip), %rdi # 0xc316
callq 0x5b5c
movl $0xc8, %edx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x20e0
leaq 0x7626(%rip), %rdi # 0xc6ad
callq 0x51eb
testb %al, %al
je 0x5094
xorl %eax, %eax
jmp 0x50cd
movq %r15, 0x38(%rsp)
movq %r14, %rbp
leaq 0x760a(%rip), %r15 # 0xc6ad
callq 0x867b
movq %rax, %r14
movq %rax, 0x30(%rbp)
movq %r15, %rdi
callq 0x51eb
movq %r14, %rbp
testb %al, %al
je 0x50a3
movq 0x70(%rsp), %rax
leaq 0x8(%rsp), %rbp
movq 0x38(%rsp), %r15
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rbx)
movq %rax, 0x18(%r13)
movq 0xb36e(%rip), %rcx # 0x10450
movq %rcx, 0x20(%r13)
cmpl $0x2, 0x1c(%rsp)
sete 0x34(%r13)
testq %rcx, %rcx
je 0x5122
movq 0x8(%rcx), %rsi
movq (%rsi), %rdi
movl 0x8(%rdi), %r8d
movl %r12d, %eax
cltd
idivl %r8d
cmpl $0x1, %edx
movl %eax, %r12d
sbbl $-0x1, %r12d
imull %r8d, %r12d
addl 0x4(%rdi), %r12d
movl %r12d, 0x10(%rsi)
movq (%rcx), %rcx
jmp 0x50f0
leal 0x7(%r12), %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
shrl $0x3, %eax
andl $0x7, %r12d
cmpl $0x1, %r12d
sbbl $-0x1, %eax
shll $0x3, %eax
movl %eax, 0x30(%r13)
movq 0x20(%rsp), %rax
movq %rax, 0xb2f1(%rip) # 0x10440
movq 0x28(%rsp), %rax
movq %rax, 0xb2dd(%rip) # 0x10438
decl 0xb2cf(%rip) # 0x10430
movq %r13, (%r15)
jmp 0x5043
movq 0x30(%rsp), %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq 0xb2a4(%rip), %rcx # 0x10428
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r13), %rdi
leaq 0x79be(%rip), %rsi # 0xcb66
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
peek_token
|
static bool peek_token(char *op) {
if (token->kind != TK_RESERVED ||
token->len != strlen(op) ||
memcmp(token->str, op, token->len)) {
return false;
}
return true;
}
|
pushq %r15
pushq %r14
pushq %rbx
leaq 0xb289(%rip), %rax # 0x10480
movq (%rax), %r15
cmpl $0x1, (%r15)
jne 0x5227
movq %rdi, %rbx
movslq 0x20(%r15), %r14
callq 0x20b0
cmpq %r14, %rax
jne 0x5227
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
sete %al
jmp 0x5229
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
basetype
|
static Type *basetype(StorageClass *sclass) {
if (!is_type(token)) {
error_at(token->str, "typename expected");
}
// typedef x
// なども合法なのでデフォルトの型をintにしておく
Type *ty = int_type;
// 各型が何回出てきたかを数えるcounter
int counter = 0;
// counterに加えていく値。
// 適当に2回足してもかぶらないようにシフトさせているんだと思う
enum {
VOID = 1 << 0,
BOOL = 1 << 2,
CHAR = 1 << 4,
SHORT = 1 << 6,
INT = 1 << 8,
LONG = 1 << 10,
OTHER = 1 << 12,
};
// storage class が指定可能な場所はまず未定義で初期化
if (sclass) {
*sclass = 0;
}
while (is_type(token)) {
Token *tk = token;
if (peek_kind(TK_TYPEDEF) || peek_kind(TK_STATIC) || peek_kind(TK_EXTERN)) {
if (!sclass) {
error_at(tk->str, "ストレージクラス指定子はここでは使えません");
}
// 一度でもどこかにtypedef/staticがついていたら覚えておく
if (consume_kind(TK_TYPEDEF)) {
*sclass |= TYPEDEF;
} else if (consume_kind(TK_STATIC)) {
*sclass |= STATIC;
} else if (consume_kind(TK_EXTERN)) {
*sclass |= EXTERN;
}
// typedef と static と extern を同時に使っていたらエラーにする
// 001 010 100
// 3bitのうちどこか1bitのみ立っている場合だけOKでそれ以外はNGにしたい。
// ある値xがあったとして
// x & (x - 1) が 0 になる場合は どこかの1bitしか立っていないということに鳴るらしい
// 例
// x = 0b0010 の場合
// x & (x - 1) = 0b0010 & 0b0001 = 0
//
// x = 0b0011 の場合
// x & (x - 1) = 0b0011 & 0b0001 = 0b0001
//
// となり、複数のbitが立っているときのみ0以外になる
if (*sclass & (*sclass - 1)) {
// どこかの複数のbitが立っていた場合は複数のsclassが使われていることになるので
error_at(tk->str, "static、typedefとexternは同時に指定できません");
}
continue;
}
if (!is_builtin_type(tk)) {
if (counter) {
//ビルトインの型名じゃないものがきて、かつ、一度でも何かの型を読んでいたら
//変数宣言(またはtypedef)の後の識別子にきてるので、終了
break;
}
//まだ何も型名を読んでいなくて、ビルトインの方じゃない場合は、構造体か、typedefされた型名になる。
if (tk->kind == TK_STRUCT) {
ty = struct_decl();
} else if (tk->kind == TK_ENUM) {
ty = enum_decl();
} else {
ty = find_typedef(tk);
// fprintf(stderr, "found typedef: %s\n", my_strndup(tk->str, tk->len));
// fprintf(stderr, "found is_incomplete: %d\n", ty->is_incomplete);
assert(ty);
token = token->next;
}
// ビルトイン以外の型を読んだのでカウンターを上げる
counter += OTHER;
continue;
}
if (consume_kind(TK_VOID)) {
counter += VOID;
} else if (consume_kind(TK_BOOL)) {
counter += BOOL;
} else if (consume_kind(TK_CHAR)) {
counter += CHAR;
} else if (consume_kind(TK_SHORT)) {
counter += SHORT;
} else if (consume_kind(TK_INT)) {
counter += INT;
} else if (consume_kind(TK_LONG)) {
counter += LONG;
}
// counterがとり得る値のみ許可して他はエラー
switch (counter) {
case VOID:
ty = void_type;
break;
case BOOL:
ty = bool_type;
break;
case CHAR:
ty = char_type;
break;
case SHORT:
case SHORT + INT: // これで short int, int short どっちも判断できる
ty = short_type;
break;
case INT:
ty = int_type;
break;
case LONG:
case LONG + INT:
case LONG + LONG:
case LONG + LONG + INT:
ty = long_type;
break;
default:
error_at(tk->str, "不正な型です");
}
}
return ty;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xb23c(%rip), %r15 # 0x10480
movq (%r15), %r14
movl (%r14), %eax
leal -0xa(%rax), %ecx
cmpl $0x6, %ecx
movq %rdi, (%rsp)
jb 0x526d
cmpl $0x17, %eax
ja 0x57b2
movl $0xe30000, %ecx # imm = 0xE30000
btl %eax, %ecx
jae 0x57b2
leaq 0xb0ec(%rip), %rax # 0x10360
movq (%rax), %rbp
testq %rdi, %rdi
je 0x5282
movl $0x0, (%rdi)
xorl %r12d, %r12d
movl (%r14), %ebx
leal -0xa(%rbx), %eax
cmpl $0x6, %eax
jae 0x52ef
jae 0x52a6
movl %eax, %eax
movq 0x8(%r14), %rcx
movq %rcx, (%r15)
leaq 0x73e2(%rip), %rcx # 0xc684
addl (%rcx,%rax,4), %r12d
cmpl $0x13f, %r12d # imm = 0x13F
jg 0x5325
cmpl $0xf, %r12d
jle 0x5404
cmpl $0x10, %r12d
je 0x5545
cmpl $0x40, %r12d
je 0x544c
cmpl $0x100, %r12d # imm = 0x100
jne 0x5820
leaq 0xb07f(%rip), %rax # 0x10360
movq (%rax), %rbp
movl $0x100, %r12d # imm = 0x100
jmp 0x5798
leal -0x15(%rbx), %r13d
cmpl $0x3, %r13d
jae 0x535e
testq %rdi, %rdi
je 0x57ef
cmpl $0x16, %ebx
je 0x545b
cmpl $0x15, %ebx
jne 0x5469
movq 0x8(%r14), %rax
movq %rax, (%r15)
movl (%rdi), %eax
orl $0x1, %eax
jmp 0x5475
cmpl $0x4ff, %r12d # imm = 0x4FF
jle 0x542d
cmpl $0x500, %r12d # imm = 0x500
je 0x5443
cmpl $0x800, %r12d # imm = 0x800
je 0x5443
cmpl $0x900, %r12d # imm = 0x900
je 0x5443
jmp 0x5820
leal -0x10(%rbx), %eax
cmpl $0x2, %eax
jae 0x5487
testl %r12d, %r12d
jne 0x57a0
cmpl $0x11, %ebx
je 0x54ab
cmpl $0x10, %ebx
jne 0x5510
movl $0x10, %edi
callq 0x5a49
movq (%r15), %r14
cmpl $0x2, (%r14)
leaq 0x6f79(%rip), %r12 # 0xc316
jne 0x555a
movq 0x8(%r14), %rbx
movq %rbx, (%r15)
movq %r12, %rdi
callq 0x51eb
testb %al, %al
je 0x5651
movq %r12, %rdi
callq 0x51eb
testb %al, %al
je 0x563e
movq 0x8(%rbx), %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x5a7d
testq %rax, %rax
je 0x5698
movl 0x18(%rax), %ecx
cmpl 0xb045(%rip), %ecx # 0x10430
jne 0x5698
movq 0x10(%rax), %rbp
cmpl $0x9, (%rbp)
je 0x56b0
jmp 0x5889
cmpl $0x1, %r12d
je 0x5530
cmpl $0x4, %r12d
jne 0x5820
leaq 0xaf09(%rip), %rax # 0x10328
movq (%rax), %rbp
movl $0x4, %r12d
jmp 0x5798
cmpl $0x140, %r12d # imm = 0x140
je 0x544c
cmpl $0x400, %r12d # imm = 0x400
jne 0x5820
leaq 0xaf86(%rip), %rax # 0x103d0
jmp 0x5453
leaq 0xafb5(%rip), %rax # 0x10408
movq (%rax), %rbp
jmp 0x5798
movq 0x8(%r14), %rax
movq %rax, (%r15)
movl (%rdi), %eax
orl $0x2, %eax
jmp 0x5475
movl (%rdi), %eax
movq 0x8(%r14), %rcx
movq %rcx, (%r15)
orl $0x4, %eax
movl %eax, (%rdi)
leal -0x1(%rax), %ecx
testl %ecx, %eax
je 0x5798
jmp 0x57e2
movq %r14, %rdi
callq 0x59dc
movq (%rsp), %rdi
testq %rax, %rax
je 0x57a0
cmpl $0x2, %r13d
jbe 0x52f9
jmp 0x536a
movl $0x11, %edi
callq 0x5a49
movq (%r15), %r14
movl (%r14), %ebx
cmpl $0x2, %ebx
leaq 0x6e51(%rip), %r12 # 0xc316
jne 0x557e
movq 0x8(%r14), %rax
movq %rax, (%r15)
movq %r12, %rdi
callq 0x51eb
testb %al, %al
jne 0x5581
movq %r14, %rdi
callq 0x5a7d
testq %rax, %rax
je 0x582d
movq 0x10(%rax), %rbp
movl $0x1000, %r12d # imm = 0x1000
cmpl $0xa, (%rbp)
movq (%rsp), %rdi
je 0x5798
jmp 0x585b
movq %r14, %rdi
callq 0x59dc
testq %rax, %rax
je 0x5801
movq %rax, %rbp
movq 0x8(%r14), %rax
movq %rax, (%r15)
jmp 0x578e
leaq 0xadb9(%rip), %rax # 0x102f0
movq (%rax), %rbp
movl $0x1, %r12d
jmp 0x5798
leaq 0xae4c(%rip), %rax # 0x10398
movq (%rax), %rbp
movl $0x10, %r12d
jmp 0x5798
movq %r12, %rdi
callq 0x51eb
testb %al, %al
je 0x563e
movq 0x8(%r14), %rax
movq %rax, (%r15)
callq 0x9eac
movq %rax, %rbp
jmp 0x56b0
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x5b5c
xorl %r13d, %r13d
callq 0x9e86
movq %rax, %rbp
callq 0x5bde
movq %rax, %r12
leaq 0x735e(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x55c8
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %rax, (%r15)
callq 0x5fef
movq %rax, %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r13
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %r12, 0x8(%rax)
movq 0xae5e(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movl 0xae45(%rip), %ecx # 0x10430
movl %ecx, 0x2c(%rax)
movq %rax, 0xae4b(%rip) # 0x10440
movq %rbp, 0x20(%rax)
movl %r13d, 0x28(%rax)
callq 0x4b2b
testb %al, %al
jne 0x561a
incl %r13d
leaq 0x709f(%rip), %rdi # 0xc6af
callq 0x5b5c
jmp 0x5594
movl $0x1000, %r12d # imm = 0x1000
cmpl $0x2, %ebx
jne 0x5794
movq 0x18(%r14), %rdi
movl 0x20(%r14), %esi
movq %rbp, %rdx
callq 0x5ad5
jmp 0x5794
movl $0x1000, %r12d # imm = 0x1000
callq 0x9eac
movq %rax, %rbp
jmp 0x5794
movq %r14, %rdi
callq 0x5a7d
testq %rax, %rax
je 0x567b
movq 0x10(%rax), %rbp
movl $0x1000, %r12d # imm = 0x1000
cmpl $0x9, (%rbp)
movq (%rsp), %rdi
je 0x5798
jmp 0x5889
callq 0x9eac
movq %rax, %rbp
movq 0x18(%r14), %rdi
movl 0x20(%r14), %esi
movq %rax, %rdx
callq 0x5ad5
jmp 0x578e
callq 0x9eac
movq %rax, %rbp
movq 0x18(%r14), %rdi
movl 0x20(%r14), %esi
movq %rax, %rdx
callq 0x5ad5
movq $0x0, 0x8(%rsp)
leaq 0x6fed(%rip), %rdi # 0xc6ad
callq 0x51eb
testb %al, %al
jne 0x5735
leaq 0x8(%rsp), %rbx
xorl %edi, %edi
callq 0x522f
movq (%r15), %r12
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x58f5
cmpb $0x1, 0xc(%rax)
je 0x57d4
movq %rax, %r14
leaq 0x6fc1(%rip), %rdi # 0xc6ba
callq 0x5b5c
movl $0x1, %edi
movl $0x20, %esi
callq 0x2100
movq %rax, %r12
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r12)
movq %r14, 0x8(%r12)
movq %r12, (%rbx)
leaq 0x6f84(%rip), %rdi # 0xc6ad
callq 0x51eb
movq %r12, %rbx
testb %al, %al
je 0x56ce
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %rax, (%r15)
movq 0x8(%rsp), %rsi
movq %rsi, 0x20(%rbp)
movl 0x8(%rbp), %ecx
xorl %eax, %eax
testq %rsi, %rsi
je 0x577b
movq 0x8(%rsi), %r8
movl 0x8(%r8), %edi
cltd
idivl %edi
cmpl $0x1, %edx
sbbl $-0x1, %eax
imull %edi, %eax
movl %eax, 0x18(%rsi)
addl 0x4(%r8), %eax
cmpl %edi, %ecx
jge 0x5776
movl %edi, 0x8(%rbp)
movl %edi, %ecx
movq (%rsi), %rsi
jmp 0x574d
cltd
idivl %ecx
cmpl $0x1, %edx
sbbl $-0x1, %eax
imull %ecx, %eax
movl %eax, 0x4(%rbp)
movb $0x0, 0xc(%rbp)
movl $0x1000, %r12d # imm = 0x1000
movq (%rsp), %rdi
movq (%r15), %r14
jmp 0x5285
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x59dc
movq (%rsp), %rdi
testq %rax, %rax
jne 0x526d
movq 0x18(%r14), %rdi
leaq 0x6eea(%rip), %rsi # 0xc6bc
jmp 0x57fa
movq 0x18(%r12), %rdi
leaq 0x6fef(%rip), %rsi # 0xc7cf
jmp 0x57fa
movq 0x18(%r14), %rdi
leaq 0x6f21(%rip), %rsi # 0xc70e
jmp 0x57fa
movq 0x18(%r14), %rdi
leaq 0x6ed4(%rip), %rsi # 0xc6ce
xorl %eax, %eax
callq 0x487c
leaq 0x6f41(%rip), %rdi # 0xc749
leaq 0x6ea2(%rip), %rsi # 0xc6b1
leaq 0x6f36(%rip), %rcx # 0xc74c
movl $0x41f, %edx # imm = 0x41F
callq 0x20d0
movq 0x18(%r14), %rdi
leaq 0x6f40(%rip), %rsi # 0xc76b
jmp 0x57fa
movq 0x18(%r14), %rbx
movslq 0x20(%r14), %r15
leaq 0x1(%r15), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r14
testq %r15, %r15
jle 0x58b7
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2150
jmp 0x58ba
movq 0x18(%r14), %rbx
movslq 0x20(%r14), %r15
leaq 0x1(%r15), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r14
testq %r15, %r15
jle 0x58c8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2150
jmp 0x58cb
movq 0x18(%r14), %rbx
movslq 0x20(%r14), %r15
leaq 0x1(%r15), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r14
testq %r15, %r15
jle 0x58d9
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2150
jmp 0x58dc
xorl %r15d, %r15d
movb $0x0, (%r14,%r15)
leaq 0x6f73(%rip), %rsi # 0xc839
jmp 0x58e8
xorl %r15d, %r15d
movb $0x0, (%r14,%r15)
leaq 0x6f84(%rip), %rsi # 0xc85b
jmp 0x58e8
xorl %r15d, %r15d
movb $0x0, (%r14,%r15)
leaq 0x6e96(%rip), %rsi # 0xc77e
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
declarator
|
static Type *declarator(Type *ty, char **name) {
while (consume("*")) {
ty = pointer_to(ty);
}
if (consume("(")) {
Type *placeholder = calloc(1, sizeof(Type));
Type *new_ty = declarator(placeholder, name);
expect(")");
// 入れ子部分を全部パースした後に、その後に続く配列の [] などを含めた(type_suffix)型としてplaceholderを完成させる
memcpy(placeholder, type_suffix(ty), sizeof(Type));
return new_ty;
}
*name = expect_ident();
return type_suffix(ty);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x750d(%rip), %rdi # 0xce17
callq 0x51eb
testb %al, %al
je 0x5944
leaq 0xab66(%rip), %r12 # 0x10480
leaq 0x74f6(%rip), %r15 # 0xce17
movq (%r12), %rax
movq 0x8(%rax), %rax
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x9de4
movq %rax, %rbx
movq %r15, %rdi
callq 0x51eb
testb %al, %al
jne 0x5921
leaq 0x6c2b(%rip), %rdi # 0xc576
callq 0x51eb
testb %al, %al
je 0x59c1
leaq 0xab25(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x58f5
movq %rax, %r14
leaq 0x6bfd(%rip), %rdi # 0xc589
callq 0x5b5c
movq %rbx, %rdi
callq 0x6dbb
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r15)
movups %xmm1, 0x10(%r15)
movups %xmm2, 0x20(%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5bde
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6dbb
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
find_typedef
|
static Type *find_typedef(Token *tk) {
for (VarScope *sc = var_scope; sc; sc = sc->next) {
if (sc->var) {
// var はtypedefじゃないので無視
continue;
}
assert(sc);
if (strlen(sc->name) == tk->len &&
strncmp(sc->name, tk->str, tk->len) == 0) {
return sc->type_def;
}
}
return NULL;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xaa55(%rip), %r12 # 0x10440
testq %r12, %r12
je 0x5a31
movq %rdi, %r14
xorl %ebx, %ebx
cmpq $0x0, 0x10(%r12)
jne 0x5a26
movq 0x8(%r12), %r15
movq %r15, %rdi
callq 0x20b0
movslq 0x20(%r14), %rcx
cmpq %rcx, %rax
jne 0x5a26
movq 0x18(%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x2060
testl %eax, %eax
je 0x5a35
movq (%r12), %r12
testq %r12, %r12
jne 0x59f5
jmp 0x5a3a
xorl %ebx, %ebx
jmp 0x5a3a
movq 0x18(%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
find_tag
|
static TagScope *find_tag(Token *tk) {
for (TagScope *sc = tag_scope; sc; sc = sc->next) {
if (strlen(sc->name) == tk->len && strncmp(sc->name, tk->str, tk->len) == 0) {
// fprintf(stderr, "tag: %s, sc_name: %s\n", my_strndup(tk->str, tk->len), sc->name);
return sc;
}
}
return NULL;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xa9ac(%rip), %rbx # 0x10438
testq %rbx, %rbx
je 0x5ac4
movq %rdi, %r14
movslq 0x20(%rdi), %r15
movq 0x8(%rbx), %r12
movq %r12, %rdi
callq 0x20b0
cmpq %r15, %rax
jne 0x5abc
movq 0x18(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x2060
testl %eax, %eax
je 0x5ac6
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x5a98
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
push_tag_scope
|
static void push_tag_scope(Token *tag_tok, Type *type) {
TagScope *sc = calloc(1, sizeof(TagScope));
sc->name = my_strndup(tag_tok->str, tag_tok->len);
sc->ty = type;
sc->next = tag_scope;
sc->depth = scope_depth;
tag_scope = sc;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x2100
movq %rax, %r14
leal 0x1(%r12), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r13
testl %r12d, %r12d
jle 0x5b26
movl %r12d, %r12d
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2150
jmp 0x5b29
xorl %r12d, %r12d
movb $0x0, (%r13,%r12)
movq %r13, 0x8(%r14)
movq %rbx, 0x10(%r14)
movq 0xa8fa(%rip), %rax # 0x10438
movq %rax, (%r14)
movl 0xa8e9(%rip), %eax # 0x10430
movl %eax, 0x18(%r14)
movq %r14, 0xa8e6(%rip) # 0x10438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
expect
|
static void expect(char *op) {
if (token->kind != TK_RESERVED ||
token->len != strlen(op) ||
memcmp(token->str, op, token->len)) {
error_at(token->str, "'%c'(token->kind: %s, token->len: %d, op: %s)ではありません", op, token_kind_to_s(token->kind), token->len, op);
}
token = token->next;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xa912(%rip), %r15 # 0x10480
movq (%r15), %r12
movl (%r12), %ebp
cmpl $0x1, %ebp
jne 0x5bb1
movslq 0x20(%r12), %r14
movq %rbx, %rdi
callq 0x20b0
cmpq %r14, %rax
jne 0x5bb1
movq 0x18(%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2170
testl %eax, %eax
jne 0x5bb1
movq 0x8(%r12), %rax
movq %rax, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %r14
movl %ebp, %edi
callq 0x9568
movq (%r15), %rcx
movl 0x20(%rcx), %r8d
leaq 0x6c2b(%rip), %rsi # 0xc7f6
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
expect_ident
|
static char *expect_ident() {
if (token->kind != TK_IDENT) {
error_at(token->str, "識別子ではありません。");
}
char *s = my_strndup(token->str, token->len);
token = token->next;
return s;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0xa892(%rip), %r12 # 0x10480
movq (%r12), %r13
cmpl $0x2, (%r13)
movq 0x18(%r13), %r14
jne 0x5c43
movslq 0x20(%r13), %rbx
leaq 0x1(%rbx), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r15
testq %rbx, %rbx
jle 0x5c27
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2150
jmp 0x5c29
xorl %ebx, %ebx
movb $0x0, (%r15,%rbx)
movq 0x8(%r13), %rax
movq %rax, (%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6c31(%rip), %rsi # 0xc87b
movq %r14, %rdi
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
eval2
|
static long eval2(Node *node, Var **var) {
#pragma clang diagnostic ignored "-Wswitch"
switch (node->kind) {
case ND_ADD:
return eval(node->lhs) + eval(node->rhs);
case ND_PTR_ADD:
return eval2(node->lhs, var) + eval(node->rhs);
case ND_PTR_SUB:
return eval2(node->lhs, var) - eval(node->rhs);
case ND_SUB:
return eval(node->lhs) - eval(node->rhs);
case ND_MUL:
return eval(node->lhs) * eval(node->rhs);
case ND_DIV:
return eval(node->lhs) / eval(node->rhs);
case ND_BIT_AND:
return eval(node->lhs) & eval(node->rhs);
case ND_BIT_OR:
return eval(node->lhs) | eval(node->rhs);
case ND_BIT_XOR:
return eval(node->lhs) ^ eval(node->rhs);
case ND_A_LSHIFT:
return eval(node->lhs) << eval(node->rhs);
case ND_A_RSHIFT:
return eval(node->lhs) >> eval(node->rhs);
case ND_EQL:
return eval(node->lhs) == eval(node->rhs);
case ND_NOT_EQL:
return eval(node->lhs) != eval(node->rhs);
case ND_LT:
return eval(node->lhs) < eval(node->rhs);
case ND_LTE:
return eval(node->lhs) <= eval(node->rhs);
case ND_TERNARY:
return eval(node->cond) ? eval(node->then) : eval(node->els);
case ND_COMMA:
return eval(node->rhs);
case ND_NOT:
return !eval(node->lhs);
case ND_BIT_NOT:
return ~eval(node->lhs);
case ND_AND:
return eval(node->lhs) && eval(node->rhs);
case ND_OR:
return eval(node->lhs) || eval(node->rhs);
case ND_MOD:
return eval(node->lhs) % eval(node->rhs);
case ND_NUM:
return node->val;
case ND_ADDR:
// ing gvar1[] = {1, 2}
// int *gvar2 = &gvar1
// のようなケースの2行目の&gvar1の処理
// この場合、単にgvarの先頭アドレスが設定される
//
// 変数をついでに探さないモード(!var)か
// 変数もついでに探すモード(*var) で、対象のノードが変数でなければエラー
if (!var || *var || node->lhs->kind != ND_VAR) {
error_at(token->str, "invalid addr initializer");
}
// 初期化式の中の変数をキャプチャする
*var = node->lhs->var;
return 0;
case ND_VAR:
// ing gvar1[] = {1, 2}
// int *gvar2 = gvar1
// のようなケースの2行目のgvar1の処理
if (!var || *var || node->var->type->kind != TY_ARRAY) {
error_at(token->str, "invalid var initializer");
}
*var = node->var;
return 0;
}
#pragma clang diagnostic ignored "-Wreturn-type"
error("定数式の計算のみ可能です");
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x6927(%rip), %r13 # 0xc594
xorl %ebx, %ebx
movl (%r14), %eax
decl %eax
cmpl $0x2f, %eax
ja 0x5fae
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x20, %eax
jmp 0x5ca9
movq 0x38(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leaq 0x40(,%rcx,8), %rax
movq (%r14,%rax), %r14
xorl %r15d, %r15d
jmp 0x5c6f
movq 0x18(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x5c54
movq 0x20(%r14), %r14
addq %rax, %rbx
jmp 0x5c6f
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x5c54
movq 0x20(%r14), %r14
addq %r12, %rbx
addq %rax, %rbx
xorl %r15d, %r15d
movq %rbx, %r12
jmp 0x5c6d
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
xorq %r15, %rax
jmp 0x5f76
testq %r15, %r15
je 0x5fbc
cmpq $0x0, (%r15)
jne 0x5fbc
movq 0x18(%r14), %rax
cmpl $0x17, (%rax)
jne 0x5fbc
movq 0x78(%rax), %rax
jmp 0x5f95
movq 0x18(%r14), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x5c54
testq %rax, %rax
jne 0x5d89
jmp 0x5f9b
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
xorl %ecx, %ecx
cmpq %rax, %r15
setl %cl
jmp 0x5f39
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movl $0x1, %r15d
testq %rax, %rax
jne 0x5f9b
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
cmpq $0x1, %rax
sbbq $-0x1, %rbx
addq %r12, %rbx
jmp 0x5fa1
movq 0x18(%r14), %rdi
movq %r15, %rsi
jmp 0x5dd9
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
xorl %ecx, %ecx
cmpq %rax, %r15
setle %cl
jmp 0x5f39
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
addq %rbx, %r15
subq %rax, %r15
addq %r12, %r15
movq %r15, %rbx
jmp 0x5fa1
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
imulq %r15, %rax
jmp 0x5f76
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
addq %r12, %rbx
addq %rdx, %rbx
jmp 0x5fa1
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %rcx
movq %r15, %rax
cqto
idivq %rcx
jmp 0x5f76
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
xorl %ecx, %ecx
cmpq %rax, %r15
sete %cl
jmp 0x5f39
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movl %eax, %ecx
sarq %cl, %r15
jmp 0x5f9b
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movl %eax, %ecx
shlq %cl, %r15
jmp 0x5f9b
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
cmpq $0x1, %rax
adcq %r12, %rbx
jmp 0x5fa1
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
orq %r15, %rax
jmp 0x5f76
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
xorl %ecx, %ecx
cmpq %rax, %r15
setne %cl
addq %r12, %rbx
addq %rcx, %rbx
jmp 0x5fa1
movq 0x80(%r14), %r15
jmp 0x5f9b
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
notq %rax
jmp 0x5f76
movq 0x18(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r15
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x5c54
andq %r15, %rax
addq %r12, %rbx
addq %rax, %rbx
jmp 0x5fa1
testq %r15, %r15
je 0x5fd3
cmpq $0x0, (%r15)
jne 0x5fd3
movq 0x78(%r14), %rax
movq (%rax), %rcx
cmpl $0x8, (%rcx)
jne 0x5fd3
movq %rax, (%r15)
xorl %r15d, %r15d
addq %r12, %rbx
addq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6919(%rip), %rdi # 0xc8ce
xorl %eax, %eax
callq 0x4a3b
leaq 0xa4bd(%rip), %rax # 0x10480
movq (%rax), %rax
movq 0x18(%rax), %rdi
leaq 0x68cc(%rip), %rsi # 0xc89d
jmp 0x5fe8
leaq 0xa4a6(%rip), %rax # 0x10480
movq (%rax), %rax
movq 0x18(%rax), %rdi
leaq 0x68ce(%rip), %rsi # 0xc8b6
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
logical_and
|
static Node *logical_and() {
Token *tk;
Node *node = bit_or();
while (tk = consume("&&")) {
node = new_bin_node(ND_AND, node, bit_or(), tk);
}
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x61ca
movq %rax, %rbx
leaq 0x67ab(%rip), %rdi # 0xc8f8
callq 0x51eb
testb %al, %al
je 0x61b5
leaq 0xa323(%rip), %r13 # 0x10480
leaq 0x6794(%rip), %r14 # 0xc8f8
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
callq 0x61ca
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0xc, (%rax)
movq %rbp, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rdi
callq 0x51eb
movq %r15, %rbx
testb %al, %al
jne 0x6164
jmp 0x61b8
movq %rbx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
bit_or
|
static Node *bit_or() {
Token *tk;
Node *node = bit_xor();
while (tk = consume("|")) {
node = new_bin_node(ND_BIT_OR, node, bit_xor(), tk);
}
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6261
movq %rax, %rbx
leaq 0x6712(%rip), %rdi # 0xc8f6
callq 0x51eb
testb %al, %al
je 0x624c
leaq 0xa28c(%rip), %r13 # 0x10480
leaq 0x66fb(%rip), %r14 # 0xc8f6
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
callq 0x6261
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0xd, (%rax)
movq %rbp, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rdi
callq 0x51eb
movq %r15, %rbx
testb %al, %al
jne 0x61fb
jmp 0x624f
movq %rbx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
bit_xor
|
static Node *bit_xor() {
Token *tk;
Node *node = bit_and();
while (tk = consume("^")) {
node = new_bin_node(ND_BIT_XOR, node, bit_and(), tk);
}
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x62f8
movq %rax, %rbx
leaq 0x6680(%rip), %rdi # 0xc8fb
callq 0x51eb
testb %al, %al
je 0x62e3
leaq 0xa1f5(%rip), %r13 # 0x10480
leaq 0x6669(%rip), %r14 # 0xc8fb
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
callq 0x62f8
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x11, (%rax)
movq %rbp, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rdi
callq 0x51eb
movq %r15, %rbx
testb %al, %al
jne 0x6292
jmp 0x62e6
movq %rbx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
bit_and
|
static Node *bit_and() {
Token *tk;
Node *node = equality();
while (tk = consume("&")) {
node = new_bin_node(ND_BIT_AND, node, equality(), tk);
}
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x638f
movq %rax, %rbx
leaq 0x65e7(%rip), %rdi # 0xc8f9
callq 0x51eb
testb %al, %al
je 0x637a
leaq 0xa15e(%rip), %r13 # 0x10480
leaq 0x65d0(%rip), %r14 # 0xc8f9
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
callq 0x638f
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0xe, (%rax)
movq %rbp, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rdi
callq 0x51eb
movq %r15, %rbx
testb %al, %al
jne 0x6329
jmp 0x637d
movq %rbx, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
equality
|
static Node *equality() {
Token *tk;
Node *node = relational();
for (;;) {
if (tk = consume("==")) {
node = new_bin_node(ND_EQL, node, relational(), tk);
} else if (tk = consume("!=")) {
node = new_bin_node(ND_NOT_EQL, node, relational(), tk);
} else {
return node;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6429
movq %rax, %r14
leaq 0xa0d7(%rip), %rbp # 0x10480
leaq 0x654d(%rip), %rdi # 0xc8fd
callq 0x51eb
movl $0x12, %r15d
testb %al, %al
jne 0x63d5
leaq 0x653a(%rip), %rdi # 0xc900
callq 0x51eb
movl $0x13, %r15d
testb %al, %al
je 0x6417
movq (%rbp), %rbx
movq 0x8(%rbx), %rax
movq %rax, (%rbp)
callq 0x6429
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r13
movl %r15d, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r13, %r14
jmp 0x63a9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
relational
|
static Node *relational() {
Token *tk;
Node *node = shift();
for (;;) {
if (tk = consume("<=")) {
node = new_bin_node(ND_LTE, node, shift(), tk);
} else if (tk = consume(">=")) {
node = new_bin_node(ND_LTE, shift(), node, tk);
} else if (tk = consume("<")) {
node = new_bin_node(ND_LT, node, shift(), tk);
} else if (tk = consume(">")) {
node = new_bin_node(ND_LT, shift(), node, tk);
} else {
return node;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6522
movq %rax, %r13
leaq 0xa03d(%rip), %r12 # 0x10480
leaq 0x657a(%rip), %rdi # 0xc9c4
callq 0x51eb
testb %al, %al
je 0x6471
movq (%r12), %r15
movq 0x8(%r15), %rax
movq %rax, (%r12)
movl $0xa, %ebx
callq 0x6522
movq %r13, %rbp
movq %rax, %r13
jmp 0x64e0
leaq 0x6550(%rip), %rdi # 0xc9c8
callq 0x51eb
testb %al, %al
je 0x6494
movq (%r12), %r15
movq 0x8(%r15), %rax
movq %rax, (%r12)
movl $0xa, %ebx
jmp 0x64d8
leaq 0x6469(%rip), %rdi # 0xc904
callq 0x51eb
testb %al, %al
je 0x64b7
movq (%r12), %r15
movq 0x8(%r15), %rax
movq %rax, (%r12)
movl $0x9, %ebx
jmp 0x6464
leaq 0x64be(%rip), %rdi # 0xc97c
callq 0x51eb
testb %al, %al
je 0x6510
movq (%r12), %r15
movq 0x8(%r15), %rax
movq %rax, (%r12)
movl $0x9, %ebx
callq 0x6522
movq %rax, %rbp
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl %ebx, (%rax)
movq %r15, 0x8(%rax)
movq %rbp, 0x18(%rax)
movq %r13, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %r13
jmp 0x6443
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
shift
|
static Node *shift() {
Token *tk;
Node *node = add();
for (;;) {
if (tk = consume("<<")) {
node = new_bin_node(ND_A_LSHIFT, node, add(), tk);
} else if (tk = consume(">>")) {
node = new_bin_node(ND_A_RSHIFT, node, add(), tk);
} else {
return node;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x65bc
movq %rax, %r14
leaq 0x9f44(%rip), %rbp # 0x10480
leaq 0x63c0(%rip), %rdi # 0xc903
callq 0x51eb
movl $0xf, %r15d
testb %al, %al
jne 0x6568
leaq 0x63ad(%rip), %rdi # 0xc906
callq 0x51eb
movl $0x10, %r15d
testb %al, %al
je 0x65aa
movq (%rbp), %rbx
movq 0x8(%rbx), %rax
movq %rax, (%rbp)
callq 0x65bc
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r13
movl %r15d, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r13, %r14
jmp 0x653c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
add
|
static Node *add() {
Token *tk;
Node *node = mul();
for (;;) {
if (tk = consume("+")) {
node = new_add_node(node, mul(), tk);
} else if (tk = consume("-")) {
node = new_sub_node(node, mul(), tk);
} else {
return node;
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x67e4
movq %rax, %r15
leaq 0x635f(%rip), %rbx # 0xc933
leaq 0x9ea5(%rip), %r13 # 0x10480
leaq 0x6be7(%rip), %r14 # 0xd1c9
movq %rbx, %rdi
callq 0x51eb
testb %al, %al
je 0x6613
movq (%r13), %r12
movq 0x8(%r12), %rax
movq %rax, (%r13)
callq 0x67e4
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x6651
movq %rax, %r15
jmp 0x65e2
movq %r14, %rdi
callq 0x51eb
testb %al, %al
je 0x6644
movq (%r13), %r12
movq 0x8(%r12), %rax
movq %rax, (%r13)
callq 0x67e4
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x6727
movq %rax, %r15
jmp 0x65e2
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
new_add_node
|
static Node *new_add_node(Node *lhs, Node *rhs, Token *tk) {
add_type(lhs);
add_type(rhs);
// int x
// &x + 2
// => & に intのサイズ(4) * 2 => xのアドレスの 8byte先
//
// int x
// int *y = &x
// int **z = &y
// &z + 2
// => & に intのポインタのサイズ(8) * 2 => zのアドレスの 16byte先
if (is_integer(lhs->ty) && is_integer(rhs->ty)) {
// num + num
return new_bin_node(ND_ADD, lhs, rhs, tk);
} else if (is_pointer(lhs->ty) && is_integer(rhs->ty)) {
// ptr + num のケース
return new_bin_node(ND_PTR_ADD, lhs, rhs, tk);
} else if (is_integer(lhs->ty) && is_pointer(rhs->ty)){
// num + ptrのケースなので、入れ替えてptr + num に正規化する
return new_bin_node(ND_PTR_ADD, rhs, lhs, tk);
}
// ここに来た場合 ptr + ptr という不正なパターンになるので落とす
error_at(token->str, "不正なaddパターンです。");
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x9eef
movq %r15, %rdi
callq 0x9eef
movq 0x10(%r14), %rdi
callq 0x9edb
testb %al, %al
je 0x668e
movq 0x10(%r15), %rdi
callq 0x9edb
movl $0x1, %ebp
testb %al, %al
jne 0x66ad
movq 0x10(%r14), %rdi
callq 0x9ecf
testb %al, %al
je 0x66b5
movq 0x10(%r15), %rdi
callq 0x9edb
movl $0x2, %ebp
testb %al, %al
je 0x66b5
movq %r14, %r12
movq %r15, %r14
jmp 0x66d7
movq 0x10(%r14), %rdi
callq 0x9edb
testb %al, %al
je 0x670b
movq 0x10(%r15), %rdi
callq 0x9ecf
movl $0x2, %ebp
movq %r15, %r12
testb %al, %al
je 0x670b
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
movq %r12, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9d6e(%rip), %rax # 0x10480
movq (%rax), %rax
movq 0x18(%rax), %rdi
leaq 0x6403(%rip), %rsi # 0xcb23
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
new_sub_node
|
static Node *new_sub_node(Node *lhs, Node *rhs, Token *tk) {
add_type(lhs);
add_type(rhs);
if (is_integer(lhs->ty) && is_integer(rhs->ty)) {
// num - num
return new_bin_node(ND_SUB, lhs, rhs, tk);
} else if (is_pointer(lhs->ty) && is_pointer(rhs->ty)) {
// ptr - ptr
return new_bin_node(ND_PTR_DIFF, lhs, rhs, tk);
} else if (is_pointer(lhs->ty) && is_integer(rhs->ty)) {
// ptr - num
return new_bin_node(ND_PTR_SUB, lhs, rhs, tk);
}
// ここに来た場合 num - ptr になってしまうので、エラーにする
error("不正な演算です: num - ptr");
return NULL; // error で落ちるので実際にはreturnされない
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x9eef
movq %rbx, %rdi
callq 0x9eef
movq 0x10(%r15), %rdi
callq 0x9edb
testb %al, %al
je 0x6764
movq 0x10(%rbx), %rdi
callq 0x9edb
movl $0x3, %ebp
testb %al, %al
jne 0x67a2
movq 0x10(%r15), %rdi
callq 0x9ecf
testb %al, %al
je 0x6783
movq 0x10(%rbx), %rdi
callq 0x9ecf
movl $0x5, %ebp
testb %al, %al
jne 0x67a2
movq 0x10(%r15), %rdi
callq 0x9ecf
testb %al, %al
je 0x67d6
movq 0x10(%rbx), %rdi
callq 0x9edb
movl $0x4, %ebp
testb %al, %al
je 0x67d6
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6368(%rip), %rdi # 0xcb45
xorl %eax, %eax
callq 0x4a3b
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
mul
|
static Node *mul() {
Token *tk;
Node *node = cast();
for (;;) {
if (tk = consume("*")) {
node = new_bin_node(ND_MUL, node, cast(), tk);
} else if (tk = consume("/")) {
node = new_bin_node(ND_DIV, node, cast(), tk);
} else if (tk = consume("%")) {
node = new_bin_node(ND_MOD, node, cast(), tk);
} else {
return node;
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6897
movq %rax, %r14
leaq 0x9c82(%rip), %r12 # 0x10480
leaq 0x6612(%rip), %rdi # 0xce17
callq 0x51eb
movl $0x6, %r15d
testb %al, %al
jne 0x6840
leaq 0x65ff(%rip), %rdi # 0xce1a
callq 0x51eb
movl $0x7, %r15d
testb %al, %al
jne 0x6840
leaq 0x60d8(%rip), %rdi # 0xc909
callq 0x51eb
movl $0x8, %r15d
testb %al, %al
je 0x6885
movq (%r12), %rbx
movq 0x8(%rbx), %rax
movq %rax, (%r12)
callq 0x6897
movq %rax, %r13
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbp
movl %r15d, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r13, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %rbp, %r14
jmp 0x67fe
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
cast
|
static Node *cast() {
Token *tk = token;
if (consume("(")) {
if (is_type(token)) {
Type *ty = type_name();
expect(")");
if (!consume("{")) {
// "{" が来た場合は、キャストではなくcompound-literaruの"(" typename ")" になるので、
// この節はスキップして、token=tmpでもとに戻した上で、postfix側で処理する
Node *node = new_unary_node(ND_CAST, cast(), tk);
add_type(node->lhs);
node->ty = ty;
return node;
}
}
}
token = tk;
Node *node = unary();
add_type(node);
return node;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x9bda(%rip), %rbx # 0x10480
movq (%rbx), %r12
leaq 0x5cc6(%rip), %rdi # 0xc576
callq 0x51eb
testb %al, %al
je 0x690a
movq 0x8(%r12), %rdi
movq %rdi, (%rbx)
movl (%rdi), %eax
leal -0xa(%rax), %ecx
cmpl $0x6, %ecx
jb 0x68e2
cmpl $0x17, %eax
ja 0x6a93
movl $0xe30000, %ecx # imm = 0xE30000
btl %eax, %ecx
jae 0x6a93
callq 0x6cdd
movq %rax, %r14
leaq 0x5c98(%rip), %rdi # 0xc589
callq 0x5b5c
leaq 0x5a19(%rip), %rdi # 0xc316
callq 0x51eb
testb %al, %al
je 0x69a3
movq %r12, (%rbx)
leaq 0x601f(%rip), %rdi # 0xc933
callq 0x51eb
testb %al, %al
je 0x6932
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %rbx
jmp 0x6b5a
leaq 0x6890(%rip), %rdi # 0xd1c9
callq 0x51eb
testb %al, %al
je 0x69dc
movq 0x8(%r12), %rax
movq %rax, (%rbx)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl $0x22, (%rax)
movq %r12, 0x8(%rax)
callq 0x6897
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x3, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
jmp 0x6b5a
callq 0x6897
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x24, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r15, %rdi
callq 0x9eef
movq %r14, 0x10(%rbx)
jmp 0x6b62
leaq 0x5f16(%rip), %rdi # 0xc8f9
callq 0x51eb
testb %al, %al
je 0x6a19
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x1e, (%rax)
jmp 0x6b52
leaq 0x63f7(%rip), %rdi # 0xce17
callq 0x51eb
testb %al, %al
je 0x6a56
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x1f, (%rax)
jmp 0x6b52
leaq 0x5ed5(%rip), %rdi # 0xc932
callq 0x51eb
testb %al, %al
je 0x6aa6
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x28, (%rax)
jmp 0x6b52
callq 0x59dc
testq %rax, %rax
jne 0x68e2
jmp 0x690a
leaq 0x671b(%rip), %rdi # 0xd1c8
callq 0x51eb
testb %al, %al
je 0x6ae0
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x29, (%rax)
jmp 0x6b52
leaq 0x5e4e(%rip), %rdi # 0xc935
callq 0x51eb
testb %al, %al
je 0x6b1a
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x14, (%rax)
jmp 0x6b52
leaq 0x5e16(%rip), %rdi # 0xc937
callq 0x51eb
testb %al, %al
je 0x6b71
movq 0x8(%r12), %rax
movq %rax, (%rbx)
callq 0x6897
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x15, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, %rdi
callq 0x9eef
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl (%r12), %eax
cmpl $0x12, %eax
je 0x6bd0
cmpl $0x13, %eax
jne 0x6c57
movq 0x8(%r12), %rax
movq %rax, (%rbx)
leaq 0x59e4(%rip), %rdi # 0xc576
callq 0x5b5c
callq 0x6cdd
movq %rax, %rbx
leaq 0x59e3(%rip), %rdi # 0xc589
callq 0x5b5c
movslq 0x8(%rbx), %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x22, (%rax)
movq %r12, 0x8(%rax)
jmp 0x6cb2
movq 0x8(%r12), %r15
movq %r15, (%rbx)
leaq 0x5997(%rip), %rdi # 0xc576
callq 0x51eb
testb %al, %al
je 0x6c71
movq 0x8(%r15), %r14
movq %r14, (%rbx)
movl (%r14), %eax
leal -0xa(%rax), %ecx
cmpl $0x6, %ecx
jb 0x6c0d
cmpl $0x17, %eax
ja 0x6c61
movl $0xe30000, %ecx # imm = 0xE30000
btl %eax, %ecx
jae 0x6c61
callq 0x6cdd
cmpb $0x1, 0xc(%rax)
je 0x6ccb
movq %rax, %rbx
leaq 0x5963(%rip), %rdi # 0xc589
callq 0x5b5c
movslq 0x4(%rbx), %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x22, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x80(%rax)
jmp 0x6b5a
callq 0x6e72
jmp 0x692a
movq %r14, %rdi
callq 0x59dc
testq %rax, %rax
jne 0x6c0d
movq %r15, (%rbx)
callq 0x6897
movq %rax, %rbx
movq %rax, %rdi
callq 0x9eef
movq 0x10(%rbx), %rax
cmpb $0x1, 0xc(%rax)
je 0x6cbe
movq %rbx, %rdi
callq 0x9ee7
movslq %eax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x22, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x80(%rax)
jmp 0x6b5a
movq 0x18(%r15), %rdi
leaq 0x5c91(%rip), %rsi # 0xc95a
jmp 0x6cd6
movq 0x18(%r14), %rdi
leaq 0x5c63(%rip), %rsi # 0xc939
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
abstract_declarator
|
static Type *abstract_declarator(Type *ty) {
while (consume("*")) {
ty = pointer_to(ty);
}
if (consume("(")) {
Type *placeholder = calloc(1, sizeof(Type));
Type *new_ty = abstract_declarator(placeholder);
expect(")");
// 入れ子部分を全部パースした後に、その後に続く配列の [] などを含めた(type_suffix)型としてplaceholderを完成させる
memcpy(placeholder, type_suffix(ty), sizeof(Type));
return new_ty;
}
return type_suffix(ty);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6112(%rip), %rdi # 0xce17
callq 0x51eb
testb %al, %al
je 0x6d3d
leaq 0x976b(%rip), %r15 # 0x10480
leaq 0x60fb(%rip), %r14 # 0xce17
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x9de4
movq %rax, %rbx
movq %r14, %rdi
callq 0x51eb
testb %al, %al
jne 0x6d1c
leaq 0x5832(%rip), %rdi # 0xc576
callq 0x51eb
testb %al, %al
je 0x6db1
leaq 0x972c(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %rax, %r14
movq %rax, %rdi
callq 0x6cf6
movq %rax, %r15
leaq 0x5807(%rip), %rdi # 0xc589
callq 0x5b5c
movq %rbx, %rdi
callq 0x6dbb
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r14)
movups %xmm1, 0x10(%r14)
movups %xmm2, 0x20(%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6dbb
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
type_suffix
|
static Type *type_suffix(Type *base) {
if (!consume("[")) {
return base;
}
int array_size = 0;
int is_incomplete = true;
if (!consume("]")) {
//[の直後に"]"が来ていない場合、配列のサイズがあるはずなので、完全な方としてis_incompleteをfalseに
is_incomplete = false;
array_size = const_expr();
expect("]");
}
Token *tk = token;
base = type_suffix(base);
// 不完全型許されるのは最初の配列の最初の次元のみなので、再帰で呼ばれた結果(=2次元以降)に関しては必ず完全になっていること
if (base->is_incomplete) {
error_at(tk->str, "incomplete element type(type_suffix)");
}
base = array_of(base, array_size);
base->is_incomplete = is_incomplete;
return base;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x5b3d(%rip), %rdi # 0xc90b
callq 0x51eb
testb %al, %al
je 0x6e53
leaq 0x96a2(%rip), %r12 # 0x10480
movq (%r12), %rax
movq 0x8(%rax), %r14
movq %r14, (%r12)
leaq 0x49cd(%rip), %rdi # 0xb7be
callq 0x51eb
testb %al, %al
je 0x6e0e
movq 0x8(%r14), %r13
movq %r13, (%r12)
testq %r14, %r14
setne %r15b
xorl %r14d, %r14d
jmp 0x6e33
callq 0x5fef
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r14
leaq 0x4994(%rip), %rdi # 0xb7be
callq 0x5b5c
movq (%r12), %r13
movq %rbx, %rdi
callq 0x6dbb
cmpb $0x1, 0xc(%rax)
je 0x6e60
movq %rax, %rdi
movl %r14d, %esi
callq 0x9e11
movq %rax, %rbx
movb %r15b, 0xc(%rax)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r13), %rdi
leaq 0x5aa2(%rip), %rsi # 0xc90d
xorl %eax, %eax
callq 0x487c
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
struct_ref
|
static Node *struct_ref(Node *lhs) {
add_type(lhs);
if (lhs->ty->kind != TY_STRUCT) {
fprintf(stderr, "type_info: %s\n", type_info(lhs->ty));
error_at(token->str, "not a struct(lhs->ty->kind: %d", lhs->ty->kind);
}
Token *tok = token;
Member *m = find_member(lhs->ty, expect_ident());
if (!m) {
error_at(tok->str, "no such member");
}
Node *n = new_unary_node(ND_MEMBER, lhs, tok);
n->member = m;
return n;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x9eef
movq 0x10(%rbx), %r14
cmpl $0x9, (%r14)
jne 0x758a
leaq 0x8f66(%rip), %rax # 0x10480
movq (%rax), %r12
callq 0x5bde
cmpl $0x9, (%r14)
jne 0x7599
movq %rax, %r15
addq $0x20, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x7577
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2110
testl %eax, %eax
jne 0x752f
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x23, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r14, 0x98(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdi
leaq 0x5555(%rip), %rsi # 0xcad8
xorl %eax, %eax
callq 0x487c
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x225f
leaq 0x5547(%rip), %rdi # 0xcae7
leaq 0x510a(%rip), %rsi # 0xc6b1
leaq 0x5551(%rip), %rcx # 0xcaff
movl $0x950, %edx # imm = 0x950
callq 0x20d0
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
new_var
|
static Var *new_var(char *name, Type *type, bool is_local) {
Var *var = calloc(1, sizeof(Var));
var->type = type;
var->name = name;
var->is_local = is_local;
// 今のscopeにこの変数を追加
push_var_scope(name, var);
return var;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rax, %r12
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movb %bl, 0x14(%rax)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %r15, 0x8(%rax)
movq 0x8dde(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movl 0x8dc5(%rip), %ecx # 0x10430
movl %ecx, 0x2c(%rax)
movq %rax, 0x8dcb(%rip) # 0x10440
movq %r12, 0x10(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
new_label
|
static char *new_label() {
static int label_index = 0;
char buf[100];
int n = sprintf(buf, ".L.data.%03d", label_index++);
return my_strndup(buf, n);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl 0x8db1(%rip), %edx # 0x10448
leal 0x1(%rdx), %eax
movl %eax, 0x8da8(%rip) # 0x10448
leaq 0x52d7(%rip), %rsi # 0xc97e
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %eax, %eax
callq 0x21c0
movl %eax, %r15d
leal 0x1(%r15), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r14
testl %r15d, %r15d
jle 0x76e0
movl %r15d, %ebx
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2150
movb $0x0, (%r14,%rbx)
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
gvar_initializer_sub
|
static Initializer *gvar_initializer_sub(Initializer *cur, Type *ty) {
Token *cur_tok = token;
if (ty->kind == TY_ARRAY && ty->ptr_to->kind == TY_CHAR) {
Token *str = consume_kind(TK_STR);
if (str) {
if (ty->is_incomplete) {
ty->array_size = ty->size = str->content_length;
ty->is_incomplete = false;
}
int len = str->content_length > ty->array_size ? ty->array_size : str->content_length;
for (int i = 0; i < len; i++) {
cur = new_init_val(cur, 1, str->contents[i]);
}
for (; len < ty->array_size; len++) {
cur = new_init_val(cur, 1, 0);
}
return cur;
}
}
if (ty->kind == TY_ARRAY) {
bool has_open_brace = consume("{");
int i = 0;
if (!peek_token("}")) {
do {
cur = gvar_initializer_sub(cur, ty->ptr_to);
i++;
} while(!is_array_limit_over(ty, i) && !peek_end() && consume(","));
if (has_open_brace && !consume_end()) {
// "{" で始まってるのに、配列のサイズ個の初期化式を読んでもなおまだ初期化式が残っている場合、無視する
skip_excess_elements();
}
}
if (i < ty->array_size) {
for (; i < ty->array_size; i++) {
cur = new_init_zero(cur, ty->ptr_to->size);
}
}
if (ty->is_incomplete) {
ty->array_size = i;
ty->size = ty->ptr_to->size * i;
ty->is_incomplete = false;
}
return cur;
}
if (ty->kind == TY_STRUCT) {
bool has_open_brace = consume("{");
if (!peek_token("}")) {
Member *mem = ty->members;
do {
cur = gvar_initializer_sub(cur, mem->ty);
cur = emit_struct_padding(cur, ty, mem);
mem = mem->next;
} while(mem && !peek_end() && consume(","));
if (has_open_brace && !consume_end()) {
// "{" で始まってるのに、配列のサイズ個の初期化式を読んでもなおまだ初期化式が残っている場合、無視する
skip_excess_elements();
}
if (mem) {
for (; mem; mem = mem->next) {
cur = new_init_zero(cur, mem->ty->size);
}
}
}
return cur;
}
// compound-literal で "{" 初期化式 "}" で初期化する場合に "{" が存在する
// (int) { 1 } とか
bool has_open_brace = consume("{");
Node *expr = ternary();
if (has_open_brace) {
expect_end();
}
// グローバル変数の初期化で別のグローバル変数のアドレス参照のみ使えるため、
// 初期化式の中に最大一つだけ変数を取れる。
// その変数をevalの評価中に合わせて取得し返してもらう。
// その初期化式の値は、 evalの中で見つかった別のグローバル変数を基準にしたアドレス計算の結果をinitializerとする
Var *var = NULL;
long addend = eval2(expr, &var);
if (var) {
// 変数からのオフセットの初期化式だったので、ポインタ演算とみなして実際のバイト数に変換する
int scale = (var->type->kind == TY_ARRAY) ? var->type->ptr_to->size : var->type->size;
return new_init_label(cur, var->name, addend * scale);
}
// 変数がない場合は単にevalの値を定数として設定するinitializerとする
return new_init_val(cur, ty->size, addend);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r13
movl (%rsi), %eax
cmpl $0x9, %eax
je 0x7763
cmpl $0x8, %eax
jne 0x7857
movq 0x10(%r14), %rax
cmpl $0x4, (%rax)
jne 0x78a2
leaq 0x8d56(%rip), %rcx # 0x10480
movq (%rcx), %rax
cmpl $0x14, (%rax)
jne 0x78a2
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movl 0x30(%rax), %esi
movslq %esi, %rcx
cmpb $0x0, 0xc(%r14)
je 0x7ad7
movl %ecx, 0x4(%r14)
movq %rcx, 0x18(%r14)
movb $0x0, 0xc(%r14)
movq %rcx, %rdx
jmp 0x7adb
leaq 0x4bac(%rip), %rdi # 0xc316
callq 0x51eb
movb $0x1, %bl
testb %al, %al
je 0x778c
leaq 0x8d04(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
sete %bl
leaq 0x4f1a(%rip), %rdi # 0xc6ad
callq 0x51eb
testb %al, %al
jne 0x7ac5
movb %bl, 0x4(%rsp)
movq 0x20(%r14), %rbx
addq $0x4, %r14
movq %r14, %rbp
movq %rbx, %r14
movq 0x8(%rbx), %rsi
movq %r13, %rdi
callq 0x76f2
movq %rax, %r12
movq (%rbx), %rbx
movq 0x8(%r14), %rax
movl 0x4(%rax), %eax
leaq 0x18(%rbx), %rcx
testq %rbx, %rbx
cmoveq %rbp, %rcx
movl (%rcx), %r15d
addl 0x18(%r14), %eax
subl %eax, %r15d
testl %r15d, %r15d
jle 0x7814
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rax, %r13
movq $0x0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rax, (%r12)
movq %rax, %r12
decl %r15d
jne 0x77e5
jmp 0x7817
movq %r12, %r13
testq %rbx, %rbx
je 0x7944
callq 0x4b87
testb %al, %al
jne 0x7944
leaq 0x4e7b(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x7944
leaq 0x8c38(%rip), %rcx # 0x10480
movq (%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rcx)
jmp 0x77af
leaq 0x4ab8(%rip), %rdi # 0xc316
callq 0x51eb
testb %al, %al
je 0x79af
leaq 0x8c0e(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
callq 0x5fef
movq %rax, %r15
callq 0x4b2b
testb %al, %al
jne 0x79b7
leaq 0x4e15(%rip), %rdi # 0xc6ad
callq 0x5b5c
jmp 0x79b7
leaq 0x4a6d(%rip), %rdi # 0xc316
callq 0x51eb
movb $0x1, %bpl
testb %al, %al
je 0x78cd
leaq 0x8bc4(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
sete %bpl
leaq 0x4dd9(%rip), %rdi # 0xc6ad
callq 0x51eb
xorl %r12d, %r12d
testb %al, %al
jne 0x7a25
movl $0x1, %r12d
leaq 0x4dbe(%rip), %r15 # 0xc6af
leaq 0x8b88(%rip), %rbx # 0x10480
movq 0x10(%r14), %rsi
movq %r13, %rdi
callq 0x76f2
movq %rax, %r13
cmpb $0x0, 0xc(%r14)
jne 0x7918
cmpq %r12, 0x18(%r14)
jle 0x7a13
callq 0x4b87
testb %al, %al
jne 0x7a13
movq %r15, %rdi
callq 0x51eb
testb %al, %al
je 0x7a13
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
incq %r12
jmp 0x78f8
cmpb $0x0, 0x4(%rsp)
jne 0x7958
callq 0x4b2b
testb %al, %al
je 0x7b77
testq %rbx, %rbx
je 0x7ac5
movq %r13, %r14
movq 0x8(%rbx), %rax
movl 0x4(%rax), %ebp
testl %ebp, %ebp
jle 0x799c
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rax, %r13
movq $0x0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rax, (%r14)
movq %rax, %r14
decl %ebp
jne 0x796f
jmp 0x799f
movq %r14, %r13
movq (%rbx), %rbx
movq %r13, %r14
testq %rbx, %rbx
jne 0x7964
jmp 0x7ac5
callq 0x5fef
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5c54
movq %rax, %r15
movq (%r12), %rax
testq %rax, %rax
je 0x7aa4
movq (%rax), %rcx
cmpl $0x8, (%rcx)
jne 0x79eb
movq 0x10(%rcx), %rcx
movslq 0x4(%rcx), %rcx
movq 0x8(%rax), %rbx
imulq %rcx, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
jmp 0x7abe
testb %bpl, %bpl
jne 0x7a25
callq 0x4b2b
testb %al, %al
je 0x7b81
movslq %r12d, %r15
movq %r14, %rax
movq 0x18(%r14), %r14
cmpq %r15, %r14
movq %rax, 0x8(%rsp)
jle 0x7a81
movq 0x10(%rax), %rax
movl 0x4(%rax), %ebp
testl %ebp, %ebp
jle 0x7a76
movl %ebp, %r12d
movq %r13, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rax, %r13
movq $0x0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rax, (%rbx)
movq %rax, %rbx
decl %r12d
jne 0x7a4a
incq %r15
cmpq %r15, %r14
jg 0x7a40
movl %r15d, %r12d
movq 0x8(%rsp), %rdx
cmpb $0x1, 0xc(%rdx)
jne 0x7ac5
movslq %r12d, %rax
movq %rax, 0x18(%rdx)
movq 0x10(%rdx), %rcx
imull 0x4(%rcx), %eax
movl %eax, 0x4(%rdx)
movb $0x0, 0xc(%rdx)
jmp 0x7ac5
movl 0x4(%r14), %ebx
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %r15, 0x10(%rax)
movl %ebx, 0x8(%rax)
movq %rax, (%r13)
movq %rax, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rdx
cmpq %rcx, %rdx
movq %rdx, 0x8(%rsp)
cmovll %edx, %esi
testl %esi, %esi
movl %esi, 0x4(%rsp)
jle 0x7b29
movq 0x28(%rax), %r12
movl %esi, %ebx
xorl %ebp, %ebp
movsbq (%r12,%rbp), %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rax, %r14
movq %r15, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rax, (%r13)
incq %rbp
movq %rax, %r13
cmpq %rbp, %rbx
jne 0x7af6
jmp 0x7b2c
movq %r13, %r14
movslq 0x4(%rsp), %r12
movq 0x8(%rsp), %rbx
cmpq %r12, %rbx
jle 0x7b6f
movl $0x1, %edi
movl $0x28, %esi
callq 0x2100
movq %rax, %r13
movq $0x0, 0x10(%rax)
movl $0x1, 0x8(%rax)
movq %rax, (%r14)
incq %r12
movq %rax, %r14
cmpq %r12, %rbx
jg 0x7b3b
jmp 0x7ac5
movq %r14, %r13
jmp 0x7ac5
callq 0x2230
jmp 0x7958
callq 0x2230
jmp 0x7a25
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
skip_excess_elements2
|
static void skip_excess_elements2() {
for (;;) {
if (consume("{")) {
skip_excess_elements2();
} else {
// brace以外の場合は何か式があるはずなので読み飛ばす
assign();
}
if (consume_end()) {
return;
}
expect(",");
}
}
|
pushq %r15
pushq %r14
pushq %rbx
leaq 0x477f(%rip), %rbx # 0xc316
leaq 0x88e2(%rip), %r15 # 0x10480
leaq 0x4b0a(%rip), %r14 # 0xc6af
movq %rbx, %rdi
callq 0x51eb
testb %al, %al
je 0x7bc2
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %rax, (%r15)
callq 0x7b8b
jmp 0x7bc7
callq 0x7be0
callq 0x4b2b
testb %al, %al
jne 0x7bda
movq %r14, %rdi
callq 0x5b5c
jmp 0x7ba5
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
assign
|
static Node *assign() {
Node *node = ternary();
Token *tk;
// chibicc だと "=" 以外の +=, -=... 計の演算子は別途 ND_ADD_EQ のような専用のNode種別をつくって処理している
// https://github.com/rui314/chibicc/commit/05e907d2b8a94103d60148ce90e27ca191ad5446
// 難しかったので、簡単そうな i += x を構文木上 i = i + x に読み替える方式にしてみる。
// ただそのせいで、左辺のnodeが複数のnodeで共有されてしまってfree_nodesのときに複数回freeしてしまってエラーになったので、
// chibccに合わせて今回からastのfreeはやめる
if (tk = consume("=")) {
return new_bin_node(ND_ASSIGN, node, assign(), tk);
} else if (tk = consume("+=")) {
Node *n = new_add_node(node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("-=")) {
Node *n = new_sub_node(node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("*=")) {
Node *n = new_bin_node(ND_MUL, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("/=")) {
Node *n = new_bin_node(ND_DIV, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("<<=")) {
Node *n = new_bin_node(ND_A_LSHIFT, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume(">>=")) {
Node *n = new_bin_node(ND_A_RSHIFT, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("|=")) {
Node *n = new_bin_node(ND_BIT_OR, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("&=")) {
Node *n = new_bin_node(ND_BIT_AND, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
} else if (tk = consume("^=")) {
Node *n = new_bin_node(ND_BIT_XOR, node, assign(), tk);
return new_bin_node(ND_ASSIGN, node, n, tk);
}
return node;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x5fef
movq %rax, %rbx
leaq 0x4d0a(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x7c4e
leaq 0x8879(%rip), %rax # 0x10480
movq (%rax), %r12
movq 0x8(%r12), %rcx
movq %rcx, (%rax)
callq 0x7be0
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x16, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r15, %rbx
jmp 0x7cea
leaq 0x4d62(%rip), %rdi # 0xc9b7
callq 0x51eb
testb %al, %al
je 0x7c84
leaq 0x881b(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6651
jmp 0x7cb8
leaq 0x4d2f(%rip), %rdi # 0xc9ba
callq 0x51eb
testb %al, %al
je 0x7cf9
leaq 0x87e5(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x6727
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r12
movl $0x16, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4cbd(%rip), %rdi # 0xc9bd
callq 0x51eb
testb %al, %al
je 0x7d3d
leaq 0x8770(%rip), %rax # 0x10480
movq (%rax), %r12
movq 0x8(%r12), %rcx
movq %rcx, (%rax)
callq 0x7be0
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x6, (%rax)
jmp 0x7d7f
leaq 0x4c7c(%rip), %rdi # 0xc9c0
callq 0x51eb
testb %al, %al
je 0x7dc7
leaq 0x872c(%rip), %rax # 0x10480
movq (%rax), %r12
movq 0x8(%r12), %rcx
movq %rcx, (%rax)
callq 0x7be0
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x7, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl $0x16, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rbx
jmp 0x7cea
leaq 0x4bf5(%rip), %rdi # 0xc9c3
callq 0x51eb
testb %al, %al
je 0x7df7
leaq 0x86a2(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movl $0xf, %edi
jmp 0x7eb0
leaq 0x4bc9(%rip), %rdi # 0xc9c7
callq 0x51eb
testb %al, %al
je 0x7e27
leaq 0x8672(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movl $0x10, %edi
jmp 0x7eb0
leaq 0x4b9d(%rip), %rdi # 0xc9cb
callq 0x51eb
testb %al, %al
je 0x7e54
leaq 0x8642(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movl $0xd, %edi
jmp 0x7eb0
leaq 0x4b73(%rip), %rdi # 0xc9ce
callq 0x51eb
testb %al, %al
je 0x7e81
leaq 0x8615(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movl $0xe, %edi
jmp 0x7eb0
leaq 0x4b49(%rip), %rdi # 0xc9d1
callq 0x51eb
testb %al, %al
je 0x7cea
leaq 0x85e4(%rip), %rax # 0x10480
movq (%rax), %r14
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
callq 0x7be0
movl $0x11, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x60ec
movl $0x16, %edi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x60ec
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
local_var_initializer_sub
|
static Node *local_var_initializer_sub(Node *cur, Var *var, Type *ty, Designator *desg) {
if (ty->kind == TY_ARRAY && ty->ptr_to->kind == TY_CHAR && peek_kind(TK_STR)) {
// char hoge[3] = "abc" のような場合
// hoge[0] = 'a';
// hoge[1] = 'b';
// hoge[2] = 'c';
// のようなコードを生成する
// gccでためしたところ
// char hoge[10] = "01234";
// みたいに配列の長さに満たない分は0で初期化されていいるっぽい
// 初期化敷なしで宣言だけの(char hoge[10];)場合は値は不定
Token *str = consume_kind(TK_STR);
int len = ty->array_size > str->content_length ? str->content_length : ty->array_size;
for (int i = 0; i < len; i++) {
Designator desg2 = {desg, i};
cur->next = new_desg_node(var, &desg2, new_num_node(str->contents[i], str));
cur = cur->next;
}
for (int i = len; i < ty->array_size; i++) {
Designator desg2 = {desg, i};
cur = lvar_init_zero(cur, var, ty->ptr_to, &desg2);
}
// 不完全型(配列のサイズが省略されている場合)の場合、初期化した文字列の長さに合わせる
if (ty->is_incomplete) {
array_size_completed(ty, str->content_length);
}
return cur;
}
// static int count = 0;
// fprintf(stdout, "count: %d, type: %d\n", count++, ty->kind);
if (ty->kind == TY_ARRAY) {
bool has_open_brace = consume("{");
int i = 0;
if (!peek_token("}")) {
do {
Designator desg2 = {desg, i++};
cur = local_var_initializer_sub(cur, var, ty->ptr_to, &desg2);
} while(!is_array_limit_over(ty, i) && !peek_end() && consume(","));
}
if (has_open_brace && !consume_end()) {
// "{" で始まってるのに、配列のサイズ個の初期化式を読んでもなおまだ初期化式が残っている場合、無視する
skip_excess_elements();
}
// 初期化子が配列のサイズに満たない場合は、0で初期化する
for (; i < ty->array_size; i++) {
Designator dseg2 = {desg, i};
cur = lvar_init_zero(cur, var, ty->ptr_to, &dseg2);
}
// 不完全型(配列のサイズが省略されている場合)の場合、初期化した文字列の長さに合わせる
if (ty->is_incomplete) {
array_size_completed(ty, i);
}
return cur;
}
if (ty->kind == TY_STRUCT) {
bool has_open_brace = consume("{");
Member *mem = ty->members;
if (!peek_token("}")) {
do {
assert(mem);
Designator desg2 = {desg, 0, mem};
cur = local_var_initializer_sub(cur, var, mem->ty, &desg2);
mem = mem->next;
} while(mem && !peek_end() && consume(","));
}
if (has_open_brace && !consume_end()) {
// "{" で始まってるのに、配列のサイズ個の初期化式を読んでもなおまだ初期化式が残っている場合、無視する
skip_excess_elements();
}
// 残りのメンバーがまだあったらゼロ初期化する
for (; mem; mem = mem->next) {
Designator dseg2 = {desg, 0, mem};
cur = lvar_init_zero(cur, var, mem->ty, &dseg2);
}
return cur;
}
// compound-literal で "{" 初期化式 "}" で初期化する場合に "{" が存在する
// (int) { 1 } とか
bool has_open_brace = consume("{");
Node *e = assign();
// fprintf(stdout, "val: %d\n", e->val);
cur->next = new_desg_node(var, desg, e);
if (has_open_brace) {
expect_end();
}
return cur->next;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdx), %eax
cmpl $0x9, %eax
je 0x804a
cmpl $0x8, %eax
jne 0x810a
movq 0x10(%r12), %rax
cmpl $0x4, (%rax)
movq %r14, 0x20(%rsp)
jne 0x816f
leaq 0x855c(%rip), %rax # 0x10480
movq (%rax), %rdx
cmpl $0x14, (%rdx)
jne 0x816f
movq 0x8(%rdx), %rcx
movq %rcx, (%rax)
movq 0x18(%r12), %rax
movq %rdx, 0x30(%rsp)
movslq 0x30(%rdx), %rcx
cmpq %rcx, %rax
movl %eax, %edx
cmovgl %ecx, %edx
testl %edx, %edx
jle 0x7fd0
movl %edx, 0x2c(%rsp)
movl %edx, %eax
movq %rax, (%rsp)
xorl %r14d, %r14d
movq 0x30(%rsp), %rbp
movq %rbx, %r13
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl %r14d, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rbp), %rax
movsbq (%rax,%r14), %rbx
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x22, (%rax)
movq %rbp, 0x8(%rax)
movq %rbx, 0x80(%rax)
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x8342
movq %rax, %rbx
movq %rax, 0x30(%r13)
incq %r14
cmpq %r14, (%rsp)
jne 0x7f63
movq 0x18(%r12), %rax
movl 0x2c(%rsp), %edx
movslq %edx, %r14
cmpq %r14, %rax
jle 0x8015
leaq 0x8(%rsp), %r13
movq 0x20(%rsp), %rbp
movq %rbp, 0x8(%rsp)
movl %r14d, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x83b6
movq %rax, %rbx
incq %r14
cmpq %r14, 0x18(%r12)
jg 0x7fe2
cmpb $0x0, 0xc(%r12)
je 0x8300
movq 0x30(%rsp), %rax
movslq 0x30(%rax), %rax
movb $0x0, 0xc(%r12)
movq %rax, 0x18(%r12)
movq 0x10(%r12), %rcx
movl 0x4(%rcx), %ecx
imull %eax, %ecx
movl %ecx, 0x4(%r12)
jmp 0x8300
leaq 0x42c5(%rip), %rdi # 0xc316
callq 0x51eb
movb $0x1, %r13b
testb %al, %al
je 0x8075
leaq 0x841c(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
sete %r13b
movq 0x20(%r12), %rbp
leaq 0x462c(%rip), %rdi # 0xc6ad
callq 0x51eb
testb %al, %al
jne 0x82b8
movb %r13b, (%rsp)
testq %rbp, %rbp
je 0x8323
leaq 0x8(%rsp), %r12
leaq 0x83d9(%rip), %r13 # 0x10480
movq %r14, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x7edc
movq %rax, %rbx
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x82b2
callq 0x4b87
testb %al, %al
jne 0x82b4
leaq 0x45c0(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x82b4
movq (%r13), %rax
movq 0x8(%rax), %rax
movq %rax, (%r13)
jmp 0x80a7
leaq 0x4205(%rip), %rdi # 0xc316
callq 0x51eb
movb $0x1, %bpl
testb %al, %al
je 0x8135
leaq 0x835c(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
sete %bpl
callq 0x7be0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8342
movq %rax, 0x30(%rbx)
testb %bpl, %bpl
jne 0x8166
callq 0x4b2b
testb %al, %al
jne 0x8166
leaq 0x454c(%rip), %rdi # 0xc6ad
callq 0x5b5c
movq 0x30(%rbx), %rbx
jmp 0x8300
leaq 0x41a0(%rip), %rdi # 0xc316
callq 0x51eb
movb $0x1, %bpl
testb %al, %al
je 0x819a
leaq 0x82f7(%rip), %rax # 0x10480
movq (%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
sete %bpl
leaq 0x450c(%rip), %rdi # 0xc6ad
callq 0x51eb
xorl %r14d, %r14d
testb %al, %al
jne 0x8233
movb %bpl, (%rsp)
xorl %r14d, %r14d
leaq 0x82c1(%rip), %rbp # 0x10480
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1(%r14), %r13
movl %r14d, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %rcx
callq 0x7edc
movq %rax, %rbx
cmpb $0x0, 0xc(%r12)
jne 0x8202
cmpq %r13, 0x18(%r12)
jle 0x822c
callq 0x4b87
testb %al, %al
jne 0x822c
leaq 0x449d(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x822c
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbp)
movq %r13, %r14
jmp 0x81bf
incl %r14d
movb (%rsp), %bpl
testb %bpl, %bpl
jne 0x8245
callq 0x4b2b
testb %al, %al
je 0x8319
movslq %r14d, %rbp
cmpq %rbp, 0x18(%r12)
jle 0x828e
leaq 0x8(%rsp), %r13
movq 0x20(%rsp), %r14
movq %r14, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x83b6
movq %rax, %rbx
incq %rbp
cmpq %rbp, 0x18(%r12)
jg 0x8259
movl %ebp, %r14d
cmpb $0x1, 0xc(%r12)
jne 0x8300
movb $0x0, 0xc(%r12)
movq %rbp, 0x18(%r12)
movq 0x10(%r12), %rax
imull 0x4(%rax), %r14d
movl %r14d, 0x4(%r12)
jmp 0x8300
xorl %ebp, %ebp
movb (%rsp), %r13b
testb %r13b, %r13b
jne 0x82c6
callq 0x4b2b
testb %al, %al
je 0x8312
testq %rbp, %rbp
je 0x8300
leaq 0x8(%rsp), %r12
movq %r14, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq 0x8(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x83b6
movq %rax, %rbx
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0x82d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2230
jmp 0x82c6
callq 0x2230
jmp 0x8245
leaq 0x46aa(%rip), %rdi # 0xc9d4
leaq 0x4380(%rip), %rsi # 0xc6b1
leaq 0x46a0(%rip), %rcx # 0xc9d8
movl $0x6f2, %edx # imm = 0x6F2
callq 0x20d0
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
lvar_init_zero
|
static Node *lvar_init_zero(Node *cur, Var *var, Type *ty, Designator *dseg) {
if (ty->kind == TY_ARRAY) {
// 配列の場合は各要素も再帰的に0にする
for (int i = 0; i < ty->array_size; i++) {
Designator desg2 = {dseg, i};
cur = lvar_init_zero(cur, var, ty->ptr_to, &desg2);
}
return cur;
}
// 配列でない場合は、単純にその変数(入れ子の配列の場合はどこかの末端の要素)に0を代入するコードをnextにつなげていく
cur->next = new_desg_node(var, dseg, new_num_node(0, token));
return cur->next;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x8, (%rdx)
jne 0x8414
movq %rdx, %r12
cmpq $0x0, 0x18(%rdx)
jle 0x844c
xorl %ebp, %ebp
movq %rsp, %r13
movq %r14, (%rsp)
movl %ebp, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x83b6
movq %rax, %rbx
incq %rbp
cmpq %rbp, 0x18(%r12)
jg 0x83e1
jmp 0x844c
leaq 0x8065(%rip), %rax # 0x10480
movq (%rax), %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x22, (%rax)
movq %r12, 0x8(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8342
movq %rax, 0x30(%rbx)
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
new_desg_node_sub
|
static Node *new_desg_node_sub(Var *var, Designator *desg, Token *tk) {
if (!desg) {
return new_var_node(var, tk);
}
Node *node = new_desg_node_sub(var, desg->next, tk);
if (desg->mem) {
// dsegが構造体のメンバー参照なら、返ってきたnodeを構造体の変数とみなしてそのメンバー参照のastを作成
node = new_unary_node(ND_MEMBER, node, tk);
node->member = desg->mem;
return node;
}
node = new_add_node(node, new_num_node(desg->idx, tk), tk);
node = new_unary_node(ND_DEREF, node, tk);
add_type(node);
return node;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x84b7
movq %rsi, %r14
movq (%rsi), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x845e
movq %rax, %r15
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x84d9
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl $0x23, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r12, 0x98(%rax)
jmp 0x8536
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl $0x17, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x78(%rax)
jmp 0x852e
movslq 0x8(%r14), %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movl $0x22, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, 0x80(%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x6651
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl $0x1f, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
find_var
|
static VarScope *find_var(Token *token) {
for (VarScope *sc = var_scope; sc; sc = sc->next) {
if (sc->type_def) {
// typedef は変数じゃないので無視
continue;
}
if (strlen(sc->name) == token->len &&
strncmp(sc->name, token->str, token->len) == 0) {
return sc;
}
}
return NULL;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x7eef(%rip), %rbx # 0x10440
testq %rbx, %rbx
je 0x8590
movq %rdi, %r14
cmpq $0x0, 0x18(%rbx)
jne 0x8588
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x20b0
movslq 0x20(%r14), %rcx
cmpq %rcx, %rax
jne 0x8588
movq 0x18(%r14), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0x2060
testl %eax, %eax
je 0x8592
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x8559
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
expr
|
static Node *expr() {
Token *tk;
Node *node = assign();
while (tk = consume(",")) {
// カンマがある場合、最後の式の値だけスタックに積みたいので、
// カンマより左にある式の結果は全部式文(ND_EXPR_STMT)にして計算だけして結果は捨てる
node = new_unary_node(ND_EXPR_STMT, node, node->tok);
node = new_bin_node(ND_COMMA, node, assign(), tk);
}
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x7be0
movq %rax, %rbx
leaq 0x40fa(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x863c
leaq 0x7ebb(%rip), %r13 # 0x10480
leaq 0x40e3(%rip), %r14 # 0xc6af
movq (%r13), %rbp
movq 0x8(%rbp), %rax
movq %rax, (%r13)
movq 0x8(%rbx), %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x21, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, 0x18(%rax)
callq 0x7be0
movq %rax, %r12
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x25, (%rax)
movq %rbp, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
movq %r14, %rdi
callq 0x51eb
testb %al, %al
jne 0x85cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
enter_scope
|
static Scope *enter_scope(void) {
Scope *new_scope = calloc(1, sizeof(Scope));
new_scope->var_scope = var_scope;
new_scope->tag_scope = tag_scope;
scope_depth++;
return new_scope;
}
|
pushq %rax
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq 0x7ddb(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movq 0x7dc9(%rip), %rcx # 0x10438
movq %rcx, 0x8(%rax)
incl 0x7db7(%rip) # 0x10430
popq %rcx
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
stmt
|
static Node *stmt() {
Token *tk;
Node *node = NULL;
if (tk = consume(";")) {
node = new_node(ND_NULL, tk);
} else if (tk = consume_kind(TK_RETURN)) {
node = new_node(ND_RETURN, tk);
if (!consume(";")) {
node->lhs = expr();
expect(";");
}
} else if (tk = consume_kind(TK_IF)) {
node = new_node(ND_IF, tk);
expect("(");
node->cond = expr();
expect(")");
node->then = stmt();
// elseがあればパース
if (consume_kind(TK_ELSE)) {
node->els = stmt();
} else {
node->els = NULL;
}
} else if (tk = consume_kind(TK_WHILE)) {
node = new_node(ND_WHILE, tk);
expect("(");
node->cond = expr();
expect(")");
node->body = stmt();
} else if (tk = consume_kind(TK_DO)) {
node = new_node(ND_WHILE, tk);
node->is_do_while = true;
node->body = stmt();
expect_kind(TK_WHILE);
expect("(");
node->cond = expr();
expect(")");
expect(";");
} else if (tk = consume_kind(TK_FOR)) {
node = new_node(ND_FOR, tk);
Scope *sc = enter_scope();
expect("(");
if (consume(";")) {
//次が";"なら初期化式なしなのでNULL入れる
node->init = NULL;
} else {
// ";"でないなら初期化式かまたは辺宣言あるのでパース
if (is_type(token)) {
node->init = var_decl();
} else {
node->init = read_expr_stmt();
expect(";");
}
}
if (consume(";")) {
//次が";"なら条件式なしなのでNULL入れる
node->cond = NULL;
} else {
// ";"でないなら条件式があるのでパース
node->cond = expr();
expect(";");
}
if (consume(")")) {
//次が")"なら継続式なしなのでNULL入れる
node->inc = NULL;
} else {
// ")"でないなら継続式があるのでパース
node->inc = read_expr_stmt();
expect(")");
}
node->body = stmt();
leave_scope(sc);
} else if (tk = consume("{")) {
node = new_node(ND_BLOCK, tk);
Scope *sc = enter_scope();
int i = 0;
Node head = {};
Node *cur = &head;
while (!consume("}")) {
cur->next = stmt();
cur = cur->next;
}
node->body = head.next;
leave_scope(sc);
} else if (tk = consume_kind(TK_BREAK)) {
expect(";");
node = new_node(ND_BREAK, tk);
} else if (tk = consume_kind(TK_CONTINUE)) {
expect(";");
node = new_node(ND_CONTINUE, tk);
} else if (tk = consume_kind(TK_GOTO)) {
char *ident = expect_ident();
expect(";");
node = new_node(ND_GOTO, tk);
node->label_name = ident;
} else if (tk = consume_kind(TK_SWITCH)) {
expect("(");
Node *switch_condition = expr();
expect(")");
node = new_unary_node(ND_SWITCH, switch_condition, tk);
// 今のswitchを保存して現在のswitchに切り替える
Node *tmp = current_switch;
current_switch = node;
node->body = stmt();
// もとのswitchに戻す
current_switch = tmp;
} else if (tk = consume_kind(TK_CASE)) {
if (!current_switch) {
error(tk->str, "対応するswitchがありません");
}
int case_cond_val = const_expr();
expect(":");
node = new_unary_node(ND_CASE, stmt(), tk);
node->case_cond_val = case_cond_val;
node->is_default_case = false;
node->case_next = current_switch->case_next;
current_switch->case_next = node;
} else if (tk = consume_kind(TK_DEFAULT)) {
if (!current_switch) {
error(tk->str, "対応するswitchがありません");
}
expect(":");
node = new_unary_node(ND_CASE, stmt(), tk);
node->is_default_case = true;
current_switch->default_case = node;
} else {
Token *tmp = token;
Token *tk = consume_ident();
if (consume(":")) {
// identの次に":" が来てたらラベル
node = new_unary_node(ND_LABEL, stmt(), tk);
node->label_name = my_strndup(tk->str, tk->len);
} else {
// ラベルじゃなかったので、もとに戻す
token = tmp;
// キーワードじゃなかったら 変数宣言かどうかチェック
node = var_decl();
if (!node) {
// 変数宣言でなかったら式文
node = read_expr_stmt();
expect(";");
}
}
}
add_type(node);
return node;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x4027(%rip), %rdi # 0xc6ba
callq 0x51eb
leaq 0x7de1(%rip), %rbp # 0x10480
movq (%rbp), %r12
testb %al, %al
je 0x86e9
movq 0x8(%r12), %rax
movq %rax, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x31, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, %rdi
callq 0x9eef
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r12), %ebx
leal -0x4(%rbx), %eax
cmpl $0x5, %eax
ja 0x8748
leaq 0x3f58(%rip), %rcx # 0xc654
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r12), %r14
movq %r14, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x18, (%rax)
movq %r12, 0x8(%rax)
leaq 0x3f89(%rip), %rdi # 0xc6ba
callq 0x51eb
testb %al, %al
je 0x89ae
movq 0x8(%r14), %rax
movq %rax, (%rbp)
jmp 0x86cc
leaq 0x3bc7(%rip), %rdi # 0xc316
callq 0x51eb
testb %al, %al
je 0x8960
movq 0x8(%r12), %rax
movq %rax, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x1a, (%rax)
movq %r12, 0x8(%rax)
callq 0x864e
movq %rax, %r14
movq %rsp, %r15
movl $0xc8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
leaq 0x3f0b(%rip), %rdi # 0xc6ad
callq 0x51eb
testb %al, %al
jne 0x87cd
leaq 0x3efb(%rip), %r12 # 0xc6ad
callq 0x867b
movq %rax, %r13
movq %rax, 0x30(%r15)
movq %r12, %rdi
callq 0x51eb
movq %r13, %r15
testb %al, %al
je 0x87b2
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbp)
movq 0x30(%rsp), %rax
jmp 0x8a5d
movq 0x8(%r12), %rax
movq %rax, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x19, (%rax)
movq %r12, 0x8(%rax)
movb $0x1, 0x50(%rax)
callq 0x867b
movq %rax, 0x28(%rbx)
callq 0x8d5e
leaq 0x3d55(%rip), %rdi # 0xc576
callq 0x5b5c
callq 0x859b
movq %rax, 0x38(%rbx)
leaq 0x3d53(%rip), %rdi # 0xc589
callq 0x5b5c
jmp 0x89b7
movq 0x8(%r12), %rax
movq %rax, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x19, (%rax)
movq %r12, 0x8(%rax)
leaq 0x3d0a(%rip), %rdi # 0xc576
callq 0x5b5c
callq 0x859b
movq %rax, 0x38(%rbx)
leaq 0x3d08(%rip), %rdi # 0xc589
callq 0x5b5c
callq 0x867b
movq %rax, 0x28(%rbx)
jmp 0x86cc
movq 0x8(%r12), %rax
movq %rax, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x1b, (%rax)
movq %r12, 0x8(%rax)
leaq 0x3cb6(%rip), %rdi # 0xc576
callq 0x5b5c
callq 0x859b
movq %rax, 0x38(%rbx)
leaq 0x3cb4(%rip), %rdi # 0xc589
callq 0x5b5c
callq 0x867b
movq %rax, 0x40(%rbx)
movq (%rbp), %rax
cmpl $0x8, (%rax)
jne 0x86cc
movq 0x8(%rax), %rax
movq %rax, (%rbp)
callq 0x867b
movq %rax, 0x48(%rbx)
jmp 0x86cc
movq 0x8(%r12), %rax
movq %rax, (%rbp)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x1c, (%rax)
movq %r12, 0x8(%rax)
callq 0x864e
movq %rax, %r14
leaq 0x3c3c(%rip), %rdi # 0xc576
callq 0x5b5c
leaq 0x3d74(%rip), %rdi # 0xc6ba
callq 0x51eb
movq (%rbp), %rdi
testb %al, %al
je 0x89c8
movq 0x8(%rdi), %rax
movq %rax, (%rbp)
jmp 0x89f2
leal -0x18(%rbx), %eax
cmpl $0x5, %eax
ja 0x8a81
leaq 0x3cf9(%rip), %rcx # 0xc66c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r12), %rax
movq %rax, (%rbp)
leaq 0x3d2e(%rip), %rdi # 0xc6ba
callq 0x5b5c
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2a, (%rax)
jmp 0x86c8
callq 0x859b
movq %rax, 0x18(%rbx)
leaq 0x3cfc(%rip), %rdi # 0xc6ba
callq 0x5b5c
jmp 0x86cc
movl (%rdi), %eax
leal -0xa(%rax), %ecx
cmpl $0x6, %ecx
jb 0x89e9
cmpl $0x17, %eax
ja 0x8d0f
movl $0xe30000, %ecx # imm = 0xE30000
btl %eax, %ecx
jae 0x8d0f
callq 0x8d98
movq %rax, 0x58(%rbx)
leaq 0x3cc1(%rip), %rdi # 0xc6ba
callq 0x51eb
testb %al, %al
je 0x8a10
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbp)
jmp 0x8a25
callq 0x859b
movq %rax, 0x38(%rbx)
leaq 0x3c9a(%rip), %rdi # 0xc6ba
callq 0x5b5c
leaq 0x3b5d(%rip), %rdi # 0xc589
callq 0x51eb
testb %al, %al
je 0x8a43
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbp)
jmp 0x8a58
callq 0x92c6
movq %rax, 0x60(%rbx)
leaq 0x3b36(%rip), %rdi # 0xc589
callq 0x5b5c
callq 0x867b
movq %rax, 0x28(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, 0x79d1(%rip) # 0x10440
movq %rcx, 0x79c2(%rip) # 0x10438
decl 0x79b4(%rip) # 0x10430
jmp 0x86cc
cmpl $0x2, %ebx
jne 0x8b6f
movq 0x8(%r12), %rbx
movq %rbx, (%rbp)
movq %r12, %r15
jmp 0x8b75
movq 0x8(%r12), %rax
movq %rax, (%rbp)
cmpq $0x0, 0x79ac(%rip) # 0x10458
je 0x8d4b
callq 0x5fef
movq %rax, %rdi
xorl %esi, %esi
callq 0x5c54
movq %rax, %r14
leaq 0x2a56(%rip), %rdi # 0xb521
callq 0x5b5c
callq 0x867b
movq %rax, %r15
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2f, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x18(%rax)
movslq %r14d, %rax
movq %rax, 0xa8(%rbx)
movb $0x0, 0xb0(%rbx)
movq 0x7948(%rip), %rax # 0x10458
movq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rbx)
movq %rbx, 0xc0(%rax)
jmp 0x86cc
movq 0x8(%r12), %rax
movq %rax, (%rbp)
callq 0x5bde
movq %rax, %r14
leaq 0x3b78(%rip), %rdi # 0xc6ba
callq 0x5b5c
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2c, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0xa0(%rax)
jmp 0x86cc
xorl %r15d, %r15d
movq %r12, %rbx
leaq 0x29a5(%rip), %rdi # 0xb521
callq 0x51eb
testb %al, %al
je 0x8bea
movq 0x8(%rbx), %rax
movq %rax, (%rbp)
callq 0x867b
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2d, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x18(%rax)
movq 0x18(%r15), %r12
movslq 0x20(%r15), %r14
leaq 0x1(%r14), %rdi
movl $0x1, %esi
callq 0x2100
movq %rax, %r15
testq %r14, %r14
jle 0x8d37
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2150
jmp 0x8d3a
movq %r12, (%rbp)
callq 0x8d98
movq %rax, %rbx
testq %rax, %rax
jne 0x86cc
callq 0x92c6
movq %rax, %rbx
jmp 0x89b7
movq 0x8(%r12), %rax
movq %rax, (%rbp)
leaq 0x395a(%rip), %rdi # 0xc576
callq 0x5b5c
callq 0x859b
movq %rax, %r14
leaq 0x3959(%rip), %rdi # 0xc589
callq 0x5b5c
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2e, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x18(%rax)
movq 0x77fc(%rip), %r14 # 0x10458
movq %rax, 0x77f5(%rip) # 0x10458
callq 0x867b
movq %rax, 0x28(%rbx)
movq %r14, 0x77e5(%rip) # 0x10458
jmp 0x86cc
movq 0x8(%r12), %rax
movq %rax, (%rbp)
leaq 0x3a32(%rip), %rdi # 0xc6ba
callq 0x5b5c
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2b, (%rax)
jmp 0x86c8
movq 0x8(%r12), %rax
movq %rax, (%rbp)
cmpq $0x0, 0x779d(%rip) # 0x10458
je 0x8d4b
leaq 0x2859(%rip), %rdi # 0xb521
callq 0x5b5c
callq 0x867b
movq %rax, %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movl $0x2f, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x18(%rax)
movb $0x1, 0xb0(%rax)
movq 0x7755(%rip), %rax # 0x10458
movq %rbx, 0xb8(%rax)
jmp 0x86cc
callq 0x59dc
testq %rax, %rax
jne 0x89e9
callq 0x92c6
movq %rax, 0x58(%rbx)
leaq 0x398d(%rip), %rdi # 0xc6ba
callq 0x5b5c
jmp 0x89f2
xorl %r14d, %r14d
movb $0x0, (%r15,%r14)
movq %r15, 0xa0(%rbx)
jmp 0x86cc
movq 0x18(%r12), %rdi
leaq 0x3e31(%rip), %rsi # 0xcb88
xorl %eax, %eax
callq 0x4a3b
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
var_decl
|
static Node *var_decl() {
Token *tk;
if (is_type(token)) {
StorageClass sclass = false;
Type *type = basetype(&sclass);
if (tk = consume(";")) {
// basetypeの直後に;が来ていたらenumやstructの型の定義だけする場合
// また、試したところ int; という意味ない文もエラーにはならないので、
// 特に構造体やenumに限定せず任意のbasetypeの直後の ";" もいけそう。
return new_node(ND_NULL, tk);
}
tk = token;
char *ident_name;
Type *basic_type = type;
type = declarator(type, &ident_name);
if (sclass == TYPEDEF) {
expect(";");
push_typedef_scope(ident_name, type);
return new_node(ND_NULL, tk);
}
if (sclass == STATIC) {
// static がついてたらスコープだけローカル変数で、グローバル変数扱いにする
// ただ、単純にident_name でグローバル変数を作ってしまうと別の関数で、
// 同じ名前のstatic local な変数を作れなくなる。
//
// なので、グローバル変数自体はユニークなラベルで名前をつけて、
// スコープ側でその変数をここでパースしたident_nameで登録することで、同じ名前のstatic_local変数を別の関数でも使えるようにしている。
Var *var = new_gvar(new_label(), type, true, true);
// 別途スコープにident_nameでこの変数を登録
push_var_scope(ident_name, var);
if (!consume("=")) {
if (type->is_incomplete) {
error_at(tk->str, "incomplete element type(gvar)");
}
} else {
var->initializer = gvar_initializer(type);
}
// カンマ区切りの別の宣言もあればパース
static_var_decl_sub(basic_type, sclass);
expect(";");
return new_node(ND_NULL, tk);
}
Var *var = new_lvar(ident_name, type);
Node *node = new_node(ND_VAR_DECL, tk);
node->var = var;
if (var->type->kind == TY_VOID) {
error_at(tk->str, "void型の変数は宣言できません");
}
// 初期化式があるかどうかチェック
if (consume("=")) {
// 今作ったlocal変数に初期化式の値を代入するノードを設定
node->initializer = local_var_initializer(var, tk);
}
if (type->is_incomplete) {
error_at(tk->str, "incomplete element type(var_decl)");
}
// カンマ区切りの別の宣言もあればパース
node = var_decl_sub(basic_type, node);
expect(";");
return node;
}
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x76d3(%rip), %rbx # 0x10480
movq (%rbx), %rdi
movl (%rdi), %eax
leal -0xa(%rax), %ecx
cmpl $0x6, %ecx
jb 0x8dd1
cmpl $0x17, %eax
ja 0x9101
movl $0xe30000, %ecx # imm = 0xE30000
btl %eax, %ecx
jae 0x9101
leaq 0x14(%rsp), %rdi
movl $0x0, (%rdi)
callq 0x522f
movq %rax, %r13
leaq 0x38cf(%rip), %rdi # 0xc6ba
callq 0x51eb
movq (%rbx), %r14
testb %al, %al
je 0x8e00
movq 0x8(%r14), %rax
movq %rax, (%rbx)
jmp 0x8e64
leaq 0x20(%rsp), %rsi
movq %r13, %rdi
callq 0x58f5
movq %rax, %r12
movl 0x14(%rsp), %eax
cmpl $0x2, %eax
je 0x8e92
cmpl $0x1, %eax
jne 0x8f44
leaq 0x3891(%rip), %rdi # 0xc6ba
callq 0x5b5c
movq 0x20(%rsp), %rbx
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %rbx, 0x8(%rax)
movq 0x75f3(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movl 0x75da(%rip), %ecx # 0x10430
movl %ecx, 0x2c(%rax)
movq %rax, 0x75e0(%rip) # 0x10440
movq %r12, 0x18(%rax)
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbp
movl $0x31, (%rax)
movq %r14, 0x8(%rax)
movq %rbp, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rsp)
callq 0x7688
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x761c
movq %rax, %r15
movb $0x1, 0x20(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %r15, 0x8(%rax)
movq 0x755e(%rip), %rcx # 0x10428
movq %rcx, (%rax)
movq %rax, 0x7554(%rip) # 0x10428
movq 0x20(%rsp), %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %r14, 0x8(%rax)
movq 0x754d(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movl 0x7534(%rip), %ecx # 0x10430
movl %ecx, 0x2c(%rax)
movq %rax, 0x753a(%rip) # 0x10440
movq %r15, 0x10(%rax)
leaq 0x39f0(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x9116
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x76f2
movq (%r14), %rax
movq %rax, 0x18(%r15)
jmp 0x9122
movq 0x20(%rsp), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x761c
movq %rax, %rbp
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %rbp, 0x8(%rax)
movq 0x74dd(%rip), %rcx # 0x10450
movq %rcx, (%rax)
movq %rax, 0x74d3(%rip) # 0x10450
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r15
movl $0x20, (%rax)
movq %r14, 0x8(%rsp)
movq %r14, 0x8(%rax)
movq %rbp, 0x78(%rax)
movq (%rbp), %rax
cmpl $0x1, (%rax)
je 0x929e
leaq 0x394b(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x8fda
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0x75b8
movq %rax, 0x68(%r15)
cmpb $0x1, 0xc(%r12)
je 0x92a9
leaq 0x36c2(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x925d
movq %r13, 0x18(%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %r13
movq %r13, (%rbx)
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x58f5
movq %rax, %rbp
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x761c
movq %rax, %r12
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %r12, 0x8(%rax)
movq 0x7406(%rip), %rcx # 0x10450
movq %rcx, (%rax)
movq %rax, 0x73fc(%rip) # 0x10450
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %r14
movl $0x20, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x78(%rax)
movq (%r12), %rax
cmpl $0x1, (%rax)
je 0x9271
leaq 0x3879(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x90ac
movq (%rbx), %r13
movq 0x8(%r13), %rax
movq %rax, (%rbx)
movq %r12, %rdi
movq %r13, %rsi
callq 0x75b8
movq %rax, 0x68(%r14)
jmp 0x90af
xorl %r13d, %r13d
cmpb $0x1, 0xc(%rbp)
je 0x927e
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbp
movl $0x25, (%rax)
movq %r13, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rax, %rdi
callq 0x9eef
leaq 0x35c3(%rip), %rdi # 0xc6af
callq 0x51eb
movq %rbp, %r15
testb %al, %al
jne 0x8fff
jmp 0x9260
callq 0x59dc
testq %rax, %rax
jne 0x8dd1
xorl %ebp, %ebp
jmp 0x8e80
cmpb $0x1, 0xc(%r12)
je 0x92bb
leaq 0x3586(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
je 0x922b
cmpl $0x2, 0x14(%rsp)
sete 0x18(%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %r12
movq %r12, (%rbx)
movq %r13, %r15
movq %r13, %rdi
leaq 0x28(%rsp), %rsi
callq 0x58f5
movq %rax, %r13
callq 0x7688
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x761c
movq %rax, %r14
movb 0x18(%rsp), %al
movb %al, 0x20(%r14)
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %r14, 0x8(%rax)
movq 0x7294(%rip), %rcx # 0x10428
movq %rcx, (%rax)
movq %rax, 0x728a(%rip) # 0x10428
movq 0x28(%rsp), %rbp
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %rbp, 0x8(%rax)
movq 0x7283(%rip), %rcx # 0x10440
movq %rcx, (%rax)
movl 0x726a(%rip), %ecx # 0x10430
movl %ecx, 0x2c(%rax)
movq %rax, 0x7270(%rip) # 0x10440
movq %r14, 0x10(%rax)
leaq 0x3726(%rip), %rdi # 0xc901
callq 0x51eb
testb %al, %al
je 0x9206
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, (%rbx)
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x76f2
movq 0x30(%rsp), %rax
movq %rax, 0x18(%r14)
jmp 0x920d
cmpb $0x1, 0xc(%r13)
je 0x928b
leaq 0x349b(%rip), %rdi # 0xc6af
callq 0x51eb
testb %al, %al
movq %r15, %r13
leaq 0x725b(%rip), %rbx # 0x10480
jne 0x9140
leaq 0x3488(%rip), %rdi # 0xc6ba
callq 0x5b5c
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbp
movl $0x31, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbp)
jmp 0x8e80
movq %r15, %rbp
leaq 0x3453(%rip), %rdi # 0xc6ba
callq 0x5b5c
jmp 0x8e80
movq 0x18(%r13), %rdi
leaq 0x3954(%rip), %rsi # 0xcbd0
jmp 0x9297
movq 0x18(%r13), %rdi
leaq 0x3992(%rip), %rsi # 0xcc1b
jmp 0x9297
movq 0x18(%r12), %rdi
leaq 0x38cf(%rip), %rsi # 0xcb66
xorl %eax, %eax
callq 0x487c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
jmp 0x9275
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x3940(%rip), %rsi # 0xcbf9
jmp 0x9297
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
jmp 0x9290
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
read_expr_stmt
|
static Node *read_expr_stmt() {
Node *node = new_node(ND_EXPR_STMT, token);
node->kind = ND_EXPR_STMT;
node->lhs = expr();
return node;
}
|
pushq %r14
pushq %rbx
pushq %rax
leaq 0x71af(%rip), %rax # 0x10480
movq (%rax), %r14
movl $0x1, %edi
movl $0xc8, %esi
callq 0x2100
movq %rax, %rbx
movq %r14, 0x8(%rax)
movl $0x21, (%rax)
callq 0x859b
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/parser.c
|
sb_init
|
string_buffer *sb_init() {
string_buffer *sb = calloc(1, sizeof(string_buffer));
sb->str_len = 0;
sb->buf_len = 16;
sb->buf = calloc(sb->buf_len, sizeof(char));
return sb;
}
|
pushq %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x2100
movq %rax, %rbx
movl $0x10, 0xc(%rax)
movl $0x10, %edi
movl $0x1, %esi
callq 0x2100
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/string_buffer.c
|
add_all1
|
int add_all1(int x, ...) {
va_list ap;
va_start(ap, x);
for (;;) {
int y = va_arg(ap, int);
if (y == 0)
return x;
x += y;
}
}
|
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x943a
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, -0x80(%rsp)
movl $0x8, %ecx
movl %edi, %eax
cmpl $0x28, %ecx
ja 0x9475
movq %rdx, %rsi
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x947e
leaq 0x8(%rdx), %rsi
movq %rsi, -0x78(%rsp)
movl (%rdx), %r8d
leal (%r8,%rax), %edi
movq %rsi, %rdx
testl %r8d, %r8d
jne 0x945d
addq $0x58, %rsp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/test_func.c
|
add_all2
|
int add_all2(int x, int y, ...) {
va_list ap;
va_start(ap, y);
x = x + y;
for (;;) {
int y = va_arg(ap, int);
if (y == 0)
return x;
x += y;
}
}
|
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x94d6
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rdx
movq %rdx, -0x78(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, -0x80(%rsp)
addl %esi, %edi
movl $0x10, %ecx
movl %edi, %eax
cmpl $0x28, %ecx
ja 0x9513
movq %rdx, %rsi
movl %ecx, %edx
addq %r10, %rdx
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x951c
leaq 0x8(%rdx), %rsi
movq %rsi, -0x78(%rsp)
movl (%rdx), %r8d
leal (%r8,%rax), %edi
movq %rsi, %rdx
testl %r8d, %r8d
jne 0x94fb
addq $0x58, %rsp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/test_func.c
|
dump_token
|
void dump_token(Token *t) {
if (!t) {
printf("## (NULL token)");
return;
}
printf("## (Token kind: %*s ", 12 ,token_kind_to_s(t->kind));
switch (t->kind) {
case TK_NUM:
printf("[%ld]", t->val);
break;
case TK_STR:
printf("[contents: [%s], length(includes \\0): %d", t->contents, t->content_length);
break;
default:
printf("[%s]", my_strndup(t->str, t->len));
break;
}
printf(")\n");
}
|
testq %rdi, %rdi
je 0x95d4
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x9568
leaq 0x3824(%rip), %rdi # 0xcdd0
movl $0xc, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20c0
movl (%rbx), %eax
cmpl $0x14, %eax
je 0x95e2
cmpl $0x3, %eax
jne 0x95f9
movq 0x10(%rbx), %rsi
leaq 0x2d2d(%rip), %rdi # 0xc2ff
jmp 0x960f
leaq 0x37e5(%rip), %rdi # 0xcdc0
xorl %eax, %eax
jmp 0x20c0
movq 0x28(%rbx), %rsi
movl 0x30(%rbx), %edx
leaq 0x37f5(%rip), %rdi # 0xcde5
xorl %eax, %eax
callq 0x20c0
jmp 0x9616
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %esi
callq 0x4ae3
leaq 0x3802(%rip), %rdi # 0xce0e
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
leaq 0x2f6c(%rip), %rdi # 0xc589
popq %rbx
jmp 0x2070
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/tokenize.c
|
free_tokens
|
void free_tokens(Token *cur) {
while (cur) {
Token *tmp = cur->next;
free(cur);
cur = tmp;
}
}
|
testq %rdi, %rdi
je 0x963b
pushq %rbx
movq 0x8(%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x9629
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/tokenize.c
|
tokenize_keyword
|
Keyword *tokenize_keyword(char *p) {
for (int i = 0; i < sizeof(keywords) / sizeof(Keyword); i++) {
Keyword *k = &keywords[i];
int len = strlen(k->keyword);
if (strncmp(p, k->keyword, len) == 0 && !is_alnum(p[len])) {
return k;
}
}
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x6a7c(%rip), %r13 # 0x10130
xorl %ebp, %ebp
movq (%rbp,%r13), %r12
movq %r12, %rdi
callq 0x20b0
movslq %eax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2060
testl %eax, %eax
jne 0x96f0
movb (%r14,%r15), %al
cmpb $0x5f, %al
je 0x96f0
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x96f0
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
ja 0x96ff
addq $0x10, %rbp
cmpq $0x190, %rbp # imm = 0x190
jne 0x96b6
jmp 0x9705
addq %rbp, %r13
movq %r13, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/tokenize.c
|
is_multi_char_operator
|
int is_multi_char_operator(char *p) {
for (char **op = multi_char_ope; *op; op++) {
if (starts_with(p, *op)) {
return strlen(*op);
}
}
return 0;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x329e(%rip), %r14 # 0xc9c4
leaq 0x661b(%rip), %r15 # 0xfd48
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
testl %eax, %eax
je 0x9757
movq (%r15), %r14
addq $0x8, %r15
testq %r14, %r14
jne 0x972d
xorl %eax, %eax
jmp 0x975f
movq %r14, %rdi
callq 0x20b0
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/tokenize.c
|
tokenize
|
Token *tokenize(char *p) {
Token head;
head.next = NULL;
Token *cur = &head;
while (*p) {
// fprintf(stderr, "*p ... %c\n", *p);
if (isspace(*p)) {
p++;
continue;
}
if (starts_with(p, "//")) {
p += 2;
while (*p != '\n') {
p++;
}
continue;
}
if (starts_with(p, "/*")) {
char *q = strstr(p + 2, "*/");
if (!q) {
error_at(p, "ブロックコメントが閉じられていません");
}
p = q + 2;
continue;
}
// fprintf(stderr, "c ... %c\n", *p);
Keyword *key = tokenize_keyword(p);
if (key) {
int keyword_len = strlen(key->keyword);
cur = new_token(key->kind, cur, p, keyword_len);
assert(cur);
p += keyword_len;
continue;
}
int len = is_multi_char_operator(p);
if (len) {
cur = new_token(TK_RESERVED, cur, p, len);
assert(cur);
p += len;
continue;
}
if (is_ident_first_char(*p)) {
// fprintf(stderr, "tokenize ident(%c)\n", *p);
char *s = p; // 識別子の先頭
while (is_alnum(*p)) {
p++;
}
cur = new_token(TK_IDENT, cur, s, p - s); //p - s で文字列長さになる
assert(cur);
continue;
}
if (*p == '"') {
cur = tokenize_string_literal(cur, &p);
assert(cur);
continue;
}
if (*p == '\'') {
cur = tokenize_char_literal(cur, &p);
assert(cur);
continue;
}
if (ispunct(*p)) {
cur = new_token(TK_RESERVED, cur, p++, 1);
assert(cur);
continue;
}
if (isdigit(*p)) {
cur = tokenize_number(cur, &p);
assert(cur);
continue;
}
error_at(p, "トークナイズできません");
}
new_token(TK_EOF, cur, p, 0);
return head.next;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbp
movq %rdi, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movb (%rdi), %r15b
leaq 0x10(%rsp), %r13
testb %r15b, %r15b
je 0x9c79
callq 0x2210
movq %rax, %rbx
movq %r13, (%rsp)
movq %rbp, %r12
movq (%rbx), %r14
movsbq %r15b, %rax
movzwl (%r14,%rax,2), %ebp
btl $0xd, %ebp
jb 0x97fb
cmpw $0x2f2f, (%r12) # imm = 0x2F2F
je 0x980c
cmpw $0x2a2f, (%r12) # imm = 0x2A2F
jne 0x9821
leaq 0x2(%r12), %rdi
leaq 0x3645(%rip), %rsi # 0xce19
callq 0x2200
movq %rax, %r13
testq %rax, %rax
jne 0x97f2
movq %r12, %rdi
leaq 0x3631(%rip), %rsi # 0xce1c
xorl %eax, %eax
callq 0x487c
addq $0x2, %r13
movq %r13, %r12
jmp 0x97fe
incq %r12
movb (%r12), %r15b
testb %r15b, %r15b
jne 0x97a4
jmp 0x9c72
incq %r12
cmpb $0xa, 0x1(%r12)
leaq 0x1(%r12), %r12
jne 0x980f
movb $0xa, %r15b
jmp 0x9802
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x969d
testq %rax, %rax
je 0x9879
movq %rax, %r13
movq (%rax), %rdi
callq 0x20b0
movq %rax, %rbp
movl 0x8(%r13), %r14d
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r13
movl %r14d, (%rax)
movq %r12, 0x18(%rax)
movl %ebp, 0x20(%rax)
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movslq %ebp, %rbp
addq %r12, %rbp
movq %rbp, 0x8(%rsp)
jmp 0x9ad9
movq %r12, %rdi
callq 0x9717
testl %eax, %eax
je 0x98c0
movl %eax, %r13d
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movl $0x1, (%rax)
movq %r12, 0x18(%rax)
movl %r13d, 0x20(%rax)
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movslq %r13d, %rbp
addq %r12, %rbp
movq %rbp, 0x8(%rsp)
movq %rax, %r13
jmp 0x9ad9
cmpb $0x5f, %r15b
je 0x9930
movl %r15d, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x9930
cmpb $0x27, %r15b
je 0x998a
movzbl %r15b, %eax
cmpl $0x22, %eax
jne 0x99ab
xorl %eax, %eax
callq 0x9304
movq %rax, %r13
movq %r12, %rbp
movzbl 0x1(%rbp), %eax
cmpl $0x5c, %eax
je 0x9917
testl %eax, %eax
je 0x9a4f
cmpl $0x22, %eax
je 0x9a60
incq %rbp
movsbl %al, %esi
jmp 0x9926
movsbl 0x2(%rbp), %edi
addq $0x2, %rbp
callq 0x9dac
movl %eax, %esi
movq %r13, %rdi
callq 0x9335
jmp 0x98f5
leaq -0x1(%r12), %rbp
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movb 0x1(%rbp), %al
incq %rbp
incl %r14d
cmpb $0x5f, %al
je 0x993b
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x993b
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x993b
movq %rbp, 0x8(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r13
movl $0x2, (%rax)
movq %r12, 0x18(%rax)
movl %r14d, 0x20(%rax)
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
jmp 0x9ad9
movsbl 0x1(%r12), %r13d
cmpl $0x5c, %r13d
jne 0x99dc
leaq 0x2(%r12), %rbp
movsbl 0x2(%r12), %edi
callq 0x9dac
movl %eax, %r13d
jmp 0x99e1
testb $0x4, %bpl
jne 0x9aeb
btl $0xb, %ebp
jb 0x9b1a
movq %r12, %rdi
leaq 0x348a(%rip), %rsi # 0xce53
xorl %eax, %eax
callq 0x487c
movq %r12, %rbp
movq (%rsp), %r13
jmp 0x9ad9
leaq 0x1(%r12), %rbp
movb 0x1(%rbp), %al
testb %al, %al
jne 0x99fc
movq %rbp, %rdi
leaq 0x3544(%rip), %rsi # 0xcf36
xorl %eax, %eax
callq 0x487c
movb 0x1(%rbp), %al
cmpb $0x27, %al
je 0x9a12
leaq 0x1(%rbp), %rdi
leaq 0x3550(%rip), %rsi # 0xcf5b
xorl %eax, %eax
callq 0x487c
addq $0x2, %rbp
movq %rbp, 0x8(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movl $0x3, (%rax)
movq %r12, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movslq %r13d, %rcx
movq %rcx, 0x10(%rax)
jmp 0x98b8
movq %r12, %rdi
leaq 0x34b5(%rip), %rsi # 0xcf0e
xorl %eax, %eax
callq 0x487c
addq $0x2, %rbp
movl %ebp, %r14d
subl %r12d, %r14d
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r15
movl $0x14, (%rax)
movq %r12, 0x18(%rax)
movl %r14d, 0x20(%rax)
movq (%rsp), %rax
movq %r15, 0x8(%rax)
movq %r13, %rdi
xorl %esi, %esi
callq 0x9335
movq %r13, %rdi
callq 0x93b0
movq %rax, %r12
movq %r13, %rdi
callq 0x93b4
movq %r12, %rdi
movl %eax, %esi
callq 0x4ae3
movq %rax, 0x28(%r15)
movq %r13, %rdi
callq 0x93b4
movl %eax, 0x30(%r15)
movq %r13, %rdi
callq 0x9377
movq %rbp, 0x8(%rsp)
movq %r15, %r13
movb (%rbp), %r15b
testb %r15b, %r15b
jne 0x979d
jmp 0x9c79
leaq 0x1(%r12), %rbp
movq %rbp, 0x8(%rsp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r13
movl $0x1, %ecx
movl %ecx, (%rax)
movq %r12, 0x18(%rax)
movl %ecx, 0x20(%rax)
jmp 0x997d
cmpw $0x7830, (%r12) # imm = 0x7830
je 0x9b8c
cmpw $0x6230, (%r12) # imm = 0x6230
je 0x9c1d
cmpb $0x30, %r15b
jne 0x9b48
movsbq 0x1(%r12), %rax
testb $0x8, 0x1(%r14,%rax,2)
jne 0x9c4a
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r13
movl $0x3, (%rax)
movq %r12, 0x18(%rax)
movq (%rsp), %rax
movq %r13, 0x8(%rax)
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
movl $0xa, %edx
callq 0x2140
movq %rax, 0x10(%r13)
movq 0x8(%rsp), %rbp
jmp 0x9ad9
leaq 0x2(%r12), %rbp
xorl %r14d, %r14d
movq $-0x57, %rsi
movabsq $0x3f0000003f, %rdi # imm = 0x3F0000003F
movzbl (%rbp), %eax
movl %eax, %ecx
addl $-0x41, %ecx
cmpl $0x25, %ecx
ja 0x9be8
btq %rcx, %rdi
jae 0x9be8
leal -0x41(%rax), %edx
movq $-0x37, %rcx
cmpb $0x6, %dl
jb 0x9bcf
movq $-0x30, %rcx
shlq $0x4, %r14
leal -0x61(%rax), %edx
cmpb $0x6, %dl
cmovbq %rsi, %rcx
addq %rax, %r14
addq %rcx, %r14
incq %rbp
jmp 0x9ba5
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
jbe 0x9bb9
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movq %rax, %r13
movl $0x3, (%rax)
movq %r12, 0x18(%rax)
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movq %r14, 0x10(%rax)
jmp 0x986f
leaq 0x2(%r12), %rbp
movb 0x2(%r12), %al
movl %eax, %ecx
andb $-0x2, %cl
xorl %r14d, %r14d
cmpb $0x30, %cl
jne 0x9bf0
andb $0x1, %al
movzbl %al, %eax
leaq (%rax,%r14,2), %r14
movb 0x1(%rbp), %al
incq %rbp
movl %eax, %ecx
andb $-0x2, %cl
jmp 0x9c2f
leaq 0x1(%r12), %rbp
movl %eax, %ecx
andb $-0x8, %cl
xorl %r14d, %r14d
cmpb $0x30, %cl
jne 0x9bf0
andb $0x7, %al
movzbl %al, %eax
leaq (%rax,%r14,8), %r14
movb 0x1(%rbp), %al
incq %rbp
movl %eax, %ecx
andb $-0x8, %cl
jmp 0x9c57
movq %r12, %rbp
movq (%rsp), %r13
movl $0x1, %edi
movl $0x38, %esi
callq 0x2100
movl $0x1e, (%rax)
movq %rbp, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x8(%r13)
movq 0x18(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/tokenize.c
|
read_file
|
char *read_file(char *path) {
FILE *fp = fopen(path, "r");
if (!fp) {
error("cannot open %s: %s", path, strerror(errno));
}
// ファイルの最後の位置を調べてサイズ計算
if (fseek(fp, 0, SEEK_END) == -1) {
error("%s: fseek: %s", path, strerror(errno));
}
long file_size = ftell(fp);
// 読むために先頭に戻す
if (fseek(fp, 0, SEEK_SET) == -1) {
error("%s: fseek: %s", path, strerror(errno));
}
// \n\0で終わらせるための2バイト追加で確保
char *buf = calloc(1, file_size + 2);
fread(buf, file_size, 1, fp);
if (file_size == 0 || buf[file_size - 1] != '\n') {
buf[file_size++] = '\n';
}
buf[file_size] = '\0';
fclose(fp);
return buf;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2632(%rip), %rsi # 0xc2f2
callq 0x21a0
movq %rax, %rbx
testq %rax, %rax
jne 0x9ced
callq 0x2050
movl (%rax), %edi
callq 0x21f0
leaq 0x3195(%rip), %rdi # 0xce75
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4a3b
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2180
cmpl $-0x1, %eax
jne 0x9d21
callq 0x2050
movl (%rax), %edi
callq 0x21f0
leaq 0x3174(%rip), %rdi # 0xce88
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4a3b
movq %rbx, %rdi
callq 0x2130
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2180
cmpl $-0x1, %eax
jne 0x9d5d
callq 0x2050
movl (%rax), %edi
callq 0x21f0
leaq 0x3138(%rip), %rdi # 0xce88
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4a3b
leaq 0x2(%r15), %rsi
movl $0x1, %edi
callq 0x2100
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x2080
testq %r15, %r15
je 0x9d8e
cmpb $0xa, -0x1(%r14,%r15)
je 0x9d96
movb $0xa, (%r14,%r15)
incq %r15
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x2090
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/tokenize.c
|
struct_type
|
Type *struct_type(void) {
// 一旦サイズゼロ、アラインメント1バイトで作成
// 実際には構造体のメンバーのパース時に、メンバー中で一番大きいアラインメントで上書きされる。
Type *type = new_type(TY_STRUCT, 0, 1);
type->is_incomplete = true;
return type;
}
|
pushq %rax
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movl $0x9, (%rax)
movl $0x1, 0x8(%rax)
movb $0x1, 0xc(%rax)
popq %rcx
retq
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/type.c
|
add_type
|
void add_type(Node *node) {
if (!node || node->ty)
return;
assert(node);
add_type(node->lhs);
add_type(node->rhs);
add_type(node->cond);
add_type(node->then);
add_type(node->els);
add_type(node->init);
add_type(node->inc);
for (Node *n = node->body; n; n = n->next) {
add_type(n);
}
for (Node *n = node->arg; n; n = n->next) {
add_type(n);
}
#pragma clang diagnostic ignored "-Wswitch"
switch (node->kind) {
case ND_ADD:
case ND_SUB:
case ND_PTR_DIFF:
case ND_MUL:
case ND_DIV:
case ND_EQL:
case ND_NOT_EQL:
case ND_LT:
case ND_LTE:
case ND_BIT_AND:
case ND_BIT_OR:
case ND_BIT_XOR:
case ND_A_LSHIFT:
case ND_A_RSHIFT:
case ND_NUM:
node->ty = long_type;
return;
case ND_PTR_ADD:
case ND_PTR_SUB:
case ND_ASSIGN:
case ND_POST_INC:
case ND_POST_DEC:
case ND_PRE_INC:
case ND_PRE_DEC:
node->ty = node->lhs->ty;
return;
case ND_VAR:
node->ty = node->var->type;
return;
case ND_MEMBER:
node->ty = node->member->ty;
return;
case ND_TERNARY:
node->ty = node->then->ty;
return;
case ND_ADDR:
if (node->lhs->ty->kind == TY_ARRAY) {
node->ty = pointer_to(node->lhs->ty->ptr_to);
} else {
node->ty = pointer_to(node->lhs->ty);
}
return;
case ND_DEREF:
{
if (!node->lhs->ty->ptr_to) {
error_at(node->tok->str, "invalid pointer dereferrence");
}
Type *ty = node->lhs->ty->ptr_to;
if (ty->kind == TY_VOID) {
error_at(node->tok->str, "void *ポインタをデリファレンスできません");
}
if (ty->kind == TY_STRUCT && ty->is_incomplete) {
error_at(node->tok->str, "不完全な構造体のデリファレンスはできません");
}
node->ty = ty;
}
return;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9fa6
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x9fa6
movq 0x18(%rbx), %rdi
callq 0x9eef
movq 0x20(%rbx), %rdi
callq 0x9eef
movq 0x38(%rbx), %rdi
callq 0x9eef
movq 0x40(%rbx), %rdi
callq 0x9eef
movq 0x48(%rbx), %rdi
callq 0x9eef
movq 0x58(%rbx), %rdi
callq 0x9eef
movq 0x60(%rbx), %rdi
callq 0x9eef
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x9f61
movq %r14, %rdi
callq 0x9eef
movq 0x30(%r14), %r14
jmp 0x9f4e
movq 0x70(%rbx), %r14
testq %r14, %r14
je 0x9f78
movq %r14, %rdi
callq 0x9eef
movq 0x30(%r14), %r14
jmp 0x9f65
movl (%rbx), %eax
decl %eax
cmpl $0x2f, %eax
ja 0x9fa6
leaq 0x307c(%rip), %rcx # 0xd004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x6438(%rip), %r14 # 0x103d0
jmp 0x9fa2
movq 0x18(%rbx), %rax
movq 0x10(%rax), %r14
movq %r14, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
testq %r14, %r14
jne 0x9fdf
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x30f8(%rip), %rsi # 0xd0c4
xorl %eax, %eax
callq 0x487c
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %r14
movl (%r14), %eax
cmpl $0x1, %eax
jne 0xa000
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x30eb(%rip), %rsi # 0xd0e1
xorl %eax, %eax
callq 0x487c
movl (%r14), %eax
cmpl $0x9, %eax
jne 0x9fa2
cmpb $0x1, 0xc(%r14)
jne 0x9fa2
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x3100(%rip), %rsi # 0xd11b
xorl %eax, %eax
callq 0x487c
jmp 0x9fa2
movq 0x78(%rbx), %rax
movq (%rax), %r14
jmp 0x9fa2
movq 0x40(%rbx), %rax
jmp 0x9f9e
movq 0x98(%rbx), %rax
movq 0x8(%rax), %r14
jmp 0x9fa2
movq 0x18(%rbx), %rax
movq 0x10(%rax), %r15
cmpl $0x8, (%r15)
jne 0xa05e
movq 0x10(%r15), %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x2100
movq %rax, %r14
movabsq $0x800000007, %rax # imm = 0x800000007
movq %rax, (%r14)
movl $0x8, 0x8(%r14)
movq %r15, 0x10(%r14)
jmp 0x9fa2
nop
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/type.c
|
main
|
int main(int argc, char **argv) {
bool f_dump_ast = false;
bool f_dump_ast_only = false;
bool f_dump_tokens = false;
if (argc < 2) {
fprintf(stderr, "引数の個数が正しくありません\n");
return 1;
}
if (argc > 2) {
for (int i = 1; i < argc - 1; i++) {
if (strcmp(argv[i], "--ast") == 0) {
f_dump_ast = true;
}
if (strcmp(argv[i], "--ast-only") == 0) {
f_dump_ast = true;
f_dump_ast_only = true;
}
if (strcmp(argv[i], "--tokens") == 0) {
f_dump_tokens = true;
}
}
}
// プログラム全体を保存
filename = argv[argc - 1];
user_input = read_file(filename);
// head はfree用
Token *head = token = tokenize(user_input);
// fprintf(stderr, "-------------------------------- tokenized\n");
if (f_dump_tokens) {
printf("##-----------------------------\n");
printf("## tokens\n");
dump_tokens(head);
}
// パースする(結果は グローバル変数のfunctionsに入る)
Program *pgm = program();
if (f_dump_ast) {
printf("##-----------------------------\n");
printf("## ast\n");
dump_globals(pgm->global_var);
for (Function *f = pgm->functions; f; f = f->next) {
if (f_dump_ast) {
dump_function(f);
}
}
}
if (!f_dump_ast_only) {
codegen(pgm);
}
free_tokens(head);
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x1, %edi
jle 0xa1f4
cmpl $0x2, %edi
movq %rdi, (%rsp)
jne 0xa0bb
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r15d, %r15d
jmp 0xa132
leal -0x1(%rdi), %eax
movq %rax, 0x8(%rsp)
movl $0x1, %ebx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rsi, 0x10(%rsp)
movq (%rsi,%rbx,8), %rbp
movq %rbp, %rdi
leaq 0x30a3(%rip), %rsi # 0xd187
callq 0x2110
testl %eax, %eax
sete %r13b
movq %rbp, %rdi
leaq 0x3094(%rip), %rsi # 0xd18d
callq 0x2110
testl %eax, %eax
sete %al
orb %al, %r14b
orb %al, %r13b
orb %r13b, %r15b
movq %rbp, %rdi
leaq 0x3082(%rip), %rsi # 0xd198
callq 0x2110
movq 0x10(%rsp), %rsi
testl %eax, %eax
sete %al
orb %al, %r12b
incq %rbx
cmpq %rbx, 0x8(%rsp)
jne 0xa0d6
movl (%rsp), %eax
movq -0x8(%rsi,%rax,8), %rdi
movq %rdi, 0x632f(%rip) # 0x10470
callq 0x9cb1
movq %rax, 0x632b(%rip) # 0x10478
movq %rax, %rdi
callq 0x9765
movq %rax, %rbx
movq %rax, 0x6321(%rip) # 0x10480
testb $0x1, %r12b
je 0xa185
leaq 0x303f(%rip), %rdi # 0xd1ab
callq 0x2070
leaq 0x3029(%rip), %rdi # 0xd1a1
callq 0x2070
movq %rbx, %rdi
callq 0x485f
xorl %eax, %eax
callq 0x4be4
movq %rax, %r12
testb $0x1, %r15b
je 0xa1cd
leaq 0x300f(%rip), %rdi # 0xd1ab
callq 0x2070
leaq 0x3023(%rip), %rdi # 0xd1cb
callq 0x2070
movq (%r12), %rdi
callq 0x480a
movq 0x8(%r12), %r15
testq %r15, %r15
je 0xa1cd
movq %r15, %rdi
callq 0x47e7
movq (%r15), %r15
jmp 0xa1bb
testb $0x1, %r14b
jne 0xa1db
movq %r12, %rdi
callq 0x23dc
movq %rbx, %rdi
callq 0x9623
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x22c5
movl $0x1, %eax
jmp 0xa1e5
|
/workspace/github_c_makefile_star2_O3/pocari[P]compilerbook-9cc/ynicc.c
|
main
|
int main(int argc, char ** argv)
{
int major = 0;
int minor = 0;
int patch = 0;
parasail_result_t *result = NULL;
parasail_matrix_t *matrix = NULL;
parasail_profile_t *profile = NULL;
parasail_version(&major, &minor, &patch);
printf("parasail is using C lib version %d.%d.%d\n", major, minor, patch);
printf("\ntest1\n");
printf("result = parasail_sw(\"asdf\", 4, \"asdf\", 4, 10, 1, ¶sail_blosum62)\n");
result = parasail_sw("asdf", 4, "asdf", 4, 10, 1, ¶sail_blosum62);
if (result->score != 20) {
printf("failed\n");
return EXIT_FAILURE;
}
else {
printf("pass\n");
}
parasail_result_free(result);
printf("\ntest2\n");
printf("result = parasail_sw(\"asdf\", 4, \"asdf\", 4, 10, 1, ¶sail_pam50)\n");
result = parasail_sw("asdf", 4, "asdf", 4, 10, 1, ¶sail_pam50);
if (result->score != 27) {
printf("failed\n");
return EXIT_FAILURE;
}
else {
printf("pass\n");
}
parasail_result_free(result);
printf("\ntest3\n");
printf("matrix = parasail_matrix_create(\"acgt\", 1, -1)\n");
matrix = parasail_matrix_create("acgt", 1, -1);
printf("result = parasail_sw(\"acgt\", 4, \"acgt\", 4, 10, 1, matrix)\n");
result = parasail_sw("acgt", 4, "acgt", 4, 10, 1, matrix);
if (result->score != 4) {
printf("failed\n");
return EXIT_FAILURE;
}
else {
printf("pass\n");
}
parasail_result_free(result);
parasail_matrix_free(matrix);
/* if no vector ISA detected at build-time and/or run-time, this will fail */
printf("\ntest4\n");
printf("profile = parasail_profile_create_8(\"asdf\", 4, ¶sail_blosum62)\n");
profile = parasail_profile_create_8("asdf", 4, ¶sail_blosum62);
if (!profile) {
printf("NULL profile returned; vector ISA not supported\n");
printf("pass\n");
}
else {
printf("result = parasail_sw_striped_profile_8(profile, \"asdf\", 4, 10, 1)\n");
result = parasail_sw_striped_profile_8(profile, "asdf", 4, 10, 1);
if (!result) {
printf("NULL result returned; vector ISA not supported\n");
printf("pass\n");
}
else {
if (result->score != 20) {
printf("failed\n");
return EXIT_FAILURE;
}
else {
printf("pass\n");
}
parasail_result_free(result);
}
}
return 0;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorl %eax, %eax
leaq 0x1c(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x18(%rsp), %r14
movl %eax, (%r14)
leaq 0x14(%rsp), %r15
movl %eax, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32eff
movl (%rbx), %esi
movl (%r14), %edx
movl (%r15), %ecx
leaq 0xe8f19(%rip), %rdi # 0x11b004
xorl %eax, %eax
callq 0x13030
leaq 0xe8f67(%rip), %rdi # 0x11b060
callq 0x13060
leaq 0xe8f62(%rip), %rdi # 0x11b067
callq 0x13060
leaq 0x116c2f(%rip), %rax # 0x148d40
movq %rax, (%rsp)
leaq 0xe8f12(%rip), %rdi # 0x11b02e
movl $0x1, %ebx
movl $0x4, %esi
movq %rdi, %rdx
movl $0x4, %ecx
movl $0xa, %r8d
movl $0x1, %r9d
callq 0x391c0
cmpl $0x14, (%rax)
jne 0x322e4
movq %rax, %r14
leaq 0xe9100(%rip), %rdi # 0x11b252
callq 0x13060
movq %r14, %rdi
callq 0x32d38
leaq 0xe8f47(%rip), %rdi # 0x11b0ad
callq 0x13060
leaq 0xe8f42(%rip), %rdi # 0x11b0b4
callq 0x13060
leaq 0x116c0a(%rip), %rax # 0x148d88
movq %rax, (%rsp)
leaq 0xe8ea5(%rip), %rdi # 0x11b02e
movl $0x1, %ebx
movl $0x4, %esi
movq %rdi, %rdx
movl $0x4, %ecx
movl $0xa, %r8d
movl $0x1, %r9d
callq 0x391c0
cmpl $0x1b, (%rax)
jne 0x322e4
movq %rax, %r14
leaq 0xe9093(%rip), %rdi # 0x11b252
callq 0x13060
movq %r14, %rdi
callq 0x32d38
leaq 0xe8f24(%rip), %rdi # 0x11b0f7
callq 0x13060
leaq 0xe8f1f(%rip), %rdi # 0x11b0fe
callq 0x13060
leaq 0xe8e48(%rip), %r15 # 0x11b033
movl $0x1, %ebx
movq %r15, %rdi
movl $0x1, %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x32f12
movq %rax, %r14
leaq 0xe8f21(%rip), %rdi # 0x11b12d
callq 0x13060
movq %r14, (%rsp)
movq %r15, %rdi
movl $0x4, %esi
movq %r15, %rdx
movl $0x4, %ecx
movl $0xa, %r8d
movl $0x1, %r9d
callq 0x391c0
cmpl $0x4, (%rax)
jne 0x322e4
movq %rax, %r15
leaq 0xe9009(%rip), %rdi # 0x11b252
callq 0x13060
movq %r15, %rdi
callq 0x32d38
movq %r14, %rdi
callq 0x338de
leaq 0xe8f02(%rip), %rdi # 0x11b167
callq 0x13060
leaq 0xe8efd(%rip), %rdi # 0x11b16e
callq 0x13060
leaq 0xe8db1(%rip), %rdi # 0x11b02e
leaq 0x116abc(%rip), %rdx # 0x148d40
movl $0x4, %esi
callq 0x3917f
testq %rax, %rax
je 0x322fc
movq %rax, %rbx
leaq 0xe8f44(%rip), %rdi # 0x11b1e1
callq 0x13060
leaq 0xe8d85(%rip), %rsi # 0x11b02e
movq %rbx, %rdi
movl $0x4, %edx
movl $0xa, %ecx
movl $0x1, %r8d
callq 0x38b5f
testq %rax, %rax
je 0x32305
movq %rax, %rbx
cmpl $0x14, (%rax)
jne 0x32321
leaq 0xe8f7d(%rip), %rdi # 0x11b252
callq 0x13060
movq %rbx, %rdi
callq 0x32d38
jmp 0x3231d
leaq 0xe8f6c(%rip), %rdi # 0x11b257
callq 0x13060
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe8eae(%rip), %rdi # 0x11b1b1
jmp 0x3230c
leaq 0xe8f17(%rip), %rdi # 0x11b223
callq 0x13060
leaq 0xe8f3a(%rip), %rdi # 0x11b252
callq 0x13060
xorl %ebx, %ebx
jmp 0x322f0
leaq 0xe8f2f(%rip), %rdi # 0x11b257
callq 0x13060
movl $0x1, %ebx
jmp 0x322f0
|
/workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/tests/test_basic.c
|
stick_self_to_core
|
int
stick_self_to_core(int cpu)
{
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpu, &cpuset);
return sched_setaffinity(0, sizeof(cpuset), &cpuset);
}
|
subq $0x88, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %edi # imm = 0x3FF
ja 0x1948
movl $0x1, %eax
movl %edi, %ecx
shlq %cl, %rax
shrl $0x6, %edi
orq %rax, (%rsp,%rdi,8)
movq %rsp, %rdx
movl $0x80, %esi
xorl %edi, %edi
callq 0x10b0
addq $0x88, %rsp
retq
|
/workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/context-switches.c
|
thread_handler
|
void*
thread_handler(void* arg)
{
(void)arg;
int num_cores = sysconf(_SC_NPROCESSORS_ONLN);
while (1) {
int r = rand() % num_cores;
int ndx = 0;
while (++ndx < num_cores) {
int n = 1000;
_STRESS_MUST((stick_self_to_core(r) != -1),
"couldn't stick thread to cpu %d",
ndx);
while (n-- > 0) {
printf("Thread %lu is running on CPU %3d\n",
(unsigned long)pthread_self(),
sched_getcpu());
}
}
}
return NULL;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x54, %edi
callq 0x1130
movq %rax, %r14
leaq 0x7c1(%rip), %r15 # 0x213f
callq 0x11b0
cltd
idivl %r14d
cmpl $0x2, %r14d
jl 0x197e
movl %edx, %ebp
movl $0x1, %ebx
movl %ebp, %edi
callq 0x18fe
cmpl $-0x1, %eax
je 0x19d4
movl $0x3e9, %r13d # imm = 0x3E9
callq 0x1120
movq %rax, %r12
callq 0x1150
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x1090
decl %r13d
cmpl $0x1, %r13d
ja 0x19ae
incl %ebx
cmpl %r14d, %ebx
jne 0x1994
jmp 0x197e
movq 0x261d(%rip), %r14 # 0x3ff8
movq (%r14), %rcx
leaq 0x63b(%rip), %rdi # 0x2020
movl $0x9, %esi
movl $0x1, %edx
callq 0x1180
movq (%r14), %rcx
leaq 0x628(%rip), %rdi # 0x2026
movl $0x3, %esi
movl $0x1, %edx
callq 0x1180
movq (%r14), %rdi
leaq 0x6f1(%rip), %rsi # 0x2108
movl %ebx, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r14), %rcx
leaq 0x623(%rip), %rdi # 0x204d
movl $0x2, %esi
movl $0x1, %edx
callq 0x1180
movq (%r14), %rdi
leaq 0x60d(%rip), %rsi # 0x2050
leaq 0x6de(%rip), %rdx # 0x2128
xorl %eax, %eax
callq 0x10f0
movq (%r14), %rdi
leaq 0x611(%rip), %rsi # 0x206c
movl $0x27, %edx
xorl %eax, %eax
callq 0x10f0
movq (%r14), %rsi
movl $0xa, %edi
callq 0x10c0
movq (%r14), %rcx
leaq 0x5fb(%rip), %rdi # 0x2079
movl $0xa, %esi
movl $0x1, %edx
callq 0x1180
movl $0x1, %edi
callq 0x1170
|
/workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/context-switches.c
|
main
|
int
main()
{
pthread_t threads[NTHREADS];
srand(time(NULL));
for (int i = 0; i < NTHREADS; i++) {
_STRESS_MUST(
(!pthread_create(&threads[i], NULL, &thread_handler, NULL)),
"Unexpected error creating thread %d",
i);
}
for (int i = 0; i < NTHREADS; i++) {
_STRESS_MUST((!pthread_join(threads[i], NULL)),
"Unexpected error waiting for thread %d",
i);
}
return 0;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10e0
movq %rsp, %r14
leaq -0x15e(%rip), %r15 # 0x195f
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x1110
testl %eax, %eax
jne 0x1b06
incq %rbx
addq $0x8, %r14
cmpq $0x32, %rbx
jne 0x1abd
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1190
testl %eax, %eax
jne 0x1b0e
incq %rbx
cmpq $0x32, %rbx
jne 0x1adf
xorl %eax, %eax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x140c
movq %rbx, %rdi
callq 0x14c5
|
/workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/context-switches.c
|
LZ4_compress_fast_extState
|
int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
{
LZ4_stream_t_internal* ctx = &((LZ4_stream_t*)state)->internal_donotuse;
LZ4_resetStream((LZ4_stream_t*)state);
if (acceleration < 1) acceleration = ACCELERATION_DEFAULT;
if (maxOutputSize >= LZ4_compressBound(inputSize)) {
if (inputSize < LZ4_64Klimit)
return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
else
return LZ4_compress_generic(ctx, source, dest, inputSize, 0, notLimited, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
} else {
if (inputSize < LZ4_64Klimit)
return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
else
return LZ4_compress_generic(ctx, source, dest, inputSize, maxOutputSize, limitedOutput, (sizeof(void*)==8) ? byU32 : byPtr, noDict, noDictIssue, acceleration);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %r15d
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, 0x30(%rsp)
xorl %ebx, %ebx
movl $0x4020, %edx # imm = 0x4020
movq %rdi, 0x38(%rsp)
xorl %esi, %esi
callq 0x62d0
cmpl $0x2, %r15d
pushq $0x1
popq %rax
cmovll %eax, %r15d
cmpl $0x7e000000, %r13d # imm = 0x7E000000
ja 0x6bd6
movl $0xff, %ecx
movl %r13d, %eax
xorl %edx, %edx
divl %ecx
leal (%rax,%r13), %ebx
addl $0x10, %ebx
movl %r13d, %eax
movslq %r13d, %rdx
cmpl %ebp, %ebx
jle 0x6fcb
movslq %ebp, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rsp)
cmpl $0x1000a, %r13d # imm = 0x1000A
movq 0x30(%rsp), %r9
movq 0x38(%rsp), %rbx
jg 0x700f
cmpl $0x7e000000, %r13d # imm = 0x7E000000
ja 0x7401
movl %ebp, 0x64(%rsp)
movq %r14, %rsi
movq %r9, %r14
movq %rsi, %r12
cmpl $0xd, %r13d
jb 0x7aae
leaq (%r9,%rdx), %r10
addq $-0xc, %r10
movq %rdx, 0x68(%rsp)
leaq (%r9,%rdx), %rax
addq $-0x5, %rax
movq %rax, 0x50(%rsp)
imull $0x9e3779b1, (%r9), %eax # imm = 0x9E3779B1
shrl $0x13, %eax
andw $0x0, (%rbx,%rax,2)
shll $0x6, %r15d
pushq $0x1
popq %rcx
movq %rsi, 0x28(%rsp)
movq %rsi, %r12
movq %r9, %r14
movq %r10, 0x48(%rsp)
movl %r15d, 0x14(%rsp)
leaq 0x1(%r14), %rax
movl 0x1(%r14), %edx
movl %ecx, %esi
movl %r15d, %ecx
movq %rax, %rbp
movl %esi, %eax
addq %rbp, %rax
cmpq %r10, %rax
ja 0x7aa4
movl %ecx, %esi
shrl $0x6, %esi
incl %ecx
imull $0x9e3779b1, %edx, %edi # imm = 0x9E3779B1
shrl $0x13, %edi
movzwl (%rbx,%rdi,2), %r13d
movl (%rax), %edx
movl %ebp, %r8d
subl %r9d, %r8d
movw %r8w, (%rbx,%rdi,2)
movl (%r9,%r13), %edi
cmpl (%rbp), %edi
jne 0x6c7c
movq %r12, 0x20(%rsp)
leaq (%r9,%r13), %r10
movl %ebp, %eax
subl %r14d, %eax
leal -0xf(%rax), %edx
movq %rax, 0x18(%rsp)
addl $0xfffffef2, %eax # imm = 0xFFFFFEF2
movl %eax, 0x60(%rsp)
movl %ebp, %eax
shlb $0x4, %al
movl %r14d, %ecx
shlb $0x4, %cl
subb %cl, %al
xorl %ecx, %ecx
movl %edx, 0x58(%rsp)
movl %edx, %ebx
movq %rcx, %r12
movl %eax, %r8d
leaq (%r10,%rcx), %rax
leaq (%rcx,%rbp), %r15
cmpq %r9, %rax
jbe 0x6d1c
cmpq %r14, %r15
jbe 0x6d1c
movb -0x1(%rbp,%r12), %dil
leal -0x1(%rbx), %edx
leaq -0x1(%r12), %rcx
leal -0x10(%r8), %eax
cmpb -0x1(%r10,%r12), %dil
je 0x6cea
movq %r10, 0x40(%rsp)
movl %ebp, %eax
subl %r14d, %eax
leal (%r12,%rax), %r11d
movq 0x18(%rsp), %rax
leaq (%rax,%r12), %rcx
movq 0x20(%rsp), %rax
movq %rax, %rsi
leaq (%rax,%r11), %rdi
incq %rdi
movl %ecx, %eax
xorl %edx, %edx
movl $0xff, %r10d
divl %r10d
addq %rdi, %rax
addq $0x8, %rax
cmpq 0x8(%rsp), %rax
ja 0x7401
movq %rsi, %rdx
leaq 0x1(%rsi), %rdi
cmpl $0xf, %ecx
jb 0x6e0f
movl 0x58(%rsp), %eax
addq %r12, %rax
movb $-0x10, (%rdx)
cmpl $0xfe, %eax
jle 0x6dfe
movq 0x18(%rsp), %rsi
addl $0xef, %esi
movq %rsi, 0x18(%rsp)
movl $0x1fd, %eax # imm = 0x1FD
cmpl %eax, %ebx
movl $0x1fd, %ecx # imm = 0x1FD
cmovbl %ebx, %ecx
cmovgel %eax, %ebx
movl %esi, %eax
subl %ecx, %eax
addl %r12d, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
leal 0x1(%rax), %edx
movl $0xff, %esi
movq %r11, 0x58(%rsp)
callq 0x62d0
movq 0x58(%rsp), %r11
movq 0x30(%rsp), %r9
movq 0x18(%rsp), %rax
subl %ebx, %eax
addl %r12d, %eax
movq %rax, %rcx
xorl %edx, %edx
movl $0xff, %esi
divl %esi
subl %ecx, %edx
movq 0x20(%rsp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x2, %rdi
movl 0x60(%rsp), %eax
addl %r12d, %eax
addl %edx, %eax
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rdx
movb %al, (%rdi)
incq %rdi
jmp 0x6e1c
movb %r8b, (%rdx)
movq 0x38(%rsp), %rbx
movq 0x40(%rsp), %rdx
addq %rdi, %r11
movq (%r14), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %r14
cmpq %r11, %rdi
jb 0x6e1f
addl %r9d, %r13d
movl %r15d, %ecx
subl %r12d, %ecx
subl %r13d, %ecx
movw %cx, (%r11)
leaq (%r12,%rbp), %rdi
addq $0x4, %rdi
leaq (%rdx,%r12), %rsi
addq $0x4, %rsi
movq 0x50(%rsp), %rdx
movq %r11, %r14
callq 0x2e3a5
movl %eax, %ecx
shrl $0x8, %ecx
addq %r14, %rcx
addq $0x8, %rcx
cmpq 0x8(%rsp), %rcx
ja 0x7401
movq %r14, %r8
movl %eax, %ecx
addl $0x4, %ecx
addq %rcx, %r15
movq %r15, %r14
movl 0x14(%rsp), %r13d
xorl %ebp, %ebp
movq 0x20(%rsp), %r12
movl %r13d, %r15d
leaq 0x2(%r8), %rcx
movb (%r12), %dl
cmpl $0xf, %eax
jb 0x6f10
addb $0xf, %dl
movb %dl, (%r12)
leal -0xf(%rax), %ebp
orl $-0x1, (%rcx)
cmpl $0x3fc, %ebp # imm = 0x3FC
jb 0x6eed
addl $0xfffffbf5, %eax # imm = 0xFFFFFBF5
xorl %edx, %edx
movl $0x3fc, %ecx # imm = 0x3FC
divl %ecx
movl %eax, %r12d
movl %edx, %ebp
leaq 0x6(%r8), %rdi
shll $0x2, %r12d
leaq 0x4(%r12), %rdx
movl $0xff, %esi
movq %r8, %r15
callq 0x62d0
leaq (%r15,%r12), %rcx
addq $0x6, %rcx
movl %r13d, %r15d
movl %ebp, %eax
xorl %edx, %edx
movw $0xff, %si
divw %si
movzwl %ax, %eax
leaq (%rcx,%rax), %r12
incq %r12
movb %dl, -0x1(%r12)
movq 0x30(%rsp), %r9
xorl %ebp, %ebp
jmp 0x6f1e
addb %al, %dl
movb %dl, (%r12)
movq %rcx, %r12
movq 0x30(%rsp), %r9
movq 0x48(%rsp), %r10
cmpq %r10, %r14
ja 0x7aa4
leaq -0x2(%r14), %rax
imull $0x9e3779b1, -0x2(%r14), %ecx # imm = 0x9E3779B1
subl %r9d, %eax
shrl $0x13, %ecx
movw %ax, (%rbx,%rcx,2)
imull $0x9e3779b1, (%r14), %eax # imm = 0x9E3779B1
shrl $0x13, %eax
movzwl (%rbx,%rax,2), %ecx
leaq (%r9,%rcx), %rsi
movl %r14d, %edx
subl %r9d, %edx
movw %dx, (%rbx,%rax,2)
leaq (%r9,%rcx), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r14, %rax
jb 0x6fc3
movl (%rsi), %eax
cmpl (%r14), %eax
jne 0x6fc3
leaq 0x1(%r12), %r15
movb $0x0, (%r12)
movl %r14d, %eax
subl %esi, %eax
movw %ax, 0x1(%r12)
leaq 0x4(%r14), %rdi
addq $0x4, %rsi
movq 0x50(%rsp), %rdx
callq 0x2e3a5
movq %r15, %r8
movl %r13d, %r15d
leal 0x4(%rax), %ecx
addq %rcx, %r14
movl %eax, %ecx
shrl $0x8, %ecx
addq %r12, %rcx
addq $0x9, %rcx
cmpq 0x8(%rsp), %rcx
jbe 0x6e93
jmp 0x7403
pushq $0x1
popq %rcx
jmp 0x6c6f
cmpl $0x1000a, %r13d # imm = 0x1000A
movq 0x30(%rsp), %r11
movq 0x38(%rsp), %rbx
jg 0x73f8
cmpl $0x7e000000, %r13d # imm = 0x7E000000
ja 0x7401
leaq (%r11,%rdx), %rax
movq %rax, 0x20(%rsp)
cmpl $0xd, %r13d
jae 0x77a8
movq %r14, 0x8(%rsp)
movq %r11, %rbp
jmp 0x7b63
cmpl $0x7e000000, %r13d # imm = 0x7E000000
ja 0x7401
movl %ebp, 0x64(%rsp)
leaq (%r9,%rax), %rcx
movq %rcx, 0x70(%rsp)
leaq (%r9,%rax), %r10
addq $-0xc, %r10
movq (%r9), %rcx
movabsq $-0x30e4432345000000, %rdx # imm = 0xCF1BBCDCBB000000
imulq %rdx, %rcx
shrq $0x34, %rcx
andl $0x0, (%rbx,%rcx,4)
addq %r9, %rax
addq $-0x5, %rax
movq %rax, 0x50(%rsp)
movl %r15d, %edi
shll $0x6, %edi
incl %edi
andl $0x3ffffff, %r15d # imm = 0x3FFFFFF
movl %r15d, 0x14(%rsp)
leaq 0x2(%r9), %rax
movq %r14, %r12
movq %r9, %r14
movq %r12, 0x28(%rsp)
movq %r10, 0x48(%rsp)
movl %edi, 0x68(%rsp)
movq %r12, 0x20(%rsp)
leaq 0x1(%r14), %rbp
movq 0x1(%r14), %rdx
movl 0x14(%rsp), %esi
movl %edi, %ecx
movq %rax, %rdi
movabsq $-0x30e4432345000000, %rax # imm = 0xCF1BBCDCBB000000
imulq %rax, %rdx
movq %rdx, %rax
shrq $0x34, %rax
movl (%rbx,%rax,4), %r13d
movq (%rdi), %rdx
movl %ebp, %r8d
subl %r9d, %r8d
movl %r8d, (%rbx,%rax,4)
leaq (%r9,%r13), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %rbp, %rax
jb 0x70da
leaq (%r9,%r13), %r12
movl (%r12), %eax
cmpl (%rbp), %eax
je 0x70f8
movl %esi, %eax
addq %rdi, %rax
leal 0x1(%rcx), %r8d
shrl $0x6, %ecx
movl %ecx, %esi
movl %r8d, %ecx
movq %rdi, %rbp
cmpq %r10, %rax
jbe 0x7095
jmp 0x7c25
movl %ebp, %eax
subl %r14d, %eax
leal -0xf(%rax), %edx
movq %rax, 0x18(%rsp)
addl $0xfffffef2, %eax # imm = 0xFFFFFEF2
movl %eax, 0x60(%rsp)
movl %ebp, %eax
shlb $0x4, %al
movl %r14d, %ecx
shlb $0x4, %cl
subb %cl, %al
xorl %ecx, %ecx
movl %edx, 0x58(%rsp)
movl %edx, %r15d
movq %rcx, %rbx
movl %eax, %r8d
leaq (%r12,%rcx), %rax
leaq (%rcx,%rbp), %r10
cmpq %r9, %rax
jbe 0x7154
cmpq %r14, %r10
jbe 0x7154
movb -0x1(%rbp,%rbx), %dil
leal -0x1(%r15), %edx
leaq -0x1(%rbx), %rcx
leal -0x10(%r8), %eax
cmpb -0x1(%r12,%rbx), %dil
je 0x7121
movq %r10, 0x40(%rsp)
movl %ebp, %eax
subl %r14d, %eax
leal (%rbx,%rax), %r11d
movq 0x18(%rsp), %rax
leaq (%rax,%rbx), %rcx
movq 0x20(%rsp), %rax
movq %rax, %rsi
leaq (%rax,%r11), %rdi
incq %rdi
movl %ecx, %eax
xorl %edx, %edx
movl $0xff, %r10d
divl %r10d
addq %rdi, %rax
addq $0x8, %rax
cmpq 0x8(%rsp), %rax
ja 0x7401
movq %rsi, %rdx
leaq 0x1(%rsi), %rdi
cmpl $0xf, %ecx
jb 0x7243
movl 0x58(%rsp), %eax
addq %rbx, %rax
movb $-0x10, (%rdx)
cmpl $0xfe, %eax
jle 0x7237
movq 0x18(%rsp), %rsi
addl $0xef, %esi
movq %rsi, 0x18(%rsp)
movl $0x1fd, %eax # imm = 0x1FD
cmpl %eax, %r15d
movl $0x1fd, %ecx # imm = 0x1FD
cmovbl %r15d, %ecx
cmovgel %eax, %r15d
movl %esi, %eax
subl %ecx, %eax
addl %ebx, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
leal 0x1(%rax), %edx
movl $0xff, %esi
movq %r11, 0x58(%rsp)
callq 0x62d0
movq 0x58(%rsp), %r11
movq 0x30(%rsp), %r9
movq 0x18(%rsp), %rax
subl %r15d, %eax
addl %ebx, %eax
movq %rax, %rcx
xorl %edx, %edx
movl $0xff, %esi
divl %esi
subl %ecx, %edx
movq 0x20(%rsp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x2, %rdi
movl 0x60(%rsp), %eax
addl %ebx, %eax
addl %edx, %eax
movq 0x40(%rsp), %r8
movb %al, (%rdi)
incq %rdi
jmp 0x724b
movb %r8b, (%rdx)
movq 0x40(%rsp), %r8
addq %rdi, %r11
movq (%r14), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %r14
cmpq %r11, %rdi
jb 0x724e
addl %r9d, %r13d
movl %r8d, %ecx
subl %ebx, %ecx
subl %r13d, %ecx
movw %cx, (%r11)
leaq (%rbx,%rbp), %rdi
addq $0x4, %rdi
leaq 0x4(%rbx,%r12), %rsi
movq 0x50(%rsp), %rdx
movq %r11, %r15
movq %r8, %r14
callq 0x2e3a5
movl %eax, %ecx
shrl $0x8, %ecx
addq %r15, %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %r13
cmpq %r13, %rcx
ja 0x7401
movl %eax, %ecx
addl $0x4, %ecx
addq %rcx, %r14
movq 0x38(%rsp), %rbx
xorl %ebp, %ebp
movq 0x20(%rsp), %r12
leaq 0x2(%r15), %rcx
movb (%r12), %dl
cmpl $0xf, %eax
jb 0x7332
addb $0xf, %dl
movb %dl, (%r12)
leal -0xf(%rax), %ebp
orl $-0x1, (%rcx)
cmpl $0x3fc, %ebp # imm = 0x3FC
jb 0x730f
addl $0xfffffbf5, %eax # imm = 0xFFFFFBF5
xorl %edx, %edx
movl $0x3fc, %ecx # imm = 0x3FC
divl %ecx
movl %eax, %r12d
movl %edx, %ebp
leaq 0x6(%r15), %rdi
shll $0x2, %r12d
leaq 0x4(%r12), %rdx
movl $0xff, %esi
callq 0x62d0
leaq (%r15,%r12), %rcx
addq $0x6, %rcx
movl %ebp, %eax
xorl %edx, %edx
movw $0xff, %si
divw %si
movzwl %ax, %eax
leaq (%rcx,%rax), %r12
incq %r12
movb %dl, -0x1(%r12)
movq 0x30(%rsp), %r9
xorl %ebp, %ebp
jmp 0x7340
addb %al, %dl
movb %dl, (%r12)
movq %rcx, %r12
movq 0x30(%rsp), %r9
movq 0x48(%rsp), %r10
cmpq %r10, %r14
ja 0x7c2a
leaq -0x2(%r14), %rax
movq -0x2(%r14), %rcx
movabsq $-0x30e4432345000000, %rdx # imm = 0xCF1BBCDCBB000000
imulq %rdx, %rcx
shrq $0x34, %rcx
subl %r9d, %eax
movl %eax, (%rbx,%rcx,4)
movq (%r14), %rax
imulq %rdx, %rax
shrq $0x34, %rax
movl (%rbx,%rax,4), %esi
movl %r14d, %ecx
subl %r9d, %ecx
movl %ecx, (%rbx,%rax,4)
leaq (%r9,%rsi), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r14, %rax
jb 0x73e2
addq %r9, %rsi
movl (%rsi), %eax
cmpl (%r14), %eax
jne 0x73e2
leaq 0x1(%r12), %r15
movb $0x0, (%r12)
movl %r14d, %eax
subl %esi, %eax
movw %ax, 0x1(%r12)
leaq 0x4(%r14), %rdi
addq $0x4, %rsi
movq 0x50(%rsp), %rdx
callq 0x2e3a5
leal 0x4(%rax), %ecx
addq %rcx, %r14
movl %eax, %ecx
shrl $0x8, %ecx
addq %r12, %rcx
addq $0x9, %rcx
cmpq %r13, %rcx
jbe 0x72bb
jmp 0x7403
leaq 0x2(%r14), %rax
cmpq %r10, %rax
movl 0x68(%rsp), %edi
jbe 0x7082
jmp 0x7c2a
cmpl $0x7e000000, %r13d # imm = 0x7E000000
jbe 0x7414
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%r11,%rax), %rcx
movq %rcx, 0x40(%rsp)
leaq (%r11,%rax), %r13
addq $-0xc, %r13
movq (%r11), %rcx
movabsq $-0x30e4432345000000, %rdx # imm = 0xCF1BBCDCBB000000
imulq %rdx, %rcx
shrq $0x34, %rcx
andl $0x0, (%rbx,%rcx,4)
addq %r11, %rax
addq $-0x5, %rax
movq %rax, 0x48(%rsp)
movl %r15d, %edx
shll $0x6, %edx
incl %edx
andl $0x3ffffff, %r15d # imm = 0x3FFFFFF
leaq 0x2(%r11), %rcx
movq %r11, %r12
movq %r14, %rbp
movq %r14, 0x28(%rsp)
movl %r15d, 0x14(%rsp)
movq %r13, 0x50(%rsp)
movl %edx, 0x18(%rsp)
leaq 0x1(%r12), %rax
movq 0x1(%r12), %rsi
movl %r15d, %edi
movq %rcx, %r8
movabsq $-0x30e4432345000000, %rcx # imm = 0xCF1BBCDCBB000000
imulq %rcx, %rsi
movq %rsi, %r9
shrq $0x34, %r9
movl (%rbx,%r9,4), %ecx
movq (%r8), %rsi
movl %eax, %r10d
subl %r11d, %r10d
movl %r10d, (%rbx,%r9,4)
leaq (%r11,%rcx), %r9
addq $0xffff, %r9 # imm = 0xFFFF
cmpq %rax, %r9
jb 0x74c7
addq %r11, %rcx
movl (%rcx), %r9d
cmpl (%rax), %r9d
je 0x74e3
movl %edi, %ecx
addq %r8, %rcx
leal 0x1(%rdx), %eax
shrl $0x6, %edx
movl %edx, %edi
movl %eax, %edx
movq %r8, %rax
cmpq %r13, %rcx
jbe 0x7483
jmp 0x773e
movq %rbp, 0x8(%rsp)
movl %eax, %ebp
subl %r12d, %ebp
leal -0xf(%rbp), %edx
leal -0x10e(%rbp), %esi
movl %esi, 0x20(%rsp)
movl %eax, %edi
shlb $0x4, %dil
movl %r12d, %esi
shlb $0x4, %sil
subb %sil, %dil
xorl %r8d, %r8d
movl %edx, %r9d
movl %r9d, %r15d
movq %r8, %r13
movl %edi, %esi
leaq (%rcx,%r8), %r14
leaq (%rax,%r8), %rbx
cmpq %r11, %r14
jbe 0x7541
cmpq %r12, %rbx
jbe 0x7541
movb -0x1(%rax,%r13), %r10b
leal -0x1(%r15), %r9d
leaq -0x1(%r13), %r8
leal -0x10(%rsi), %edi
cmpb -0x1(%rcx,%r13), %r10b
je 0x7510
leal (%rbp,%r13), %eax
movq 0x8(%rsp), %rcx
leaq 0x1(%rcx), %rdi
cmpl $0xf, %eax
jb 0x75ce
movl %edx, %eax
addq %r13, %rax
movb $-0x10, (%rcx)
cmpl $0xfe, %eax
jle 0x75c4
addl $0xef, %ebp
movl $0x1fd, %eax # imm = 0x1FD
cmpl %eax, %r15d
movl $0x1fd, %ecx # imm = 0x1FD
cmovbl %r15d, %ecx
cmovgel %eax, %r15d
movl %ebp, %eax
subl %ecx, %eax
addl %r13d, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
leal 0x1(%rax), %edx
movl $0xff, %esi
callq 0x62d0
subl %r15d, %ebp
addl %r13d, %ebp
movl %ebp, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
subl %ebp, %edx
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x2, %rdi
movl 0x20(%rsp), %eax
addl %r13d, %eax
addl %edx, %eax
movq %rcx, %r13
movb %al, (%rdi)
incq %rdi
jmp 0x75d4
movb %sil, (%rcx)
movq %rcx, %r13
movq %rbx, %rax
subq %r12, %rax
movl %eax, %r15d
addq %rdi, %r15
movq (%r12), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %r12
cmpq %r15, %rdi
jb 0x75e0
movq %rbx, %r12
movq 0x38(%rsp), %rbx
movl %r12d, %eax
subl %r14d, %eax
movw %ax, (%r15)
leaq 0x2(%r15), %rbp
leaq 0x4(%r12), %rdi
addq $0x4, %r14
movq %r14, %rsi
movq 0x48(%rsp), %rdx
callq 0x2e3a5
movl %eax, %r14d
movb (%r13), %al
cmpl $0xf, %r14d
jb 0x7694
addb $0xf, %al
movb %al, (%r13)
movq %rbp, %rcx
leal -0xf(%r14), %ebp
orl $-0x1, (%rcx)
cmpl $0x3fc, %ebp # imm = 0x3FC
jb 0x7678
leal -0x40b(%r14), %eax
xorl %edx, %edx
movl $0x3fc, %ecx # imm = 0x3FC
divl %ecx
movl %eax, %r13d
movl %edx, %ebp
leaq 0x6(%r15), %rdi
shll $0x2, %r13d
leaq 0x4(%r13), %rdx
movl $0xff, %esi
callq 0x62d0
leaq (%r15,%r13), %rcx
addq $0x6, %rcx
movl %ebp, %eax
xorl %edx, %edx
movw $0xff, %si
divw %si
movzwl %ax, %eax
addq %rax, %rcx
incq %rcx
movb %dl, -0x1(%rcx)
movq %rcx, %rbp
jmp 0x769b
addb %r14b, %al
movb %al, (%r13)
addl $0x4, %r14d
addq %r14, %r12
movq 0x50(%rsp), %r13
cmpq %r13, %r12
movq 0x30(%rsp), %r11
ja 0x7739
leaq -0x2(%r12), %rax
movq -0x2(%r12), %rcx
movabsq $-0x30e4432345000000, %rdx # imm = 0xCF1BBCDCBB000000
imulq %rdx, %rcx
shrq $0x34, %rcx
subl %r11d, %eax
movl %eax, (%rbx,%rcx,4)
movq (%r12), %rax
imulq %rdx, %rax
shrq $0x34, %rax
movl (%rbx,%rax,4), %r14d
movl %r12d, %ecx
subl %r11d, %ecx
movl %ecx, (%rbx,%rax,4)
leaq (%r11,%r14), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r12, %rax
jb 0x771b
addq %r11, %r14
movl (%r14), %eax
cmpl (%r12), %eax
jne 0x771b
leaq 0x1(%rbp), %r15
movb $0x0, (%rbp)
movq %rbp, %r13
jmp 0x75fc
leaq 0x2(%r12), %rcx
cmpq %r13, %rcx
movq 0x28(%rsp), %r14
movl 0x14(%rsp), %r15d
movl 0x18(%rsp), %edx
jbe 0x7476
jmp 0x773e
movq 0x28(%rsp), %r14
movq 0x40(%rsp), %r15
subq %r12, %r15
cmpq $0xf, %r15
jb 0x7a7f
leaq -0xf(%r15), %rax
movb $-0x10, (%rbp)
leaq 0x1(%rbp), %rdi
cmpq $0xff, %rax
jb 0x779e
leaq -0x10e(%r15), %rax
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
leaq 0x1(%rax), %rdx
movl $0xff, %esi
callq 0x62d0
imulq $-0xff, %rbx, %rax
addq %r15, %rax
addq $-0x10e, %rax # imm = 0xFEF2
leaq (%rbx,%rbp), %rdi
addq $0x2, %rdi
movb %al, (%rdi)
movq %rdi, %rbp
jmp 0x7a88
leaq (%r11,%rdx), %r12
addq $-0xc, %r12
imull $0x9e3779b1, (%r11), %eax # imm = 0x9E3779B1
shrl $0x13, %eax
andw $0x0, (%rbx,%rax,2)
leaq (%r11,%rdx), %rax
addq $-0x5, %rax
movq %rax, 0x48(%rsp)
shll $0x6, %r15d
movq %r14, 0x8(%rsp)
movq %r11, %rbp
movq %r14, 0x28(%rsp)
movl %r15d, 0x14(%rsp)
movq %r12, 0x50(%rsp)
leaq 0x1(%rbp), %rdx
movl 0x1(%rbp), %edi
pushq $0x1
popq %r8
movl %r15d, %esi
movq %rdx, %rax
movl %r8d, %edx
addq %rax, %rdx
cmpq %r12, %rdx
ja 0x7ceb
movl %esi, %r8d
shrl $0x6, %r8d
incl %esi
imull $0x9e3779b1, %edi, %r9d # imm = 0x9E3779B1
shrl $0x13, %r9d
movzwl (%rbx,%r9,2), %ecx
movl (%rdx), %edi
movl %eax, %r10d
subl %r11d, %r10d
movw %r10w, (%rbx,%r9,2)
movl (%r11,%rcx), %r9d
cmpl (%rax), %r9d
jne 0x77f5
addq %r11, %rcx
movl %eax, %r12d
subl %ebp, %r12d
leal -0xf(%r12), %edx
leal -0x10e(%r12), %esi
movl %esi, 0x18(%rsp)
movl %eax, %edi
shlb $0x4, %dil
movl %ebp, %esi
shlb $0x4, %sil
subb %sil, %dil
xorl %r8d, %r8d
movl %edx, %r9d
movl %r9d, %r15d
movq %r8, %r13
movl %edi, %esi
leaq (%rcx,%r8), %r14
leaq (%rax,%r8), %rbx
cmpq %r11, %r14
jbe 0x7896
cmpq %rbp, %rbx
jbe 0x7896
movb -0x1(%rax,%r13), %r10b
leal -0x1(%r15), %r9d
leaq -0x1(%r13), %r8
leal -0x10(%rsi), %edi
cmpb -0x1(%rcx,%r13), %r10b
je 0x7865
leal (%r12,%r13), %eax
movq 0x8(%rsp), %rcx
leaq 0x1(%rcx), %rdi
cmpl $0xf, %eax
jb 0x792c
movl %edx, %eax
addq %r13, %rax
movb $-0x10, (%rcx)
cmpl $0xfe, %eax
jle 0x7925
addl $0xef, %r12d
movl $0x1fd, %eax # imm = 0x1FD
cmpl %eax, %r15d
movq %rcx, 0x8(%rsp)
movl $0x1fd, %ecx # imm = 0x1FD
cmovbl %r15d, %ecx
cmovgel %eax, %r15d
movl %r12d, %eax
subl %ecx, %eax
addl %r13d, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
leal 0x1(%rax), %edx
movl $0xff, %esi
callq 0x62d0
subl %r15d, %r12d
addl %r13d, %r12d
movl %r12d, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
subl %r12d, %edx
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x2, %rdi
movl 0x18(%rsp), %eax
addl %r13d, %eax
addl %edx, %eax
movb %al, (%rdi)
incq %rdi
jmp 0x792f
movb %sil, (%rcx)
movq %rbx, %rax
subq %rbp, %rax
movl %eax, %r13d
addq %rdi, %r13
movq (%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rbp
cmpq %r13, %rdi
jb 0x793b
movq 0x8(%rsp), %r12
movl %ebx, %eax
subl %r14d, %eax
movw %ax, (%r13)
leaq 0x2(%r13), %r15
leaq 0x4(%rbx), %rdi
addq $0x4, %r14
movq %r14, %rsi
movq 0x48(%rsp), %rdx
callq 0x2e3a5
movl %eax, %r14d
movb (%r12), %al
cmpl $0xf, %r14d
jb 0x79e8
addb $0xf, %al
movb %al, (%r12)
leal -0xf(%r14), %ebp
orl $-0x1, (%r15)
cmpl $0x3fc, %ebp # imm = 0x3FC
jb 0x79ce
leal -0x40b(%r14), %eax
xorl %edx, %edx
movl $0x3fc, %ecx # imm = 0x3FC
divl %ecx
movl %eax, %r12d
movl %edx, %ebp
leaq 0x6(%r13), %rdi
shll $0x2, %r12d
leaq 0x4(%r12), %rdx
movl $0xff, %esi
callq 0x62d0
leaq (%r12,%r13), %r15
addq $0x6, %r15
movl %ebp, %eax
xorl %edx, %edx
movw $0xff, %cx
divw %cx
movzwl %ax, %eax
addq %rax, %r15
incq %r15
movb %dl, -0x1(%r15)
jmp 0x79ef
addb %r14b, %al
movb %al, (%r12)
movq 0x30(%rsp), %r11
addl $0x4, %r14d
addq %r14, %rbx
movq 0x50(%rsp), %r12
cmpq %r12, %rbx
ja 0x7b53
leaq -0x2(%rbx), %rax
imull $0x9e3779b1, -0x2(%rbx), %ecx # imm = 0x9E3779B1
subl %r11d, %eax
shrl $0x13, %ecx
movq 0x38(%rsp), %rsi
movw %ax, (%rsi,%rcx,2)
imull $0x9e3779b1, (%rbx), %eax # imm = 0x9E3779B1
shrl $0x13, %eax
movzwl (%rsi,%rax,2), %ecx
leaq (%r11,%rcx), %r14
movl %ebx, %edx
subl %r11d, %edx
movw %dx, (%rsi,%rax,2)
leaq (%r11,%rcx), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %rbx, %rax
jb 0x7a63
movl (%r14), %eax
cmpl (%rbx), %eax
jne 0x7a63
leaq 0x1(%r15), %r13
movb $0x0, (%r15)
movq %r15, %r12
jmp 0x7954
movq %r15, 0x8(%rsp)
movq %rbx, %rbp
movq 0x28(%rsp), %r14
movl 0x14(%rsp), %r15d
movq 0x38(%rsp), %rbx
jmp 0x77e7
movl %r15d, %eax
shlb $0x4, %al
movb %al, (%rbp)
incq %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x63f0
addl %r15d, %ebp
subl %r14d, %ebp
jmp 0x7403
movq 0x28(%rsp), %rsi
movq 0x68(%rsp), %rdx
addq %rdx, %r9
subq %r14, %r9
leaq 0xf0(%r9), %rax
xorl %ebp, %ebp
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %r12, %rcx
subq %rsi, %rcx
addq %r9, %rcx
addq %rcx, %rax
incq %rax
movl 0x64(%rsp), %ecx
cmpq %rcx, %rax
ja 0x7403
movq %rsi, %r15
cmpq $0xf, %r9
jb 0x7bfc
leaq -0xf(%r9), %rax
movb $-0x10, (%r12)
leaq 0x1(%r12), %rdi
cmpq $0xff, %rax
jb 0x7b49
leaq -0x10e(%r9), %rax
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
leaq 0x1(%rax), %rdx
movl $0xff, %esi
movq %r12, %r13
movq %r9, %r12
callq 0x62d0
movq %r12, %r9
imulq $-0xff, %rbx, %rax
addq %r12, %rax
addq $-0x10e, %rax # imm = 0xFEF2
leaq (%rbx,%r13), %rdi
addq $0x2, %rdi
movb %al, (%rdi)
movq %rdi, %r12
jmp 0x7c06
movq %rbx, %r11
movq %r15, 0x8(%rsp)
movq %rbx, %rbp
movq 0x28(%rsp), %r14
movq 0x20(%rsp), %rdx
subq %r11, %rdx
cmpq $0xf, %rdx
jb 0x7bd1
leaq -0xf(%rdx), %rax
movq 0x8(%rsp), %r15
movb $-0x10, (%r15)
leaq 0x1(%r15), %rdi
cmpq $0xff, %rax
jb 0x7bca
leaq -0x10e(%rdx), %rax
movl $0xff, %ecx
movq %rdx, %r12
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
leaq 0x1(%rax), %rdx
movl $0xff, %esi
callq 0x62d0
movq %r12, %rdx
imulq $-0xff, %rbx, %rax
addq %r12, %rax
addq $-0x10e, %rax # imm = 0xFEF2
leaq (%rbx,%r15), %rdi
addq $0x2, %rdi
movb %al, (%rdi)
movq %rdi, %rbx
jmp 0x7bdd
movl %edx, %eax
shlb $0x4, %al
movq 0x8(%rsp), %rbx
movb %al, (%rbx)
incq %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %rdx, %r15
callq 0x63f0
addl %r15d, %ebx
subl %r14d, %ebx
movq %rbx, %rbp
jmp 0x7403
movl %r9d, %eax
shlb $0x4, %al
movb %al, (%r12)
incq %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r9, %rdx
movq %r9, %rbx
callq 0x63f0
addl %ebx, %r12d
subl %r15d, %r12d
jmp 0x7ce3
movq 0x20(%rsp), %r12
movq 0x70(%rsp), %r15
subq %r14, %r15
leaq 0xf0(%r15), %rax
xorl %ebp, %ebp
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %r12, %rcx
subq 0x28(%rsp), %rcx
addq %r15, %rcx
addq %rcx, %rax
incq %rax
movl 0x64(%rsp), %ecx
cmpq %rcx, %rax
ja 0x7403
cmpq $0xf, %r15
jb 0x7cc0
leaq -0xf(%r15), %rax
movb $-0x10, (%r12)
leaq 0x1(%r12), %rdi
cmpq $0xff, %rax
jb 0x7cb9
leaq -0x10e(%r15), %rax
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
leaq 0x1(%rax), %rdx
movl $0xff, %esi
callq 0x62d0
imulq $-0xff, %rbx, %rax
addq %r15, %rax
addq $-0x10e, %rax # imm = 0xFEF2
leaq (%rbx,%r12), %rdi
addq $0x2, %rdi
movb %al, (%rdi)
movq %rdi, %r12
jmp 0x7cca
movl %r15d, %eax
shlb $0x4, %al
movb %al, (%r12)
incq %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x63f0
addl %r15d, %r12d
subl 0x28(%rsp), %r12d
movl %r12d, %ebp
jmp 0x7403
movq %rbp, %r11
jmp 0x7b63
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
LZ4_compress_fast_force
|
int LZ4_compress_fast_force(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
{
LZ4_stream_t ctx;
LZ4_resetStream(&ctx);
if (inputSize < LZ4_64Klimit)
return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
else
return LZ4_compress_generic(&ctx.internal_donotuse, source, dest, inputSize, maxOutputSize, limitedOutput, sizeof(void*)==8 ? byU32 : byPtr, noDict, noDictIssue, acceleration);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4088, %rsp # imm = 0x4088
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
movl $0x4020, %edx # imm = 0x4020
xorl %esi, %esi
callq 0x62d0
movq %r14, %rdx
movslq %ebx, %r13
addq %r14, %r13
cmpl $0x1000a, %r15d # imm = 0x1000A
jg 0x8146
cmpl $0x7e000000, %r15d # imm = 0x7E000000
movl $0x0, %esi
ja 0x86bc
movl %ebx, 0x38(%rsp)
movslq %r15d, %rcx
movq 0x10(%rsp), %r9
movq %r9, %r14
cmpl $0xd, %r15d
movq %rdx, %r15
jb 0x85fb
leaq (%r9,%rcx), %rbx
addq $-0xc, %rbx
movq %rcx, 0x58(%rsp)
leaq (%r9,%rcx), %rax
addq $-0x5, %rax
movq %rax, 0x50(%rsp)
shll $0x6, %r12d
pushq $0x1
popq %rsi
movq %rdx, 0x40(%rsp)
movq %rdx, (%rsp)
movq %r9, %r14
movl %r12d, 0x3c(%rsp)
movq %r13, 0x28(%rsp)
movq %rbx, 0x48(%rsp)
leaq 0x1(%r14), %rax
movl 0x1(%r14), %edx
movl %r12d, %ecx
movq %rax, %r15
movl %esi, %eax
addq %r15, %rax
cmpq %rbx, %rax
ja 0x85ed
movl %ecx, %esi
shrl $0x6, %esi
incl %ecx
imull $0x9e3779b1, %edx, %edi # imm = 0x9E3779B1
shrl $0x13, %edi
movzwl 0x68(%rsp,%rdi,2), %r12d
movl (%rax), %edx
movl %r15d, %r8d
subl %r9d, %r8d
movw %r8w, 0x68(%rsp,%rdi,2)
movl (%r9,%r12), %edi
cmpl (%r15), %edi
jne 0x7dff
leaq (%r9,%r12), %r10
movl %r15d, %eax
subl %r14d, %eax
leal -0xf(%rax), %edx
movq %rax, 0x8(%rsp)
addl $0xfffffef2, %eax # imm = 0xFFFFFEF2
movl %eax, 0x34(%rsp)
movl %r15d, %eax
shlb $0x4, %al
movl %r14d, %ecx
shlb $0x4, %cl
subb %cl, %al
xorl %ecx, %ecx
movl %edx, 0x18(%rsp)
movl %edx, %r13d
movq %rcx, %rbx
movl %eax, %r8d
leaq (%r10,%rcx), %rax
leaq (%r15,%rcx), %rbp
cmpq %r9, %rax
jbe 0x7e9f
cmpq %r14, %rbp
jbe 0x7e9f
movb -0x1(%r15,%rbx), %dil
leal -0x1(%r13), %edx
leaq -0x1(%rbx), %rcx
leal -0x10(%r8), %eax
cmpb -0x1(%r10,%rbx), %dil
je 0x7e6c
movq %r10, 0x20(%rsp)
movl %r15d, %eax
subl %r14d, %eax
leal (%rbx,%rax), %r11d
movq 0x8(%rsp), %rax
leaq (%rax,%rbx), %rcx
movq (%rsp), %rax
movq %rax, %rsi
leaq (%rax,%r11), %rdi
incq %rdi
movl %ecx, %eax
xorl %edx, %edx
movl $0xff, %r10d
divl %r10d
addq %rdi, %rax
addq $0x8, %rax
cmpq 0x28(%rsp), %rax
ja 0x85e6
movq %rsi, %rdx
leaq 0x1(%rsi), %rdi
cmpl $0xf, %ecx
jb 0x7f9a
movl 0x18(%rsp), %eax
addq %rbx, %rax
movb $-0x10, (%rdx)
cmpl $0xfe, %eax
jle 0x7f89
movq 0x8(%rsp), %rsi
addl $0xef, %esi
movq %rsi, 0x8(%rsp)
movl $0x1fd, %eax # imm = 0x1FD
cmpl %eax, %r13d
movl $0x1fd, %ecx # imm = 0x1FD
cmovbl %r13d, %ecx
cmovgel %eax, %r13d
movl %esi, %eax
subl %ecx, %eax
addl %ebx, %eax
movq %rdx, (%rsp)
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
leal 0x1(%rax), %edx
movl $0xff, %esi
movq %r11, 0x18(%rsp)
callq 0x62d0
movq 0x18(%rsp), %r11
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rax
subl %r13d, %eax
addl %ebx, %eax
movq %rax, %rcx
xorl %edx, %edx
movl $0xff, %esi
divl %esi
subl %ecx, %edx
movq (%rsp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x2, %rdi
movl 0x34(%rsp), %eax
addl %ebx, %eax
addl %edx, %eax
movq 0x28(%rsp), %r13
movq 0x20(%rsp), %rdx
movb %al, (%rdi)
incq %rdi
jmp 0x7fa7
movb %r8b, (%rdx)
movq 0x28(%rsp), %r13
movq 0x20(%rsp), %rdx
addq %rdi, %r11
movq (%r14), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %r14
cmpq %r11, %rdi
jb 0x7faa
addl %r9d, %r12d
movl %ebp, %ecx
subl %ebx, %ecx
subl %r12d, %ecx
movw %cx, (%r11)
leaq (%r15,%rbx), %rdi
addq $0x4, %rdi
leaq (%rdx,%rbx), %rsi
addq $0x4, %rsi
movq 0x50(%rsp), %rdx
movq %r11, %rbx
callq 0x2e3a5
movl %eax, %ecx
shrl $0x8, %ecx
addq %rbx, %rcx
addq $0x8, %rcx
cmpq %r13, %rcx
ja 0x85e6
movq %rbx, %r8
movl %eax, %ecx
addl $0x4, %ecx
addq %rcx, %rbp
movq %rbp, %r14
movl 0x3c(%rsp), %r12d
movq (%rsp), %r15
movq 0x48(%rsp), %rbx
leaq 0x2(%r8), %rcx
movb (%r15), %dl
cmpl $0xf, %eax
jb 0x8092
addb $0xf, %dl
movb %dl, (%r15)
leal -0xf(%rax), %ebx
orl $-0x1, (%rcx)
cmpl $0x3fc, %ebx # imm = 0x3FC
jb 0x806d
addl $0xfffffbf5, %eax # imm = 0xFFFFFBF5
xorl %edx, %edx
movl $0x3fc, %ecx # imm = 0x3FC
divl %ecx
movl %eax, %r15d
movl %edx, %ebx
leaq 0x6(%r8), %rdi
shll $0x2, %r15d
leaq 0x4(%r15), %rdx
movl $0xff, %esi
movq %r8, %rbp
callq 0x62d0
leaq (%r15,%rbp), %rcx
addq $0x6, %rcx
movl %ebx, %eax
xorl %edx, %edx
movw $0xff, %si
divw %si
movzwl %ax, %eax
leaq (%rcx,%rax), %r15
incq %r15
movb %dl, -0x1(%r15)
movq 0x10(%rsp), %r9
movq 0x48(%rsp), %rbx
jmp 0x809f
addb %al, %dl
movb %dl, (%r15)
movq %rcx, %r15
movq 0x10(%rsp), %r9
cmpq %rbx, %r14
ja 0x85f1
leaq -0x2(%r14), %rax
imull $0x9e3779b1, -0x2(%r14), %ecx # imm = 0x9E3779B1
subl %r9d, %eax
shrl $0x13, %ecx
movw %ax, 0x68(%rsp,%rcx,2)
imull $0x9e3779b1, (%r14), %eax # imm = 0x9E3779B1
shrl $0x13, %eax
movzwl 0x68(%rsp,%rax,2), %ecx
leaq (%r9,%rcx), %rsi
movl %r14d, %edx
subl %r9d, %edx
movw %dx, 0x68(%rsp,%rax,2)
leaq (%r9,%rcx), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r14, %rax
jb 0x813a
movl (%rsi), %eax
cmpl (%r14), %eax
jne 0x813a
leaq 0x1(%r15), %rbp
movb $0x0, (%r15)
movl %r14d, %eax
subl %esi, %eax
movw %ax, 0x1(%r15)
leaq 0x4(%r14), %rdi
addq $0x4, %rsi
movq 0x50(%rsp), %rdx
callq 0x2e3a5
movq %rbp, %r8
leal 0x4(%rax), %ecx
addq %rcx, %r14
movl %eax, %ecx
shrl $0x8, %ecx
addq %r15, %rcx
addq $0x9, %rcx
cmpq %r13, %rcx
jbe 0x8019
jmp 0x85e6
movq %r15, (%rsp)
pushq $0x1
popq %rsi
jmp 0x7df4
cmpl $0x7e000000, %r15d # imm = 0x7E000000
movl $0x0, %esi
ja 0x86bc
movl %ebx, 0x38(%rsp)
movl %r15d, %eax
movq 0x10(%rsp), %r9
leaq (%r9,%rax), %rcx
movq %rcx, 0x60(%rsp)
leaq -0xc(%r9,%rax), %r10
leaq -0x5(%r9,%rax), %rax
movq %rax, 0x50(%rsp)
movabsq $-0x30e4432345000000, %r11 # imm = 0xCF1BBCDCBB000000
movl %r12d, %ecx
shll $0x6, %ecx
incl %ecx
andl $0x3ffffff, %r12d # imm = 0x3FFFFFF
leaq 0x2(%r9), %rax
movq %r9, %r14
movq %rdx, 0x40(%rsp)
movq %rdx, %r15
movq %r10, 0x48(%rsp)
movl %r12d, 0x3c(%rsp)
movq %r13, 0x28(%rsp)
movl %ecx, 0x58(%rsp)
movq %r15, (%rsp)
leaq 0x1(%r14), %r15
movq 0x1(%r14), %rdx
movl %r12d, %esi
movq %rax, %rdi
imulq %r11, %rdx
movq %rdx, %rax
shrq $0x34, %rax
movl 0x68(%rsp,%rax,4), %r13d
movq (%rdi), %rdx
movl %r15d, %r8d
subl %r9d, %r8d
movl %r8d, 0x68(%rsp,%rax,4)
leaq (%r9,%r13), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r15, %rax
jb 0x8201
leaq (%r9,%r13), %rbx
movl (%rbx), %eax
cmpl (%r15), %eax
je 0x821f
movl %esi, %eax
addq %rdi, %rax
leal 0x1(%rcx), %r8d
shrl $0x6, %ecx
movl %ecx, %esi
movl %r8d, %ecx
movq %rdi, %r15
cmpq %r10, %rax
jbe 0x81c6
jmp 0x8525
movl %r15d, %eax
subl %r14d, %eax
leal -0xf(%rax), %edx
movq %rax, 0x8(%rsp)
addl $0xfffffef2, %eax # imm = 0xFFFFFEF2
movl %eax, 0x34(%rsp)
movl %r15d, %eax
shlb $0x4, %al
movl %r14d, %ecx
shlb $0x4, %cl
subb %cl, %al
xorl %ecx, %ecx
movl %edx, 0x18(%rsp)
movl %edx, %ebp
movq %rcx, %r12
movl %eax, %r8d
leaq (%rbx,%rcx), %rax
leaq (%r15,%rcx), %r10
cmpq %r9, %rax
jbe 0x827c
cmpq %r14, %r10
jbe 0x827c
movb -0x1(%r15,%r12), %dil
leal -0x1(%rbp), %edx
leaq -0x1(%r12), %rcx
leal -0x10(%r8), %eax
cmpb -0x1(%rbx,%r12), %dil
je 0x824a
movq %r10, 0x20(%rsp)
movl %r15d, %eax
subl %r14d, %eax
leal (%r12,%rax), %r11d
movq 0x8(%rsp), %rax
leaq (%rax,%r12), %rcx
movq (%rsp), %rax
movq %rax, %rsi
leaq (%rax,%r11), %rdi
incq %rdi
movl %ecx, %eax
xorl %edx, %edx
movl $0xff, %r10d
divl %r10d
addq %rdi, %rax
addq $0x8, %rax
cmpq 0x28(%rsp), %rax
ja 0x85e6
movq %rsi, %rdx
leaq 0x1(%rsi), %rdi
cmpl $0xf, %ecx
jb 0x8369
movl 0x18(%rsp), %eax
addq %r12, %rax
movb $-0x10, (%rdx)
cmpl $0xfe, %eax
jle 0x835d
movq 0x8(%rsp), %rsi
addl $0xef, %esi
movq %rsi, 0x8(%rsp)
movl $0x1fd, %eax # imm = 0x1FD
cmpl %eax, %ebp
movl $0x1fd, %ecx # imm = 0x1FD
cmovbl %ebp, %ecx
cmovgel %eax, %ebp
movl %esi, %eax
subl %ecx, %eax
addl %r12d, %eax
xorl %edx, %edx
movl $0xff, %ecx
divl %ecx
leal 0x1(%rax), %edx
movl $0xff, %esi
movq %r11, 0x18(%rsp)
callq 0x62d0
movq 0x18(%rsp), %r11
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rax
subl %ebp, %eax
addl %r12d, %eax
movq %rax, %rcx
xorl %edx, %edx
movl $0xff, %esi
divl %esi
subl %ecx, %edx
movq (%rsp), %rcx
leaq (%rcx,%rax), %rdi
addq $0x2, %rdi
movl 0x34(%rsp), %eax
addl %r12d, %eax
addl %edx, %eax
movq 0x20(%rsp), %r8
movb %al, (%rdi)
incq %rdi
jmp 0x8371
movb %r8b, (%rdx)
movq 0x20(%rsp), %r8
addq %rdi, %r11
movq (%r14), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %r14
cmpq %r11, %rdi
jb 0x8374
addl %r9d, %r13d
movl %r8d, %ecx
subl %r12d, %ecx
subl %r13d, %ecx
movw %cx, (%r11)
leaq (%r15,%r12), %rdi
addq $0x4, %rdi
leaq 0x4(%r12,%rbx), %rsi
movq 0x50(%rsp), %rdx
movq %r11, %rbx
movq %r8, %r14
callq 0x2e3a5
movl %eax, %ecx
shrl $0x8, %ecx
addq %rbx, %rcx
addq $0x8, %rcx
movq 0x28(%rsp), %r13
cmpq %r13, %rcx
ja 0x85e6
movq %rbx, %r8
movl %eax, %ecx
addl $0x4, %ecx
addq %rcx, %r14
movl 0x3c(%rsp), %r12d
movq (%rsp), %r15
leaq 0x2(%r8), %rcx
movb (%r15), %dl
cmpl $0xf, %eax
jb 0x845d
addb $0xf, %dl
movb %dl, (%r15)
leal -0xf(%rax), %ebx
orl $-0x1, (%rcx)
cmpl $0x3fc, %ebx # imm = 0x3FC
jb 0x8442
addl $0xfffffbf5, %eax # imm = 0xFFFFFBF5
xorl %edx, %edx
movl $0x3fc, %ecx # imm = 0x3FC
divl %ecx
movl %eax, %r15d
movl %edx, %ebx
leaq 0x6(%r8), %rdi
shll $0x2, %r15d
leaq 0x4(%r15), %rdx
movl $0xff, %esi
movq %r13, %rbp
movl %r12d, %r13d
movq %r8, %r12
callq 0x62d0
leaq (%r12,%r15), %rcx
addq $0x6, %rcx
movl %r13d, %r12d
movq %rbp, %r13
movl %ebx, %eax
xorl %edx, %edx
movw $0xff, %si
divw %si
movzwl %ax, %eax
leaq (%rcx,%rax), %r15
incq %r15
movb %dl, -0x1(%r15)
jmp 0x8465
addb %al, %dl
movb %dl, (%r15)
movq %rcx, %r15
movq 0x10(%rsp), %r9
movq 0x48(%rsp), %r10
movabsq $-0x30e4432345000000, %r11 # imm = 0xCF1BBCDCBB000000
cmpq %r10, %r14
ja 0x8529
leaq -0x2(%r14), %rax
movq -0x2(%r14), %rcx
imulq %r11, %rcx
shrq $0x34, %rcx
subl %r9d, %eax
movl %eax, 0x68(%rsp,%rcx,4)
movq (%r14), %rax
imulq %r11, %rax
shrq $0x34, %rax
movl 0x68(%rsp,%rax,4), %esi
movl %r14d, %ecx
subl %r9d, %ecx
movl %ecx, 0x68(%rsp,%rax,4)
leaq (%r9,%rsi), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r14, %rax
jb 0x8512
addq %r9, %rsi
movl (%rsi), %eax
cmpl (%r14), %eax
jne 0x8512
leaq 0x1(%r15), %rbx
movb $0x0, (%r15)
movl %r14d, %eax
subl %esi, %eax
movw %ax, 0x1(%r15)
leaq 0x4(%r14), %rdi
addq $0x4, %rsi
movq 0x50(%rsp), %rdx
callq 0x2e3a5
movq %rbx, %r8
leal 0x4(%rax), %ecx
addq %rcx, %r14
movl %eax, %ecx
shrl $0x8, %ecx
addq %r15, %rcx
addq $0x9, %rcx
cmpq %r13, %rcx
jbe 0x83e2
jmp 0x85e6
leaq 0x2(%r14), %rax
cmpq %r10, %rax
movl 0x58(%rsp), %ecx
jbe 0x81b7
jmp 0x8529
movq (%rsp), %r15
movq 0x60(%rsp), %rbx
subq %r14, %rbx
leaq 0xf0(%rbx), %rax
xorl %esi, %esi
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %r15, %rcx
subq 0x40(%rsp), %rcx
addq %rbx, %rcx
addq %rcx, %rax
incq %rax
movl 0x38(%rsp), %ecx
cmpq %rcx, %rax
ja 0x86bc
cmpq $0xf, %rbx
jb 0x85c0
leaq -0xf(%rbx), %rax
movb $-0x10, (%r15)
leaq 0x1(%r15), %rdi
cmpq $0xff, %rax
jb 0x85b9
leaq -0x10e(%rbx), %rax
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %r15, %r12
movq %rax, %r15
leaq 0x1(%rax), %rdx
movl $0xff, %esi
callq 0x62d0
imulq $-0xff, %r15, %rax
addq %rbx, %rax
addq $-0x10e, %rax # imm = 0xFEF2
leaq (%r15,%r12), %rdi
addq $0x2, %rdi
movb %al, (%rdi)
movq %rdi, %r15
jmp 0x85c8
movl %ebx, %eax
shlb $0x4, %al
movb %al, (%r15)
incq %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x63f0
addl %ebx, %r15d
subl 0x40(%rsp), %r15d
jmp 0x86b9
xorl %esi, %esi
jmp 0x86bc
movq (%rsp), %r15
movq 0x58(%rsp), %rcx
movq 0x40(%rsp), %rdx
addq %rcx, %r9
subq %r14, %r9
leaq 0xf0(%r9), %rax
movl $0xff, %ecx
movq %rdx, %r13
xorl %edx, %edx
divq %rcx
movq %r15, %rcx
subq %r13, %rcx
addq %r9, %rcx
xorl %esi, %esi
addq %rcx, %rax
incq %rax
movl 0x38(%rsp), %ecx
cmpq %rcx, %rax
ja 0x86bc
movq %r9, %rbx
movq %r9, %rdx
cmpq $0xf, %rbx
jb 0x869a
leaq -0xf(%rdx), %rax
movb $-0x10, (%r15)
leaq 0x1(%r15), %rdi
cmpq $0xff, %rax
jb 0x8693
leaq -0x10e(%rdx), %rax
movl $0xff, %ecx
xorl %edx, %edx
divq %rcx
movq %r15, %r12
movq %rax, %r15
leaq 0x1(%rax), %rdx
movl $0xff, %esi
callq 0x62d0
movq %rbx, %rdx
imulq $-0xff, %r15, %rax
addq %rbx, %rax
addq $-0x10e, %rax # imm = 0xFEF2
leaq (%r15,%r12), %rdi
addq $0x2, %rdi
movb %al, (%rdi)
movq %rdi, %r15
jmp 0x86a2
movl %edx, %eax
shlb $0x4, %al
movb %al, (%r15)
incq %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rdx, %rbx
callq 0x63f0
addl %ebx, %r15d
subl %r13d, %r15d
movl %r15d, %esi
movl %esi, %eax
addq $0x4088, %rsp # imm = 0x4088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
luaH_resize
|
void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
unsigned int nhsize) {
unsigned int i;
int j;
unsigned int oldasize = t->sizearray;
int oldhsize = allocsizenode(t);
Node *nold = t->node; /* save old hash ... */
if (nasize > oldasize) /* array part must grow? */
setarrayvector(L, t, nasize);
/* create new hash part with appropriate size */
setnodevector(L, t, nhsize);
if (nasize < oldasize) { /* array part must shrink? */
t->sizearray = nasize;
/* re-insert elements from vanishing slice */
for (i=nasize; i<oldasize; i++) {
if (!ttisnil(&t->array[i]))
luaH_setint(L, t, i + 1, &t->array[i]);
}
/* shrink array */
luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
}
/* re-insert elements from hash part */
for (j = oldhsize - 1; j >= 0; j--) {
Node *old = nold + j;
if (!ttisnil(gval(old))) {
/* doesn't need barrier/invalidate cache, as entry was
already present in the table */
setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
}
}
if (oldhsize > 0) /* not the dummy node? */
luaM_freearray(L, nold, cast(size_t, oldhsize)); /* free old hash */
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rsi), %edx
cmpq $0x0, 0x20(%rsi)
je 0xb2ed
movb 0xb(%r14), %cl
movl $0x1, %r12d
shll %cl, %r12d
jmp 0xb2f0
xorl %r12d, %r12d
movq 0x18(%r14), %rax
movq %rax, 0x10(%rsp)
cmpl %ebp, %edx
movq %rdx, 0x8(%rsp)
jae 0xb43c
movq 0x10(%r14), %rsi
shlq $0x4, %rdx
movl %ebp, %r15d
movq %r15, %rcx
shlq $0x4, %rcx
movq %rbx, %rdi
callq 0x11d07
movq %rax, 0x10(%r14)
movl 0xc(%r14), %edx
cmpl %ebp, %edx
jae 0xb433
subq %rdx, %r15
leaq 0x3(%r15), %rcx
andq $-0x4, %rcx
decq %r15
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x38, %rax
xorl %edx, %edx
movdqa 0x26cb3(%rip), %xmm1 # 0x32010
movdqa 0x26cbb(%rip), %xmm2 # 0x32020
movdqa 0x26cc3(%rip), %xmm3 # 0x32030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0xb3bf
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0xb3d5
movl $0x0, -0x20(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0xb411
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0xb422
movl $0x0, (%rax)
addq $0x4, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0xb375
movl %ebp, 0xc(%r14)
movq 0x8(%rsp), %rdx
testl %r13d, %r13d
movl %r12d, 0x4(%rsp)
je 0xb46d
decl %r13d
xorl %eax, %eax
cmpl $0x100, %r13d # imm = 0x100
jb 0xb482
xorl %eax, %eax
movl %r13d, %ecx
addl $0x8, %eax
shrl $0x8, %ecx
cmpl $0xffff, %r13d # imm = 0xFFFF
movl %ecx, %r13d
ja 0xb459
jmp 0xb485
leaq 0x2793c(%rip), %rax # 0x32db0
movq %rax, 0x18(%r14)
movb $0x0, 0xb(%r14)
xorl %r12d, %r12d
jmp 0xb4f6
movl %r13d, %ecx
movl %ecx, %ecx
leaq 0x276f2(%rip), %rdx # 0x32b80
movzbl (%rcx,%rdx), %r13d
addl %eax, %r13d
cmpl $0x1f, %r13d
jge 0xb5ec
movl $0x1, %r15d
movl %r13d, %ecx
shll %cl, %r15d
movq %r15, %r12
shlq $0x5, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x11d07
movq %rax, 0x18(%r14)
movl $0x1c, %eax
movq 0x18(%r14), %rcx
movq $0x0, -0x4(%rcx,%rax)
movl $0x0, -0x14(%rcx,%rax)
addq $0x20, %rax
decq %r15
jne 0xb4cb
movb %r13b, 0xb(%r14)
addq 0x18(%r14), %r12
movq 0x8(%rsp), %rdx
movq %r12, 0x20(%r14)
cmpl %ebp, %edx
jbe 0xb567
movl %ebp, 0xc(%r14)
movl %ebp, %r13d
movq %rdx, %rbp
negq %rbp
leaq 0x1(%r13), %r15
movq %r13, %r12
shlq $0x4, %r12
movq 0x10(%r14), %rcx
cmpl $0x0, 0x8(%rcx,%r12)
je 0xb533
addq %r12, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xbc07
leaq (%r15,%rbp), %rax
incq %rax
incq %r15
addq $0x10, %r12
cmpq $0x1, %rax
jne 0xb516
movq 0x10(%r14), %rsi
movq 0x8(%rsp), %rdx
shlq $0x4, %rdx
shlq $0x4, %r13
movq %rbx, %rdi
movq %r13, %rcx
callq 0x11d07
movq %rax, 0x10(%r14)
movl 0x4(%rsp), %eax
testl %eax, %eax
jle 0xb5dd
movl %eax, %r12d
leaq 0x1(%r12), %r13
movq %r12, %rax
shlq $0x5, %rax
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx), %r15
addq $-0x10, %r15
cmpl $0x0, -0x8(%r15)
je 0xb5ad
leaq -0x10(%r15), %rbp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xbb5e
movdqu (%rbp), %xmm0
movdqu %xmm0, (%rax)
decq %r13
addq $-0x20, %r15
cmpq $0x1, %r13
ja 0xb58b
cmpl $0x0, 0x4(%rsp)
jle 0xb5dd
shlq $0x5, %r12
movq 0x18(%rbx), %rbx
movq 0x8(%rbx), %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq *(%rbx)
subq %r12, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x294c1(%rip), %rsi # 0x34ab4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11359
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaC_upvdeccount
|
void luaC_upvdeccount (lua_State *L, UpVal *uv) {
lua_assert(uv->refcount > 0);
uv->refcount--;
if (uv->refcount == 0 && !upisopen(uv))
luaM_free(L, uv);
}
|
decq 0x8(%rsi)
je 0xd22b
retq
leaq 0x10(%rsi), %rax
cmpq %rax, (%rsi)
jne 0xd22a
pushq %rbx
movq 0x18(%rdi), %rbx
movq 0x8(%rbx), %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq *(%rbx)
addq $-0x20, 0x18(%rbx)
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaL_tolstring
|
LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
if (luaL_callmeta(L, idx, "__tostring")) { /* metafield? */
if (!lua_isstring(L, -1))
luaL_error(L, "'__tostring' must return a string");
}
else {
switch (lua_type(L, idx)) {
case LUA_TNUMBER: {
if (lua_isinteger(L, idx))
lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx));
else
lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx));
break;
}
case LUA_TSTRING:
lua_pushvalue(L, idx);
break;
case LUA_TBOOLEAN:
lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
break;
case LUA_TNIL:
lua_pushliteral(L, "nil");
break;
default: {
int tt = luaL_getmetafield(L, idx, "__name"); /* try name */
const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) :
luaL_typename(L, idx);
lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx));
if (tt != LUA_TNIL)
lua_remove(L, -2); /* remove '__name' */
break;
}
}
}
return lua_tolstring(L, -1, len);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x23f0d(%rip), %rdx # 0x32f6a
callq 0xef5a
testl %eax, %eax
je 0xf094
movq 0x10(%rbx), %rax
movl -0x8(%rax), %eax
andl $0xf, %eax
addl $-0x5, %eax
cmpl $-0x3, %eax
jbe 0xf202
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9ffc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x916a
leaq 0x2399b(%rip), %r12 # 0x32a40
cmpq %r12, %rax
je 0xf0d3
movl 0x8(%rax), %ecx
movl %ecx, %edx
andl $0xf, %edx
cmpl $0x4, %edx
ja 0xf0d3
leaq 0x2318a(%rip), %rsi # 0x32248
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x24450(%rip), %rsi # 0x3351e
jmp 0xf168
leaq 0x23e07(%rip), %rdx # 0x32ee1
movq %rbx, %rdi
movl %ebp, %esi
callq 0xeee6
movl %eax, %r15d
movq %rbx, %rdi
cmpl $0x4, %eax
jne 0xf103
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x9ffc
movq %rax, %r12
jmp 0xf1a1
movl %ebp, %esi
callq 0x916a
cmpq %r12, %rax
je 0xf194
movl 0x8(%rax), %eax
andl $0xf, %eax
incq %rax
jmp 0xf196
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
cmpl $0x13, %ecx
jne 0xf1e7
callq 0x9e85
leaq 0x23e5d(%rip), %rsi # 0x32f97
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xab73
jmp 0xf07c
testl %ecx, %ecx
je 0xf161
leaq 0x23e43(%rip), %rsi # 0x32f9a
cmpl $0x1, %ecx
jne 0xf168
cmpl $0x0, (%rax)
jne 0xf168
leaq 0x23e37(%rip), %rsi # 0x32f9f
movq %rbx, %rdi
callq 0xa67f
jmp 0xf07c
movq 0x10(%rbx), %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x916a
movups (%rax), %xmm0
movups %xmm0, (%r15)
addq $0x10, 0x10(%rbx)
jmp 0xf07c
xorl %eax, %eax
leaq 0x31bd3(%rip), %rcx # 0x40d70
movq (%rcx,%rax,8), %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0xa452
leaq 0x23df3(%rip), %rsi # 0x32fa5
movq %rbx, %rdi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xab73
testl %r15d, %r15d
je 0xf07c
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x90c6
addq $-0x10, 0x10(%rbx)
jmp 0xf07c
callq 0x9e2d
leaq 0x23e51(%rip), %rsi # 0x33044
movq %rbx, %rdi
movb $0x1, %al
callq 0xab73
jmp 0xf07c
leaq 0x23d6c(%rip), %rsi # 0x32f75
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdb8f
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaL_requiref
|
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
lua_CFunction openf, int glb) {
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
lua_getfield(L, -1, modname); /* LOADED[modname] */
if (!lua_toboolean(L, -1)) { /* package not already loaded? */
lua_pop(L, 1); /* remove field */
lua_pushcfunction(L, openf);
lua_pushstring(L, modname); /* argument to open function */
lua_call(L, 1, 1); /* call 'openf' to open module */
lua_pushvalue(L, -1); /* make copy of module (call result) */
lua_setfield(L, -3, modname); /* LOADED[modname] = module */
}
lua_remove(L, -2); /* remove LOADED table */
if (glb) {
lua_pushvalue(L, -1); /* copy of module */
lua_setglobal(L, modname); /* _G[modname] = module */
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x23ae9(%rip), %rdx # 0x32fbe
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0xf422
movq 0x10(%r14), %rsi
addq $-0x10, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xad9e
movq 0x10(%r14), %rax
movl -0x8(%rax), %ecx
testl %ecx, %ecx
je 0xf510
cmpl $0x1, %ecx
jne 0xf591
cmpl $0x0, -0x10(%rax)
jne 0xf591
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movq %r15, -0x10(%rax)
movl $0x16, -0x8(%rax)
addq $0x10, 0x10(%r14)
movq 0x18(%r14), %rax
cmpq $0x0, 0x18(%rax)
jle 0xf53b
movq %r14, %rdi
callq 0xa125
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa67f
movq 0x10(%r14), %rsi
addq $-0x20, %rsi
incw 0xc4(%r14)
movq %r14, %rdi
movl $0x1, %edx
callq 0xbf2f
decw 0xc4(%r14)
movq 0x10(%r14), %rax
movups -0x10(%rax), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rsi
leaq 0x10(%rsi), %rax
movq %rax, 0x10(%r14)
addq $-0x20, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xb6bd
movq %r14, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x90c6
movq 0x10(%r14), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
testl %ebp, %ebp
je 0xf5e9
movups -0x20(%rax), %xmm0
movups %xmm0, (%rcx)
addq $0x10, 0x10(%r14)
movq 0x18(%r14), %rax
movq 0x40(%rax), %rdi
movl $0x2, %esi
callq 0xae27
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb6bd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaL_checkversion_
|
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
const lua_Number *v = lua_version(L);
if (sz != LUAL_NUMSIZES) /* check numeric types */
luaL_error(L, "core and library have incompatible numeric types");
if (v != lua_version(NULL))
luaL_error(L, "multiple Lua VMs detected");
else if (*v != ver)
luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
(LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);
}
|
pushq %rax
testq %rdi, %rdi
je 0xf94c
cmpq $0x88, %rsi
jne 0xf963
movq 0x18(%rdi), %rax
leaq 0x230fe(%rip), %rcx # 0x32a38
cmpq %rcx, 0xd0(%rax)
je 0xf955
leaq 0x236ad(%rip), %rsi # 0x32ff7
jmp 0xf96a
cmpq $0x88, %rsi
jne 0xf963
ucomisd 0x2348b(%rip), %xmm0 # 0x32de8
jne 0xf971
jp 0xf971
popq %rax
retq
leaq 0x2365c(%rip), %rsi # 0x32fc6
xorl %eax, %eax
callq 0xdb8f
leaq 0x23699(%rip), %rsi # 0x33011
movsd 0x23468(%rip), %xmm1 # 0x32de8
movb $0x2, %al
callq 0xdb8f
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaK_prefix
|
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};
switch (op) {
case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */
if (constfolding(fs, op + LUA_OPUNM, e, &ef))
break;
/* FALLTHROUGH */
case OPR_LEN:
codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
break;
case OPR_NOT: codenot(fs, e); break;
default: lua_assert(0);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2, %esi
jb 0x108a7
je 0x10920
cmpl $0x3, %r15d
je 0x108c1
jmp 0x10915
leal 0xc(%r15), %esi
leaq 0x2219e(%rip), %rcx # 0x32a50
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10a21
testl %eax, %eax
jne 0x10915
addl $0x19, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x103a8
cmpl $0x7, (%r14)
jne 0x108eb
movl 0x8(%r14), %ecx
btl $0x8, %ecx
jb 0x108eb
movzbl 0x3a(%rbx), %edx
cmpl %edx, %ecx
jl 0x108eb
decb 0x3c(%rbx)
shll $0x17, %eax
orl %r15d, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0xfced
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
movq (%rbx), %rax
movq 0x48(%rax), %rax
movslq 0x20(%rbx), %rcx
movl %ebp, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1019a
movl (%r14), %eax
decl %eax
cmpl $0xb, %eax
ja 0x109f3
leaq 0x21950(%rip), %rcx # 0x32290
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, (%r14)
jmp 0x109f3
movl $0x2, (%r14)
jmp 0x109f3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae33
cmpl $0x7, (%r14)
jne 0x10987
movl 0x8(%r14), %eax
btl $0x8, %eax
jb 0x10987
movzbl 0x3a(%rbx), %ecx
cmpl %ecx, %eax
jl 0x10987
decb 0x3c(%rbx)
movl 0x8(%r14), %esi
shll $0x17, %esi
orl $0x1b, %esi
movq %rbx, %rdi
callq 0xfced
movl %eax, 0x8(%r14)
movl $0xc, (%r14)
jmp 0x109f3
movq (%rbx), %rcx
movslq 0x8(%r14), %rdx
leaq (,%rdx,4), %rax
addq 0x38(%rcx), %rax
testq %rdx, %rdx
jle 0x109d0
movl -0x4(%rax), %ecx
movl %ecx, %edx
andl $0x3f, %edx
addq $-0x24, %rdx
cmpq $-0x6, %rdx
ja 0x109d4
movl (%rax), %ecx
jmp 0x109d8
addq $-0x4, %rax
movl %ecx, %edx
andl $0xffffc03f, %edx # imm = 0xFFFFC03F
xorl %esi, %esi
testl $0x3fc0, %ecx # imm = 0x3FC0
sete %sil
shll $0x6, %esi
orl %edx, %esi
movl %esi, (%rax)
movl 0x10(%r14), %esi
movl 0x14(%r14), %eax
movl %esi, 0x14(%r14)
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x1ae6e
movl 0x10(%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ae6e
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaD_shrinkstack
|
void luaD_shrinkstack (lua_State *L) {
int inuse = stackinuse(L);
int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
if (goodsize > LUAI_MAXSTACK)
goodsize = LUAI_MAXSTACK; /* respect stack limit */
if (L->stacksize > LUAI_MAXSTACK) /* had been handling stack overflow? */
luaE_freeCI(L); /* free all CIs (list grew because of an error) */
else
luaE_shrinkCI(L); /* shrink list */
/* if thread is currently not handling a stack overflow and its
good size is smaller than current size, shrink its stack */
if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
goodsize < L->stacksize)
luaD_reallocstack(L, goodsize);
else /* don't change stack */
condmovestack(L,{},{}); /* (change only for debugging) */
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x11e1b
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
cmpq %rcx, %r14
cmovbq %rcx, %r14
jmp 0x11e05
subq 0x38(%rbx), %r14
shrq $0x4, %r14
leal 0x1(%r14), %eax
leal 0x8(%r14), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x3, %ecx
leal (%rcx,%r14), %eax
incl %eax
movl $0xf4236, %ebp # imm = 0xF4236
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl $0xf4241, 0xb8(%rbx) # imm = 0xF4241
jl 0x11e59
movq %rbx, %rdi
callq 0x11e88
jmp 0x11e61
movq %rbx, %rdi
callq 0x11ed2
cmpl $0xf423a, %r14d # imm = 0xF423A
jg 0x11e83
addl $0xa, %ebp
cmpl 0xb8(%rbx), %ebp
jge 0x11e83
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x11b29
popq %rbx
popq %r14
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
lua_resume
|
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
int status;
unsigned short oldnny = L->nny; /* save "number of non-yieldable" calls */
lua_lock(L);
if (L->status == LUA_OK) { /* may be starting a coroutine */
if (L->ci != &L->base_ci) /* not in base level? */
return resume_error(L, "cannot resume non-suspended coroutine", nargs);
}
else if (L->status != LUA_YIELD)
return resume_error(L, "cannot resume dead coroutine", nargs);
L->nCcalls = (from) ? from->nCcalls + 1 : 1;
if (L->nCcalls >= LUAI_MAXCCALLS)
return resume_error(L, "C stack overflow", nargs);
luai_userstateresume(L, nargs);
L->nny = 0; /* allow yields */
api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
status = luaD_rawrunprotected(L, resume, &nargs);
if (status == -1) /* error calling 'lua_resume'? */
status = LUA_ERRRUN;
else { /* continue running after recoverable errors */
while (errorstatus(status) && recover(L, status)) {
/* unroll continuation */
status = luaD_rawrunprotected(L, unroll, &status);
}
if (errorstatus(status)) { /* unrecoverable error? */
L->status = cast_byte(status); /* mark thread as 'dead' */
seterrorobj(L, status, L->top); /* push error message */
L->ci->top = L->top;
}
else lua_assert(status == L->status); /* normal end or yield */
}
L->nny = oldnny; /* restore 'nny' */
L->nCcalls--;
lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
lua_unlock(L);
return status;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movzwl 0xc4(%rdi), %r13d
movzbl 0xc(%rdi), %eax
cmpl $0x1, %eax
je 0x144ea
testl %eax, %eax
jne 0x14527
leaq 0x60(%rbx), %rax
cmpq %rax, 0x20(%rbx)
je 0x144ea
movq 0x10(%rbx), %r14
movslq %edx, %r15
shlq $0x4, %r15
movq %r14, %r12
subq %r15, %r12
movq %r12, 0x10(%rbx)
leaq 0x1ec5e(%rip), %rsi # 0x33146
jmp 0x14543
testq %rsi, %rsi
je 0x1456d
movzwl 0xc6(%rsi), %eax
incl %eax
movw %ax, 0xc6(%rbx)
movzwl %ax, %eax
cmpl $0xc8, %eax
jb 0x14576
movq 0x10(%rbx), %r14
movslq %edx, %r15
shlq $0x4, %r15
movq %r14, %r12
subq %r15, %r12
movq %r12, 0x10(%rbx)
leaq 0x1ec64(%rip), %rsi # 0x33189
jmp 0x14543
movq 0x10(%rbx), %r14
movslq %edx, %r15
shlq $0x4, %r15
movq %r14, %r12
subq %r15, %r12
movq %r12, 0x10(%rbx)
leaq 0x1ec29(%rip), %rsi # 0x3316c
movq %rbx, %rdi
callq 0xa533
movq %rax, (%r12)
movzbl 0x8(%rax), %eax
orl $0x40, %eax
negq %r15
movl %eax, 0x8(%r14,%r15)
addq $0x10, 0x10(%rbx)
movl $0x2, %ebp
jmp 0x1467f
movw $0x1, 0xc6(%rbx)
movw $0x0, 0xc4(%rbx)
leaq 0x10a(%rip), %rsi # 0x14690
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x8e44
movl %eax, (%rsp)
cmpl $-0x1, %eax
je 0x14643
movl %eax, %ebp
cmpl $0x2, %eax
jl 0x14670
leaq 0x18f(%rip), %r12 # 0x14740
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x1464f
testb $0x10, 0x42(%r14)
jne 0x145d0
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x145be
jmp 0x1464a
movq %r12, %r15
movq 0x38(%rbx), %r12
addq 0x38(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1481b
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r15, %r12
movq %rsp, %r15
callq 0x11aca
movq %r14, 0x20(%rbx)
movb 0x42(%r14), %al
andb $0x1, %al
movb %al, 0xcc(%rbx)
movw $0x0, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x11df6
movq 0x28(%r14), %rax
movq %rax, 0xb0(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x8e44
movl %eax, %ebp
movl %eax, (%rsp)
cmpl $0x1, %eax
jg 0x145b1
jmp 0x14670
movl $0x2, %ebp
jmp 0x14670
cmpl $0x2, %ebp
jl 0x14670
movb %bpl, 0xc(%rbx)
movq 0x10(%rbx), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11aca
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl (%rsp), %ebp
movw %r13w, 0xc4(%rbx)
decw 0xc6(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
resume
|
static void resume (lua_State *L, void *ud) {
int n = *(cast(int*, ud)); /* number of arguments */
StkId firstArg = L->top - n; /* first argument */
CallInfo *ci = L->ci;
if (L->status == LUA_OK) { /* starting a coroutine? */
if (!luaD_precall(L, firstArg - 1, LUA_MULTRET)) /* Lua function? */
luaV_execute(L); /* call it */
}
else { /* resuming from previous yield */
lua_assert(L->status == LUA_YIELD);
L->status = LUA_OK; /* mark that it is running (again) */
ci->func = restorestack(L, ci->extra);
if (isLua(ci)) /* yielded inside a hook? */
luaV_execute(L); /* just continue running Lua code */
else { /* 'common' yield */
if (ci->u.c.k != NULL) { /* does it have a continuation function? */
lua_unlock(L);
n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
lua_lock(L);
api_checknelems(L, n);
firstArg = L->top - n; /* yield results come from continuation */
}
luaD_poscall(L, ci, firstArg, n); /* finish 'luaD_precall' */
}
unroll(L, NULL); /* run continuation */
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rsi), %rcx
movq %rcx, %rax
shlq $0x4, %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
cmpb $0x0, 0xc(%rdi)
je 0x146fb
movq 0x20(%rbx), %r14
movb $0x0, 0xc(%rbx)
movq 0x38(%rbx), %rax
addq 0x38(%r14), %rax
movq %rax, (%r14)
testb $0x2, 0x42(%r14)
jne 0x1471b
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x146ee
movq 0x30(%r14), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq *%rax
movl %eax, %ecx
movq 0x10(%rbx), %rdx
cltq
shlq $0x4, %rax
subq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11f68
jmp 0x14723
addq $-0x10, %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x121bf
testl %eax, %eax
je 0x14731
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x12589
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14740
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12589
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
separatetobefnz
|
static void separatetobefnz (global_State *g, int all) {
GCObject *curr;
GCObject **p = &g->finobj;
GCObject **lastnext = findlast(&g->tobefnz);
while ((curr = *p) != NULL) { /* traverse all finalizable objects */
lua_assert(tofinalize(curr));
if (!(iswhite(curr) || all)) /* not being collected? */
p = &curr->next; /* don't bother with it */
else {
*p = curr->next; /* remove 'curr' from 'finobj' list */
curr->next = *lastnext; /* link at the end of 'tobefnz' list */
*lastnext = curr;
lastnext = &curr->next;
}
}
}
|
leaq 0x98(%rdi), %rcx
movq %rcx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x152ca
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0x1530d
addq $0x68, %rdi
testl %esi, %esi
jne 0x152f3
movb 0x9(%rcx), %dl
andb $0x3, %dl
jne 0x152f3
movq %rcx, %rdi
jmp 0x15305
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq (%rax), %rdx
movq %rdx, (%rcx)
movq %rcx, (%rax)
movq %rcx, %rax
movq (%rdi), %rcx
testq %rcx, %rcx
jne 0x152e2
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaopen_package
|
LUAMOD_API int luaopen_package (lua_State *L) {
createclibstable(L);
luaL_newlib(L, pk_funcs); /* create 'package' table */
createsearcherstable(L);
/* set paths */
setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
/* store config information */
lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
lua_setfield(L, -2, "config");
/* set field 'loaded' */
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
lua_setfield(L, -2, "loaded");
/* set field 'preload' */
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
lua_setfield(L, -2, "preload");
lua_pushglobaltable(L);
lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */
luaL_setfuncs(L, ll_funcs, 1); /* open lib into global table */
lua_pop(L, 1); /* pop global table */
return 1; /* return 'package' table */
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0xb205
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xb205
movq 0x10(%rbx), %rax
leaq 0x9ad1(%rip), %rcx # 0x2047b
movq %rcx, (%rax)
movl $0x16, 0x8(%rax)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
addq $0x10, %rsi
movq %rsi, 0x10(%rbx)
cmpq $0x0, 0x18(%rax)
jle 0x169d7
movq %rbx, %rdi
callq 0xa125
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
leaq 0x1cb84(%rip), %rdx # 0x33566
movq %rbx, %rdi
callq 0xb6bd
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0xbce1
leaq 0x1c35a(%rip), %rdx # 0x32d58
movq %rbx, %rdi
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0xbc61
movq 0x18(%rbx), %rax
leaq 0x1c022(%rip), %rcx # 0x32a38
cmpq %rcx, 0xd0(%rax)
jne 0x16bc3
movq %rbx, %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0xb205
leaq 0x2ab17(%rip), %rsi # 0x41550
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf213
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0xb205
movl $0x1, %r14d
leaq 0x2b111(%rip), %r15 # 0x41b70
movq 0x10(%rbx), %rax
movups -0x20(%rax), %xmm0
movups %xmm0, (%rax)
addq $0x10, 0x10(%rbx)
movq (%r15), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0xac1c
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0xbb9c
incq %r14
addq $0x8, %r15
cmpq $0x5, %r14
jne 0x16a5f
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
leaq 0x1d621(%rip), %rdx # 0x340cc
movq %rbx, %rdi
callq 0xb6bd
leaq 0x1c85c(%rip), %rsi # 0x33316
leaq 0x1c7b4(%rip), %rdx # 0x33275
leaq 0x1c7b6(%rip), %rcx # 0x3327e
movq %rbx, %rdi
callq 0x16bd4
leaq 0x1c83e(%rip), %rsi # 0x33315
leaq 0x1c83d(%rip), %rdx # 0x3331b
leaq 0x1c840(%rip), %rcx # 0x33325
movq %rbx, %rdi
callq 0x16bd4
leaq 0x1c876(%rip), %rsi # 0x3336a
movq %rbx, %rdi
callq 0xa67f
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
leaq 0x1c86a(%rip), %rdx # 0x33375
movq %rbx, %rdi
callq 0xb6bd
leaq 0x1c4a4(%rip), %rdx # 0x32fbe
movq %rbx, %rdi
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0xf422
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
leaq 0x1c846(%rip), %rdx # 0x3337c
movq %rbx, %rdi
callq 0xb6bd
leaq 0x1c83e(%rip), %rdx # 0x33383
movq %rbx, %rdi
movl $0xfff0b9d8, %esi # imm = 0xFFF0B9D8
callq 0xf422
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
leaq 0x1c82b(%rip), %rdx # 0x3338c
movq %rbx, %rdi
callq 0xb6bd
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %rax
movq 0x40(%rax), %rdi
movl $0x2, %esi
callq 0xae27
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movups -0x10(%rax), %xmm0
movups %xmm0, 0x10(%rax)
addq $0x10, 0x10(%rbx)
leaq 0x2aa2a(%rip), %rsi # 0x415d0
movq %rbx, %rdi
movl $0x1, %edx
callq 0xf213
addq $-0x10, 0x10(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c42d(%rip), %rsi # 0x32ff7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdb8f
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
setpath
|
static void setpath (lua_State *L, const char *fieldname,
const char *envname,
const char *dft) {
const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
const char *path = getenv(nver); /* use versioned name */
if (path == NULL) /* no environment variable? */
path = getenv(envname); /* try unversioned name */
if (path == NULL || noenv(L)) /* no environment variable? */
lua_pushstring(L, dft); /* use default */
else {
/* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
luaL_gsub(L, path, AUXMARK, dft);
lua_remove(L, -2); /* remove result from 1st 'gsub' */
}
setprogdir(L);
lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */
lua_pop(L, 1); /* pop versioned variable name */
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d5d4(%rip), %rsi # 0x341c4
leaq 0x1d5d2(%rip), %rcx # 0x341c9
xorl %eax, %eax
callq 0xab73
movq %rax, %rdi
callq 0x65a0
testq %rax, %rax
jne 0x16c1c
movq %r13, %rdi
callq 0x65a0
testq %rax, %rax
je 0x16cab
movq %rax, %r12
movq 0x18(%rbx), %rsi
addq $0x40, %rsi
leaq 0x1d5a9(%rip), %rdx # 0x341d7
movq %rbx, %rdi
callq 0xad9e
movq 0x10(%rbx), %rax
movl -0x8(%rax), %ecx
addq $-0x10, %rax
cmpl $0x1, %ecx
je 0x16c50
testl %ecx, %ecx
jne 0x16ca7
movq %rax, 0x10(%rbx)
jmp 0x16c59
cmpl $0x0, (%rax)
movq %rax, 0x10(%rbx)
jne 0x16cab
leaq 0x1d56e(%rip), %rdx # 0x341ce
leaq 0x1d56a(%rip), %rcx # 0x341d1
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf5f4
leaq 0x1d55c(%rip), %rdx # 0x341d5
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0xf5f4
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x90c6
movq 0x10(%rbx), %rsi
addq $-0x10, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x16cba
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa67f
movq 0x10(%rbx), %rsi
addq $-0x30, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb6bd
addq $-0x10, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
internshrstr
|
static TString *internshrstr (lua_State *L, const char *str, size_t l) {
TString *ts;
global_State *g = G(L);
unsigned int h = luaS_hash(str, l, g->seed);
TString **list = &g->strt.hash[lmod(h, g->strt.size)];
lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */
for (ts = *list; ts != NULL; ts = ts->u.hnext) {
if (l == ts->shrlen &&
(memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
/* found! */
if (isdead(g, ts)) /* dead (but not collected yet)? */
changewhite(ts); /* resurrect it */
return ts;
}
}
if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
luaS_resize(L, g->strt.size * 2);
list = &g->strt.hash[lmod(h, g->strt.size)]; /* recompute with new size */
}
ts = createstrobj(L, l, LUA_TSHRSTR, h);
memcpy(getstr(ts), str, l * sizeof(char));
ts->shrlen = cast_byte(l);
ts->u.hnext = *list;
*list = ts;
g->strt.nuse++;
return ts;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0x18(%rdi), %r8
movl 0x50(%r8), %r15d
xorl %ebx, %r15d
testq %rdx, %rdx
je 0x179aa
movq %rbx, %rax
shrq $0x5, %rax
movq %rax, %rcx
notq %rcx
movq %rbx, %rdx
movl %r15d, %esi
shll $0x5, %esi
movl %r15d, %edi
shrl $0x2, %edi
addl %esi, %edi
movzbl -0x1(%r14,%rdx), %esi
addl %edi, %esi
xorl %esi, %r15d
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x17989
movq 0x30(%r8), %rcx
movq %r8, (%rsp)
movl 0x3c(%r8), %r13d
leal -0x1(%r13), %eax
andl %r15d, %eax
movslq %eax, %rbp
movq %rcx, 0x10(%rsp)
movq (%rcx,%rbp,8), %r12
testq %r12, %r12
je 0x179f4
movzbl 0xb(%r12), %eax
cmpq %rbx, %rax
jne 0x179ed
leaq 0x18(%r12), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x64d0
testl %eax, %eax
je 0x17a44
movq 0x10(%r12), %r12
jmp 0x179c9
movq 0x10(%rsp), %rax
leaq (%rax,%rbp,8), %rcx
cmpl $0x3fffffff, %r13d # imm = 0x3FFFFFFF
jg 0x17a60
movq (%rsp), %r12
movq %r12, %rbp
cmpl %r13d, 0x38(%r12)
jl 0x17a64
addl %r13d, %r13d
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movl %r13d, %esi
callq 0x17717
movslq 0x3c(%r12), %rax
decq %rax
movslq %r15d, %rcx
andq %rax, %rcx
shlq $0x3, %rcx
addq 0x30(%r12), %rcx
movq 0x18(%rbp), %rbp
jmp 0x17a64
movb 0x9(%r12), %al
xorb $0x3, %al
movq (%rsp), %rcx
movb 0x54(%rcx), %cl
xorb $0x3, %cl
testb %al, %cl
jne 0x17ad5
movb %al, 0x9(%r12)
jmp 0x17ad5
movq (%rsp), %rbp
movq %rcx, %r13
leaq 0x19(%rbx), %rcx
movl $0x4, %edx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x11d07
movq %rax, %r12
movb 0x54(%rbp), %al
andb $0x3, %al
movb %al, 0x9(%r12)
movb $0x4, 0x8(%r12)
movq 0x58(%rbp), %rax
movq %rax, (%r12)
movq %r12, 0x58(%rbp)
movl %r15d, 0xc(%r12)
xorl %eax, %eax
movb %al, 0xa(%r12)
leaq 0x18(%r12), %rdi
movb %al, 0x18(%r12,%rbx)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x63f0
movb %bl, 0xb(%r12)
movq (%r13), %rax
movq %rax, 0x10(%r12)
movq %r12, (%r13)
movq (%rsp), %rax
incl 0x38(%rax)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaH_free
|
void luaH_free (lua_State *L, Table *t) {
if (!isdummy(t))
luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
luaM_freearray(L, t->array, t->sizearray);
luaM_free(L, t);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rsi)
je 0x17c19
movq 0x18(%rbx), %r15
movb 0xb(%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %r12
shlq $0x5, %r12
movq 0x18(%r14), %r13
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq *(%r13)
testq %r15, %r15
cmoveq %r15, %r12
subq %r12, 0x18(%r13)
movq 0x10(%rbx), %r15
movl 0xc(%rbx), %r12d
shlq $0x4, %r12
movq 0x18(%r14), %r13
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq *(%r13)
testq %r15, %r15
cmoveq %r15, %r12
subq %r12, 0x18(%r13)
movq 0x18(%r14), %r14
movq 0x8(%r14), %rdi
movl $0x38, %edx
movq %rbx, %rsi
xorl %ecx, %ecx
callq *(%r14)
addq $-0x38, 0x18(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
luaopen_table
|
LUAMOD_API int luaopen_table (lua_State *L) {
luaL_newlib(L, tab_funcs);
#if defined(LUA_COMPAT_UNPACK)
/* _G.unpack = table.unpack */
lua_getfield(L, -1, "unpack");
lua_setglobal(L, "unpack");
#endif
return 1;
}
|
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x181f4
movq 0x18(%rbx), %rax
leaq 0x1a84d(%rip), %rcx # 0x32a38
cmpq %rcx, 0xd0(%rax)
jne 0x1821b
movq %rbx, %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0xb205
leaq 0x29746(%rip), %rsi # 0x41950
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf213
movl $0x1, %eax
popq %rbx
retq
leaq 0x1add5(%rip), %rsi # 0x32ff7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdb8f
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
newprefile
|
static LStream *newprefile (lua_State *L) {
LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
p->closef = NULL; /* mark file handle as 'closed' */
luaL_setmetatable(L, LUA_FILEHANDLE);
return p;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %esi
callq 0xcec3
movq %rax, %r14
movq $0x0, 0x8(%rax)
movq 0x18(%rbx), %rsi
addq $0x40, %rsi
leaq 0x15ad0(%rip), %rdx # 0x33d6e
movq %rbx, %rdi
callq 0xad9e
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0xbce1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
g_write
|
static int g_write (lua_State *L, FILE *f, int arg) {
int nargs = lua_gettop(L) - arg;
int status = 1;
for (; nargs--; arg++) {
if (lua_type(L, arg) == LUA_TNUMBER) {
/* optimization: could be done exactly as for strings */
int len = lua_isinteger(L, arg)
? fprintf(f, LUA_INTEGER_FMT,
(LUAI_UACINT)lua_tointeger(L, arg))
: fprintf(f, LUA_NUMBER_FMT,
(LUAI_UACNUMBER)lua_tonumber(L, arg));
status = status && (len > 0);
}
else {
size_t l;
const char *s = luaL_checklstring(L, arg, &l);
status = status && (fwrite(s, sizeof(char), l, f) == l);
}
}
if (status) return 1; /* file handle already on stack top */
else return luaL_fileresult(L, status, NULL);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
movq 0x20(%rdi), %rax
subq (%rax), %r12
addq $-0x10, %r12
shrq $0x4, %r12
movl $0x1, %eax
cmpl %edx, %r12d
je 0x1ef2d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %r15d
leaq 0x13bd6(%rip), %r13 # 0x32a40
movq %rbx, %rdi
movl %ebp, %esi
callq 0x916a
cmpq %r13, %rax
je 0x1eead
movl 0x8(%rax), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x3, %ecx
jne 0x1eead
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
cmpl $0x13, %eax
jne 0x1eee5
callq 0x9e85
movq %r14, %rdi
leaq 0x144f3(%rip), %rsi # 0x33394
movq %rax, %rdx
xorl %eax, %eax
callq 0x66a0
jmp 0x1eefb
movq %rbx, %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0xe339
testl %r15d, %r15d
je 0x1eee0
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r14, %rcx
callq 0x6870
xorl %r15d, %r15d
cmpq (%rsp), %rax
sete %r15b
jmp 0x1ef0c
xorl %r15d, %r15d
jmp 0x1ef0c
callq 0x9e2d
movq %r14, %rdi
leaq 0x144a5(%rip), %rsi # 0x33399
movb $0x1, %al
callq 0x66a0
testl %r15d, %r15d
setne %cl
testl %eax, %eax
setg %al
andb %cl, %al
movzbl %al, %r15d
incl %ebp
cmpl %ebp, %r12d
jne 0x1ee6a
movl $0x1, %eax
testl %r15d, %r15d
jne 0x1ef2d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xdf1b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
math_log
|
static int math_log (lua_State *L) {
lua_Number x = luaL_checknumber(L, 1);
lua_Number res;
if (lua_isnoneornil(L, 2))
res = l_mathop(log)(x);
else {
lua_Number base = luaL_checknumber(L, 2);
#if !defined(LUA_USE_C89)
if (base == l_mathop(2.0))
res = l_mathop(log2)(x); else
#endif
if (base == l_mathop(10.0))
res = l_mathop(log10)(x);
else
res = l_mathop(log)(x)/l_mathop(log)(base);
}
lua_pushnumber(L, res);
return 1;
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0xe3e3
movq 0x20(%rbx), %rax
movq (%rax), %rax
leaq 0x20(%rax), %rcx
cmpq 0x10(%rbx), %rcx
setae %dl
leaq 0x12c42(%rip), %rsi # 0x32a40
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x1fe38
testb $0xf, 0x28(%rax)
je 0x1fe38
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0xe3e3
ucomisd 0x12fe8(%rip), %xmm0 # 0x32e10
jne 0x1fe5c
jp 0x1fe5c
movsd (%rsp), %xmm0
callq 0x67c0
jmp 0x1fe3d
callq 0x63d0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
movl $0x3, 0x8(%rax)
addq $0x10, 0x10(%rbx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
movapd %xmm0, %xmm1
ucomisd 0x12fb0(%rip), %xmm0 # 0x32e18
movsd (%rsp), %xmm0
jne 0x1fe78
jp 0x1fe78
callq 0x6290
jmp 0x1fe3d
movsd %xmm1, 0x8(%rsp)
callq 0x63d0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x63d0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x1fe3d
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
searcher_preload
|
static int searcher_preload (lua_State *L) {
const char *name = luaL_checkstring(L, 1);
lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
if (lua_getfield(L, -1, name) == LUA_TNIL) /* not found? */
lua_pushfstring(L, "\n\tno field package.preload['%s']", name);
return 1;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0xe339
movq %rax, %r14
movq 0x18(%rbx), %rsi
addq $0x40, %rsi
leaq 0x12b2d(%rip), %rdx # 0x33383
movq %rbx, %rdi
callq 0xad9e
movq 0x10(%rbx), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xad9e
testl %eax, %eax
jne 0x20889
leaq 0x138b0(%rip), %rsi # 0x3412c
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xab73
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
ll_require
|
static int ll_require (lua_State *L) {
const char *name = luaL_checkstring(L, 1);
lua_settop(L, 1); /* LOADED table will be at index 2 */
lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
lua_getfield(L, 2, name); /* LOADED[name] */
if (lua_toboolean(L, -1)) /* is it there? */
return 1; /* package is already loaded */
/* else must load package */
lua_pop(L, 1); /* remove 'getfield' result */
findloader(L, name);
lua_pushstring(L, name); /* pass name as argument to module loader */
lua_insert(L, -2); /* name is 1st argument (before search data) */
lua_call(L, 2, 1); /* run loader to load module */
if (!lua_isnil(L, -1)) /* non-nil return? */
lua_setfield(L, 2, name); /* LOADED[name] = returned value */
if (lua_getfield(L, 2, name) == LUA_TNIL) { /* module set no value? */
lua_pushboolean(L, 1); /* use true as result */
lua_pushvalue(L, -1); /* extra copy to be returned */
lua_setfield(L, 2, name); /* LOADED[name] = true */
}
return 1;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2028, %rsp # imm = 0x2028
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0xe339
movq %rax, %r14
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq (%rcx), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jae 0x20d14
leaq 0x10(%rax), %rsi
cmpq %rsi, %rcx
cmovaq %rcx, %rsi
movq %rax, %rdx
notq %rdx
addq %rsi, %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
addq $0x38, %rax
xorl %esi, %esi
movdqa 0x113d2(%rip), %xmm1 # 0x32010
movdqa 0x113da(%rip), %xmm2 # 0x32020
movdqa 0x113e2(%rip), %xmm3 # 0x32030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x20ca0
movl $0x0, -0x30(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x20cb6
movl $0x0, -0x20(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x20cf2
movl $0x0, -0x10(%rax)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x20d03
movl $0x0, (%rax)
addq $0x4, %rsi
addq $0x40, %rax
cmpq %rsi, %rdx
jne 0x20c56
movq %rcx, 0x10(%rbx)
movq 0x18(%rbx), %rsi
addq $0x40, %rsi
leaq 0x12297(%rip), %rdx # 0x32fbe
movq %rbx, %rdi
callq 0xad9e
movq 0x20(%rbx), %rax
movq (%rax), %rsi
addq $0x20, %rsi
cmpq 0x10(%rbx), %rsi
leaq 0x11cfb(%rip), %r15 # 0x32a40
cmovaeq %r15, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xad9e
movq 0x10(%rbx), %rax
movl -0x8(%rax), %ecx
testl %ecx, %ecx
je 0x20d72
cmpl $0x1, %ecx
jne 0x20f80
cmpl $0x0, -0x10(%rax)
jne 0x20f80
addq $-0x10, %rax
movq %rax, 0x10(%rbx)
leaq 0x28(%rsp), %rax
movq %rbx, -0x8(%rax)
movq %rax, -0x20(%rax)
movq $0x0, -0x10(%rax)
movq $0x2000, -0x18(%rax) # imm = 0x2000
movq 0x20(%rbx), %rax
movq (%rax), %rax
cmpl $0x16, 0x8(%rax)
je 0x20dba
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
leaq 0x20(%rax), %rax
leaq 0x11c8a(%rip), %r15 # 0x32a40
cmovneq %rax, %r15
leaq 0x1330b(%rip), %rdx # 0x340cc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xad9e
cmpl $0x5, %eax
jne 0x20fcb
movl $0x1, %r12d
leaq 0x11c5e(%rip), %r15 # 0x32a40
leaq 0x8(%rsp), %r13
movq 0x10(%rbx), %rbp
movq 0x20(%rbx), %rax
movq (%rax), %rax
addq $0x30, %rax
cmpq %rbp, %rax
cmovaeq %r15, %rax
movq (%rax), %rdi
movq %r12, %rsi
callq 0xae27
movdqu (%rax), %xmm0
movdqu %xmm0, (%rbp)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
testb $0xf, 0x8(%rax)
je 0x20f97
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa67f
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
incw 0xc4(%rbx)
movq %rbx, %rdi
movl $0x2, %edx
callq 0xbf2f
decw 0xc4(%rbx)
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
cmpq %r15, %rcx
setne %sil
movl -0x18(%rax), %edx
andl $0xf, %edx
cmpl $0x6, %edx
sete %dil
testb %dil, %sil
jne 0x20e9c
addl $-0x5, %edx
cmpl $-0x2, %edx
jae 0x20e84
movq %rcx, 0x10(%rbx)
jmp 0x20e94
addq $-0x10, %rax
movq %rax, 0x10(%rbx)
movq %r13, %rdi
callq 0xe789
incq %r12
jmp 0x20de7
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa67f
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x90c6
movq 0x10(%rbx), %rsi
addq $-0x30, %rsi
incw 0xc4(%rbx)
movq %rbx, %rdi
movl $0x1, %edx
callq 0xbf2f
decw 0xc4(%rbx)
movq 0x10(%rbx), %rax
leaq -0x10(%rax), %rcx
cmpq %r15, %rcx
je 0x20eef
testb $0xf, -0x8(%rax)
je 0x20f10
movq 0x20(%rbx), %rcx
movq (%rcx), %rsi
addq $0x20, %rsi
cmpq %rax, %rsi
cmovaeq %r15, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb6bd
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq (%rcx), %rsi
addq $0x20, %rsi
cmpq %rax, %rsi
cmovaeq %r15, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xad9e
testl %eax, %eax
jne 0x20f80
movq 0x10(%rbx), %rax
movl $0x1, %ecx
movl %ecx, (%rax)
movl %ecx, 0x8(%rax)
movq 0x10(%rbx), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rbx)
movdqu (%rax), %xmm0
movdqu %xmm0, 0x10(%rax)
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
addq $0x10, %rax
movq %rax, 0x10(%rbx)
movq (%rcx), %rcx
addq $0x20, %rcx
cmpq %rax, %rcx
cmovbq %rcx, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb6bd
movl $0x1, %eax
addq $0x2028, %rsp # imm = 0x2028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
callq 0xe72f
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x9ffc
leaq 0x13252(%rip), %rsi # 0x3420d
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xdb8f
leaq 0x13217(%rip), %rsi # 0x341e9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdb8f
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
os_date
|
static int os_date (lua_State *L) {
size_t slen;
const char *s = luaL_optlstring(L, 1, "%c", &slen);
time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
const char *se = s + slen; /* 's' end */
struct tm tmr, *stm;
if (*s == '!') { /* UTC? */
stm = l_gmtime(&t, &tmr);
s++; /* skip '!' */
}
else
stm = l_localtime(&t, &tmr);
if (stm == NULL) /* invalid date? */
luaL_error(L, "time result cannot be represented in this installation");
if (strcmp(s, "*t") == 0) {
lua_createtable(L, 0, 9); /* 9 = number of fields */
setallfields(L, stm);
}
else {
char cc[4]; /* buffer for individual conversion specifiers */
luaL_Buffer b;
cc[0] = '%';
luaL_buffinit(L, &b);
while (s < se) {
if (*s != '%') /* not a conversion specifier? */
luaL_addchar(&b, *s++);
else {
size_t reslen;
char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
s++; /* skip '%' */
s = checkoption(L, s, se - s, cc + 1); /* copy specifier to 'cc' */
reslen = strftime(buff, SIZETIMEFMT, cc, stm);
luaL_addsize(&b, reslen);
}
}
luaL_pushresult(&b);
}
return 1;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2088, %rsp # imm = 0x2088
movq %rdi, %rbx
leaq 0x131ec(%rip), %rdx # 0x3426a
leaq 0x28(%rsp), %rcx
movl $0x1, %esi
callq 0xe2d2
movq %rax, %r14
movq 0x20(%rbx), %rax
movq (%rax), %rax
leaq 0x20(%rax), %rcx
movq %rbx, 0x8(%rsp)
cmpq 0x10(%rbx), %rcx
setae %dl
leaq 0x11992(%rip), %rsi # 0x32a40
cmpq %rsi, %rcx
sete %cl
orb %dl, %cl
jne 0x210cf
testb $0xf, 0x28(%rax)
je 0x210cf
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0xe462
jmp 0x210d6
xorl %edi, %edi
callq 0x6460
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %r13
addq %r14, %r13
cmpb $0x21, (%r14)
jne 0x21100
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x68a0
movq %rax, %r15
incq %r14
jmp 0x21112
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x62c0
movq %rax, %r15
testq %r15, %r15
je 0x212cc
cmpb $0x2a, (%r14)
jne 0x21133
cmpb $0x74, 0x1(%r14)
jne 0x21133
cmpb $0x0, 0x2(%r14)
je 0x21282
movb $0x25, 0x4(%rsp)
leaq 0x88(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, -0x8(%rax)
movq %rax, -0x20(%rax)
movq $0x0, -0x10(%rax)
movq $0x2000, -0x18(%rax) # imm = 0x2000
cmpq %r13, %r14
jae 0x21261
movq %r13, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movb (%r14), %al
cmpb $0x25, %al
jne 0x211e5
movl $0xfa, %esi
leaq 0x68(%rsp), %rdi
callq 0xe4f9
incq %r14
subq %r14, %r13
testq %r13, %r13
jle 0x212a3
movq %rax, %rbx
movl $0x1, %r15d
movb $0x61, %al
movl $0x1, %r12d
leaq 0x1311b(%rip), %rbp # 0x342c8
cmpb $0x7c, %al
jne 0x211b6
incl %r15d
jmp 0x211c8
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x64d0
testl %eax, %eax
je 0x2121e
movslq %r15d, %r12
movb (%rbp,%r12), %al
testb %al, %al
je 0x212a3
addq %r12, %rbp
cmpq %r12, %r13
jge 0x211ad
jmp 0x212a3
movq 0x78(%rsp), %rcx
cmpq 0x70(%rsp), %rcx
jb 0x21208
movl $0x1, %esi
leaq 0x68(%rsp), %rdi
callq 0xe4f9
movb (%r14), %al
movq 0x78(%rsp), %rcx
incq %r14
movq 0x68(%rsp), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x78(%rsp)
movb %al, (%rdx,%rcx)
jmp 0x21258
leaq 0x5(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x63f0
movb $0x0, 0x5(%rsp,%r12)
addq %r12, %r14
movl $0xfa, %esi
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x63e0
addq %rax, 0x78(%rsp)
movq 0x20(%rsp), %r13
cmpq %r13, %r14
jb 0x21170
leaq 0x68(%rsp), %rdi
callq 0xe72f
movl $0x1, %eax
addq $0x2088, %rsp # imm = 0x2088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x9, %edx
callq 0xb205
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2184a
jmp 0x2126b
leaq 0x1306c(%rip), %rsi # 0x34316
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xab73
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0xdabf
leaq 0x12f9a(%rip), %rsi # 0x3426d
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0xdb8f
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
test_then_block
|
static void test_then_block (LexState *ls, int *escapelist) {
/* test_then_block -> [IF | ELSEIF] cond THEN block */
BlockCnt bl;
FuncState *fs = ls->fs;
expdesc v;
int jf; /* instruction to skip 'then' code (if condition is false) */
luaX_next(ls); /* skip IF or ELSEIF */
expr(ls, &v); /* read condition */
checknext(ls, TK_THEN);
if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */
enterblock(fs, &bl, 0); /* must enter block before 'goto' */
gotostat(ls, v.t); /* handle goto/break */
skipnoopstat(ls); /* skip other no-op statements */
if (block_follow(ls, 0)) { /* 'goto' is the entire block? */
leaveblock(fs);
return; /* and that is it */
}
else /* must skip over 'then' part if condition is false */
jf = luaK_jump(fs);
}
else { /* regular case (not goto/break) */
luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */
enterblock(fs, &bl, 0);
jf = v.f;
}
statlist(ls); /* 'then' part */
leaveblock(fs);
if (ls->t.token == TK_ELSE ||
ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */
luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */
luaK_patchtohere(fs, jf);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rbx
movl 0x4(%rdi), %eax
movl 0x20(%rdi), %ecx
movl %eax, 0x8(%rdi)
leaq 0x10(%rdi), %r13
cmpl $0x121, %ecx # imm = 0x121
jne 0x22be6
leaq 0x18(%r15), %rsi
movq %r15, %rdi
callq 0x15dff
movl %eax, 0x10(%r15)
jmp 0x22bf8
leaq 0x20(%r15), %rax
movups (%rax), %xmm0
movups %xmm0, (%r13)
movl $0x121, (%rax) # imm = 0x121
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x22f3a
movq %r15, %rdi
movl $0x113, %esi # imm = 0x113
callq 0x22d61
movl 0x10(%r15), %eax
orl $0x8, %eax
cmpl $0x10a, %eax # imm = 0x10A
jne 0x22cb0
movq 0x30(%r15), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x107eb
xorl %eax, %eax
leaq 0x20(%rsp), %rcx
movb %al, 0x12(%rcx)
movb 0x3a(%rbx), %dl
movb %dl, 0x10(%rcx)
movq 0x10(%rbx), %rdx
movq 0x58(%rdx), %rdx
movl 0x28(%rdx), %esi
movl %esi, 0x8(%rcx)
movl 0x18(%rdx), %edx
movl %edx, 0xc(%rcx)
movb %al, 0x11(%rcx)
movq 0x18(%rbx), %rax
movq %rax, (%rcx)
movq %rcx, 0x18(%rbx)
movl 0x10(%r12), %esi
movq %r15, %rdi
callq 0x22b15
movl (%r13), %eax
cmpl $0x11f, %eax # imm = 0x11F
jg 0x22c88
cmpl $0x3b, %eax
je 0x22c8f
jmp 0x22c99
cmpl $0x120, %eax # imm = 0x120
jne 0x22cfa
movq %r15, %rdi
callq 0x21e58
jmp 0x22c76
addl $0xfffffefc, %eax # imm = 0xFFFFFEFC
cmpl $0x3, %eax
jae 0x22d01
movq %rbx, %rdi
callq 0x22daa
jmp 0x22d52
movq 0x30(%r15), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x1069b
xorl %eax, %eax
leaq 0x20(%rsp), %rcx
movb %al, 0x12(%rcx)
movb 0x3a(%rbx), %dl
movb %dl, 0x10(%rcx)
movq 0x10(%rbx), %rdx
movq 0x58(%rdx), %rdx
movl 0x28(%rdx), %esi
movl %esi, 0x8(%rcx)
movl 0x18(%rdx), %edx
movl %edx, 0xc(%rcx)
movb %al, 0x11(%rcx)
movq 0x18(%rbx), %rax
movq %rax, (%rcx)
movq %rcx, 0x18(%rbx)
movl 0x14(%r12), %ebp
jmp 0x22d0b
cmpl $0x121, %eax # imm = 0x121
je 0x22ca3
movq %rbx, %rdi
callq 0xfb84
movl %eax, %ebp
movq %r15, %rdi
callq 0x21c52
movq %rbx, %rdi
callq 0x22daa
movl 0x10(%r15), %eax
andl $-0x2, %eax
cmpl $0x104, %eax # imm = 0x104
jne 0x22d3e
movq %rbx, %rdi
callq 0xfb84
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0xfb01
movl 0x20(%rbx), %eax
movl %eax, 0x24(%rbx)
leaq 0x28(%rbx), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0xfb01
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lua53.c
|
LZ4_compress_destSize
|
int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
{
#if (LZ4_HEAPMODE)
LZ4_stream_t* ctx = (LZ4_stream_t*)ALLOCATOR(1, sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
#else
LZ4_stream_t ctxBody;
LZ4_stream_t* ctx = &ctxBody;
#endif
int result = LZ4_compress_destSize_extState(ctx, src, dst, srcSizePtr, targetDstSize);
#if (LZ4_HEAPMODE)
FREEMEM(ctx);
#endif
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4020, %rsp # imm = 0x4020
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq %rsp, %rdi
xorl %ebp, %ebp
movl $0x4020, %edx # imm = 0x4020
xorl %esi, %esi
callq 0x62d0
movl (%r15), %ecx
cmpl $0x7e000000, %ecx # imm = 0x7E000000
ja 0x29427
movl %ecx, %eax
movl $0x80808081, %edx # imm = 0x80808081
imulq %rax, %rdx
shrq $0x27, %rdx
leal (%rcx,%rdx), %ebp
addl $0x10, %ebp
movq %rsp, %rdi
movq %r12, %rsi
movq %r14, %rdx
cmpl %ebx, %ebp
jle 0x2946b
cmpl $0x1000a, %ecx # imm = 0x1000A
jg 0x2944a
movq %r15, %rcx
movl %ebx, %r8d
movl $0x2, %r9d
jmp 0x29456
movq %r15, %rcx
movl %ebx, %r8d
movl $0x1, %r9d
callq 0x2e41c
addq $0x4020, %rsp # imm = 0x4020
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %r8d
movl $0x1, %r9d
callq 0x6b7d
jmp 0x2945b
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
LZ4_renormDictT
|
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, const BYTE* src)
{
if ((LZ4_dict->currentOffset > 0x80000000) ||
((uptrval)LZ4_dict->currentOffset > (uptrval)src)) { /* address space overflow */
/* rescale hash table */
U32 const delta = LZ4_dict->currentOffset - 64 KB;
const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
int i;
for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
else LZ4_dict->hashTable[i] -= delta;
}
LZ4_dict->currentOffset = 64 KB;
if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
}
}
|
movl 0x4000(%rdi), %edx
movl $0x80000001, %eax # imm = 0x80000001
cmpq %rax, %rdx
setb %al
cmpq %rsi, %rdx
setbe %cl
testb %cl, %al
jne 0x2adbe
movq 0x4008(%rdi), %rax
movl 0x4018(%rdi), %ecx
addl $0xffff0000, %edx # imm = 0xFFFF0000
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
xorl %edx, %edx
movdqa 0x72db(%rip), %xmm1 # 0x32030
movdqa %xmm0, %xmm2
pxor %xmm1, %xmm2
movdqu (%rdi,%rdx,4), %xmm3
movdqa %xmm3, %xmm4
pxor %xmm1, %xmm4
pcmpgtd %xmm2, %xmm4
psubd %xmm0, %xmm3
pand %xmm4, %xmm3
movdqu %xmm3, (%rdi,%rdx,4)
addq $0x4, %rdx
cmpq $0x1000, %rdx # imm = 0x1000
jne 0x2ad5d
addq %rcx, %rax
movl $0x10000, 0x4000(%rdi) # imm = 0x10000
movl 0x4018(%rdi), %ecx
cmpl $0x10001, %ecx # imm = 0x10001
jb 0x2adb2
movl $0x10000, 0x4018(%rdi) # imm = 0x10000
movl $0x10000, %ecx # imm = 0x10000
movl %ecx, %ecx
subq %rcx, %rax
movq %rax, 0x4008(%rdi)
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
LZ4_compress_forceExtDict
|
int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int inputSize)
{
LZ4_stream_t_internal* streamPtr = &LZ4_dict->internal_donotuse;
int result;
const BYTE* const dictEnd = streamPtr->dictionary + streamPtr->dictSize;
const BYTE* smallest = dictEnd;
if (smallest > (const BYTE*) source) smallest = (const BYTE*) source;
LZ4_renormDictT(streamPtr, smallest);
result = LZ4_compress_generic(streamPtr, source, dest, inputSize, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
streamPtr->dictionary = (const BYTE*)source;
streamPtr->dictSize = (U32)inputSize;
streamPtr->currentOffset += (U32)inputSize;
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r13
movl 0x4018(%rdi), %esi
addq 0x4008(%rdi), %rsi
cmpq %r13, %rsi
cmovaq %r13, %rsi
movq %rdi, 0x20(%rsp)
callq 0x2ad10
xorl %eax, %eax
cmpl $0x7e000000, %ebp # imm = 0x7E000000
ja 0x2b303
movslq %ebp, %rax
leaq (%rax,%r13), %rcx
movq %rcx, 0x68(%rsp)
movq %rbx, %r8
movq %r13, %r14
movl %ebp, 0x1c(%rsp)
cmpl $0xd, %ebp
movq 0x20(%rsp), %r10
jb 0x2b25d
movl 0x4018(%r10), %edx
movq 0x4008(%r10), %r11
movl 0x4000(%r10), %edi
movabsq $-0x30e4432345000000, %rsi # imm = 0xCF1BBCDCBB000000
movq (%r13), %rcx
imulq %rsi, %rcx
shrq $0x34, %rcx
movl %edi, (%r10,%rcx,4)
movq %rbx, %r8
movq %r13, %r14
cmpl $0xd, 0x1c(%rsp)
je 0x2b25d
movq %rdi, %rsi
addq %r11, %rdx
movq %rdx, 0x70(%rsp)
subq %r13, %rdx
movq %rdx, 0x48(%rsp)
leaq (%rax,%r13), %rcx
addq $-0xc, %rcx
movq %rcx, 0x38(%rsp)
addq %r13, %rax
addq $-0x5, %rax
movq %rax, (%rsp)
movq %rdi, %rcx
negq %rcx
movq %r13, %r15
subq %rdi, %r15
leaq 0x2(%r13), %rax
addq %r13, %rcx
movq %rcx, 0x40(%rsp)
notq %rsi
addq %r13, %rsi
movq %rsi, 0x60(%rsp)
movq %r13, %r14
movq %rbx, %r8
movq %r13, 0x10(%rsp)
movq %rbx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r8, 0x8(%rsp)
leaq 0x1(%r14), %rbp
movq 0x1(%r14), %rdx
movl $0x41, %ecx
movl $0x1, %esi
movq %rax, %rdi
movabsq $-0x30e4432345000000, %rax # imm = 0xCF1BBCDCBB000000
imulq %rax, %rdx
movq %rdx, %r8
shrq $0x34, %r8
movl (%r10,%r8,4), %eax
movq (%rdi), %rdx
movl %ebp, %r9d
subl %r15d, %r9d
movl %r9d, (%r10,%r8,4)
leaq (%r15,%rax), %r8
addq $0xffff, %r8 # imm = 0xFFFF
cmpq %rbp, %r8
jb 0x2af35
leaq (%r15,%rax), %rbx
cmpq %r13, %rbx
movl $0x0, %r12d
cmovbq 0x48(%rsp), %r12
movl (%rbx,%r12), %r8d
cmpl (%rbp), %r8d
je 0x2af55
movl %esi, %eax
addq %rdi, %rax
leal 0x1(%rcx), %r8d
shrl $0x6, %ecx
movl %ecx, %esi
movl %r8d, %ecx
movq %rdi, %rbp
cmpq 0x38(%rsp), %rax
jbe 0x2aedf
jmp 0x2b32a
cmpq %r13, %rbx
cmovbq %r11, %r13
cmpq %r14, %rbp
movq 0x8(%rsp), %r8
jbe 0x2afad
leaq (%rbx,%r12), %rcx
cmpq %r13, %rcx
jbe 0x2afad
leaq (%r12,%rax), %rdx
addq 0x60(%rsp), %rdx
xorl %ecx, %ecx
movb -0x1(%rbp,%rcx), %sil
cmpb (%rdx,%rcx), %sil
jne 0x2afb3
leaq (%rcx,%rbp), %rdi
decq %rdi
leaq -0x1(%rcx), %rsi
cmpq %r14, %rdi
jbe 0x2afa0
addq %rdx, %rcx
cmpq %r13, %rcx
movq %rsi, %rcx
ja 0x2af7a
addq %rsi, %rbp
addq 0x40(%rsp), %rax
addq %rsi, %rax
jmp 0x2afbe
movq (%rsp), %rcx
jmp 0x2afc5
addq %rcx, %rbp
addq 0x40(%rsp), %rax
addq %rcx, %rax
movq (%rsp), %rcx
movq %rax, %rbx
movq %rbp, %rdx
subq %r14, %rdx
leaq 0x1(%r8), %rdi
cmpl $0xf, %edx
jb 0x2b05f
leal -0xf(%rdx), %eax
movb $-0x10, (%r8)
cmpl $0xff, %eax
jl 0x2b058
movl $0x1fd, %ecx # imm = 0x1FD
cmpl %ecx, %eax
cmovael %ecx, %eax
addl %r14d, %eax
negl %eax
leal (%rax,%rbp), %ecx
addl $0xef, %ecx
movl $0x80808081, %eax # imm = 0x80808081
imulq %rax, %rcx
shrq $0x27, %rcx
movq %rcx, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
leaq 0x1(%rcx), %rdx
movl $0xff, %esi
callq 0x62d0
movq 0x58(%rsp), %rdx
movq 0x8(%rsp), %r8
movq 0x30(%rsp), %r11
movq 0x50(%rsp), %rsi
movl %esi, %eax
shll $0x8, %eax
movl %esi, %ecx
subl %eax, %ecx
leaq (%r8,%rsi), %rdi
addq $0x2, %rdi
movl %ebp, %eax
subl %r14d, %eax
addl %ecx, %eax
addl $0xfffffef2, %eax # imm = 0xFFFFFEF2
movq (%rsp), %rcx
movb %al, (%rdi)
incq %rdi
jmp 0x2b067
movl %edx, %eax
shlb $0x4, %al
movb %al, (%r8)
movl %edx, %edx
addq %rdi, %rdx
movq (%r14), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %r14
cmpq %rdx, %rdi
jb 0x2b06c
movq %r8, 0x8(%rsp)
movq %rbp, %r14
movl %r14d, %eax
subl %ebx, %eax
movq %rdx, %rbp
movw %ax, (%rdx)
cmpq %r11, %r13
je 0x2b0b4
leaq 0x4(%r14), %rdi
addq $0x4, %rbx
movq %rbx, %rsi
movq %rcx, %rdx
callq 0x2e3a5
movl %eax, %ebx
addl $0x4, %eax
addq %rax, %r14
jmp 0x2b0f2
leaq (%rbx,%r12), %rax
movq 0x70(%rsp), %r13
subq %rax, %r13
addq %r14, %r13
cmpq %rcx, %r13
cmovaq %rcx, %r13
leaq 0x4(%r14), %rdi
leaq (%rbx,%r12), %rsi
addq $0x4, %rsi
movq %r13, %rdx
movq %rcx, %r12
callq 0x2e3a5
movl %eax, %ebx
leal 0x4(%rbx), %eax
addq %rax, %r14
cmpq %r13, %r14
je 0x2b21e
movq 0x10(%rsp), %r13
leaq 0x2(%rbp), %r8
movq 0x8(%rsp), %rcx
movb (%rcx), %al
cmpl $0xf, %ebx
movq 0x20(%rsp), %r10
jb 0x2b18b
addb $0xf, %al
movb %al, (%rcx)
leal -0xf(%rbx), %eax
movl $0xffffffff, (%r8) # imm = 0xFFFFFFFF
cmpl $0x3fc, %eax # imm = 0x3FC
jb 0x2b171
leaq 0x6(%rbp), %rdi
addl $0xfffffbf5, %ebx # imm = 0xFFFFFBF5
movq %rbx, %r12
movl $0x80808081, %eax # imm = 0x80808081
imulq %rax, %r12
shrq $0x29, %r12
leal (,%r12,4), %r13d
leaq 0x4(%r13), %rdx
movl $0xff, %esi
callq 0x62d0
movq 0x20(%rsp), %r10
imull $0x3fc, %r12d, %eax # imm = 0x3FC
subl %eax, %ebx
leaq 0x6(,%r13), %r8
addq %rbp, %r8
movq 0x10(%rsp), %r13
movl %ebx, %eax
movzwl %ax, %ecx
imull $0x8081, %ecx, %ecx # imm = 0x8081
shrl $0x17, %ecx
addq %rcx, %r8
incq %r8
addl %eax, %ecx
movb %cl, -0x1(%r8)
jmp 0x2b18f
addb %bl, %al
movb %al, (%rcx)
movq 0x30(%rsp), %r11
cmpq 0x38(%rsp), %r14
ja 0x2b258
leaq -0x2(%r14), %rax
movq -0x2(%r14), %rcx
movabsq $-0x30e4432345000000, %rdx # imm = 0xCF1BBCDCBB000000
imulq %rdx, %rcx
shrq $0x34, %rcx
subl %r15d, %eax
movl %eax, (%r10,%rcx,4)
movq (%r14), %rax
imulq %rdx, %rax
shrq $0x34, %rax
movl (%r10,%rax,4), %ecx
leaq (%r15,%rcx), %rbx
cmpq %r13, %rbx
movl $0x0, %r12d
cmovbq 0x48(%rsp), %r12
cmovbq %r11, %r13
movl %r14d, %edx
subl %r15d, %edx
movl %edx, (%r10,%rax,4)
leaq (%r15,%rcx), %rax
addq $0xffff, %rax # imm = 0xFFFF
cmpq %r14, %rax
jb 0x2b23d
movl (%rbx,%r12), %eax
cmpl (%r14), %eax
jne 0x2b23d
leaq 0x1(%r8), %rdx
movb $0x0, (%r8)
movq %r8, 0x8(%rsp)
movq (%rsp), %rcx
jmp 0x2b087
movq %r14, %rdi
movq 0x10(%rsp), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x2e3a5
addl %eax, %ebx
movl %eax, %eax
addq %rax, %r14
jmp 0x2b0f7
leaq 0x2(%r14), %rax
cmpq 0x38(%rsp), %rax
movq 0x10(%rsp), %r13
movq 0x28(%rsp), %rbx
jbe 0x2aec8
jmp 0x2b25d
movq 0x28(%rsp), %rbx
movq 0x68(%rsp), %r15
subq %r14, %r15
cmpq $0xf, %r15
jb 0x2b2da
leaq -0xf(%r15), %rax
movb $-0x10, (%r8)
leaq 0x1(%r8), %rdi
cmpq $0xff, %rax
jb 0x2b2d3
leaq -0x10e(%r15), %rax
movabsq $-0x7f7f7f7f7f7f7f7f, %rcx # imm = 0x8080808080808081
mulq %rcx
movq %r15, %r12
movq %rbx, %r15
movq %rdx, %rbx
shrq $0x7, %rbx
leaq 0x1(%rbx), %rdx
movl $0xff, %esi
movq %r8, %rbp
callq 0x62d0
movq %rbx, %rax
shlq $0x8, %rax
leaq (%rbx,%rbp), %rdi
addq $0x2, %rdi
subq %rax, %rbx
leaq (%r12,%rbx), %rax
addq $-0x10e, %rax # imm = 0xFEF2
movq %r15, %rbx
movq %r12, %r15
movb %al, (%rdi)
movq %rdi, %r8
jmp 0x2b2e3
movl %r15d, %eax
shlb $0x4, %al
movb %al, (%r8)
incq %r8
movq %r8, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r8, %r14
callq 0x63f0
movq %r14, %rax
addl %r15d, %eax
subl %ebx, %eax
movl 0x1c(%rsp), %ebp
movq 0x20(%rsp), %rcx
movq %r13, 0x4008(%rcx)
movl %ebp, 0x4018(%rcx)
addl %ebp, 0x4000(%rcx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rbx
movq 0x8(%rsp), %r8
jmp 0x2b25d
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
LZ4_decompress_safe_continue
|
int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
{
LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
int result;
if (lz4sd->prefixEnd == (BYTE*)dest) {
result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
endOnInputSize, full, 0,
usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
if (result <= 0) return result;
lz4sd->prefixSize += result;
lz4sd->prefixEnd += result;
} else {
lz4sd->extDictSize = lz4sd->prefixSize;
lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
result = LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
endOnInputSize, full, 0,
usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
if (result <= 0) return result;
lz4sd->prefixSize = result;
lz4sd->prefixEnd = (BYTE*)dest + result;
}
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r9
movq %rsi, %r11
movq %rdi, %r13
movq 0x10(%rdi), %r10
movq 0x18(%rdi), %r15
movslq %ecx, %rsi
addq %r11, %rsi
movslq %r8d, %rdx
addq %r9, %rdx
cmpq %r9, %r10
movq %rdx, 0x78(%rsp)
movq %rsi, 0x80(%rsp)
je 0x2be3a
movq %r15, 0x8(%r13)
movq %r10, %rax
subq %r15, %rax
movq %rax, (%r13)
testl %r8d, %r8d
je 0x2c1c7
movq %r9, %r8
subq %r15, %r8
leaq -0xc(%rdx), %rax
movq %rax, 0x40(%rsp)
leaq -0xf(%rsi), %r14
leaq -0x8(%rsi), %rax
movq %rax, 0x68(%rsp)
leaq -0x5(%rsi), %rax
movq %rax, 0x60(%rsp)
leaq -0x7(%rdx), %rax
movq %rax, 0x48(%rsp)
leaq -0x5(%rdx), %rax
movq %rax, 0x50(%rsp)
movq %r9, %rdi
movq %r11, %r12
leaq 0x1(%r12), %rsi
movzbl (%r12), %eax
movl %eax, %edx
shrl $0x4, %edx
cmpl $0xf, %edx
jne 0x2bb81
addq $0x2, %r12
movl $0xf, %edx
movq %r12, %rcx
movq %rsi, %r12
movzbl (%r12), %esi
incq %r12
addq %rsi, %rdx
incq %rcx
cmpq %r14, %r12
jae 0x2bb68
cmpb $-0x1, %sil
je 0x2bb4f
movq %rdi, %rsi
addq %rdx, %rsi
jb 0x2c1e0
negq %rcx
cmpq %rcx, %rdx
jbe 0x2bb84
jmp 0x2c1e0
movq %rsi, %r12
leaq (%rdi,%rdx), %rbp
leaq (%r12,%rdx), %rcx
cmpq 0x40(%rsp), %rbp
ja 0x2c17d
cmpq 0x68(%rsp), %rcx
ja 0x2c17d
movq (%r12), %rdx
movq %rdx, (%rdi)
addq $0x8, %rdi
addq $0x8, %r12
cmpq %rbp, %rdi
jb 0x2bba2
movzwl (%rcx), %edi
addq $0x2, %rcx
movq %rbp, %rsi
subq %rdi, %rsi
cmpq $0xffff, %r15 # imm = 0xFFFF
movq 0x60(%rsp), %rbx
ja 0x2bbda
cmpq %r8, %rsi
jb 0x2c1dd
movl %edi, (%rbp)
andl $0xf, %eax
cmpq $0xf, %rax
jne 0x2bc17
movl $0xf, %eax
leaq 0x1(%rcx), %r12
cmpq %rbx, %r12
ja 0x2c1e0
movzbl (%rcx), %edx
addq %rdx, %rax
movq %r12, %rcx
cmpq $0xff, %rdx
je 0x2bbeb
movq %rbp, %rcx
addq %rax, %rcx
jae 0x2bc1a
jmp 0x2c1e0
movq %rcx, %r12
leaq 0x4(%rax), %rdx
leaq (%rax,%rbp), %rbx
addq $0x4, %rbx
cmpq %r9, %rsi
jae 0x2bcd9
cmpq 0x50(%rsp), %rbx
ja 0x2c1e0
movq %r8, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r13, 0x30(%rsp)
movq %r9, %r13
subq %rsi, %r13
movq %rdx, %r15
subq %r13, %r15
movq %r9, 0x8(%rsp)
jbe 0x2bd34
movq %rdx, 0x38(%rsp)
movq %r10, 0x10(%rsp)
movq %r10, %rsi
subq %r13, %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x63f0
addq %r13, %rbp
movq %rbp, %rax
movq 0x8(%rsp), %r9
subq %r9, %rax
cmpq %rax, %r15
jbe 0x2bd5c
movq %rbp, %rdi
cmpq %r13, 0x38(%rsp)
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r11
movq 0x10(%rsp), %r10
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r8
jle 0x2bb2c
movq %r9, %rax
movb (%rax), %cl
incq %rax
movb %cl, (%rbp)
incq %rbp
cmpq %rbx, %rbp
jb 0x2bcc1
movq %rbp, %rdi
jmp 0x2bb2c
cmpw $0x7, %di
jbe 0x2bd91
movq (%rsi), %rax
movq %rax, (%rbp)
addq $0x8, %rsi
leaq 0x8(%rbp), %rax
cmpq 0x40(%rsp), %rbx
ja 0x2bde0
movq (%rsi), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
cmpq $0x11, %rdx
jb 0x2bb2c
addq $0x10, %rbp
addq $0x8, %rsi
movq (%rsi), %rax
movq %rax, (%rbp)
addq $0x8, %rbp
addq $0x8, %rsi
cmpq %rbx, %rbp
jb 0x2bd18
movq %rbx, %rdi
jmp 0x2bb2c
movq %r10, %rsi
subq %r13, %rsi
movq %rbp, %rdi
movq %r10, %r15
callq 0x6720
movq %r15, %r10
movq %rbx, %rdi
movq 0x30(%rsp), %r13
movq 0x8(%rsp), %r9
movq 0x28(%rsp), %r11
jmp 0x2bd82
movq %rbp, %rdi
movq %r9, %rsi
movq %r15, %rdx
movq %r9, %r15
callq 0x63f0
movq %r15, %r9
movq %rbx, %rdi
movq 0x30(%rsp), %r13
movq 0x28(%rsp), %r11
movq 0x10(%rsp), %r10
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r8
jmp 0x2bb2c
movq %rdx, 0x38(%rsp)
movq %rbp, %rdx
leaq 0x70(%rsp), %rcx
movq %r9, 0x8(%rsp)
movq %r15, 0x20(%rsp)
movq %r11, %r15
movq %r10, 0x10(%rsp)
movq %r8, 0x18(%rsp)
callq 0x8845
movq 0x38(%rsp), %rdx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r10
movq %r15, %r11
movq 0x20(%rsp), %r15
movq 0x8(%rsp), %r9
movq 0x70(%rsp), %rsi
jmp 0x2bcee
cmpq 0x50(%rsp), %rbx
ja 0x2c1e0
movq 0x48(%rsp), %rbp
cmpq %rbp, %rax
jae 0x2be1a
movq %rsi, %rcx
movq %rax, %rdx
movq (%rcx), %rdi
movq %rdi, (%rdx)
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %rbp, %rdx
jb 0x2bdfb
movq %rbp, %rcx
subq %rax, %rcx
addq %rcx, %rsi
movq %rbp, %rax
movq %rbx, %rdi
cmpq %rbx, %rax
jae 0x2bb2c
movb (%rsi), %cl
incq %rsi
movb %cl, (%rax)
incq %rax
cmpq %rbx, %rax
jb 0x2be26
jmp 0x2bd2c
testl %r8d, %r8d
je 0x2c1c7
subq %r15, %r10
movq 0x8(%r13), %rax
movq %r10, 0x10(%rsp)
subq %rax, %r10
movq %r10, 0x20(%rsp)
movq (%r13), %rcx
movq %rax, 0x60(%rsp)
addq %rax, %rcx
movq %rcx, 0x48(%rsp)
leaq -0xc(%rdx), %rax
movq %rax, 0x40(%rsp)
leaq -0xf(%rsi), %r14
leaq -0x8(%rsi), %rax
movq %rax, 0x68(%rsp)
leaq -0x5(%rsi), %rax
movq %rax, 0x50(%rsp)
leaq -0x7(%rdx), %rax
movq %rax, 0x38(%rsp)
leaq -0x5(%rdx), %rax
movq %rax, 0x18(%rsp)
movq %r9, %rdi
movq %r11, %r12
leaq 0x1(%r12), %rsi
movzbl (%r12), %eax
movl %eax, %edx
shrl $0x4, %edx
cmpl $0xf, %edx
jne 0x2bef9
addq $0x2, %r12
movl $0xf, %edx
movq %r12, %rcx
movq %rsi, %r12
movzbl (%r12), %esi
incq %r12
addq %rsi, %rdx
incq %rcx
cmpq %r14, %r12
jae 0x2bedb
cmpb $-0x1, %sil
je 0x2bec2
movq %rdi, %rsi
addq %rdx, %rsi
movq 0x10(%rsp), %r8
jb 0x2c1fa
negq %rcx
cmpq %rcx, %rdx
jbe 0x2bf01
jmp 0x2c1fa
movq %rsi, %r12
movq 0x10(%rsp), %r8
leaq (%rdi,%rdx), %rbp
leaq (%r12,%rdx), %rcx
cmpq 0x40(%rsp), %rbp
ja 0x2c1a4
cmpq 0x68(%rsp), %rcx
ja 0x2c1a4
movq (%r12), %rdx
movq %rdx, (%rdi)
addq $0x8, %rdi
addq $0x8, %r12
cmpq %rbp, %rdi
jb 0x2bf1f
movzwl (%rcx), %edi
addq $0x2, %rcx
movq %rbp, %rsi
subq %rdi, %rsi
cmpq $0xffff, 0x60(%rsp) # imm = 0xFFFF
movq 0x50(%rsp), %r10
ja 0x2bf5b
cmpq 0x20(%rsp), %rsi
jb 0x2c1f7
movl %edi, (%rbp)
andl $0xf, %eax
cmpq $0xf, %rax
jne 0x2bf98
movl $0xf, %eax
leaq 0x1(%rcx), %r12
cmpq %r10, %r12
ja 0x2c1fa
movzbl (%rcx), %edx
addq %rdx, %rax
movq %r12, %rcx
cmpq $0xff, %rdx
je 0x2bf6c
movq %rbp, %rcx
addq %rax, %rcx
jae 0x2bf9b
jmp 0x2c1fa
movq %rcx, %r12
leaq 0x4(%rax), %rdx
leaq (%rax,%rbp), %r15
addq $0x4, %r15
cmpq %r8, %rsi
jae 0x2c045
cmpq 0x18(%rsp), %r15
ja 0x2c1fa
movq %r11, 0x28(%rsp)
movq %r9, 0x8(%rsp)
movq %r13, 0x30(%rsp)
movq %r8, %r13
subq %rsi, %r13
movq %rdx, %rbx
subq %r13, %rbx
jbe 0x2c0a0
movq %rdx, 0x58(%rsp)
movq 0x48(%rsp), %rsi
subq %r13, %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x63f0
addq %r13, %rbp
movq %rbp, %rax
movq 0x10(%rsp), %rsi
subq %rsi, %rax
cmpq %rax, %rbx
jbe 0x2c0b2
movq %rbp, %rdi
cmpq %r13, 0x58(%rsp)
movq 0x30(%rsp), %r13
movq 0x8(%rsp), %r9
movq 0x28(%rsp), %r11
jle 0x2be9f
movq 0x10(%rsp), %rax
movb (%rax), %cl
incq %rax
movb %cl, (%rbp)
incq %rbp
cmpq %r15, %rbp
jb 0x2c02d
movq %rbp, %rdi
jmp 0x2be9f
cmpw $0x7, %di
jbe 0x2c0d4
movq (%rsi), %rax
movq %rax, (%rbp)
addq $0x8, %rsi
leaq 0x8(%rbp), %rax
cmpq 0x40(%rsp), %r15
ja 0x2c105
movq (%rsi), %rcx
movq %rcx, (%rax)
movq %r15, %rdi
cmpq $0x11, %rdx
jb 0x2be9f
addq $0x10, %rbp
addq $0x8, %rsi
movq (%rsi), %rax
movq %rax, (%rbp)
addq $0x8, %rbp
addq $0x8, %rsi
cmpq %r15, %rbp
jb 0x2c084
movq %r15, %rdi
jmp 0x2be9f
movq 0x48(%rsp), %rsi
subq %r13, %rsi
movq %rbp, %rdi
callq 0x6720
jmp 0x2c0bd
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x63f0
movq %r15, %rdi
movq 0x30(%rsp), %r13
movq 0x8(%rsp), %r9
movq 0x28(%rsp), %r11
jmp 0x2be9f
movq %rdx, 0x58(%rsp)
movq %rbp, %rdx
leaq 0x70(%rsp), %rcx
movq %r9, 0x8(%rsp)
movq %r11, %rbx
callq 0x888a
movq 0x58(%rsp), %rdx
movq %rbx, %r11
movq 0x8(%rsp), %r9
movq 0x70(%rsp), %rsi
jmp 0x2c05a
movq %r11, %rbx
movq %r13, %r8
cmpq 0x18(%rsp), %r15
ja 0x2c229
movq %r9, %r10
movq 0x38(%rsp), %r9
cmpq %r9, %rax
jae 0x2c148
movq %rsi, %rcx
movq %rax, %rdx
movq (%rcx), %rdi
movq %rdi, (%rdx)
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %r9, %rdx
jb 0x2c129
movq %r9, %rcx
subq %rax, %rcx
addq %rcx, %rsi
movq %r9, %rax
movq %r15, %rdi
cmpq %r15, %rax
movq %r8, %r13
movq %r10, %r9
movq %rbx, %r11
jae 0x2be9f
movb (%rsi), %cl
incq %rsi
movb %cl, (%rax)
incq %rax
cmpq %r15, %rax
jb 0x2c15d
movq %r15, %rdi
movq %r8, %r13
movq %r10, %r9
movq %rbx, %r11
jmp 0x2be9f
cmpq 0x80(%rsp), %rcx
jne 0x2c1e0
cmpq 0x78(%rsp), %rbp
ja 0x2c1e0
movq %r12, %rsi
movq %r9, %rbx
callq 0x63f0
movq %rbx, %r9
subl %r9d, %ebp
movl %ebp, %r12d
jmp 0x2c1e6
cmpq 0x80(%rsp), %rcx
jne 0x2c1fa
cmpq 0x78(%rsp), %rbp
ja 0x2c1fa
movq %r12, %rsi
movq %r9, %rbx
callq 0x63f0
subl %ebx, %ebp
movl %ebp, %r12d
jmp 0x2c200
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpl $0x1, %ecx
jne 0x2c214
xorl %r12d, %r12d
cmpb (%r11), %r12b
sbbl %r12d, %r12d
jmp 0x2c214
movq %rcx, %r12
notl %r12d
addl %r11d, %r12d
testl %r12d, %r12d
jle 0x2c214
movl %r12d, %eax
movq %rax, 0x18(%r13)
addq %rax, %r9
jmp 0x2c210
movq %rcx, %r12
notl %r12d
addl %r11d, %r12d
testl %r12d, %r12d
jle 0x2c214
movl %r12d, %r9d
addq %r9, 0x18(%r13)
addq 0x10(%r13), %r9
movq %r9, 0x10(%r13)
movl %r12d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r13
movq %rbx, %r11
jmp 0x2c1fa
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
LZ4_decompress_fast_continue
|
int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
{
LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
int result;
if (lz4sd->prefixEnd == (BYTE*)dest) {
result = LZ4_decompress_generic(source, dest, 0, originalSize,
endOnOutputSize, full, 0,
usingExtDict, lz4sd->prefixEnd - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
if (result <= 0) return result;
lz4sd->prefixSize += originalSize;
lz4sd->prefixEnd += originalSize;
} else {
lz4sd->extDictSize = lz4sd->prefixSize;
lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
result = LZ4_decompress_generic(source, dest, 0, originalSize,
endOnOutputSize, full, 0,
usingExtDict, (BYTE*)dest, lz4sd->externalDict, lz4sd->extDictSize);
if (result <= 0) return result;
lz4sd->prefixSize = originalSize;
lz4sd->prefixEnd = (BYTE*)dest + originalSize;
}
return result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbp
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rax
movslq %ecx, %rdx
leaq (%rdx,%rbp), %rbx
cmpq %rbp, %r8
movq %rdi, 0x8(%rsp)
movq %rdx, 0x50(%rsp)
movq %rsi, (%rsp)
movq %rbx, 0x28(%rsp)
je 0x2c4fb
movq %rax, 0x8(%rdi)
movq %r8, %rdx
subq %rax, %rdx
movq %rdx, (%rdi)
testl %ecx, %ecx
je 0x2c7f9
leaq -0xc(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq -0x8(%rbx), %r12
leaq -0x7(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq -0x5(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %rbp, %rdi
movq %rsi, %r14
movq %r8, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movzbl (%r14), %eax
incq %r14
movl %eax, %r15d
shrl $0x4, %r15d
cmpl $0xf, %r15d
jne 0x2c2de
movl $0xf, %r15d
movzbl (%r14), %ecx
incq %r14
addq %rcx, %r15
cmpq $0xff, %rcx
je 0x2c2cb
leaq (%rdi,%r15), %r13
cmpq %r12, %r13
ja 0x2c4d9
movq %r14, %rcx
movq (%rcx), %rdx
movq %rdx, (%rdi)
addq $0x8, %rdi
addq $0x8, %rcx
cmpq %r13, %rdi
jb 0x2c2ee
addq %r15, %r14
addq $0x2, %r14
movzwl -0x2(%r14), %edi
movl %edi, (%r13)
andl $0xf, %eax
cmpq $0xf, %rax
jne 0x2c332
movl $0xf, %eax
movzbl (%r14), %ecx
incq %r14
addq %rcx, %rax
cmpq $0xff, %rcx
je 0x2c31f
movq %r13, %rsi
subq %rdi, %rsi
leaq 0x4(%rax), %rdx
leaq (%rax,%r13), %rbx
addq $0x4, %rbx
cmpq %rbp, %rsi
jae 0x2c3c2
cmpq 0x20(%rsp), %rbx
ja 0x2c7e6
movq %rbp, %r12
subq %rsi, %r12
movq %rdx, %r15
subq %r12, %r15
jbe 0x2c41d
movq %rdx, 0x40(%rsp)
subq %r12, %r8
movq %r13, %rdi
movq %r8, %rsi
movq %r12, %rdx
callq 0x63f0
addq %r12, %r13
movq %r13, %rax
subq %rbp, %rax
cmpq %rax, %r15
jbe 0x2c43d
movq %r13, %rdi
cmpq %r12, 0x40(%rsp)
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r12
jle 0x2c2b1
movq %rbp, %rax
movb (%rax), %cl
incq %rax
movb %cl, (%r13)
incq %r13
cmpq %rbx, %r13
jb 0x2c3a9
movq %r13, %rdi
jmp 0x2c2b1
cmpw $0x7, %di
jbe 0x2c45d
movq (%rsi), %rax
movq %rax, (%r13)
addq $0x8, %rsi
leaq 0x8(%r13), %rax
cmpq 0x30(%rsp), %rbx
ja 0x2c47f
movq (%rsi), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
cmpq $0x11, %rdx
jb 0x2c2b1
addq $0x10, %r13
addq $0x8, %rsi
movq (%rsi), %rax
movq %rax, (%r13)
addq $0x8, %r13
addq $0x8, %rsi
cmpq %rbx, %r13
jb 0x2c401
movq %rbx, %rdi
jmp 0x2c2b1
subq %r12, %r8
movq %r13, %rdi
movq %r8, %rsi
callq 0x6720
movq 0x18(%rsp), %r8
movq %rbx, %rdi
movq 0x10(%rsp), %r12
jmp 0x2c2b1
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x63f0
movq %rbx, %rdi
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r12
jmp 0x2c2b1
movq %rdx, %r15
movq %r13, %rdx
leaq 0x48(%rsp), %rcx
callq 0x88cf
movq %r15, %rdx
movq 0x18(%rsp), %r8
movq 0x48(%rsp), %rsi
jmp 0x2c3d7
cmpq 0x20(%rsp), %rbx
ja 0x2c7e6
movq 0x38(%rsp), %r9
cmpq %r9, %rax
jae 0x2c4b9
movq %rsi, %rcx
movq %rax, %rdx
movq (%rcx), %rdi
movq %rdi, (%rdx)
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %r9, %rdx
jb 0x2c49a
movq %r9, %rcx
subq %rax, %rcx
addq %rcx, %rsi
movq %r9, %rax
movq %rbx, %rdi
cmpq %rbx, %rax
jae 0x2c2b1
movb (%rsi), %cl
incq %rsi
movb %cl, (%rax)
incq %rax
cmpq %rbx, %rax
jb 0x2c4c5
jmp 0x2c415
movq 0x28(%rsp), %rbx
cmpq %rbx, %r13
je 0x2c770
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
notl %r14d
addl %eax, %r14d
jmp 0x2c787
testl %ecx, %ecx
je 0x2c80c
subq %rax, %r8
movq (%rdi), %rax
addq 0x8(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq -0xc(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq -0x8(%rbx), %r12
leaq -0x7(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq -0x5(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %rsi, %r14
movq %r12, 0x10(%rsp)
movzbl (%r14), %eax
incq %r14
movl %eax, %r15d
shrl $0x4, %r15d
cmpl $0xf, %r15d
jne 0x2c566
movl $0xf, %r15d
movzbl (%r14), %ecx
incq %r14
addq %rcx, %r15
cmpq $0xff, %rcx
je 0x2c553
leaq (%r15,%rbp), %r13
cmpq %r12, %r13
ja 0x2c758
movq %r14, %rcx
movq (%rcx), %rdx
movq %rdx, (%rbp)
addq $0x8, %rbp
addq $0x8, %rcx
cmpq %r13, %rbp
jb 0x2c576
addq %r15, %r14
addq $0x2, %r14
movzwl -0x2(%r14), %edi
movl %edi, (%r13)
andl $0xf, %eax
cmpq $0xf, %rax
jne 0x2c5bb
movl $0xf, %eax
movzbl (%r14), %ecx
incq %r14
addq %rcx, %rax
cmpq $0xff, %rcx
je 0x2c5a8
movq %r13, %rsi
subq %rdi, %rsi
leaq 0x4(%rax), %rdx
leaq (%rax,%r13), %r15
addq $0x4, %r15
cmpq %r8, %rsi
jae 0x2c64e
cmpq 0x20(%rsp), %r15
ja 0x2c75f
movq %r8, %r12
subq %rsi, %r12
movq %rdx, %rbx
subq %r12, %rbx
movq %r8, %rbp
jbe 0x2c6a9
movq %rdx, 0x40(%rsp)
movq 0x30(%rsp), %rsi
subq %r12, %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x63f0
addq %r12, %r13
movq %r13, %rax
subq %rbp, %rax
cmpq %rax, %rbx
movq %rbp, %r8
jbe 0x2c6be
movq %r13, %rbp
cmpq %r12, 0x40(%rsp)
movq 0x10(%rsp), %r12
jle 0x2c539
movq %r8, %rax
movb (%rax), %cl
incq %rax
movb %cl, (%r13)
incq %r13
cmpq %r15, %r13
jb 0x2c635
movq %r13, %rbp
jmp 0x2c539
cmpw $0x7, %di
jbe 0x2c6df
movq (%rsi), %rax
movq %rax, (%r13)
addq $0x8, %rsi
leaq 0x8(%r13), %rax
cmpq 0x18(%rsp), %r15
ja 0x2c702
movq (%rsi), %rcx
movq %rcx, (%rax)
movq %r15, %rbp
cmpq $0x11, %rdx
jb 0x2c539
addq $0x10, %r13
addq $0x8, %rsi
movq (%rsi), %rax
movq %rax, (%r13)
addq $0x8, %r13
addq $0x8, %rsi
cmpq %r15, %r13
jb 0x2c68d
movq %r15, %rbp
jmp 0x2c539
movq 0x30(%rsp), %rsi
subq %r12, %rsi
movq %r13, %rdi
callq 0x6720
movq %rbp, %r8
jmp 0x2c6d2
movq %r13, %rdi
movq %r8, %rsi
movq %rbx, %rdx
movq %r8, %rbx
callq 0x63f0
movq %rbx, %r8
movq %r15, %rbp
movq 0x10(%rsp), %r12
jmp 0x2c539
movq %rdx, %rbp
movq %r13, %rdx
leaq 0x48(%rsp), %rcx
movq %r8, %rbx
callq 0x8914
movq %rbp, %rdx
movq %rbx, %r8
movq 0x48(%rsp), %rsi
jmp 0x2c663
cmpq 0x20(%rsp), %r15
ja 0x2c75f
movq 0x38(%rsp), %r9
cmpq %r9, %rax
jae 0x2c738
movq %rsi, %rcx
movq %rax, %rdx
movq (%rcx), %rdi
movq %rdi, (%rdx)
addq $0x8, %rdx
addq $0x8, %rcx
cmpq %r9, %rdx
jb 0x2c719
movq %r9, %rcx
subq %rax, %rcx
addq %rcx, %rsi
movq %r9, %rax
movq %r15, %rbp
cmpq %r15, %rax
jae 0x2c539
movb (%rsi), %cl
incq %rsi
movb %cl, (%rax)
incq %rax
cmpq %r15, %rax
jb 0x2c744
jmp 0x2c6a1
cmpq 0x28(%rsp), %r13
je 0x2c797
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
notl %r14d
addl %eax, %r14d
jmp 0x2c7b1
movq %r14, %rsi
movq %r15, %rdx
callq 0x63f0
addl %r15d, %r14d
subl (%rsp), %r14d
movq 0x8(%rsp), %rdi
testl %r14d, %r14d
jle 0x2c7d4
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rdi)
jmp 0x2c7d0
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x63f0
addl %r15d, %r14d
subl (%rsp), %r14d
movq 0x8(%rsp), %rdi
testl %r14d, %r14d
jle 0x2c7d4
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rax
movq 0x50(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rdi)
addq %rcx, %r8
movq %r8, %rbx
movq %rbx, 0x10(%rdi)
movl %r14d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x28(%rsp), %rbx
jmp 0x2c4f0
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpb $0x0, (%rsi)
jne 0x2c7d4
movl $0x1, %r14d
jmp 0x2c78c
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpb $0x0, (%rsi)
jne 0x2c7d4
movl $0x1, %r14d
jmp 0x2c7be
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
LZ4_count
|
static unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
{
const BYTE* const pStart = pIn;
while (likely(pIn<pInLimit-(STEPSIZE-1))) {
reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
pIn += LZ4_NbCommonBytes(diff);
return (unsigned)(pIn - pStart);
}
if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
return (unsigned)(pIn - pStart);
}
|
leaq -0x7(%rdx), %rcx
movq %rdi, %rax
cmpq %rdi, %rcx
jbe 0x2e3c9
movq (%rsi), %r8
movq (%rax), %r9
cmpq %r9, %r8
jne 0x2e40c
addq $0x8, %rax
addq $0x8, %rsi
cmpq %rcx, %rax
jb 0x2e3b1
leaq -0x3(%rdx), %rcx
cmpq %rcx, %rax
jae 0x2e3e0
movl (%rsi), %ecx
cmpl (%rax), %ecx
jne 0x2e3e0
addq $0x4, %rax
addq $0x4, %rsi
leaq -0x1(%rdx), %rcx
cmpq %rcx, %rax
jae 0x2e3f9
movzwl (%rsi), %ecx
cmpw (%rax), %cx
jne 0x2e3f9
addq $0x2, %rax
addq $0x2, %rsi
cmpq %rdx, %rax
jae 0x2e419
movb (%rsi), %cl
xorl %edx, %edx
cmpb (%rax), %cl
sete %dl
addq %rdx, %rax
jmp 0x2e419
xorq %r8, %r9
bsfq %r9, %rcx
shrl $0x3, %ecx
addq %rcx, %rax
subl %edi, %eax
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/lz4.c
|
main
|
int main(int argc, char **argv) {
lua_State *L = luaL_newstate();
margc = argc; margv = argv;
px_register_args(L, argc, argv);
luaL_openlibs(L);
luaL_requiref(L, "pixl", px_lua_open, 1);
lua_getglobal(L, "debug"); lua_getfield(L, -1, "traceback"); lua_remove(L, -2);
lua_pushcfunction(L, px_lua_init);
if (lua_pcall(L, 0, 0, -2) != LUA_OK) {
const char *message = luaL_gsub(L, lua_tostring(L, -1), "\t", " ");
if (audio_device) SDL_PauseAudioDevice(audio_device, SDL_TRUE);
#ifndef _WIN32
fprintf(stderr, "=[ PiXL Panic ]=\n%s\n", message);
#endif // _WIN32
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "PiXL Panic", message, window);
}
lua_close(L);
px_shutdown();
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0xf6df
movq %rax, %rbx
movl %ebp, 0x13aa1(%rip) # 0x424ec
movq %r14, 0x13a9e(%rip) # 0x424f0
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb205
testl %ebp, %ebp
jle 0x2ea8c
movl %ebp, %r12d
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0xa67f
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0xbb9c
incq %r15
cmpq %r15, %r12
jne 0x2ea68
leaq 0x5164(%rip), %rsi # 0x33bf7
movq %rbx, %rdi
callq 0xb68f
movq %rbx, %rdi
callq 0x15994
leaq 0x6946(%rip), %rsi # 0x353f0
leaq 0xef(%rip), %rdx # 0x2eba0
movq %rbx, %rdi
movl $0x1, %ecx
callq 0xf4bc
leaq 0x500b(%rip), %rsi # 0x33ad0
movq %rbx, %rdi
callq 0xad70
leaq 0x507e(%rip), %rdx # 0x33b52
movq %rbx, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xb09f
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x90c6
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x8f61
leaq 0x11a(%rip), %rsi # 0x2ec21
movq %rbx, %rdi
xorl %edx, %edx
callq 0xac1c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xbfaa
testl %eax, %eax
jne 0x2eb96
movq %rbx, %rdi
callq 0x17646
movl 0x139ae(%rip), %edi # 0x424e8
testl %edi, %edi
je 0x2eb43
callq 0x6240
movq 0x13996(%rip), %rdi # 0x424e0
testq %rdi, %rdi
je 0x2eb54
callq 0x6370
movq 0x1397d(%rip), %rdi # 0x424d8
testq %rdi, %rdi
je 0x2eb65
callq 0x6230
movq 0x13964(%rip), %rdi # 0x424d0
testq %rdi, %rdi
je 0x2eb76
callq 0x6030
callq 0x60b0
movl 0x113fcb(%rip), %edi # 0x142b4c
cmpl $-0x1, %edi
je 0x2eb8b
callq 0x6880
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x8c50
jmp 0x2eb2c
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
|
px_lua_open
|
static int px_lua_open(lua_State *L) {
luaL_newlib(L, px_functions);
lua_pushstring(L, PX_AUTHOR); lua_setfield(L, -2, "_author");
lua_pushinteger(L, PX_VERSION); lua_setfield(L, -2, "_version");
return 1;
}
|
pushq %rbx
movq %rdi, %rbx
movsd 0x423c(%rip), %xmm0 # 0x32de8
movl $0x88, %esi
callq 0xf920
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1d, %edx
callq 0xb205
leaq 0x13014(%rip), %rsi # 0x41be0
movq %rbx, %rdi
xorl %edx, %edx
callq 0xf213
leaq 0x683d(%rip), %rsi # 0x3541a
movq %rbx, %rdi
callq 0xa67f
leaq 0x685b(%rip), %rdx # 0x35447
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0xb9f7
movl $0x212, %esi # imm = 0x212
movq %rbx, %rdi
callq 0xa4be
leaq 0x6842(%rip), %rdx # 0x3544f
movq %rbx, %rdi
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0xb9f7
movl $0x1, %eax
popq %rbx
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
|
px_lua_init
|
static int px_lua_init(lua_State *L) {
SDL_AudioSpec want, have;
int i, flags;
const char *str;
// setup some hints
str = px_check_arg("-video");
if (str) SDL_SetHint(SDL_HINT_RENDER_DRIVER, str);
// check for fullscreen
if (px_check_parm("-window")) { fullscreen = SDL_FALSE; flags = SDL_WINDOW_RESIZABLE; }
else { fullscreen = SDL_TRUE; flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_FULLSCREEN_DESKTOP; }
// init network
net_initialize(L);
// init SDL
if (SDL_Init(SDL_INIT_EVERYTHING)) luaL_error(L, "SDL_Init() failed: %s", SDL_GetError());
// create window + texture
window = SDL_CreateWindow(PX_WINDOW_TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, PX_SCREEN_WIDTH, PX_SCREEN_HEIGHT, flags);
if (!window) luaL_error(L, "SDL_CreateWindow() failed: %s", SDL_GetError());
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (!renderer) luaL_error(L, "SDL_CreateRenderer() failed: %s", SDL_GetError());
px_create_texture(L, PX_SCREEN_WIDTH, PX_SCREEN_HEIGHT);
SDL_ShowCursor(0);
// audio init
if (!px_check_parm("-nosound")) {
SDL_zero(want); SDL_zero(have);
want.callback = px_audio_mixer_callback;
want.channels = 1;
want.format = AUDIO_S8;
want.freq = PX_AUDIO_FREQUENCY;
want.samples = 1024 * 4;
str = px_check_arg("-audio");
audio_device = SDL_OpenAudioDevice(str, SDL_FALSE, &want, &have, 0);
if (have.format != AUDIO_S8) luaL_error(L, "SDL_OpenAudioDevice() didn't provide AUDIO_S8 format");
if (have.channels != 1) luaL_error(L, "SDL_OpenAudioDevice() didn't provide a mono channel");
if (!audio_device) luaL_error(L, "SDL_OpenAudioDevice() failed: %s", SDL_GetError());
mixing_frequency = (float)have.freq;
SDL_PauseAudioDevice(audio_device, SDL_FALSE);
}
// init some stuff
px_randomseed(4096); for (i = 0; i < PX_AUDIO_NOISE; ++i) audio_noise[i] = px_rand() % 8 - 4;
for (i = 0; i < PX_AUDIO_CHANNELS; ++i) SDL_zerop(&channels[i]);
running = SDL_TRUE;
SDL_zero(inputs); SDL_zero(translation);
px_open_controllers(L);
px_randomseed(47 * 1024); // reset prng
// load the Lua script
str = px_check_arg("-file");
if (luaL_loadfile(L, str ? str : "game.lua")) lua_error(L);
lua_call(L, 0, 0);
// run main loop
px_run_main_loop(L);
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x6a04(%rip), %rdi # 0x35640
callq 0x30a2b
testl %eax, %eax
je 0x2ec6d
incl %eax
cmpl 0x1389f(%rip), %eax # 0x424ec
jge 0x2ec6d
movq 0x1389a(%rip), %rcx # 0x424f0
cltq
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
je 0x2ec6d
leaq 0x69df(%rip), %rdi # 0x35647
callq 0x6790
leaq 0x69e5(%rip), %rdi # 0x35659
callq 0x30a2b
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl $0x1021, %eax # imm = 0x1021
movl $0x20, %ebp
cmovel %eax, %ebp
movl %ecx, 0x113eb1(%rip) # 0x142b44
movl $0xffffffff, 0x113eaf(%rip) # imm = 0xFFFFFFFF
movl $0xf231, %edi # imm = 0xF231
callq 0x6440
testl %eax, %eax
je 0x2ecc4
callq 0x6380
leaq 0x69aa(%rip), %rsi # 0x35661
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
leaq 0x69ac(%rip), %rdi # 0x35677
movl $0x2fff0000, %esi # imm = 0x2FFF0000
movl $0x2fff0000, %edx # imm = 0x2FFF0000
movl $0x100, %ecx # imm = 0x100
movl $0xf0, %r8d
movl %ebp, %r9d
callq 0x6070
movq %rax, 0x137e1(%rip) # 0x424d0
testq %rax, %rax
jne 0x2ed14
callq 0x6380
leaq 0x6983(%rip), %rsi # 0x35683
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movq 0x137bc(%rip), %rax # 0x424d0
movq %rax, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl $0x6, %edx
callq 0x6050
movq %rax, 0x137ab(%rip) # 0x424d8
testq %rax, %rax
jne 0x2ed4b
callq 0x6380
leaq 0x6963(%rip), %rsi # 0x356a1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movq %rbx, %rdi
movl $0x100, %esi # imm = 0x100
movl $0xf0, %edx
callq 0x308c5
xorl %edi, %edi
callq 0x6890
leaq 0x6956(%rip), %rdi # 0x356c1
callq 0x30a2b
testl %eax, %eax
jne 0x2ee81
leaq 0x68(%rsp), %r15
xorl %r14d, %r14d
movl $0x20, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x6250
leaq 0x10(%rsp), %rdi
movl $0x20, %edx
xorl %esi, %esi
callq 0x6250
leaq 0x1cd0(%rip), %rax # 0x30a77
movq %rax, 0x10(%r15)
movb $0x1, 0x6(%r15)
movw $0x8008, 0x4(%r15) # imm = 0x8008
movl $0xac44, (%r15) # imm = 0xAC44
movw $0x1000, 0x8(%r15) # imm = 0x1000
leaq 0x68fe(%rip), %rdi # 0x356ca
callq 0x30a2b
testl %eax, %eax
je 0x2edf1
incl %eax
cmpl 0x1370f(%rip), %eax # 0x424ec
jge 0x2edee
movq 0x1370a(%rip), %rcx # 0x424f0
cltq
movq (%rcx,%rax,8), %r14
jmp 0x2edf1
xorl %r14d, %r14d
leaq 0x68(%rsp), %rdx
leaq 0x10(%rsp), %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x65b0
movl %eax, 0x136d7(%rip) # 0x424e8
cmpw $0x8008, 0x4(%r15) # imm = 0x8008
je 0x2ee2b
leaq 0x68b0(%rip), %rsi # 0x356d1
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdb8f
cmpb $0x1, 0x16(%rsp)
je 0x2ee43
leaq 0x68cd(%rip), %rsi # 0x35706
movq %rbx, %rdi
xorl %eax, %eax
callq 0xdb8f
movl 0x1369f(%rip), %edi # 0x424e8
testl %edi, %edi
jne 0x2ee6c
callq 0x6380
leaq 0x68e1(%rip), %rsi # 0x3573a
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movl 0x1367c(%rip), %edi # 0x424e8
cvtsi2ssl 0x10(%rsp), %xmm0
movss %xmm0, 0x113c56(%rip) # 0x142ad0
xorl %esi, %esi
callq 0x6610
movl $0x1000, %eax # imm = 0x1000
movl $0x400, %ecx # imm = 0x400
movl %eax, %edx
shll $0xd, %edx
xorl %eax, %edx
movl %edx, %esi
shrl $0x11, %esi
xorl %edx, %esi
movl %esi, %eax
shll $0x5, %eax
xorl %esi, %eax
decl %ecx
jne 0x2ee8b
xorl %ecx, %ecx
leaq 0x113823(%rip), %rdx # 0x1426d0
movl %eax, %esi
shll $0xd, %esi
xorl %eax, %esi
movl %esi, %edi
shrl $0x11, %edi
xorl %esi, %edi
movl %edi, %eax
shll $0x5, %eax
xorl %edi, %eax
andb $0x7, %dil
addb $-0x4, %dil
movb %dil, (%rcx,%rdx)
incq %rcx
cmpq $0x400, %rcx # imm = 0x400
jne 0x2eead
movl %eax, 0x113c68(%rip) # 0x142b48
xorl %r14d, %r14d
leaq 0x113626(%rip), %r15 # 0x142510
leaq (%r15,%r14), %rdi
movl $0x38, %edx
xorl %esi, %esi
callq 0x6250
addq $0x38, %r14
cmpq $0x1c0, %r14 # imm = 0x1C0
jne 0x2eeea
movl $0x1, 0x113c2f(%rip) # 0x142b40
leaq 0x113bc8(%rip), %r14 # 0x142ae0
movl $0x60, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x6250
leaq 0x1135d2(%rip), %rdi # 0x142500
movl $0x8, %edx
xorl %esi, %esi
callq 0x6250
movq %rbx, %rdi
callq 0x30dfb
movl $0xbc00, %ecx # imm = 0xBC00
movl $0x400, %eax # imm = 0x400
movl %ecx, %edx
shll $0xd, %edx
xorl %ecx, %edx
movl %edx, %esi
shrl $0x11, %esi
xorl %edx, %esi
movl %esi, %ecx
shll $0x5, %ecx
xorl %esi, %ecx
decl %eax
jne 0x2ef4c
movl %ecx, 0x113bdd(%rip) # 0x142b48
leaq 0x67e9(%rip), %rdi # 0x3575b
callq 0x30a2b
testl %eax, %eax
je 0x2ef94
incl %eax
cmpl 0x13569(%rip), %eax # 0x424ec
jge 0x2ef94
movq 0x13564(%rip), %rcx # 0x424f0
cltq
movq (%rcx,%rax,8), %rax
jmp 0x2ef96
xorl %eax, %eax
testq %rax, %rax
leaq 0x67c1(%rip), %rsi # 0x35761
cmovneq %rax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe9f0
testl %eax, %eax
je 0x2efba
movq %rbx, %rdi
callq 0xc83a
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbea9
leaq 0x510b(%rip), %rsi # 0x340dd
movq %rbx, %rdi
callq 0xad70
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x2eff2
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbea9
jmp 0x2effc
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x8f61
callq 0x64e0
cmpl $0x0, 0x113b38(%rip) # 0x142b40
je 0x2f5a0
leaq 0x30(%rsp), %r15
leaq 0x6774(%rip), %r12 # 0x3578e
leaq 0x631f(%rip), %rbp # 0x35340
xorl %r13d, %r13d
movl %eax, (%rsp)
movq %r15, %rdi
callq 0x6310
testl %eax, %eax
je 0x2f350
movl 0x30(%rsp), %eax
cmpl $0x400, %eax # imm = 0x400
jg 0x2f06d
leal -0x300(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2f09f
cmpl $0x100, %eax # imm = 0x100
je 0x2f1ad
cmpl $0x400, %eax # imm = 0x400
jne 0x2f027
movq 0x44(%rsp), %rax
movq %rax, 0x113a79(%rip) # 0x142ae4
jmp 0x2f027
leal -0x401(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2f16f
leal -0x651(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2f10c
addl $0xfffff9ad, %eax # imm = 0xFFFFF9AD
cmpl $0x2, %eax
jae 0x2f027
movq %rbx, %rdi
callq 0x30dfb
jmp 0x2f027
movl 0x44(%rsp), %ecx
cmpl $0x300, %eax # imm = 0x300
jne 0x2f0db
cmpl $0x78, %ecx
jle 0x2f188
leal -0x4000004f(%rcx), %eax
cmpl $0x3, %eax
ja 0x2f22c
leaq 0x5cd7(%rip), %rcx # 0x34da0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movw $0x20, %ax
jmp 0x2f326
cmpl $0x77, %ecx
jle 0x2f1bc
leal -0x4000004f(%rcx), %eax
cmpl $0x3, %eax
ja 0x2f21b
leaq 0x5c96(%rip), %rcx # 0x34d90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movw $0xffdf, %ax # imm = 0xFFDF
jmp 0x2f304
movzbl 0x3c(%rsp), %ecx
cmpw $0xe, %cx
ja 0x2f027
movl $0x784f, %edx # imm = 0x784F
btl %ecx, %edx
jae 0x2f027
movl 0x38(%rsp), %esi
cmpq $0x7, %rsi
ja 0x2f027
movzwl %cx, %ecx
leaq 0x623f(%rip), %rdx # 0x35380
movb (%rdx,%rcx,2), %cl
movl $0x1, %edx
shll %cl, %edx
leaq (%rsi,%rsi,2), %rcx
leaq (%r14,%rcx,4), %rcx
movzwl (%rcx), %esi
cmpl $0x651, %eax # imm = 0x651
jne 0x2f344
orl %edx, %esi
movw %si, (%rcx)
orw %dx, 0x2(%rcx)
jmp 0x2f027
movzbl 0x40(%rsp), %ecx
cmpl $0x1, %ecx
je 0x2f1dc
cmpl $0x3, %ecx
jne 0x2f027
movw $0x1, %cx
jmp 0x2f1de
cmpl $0x60, %ecx
jg 0x2f23d
cmpl $0xd, %ecx
je 0x2f1a4
cmpl $0x1b, %ecx
je 0x2f1ad
cmpl $0x20, %ecx
jne 0x2f027
movw $0x100, %ax # imm = 0x100
jmp 0x2f326
movl $0x0, 0x113989(%rip) # 0x142b40
jmp 0x2f027
cmpl $0x60, %ecx
jg 0x2f265
cmpl $0xd, %ecx
je 0x2f1d3
cmpl $0x20, %ecx
jne 0x2f027
movw $0xfeff, %ax # imm = 0xFEFF
jmp 0x2f304
xorl %ecx, %ecx
movl $0x1, %edx
shll %cl, %edx
movzwl 0x1138f4(%rip), %ecx # 0x142ae0
movzwl %dx, %edx
cmpl $0x401, %eax # imm = 0x401
jne 0x2f20b
orl %edx, %ecx
movw %cx, 0x1138e1(%rip) # 0x142ae0
orw %dx, 0x1138dc(%rip) # 0x142ae2
jmp 0x2f027
notl %edx
andl %edx, %ecx
movw %cx, 0x1138ca(%rip) # 0x142ae0
jmp 0x2f027
leal -0x79(%rcx), %eax
cmpl $0x2, %eax
jae 0x2f280
movw $0xfffe, %ax # imm = 0xFFFE
jmp 0x2f304
leal -0x79(%rcx), %eax
cmpl $0x2, %eax
jae 0x2f28f
movw $0x1, %ax
jmp 0x2f326
cmpl $0x61, %ecx
je 0x2f322
movw $0x8, %ax
cmpl $0x73, %ecx
je 0x2f326
cmpl $0x78, %ecx
jne 0x2f027
movw $0x2, %ax
jmp 0x2f326
cmpl $0x61, %ecx
je 0x2f2ee
movw $0xfff7, %ax # imm = 0xFFF7
cmpl $0x73, %ecx
je 0x2f304
jmp 0x2f027
cmpl $0x78, %ecx
jne 0x2f027
movw $0xfffd, %ax # imm = 0xFFFD
jmp 0x2f304
cmpl $0x40000045, %ecx # imm = 0x40000045
jne 0x2f027
xorl %eax, %eax
cmpl $0x0, 0x1138a0(%rip) # 0x142b44
sete %al
movl %eax, 0x113897(%rip) # 0x142b44
movq 0x1321c(%rip), %rdi # 0x424d0
movl $0x0, %esi
movl $0x1001, %eax # imm = 0x1001
cmovel %eax, %esi
callq 0x6540
cmpl $0x0, 0x113877(%rip) # 0x142b44
jne 0x2f027
movq 0x131f6(%rip), %rdi # 0x424d0
movl $0x2fff0000, %esi # imm = 0x2FFF0000
movl $0x2fff0000, %edx # imm = 0x2FFF0000
callq 0x6080
jmp 0x2f027
movw $0xfffb, %ax # imm = 0xFFFB
jmp 0x2f304
movw $0xff7f, %ax # imm = 0xFF7F
jmp 0x2f304
movw $0xffbf, %ax # imm = 0xFFBF
jmp 0x2f304
movw $0xffef, %ax # imm = 0xFFEF
andw %ax, 0x1137d5(%rip) # 0x142ae0
jmp 0x2f027
movw $0x80, %ax
jmp 0x2f326
movw $0x40, %ax
jmp 0x2f326
movw $0x10, %ax
jmp 0x2f326
movw $0x4, %ax
movd %eax, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
por 0x1137a9(%rip), %xmm0 # 0x142ae0
movd %xmm0, 0x1137a1(%rip) # 0x142ae0
jmp 0x2f027
notl %edx
andl %edx, %esi
movw %si, (%rcx)
jmp 0x2f027
callq 0x64e0
subl (%rsp), %r13d
movl %eax, (%rsp)
addl %eax, %r13d
cmpl $0x21, %r13d
jb 0x2f3b2
movq %rbx, %rdi
movq %r12, %rsi
callq 0xad70
movq %rbx, %rdi
cmpl $0x6, %eax
jne 0x2f388
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xbea9
jmp 0x2f392
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
callq 0x8f61
movl $0x2, %eax
movw $0x0, (%rax,%r14)
addq $0xc, %rax
cmpq $0x62, %rax
jne 0x2f397
addl $-0x21, %r13d
cmpl $0x20, %r13d
ja 0x2f365
movq 0x13127(%rip), %rdi # 0x424e0
testq %rdi, %rdi
je 0x2f529
xorl %esi, %esi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
callq 0x65d0
testl %eax, %eax
je 0x2f3f0
callq 0x6380
movq %rbx, %rdi
leaq 0x63f0(%rip), %rsi # 0x357d6
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movl 0x113116(%rip), %esi # 0x14250c
testl %esi, %esi
jle 0x2f474
movl 0x113108(%rip), %edx # 0x142508
leaq 0x130f9(%rip), %rax # 0x42500
xorl %ecx, %ecx
testl %edx, %edx
jle 0x2f466
movl 0x4(%rsp), %edx
imull %ecx, %edx
movslq %edx, %rsi
addq 0x8(%rsp), %rsi
movq %rax, %rdi
xorl %r8d, %r8d
movzbl (%rdi), %edx
andl $0xf, %edx
movb $-0x1, (%rsi,%r8,4)
movb 0x2(%rbp,%rdx,4), %r9b
movb %r9b, 0x1(%rsi,%r8,4)
movb (%rbp,%rdx,4), %r9b
movb 0x1(%rbp,%rdx,4), %dl
movb %dl, 0x2(%rsi,%r8,4)
movb %r9b, 0x3(%rsi,%r8,4)
incq %r8
movslq 0x1130b4(%rip), %rdx # 0x142508
addq $0x400, %rdi # imm = 0x400
cmpq %rdx, %r8
jl 0x2f422
movl 0x1130a6(%rip), %esi # 0x14250c
incq %rcx
movslq %esi, %rdi
incq %rax
cmpq %rdi, %rcx
jl 0x2f409
movq 0x13065(%rip), %rdi # 0x424e0
callq 0x6660
movq 0x13051(%rip), %rdi # 0x424d8
movl $0x10, %esi
movl $0x10, %edx
movl $0x10, %ecx
movl $0xff, %r8d
callq 0x6690
testl %eax, %eax
je 0x2f4be
callq 0x6380
movq %rbx, %rdi
leaq 0x62e1(%rip), %rsi # 0x35795
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movq 0x13013(%rip), %rdi # 0x424d8
callq 0x6480
testl %eax, %eax
je 0x2f4e7
callq 0x6380
movq %rbx, %rdi
leaq 0x62dc(%rip), %rsi # 0x357b9
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movq 0x12fea(%rip), %rdi # 0x424d8
movq 0x12feb(%rip), %rsi # 0x424e0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6520
testl %eax, %eax
je 0x2f51b
callq 0x6380
movq %rbx, %rdi
leaq 0x62e2(%rip), %rsi # 0x357f3
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movq 0x12fb6(%rip), %rdi # 0x424d8
callq 0x60e0
jmp 0x2f590
movq 0x12fa8(%rip), %rdi # 0x424d8
movl $0x40, %esi
movl $0x10, %edx
movl $0x10, %ecx
movl $0xff, %r8d
callq 0x6690
testl %eax, %eax
je 0x2f567
callq 0x6380
movq %rbx, %rdi
leaq 0x6238(%rip), %rsi # 0x35795
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
movq 0x12f6a(%rip), %rdi # 0x424d8
callq 0x6480
testl %eax, %eax
je 0x2f590
callq 0x6380
movq %rbx, %rdi
leaq 0x6233(%rip), %rsi # 0x357b9
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb8f
cmpl $0x0, 0x1135a9(%rip) # 0x142b40
movl (%rsp), %eax
jne 0x2f024
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
|
f_point
|
static int f_point(lua_State *L) {
Uint8 color = (Uint8)luaL_checkinteger(L, 1);
int x0 = (int)luaL_checknumber(L, 2);
int y0 = (int)luaL_checknumber(L, 3);
_pixel(color, x0, y0);
return 0;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0xe462
movq %rax, %rbx
movq %r14, %rdi
movl $0x2, %esi
callq 0xe3e3
cvttsd2si %xmm0, %ebp
movq %r14, %rdi
movl $0x3, %esi
callq 0xe3e3
addl 0x112eef(%rip), %ebp # 0x142500
js 0x2f644
cmpl 0x112eef(%rip), %ebp # 0x142508
jge 0x2f644
cvttsd2si %xmm0, %eax
addl 0x112edf(%rip), %eax # 0x142504
js 0x2f644
cmpl 0x112edf(%rip), %eax # 0x14250c
jge 0x2f644
movl %ebp, %ecx
movl %eax, %eax
shlq $0xa, %rcx
leaq 0x12ec2(%rip), %rdx # 0x42500
addq %rcx, %rdx
movb %bl, (%rax,%rdx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
|
f_fill
|
static int f_fill(lua_State *L) {
Uint8 color = (Uint8)luaL_checkinteger(L, 1);
int x0 = (int)luaL_checknumber(L, 2);
int y0 = (int)luaL_checknumber(L, 3);
int x1 = (int)luaL_checknumber(L, 4);
int y1 = (int)luaL_checknumber(L, 5);
int x, y;
if (x0 > x1) swap(int, x0, x1);
if (y0 > y1) swap(int, y0, y1);
for (y = y0; y <= y1; ++y) {
for (x = x0; x <= x1; ++x) {
_pixel(color, x, y);
}
}
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0xe462
movq %rax, %rbx
movq %r14, %rdi
movl $0x2, %esi
callq 0xe3e3
cvttsd2si %xmm0, %r15d
movq %r14, %rdi
movl $0x3, %esi
callq 0xe3e3
cvttsd2si %xmm0, %r12d
movq %r14, %rdi
movl $0x4, %esi
callq 0xe3e3
cvttsd2si %xmm0, %ebp
movq %r14, %rdi
movl $0x5, %esi
callq 0xe3e3
cvttsd2si %xmm0, %eax
cmpl %ebp, %r15d
movslq %ebp, %r8
cmovll %r15d, %ebp
cmpl %eax, %r12d
movl %eax, %ecx
cmovgl %r12d, %ecx
cmovll %r12d, %eax
movl 0x112e3e(%rip), %edx # 0x142504
movl 0x112e3c(%rip), %esi # 0x142508
movl 0x112e3a(%rip), %edi # 0x14250c
movslq %r15d, %r9
subq %r8, %r9
movq %r9, %r8
negq %r8
cmovsq %r9, %r8
incl %r8d
addl 0x112e15(%rip), %ebp # 0x142500
leaq 0x12e0e(%rip), %r9 # 0x42500
leal (%rdx,%rax), %r10d
movl %ebp, %r11d
movl %r8d, %r14d
testl %r11d, %r11d
js 0x2f71e
cmpl %esi, %r11d
jge 0x2f71e
testl %r10d, %r10d
js 0x2f71e
cmpl %edi, %r10d
jge 0x2f71e
movl %r11d, %r15d
shlq $0xa, %r15
addq %r9, %r15
movb %bl, (%r10,%r15)
incl %r11d
decl %r14d
jne 0x2f6fc
leal 0x1(%rax), %r10d
cmpl %ecx, %eax
movl %r10d, %eax
jne 0x2f6f2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.