LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: switchcase
void
switchcase(struct switchcases *cases, unsigned long long i, struct block *b)
{
	struct switchcase *c;

	c = treeinsert(&cases->root, i, sizeof(*c));
	if (!c->node.new)
		error(&tok.loc, "multiple 'case' labels with same value");
	c->body = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x28, %edx
callq 0x11280
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x1c(%rax)
jne 0x12b3d
leaq 0xf67d(%rip), %rdi      # 0x221a8
addq $0x8, %rdi
leaq 0x9522(%rip), %rsi      # 0x1c058
movb $0x0, %al
callq 0x11190
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: mkblock
struct block *
mkblock(char *name)
{
	static unsigned id;
	struct block *b;

	b = xmalloc(sizeof(*b));
	b->label.kind = VALUE_LABEL;
	b->label.u.name = name;
	b->label.id = ++id;
	b->insts = (struct array){0};
	b->jump.kind = JUMP_NONE;
	b->phi.res.kind = VALUE_NONE;
	b->next = NULL;

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x88, %edi
callq 0x127c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x7, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl 0xf65a(%rip), %ecx      # 0x221e0
addl $0x1, %ecx
movl %ecx, 0xf651(%rip)      # 0x221e0
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3110
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: mkglobal
struct value *
mkglobal(struct decl *d)
{
	static unsigned id;
	struct value *v;

	v = xmalloc(sizeof(*v));
	v->kind = VALUE_GLOBAL;
	if (d->kind == DECLOBJECT && d->u.obj.storage == SDTHREAD)
		v->kind |= VALUE_THREAD;
	if (d->asmname) {
		v->u.name = d->asmname;
		v->id = 0;
	} else {
		v->u.name = d->name;
		v->id = d->linkage == LINKNONE ? ++id : 0;
	}

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x127c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x12c43
movq -0x8(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x12c43
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x10, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x12c6b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
jmp 0x12ca9
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x12c98
movl 0xf55a(%rip), %eax      # 0x221e4
addl $0x1, %eax
movl %eax, 0xf551(%rip)      # 0x221e4
movl %eax, -0x14(%rbp)
jmp 0x12c9f
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x12c9f
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: mkintconst
struct value *
mkintconst(unsigned long long n)
{
	struct value *v;

	v = xmalloc(sizeof(*v));
	v->kind = VALUE_INTCONST;
	v->u.i = n;

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x127c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: delfunc
void
delfunc(struct func *f)
{
	struct block *b;
	struct inst **inst;

	while (b = f->start) {
		f->start = b->next;
		arrayforeach (&b->insts, inst)
			free(*inst);
		free(b->insts.val);
		free(b);
	}
	mapfree(&f->gotos, free);
	free(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x138c8
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
je 0x138b0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3260
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x1387d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3260
movq -0x10(%rbp), %rdi
callq 0x3260
jmp 0x1384c
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq 0xd6e1(%rip), %rsi      # 0x20fb8
callq 0xd100
movq -0x8(%rbp), %rdi
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcjmp
void
funcjmp(struct func *f, struct block *l)
{
	struct block *b = f->end;

	if (!b->jump.kind) {
		b->jump.kind = JUMP_JMP;
		b->jump.blk[0] = l;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x13949
movq -0x18(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x70(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcjnz
void
funcjnz(struct func *f, struct value *v, struct type *t, struct block *l1, struct block *l2)
{
	struct block *b = f->end;

	if (b->jump.kind)
		return;
	if (t) {
		assert(t->prop & PROPSCALAR);
		/*
		Ideally we would just do this conversion unconditionally,
		but QBE is not currently able to optimize the conversion
		away for int.
		*/
		if (t->prop & PROPINT && t->size < 4)
			v = convert(f, &typeint, t, v);
		else if (t->prop & PROPFLOAT || t->size > 4)
			v = convert(f, &typebool, t, v);
	}
	b->jump.kind = JUMP_JNZ;
	b->jump.arg = v;
	b->jump.blk[0] = l1;
	b->jump.blk[1] = l2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x13987
jmp 0x13a63
cmpq $0x0, -0x18(%rbp)
je 0x13a34
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x139a3
jmp 0x139c2
leaq 0x6fda(%rip), %rdi      # 0x1a984
leaq 0x86d7(%rip), %rsi      # 0x1c088
movl $0x252, %edx            # imm = 0x252
leaq 0x86d1(%rip), %rcx      # 0x1c08e
callq 0x30f0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x139fa
movq -0x18(%rbp), %rax
cmpq $0x4, 0x10(%rax)
jae 0x139fa
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xe2b1(%rip), %rsi      # 0x21ca0
callq 0x13a70
movq %rax, -0x10(%rbp)
jmp 0x13a32
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x13a14
movq -0x18(%rbp), %rax
cmpq $0x4, 0x10(%rax)
jbe 0x13a30
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xe069(%rip), %rsi      # 0x21a90
callq 0x13a70
movq %rax, -0x10(%rbp)
jmp 0x13a32
jmp 0x13a34
movq -0x30(%rbp), %rax
movl $0x2, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x78(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcret
void
funcret(struct func *f, struct value *v)
{
	struct block *b = f->end;

	if (!b->jump.kind) {
		b->jump.kind = JUMP_RET;
		b->jump.arg = v;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x13f19
movq -0x18(%rbp), %rax
movl $0x3, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcgoto
struct gotolabel *
funcgoto(struct func *f, char *name)
{
	void **entry;
	struct gotolabel *g;
	struct mapkey key;

	mapkey(&key, name, strlen(name));
	entry = mapput(&f->gotos, &key);
	g = *entry;
	if (!g) {
		g = xmalloc(sizeof(*g));
		g->label = mkblock(name);
		*entry = g;
	}

	return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a0
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
callq 0xcf70
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
leaq -0x38(%rbp), %rsi
callq 0xd190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13fd4
movl $0x10, %edi
callq 0x127c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12b50
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: calcvla
static void
calcvla(struct func *f, struct type *t)
{
	struct value *length, *basesize;

	if (!(t->prop & PROPVM))
		return;
	if (t->base)
		calcvla(f, t->base);
	if (t->kind == TYPEFUNC || t->size)
		return;
	assert(t->kind == TYPEARRAY);
	if (!t->u.array.size) {
		assert(t->base->size || t->base->kind == TYPEARRAY);
		assert(t->u.array.length);
		length = convert(f, &typeulong, t->u.array.length->type, funcexpr(f, t->u.array.length));
		basesize = t->base->size ? mkintconst(t->base->size) : t->base->u.array.size;
		t->u.array.size = funcinst(f, IMUL, 'l', length, basesize);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x153d4
jmp 0x15553
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x153f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x153b0
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
je 0x15404
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x15409
jmp 0x15553
movq -0x10(%rbp), %rax
cmpl $0xd, (%rax)
jne 0x15414
jmp 0x15433
leaq 0x6e0d(%rip), %rdi      # 0x1c228
leaq 0x6c66(%rip), %rsi      # 0x1c088
movl $0x158, %edx            # imm = 0x158
leaq 0x7209(%rip), %rcx      # 0x1c637
callq 0x30f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x15553
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1545e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xd, (%rax)
jne 0x15460
jmp 0x1547f
leaq 0x71fb(%rip), %rdi      # 0x1c662
leaq 0x6c1a(%rip), %rsi      # 0x1c088
movl $0x15a, %edx            # imm = 0x15A
leaq 0x71bd(%rip), %rcx      # 0x1c637
callq 0x30f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1548c
jmp 0x154ab
leaq 0x71fb(%rip), %rdi      # 0x1c68e
leaq 0x6bee(%rip), %rsi      # 0x1c088
movl $0x15b, %edx            # imm = 0x15B
leaq 0x7191(%rip), %rcx      # 0x1c637
callq 0x30f0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x13fe0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0xc8c2(%rip), %rsi      # 0x21da8
callq 0x13a70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x15515
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x12cc0
movq %rax, -0x38(%rbp)
jmp 0x15525
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x5, %esi
movl $0x6c, %edx
callq 0x15860
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcload
static struct value *
funcload(struct func *f, struct type *t, struct lvalue lval)
{
	struct value *v;
	struct qbetype qt;

	switch (t->kind) {
	case TYPESTRUCT:
	case TYPEUNION:
	case TYPEARRAY:
		return lval.addr;
	}
	qt = qbetype(t);
	v = funcinst(f, qt.load, qt.base, lval.addr, NULL);
	return funcbits(f, t, v, lval.bits);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
subl $0xd, %eax
je 0x15595
jmp 0x15588
movl -0x5c(%rbp), %eax
addl $-0xf, %eax
subl $0x1, %eax
ja 0x1559f
jmp 0x15595
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15600
movq -0x28(%rbp), %rdi
callq 0x158f0
movl %edx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x3c(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movl -0x38(%rbp), %esi
movsbl -0x3c(%rbp), %edx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x15860
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x10(%rbp), %ecx
callq 0x17450
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: mkfltconst
static struct value *
mkfltconst(int kind, double n)
{
	struct value *v;

	v = xmalloc(sizeof(*v));
	v->kind = kind;
	v->u.f = n;

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x10, %edi
callq 0x127c0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcinst
static struct value *
funcinst(struct func *f, int op, int class, struct value *arg0, struct value *arg1)
{
	struct inst *inst;
	struct block *b;

	if (f->end->jump.kind) {
		b = mkblock("dead");
		funclabel(f, b);
	}
	inst = mkinst(f, op, class, arg0, arg1);
	arrayaddptr(&f->end->insts, inst);
	return &inst->res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x60(%rax)
je 0x158a5
leaq 0x6e6e(%rip), %rdi      # 0x1c6fd
callq 0x12b50
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x17560
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rsi
callq 0x12950
movq -0x28(%rbp), %rax
addq $0x8, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: zero
static void
zero(struct func *func, struct value *addr, int align, unsigned long long offset, unsigned long long end)
{
	static const enum instkind store[] = {
		[1] = ISTOREB,
		[2] = ISTOREH,
		[4] = ISTOREW,
		[8] = ISTOREL,
	};
	static struct value z = {.kind = VALUE_INTCONST};
	struct value *tmp;
	int a = 1;

	while (offset < end) {
		if ((align - (offset & align - 1)) & a) {
			tmp = offset ? funcinst(func, IADD, ptrclass, addr, mkintconst(offset)) : addr;
			funcinst(func, store[a], 0, &z, tmp);
			offset += a;
		}
		if (a < align)
			a <<= 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x15eed
movslq -0x14(%rbp), %rax
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
andq %rdx, %rcx
subq %rcx, %rax
movslq -0x34(%rbp), %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x15ed8
cmpq $0x0, -0x20(%rbp)
je 0x15e98
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12cc0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rcx
movq %rax, %r8
movl $0x1, %esi
movl $0x6c, %edx
callq 0x15860
movq %rax, -0x40(%rbp)
jmp 0x15ea0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x34(%rbp), %rcx
leaq 0x6169(%rip), %rax      # 0x1c020
movl (%rax,%rcx,4), %esi
movq -0x30(%rbp), %r8
xorl %edx, %edx
leaq 0xc149(%rip), %rcx      # 0x22010
callq 0x15860
movslq -0x34(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15ee8
movl -0x34(%rbp), %eax
shll %eax
movl %eax, -0x34(%rbp)
jmp 0x15e22
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: casesearch
static void
casesearch(struct func *f, int class, struct value *v, struct switchcase *c, struct block *defaultlabel)
{
	struct value *res, *key;
	struct block *label[3];

	if (!c) {
		funcjmp(f, defaultlabel);
		return;
	}
	label[0] = mkblock("switch_ne");
	label[1] = mkblock("switch_lt");
	label[2] = mkblock("switch_gt");

	/* XXX: linear search if c->node.height < 4 */
	key = mkintconst(c->node.key);
	res = funcinst(f, class == 'w' ? ICEQW : ICEQL, 'w', v, key);
	funcjnz(f, res, NULL, c->body, label[0]);
	funclabel(f, label[0]);
	res = funcinst(f, class == 'w' ? ICULTW : ICULTL, 'w', v, key);
	funcjnz(f, res, NULL, label[1], label[2]);
	funclabel(f, label[1]);
	casesearch(f, class, v, c->node.child[0], defaultlabel);
	funclabel(f, label[2]);
	casesearch(f, class, v, c->node.child[1], defaultlabel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15fa4
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13910
jmp 0x160d3
leaq 0x679e(%rip), %rdi      # 0x1c749
callq 0x12b50
movq %rax, -0x50(%rbp)
leaq 0x6798(%rip), %rdi      # 0x1c753
callq 0x12b50
movq %rax, -0x48(%rbp)
leaq 0x6792(%rip), %rdi      # 0x1c75d
callq 0x12b50
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x12cc0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x2a, %esi
movl $0x20, %eax
cmpl $0x77, %ecx
cmovel %eax, %esi
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
movl $0x77, %edx
callq 0x15860
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x50(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x13950
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x13810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x31, %esi
movl $0x27, %eax
cmpl $0x77, %ecx
cmovel %eax, %esi
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %r8
movl $0x77, %edx
callq 0x15860
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0x13950
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x13810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x15f70
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x13810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0x15f70
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: emitclass
static void
emitclass(int class, struct value *v)
{
	if (v && v->kind == VALUE_TYPE)
		emitname(v);
	else if (class)
		putchar(class);
	else
		fatal("type has no QBE representation");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1647a
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x1647a
movq -0x10(%rbp), %rdi
callq 0x164a0
jmp 0x1649a
cmpl $0x0, -0x4(%rbp)
je 0x1648a
movl -0x4(%rbp), %edi
callq 0x3030
jmp 0x16498
leaq 0x62fc(%rip), %rdi      # 0x1c78d
movb $0x0, %al
callq 0x12650
jmp 0x1649a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: emitname
static void
emitname(struct value *v)
{
	static const char sigil[] = {
		[VALUE_TEMP] = '%',
		[VALUE_GLOBAL] = '$',
		[VALUE_TYPE] = ':',
		[VALUE_LABEL] = '@',
	};
	int kind;

	kind = v->kind & 0xf;
	if (kind >= LEN(sigil) || !sigil[kind])
		fatal("invalid value");
	putchar(sigil[kind]);
	if (kind == VALUE_GLOBAL && v->id)
		fputs(".L", stdout);
	if (v->u.name)
		fputs(v->u.name, stdout);
	if (v->id)
		printf(".%u", v->id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x8, %rax
jae 0x164d3
movslq -0xc(%rbp), %rcx
leaq 0x5b77(%rip), %rax      # 0x1c044
cmpb $0x0, (%rax,%rcx)
jne 0x164e1
leaq 0x62d2(%rip), %rdi      # 0x1c7ac
movb $0x0, %al
callq 0x12650
movslq -0xc(%rbp), %rcx
leaq 0x5b58(%rip), %rax      # 0x1c044
movsbl (%rax,%rcx), %edi
callq 0x3030
cmpl $0x1, -0xc(%rbp)
jne 0x1651b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1651b
movq 0xaac4(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x62a4(%rip), %rdi      # 0x1c7ba
callq 0x3100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1653d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0xaa9b(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
callq 0x3100
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1655c
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x6268(%rip), %rdi      # 0x1c7bd
movb $0x0, %al
callq 0x30c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: emitvalue
static void
emitvalue(struct value *v)
{
	switch (v->kind & 0xf) {
	case VALUE_INTCONST:
		printf("%llu", v->u.i);
		break;
	case VALUE_FLTCONST:
		printf("s_%.17g", v->u.f);
		break;
	case VALUE_DBLCONST:
		printf("d_%.17g", v->u.f);
		break;
	case VALUE_GLOBAL:
		if (v->kind & VALUE_THREAD)
			fputs("thread ", stdout);
		/* fallthrough */
	default:
		emitname(v);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xf, %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x1661a
movq -0x10(%rbp), %rax
leaq 0x59cb(%rip), %rcx      # 0x1bf6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x2212(%rip), %rdi      # 0x187cb
movb $0x0, %al
callq 0x30c0
jmp 0x16623
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x61ef(%rip), %rdi      # 0x1c7c1
movb $0x1, %al
callq 0x30c0
jmp 0x16623
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x61de(%rip), %rdi      # 0x1c7c9
movb $0x1, %al
callq 0x30c0
jmp 0x16623
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x16618
movq 0xa9c7(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x5c6a(%rip), %rdi      # 0x1c27d
callq 0x3100
jmp 0x1661a
movq -0x8(%rbp), %rdi
callq 0x164a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: emitjump
static void
emitjump(struct jump *j)
{
	switch (j->kind) {
	case JUMP_NONE:
		break;
	case JUMP_RET:
		fputs("\tret", stdout);
		if (j->arg) {
			fputc(' ', stdout);
			emitvalue(j->arg);
		}
		putchar('\n');
		break;
	case JUMP_JMP:
		fputs("\tjmp ", stdout);
		emitname(&j->blk[0]->label);
		putchar('\n');
		break;
	case JUMP_JNZ:
		fputs("\tjnz ", stdout);
		emitvalue(j->arg);
		fputs(", ", stdout);
		emitname(&j->blk[0]->label);
		fputs(", ", stdout);
		emitname(&j->blk[1]->label);
		putchar('\n');
		break;
	case JUMP_HLT:
		fputs("\thlt\n", stdout);
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x16979
movq -0x10(%rbp), %rax
leaq 0x5721(%rip), %rcx      # 0x1bf7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x16998
movq 0xa760(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x6181(%rip), %rdi      # 0x1c9fb
callq 0x3100
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x168ab
movq 0xa73f(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x3130
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16570
movl $0xa, %edi
callq 0x3030
jmp 0x16998
movq 0xa70f(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x6135(%rip), %rdi      # 0x1ca00
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x164a0
movl $0xa, %edi
callq 0x3030
jmp 0x16998
movq 0xa6dd(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x6109(%rip), %rdi      # 0x1ca06
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16570
movq 0xa6ba(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x59ee(%rip), %rdi      # 0x1c30e
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x164a0
movq 0xa697(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x59cb(%rip), %rdi      # 0x1c30e
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x164a0
movl $0xa, %edi
callq 0x3030
jmp 0x16998
movq 0xa668(%rip), %rax      # 0x20fd0
movq (%rax), %rsi
leaq 0x609a(%rip), %rdi      # 0x1ca0c
callq 0x3100
jmp 0x16998
leaq 0x5b72(%rip), %rdi      # 0x1c4f2
leaq 0x5701(%rip), %rsi      # 0x1c088
movl $0x4f1, %edx            # imm = 0x4F1
leaq 0x607f(%rip), %rcx      # 0x1ca12
callq 0x30f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funccopy
static void
funccopy(struct func *f, struct value *dst, struct value *src, unsigned long long size, int align)
{
	enum instkind load, store;
	int class;
	struct value *tmp, *inc;
	unsigned long long off;

	assert((align & align - 1) == 0);
	class = 'w';
	switch (align) {
	case 1: load = ILOADUB, store = ISTOREB; break;
	case 2: load = ILOADUH, store = ISTOREH; break;
	case 4: load = ILOADW, store = ISTOREW; break;
	default: load = ILOADL, store = ISTOREL, align = 8, class = 'l'; break;
	}
	inc = mkintconst(align);
	off = 0;
	for (;;) {
		tmp = funcinst(f, load, class, src, NULL);
		funcinst(f, store, 0, tmp, dst);
		off += align;
		if (off >= size)
			break;
		src = funcinst(f, IADD, ptrclass, src, inc);
		dst = funcinst(f, IADD, ptrclass, dst, inc);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x1730e
jmp 0x1732d
leaq 0x51c6(%rip), %rdi      # 0x1c4db
leaq 0x4d6c(%rip), %rsi      # 0x1c088
movl $0x1a1, %edx            # imm = 0x1A1
leaq 0x51cc(%rip), %rcx      # 0x1c4f4
callq 0x30f0
movl $0x77, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
subl $0x1, %eax
je 0x17355
jmp 0x17341
movl -0x4c(%rbp), %eax
subl $0x2, %eax
je 0x17365
jmp 0x1734b
movl -0x4c(%rbp), %eax
subl $0x4, %eax
je 0x17375
jmp 0x17385
movl $0x1c, -0x28(%rbp)
movl $0x14, -0x2c(%rbp)
jmp 0x173a1
movl $0x1a, -0x28(%rbp)
movl $0x13, -0x2c(%rbp)
jmp 0x173a1
movl $0x18, -0x28(%rbp)
movl $0x12, -0x2c(%rbp)
jmp 0x173a1
movl $0x17, -0x28(%rbp)
movl $0x11, -0x2c(%rbp)
movl $0x8, -0x24(%rbp)
movl $0x6c, -0x30(%rbp)
movslq -0x24(%rbp), %rdi
callq 0x12cc0
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x30(%rbp), %edx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x15860
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %r8
xorl %edx, %edx
callq 0x15860
movslq -0x24(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x17400
jmp 0x17443
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x1, %esi
movl $0x6c, %edx
callq 0x15860
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %r8
movl $0x1, %esi
movl $0x6c, %edx
callq 0x15860
movq %rax, -0x10(%rbp)
jmp 0x173b6
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: funcbits
static struct value *
funcbits(struct func *f, struct type *t, struct value *v, struct bitfield b)
{
	int class, bits;

	class = t->size <= 4 ? 'w' : 'l';
	bits = b.after;
	if (bits) {
		bits += (t->size + 3 & ~3) - t->size << 3;
		v = funcinst(f, ISHL, class, v, mkintconst(bits));
	}
	bits += b.before;
	if (bits)
		v = funcinst(f, t->u.basic.issigned ? ISAR : ISHR, class, v, mkintconst(bits));
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x6c, %eax
movl $0x77, %ecx
cmpq $0x4, %rdx
cmovbel %ecx, %eax
movl %eax, -0x24(%rbp)
movswl -0x2(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x174f1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x3, %rcx
andq $-0x4, %rcx
movq -0x18(%rbp), %rax
subq 0x10(%rax), %rcx
shlq $0x3, %rcx
movslq -0x28(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x28(%rbp), %rdi
callq 0x12cc0
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
movq -0x30(%rbp), %rcx
movq %rax, %r8
movl $0xe, %esi
callq 0x15860
movq %rax, -0x20(%rbp)
movswl -0x4(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x17554
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movb 0x40(%rax), %dl
movl $0xd, %eax
movl $0xc, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x50(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x28(%rbp), %rdi
callq 0x12cc0
movq -0x58(%rbp), %rdi
movl -0x50(%rbp), %esi
movl -0x4c(%rbp), %edx
movq -0x48(%rbp), %rcx
movq %rax, %r8
callq 0x15860
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelforney[P]cproc/qbe.c
// Function: mkinst
static struct inst *
mkinst(struct func *f, int op, int class, struct value *arg0, struct value *arg1)
{
	struct inst *inst;

	inst = xmalloc(sizeof(*inst));
	inst->kind = op;
	inst->class = class;
	inst->arg[0] = arg0;
	inst->arg[1] = arg1;
	if (class && op != IARG)
		functemp(f, &inst->res);
	else
		inst->res.kind = VALUE_NONE;
	return inst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x28, %edi
callq 0x127c0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x10(%rbp)
je 0x175d2
cmpl $0x59, -0xc(%rbp)
je 0x175d2
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
callq 0x13260
jmp 0x175dd
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/files.c
// Function: create_file
void
create_file(const char* base, const int i)
{
	FILE* fp;
	char* filename;

	_STRESS_MUST(asprintf(&filename, "%s/file%d", base, i) > 0,
	             "Couldn't create name for file %d",
	             i);
	_STRESS_MUST(
	  (fp = fopen(filename, "a")), "Couldn't create file %s", filename);
	fprintf(fp, "dummy");
	fclose(fp);
	free(filename);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
leaq 0x8(%rsp), %rdi
leaq 0x82d(%rip), %rsi       # 0x212f
movb $0x0, %al
callq 0x1120
cmpl $0x0, %eax
jg 0x19ec
movq 0x26df(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x724(%rip), %rsi       # 0x2047
movb $0x0, %al
callq 0x1100
movq 0x26c7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x712(%rip), %rsi       # 0x204d
movb $0x0, %al
callq 0x1100
movq 0x26af(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl 0x1c(%rsp), %edx
leaq 0x7e2(%rip), %rsi       # 0x2139
movb $0x0, %al
callq 0x1100
movq 0x2693(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x705(%rip), %rsi       # 0x2074
movb $0x0, %al
callq 0x1100
movq 0x267b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6f0(%rip), %rsi       # 0x2077
leaq 0x7cc(%rip), %rdx       # 0x215a
movb $0x0, %al
callq 0x1100
movq 0x265c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6ed(%rip), %rsi       # 0x2093
movl $0x16, %edx
movb $0x0, %al
callq 0x1100
movq 0x263f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6b2(%rip), %rsi       # 0x2075
movb $0x0, %al
callq 0x1100
movq 0x2627(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6c5(%rip), %rsi       # 0x20a0
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1160
jmp 0x19ee
jmp 0x19f0
movq 0x8(%rsp), %rdi
leaq 0x76a(%rip), %rsi       # 0x2166
callq 0x1130
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x1aeb
movq 0x25e1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x626(%rip), %rsi       # 0x2047
movb $0x0, %al
callq 0x1100
movq 0x25c9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x614(%rip), %rsi       # 0x204d
movb $0x0, %al
callq 0x1100
movq 0x25b1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x712(%rip), %rsi       # 0x2168
movb $0x0, %al
callq 0x1100
movq 0x2594(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x606(%rip), %rsi       # 0x2074
movb $0x0, %al
callq 0x1100
movq 0x257c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5f1(%rip), %rsi       # 0x2077
leaq 0x6cd(%rip), %rdx       # 0x215a
movb $0x0, %al
callq 0x1100
movq 0x255d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5ee(%rip), %rsi       # 0x2093
movl $0x18, %edx
movb $0x0, %al
callq 0x1100
movq 0x2540(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5b3(%rip), %rsi       # 0x2075
movb $0x0, %al
callq 0x1100
movq 0x2528(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5c6(%rip), %rsi       # 0x20a0
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1160
jmp 0x1aed
movq 0x10(%rsp), %rdi
leaq 0x687(%rip), %rsi       # 0x2180
movb $0x0, %al
callq 0x1100
movq 0x10(%rsp), %rdi
callq 0x10a0
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile.c
// Function: main
int main(int argc, char **argv)
{
	char *file;
	struct string_list *filelist = NULL;

	bits_in_bool = 8;

	clean_up_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		struct symbol_list *list;
		const char *basename = strrchr(file, '/');
		basename = basename ?  basename+1 : file;

		list = sparse(file);

		// Do type evaluation and simplification
		emit_unit_begin(basename);
		clean_up_symbols(list);
		emit_unit_end();
	} END_FOR_EACH_PTR(file);

#if 0
	// And show the allocation statistics
	show_ident_alloc();
	show_token_alloc();
	show_symbol_alloc();
	show_expression_alloc();
	show_statement_alloc();
	show_string_alloc();
	show_bytes_alloc();
#endif
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x7fc47(%rip), %rax     # 0x910dc
movl $0x8, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x173d0
movq %rax, %rdi
callq 0x115c0
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x114d7
jmp 0x115a9
jmp 0x114d9
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11591
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x11528
cmpq $0x0, -0x18(%rbp)
jne 0x11528
jmp 0x11583
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x11130
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x1154f
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x11557
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17840
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
callq 0x61180
movq -0x48(%rbp), %rdi
callq 0x115c0
callq 0x611b0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x114e0
jmp 0x11593
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x114d9
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile.c
// Function: clean_up_symbols
static void clean_up_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		expand_symbol(sym);
		emit_one_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x115ed
jmp 0x1166b
jmp 0x115ef
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x11657
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1163a
cmpq $0x0, -0x10(%rbp)
jne 0x1163a
jmp 0x1164c
movq -0x10(%rbp), %rdi
callq 0x11b10
movq -0x10(%rbp), %rdi
callq 0x61290
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x115f6
jmp 0x11659
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x115ef
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: textbuf_emit
static void textbuf_emit(struct textbuf **buf_p)
{
	struct textbuf *tmp, *list = *buf_p;

	while (list) {
		tmp = list;
		if (tmp->next == tmp)
			list = NULL;
		else {
			tmp->prev->next = tmp->next;
			tmp->next->prev = tmp->prev;
			list = tmp->next;
		}

		fputs(tmp->text, stdout);

		free(tmp);
	}

	*buf_p = list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61274
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x6121e
movq $0x0, -0x18(%rbp)
jmp 0x61252
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x29d6f(%rip), %rax     # 0x8afd0
movq (%rax), %rsi
callq 0x11150
movq -0x10(%rbp), %rdi
callq 0x11030
jmp 0x611f7
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_array_noinit
static void emit_array_noinit(struct symbol *sym)
{
	emit_global_noinit(show_ident(sym->ident),
			   sym->ctype.modifiers, sym->ctype.alignment,
			   get_expression_value(sym->array_size) * (sym->bit_size / 8));
	stor_sym_init(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x12060
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rdx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
imulq %rcx, %rax
movl %eax, %ecx
callq 0x62930
movq -0x8(%rbp), %rdi
callq 0x61950
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_object_pre
static void emit_object_pre(const char *name, unsigned long modifiers,
			    unsigned long alignment, unsigned int byte_size)
{
	if ((modifiers & MOD_STATIC) == 0)
		printf(".globl %s\n", name);
	emit_section(".data");
	if (alignment)
		printf("\t.align %lu\n", alignment);
	printf("\t.type\t%s, @object\n", name);
	printf("\t.size\t%s, %d\n", name, byte_size);
	printf("%s:\n", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
jne 0x617a7
movq -0x8(%rbp), %rsi
leaq 0x110be(%rip), %rdi     # 0x7285e
movb $0x0, %al
callq 0x11110
leaq 0x110bb(%rip), %rdi     # 0x72869
callq 0x62ad0
cmpq $0x0, -0x18(%rbp)
je 0x617cc
movq -0x18(%rbp), %rsi
leaq 0x110aa(%rip), %rdi     # 0x7286f
movb $0x0, %al
callq 0x11110
movq -0x8(%rbp), %rsi
leaq 0x110a5(%rip), %rdi     # 0x7287c
movb $0x0, %al
callq 0x11110
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq 0x110a4(%rip), %rdi     # 0x72890
movb $0x0, %al
callq 0x11110
movq -0x8(%rbp), %rsi
leaq 0x5cd5(%rip), %rdi      # 0x674d3
movb $0x0, %al
callq 0x11110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_scalar
static void emit_scalar(struct expression *expr, unsigned int bit_size)
{
	const char *type;
	long long ll;

	assert(expr->type == EXPR_VALUE);

	if (expr->value == 0ULL) {
		printf("\t.zero\t%d\n", bit_size / 8);
		return;
	}

	ll = (long long) expr->value;

	switch (bit_size) {
	case 8:		type = "byte";	ll = (char) ll; break;
	case 16:	type = "value";	ll = (short) ll; break;
	case 32:	type = "long";	ll = (int) ll; break;
	case 64:	type = "quad";	break;
	default:	type = NULL;	break;
	}

	assert(type != NULL);

	printf("\t.%s\t%lld\n", type, ll);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x61831
jmp 0x61850
leaq 0x11067(%rip), %rdi     # 0x7289f
leaq 0x10f55(%rip), %rsi     # 0x72794
movl $0x397, %edx            # imm = 0x397
leaq 0x1106d(%rip), %rcx     # 0x728b8
callq 0x11140
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x61874
movl -0xc(%rbp), %esi
shrl $0x3, %esi
leaq 0x10f6e(%rip), %rdi     # 0x727d6
movb $0x0, %al
callq 0x11110
jmp 0x61947
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x8, %eax
je 0x618ab
jmp 0x6188d
movl -0x24(%rbp), %eax
subl $0x10, %eax
je 0x618c4
jmp 0x61897
movl -0x24(%rbp), %eax
subl $0x20, %eax
je 0x618dd
jmp 0x618a1
movl -0x24(%rbp), %eax
subl $0x40, %eax
je 0x618f4
jmp 0x61901
leaq 0x72a8(%rip), %rax      # 0x68b5a
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movsbq %al, %rax
movq %rax, -0x20(%rbp)
jmp 0x61909
leaq 0xd964(%rip), %rax      # 0x6f22f
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movswq %ax, %rax
movq %rax, -0x20(%rbp)
jmp 0x61909
leaq 0xa4e3(%rip), %rax      # 0x6bdc7
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cltq
movq %rax, -0x20(%rbp)
jmp 0x61909
leaq 0x10ff1(%rip), %rax     # 0x728ec
movq %rax, -0x18(%rbp)
jmp 0x61909
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61912
jmp 0x61931
leaq 0x10e6e(%rip), %rdi     # 0x72787
leaq 0x10e74(%rip), %rsi     # 0x72794
movl $0x3a8, %edx            # imm = 0x3A8
leaq 0x10f8c(%rip), %rcx     # 0x728b8
callq 0x11140
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x10fb1(%rip), %rdi     # 0x728f1
movb $0x0, %al
callq 0x11110
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: stor_sym_init
static void stor_sym_init(struct symbol *sym)
{
	struct storage *stor;
	struct symbol_private *priv;

	priv = calloc(1, sizeof(*priv) + sizeof(*stor));
	if (!priv)
		die("OOM in stor_sym_init");

	stor = (struct storage *) (priv + 1);

	priv->addr = stor;
	stor->type = STOR_SYM;
	stor->sym = sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x111d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x61984
leaq 0x10f7f(%rip), %rdi     # 0x728fc
movb $0x0, %al
callq 0x17200
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/compile-i386.c
// Function: emit_scalar_noinit
static void emit_scalar_noinit(struct symbol *sym)
{
	emit_global_noinit(show_ident(sym->ident),
			   sym->ctype.modifiers, sym->ctype.alignment,
			   sym->bit_size / 8);
	stor_sym_init(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x314b0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rdx
movl %eax, %ecx
callq 0x62930
movq -0x8(%rbp), %rdi
callq 0x61950
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)