LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: remap
static int
remap(Isel *s, Htab *map, Insn *insn, regid *use, size_t nuse, regid *def, size_t ndef)
{
	regid ruse, rdef;
	int remapped;
	Loc *tmp;
	size_t i;

	remapped = 0;
	for (i = 0; i < nuse; i++) {
		ruse = getalias(s, use[i]);
		if (!bshas(s->spilled, ruse))
			continue;
		tmp = locreg(locmap[ruse]->mode);
		htput(map, locmap[ruse], tmp);
		bsput(s->neverspill, tmp->reg.id);
		remapped = 1;
	}

	for (i = 0; i < ndef; i++) {
		rdef = getalias(s, def[i]);
		if (!bshas(s->spilled, rdef))
			continue;
		if (hthas(map, locmap[rdef]))
			continue;
		tmp = locreg(locmap[rdef]->mode);
		htput(map, locmap[rdef], tmp);
		bsput(s->neverspill, tmp->reg.id);
		remapped = 1;
	}

	return remapped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x44(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x16142
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x112a0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x160d5
jmp 0x16131
leaq 0x668c4(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %edi
callq 0xff10
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x668a2(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x50(%rbp), %rdx
callq 0x49100
movq -0x8(%rbp), %rax
movq 0x3f8(%rax), %rdi
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x48a50
movl $0x1, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x16093
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq 0x10(%rbp), %rax
jae 0x1621b
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x112a0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x4b8(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x13f00
cmpl $0x0, %eax
jne 0x1618c
jmp 0x1620a
movq -0x10(%rbp), %rdi
leaq 0x66809(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x496f0
cmpl $0x0, %eax
je 0x161ae
jmp 0x1620a
leaq 0x667eb(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %edi
callq 0xff10
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x667c9(%rip), %rax     # 0x7c9a0
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x50(%rbp), %rdx
callq 0x49100
movq -0x8(%rbp), %rax
movq 0x3f8(%rax), %rdi
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x48a50
movl $0x1, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x1614a
movl -0x44(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/ra.c
// Function: updatelocs
static void
updatelocs(Isel *s, Htab *map, Insn *insn)
{
	size_t i;

	for (i = 0; i < insn->nargs; i++) {
		insn->args[i] = mapfind(s, map, insn->args[i]);
		insn->args[i] = mapfind(s, map, insn->args[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x1633c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdx
callq 0x16360
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdx
callq 0x16360
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x162cc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/peep.c
// Function: peep
void
peep(Isel *s)
{
	size_t i;

	for (i = 0; i < s->nbb; i++) {
		deadcode(s, s->bb[i]);
		nopjmp(s, s->bb[i], i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x165a6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x165b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
callq 0x16620
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16554
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/peep.c
// Function: deadcode
static void
deadcode(Isel *s, Asmbb *bb)
{
	size_t i;

	if (!bb)
		return;
	for (i = 0; i < bb->ni; i++) {
		if (bb->il[i]->op == Ijmp) {
			i++;
			break;
		}
	}
	bb->ni = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x165c5
jmp 0x1661b
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x1660f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x34, 0x8(%rax)
jne 0x165ff
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1660f
jmp 0x16601
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x165cd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/peep.c
// Function: nopjmp
static void
nopjmp(Isel *s, Asmbb *bb, size_t idx)
{
	Insn *jmp;
	Loc *targ;
	Asmbb *nextbb;
	size_t i;

	/* skip empty bbs */
	if (!bb || !bb->ni)
		return;
	/* find the target of the last unconditional
	 * jump in the bb */
	targ = NULL;
	if (bb->il[bb->ni - 1]->op == Ijmp) {
		jmp = bb->il[bb->ni - 1];
		if (jmp->args[0]->type == Loclbl)
			targ = jmp->args[0];
	}
	if (!targ)
		return;

	/* figure out if it's somewhere in the head of the next bb */
	nextbb = NULL;
	for (i = idx + 1; i < s->nbb; i++) {
		nextbb = s->bb[i];
		if (nextbb)
			break;
	}
	if (!nextbb)
		return;
	for (i = 0; i < nextbb->nlbls; i++) {
		if (!strcmp(nextbb->lbls[i], targ->lbl)) {
			bb->ni--;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16646
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1664b
jmp 0x16766
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x34, 0x8(%rax)
jne 0x166a8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, (%rax)
jne 0x166a6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x166a8
cmpq $0x0, -0x28(%rbp)
jne 0x166b4
jmp 0x16766
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x16703
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x166f3
jmp 0x16703
jmp 0x166f5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x166c8
cmpq $0x0, -0x30(%rbp)
jne 0x1670c
jmp 0x16766
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x16766
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x6220
cmpl $0x0, %eax
jne 0x16756
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x16766
jmp 0x16758
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x16714
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: loadvar
Node *
loadvar(Simp *s, Node *n, Node *dst)
{
	Node *p, *f, *r, *e;

	if (isconstfn(n)) {
		if (dst)
			r = dst;
		else
			r = temp(s, n);
		f = getcode(s, n);
		p = addr(s, r, exprtype(n));
		assignat(s, p, Ptrsz, f);
		e = mkintlit(n->loc, 0);
		e->expr.type = tyintptr;
		assignat(s, p, 0, e);
	} else {
		r = n;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41010
cmpl $0x0, %eax
je 0x16926
cmpq $0x0, -0x18(%rbp)
je 0x16887
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x16898
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16940
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x169c0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x8, %edx
callq 0x16b90
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f3c0
movq %rax, -0x38(%rbp)
movq 0x66541(%rip), %rcx     # 0x7ce48
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x16b90
jmp 0x1692e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: temp
static Node *
temp(Simp *simp, Node *e)
{
	Node *t, *dcl;

	assert(e->type == Nexpr);
	t = gentemp(e->loc, e->expr.type, &dcl);
	if (stacknode(e))
		declarelocal(simp, dcl);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x1695c
jmp 0x1697b
leaq 0x3604e(%rip), %rdi     # 0x4c9b1
leaq 0x37776(%rip), %rsi     # 0x4e0e0
movl $0x11c, %edx            # imm = 0x11C
leaq 0x37771(%rip), %rcx     # 0x4e0e7
callq 0x6160
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq (%rax), %rdi
leaq -0x20(%rbp), %rdx
callq 0x2ffd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x167b0
cmpl $0x0, %eax
je 0x169b2
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17210
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: getcode
static Node *
getcode(Simp *s, Node *n)
{
	Node *r, *p, *d;
	Type *ty;

	if (isconstfn(n)) {
		d = decls[n->expr.did];
		r = mkexpr(n->loc, Ovar, n->expr.args[0], NULL);
		r->expr.did = d->decl.did;
		r->expr.type = codetype(exprtype(n));
	} else {
		ty = tybase(exprtype(n));
		assert(ty->type == Tyfunc);
		p = addr(s, rval(s, n, NULL), codetype(ty));
		r = load(addk(p, Ptrsz));
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41010
cmpl $0x0, %eax
je 0x16a4f
leaq 0x66aa3(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq (%rcx), %rdx
movq (%rax), %rdi
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x76a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x16ae2
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x13, (%rax)
jne 0x16a6f
jmp 0x16a8e
leaq 0x37811(%rip), %rdi     # 0x4e287
leaq 0x37663(%rip), %rsi     # 0x4e0e0
movl $0x41e, %edx            # imm = 0x41E
leaq 0x37811(%rip), %rcx     # 0x4e29a
callq 0x6160
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x76a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x18400
movq %rax, %rdi
callq 0x18380
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: addr
static Node *
addr(Simp *s, Node *a, Type *bt)
{
	Node *n;

	n = mkexpr(a->loc, Oaddr, a, NULL);
	if (!addressable(s, a))
		forcelocal(s, a);
	if (!bt)
		n->expr.type = mktyptr(a->loc, a->expr.type);
	else
		n->expr.type = mktyptr(a->loc, bt);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq (%rax), %rdi
movl $0x12, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x173f0
cmpl $0x0, %eax
jne 0x16b42
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x172b0
cmpq $0x0, -0x18(%rbp)
jne 0x16b6a
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq (%rax), %rdi
callq 0x37430
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x16b85
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rsi
movq (%rax), %rdi
callq 0x37430
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: assignat
static Node *
assignat(Simp *s, Node *r, size_t off, Node *val)
{
	Node *pval, *pdst;
	Node *sz;
	Node *st;

	pdst = add(r, disp(val->loc, off));

	if (stacknode(val)) {
		sz = disp(val->loc, size(val));
		pval = addr(s, val, exprtype(val));
		st = mkexpr(val->loc, Oblit, pdst, pval, sz, NULL);
	} else {
		st = set(deref(pdst, val->expr.type), val);
	}
	append(s, st);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %ecx, %esi
movq (%rax), %rdi
callq 0x17540
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x174a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x167b0
cmpl $0x0, %eax
je 0x16c5d
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c480
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl %ecx, %esi
movq (%rax), %rdi
callq 0x17540
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30340
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
movq (%rax), %rdi
movl $0x46, %esi
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x40(%rbp)
jmp 0x16c7e
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x17670
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x17580
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x17710
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simpglobl
void
simpglobl(Node *dcl, Htab *globls, Func ***fn, size_t *nfn, Node ***blob, size_t *nblob)
{
	Simp s = {0,};
	char *name;
	Func *f;

	s.stkoff = mkht(varhash, vareq);
	s.envoff = mkht(varhash, vareq);
	s.globls = globls;
	s.blobs = *blob;
	s.nblobs = *nblob;
	s.hasenv = 0;

	if (dcl->decl.isextern || dcl->decl.isgeneric)
		return;

	name = asmname(dcl);
	if (isconstfn(dcl)) {
		f = simpfn(&s, name, dcl);
		lappend(fn, nfn, f);
	} else {
		simpconstinit(&s, dcl);
	}
	*blob = s.blobs;
	*nblob = s.nblobs;

	free(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x6180
leaq 0x19af3(%rip), %rdi     # 0x307d0
leaq 0x19bbc(%rip), %rsi     # 0x308a0
callq 0x48fe0
movq %rax, -0x58(%rbp)
leaq 0x19adc(%rip), %rdi     # 0x307d0
leaq 0x19ba5(%rip), %rsi     # 0x308a0
callq 0x48fe0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x74(%rax), %eax
cmpl $0x0, %eax
jne 0x16d43
movq -0x8(%rbp), %rax
movsbl 0x73(%rax), %eax
cmpl $0x0, %eax
je 0x16d48
jmp 0x16dcc
movq -0x8(%rbp), %rdi
callq 0x7720
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41010
cmpl $0x0, %eax
je 0x16d9a
movq -0xa8(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x16de0
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0x48290
jmp 0x16daa
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x17090
movq -0x70(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0xa8(%rbp), %rdi
callq 0x6040
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simpconstinit
static void
simpconstinit(Simp *s, Node *dcl)
{
	Node *e;

	dcl->decl.init = fold(dcl->decl.init, 1);;
	e = dcl->decl.init;
	if (e && exprop(e) == Olit) {
		if (e->expr.args[0]->lit.littype == Lfunc)
			dcl->decl.init = simpcode(s, e);
		lappend(&s->blobs, &s->nblobs, dcl);
	} else if (!dcl->decl.isconst && !e) {
		lappend(&s->blobs, &s->nblobs, dcl);
	} else if (e->expr.isconst) {
		switch (exprop(e)) {
		case Oarr:
		case Ostruct:
		case Oslice:
		case Oucon:
		case Ovar:
			extractsub(s, e);
			lappend(&s->blobs, &s->nblobs, dcl);
			break;
		default:
			fatal(dcl, "unsupported initializer for %s", declname(dcl));
			break;
		}
	} else {
		die("Non-constant initializer for %s\n", declname(dcl));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0x1, %esi
callq 0x1f390
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17125
movq -0x18(%rbp), %rdi
callq 0x2f210
cmpl $0x35, %eax
jne 0x17125
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rax
cmpl $0x5, 0x18(%rax)
jne 0x17107
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a960
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
jmp 0x17206
movq -0x10(%rbp), %rax
cmpb $0x0, 0x72(%rax)
jne 0x17154
cmpq $0x0, -0x18(%rbp)
jne 0x17154
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
jmp 0x17204
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x171e8
movq -0x18(%rbp), %rdi
callq 0x2f210
movl %eax, %ecx
movl %ecx, -0x1c(%rbp)
subl $0x29, %eax
je 0x17198
jmp 0x17177
movl -0x1c(%rbp), %eax
subl $0x33, %eax
je 0x17198
jmp 0x17181
movl -0x1c(%rbp), %eax
subl $0x36, %eax
je 0x17198
jmp 0x1718b
movl -0x1c(%rbp), %eax
addl $-0x38, %eax
subl $0x1, %eax
ja 0x171c0
jmp 0x17198
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b3d0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
jmp 0x171e6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30200
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x372f6(%rip), %rsi     # 0x4e4d5
movb $0x0, %al
callq 0x1dfe0
jmp 0x17202
movq -0x10(%rbp), %rdi
callq 0x30200
movq %rax, %rsi
leaq 0x372f9(%rip), %rdi     # 0x4e4f4
movb $0x0, %al
callq 0x1df20
jmp 0x17204
jmp 0x17206
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: declarelocal
static void
declarelocal(Simp *s, Node *n)
{
	if (n->type == Nexpr)
		n = decls[n->decl.did];
	if (n->decl.isconst && n->decl.isextern)
		htput(s->globls, n, asmname(n));
	else if (stacknode(n))
		forcelocal(s, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x17244
leaq 0x66257(%rip), %rax     # 0x7d488
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x72(%rax), %eax
cmpl $0x0, %eax
je 0x1728d
movq -0x10(%rbp), %rax
movsbl 0x74(%rax), %eax
cmpl $0x0, %eax
je 0x1728d
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7720
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
jmp 0x172aa
movq -0x10(%rbp), %rdi
callq 0x167b0
cmpl $0x0, %eax
je 0x172a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x172b0
jmp 0x172aa
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: forcelocal
static void
forcelocal(Simp *s, Node *n)
{
	assert(n->type == Ndecl || (n->type == Nexpr && exprop(n) == Ovar));
	s->stksz += size(n);
	s->stksz = align(s->stksz, min(size(n), Ptrsz));
	if (debugopt['i']) {
		dumpn(n, stdout);
		printf("declared at %zd, size = %zd\n", s->stksz, size(n));
	}
	htput(s->stkoff, n, itop(s->stksz));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
je 0x172e2
movq -0x10(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x172e4
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
jne 0x172e4
jmp 0x17303
leaq 0x36e17(%rip), %rdi     # 0x4e102
leaq 0x36dee(%rip), %rsi     # 0x4e0e0
movl $0xab, %edx
leaq 0x36e40(%rip), %rcx     # 0x4e13e
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x1c480
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c480
movq %rax, %rdi
movl $0x8, %esi
callq 0x4a580
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x4a5b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
leaq 0x659a5(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x69(%rax)
je 0x1739e
movq -0x10(%rbp), %rdi
movq 0x47c64(%rip), %rax     # 0x5efd0
movq (%rax), %rsi
callq 0x1de90
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c480
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x36dc7(%rip), %rdi     # 0x4e15e
movb $0x0, %al
callq 0x6120
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x173e0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: addressable
static int
addressable(Simp *s, Node *a)
{
	if (a->type == Ndecl || (a->type == Nexpr && exprop(a) == Ovar))
		return hthas(s->envoff, a) || hthas(s->stkoff, a) || hthas(s->globls, a);
	else
		return stacknode(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, 0x8(%rax)
je 0x17422
movq -0x18(%rbp), %rax
cmpl $0x8, 0x8(%rax)
jne 0x17483
movq -0x18(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
jne 0x17483
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x496f0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x17476
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x496f0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x17476
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x496f0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1748f
movq -0x18(%rbp), %rdi
callq 0x167b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: add
static Node *
add(Node *a, Node *b)
{
	Node *n;

	assert(size(a) == size(b));
	n = mkexpr(a->loc, Oadd, a, b, NULL);
	n->expr.type = a->expr.type;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c480
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c480
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x174d4
jmp 0x174f3
leaq 0x36ca0(%rip), %rdi     # 0x4e17b
leaq 0x36bfe(%rip), %rsi     # 0x4e0e0
movl $0x69, %edx
leaq 0x36ca0(%rip), %rcx     # 0x4e18e
callq 0x6160
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq (%rax), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: set
static Node *
set(Node *a, Node *b)
{
	Node *n;

	assert(a != NULL && b != NULL);
	assert(exprop(a) == Ovar || exprop(a) == Oderef);
	if (tybase(exprtype(a))->type == Tyvoid)
		return a;

	n = mkexpr(a->loc, Oset, a, b, NULL);
	n->expr.type = exprtype(a);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x175a0
cmpq $0x0, -0x18(%rbp)
je 0x175a0
jmp 0x175bf
leaq 0x36c01(%rip), %rdi     # 0x4e1a8
leaq 0x36b32(%rip), %rsi     # 0x4e0e0
movl $0xef, %edx
leaq 0x36c05(%rip), %rcx     # 0x4e1bf
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x33, %eax
je 0x175db
movq -0x10(%rbp), %rdi
callq 0x2f210
cmpl $0x13, %eax
jne 0x175dd
jmp 0x175fc
leaq 0x36bf5(%rip), %rdi     # 0x4e1d9
leaq 0x36af5(%rip), %rsi     # 0x4e0e0
movl $0xf0, %edx
leaq 0x36bc8(%rip), %rcx     # 0x4e1bf
callq 0x6160
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
cmpl $0x1, (%rax)
jne 0x1761c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1765c
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq (%rax), %rdi
movl $0x40, %esi
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: deref
static Node *
deref(Node *a, Type *t)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	if (t)
		n->expr.type = t;
	else
		n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x12, (%rax)
jne 0x1768f
jmp 0x176ae
leaq 0x36b6c(%rip), %rdi     # 0x4e202
leaq 0x36a43(%rip), %rsi     # 0x4e0e0
movl $0xe1, %edx
leaq 0x36b75(%rip), %rcx     # 0x4e21e
callq 0x6160
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movq (%rax), %rdi
movl $0x13, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x176e2
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x176fa
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x17790
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: append
static void
append(Simp *s, Node *n)
{
	if (debugopt['S'])
		dumpn(n, stdout);
        assert(n->type != Ndecl);
	lappend(&s->stmts, &s->nstmts, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x655d9(%rip), %rax     # 0x7cd00
cmpb $0x0, 0x53(%rax)
je 0x17740
movq -0x10(%rbp), %rdi
movq 0x47898(%rip), %rax     # 0x5efd0
movq (%rax), %rsi
callq 0x1de90
movq -0x10(%rbp), %rax
cmpl $0xb, 0x8(%rax)
je 0x1774c
jmp 0x1776b
leaq 0x36b07(%rip), %rdi     # 0x4e25a
leaq 0x36986(%rip), %rsi     # 0x4e0e0
movl $0x4d, %edx
leaq 0x36b05(%rip), %rcx     # 0x4e26b
callq 0x6160
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
callq 0x48290
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: load
static Node *
load(Node *a)
{
	Node *n;

	assert(a->expr.type->type == Typtr);
	n = mkexpr(a->loc, Oderef, a, NULL);
	n->expr.type = base(a->expr.type);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x12, (%rax)
jne 0x1839b
jmp 0x183ba
leaq 0x35e60(%rip), %rdi     # 0x4e202
leaq 0x35d37(%rip), %rsi     # 0x4e0e0
movl $0xd6, %edx
leaq 0x36094(%rip), %rcx     # 0x4e449
callq 0x6160
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movq (%rax), %rdi
movl $0x13, %esi
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x2f400
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x17790
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: idxaddr
static Node *
idxaddr(Simp *s, Node *seq, Node *idx)
{
	Node *a, *t, *u, *v, *w; /* temps */
	Node *r; /* result */
	Type *ty, *seqty;
	size_t sz;

	a = rval(s, seq, NULL);
	seqty = tybase(exprtype(seq));
	ty = seqty->sub[0];
	if (seqty->type == Tyarray) {
		t = addr(s, a, ty);
		w = seqty->asize;
	} else if (seqty->type == Tyslice) {
		t = load(addr(s, a, mktyptr(seq->loc, ty)));
		w = slicelen(s, a);
	} else {
		die("can't index type %s", tystr(seq->expr.type));
	}
	assert(exprtype(t)->type == Typtr);
	u = rval(s, idx, NULL);
	u = ptrsized(s, u);
	checkidx(s, Olt, w, u);
	sz = tysize(ty);
	v = mul(u, disp(seq->loc, sz));
	r = add(t, v);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
cmpl $0x15, (%rax)
jne 0x1878f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x16af0
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x18807
movq -0x58(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x187e7
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq -0x50(%rbp), %rsi
movq (%rax), %rdi
callq 0x37430
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, %rdi
callq 0x18380
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a6e0
movq %rax, -0x40(%rbp)
jmp 0x18805
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x38a10
movq %rax, %rsi
leaq 0x35b64(%rip), %rdi     # 0x4e362
movb $0x0, %al
callq 0x1df20
jmp 0x18807
movq -0x28(%rbp), %rdi
callq 0x30340
cmpl $0x12, (%rax)
jne 0x18817
jmp 0x18836
leaq 0x35b58(%rip), %rdi     # 0x4e376
leaq 0x358bb(%rip), %rsi     # 0x4e0e0
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x35b60(%rip), %rcx     # 0x4e391
callq 0x6160
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1a440
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x1b, %esi
callq 0x1a540
movq -0x50(%rbp), %rdi
callq 0x1c0f0
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq -0x60(%rbp), %rcx
movl %ecx, %esi
movq (%rax), %rdi
callq 0x17540
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x1a690
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x174a0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: membaddr
static Node *
membaddr(Simp *s, Node *n)
{
	Node *t, *u, *r;
	Node **args;
	Type *ty;

	args = n->expr.args;
	ty = tybase(exprtype(args[0]));
	if (ty->type == Typtr) {
		t = lval(s, args[0]);
	} else {
		t = addr(s, lval(s, args[0]), exprtype(n));
	}
	u = disp(n->loc, offset(args[0], args[1]));
	r = add(t, u);
	r->expr.type = mktyptr(n->loc, n->expr.type);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x12, (%rax)
jne 0x18923
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x19e00
movq %rax, -0x18(%rbp)
jmp 0x1895c
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x19e00
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1c8f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl %ecx, %esi
movq (%rax), %rdi
callq 0x17540
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x174a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rsi
movq (%rax), %rdi
callq 0x37430
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: seqlen
static Node *
seqlen(Simp *s, Node *n, Type *ty)
{
	Node *t, *r;

        r = NULL;
	if (exprtype(n)->type == Tyslice) {
		t = slicelen(s, n);
		r = simpcast(s, t, ty);
	} else if (exprtype(n)->type == Tyarray) {
		t = exprtype(n)->asize;
                if (t)
                    r = simpcast(s, t, ty);
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
cmpl $0x14, (%rax)
jne 0x18a22
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1a6e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x18fe0
movq %rax, -0x28(%rbp)
jmp 0x18a64
movq -0x10(%rbp), %rdi
callq 0x30340
cmpl $0x15, (%rax)
jne 0x18a62
movq -0x10(%rbp), %rdi
callq 0x30340
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x18a60
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x18fe0
movq %rax, -0x28(%rbp)
jmp 0x18a62
jmp 0x18a64
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: uconid
static Node *
uconid(Simp *s, Node *n)
{
	Ucon *uc;

	n = rval(s, n, NULL);
	if (exprop(n) != Oucon) {
		if (isenum(tybase(exprtype(n))))
			return n;
		return load(addr(s, n, mktype(n->loc, Tyuint)));
	}

	uc = finducon(exprtype(n), n->expr.args[0]);
	return word(uc->loc, uc->id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f210
cmpl $0x36, %eax
je 0x18d8a
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
movq %rax, %rdi
callq 0x36ab0
cmpl $0x0, %eax
je 0x18d4b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x18dc4
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0xc, %esi
callq 0x36c10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, %rdi
callq 0x18380
movq %rax, -0x8(%rbp)
jmp 0x18dc4
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
callq 0x377a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl %ecx, %esi
movq (%rax), %rdi
callq 0x1a740
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simpuget
static Node *
simpuget(Simp *s, Node *n, Node *dst)
{
	Node *u, *p, *l;
	size_t o;

	if (!dst)
		dst = temp(s, n);
	u = rval(s, n->expr.args[0], NULL);
	o = alignto(Wordsz, exprtype(n));
	p = addk(addr(s, u, exprtype(n)), o);
	l = assign(s, dst, load(p));
	append(s, l);
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18dfc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16940
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq %rax, %rsi
movl $0x4, %edi
callq 0x16770
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x18400
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x18380
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x19910
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x17710
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simptup
static Node *
simptup(Simp *s, Node *n, Node *dst)
{
	Node **args;
	Node *r;
	size_t i, off;

	args = n->expr.args;
	if (!dst)
		dst = temp(s, n);
	r = addr(s, dst, exprtype(dst));

	off = 0;
	for (i = 0; i < n->expr.nargs; i++) {
		off = alignto(off, exprtype(args[i]));
		assignat(s, r, off, rval(s, args[i], NULL));
		off += size(args[i]);
	}
	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18ee8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16940
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x18fcf
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30340
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x16770
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
callq 0x16b90
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1c480
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x18f25
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: simpblob
static Node *
simpblob(Simp *s, Node *blob)
{
	Node *r, *d;

	r = geninitdecl(blob, exprtype(blob), &d);
	htput(s->globls, d, asmname(d));
	lappend(&s->blobs, &s->nblobs, d);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30340
movq -0x38(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x1a860
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7720
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x49100
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movq -0x20(%rbp), %rdx
callq 0x48290
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: assign
static Node *
assign(Simp *s, Node *lhs, Node *rhs)
{
	Node *t, *u, *v, *r;

	t = lval(s, lhs);
	u = rval(s, rhs, t);

	if (tybase(exprtype(lhs))->type == Tyvoid)
		return u;

	/* hack: we're assigning to lhs, but blitting shit over doesn't
	 * trigger that */
	if (stacknode(lhs))
		def(s, lhs);
	/* if we stored the result into t, rval() should return that,
	 * so we know our work is done. */
	if (u == t) {
		r = t;
	} else if (stacknode(lhs)) {
		t = addr(s, t, exprtype(lhs));
		u = addr(s, u, exprtype(lhs));
		v = disp(lhs->loc, size(lhs));
		r = mkexpr(lhs->loc, Oblit, t, u, v, NULL);
		r->expr.type = exprtype(lhs);
	} else {
		r = set(t, u);
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19e00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x177e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rdi
callq 0x36a30
cmpl $0x1, (%rax)
jne 0x1996d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19a8a
movq -0x18(%rbp), %rdi
callq 0x167b0
cmpl $0x0, %eax
je 0x19988
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1aa40
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1999f
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x19a82
movq -0x18(%rbp), %rdi
callq 0x167b0
cmpl $0x0, %eax
je 0x19a6f
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x16af0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c480
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl %ecx, %esi
movq (%rax), %rdi
callq 0x17540
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq (%rax), %rdi
movl $0x46, %esi
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x2f400
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30340
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x19a80
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x17580
movq %rax, -0x40(%rbp)
jmp 0x19a82
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/oridb[P]mc/6/simp.c
// Function: lval
static Node *
lval(Simp *s, Node *n)
{
	Node *r;
	Node **args;

	args = n->expr.args;
	switch (exprop(n)) {
	case Ovar:	r = loadvar(s, n, NULL);	break;
	case Oidx:	r = loadidx(s, args[0], args[1]);	break;
	case Oderef:	r = deref(rval(s, args[0], NULL), NULL);	break;
	case Otupmemb:	r = rval(s, n, NULL);	break;
	case Omemb:	r = rval(s, n, NULL);	break;
	case Ostruct:	r = rval(s, n, NULL);	break;
	case Oucon:	r = rval(s, n, NULL);	break;
	case Oarr:	r = rval(s, n, NULL);	break;

	/*
	  not expressible as lvalues in syntax, but
	  we take their address in matches
	 */
	case Oudata:    r = rval(s, n, NULL); break;
	case Outag:     r = rval(s, n, NULL); break;
	case Otupget:   r = rval(s, n, NULL); break;

	default:
			fatal(n, "%s cannot be an lvalue", opstr[exprop(n)]);
			break;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
addl $-0x13, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x32, %eax
ja 0x19f73
movq -0x28(%rbp), %rax
leaq 0x341ae(%rip), %rcx     # 0x4dff0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x16850
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x1ad50
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17670
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x177e0
movq %rax, -0x18(%rbp)
jmp 0x19fa5
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f210
movq -0x30(%rbp), %rdi
movl %eax, %eax
movl %eax, %ecx
leaq 0x61f2d(%rip), %rax     # 0x7bec0
movq (%rax,%rcx,8), %rdx
leaq 0x34494(%rip), %rsi     # 0x4e432
movb $0x0, %al
callq 0x1dfe0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop