LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/tokenize.c
// Function: get_one_number
static int get_one_number(int c, int next, stream_t *stream)
{
	struct token *token;
	static char buffer[4095];
	char *p = buffer, *buffer_end = buffer + sizeof (buffer);

	*p++ = c;
	for (;;) {
		long class =  cclass[next + 1];
		if (!(class & (Dot | Digit | Letter)))
			break;
		if (p != buffer_end)
			*p++ = next;
		next = nextchar(stream);
		if (class & Exp) {
			if (next == '-' || next == '+') {
				if (p != buffer_end)
					*p++ = next;
				next = nextchar(stream);
			}
		}
	}

	if (p == buffer_end) {
		sparse_error(stream_pos(stream), "number token exceeds %td characters",
		      buffer_end - buffer);
		// Pretend we saw just "1".
		buffer[0] = '1';
		p = buffer + 1;
	}

	*p++ = 0;
	token = stream->token;
	token_type(token) = TOKEN_NUMBER;
	token->number = xmemdup(buffer, p - buffer);
	add_token(stream);

	return next;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movb %dil, 0x5df13(%rip)     # 0x8d620
leaq 0x5df0d(%rip), %r13     # 0x8d621
leaq 0x5ef04(%rip), %r12     # 0x8e61f
leal 0x1(%r14), %eax
leaq 0x19b9a(%rip), %rcx     # 0x492c0
movzbl (%rax,%rcx), %ebp
testb $0x13, %bpl
je 0x2f780
movq %r12, %r15
cmpq %r12, %r13
je 0x2f742
movb %r14b, (%r13)
incq %r13
movq %r13, %r15
movq %rbx, %rdi
callq 0x2f4dd
movl %eax, %r14d
testb $0x8, %bpl
je 0x2f77d
cmpl $0x2d, %r14d
je 0x2f75f
cmpl $0x2b, %r14d
jne 0x2f77d
movq %r12, %r13
cmpq %r12, %r15
je 0x2f770
movb %r14b, (%r15)
incq %r15
movq %r15, %r13
movq %rbx, %rdi
callq 0x2f4dd
movl %eax, %r14d
jmp 0x2f780
movq %r15, %r13
testb $0x13, %bpl
jne 0x2f71b
leaq 0x5ee92(%rip), %rax     # 0x8e61f
cmpq %rax, %r13
jne 0x2f7ec
movl 0xc(%rbx), %eax
movl 0x14(%rbx), %ecx
shll $0x6, %ecx
movl 0x18(%rbx), %edx
andl $0x1, %edx
shll $0x14, %edx
andl $0xfffc0, %ecx          # imm = 0xFFFC0
orl %edx, %ecx
movl 0x1c(%rbx), %edx
shll $0x16, %eax
andl $0x1, %edx
shll $0x15, %edx
orl %ecx, %edx
orl %eax, %edx
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
andl 0x10(%rbx), %edi
shlq $0x20, %rdi
orq %rdx, %rdi
leaq 0x19e02(%rip), %rsi     # 0x495d4
movl $0xfff, %edx            # imm = 0xFFF
xorl %eax, %eax
callq 0x11a38
movb $0x31, 0x5de3b(%rip)    # 0x8d620
leaq 0x5de35(%rip), %r13     # 0x8d621
movb $0x0, (%r13)
movq 0x28(%rbx), %r15
movq (%r15), %rax
andq $-0x40, %rax
orq $0x5, %rax
movq %rax, (%r15)
leaq 0x5de16(%rip), %rdi     # 0x8d620
subq %rdi, %r13
incq %r13
movq %r13, %rsi
callq 0x2fbae
movq %rax, 0x10(%r15)
movq 0x28(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x28(%rbx)
leaq 0x8(%rax), %rdx
movq %rcx, 0x8(%rax)
movq 0x20(%rbx), %rcx
movq %rax, (%rcx)
movq %rdx, 0x20(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/utils.c
// Function: xvasprintf
char *xvasprintf(const char *fmt, va_list ap)
{
	va_list ap2;
	char *str;
	int n;

	va_copy(ap2, ap);
	n = vsnprintf(NULL, 0, fmt, ap2) + 1;
	va_end(ap2);

	str = __alloc_bytes(n);
	vsnprintf(str, n, fmt, ap);

	return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rsi), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0xe0b0
movl %eax, %ebp
incl %ebp
movl %ebp, %edi
callq 0x301b5
movq %rax, %r15
movslq %ebp, %rsi
movq %rax, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xe0b0
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/allocate.c
// Function: drop_all_allocations
void drop_all_allocations(struct allocator_struct *desc)
{
	struct allocation_blob *blob = desc->blobs;

	desc->blobs = NULL;
	desc->allocations = 0;
	desc->total_bytes = 0;
	desc->useful_bytes = 0;
	desc->freelist = NULL;
	while (blob) {
		struct allocation_blob *next = blob->next;
		blob_free(blob, desc->chunking);
		blob = next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movl $0x0, 0x20(%rbx)
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
testq %rdi, %rdi
je 0x2fd28
movq (%rdi), %r14
movl 0x14(%rbx), %esi
callq 0x31459
movq %r14, %rdi
testq %r14, %r14
jne 0x2fd15
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/allocate.c
// Function: allocate
void *allocate(struct allocator_struct *desc, unsigned int size)
{
	unsigned long alignment = desc->alignment;
	struct allocation_blob *blob = desc->blobs;
	void *retval;

	/*
	 * NOTE! The freelist only works with things that are
	 *  (a) sufficiently aligned
	 *  (b) use a constant size
	 * Don't try to free allocators that don't follow
	 * these rules.
	 */
	if (desc->freelist) {
		void **p = desc->freelist;
		retval = p;
		desc->freelist = *p;
		do {
			*p = NULL;
			p++;
		} while ((size -= sizeof(void *)) > 0);
		return retval;
	}

	desc->allocations++;
	desc->useful_bytes += size;
	size = (size + alignment - 1) & ~(alignment-1);
	if (!blob || blob->left < size) {
		unsigned int offset, chunking = desc->chunking;
		struct allocation_blob *newblob = blob_alloc(chunking);
		if (!newblob)
			die("out of memory");
		if (size > chunking)
			die("alloc too big");
		desc->total_bytes += chunking;
		newblob->next = blob;
		blob = newblob;
		desc->blobs = newblob;
		offset = offsetof(struct allocation_blob, data);
		offset = (offset + alignment - 1) & ~(alignment-1);
		blob->left = chunking - offset;
		blob->offset = offset - offsetof(struct allocation_blob, data);
	}
	retval = blob->data + blob->offset;
	blob->offset += size;
	blob->left -= size;
	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x2fd73
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
movl %esi, %ecx
xorl %edx, %edx
movq $0x0, (%rax,%rdx)
addq $0x8, %rdx
cmpl %edx, %ecx
jne 0x2fd5e
jmp 0x2fdf4
movl 0x10(%rbx), %r13d
movq 0x8(%rbx), %r12
incl 0x20(%rbx)
movl %esi, %eax
addq %rax, 0x30(%rbx)
leal (%rsi,%r13), %eax
decl %eax
movq %r13, %rbp
negq %rbp
movl %ebp, %r15d
andl %eax, %r15d
testq %r12, %r12
je 0x2fda2
cmpl %r15d, 0x8(%r12)
jae 0x2fdda
movl 0x14(%rbx), %r14d
movq %r14, %rdi
callq 0x31418
testq %rax, %rax
je 0x2fe03
cmpl %r15d, %r14d
jb 0x2fe0c
addq %r14, 0x28(%rbx)
movq %r12, (%rax)
movq %rax, 0x8(%rbx)
addl $0xf, %r13d
andl %r13d, %ebp
subl %ebp, %r14d
movl %r14d, 0x8(%rax)
addl $-0x10, %ebp
movl %ebp, 0xc(%rax)
movq %rax, %r12
movl 0xc(%r12), %ecx
leaq (%r12,%rcx), %rax
addq $0x10, %rax
addl %r15d, %ecx
movl %ecx, 0xc(%r12)
subl %r15d, 0x8(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x199ce(%rip), %rdi     # 0x497d8
jmp 0x2fe13
leaq 0x199d3(%rip), %rdi     # 0x497e6
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/allocate.c
// Function: get_allocator_stats
void get_allocator_stats(struct allocator_struct *x, struct allocator_stats *s)
{
	s->name = x->name;
	s->allocations = x->allocations;
	s->useful_bytes = x->useful_bytes;
	s->total_bytes = x->total_bytes;
}

// Assembly:
movq (%rdi), %rax
movq %rax, (%rsi)
movl 0x20(%rdi), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rdi), %rax
movq %rax, 0x18(%rsi)
movq 0x28(%rdi), %rax
movq %rax, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: declare_builtins
void declare_builtins(int stream, const struct builtin_fn tbl[])
{
	if (!tbl)
		return;

	while (tbl->name)
		declare_builtin(stream, tbl++);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
testq %rsi, %rsi
je 0x30734
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x30734
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x5ffc2(%rip), %r13     # 0x90620
movl 0xc(%rsp), %edi
movl $0x3, %edx
movl $0x10, %ecx
callq 0x2c406
movq %rax, %r14
movq 0x4(%rax), %rdi
movl $0x5, %esi
callq 0x2b547
movq %rax, %r15
movq %rax, 0x60(%r14)
movq $0x10, 0x68(%r14)
orb $0x8, 0x56(%r14)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%r14)
movq 0x8(%rbx), %rax
cmpq %r13, %rax
jne 0x306b1
leaq 0x34f72(%rip), %rax     # 0x65620
movq (%rax), %rax
movq %rax, 0x60(%r15)
movzbl 0x10(%rbx), %eax
andl $0x1, %eax
shll $0x9, %eax
movl 0x54(%r15), %ecx
movl $0xfffffdff, %edx       # imm = 0xFFFFFDFF
andl %edx, %ecx
orl %eax, %ecx
movl %ecx, 0x54(%r15)
movq 0x18(%rbx), %rbp
testq %rbp, %rbp
je 0x3071e
addq $0x88, %r15
movq 0x10(%rsp), %r12
movq 0x4(%r14), %rdi
movl $0x3, %esi
callq 0x2b547
cmpq %r13, %rbp
jne 0x30702
leaq 0x34f21(%rip), %rcx     # 0x65620
movq (%rcx), %rbp
movq %rbp, 0x60(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2285b
movq (%r12), %rbp
addq $0x8, %r12
testq %rbp, %rbp
jne 0x306e5
addq $0x58, %rbx
movq (%rbx), %rsi
addq $0x58, 0x10(%rsp)
testq %rsi, %rsi
jne 0x3065e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: eval_args
static int eval_args(struct expression *expr, int n)
{
	struct expression *arg;
	struct symbol *sym;
	const char *msg;
	int rc = 1;

	FOR_EACH_PTR(expr->args, arg) {
		if (n-- == 0) {
			msg = "too many arguments";
			goto error;
		}
		if (!evaluate_expression(arg))
			rc = 0;
	} END_FOR_EACH_PTR(arg);
	if (n > 0) {
		msg = "not enough arguments";
		goto error;
	}
	return rc;

error:
	sym = expr->fn->ctype;
	expression_error(expr, "%s for %s", msg, show_ident(sym->ident));
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x307f1
movq %rbx, (%rsp)
movl $0x1, %ebp
xorl %r12d, %r12d
movq %r15, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x307d9
xorl %ebx, %ebx
movq 0x18(%r13,%rbx,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x307b7
testq %rdi, %rdi
je 0x307c9
subl $0x1, %r14d
jb 0x307e6
callq 0x32c63
testq %rax, %rax
cmovel %r12d, %ebp
incq %rbx
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jl 0x307a3
movq 0x10(%r13), %r13
cmpq %r15, %r13
jne 0x30798
xorl %eax, %eax
jmp 0x307eb
movl $0x9, %eax
movq (%rsp), %rbx
jmp 0x307fb
movl $0x2, %eax
movl $0x1, %ebp
testl %eax, %eax
je 0x30809
cmpl $0x9, %eax
je 0x30817
cmpl $0x2, %eax
jne 0x30848
testl %r14d, %r14d
jle 0x30848
leaq 0x1911b(%rip), %r14     # 0x49930
jmp 0x3081e
leaq 0x190ff(%rip), %r14     # 0x4991d
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2e465
leaq 0x1910f(%rip), %rsi     # 0x49945
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11abc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_choose
static int evaluate_choose(struct expression *expr)
{
	struct expression_list *list = expr->args;
	struct expression *arg, *args[3];
	int n = 0;

	/* there will be exactly 3; we'd already verified that */
	FOR_EACH_PTR(list, arg) {
		args[n++] = arg;
	} END_FOR_EACH_PTR(arg);

	*expr = get_expression_value(args[0]) ? *args[1] : *args[2];

	return 1;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x30b4c
xorl %ecx, %ecx
movq %rax, %rdx
movzwl (%rdx), %edi
movsbl %dil, %esi
testw %si, %si
jle 0x30b43
movzwl %si, %esi
movzwl %di, %edi
xorl %r8d, %r8d
movq 0x18(%rdx,%r8,8), %r9
cmpl $0x100, %edi            # imm = 0x100
jb 0x30b32
testq %r9, %r9
je 0x30b3b
movslq %ecx, %r10
incl %ecx
movq %r9, (%rsp,%r10,8)
incq %r8
cmpq %r8, %rsi
jne 0x30b20
movq 0x10(%rdx), %rdx
cmpq %rax, %rdx
jne 0x30b0b
movq (%rsp), %rdi
callq 0xf23d
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
movq 0x8(%rsp,%rcx,8), %rax
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm3, 0x30(%rbx)
movaps %xmm2, 0x20(%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: expand_constant_p
static int expand_constant_p(struct expression *expr, int cost)
{
	expr->type = EXPR_VALUE;
	expr->value = !cost;
	expr->taint = 0;
	return 0;
}

// Assembly:
movb $0x1, (%rdi)
xorl %eax, %eax
testl %esi, %esi
sete %al
movq %rax, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: expand_expect
static int expand_expect(struct expression *expr, int cost)
{
	struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);

	if (arg)
		*expr = *arg;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x22634
testq %rax, %rax
je 0x30bf2
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm3, 0x30(%rbx)
movaps %xmm2, 0x20(%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: expand_safe_p
static int expand_safe_p(struct expression *expr, int cost)
{
	expr->type = EXPR_VALUE;
	expr->value = (cost < SIDE_EFFECTS);
	expr->taint = 0;
	return 0;
}

// Assembly:
movb $0x1, (%rdi)
xorl %eax, %eax
cmpl $0x2710, %esi           # imm = 0x2710
setl %al
movq %rax, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: expand_warning
static int expand_warning(struct expression *expr, int cost)
{
	struct expression *arg;
	struct expression_list *arglist = expr->args;

	FOR_EACH_PTR (arglist, arg) {
		/*
		 * Constant strings get printed out as a warning. By the
		 * time we get here, the EXPR_STRING has been fully 
		 * evaluated, so by now it's an anonymous symbol with a
		 * string initializer.
		 *
		 * Just for the heck of it, allow any constant string
		 * symbol.
		 */
		if (arg->type == EXPR_SYMBOL) {
			struct symbol *sym = arg->symbol;
			if (sym->initializer && sym->initializer->type == EXPR_STRING) {
				struct string *string = sym->initializer->string;
				warning(expr->pos, "%*s", string->length-1, string->data);
			}
			continue;
		}

		/*
		 * Any other argument is a conditional. If it's
		 * non-constant, or it is false, we exit and do
		 * not print any warning.
		 */
		if (arg->type != EXPR_VALUE)
			goto out;
		if (!arg->value)
			goto out;
	} END_FOR_EACH_PTR(arg);
out:
	expr->type = EXPR_VALUE;
	expr->value = 1;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x30cca
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
leaq 0x19b75(%rip), %r14     # 0x4a7ae
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x30cb8
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rcx
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x30c5c
testq %rcx, %rcx
je 0x30ca8
movzbl (%rcx), %edx
movl $0x9, %eax
cmpl $0x1, %edx
je 0x30ca1
cmpl $0x3, %edx
jne 0x30ccf
movq 0x20(%rcx), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x30ca8
cmpb $0x2, (%rax)
jne 0x30ca8
movq 0x28(%rax), %rcx
movl (%rcx), %edx
andl %ebp, %edx
decl %edx
addq $0x4, %rcx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x118b4
jmp 0x30ca8
cmpq $0x0, 0x20(%rcx)
je 0x30ccf
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x30c48
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x30c3c
xorl %eax, %eax
jmp 0x30ccf
movl $0x2, %eax
cmpl $0x9, %eax
ja 0x30cf0
movl $0x205, %ecx            # imm = 0x205
btl %eax, %ecx
jae 0x30cf0
movb $0x1, (%rbx)
movq $0x1, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_overflow_gen
static int evaluate_overflow_gen(struct expression *expr, int ptr)
{
	struct expression *arg;
	int n = 0;

	/* there will be exactly 3; we'd already verified that */
	FOR_EACH_PTR(expr->args, arg) {
		struct symbol *type;

		n++;
		if (!arg || !(type = arg->ctype))
			return 0;
		// 1st & 2nd args must be a basic integer type
		// 3rd arg must be a pointer to such a type.
		if (n == 3 && ptr) {
			if (type->type == SYM_NODE)
				type = type->ctype.base_type;
			if (!type)
				return 0;
			if (type->type != SYM_PTR)
				goto err;
			type = type->ctype.base_type;
			if (!type)
				return 0;
		}
		if (type->type == SYM_NODE)
			type = type->ctype.base_type;
		if (!type)
			return 0;
		if (type->ctype.base_type != &int_type || type == &bool_ctype)
			goto err;
	} END_FOR_EACH_PTR(arg);

	// the builtin returns a bool
	expr->ctype = &bool_ctype;
	return 1;

err:
	sparse_error(arg->pos, "invalid type for argument %d:", n);
	info(arg->pos, "        %s", show_typename(arg->ctype));
	expr->ctype = &bad_ctype;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x30e0c
xorl %edx, %edx
leaq 0x3b14a(%rip), %rdi     # 0x6be78
leaq 0x3b303(%rip), %r8      # 0x6c038
movq %rcx, %r9
movzwl (%r9), %r11d
movsbl %r11b, %r10d
testw %r10w, %r10w
jle 0x30dfb
movzwl %r10w, %r10d
movzwl %r11w, %r11d
xorl %r15d, %r15d
movq 0x18(%r9,%r15,8), %r14
cmpl $0x100, %r11d           # imm = 0x100
jb 0x30d6c
testq %r14, %r14
je 0x30def
incl %edx
movl $0x1, %ebp
testq %r14, %r14
je 0x30de7
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x30de7
testl %esi, %esi
je 0x30dac
cmpl $0x3, %edx
jne 0x30dac
cmpb $0x3, (%r12)
jne 0x30d96
movq 0x60(%r12), %r12
testq %r12, %r12
je 0x30de7
cmpb $0x4, (%r12)
jne 0x30de2
movq 0x60(%r12), %r12
testq %r12, %r12
je 0x30de7
cmpb $0x3, (%r12)
jne 0x30db8
movq 0x60(%r12), %r12
testq %r12, %r12
je 0x30de7
cmpq %rdi, 0x60(%r12)
sete %bpl
cmpq %r8, %r12
setne %r12b
andb %bpl, %r12b
movl %r12d, %ebp
xorb $0x1, %bpl
movzbl %bpl, %r13d
leal (%r13,%r13,8), %ebp
jmp 0x30dea
movl $0x9, %ebp
xorl %r12d, %r12d
testb %r12b, %r12b
je 0x30e13
incq %r15
cmpq %r15, %r10
jne 0x30d55
movq 0x10(%r9), %r9
cmpq %rcx, %r9
jne 0x30d38
xorl %ebp, %ebp
jmp 0x30e13
movl $0x2, %ebp
xorl %edx, %edx
movl $0x1, %r15d
leaq 0x3b218(%rip), %rcx     # 0x6c038
testl %ebp, %ebp
je 0x30e68
cmpl $0x2, %ebp
je 0x30e68
cmpl $0x9, %ebp
jne 0x30e6f
movq 0x8(%r14), %rdi
leaq 0x19957(%rip), %rsi     # 0x4a790
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x11a38
movq 0x10(%r14), %rdi
callq 0x2386c
movq 0x8(%r14), %rdi
leaq 0x18abb(%rip), %rsi     # 0x49912
movq %rax, %rdx
xorl %eax, %eax
callq 0x11744
leaq 0x3ca50(%rip), %rcx     # 0x6d8b8
movq %rcx, 0x10(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_pure_unop
static int evaluate_pure_unop(struct expression *expr)
{
	struct expression *arg = first_expression(expr->args);
	int flags = arg->flags;

	/*
	 * Allow such functions with a constant integer expression
	 * argument to be treated as a *constant* integer.
	 * This allow us to use them in switch() { case ...:
	 */
	flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
	expr->flags = flags;
	return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x22634
movl (%rax), %eax
movl %eax, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shll $0x13, %eax
sarl $0x1f, %eax
andl $0x3100, %eax           # imm = 0x3100
movl $0xffff00ff, %edx       # imm = 0xFFFF00FF
andl (%rbx), %edx
orl %ecx, %edx
orl %eax, %edx
movl %edx, (%rbx)
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: expand_bswap
static int expand_bswap(struct expression *expr, int cost)
{
	struct expression *arg;
	long long val;

	if (cost)
		return cost;

	/* the arguments number & type have already been checked */
	arg = first_expression(expr->args);
	val = get_expression_value_silent(arg);
	switch (expr->ctype->bit_size) {
	case 16: expr->value = bswap16(val); break;
	case 32: expr->value = bswap32(val); break;
	case 64: expr->value = bswap64(val); break;
	default: /* impossible error */
		return SIDE_EFFECTS;
	}

	expr->type = EXPR_VALUE;
	expr->taint = 0;
	return 0;
}

// Assembly:
testl %esi, %esi
jne 0x30f10
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x22634
movq %rax, %rdi
callq 0xf2fb
movq 0x10(%rbx), %rcx
movl 0x50(%rcx), %ecx
cmpl $0x40, %ecx
je 0x30efc
cmpl $0x20, %ecx
je 0x30ef8
movl $0x2710, %esi           # imm = 0x2710
cmpl $0x10, %ecx
jne 0x30f0f
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x30eff
bswapl %eax
jmp 0x30eff
bswapq %rax
movq %rax, 0x20(%rbx)
movb $0x1, (%rbx)
movl $0x0, 0x28(%rbx)
xorl %esi, %esi
popq %rbx
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: expand_isdigit
static int expand_isdigit(struct expression *expr, int cost)
{
	struct expression *arg = first_expression(expr->args);
	long long val = get_expression_value_silent(arg);

	if (cost)
		return cost;

	expr->value = (val >= '0') && (val <= '9');
	expr->type = EXPR_VALUE;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x22634
movq %rax, %rdi
callq 0xf2fb
testl %ebp, %ebp
jne 0x31101
addq $-0x30, %rax
xorl %ecx, %ecx
cmpq $0xa, %rax
setb %cl
movq %rcx, 0x20(%rbx)
movb $0x1, (%rbx)
movl $0x0, 0x28(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_fp_unop
static int evaluate_fp_unop(struct expression *expr)
{
	struct expression *arg;

	if (!eval_args(expr, 1))
		return 0;

	arg = first_expression(expr->args);
	if (!is_float_type(arg->ctype)) {
		expression_error(expr, "non-floating-point argument in call to %s()",
			show_ident(expr->fn->ctype->ident));
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x3076f
testl %eax, %eax
je 0x3116a
movq 0x28(%rbx), %rdi
callq 0x22634
movq 0x10(%rax), %rax
cmpb $0x3, (%rax)
jne 0x31134
movq 0x60(%rax), %rax
movq 0x60(%rax), %rax
cmpq 0x2fe01(%rip), %rax     # 0x60f40
je 0x3116e
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2e465
leaq 0x19659(%rip), %rsi     # 0x4a7b2
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11abc
jmp 0x31173
xorl %ebp, %ebp
jmp 0x31173
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/./compat/mmap-blob.c
// Function: blob_alloc
void *blob_alloc(unsigned long size)
{
	void *ptr;

	if (size & ~CHUNK)
		die("internal error: bad allocation size (%lu bytes)", size);
	ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (ptr == MAP_FAILED)
		ptr = NULL;
	return ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rsi
testq $-0x8001, %rdi          # imm = 0xFFFF7FFF
jne 0x3144b
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0xe0e0
cmpq $-0x1, %rax
cmoveq %rbx, %rax
popq %rbx
retq
leaq 0x1938c(%rip), %rdi     # 0x4a7de
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/./compat/mmap-blob.c
// Function: blob_free
void blob_free(void *addr, unsigned long size)
{
	if (!size || (size & ~CHUNK) || ((unsigned long) addr & 512))
		die("internal error: bad blob free (%lu bytes at %p)", size, addr);
#ifndef DEBUG
	munmap(addr, size);
#else
	mprotect(addr, size, PROT_NONE);
#endif
}

// Assembly:
movq %rdi, %rdx
cmpq $0x8000, %rsi           # imm = 0x8000
jne 0x31476
movl %edx, %eax
andl $0x200, %eax            # imm = 0x200
jne 0x31476
movq %rdx, %rdi
jmp 0xe240
pushq %rax
leaq 0x19390(%rip), %rdi     # 0x4a80e
xorl %eax, %eax
callq 0x11bea
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/cse.c
// Function: phi_list_compare
static int phi_list_compare(struct pseudo_list *l1, struct pseudo_list *l2)
{
	pseudo_t phi1, phi2;

	PREPARE_PTR_LIST(l1, phi1);
	PREPARE_PTR_LIST(l2, phi2);
	for (;;) {
		int cmp;

		while (phi1 && (phi1 == VOID || !phi1->def))
			NEXT_PTR_LIST(phi1);
		while (phi2 && (phi2 == VOID || !phi2->def))
			NEXT_PTR_LIST(phi2);

		if (!phi1)
			return phi2 ? -1 : 0;
		if (!phi2)
			return phi1 ? 1 : 0;
		cmp = phi_compare(phi1, phi2);
		if (cmp)
			return cmp;
		NEXT_PTR_LIST(phi1);
		NEXT_PTR_LIST(phi2);
	}
	/* Not reached, but we need to make the nesting come out right */
	FINISH_PTR_LIST(phi2);
	FINISH_PTR_LIST(phi1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %edx, %edx
testq %rdi, %rdi
je 0x31a49
movq %rdi, %rcx
cmpb $0x0, (%rcx)
jg 0x31a53
movq 0x10(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x31a39
jmp 0x31a4b
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r10d, %r10d
jmp 0x31a61
movq 0x18(%rcx), %r10
andq $-0x4, %r10
movl $0x1, %r8d
testq %rsi, %rsi
je 0x31a7e
movq %rsi, %r9
cmpb $0x0, (%r9)
jg 0x31a85
movq 0x10(%r9), %r9
cmpq %rsi, %r9
jne 0x31a69
xorl %ebx, %ebx
xorl %edx, %edx
jmp 0x31a92
xorl %ebx, %ebx
xorl %r9d, %r9d
jmp 0x31a92
movq 0x18(%r9), %rbx
andq $-0x4, %rbx
movl $0x1, %edx
leaq 0x34f37(%rip), %r11     # 0x669d0
testq %r10, %r10
sete %bpl
je 0x31aed
cmpq %r11, %r10
je 0x31aae
cmpq $0x0, 0x18(%r10)
jne 0x31aed
movsbl (%rcx), %r10d
cmpl %r10d, %r8d
jl 0x31b16
movq 0x10(%rcx), %rcx
xorl %r8d, %r8d
cmpq %rdi, %rcx
jne 0x31aae
xorl %r10d, %r10d
jmp 0x31a99
movsbl (%r9), %ebx
cmpl %ebx, %edx
jl 0x31adf
movq 0x10(%r9), %r9
xorl %edx, %edx
cmpq %rsi, %r9
jne 0x31ac8
xorl %ebx, %ebx
jmp 0x31aed
movslq %edx, %rbx
movq 0x18(%r9,%rbx,8), %rbx
andq $-0x4, %rbx
incl %edx
testq %rbx, %rbx
setne %r14b
je 0x31b02
cmpq %r11, %rbx
je 0x31ac8
cmpq $0x0, 0x18(%rbx)
je 0x31ac8
testb $0x1, %bpl
je 0x31b2a
movzbl %r14b, %eax
andl $0x1, %eax
negl %eax
xorl %r10d, %r10d
jmp 0x31b86
movslq %r8d, %r10
movq 0x18(%rcx,%r10,8), %r10
andq $-0x4, %r10
incl %r8d
jmp 0x31a99
testb $0x1, %r14b
je 0x31b7f
movq 0x18(%r10), %r14
movq 0x18(%rbx), %r15
movq 0x30(%r15), %r12
cmpq %r12, 0x30(%r14)
jne 0x31b50
movq 0x8(%r15), %r15
cmpq %r15, 0x8(%r14)
je 0x31bd0
movl $0x0, %ebp
sbbl %ebp, %ebp
orl $0x1, %ebp
testl %ebp, %ebp
je 0x31b65
xorl %r14d, %r14d
movl %ebp, %eax
jmp 0x31b89
movsbl (%rcx), %r10d
cmpl %r10d, %r8d
jl 0x31b94
movq 0x10(%rcx), %rcx
xorl %r8d, %r8d
cmpq %rdi, %rcx
jne 0x31b65
xorl %r10d, %r10d
jmp 0x31ba3
movl $0x1, %eax
xorl %ebx, %ebx
xorl %r14d, %r14d
testb %r14b, %r14b
jne 0x31a99
jmp 0x31bd4
movslq %r8d, %r10
movq 0x18(%rcx,%r10,8), %r10
andq $-0x4, %r10
incl %r8d
movsbl (%r9), %ebx
cmpl %ebx, %edx
jl 0x31bbd
movq 0x10(%r9), %r9
xorl %edx, %edx
cmpq %rsi, %r9
jne 0x31ba3
movb $0x1, %r14b
xorl %ebx, %ebx
jmp 0x31b89
movslq %edx, %rbx
movq 0x18(%r9,%rbx,8), %rbx
andq $-0x4, %rbx
incl %edx
movb $0x1, %r14b
jmp 0x31b89
xorl %ebp, %ebp
jmp 0x31b5a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dominate.c
// Function: idf_compute
void idf_compute(struct entrypoint *ep, struct basic_block_list **idf, struct basic_block_list *alpha)
{
	int levels = ep->dom_levels;
	struct piggy *bank = bank_init(levels);
	struct basic_block *bb;
	unsigned long generation = bb_generation;

	generation = bb_generation;
	generation += -generation & FLAGS;
	bb_generation = generation + (FLAGS + 1);

	// init all the nodes
	FOR_EACH_PTR(ep->bbs, bb) {
		// FIXME: this should be removed and the tests for
		//	  visited/in_phi/alpha should use a sparse set
		bb->generation = generation;
	} END_FOR_EACH_PTR(bb);

	FOR_EACH_PTR(alpha, bb) {
		bb->generation = generation | ALPHA;
		bank_put(bank, bb);
	} END_FOR_EACH_PTR(bb);

	while ((bb = bank_get(bank))) {
		visit(bank, idf, bb, bb->dom_level);
	}

	bank_free(bank, levels);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r12
movl 0x30(%rdi), %r13d
leaq 0x8(,%r13,8), %rsi
movl $0x1, %edi
callq 0xe1b0
movq %rax, %rbx
leal -0x1(%r13), %eax
movl %eax, (%rbx)
leaq 0x5f35d(%rip), %rax     # 0x90f78
movq (%rax), %rcx
movl %ecx, %edx
negl %edx
andl $0x7, %edx
leaq (%rdx,%rcx), %rbp
addq %rdx, %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x31c7a
movq %rax, %rcx
movzwl (%rcx), %esi
testb %sil, %sil
jle 0x31c71
xorl %edx, %edx
movq 0x18(%rcx,%rdx,8), %rdi
movzwl %si, %esi
cmpl $0x100, %esi            # imm = 0x100
jb 0x31c5f
testq %rdi, %rdi
je 0x31c63
movq %rbp, 0x8(%rdi)
incq %rdx
movl (%rcx), %esi
movsbq %sil, %rdi
cmpq %rdi, %rdx
jl 0x31c4a
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x31c40
cmpq $0x0, (%rsp)
je 0x31cd0
orq $0x4, %rbp
movq (%rsp), %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x31cc5
xorl %r15d, %r15d
movq 0x18(%r12,%r15,8), %rsi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x31ca9
testq %rsi, %rsi
je 0x31cb5
movq %rbp, 0x8(%rsi)
movq %rbx, %rdi
callq 0x31d4a
incq %r15
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0x31c95
movq 0x10(%r12), %r12
cmpq (%rsp), %r12
jne 0x31c89
leaq 0x8(%rbx), %r12
movl (%rbx), %ebp
movslq %ebp, %rax
leaq (%r12,%rax,8), %rdi
callq 0x22b54
xorl %ecx, %ecx
testq %rax, %rax
je 0x31cee
movq %rax, %r15
jmp 0x31cff
testl %ebp, %ebp
je 0x31cfa
decl %ebp
movl %ebp, (%rbx)
movb $0x1, %cl
jmp 0x31cff
xorl %ebp, %ebp
xorl %r15d, %r15d
testb %cl, %cl
jne 0x31cd6
testq %r15, %r15
je 0x31d1c
movl 0x3c(%r15), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x31d7e
jmp 0x31cd4
testq %r13, %r13
je 0x31d34
shlq $0x3, %r13
leaq (%rbx,%r13), %rdi
callq 0x22cf3
addq $-0x8, %r13
jne 0x31d25
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe030
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dominate.c
// Function: visit
static void visit(struct piggy *bank, struct basic_block_list **idf, struct basic_block *x, int curr_level)
{
	struct basic_block *y;

	x->generation |= 1;
	FOR_EACH_PTR(x->children, y) {
		unsigned flags = y->generation & FLAGS;
		if (y->idom == x)	// J-edges will be processed later
			continue;
		if (y->dom_level > curr_level)
			continue;
		if (flags & INPHI)
			continue;
		y->generation |= INPHI;
		add_bb(idf, y);
		if (flags & ALPHA)
			continue;
		bank_put(bank, y);
	} END_FOR_EACH_PTR(y);

	FOR_EACH_PTR(x->doms, y) {
		if (y->generation & VISITED)
			continue;
		visit(bank, idf, y, curr_level);
	} END_FOR_EACH_PTR(y);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r12
orb $0x1, 0x8(%rdx)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x20(%rdx), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x31e3a
movq (%rsp), %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0x31e2c
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %r13
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x31dd3
testq %r13, %r13
je 0x31e1d
cmpq %r12, 0x30(%r13)
je 0x31e1d
movq 0x8(%r13), %r14
cmpl %ebx, 0x3c(%r13)
setle %al
testb $0x2, %r14b
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x31e1d
movq %r14, %rax
orq $0x2, %rax
movq %rax, 0x8(%r13)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2285b
testb $0x4, %r14b
jne 0x31e1d
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x31d4a
incq %r15
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0x31dbf
movq 0x10(%rbp), %rbp
cmpq (%rsp), %rbp
jne 0x31db4
movq 0x40(%r12), %r15
testq %r15, %r15
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
je 0x31e9e
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x31e94
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rdx
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x31e71
testq %rdx, %rdx
je 0x31e84
testb $0x1, 0x8(%rdx)
jne 0x31e84
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x31d7e
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0x31e5d
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x31e51
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dominate.c
// Function: idf_dump
void idf_dump(struct entrypoint *ep)
{
	struct basic_block *bb;

	domtree_build(ep);

	printf("%s's IDF:\n", show_ident(ep->name->ident));
	FOR_EACH_PTR(ep->bbs, bb) {
		struct basic_block_list *alpha = NULL;
		struct basic_block_list *idf = NULL;
		struct basic_block *df;

		add_bb(&alpha, bb);
		idf_compute(ep, &idf, alpha);

		printf("\t%s\t<-", show_label(bb));
		FOR_EACH_PTR(idf, df) {
			printf(" %s", show_label(df));
		} END_FOR_EACH_PTR(df);
		printf("\n");

		free_ptr_list(&idf);
		free_ptr_list(&alpha);
	} END_FOR_EACH_PTR(bb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3dc61
movq (%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x2e465
leaq 0x18b1e(%rip), %rdi     # 0x4a9f4
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq %rbx, 0x20(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x32010
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x17a11(%rip), %r13     # 0x49919
movq 0x18(%rsp), %rbx
movzwl (%rbx), %eax
testb %al, %al
jle 0x32001
xorl %r12d, %r12d
movq 0x18(%rbx,%r12,8), %rbp
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x31f33
testq %rbp, %rbp
je 0x31fef
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2285b
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x31be0
movq %rbp, %rdi
callq 0x12271
leaq 0x18a94(%rip), %rdi     # 0x4a9ff
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x31fcb
movq %r14, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0x31fc2
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x31fa1
testq %rdi, %rdi
je 0x31fb3
callq 0x12271
movq %r13, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
incq %r15
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0x31f8d
movq 0x10(%rbp), %rbp
cmpq %r14, %rbp
jne 0x31f82
movl $0xa, %edi
callq 0xe040
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x22cf3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x22cf3
incq %r12
movl (%rbx), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x31f1b
movq 0x10(%rbx), %rbx
cmpq 0x18(%rsp), %rbx
jne 0x31f0d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: examine_fn_arguments
static void examine_fn_arguments(struct symbol *fn)
{
	struct symbol *s;

	FOR_EACH_PTR(fn->arguments, s) {
		struct symbol *arg = evaluate_symbol(s);
		/* Array/function arguments silently degenerate into pointers */
		if (arg) {
			struct symbol *ptr;
			switch(arg->type) {
			case SYM_ARRAY:
			case SYM_FN:
				ptr = alloc_symbol(s->pos, SYM_PTR);
				if (arg->type == SYM_ARRAY)
					ptr->ctype = arg->ctype;
				else
					ptr->ctype.base_type = arg;
				combine_address_space(s->pos, &ptr->ctype.as, s->ctype.as);
				ptr->ctype.modifiers |= s->ctype.modifiers & MOD_PTRINHERIT;

				s->ctype.base_type = ptr;
				s->ctype.as = NULL;
				s->ctype.modifiers &= ~MOD_PTRINHERIT;
				s->bit_size = 0;
				s->examined = 0;
				examine_symbol_type(s);
				break;
			default:
				/* nothing */
				break;
			}
		}
	} END_FOR_EACH_PTR(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x88(%rdi), %rbp
testq %rbp, %rbp
je 0x328d9
movq %rbp, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x328cc
xorl %ebx, %ebx
movq 0x18(%r13,%rbx,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x327d9
testq %r14, %r14
je 0x328b8
movq %r14, %rdi
callq 0x366a3
testq %rax, %rax
je 0x328b8
movq %rax, %r12
movb (%rax), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x328b8
movq 0x4(%r14), %rdi
movl $0x4, %esi
callq 0x2b547
movq %rax, %r15
addq $0x60, %rax
cmpb $0x6, (%r12)
jne 0x32836
movq 0x80(%r12), %rcx
movq %rcx, 0x20(%rax)
movups 0x60(%r12), %xmm0
movups 0x70(%r12), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x32839
movq %r12, (%rax)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x3287f
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x32878
cmpq %rax, %rcx
je 0x3287f
movq 0x4(%r14), %rdi
leaq 0x33b7f(%rip), %rax     # 0x663e0
movq %rax, 0x80(%r15)
leaq 0x1524d(%rip), %rsi     # 0x47abc
xorl %eax, %eax
callq 0x11a38
jmp 0x3287f
movq %rax, 0x80(%r15)
movq 0x68(%r14), %rax
andl $0x1c001e00, %eax       # imm = 0x1C001E00
orq %rax, 0x68(%r15)
movq %r15, 0x60(%r14)
movq $0x0, 0x80(%r14)
andl $0xe3ffe1ff, 0x68(%r14) # imm = 0xE3FFE1FF
movl $0x0, 0x50(%r14)
andb $-0x9, 0x55(%r14)
movq %r14, %rdi
callq 0x2b5f4
incq %rbx
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jl 0x327c1
movq 0x10(%r13), %r13
cmpq %rbp, %r13
jne 0x327b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: classify_type
static inline int classify_type(struct symbol *type, struct symbol **base)
{
	static int type_class[SYM_BAD + 1] = {
		[SYM_PTR] = TYPE_PTR,
		[SYM_FN] = TYPE_PTR | TYPE_FN,
		[SYM_ARRAY] = TYPE_PTR | TYPE_COMPOUND,
		[SYM_STRUCT] = TYPE_COMPOUND,
		[SYM_UNION] = TYPE_COMPOUND,
		[SYM_BITFIELD] = TYPE_NUM | TYPE_BITFIELD,
		[SYM_RESTRICT] = TYPE_NUM | TYPE_RESTRICT,
		[SYM_FOULED] = TYPE_NUM | TYPE_RESTRICT | TYPE_FOULED,
	};
	if (type->type == SYM_NODE)
		type = type->ctype.base_type;
	if (type->type == SYM_TYPEOF) {
		type = examine_symbol_type(type);
		if (type->type == SYM_NODE)
			type = type->ctype.base_type;
	}
	if (type->type == SYM_ENUM)
		type = type->ctype.base_type;
	*base = type;
	if (type->type == SYM_BASETYPE) {
		if (type->ctype.base_type == &int_type)
			return TYPE_NUM;
		if (type->ctype.base_type == &fp_type)
			return TYPE_NUM | TYPE_FLOAT;
	}
	return type_class[type->type];
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x3, (%rdi)
jne 0x33472
movq 0x60(%rdi), %rdi
cmpb $0xa, (%rdi)
jne 0x33488
callq 0x2b5f4
movq %rax, %rdi
cmpb $0x3, (%rax)
jne 0x33488
movq 0x60(%rdi), %rdi
cmpb $0x9, (%rdi)
jne 0x33491
movq 0x60(%rdi), %rdi
movq %rdi, (%rbx)
movzbl (%rdi), %eax
cmpq $0x2, %rax
jne 0x334b3
movq 0x60(%rdi), %rcx
cmpq 0x2dad8(%rip), %rcx     # 0x60f80
je 0x334bf
cmpq 0x2da8f(%rip), %rcx     # 0x60f40
je 0x334c6
leaq 0x17786(%rip), %rcx     # 0x4ac40
movl (%rcx,%rax,4), %eax
jmp 0x334cb
movl $0x1, %eax
jmp 0x334cb
movl $0x9, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: cast_to
static struct expression * cast_to(struct expression *old, struct symbol *type)
{
	struct expression *expr;

	warn_for_different_enum_types (old->pos, old->ctype, type);

	if (old->ctype != &null_ctype && is_same_type(old, type))
		return old;

	expr = alloc_expression(old->pos, EXPR_IMPLIED_CAST);
	expr->ctype = type;
	expr->cast_type = type;
	expr->cast_expression = old;
	expr->flags = cast_flags(expr, old);

	if (is_bool_type(type))
		cast_to_bool(expr);

	return expr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
callq 0x37001
movq 0x10(%r14), %rdi
cmpq 0x2dab6(%rip), %rdi     # 0x60fb0
je 0x335b8
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x37274
movq %rax, %r15
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x37274
cmpq %rax, %r15
jne 0x33561
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x33561
movq (%rsp), %rax
xorq 0x8(%rsp), %rax
andq $-0x4000001, %rax       # imm = 0xFBFFFFFF
je 0x33552
cmpq $0x200, %rax            # imm = 0x200
jne 0x3355b
xorl %eax, %eax
xorl %ebp, %ebp
jmp 0x3355d
movl $0x1, %ebp
xorl %eax, %eax
jmp 0x3355d
movb $0x1, %al
testb %al, %al
je 0x335af
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movl %ecx, %edx
orl %eax, %edx
xorl %ebp, %ebp
btl $0x1a, %edx
jae 0x335af
btl $0x1a, %ecx
leaq 0xf21b(%rip), %rcx      # 0x4279c
leaq 0x17976(%rip), %rsi     # 0x4aefe
cmovaeq %rcx, %rsi
btl $0x1a, %eax
leaq 0x110e1(%rip), %rdx     # 0x44678
cmovbq %rsi, %rdx
movq 0x8(%r14), %rdi
leaq 0x17960(%rip), %rsi     # 0x4af06
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x118b4
testl %ebp, %ebp
je 0x335b8
movq %r14, %r15
jmp 0x33618
movq 0x8(%r14), %r12
xorl %edi, %edi
callq 0x30029
movq %rax, %r15
movl (%rax), %eax
orl $0xd, %eax
movq %r12, 0x8(%r15)
andl $0xffff000d, %eax       # imm = 0xFFFF000D
movl %eax, (%r15)
movq %rbx, 0x10(%r15)
movq %rbx, 0x20(%r15)
movq %r14, 0x28(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x37092
shll $0x8, %eax
movl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
andl (%r15), %ecx
orl %eax, %ecx
movl %ecx, (%r15)
cmpb $0x3, (%rbx)
jne 0x33607
movq 0x60(%rbx), %rbx
cmpq 0x2d9d2(%rip), %rbx     # 0x60fe0
jne 0x33618
movq %r15, %rdi
callq 0x37144
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_symbol_expression
static struct symbol *evaluate_symbol_expression(struct expression *expr)
{
	struct expression *addr;
	struct symbol *sym = expr->symbol;
	struct symbol *base_type;

	if (!sym) {
		expression_error(expr, "undefined identifier '%s'", show_ident(expr->symbol_name));
		return NULL;
	}

	examine_symbol_type(sym);

	base_type = get_base_type(sym);
	if (!base_type) {
		expression_error(expr, "identifier '%s' has no type", show_ident(expr->symbol_name));
		return NULL;
	}

	addr = alloc_expression(expr->pos, EXPR_SYMBOL);
	addr->symbol = sym;
	addr->symbol_name = expr->symbol_name;
	addr->ctype = &lazy_ptr_ctype;	/* Lazy evaluation: we need to do a proper job if somebody does &sym */
	addr->flags = expr->flags;
	expr->type = EXPR_PREOP;
	expr->op = '*';
	expr->unop = addr;
	expr->flags = CEF_NONE;

	/* The type of a symbol is the symbol itself! */
	expr->ctype = sym;
	return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rbx
testq %rbx, %rbx
je 0x33aeb
movq %rbx, %rdi
callq 0x2b5f4
movq 0x60(%rbx), %rdi
callq 0x2b5f4
testq %rax, %rax
je 0x33afd
movq 0x8(%r14), %r15
xorl %edi, %edi
callq 0x30029
movl (%rax), %ecx
orl $0x3, %ecx
movq %r15, 0x8(%rax)
andl $0xffff0003, %ecx       # imm = 0xFFFF0003
movl %ecx, (%rax)
movq %rbx, 0x20(%rax)
movq 0x28(%r14), %rdx
movq %rdx, 0x28(%rax)
leaq 0x39b5e(%rip), %rdx     # 0x6d618
movq %rdx, 0x10(%rax)
movzbl 0x1(%r14), %edx
shll $0x8, %edx
orl %ecx, %edx
movl %edx, (%rax)
movl (%r14), %ecx
orl $0x9, %ecx
movl $0x2a, 0x4(%r14)
movq %rax, 0x20(%r14)
andl $0xffff0009, %ecx       # imm = 0xFFFF0009
movl %ecx, (%r14)
movq %rbx, 0x10(%r14)
jmp 0x33b1c
movq 0x28(%r14), %rdi
callq 0x2e465
leaq 0x17520(%rip), %rsi     # 0x4b01b
jmp 0x33b0d
movq 0x28(%r14), %rdi
callq 0x2e465
leaq 0x17528(%rip), %rsi     # 0x4b035
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11abc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_logical
static struct symbol *evaluate_logical(struct expression *expr)
{
	if (!evaluate_conditional(expr->left, 0))
		return NULL;
	if (!evaluate_conditional(expr->right, 0))
		return NULL;

	/* the result is int [6.5.13(3), 6.5.14(3)] */
	expr->ctype = &int_ctype;
	expr->flags = expr->left->flags & expr->right->flags;
	expr->flags &= ~(CEF_CONST_MASK | CEF_ADDR);
	return &int_ctype;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbp
movq 0x20(%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x38093
testq %rax, %rax
je 0x34218
movq 0x28(%rbp), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x38093
testq %rax, %rax
je 0x34218
leaq 0x38538(%rip), %rbx     # 0x6c738
movq %rbx, 0x10(%rbp)
movq 0x20(%rbp), %rax
movq 0x28(%rbp), %rcx
movl (%rax), %eax
andl (%rcx), %eax
andl $0xb400, %eax           # imm = 0xB400
movb %ah, 0x1(%rbp)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_comma
static struct symbol *evaluate_comma(struct expression *expr)
{
	expr->ctype = unqualify_type(degenerate(expr->right));
	if (expr->ctype == &null_ctype)
		expr->ctype = &ptr_ctype;
	expr->flags &= expr->left->flags & expr->right->flags;
	return expr->ctype;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x33628
movq %rax, %rdi
callq 0x36fb5
cmpq 0x2cd72(%rip), %rax     # 0x60fb0
jne 0x34247
leaq 0x392f1(%rip), %rax     # 0x6d538
movq %rax, 0x10(%rbx)
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rdx
movl (%rcx), %ecx
andl (%rdx), %ecx
orl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
andl %ecx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_postop
static struct symbol *evaluate_postop(struct expression *expr)
{
	struct expression *op = expr->unop;
	struct symbol *ctype = op->ctype;
	int class = classify_type(ctype, &ctype);
	int multiply = 0;

	if (!class || class & TYPE_COMPOUND) {
		expression_error(expr, "need scalar for ++/--");
		return NULL;
	}
	if (!lvalue_expression(expr->unop)) {
		expression_error(expr, "need lvalue expression for ++/--");
		return NULL;
	}

	unrestrict(expr, class, &ctype);

	if (class & TYPE_NUM) {
		multiply = 1;
	} else if (class == TYPE_PTR) {
		struct symbol *target = examine_pointer_target(ctype);
		if (!is_function(target))
			multiply = bits_to_bytes(target->bit_size);
	}

	if (multiply) {
		evaluate_assign_to(op, op->ctype);
		expr->op_value = multiply;
		expr->ctype = ctype;
		return ctype;
	}

	expression_error(expr, "bad argument type for ++/--");
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r15
movq 0x10(%r15), %rbx
cmpb $0x3, (%rbx)
jne 0x35059
movq 0x60(%rbx), %rbx
cmpb $0xa, (%rbx)
jne 0x35072
movq %rbx, %rdi
callq 0x2b5f4
movq %rax, %rbx
cmpb $0x3, (%rax)
jne 0x35072
movq 0x60(%rbx), %rbx
cmpb $0x9, (%rbx)
jne 0x3507b
movq 0x60(%rbx), %rbx
movzbl (%rbx), %eax
cmpq $0x2, %rax
jne 0x3509a
movq 0x60(%rbx), %rcx
cmpq 0x2bef1(%rip), %rcx     # 0x60f80
je 0x350a7
cmpq 0x2bea8(%rip), %rcx     # 0x60f40
je 0x350af
leaq 0x15b9f(%rip), %rcx     # 0x4ac40
movl (%rcx,%rax,4), %r12d
jmp 0x350b5
movl $0x1, %r12d
jmp 0x350b5
movl $0x9, %r12d
testl %r12d, %r12d
setne %al
testb $0x20, %r12b
sete %cl
testb %cl, %al
je 0x3514e
movq 0x20(%r14), %rax
cmpb $0x9, (%rax)
jne 0x35157
cmpl $0x2a, 0x4(%rax)
jne 0x35157
testb $0x4, %r12b
je 0x3510e
testb $0x40, %r12b
je 0x350ed
movq 0x60(%rbx), %rbx
movq %rbx, %rdi
callq 0x2386c
movq 0x8(%r14), %rdi
leaq 0x15e23(%rip), %rsi     # 0x4af23
movq %rax, %rdx
xorl %eax, %eax
callq 0x118b4
movq 0x60(%rbx), %rbx
movl $0x1, %ebp
testb $0x1, %r12b
jne 0x3517b
xorl %ebp, %ebp
cmpl $0x10, %r12d
jne 0x3517b
movq %rbx, %rdi
callq 0x2bfd0
testq %rax, %rax
je 0x35133
cmpb $0x5, (%rax)
je 0x3517b
movl 0x50(%rax), %eax
testl %eax, %eax
js 0x35176
leaq 0x305bf(%rip), %rcx     # 0x65700
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
cltd
idivl %ecx
movl %eax, %ebp
jmp 0x3517b
leaq 0x16203(%rip), %rsi     # 0x4b358
jmp 0x3515e
leaq 0x16210(%rip), %rsi     # 0x4b36e
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11abc
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebp, %ebp
je 0x35198
movq 0x10(%r15), %rsi
movq %r15, %rdi
callq 0x381e1
movslq %ebp, %rax
movq %rax, 0x28(%r14)
movq %rbx, 0x10(%r14)
jmp 0x3516a
leaq 0x161f0(%rip), %rsi     # 0x4b38f
jmp 0x3515e