LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, 0x5d594(%rip)     # 0x8c620
leal 0x1(%r14), %eax
leaq 0x19189(%rip), %rcx     # 0x48220
movzbl (%rax,%rcx), %ebp
testb $0x13, %bpl
je 0x2f177
leaq 0x5d575(%rip), %r13     # 0x8c621
leaq 0x5e56c(%rip), %r12     # 0x8d61f
movq %r12, %r15
cmpq %r12, %r13
je 0x2f0c5
movb %r14b, (%r13)
incq %r13
movq %r13, %r15
movq %rbx, %rdi
callq 0x2ee53
movl %eax, %r14d
testb $0x8, %bpl
je 0x2f100
cmpl $0x2d, %r14d
je 0x2f0e2
cmpl $0x2b, %r14d
jne 0x2f100
movq %r12, %r13
cmpq %r12, %r15
je 0x2f0f3
movb %r14b, (%r15)
incq %r15
movq %r15, %r13
movq %rbx, %rdi
callq 0x2ee53
movl %eax, %r14d
jmp 0x2f103
movq %r15, %r13
leal 0x1(%r14), %eax
leaq 0x19112(%rip), %rcx     # 0x48220
movzbl (%rax,%rcx), %ebp
testb $0x13, %bpl
jne 0x2f0b3
leaq 0x5e500(%rip), %rax     # 0x8d61f
cmpq %rax, %r13
jne 0x2f17e
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 0x193e0(%rip), %rsi     # 0x48544
movl $0xfff, %edx            # imm = 0xFFF
xorl %eax, %eax
callq 0x11a80
movb $0x31, 0x5d4a9(%rip)    # 0x8c620
leaq 0x5d4a3(%rip), %r13     # 0x8c621
movb $0x0, (%r13)
movq 0x28(%rbx), %r15
movq (%r15), %rax
andq $-0x40, %rax
orq $0x5, %rax
movq %rax, (%r15)
leaq 0x5d484(%rip), %rdi     # 0x8c620
subq %rdi, %r13
incq %r13
movq %r13, %rsi
callq 0x2f572
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_O3/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 0x2f6ec
movq (%rdi), %r14
movl 0x14(%rbx), %esi
callq 0x30d39
movq %r14, %rdi
testq %r14, %r14
jne 0x2f6d9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x2f737
movq (%rax), %rcx
movq %rcx, 0x18(%r14)
movl %esi, %ecx
xorl %edx, %edx
movq $0x0, (%rax,%rdx)
addq $0x8, %rdx
cmpl %edx, %ecx
jne 0x2f722
jmp 0x2f7c0
movl 0x10(%r14), %r13d
movq 0x8(%r14), %r12
incl 0x20(%r14)
movl %esi, %eax
addq %rax, 0x30(%r14)
leal (%rsi,%r13), %eax
decl %eax
movq %r13, %r15
negq %r15
movl %r15d, %ebp
andl %eax, %ebp
testq %r12, %r12
je 0x2f768
movl 0x8(%r12), %ebx
cmpl %ebp, %ebx
jae 0x2f7a2
movl 0x14(%r14), %ebx
movq %rbx, %rdi
callq 0x30cf8
testq %rax, %rax
je 0x2f7cf
cmpl %ebp, %ebx
jb 0x2f7d8
addq %rbx, 0x28(%r14)
movq %r12, (%rax)
movq %rax, 0x8(%r14)
addl $0xf, %r13d
andl %r13d, %r15d
subl %r15d, %ebx
movl %ebx, 0x8(%rax)
addl $-0x10, %r15d
movl %r15d, 0xc(%rax)
movq %rax, %r12
jmp 0x2f7a7
movl 0xc(%r12), %r15d
movl %r15d, %eax
addq %r12, %rax
addq $0x10, %rax
addl %ebp, %r15d
movl %r15d, 0xc(%r12)
subl %ebp, %ebx
movl %ebx, 0x8(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18f72(%rip), %rdi     # 0x48748
jmp 0x2f7df
leaq 0x18f77(%rip), %rdi     # 0x48756
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/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 0x300d1
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x300d1
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x5f625(%rip), %r13     # 0x8f620
movl 0xc(%rsp), %edi
movl $0x3, %edx
movl $0x10, %ecx
callq 0x2bf00
movq %rax, %r14
movq 0x4(%rax), %rdi
movl $0x5, %esi
callq 0x2b00b
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 0x3004e
leaq 0x345d5(%rip), %rax     # 0x64620
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 0x300bb
addq $0x88, %r15
movq 0x10(%rsp), %r12
movq 0x4(%r14), %rdi
movl $0x3, %esi
callq 0x2b00b
cmpq %r13, %rbp
jne 0x3009f
leaq 0x34584(%rip), %rcx     # 0x64620
movq (%rcx), %rbp
movq %rbp, 0x60(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x227b4
movq (%r12), %rbp
addq $0x8, %r12
testq %rbp, %rbp
jne 0x30082
addq $0x58, %rbx
movq (%rbx), %rsi
addq $0x58, 0x10(%rsp)
testq %rsi, %rsi
jne 0x2fffb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movq %rdi, (%rsp)
movq 0x28(%rdi), %r14
movl $0x1, %ebp
testq %r14, %r14
je 0x30184
xorl %r13d, %r13d
movq %r14, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x3017a
xorl %ebx, %ebx
movq 0x18(%r12,%rbx,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x30152
testq %rdi, %rdi
je 0x3016b
testl %r15d, %r15d
je 0x30192
decl %r15d
callq 0x32223
testq %rax, %rax
cmovel %r13d, %ebp
movzwl (%r12), %eax
incq %rbx
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %rbx
jl 0x3013d
movq 0x10(%r12), %r12
cmpq %r14, %r12
jne 0x30132
testl %r15d, %r15d
jle 0x301c7
leaq 0x18710(%rip), %r14     # 0x488a0
jmp 0x30199
leaq 0x186f4(%rip), %r14     # 0x4888d
movq (%rsp), %rbx
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2de35
leaq 0x18700(%rip), %rsi     # 0x488b5
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11b04
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_O3/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
xorl %ecx, %ecx
movq %rax, %rdx
movzwl (%rdx), %edi
movsbl %dil, %esi
testw %si, %si
jle 0x3048d
movzwl %si, %esi
movzwl %di, %edi
xorl %r8d, %r8d
movq 0x18(%rdx,%r8,8), %r9
cmpl $0x100, %edi            # imm = 0x100
jb 0x3047c
testq %r9, %r9
je 0x30485
movslq %ecx, %r10
incl %ecx
movq %r9, (%rsp,%r10,8)
incq %r8
cmpq %r8, %rsi
jne 0x3046a
movq 0x10(%rdx), %rdx
cmpq %rax, %rdx
jne 0x30455
movq (%rsp), %rdi
callq 0xf401
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_O3/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 0x225b0
testq %rax, %rax
je 0x3053c
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_O3/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 0x30610
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
leaq 0x1919b(%rip), %r14     # 0x4971e
movq %r15, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x30602
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rcx
movzwl %ax, %edx
cmpl $0x100, %edx            # imm = 0x100
jb 0x305a7
testq %rcx, %rcx
je 0x305f3
movzbl (%rcx), %edx
cmpl $0x1, %edx
je 0x305ec
cmpl $0x3, %edx
jne 0x30610
movq 0x20(%rcx), %rcx
movq 0xb0(%rcx), %rcx
testq %rcx, %rcx
je 0x305f3
cmpb $0x2, (%rcx)
jne 0x305f3
movq 0x28(%rcx), %rcx
movl (%rcx), %edx
andl %ebp, %edx
decl %edx
addq $0x4, %rcx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x118fc
movzwl (%r12), %eax
jmp 0x305f3
cmpq $0x0, 0x20(%rcx)
je 0x30610
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x30592
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x30586
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_O3/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), %rdi
movl $0x1, %ebp
testq %rdi, %rdi
je 0x3072a
xorl %edx, %edx
leaq 0x3a9d5(%rip), %rcx     # 0x6b038
leaq 0x3a80e(%rip), %r8      # 0x6ae78
movq %rdi, %r9
movzwl (%r9), %eax
movsbl %al, %r10d
testw %r10w, %r10w
jle 0x3071b
movzwl %r10w, %r10d
movzwl %ax, %r11d
xorl %r15d, %r15d
movq 0x18(%r9,%r15,8), %r14
cmpl $0x100, %r11d           # imm = 0x100
jb 0x3069d
testq %r14, %r14
je 0x3070f
xorl %eax, %eax
testq %r14, %r14
je 0x30777
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x30777
incl %edx
testl %esi, %esi
je 0x306f2
cmpl $0x3, %edx
jne 0x306f2
movzbl (%r12), %r13d
cmpl $0x3, %r13d
jne 0x306de
movq 0x60(%r12), %r12
testq %r12, %r12
je 0x30777
movzbl (%r12), %r13d
cmpl $0x4, %r13d
jne 0x30733
movq 0x60(%r12), %r12
testq %r12, %r12
je 0x30777
cmpb $0x3, (%r12)
jne 0x30703
movq 0x60(%r12), %r12
testq %r12, %r12
je 0x30777
cmpq %rcx, %r12
je 0x30738
cmpq %r8, 0x60(%r12)
jne 0x30738
incq %r15
cmpq %r15, %r10
jne 0x3068a
movq 0x10(%r9), %r9
cmpq %rdi, %r9
jne 0x3066d
jmp 0x30771
leaq 0x3a907(%rip), %rcx     # 0x6b038
jmp 0x30771
movl $0x3, %edx
movq 0x8(%r14), %rdi
leaq 0x18fbd(%rip), %rsi     # 0x49700
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x11a80
movq 0x10(%r14), %rdi
callq 0x237c5
movq 0x8(%r14), %rdi
leaq 0x18122(%rip), %rsi     # 0x48882
movq %rax, %rdx
xorl %eax, %eax
callq 0x1178c
leaq 0x3c147(%rip), %rcx     # 0x6c8b8
movq %rcx, 0x10(%rbx)
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_O3/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 0x30818
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x225b0
movq %rax, %rdi
callq 0xf4bf
movq 0x10(%rbx), %rcx
movl 0x50(%rcx), %ecx
cmpl $0x40, %ecx
je 0x30804
cmpl $0x20, %ecx
je 0x30800
movl $0x2710, %esi           # imm = 0x2710
cmpl $0x10, %ecx
jne 0x30817
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x30807
bswapl %eax
jmp 0x30807
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_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0x225b0
movq %rax, %rdi
callq 0xf4bf
testl %ebx, %ebx
jne 0x30a0a
addq $-0x30, %rax
xorl %ecx, %ecx
cmpq $0xa, %rax
setb %cl
movq %rcx, 0x20(%r14)
movb $0x1, (%r14)
movl $0x0, 0x28(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3010c
testl %eax, %eax
je 0x30a74
movq 0x28(%rbx), %rdi
callq 0x225b0
movq 0x10(%rax), %rax
cmpb $0x3, (%rax)
jne 0x30a3e
movq 0x60(%rax), %rax
movq 0x60(%rax), %rax
cmpq 0x2f507(%rip), %rax     # 0x5ff50
je 0x30a78
movq 0x20(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2de35
leaq 0x18cbf(%rip), %rsi     # 0x49722
xorl %ebp, %ebp
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11b04
jmp 0x30a7d
xorl %ebp, %ebp
jmp 0x30a7d
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/builtin.c
// Function: expand_object_size
static int expand_object_size(struct expression *expr, int cost)
{
	struct expression *arg = first_expression(expr->args);
	int type = get_expression_value_silent(ptr_list_nth(expr->args, 1));
	unsigned long val = -1, off = 0;

	while (arg) {
		switch (arg->type) {
		case EXPR_IMPLIED_CAST:
		case EXPR_CAST:
			// ignore those
			arg = arg->cast_expression;
			continue;
		case EXPR_BINOP:
			// a constant add is (maybe) an offset
			if (!arg->right || arg->op != '+' || arg->right->type != EXPR_VALUE)
				break;
			off += arg->right->value;
			arg = arg->left;
			continue;
		case EXPR_PREOP:
			// a deref is just intermediate variable
			// and so the offset needs to be zeroed.
			if (arg->op == '*') {
				struct expression *parent = arg;
				arg = arg->unop;
				off = 0;
				switch (arg->type) {
				case EXPR_SYMBOL:
					arg = arg->symbol->initializer;
					if (arg == parent) {
						// stop at self-initialized vars
						// and do not expand them.
						arg = NULL;
						val = -1;
						break;
					}
					continue;
				default:
					break;
				}
			}
			break;
		case EXPR_SYMBOL:
			// the symbol we're looking after
			val = bits_to_bytes(arg->symbol->bit_size);
			break;
		case EXPR_CALL:
			// use alloc_size() attribute but only after linearization.
			return UNSAFE;
		default:
			break;
		}
		break;
	}

	if (val == -1)
		val = (type & 2) ? 0 : val;
	else if (type & 1)
		return UNSAFE;
	else
		val -= off;

	expr->flags |= CEF_SET_ICE;
	expr->type = EXPR_VALUE;
	expr->value = val;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x225b0
movq %rax, %r14
movq 0x28(%rbx), %rdi
movl $0x1, %esi
callq 0x225fc
movq %rax, %rdi
callq 0xf4bf
movq %rax, %rcx
testq %r14, %r14
je 0x30b6e
xorl %esi, %esi
leaq 0x17d70(%rip), %rax     # 0x48834
movq %r14, %rdx
movzbl (%rdx), %edi
leal -0x3(%rdi), %r8d
cmpl $0xa, %r8d
ja 0x30b31
movslq (%rax,%r8,4), %rdi
addq %rax, %rdi
jmpq *%rdi
movq 0x28(%rdx), %rdx
testq %rdx, %rdx
jne 0x30ac7
jmp 0x30b6e
cmpl $0x2a, 0x4(%rdx)
jne 0x30b6e
movq 0x20(%rdx), %rsi
cmpb $0x3, (%rsi)
jne 0x30b6e
movq 0x20(%rsi), %rsi
movq 0xb0(%rsi), %r14
cmpq %rdx, %r14
je 0x30b6e
xorl %esi, %esi
jmp 0x30b2a
movq 0x28(%rdx), %rdi
testq %rdi, %rdi
je 0x30b6e
cmpl $0x2b, 0x4(%rdx)
jne 0x30b6e
cmpb $0x1, (%rdi)
jne 0x30b6e
addq 0x20(%rdi), %rsi
movq 0x20(%rdx), %r14
testq %r14, %r14
jne 0x30ac4
jmp 0x30b6e
cmpl $0x14, %edi
jne 0x30b6e
movl $0x64, %edx
jmp 0x30b95
movq 0x20(%rdx), %rax
movl 0x50(%rax), %eax
testl %eax, %eax
js 0x30b6e
leaq 0x33bb1(%rip), %rdx     # 0x64700
movl (%rdx), %edi
addl %edi, %eax
decl %eax
cltd
idivl %edi
cmpl $-0x1, %eax
je 0x30b6e
movl $0x64, %edx
testb $0x1, %cl
jne 0x30b95
cltq
subq %rsi, %rax
jmp 0x30b79
xorl %eax, %eax
btl $0x1, %ecx
adcl $-0x1, %eax
cltq
movl $0xffffcf00, %ecx       # imm = 0xFFFFCF00
andl (%rbx), %ecx
orl $0x3001, %ecx           # imm = 0x3001
movl %ecx, (%rbx)
movq %rax, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorl %edx, %edx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30d2b
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 0x18a1c(%rip), %rdi     # 0x4974e
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/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 0x30d5b
movl %edx, %eax
andl $0x200, %eax            # imm = 0x200
jne 0x30d5b
movl $0x8000, %esi           # imm = 0x8000
movq %rdx, %rdi
jmp 0xe240
pushq %rax
leaq 0x18a1b(%rip), %rdi     # 0x4977e
xorl %eax, %eax
callq 0x11c32
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
xorl %ecx, %ecx
testq %rdi, %rdi
je 0x312b7
movq %rdi, %rax
cmpb $0x0, (%rax)
jg 0x312c0
movq 0x10(%rax), %rax
cmpq %rdi, %rax
jne 0x312a7
jmp 0x312b9
xorl %eax, %eax
xorl %edx, %edx
xorl %r10d, %r10d
jmp 0x312cd
movq 0x18(%rax), %r10
andq $-0x4, %r10
movl $0x1, %edx
testq %rsi, %rsi
je 0x312eb
movq %rsi, %r8
cmpb $0x0, (%r8)
jg 0x312f3
movq 0x10(%r8), %r8
cmpq %rsi, %r8
jne 0x312d5
xorl %r11d, %r11d
xorl %ecx, %ecx
jmp 0x31300
xorl %r11d, %r11d
xorl %r8d, %r8d
jmp 0x31300
movq 0x18(%r8), %r11
andq $-0x4, %r11
movl $0x1, %ecx
leaq 0x346c9(%rip), %r9      # 0x659d0
movb $0x1, %bl
testq %r10, %r10
je 0x31344
cmpq %r9, %r10
je 0x3131e
cmpq $0x0, 0x18(%r10)
jne 0x313cb
movsbl (%rax), %r10d
cmpl %r10d, %edx
jl 0x31334
movq 0x10(%rax), %rax
xorl %edx, %edx
cmpq %rdi, %rax
jne 0x3131e
jmp 0x31344
movslq %edx, %r10
movq 0x18(%rax,%r10,8), %r10
incl %edx
andq $-0x4, %r10
jne 0x3130e
xorl %r10d, %r10d
testq %r11, %r11
je 0x3140f
cmpq %r9, %r11
je 0x3135e
movq 0x18(%r11), %r11
testq %r11, %r11
jne 0x3138c
movsbl (%r8), %r11d
cmpl %r11d, %ecx
jl 0x31377
movq 0x10(%r8), %r8
xorl %ecx, %ecx
cmpq %rsi, %r8
jne 0x3135e
jmp 0x3140f
movslq %ecx, %r11
movq 0x18(%r8,%r11,8), %r11
incl %ecx
andq $-0x4, %r11
jne 0x31350
jmp 0x3140f
testb %bl, %bl
jne 0x31419
movq 0x18(%r10), %r10
movq 0x30(%r10), %rbx
movq 0x30(%r11), %r14
cmpq %r14, %rbx
jne 0x31420
movq 0x8(%r10), %r10
movq 0x8(%r11), %r11
cmpq %r11, %r10
jne 0x31427
movsbl (%rax), %r10d
cmpl %r10d, %edx
jl 0x313d2
movq 0x10(%rax), %rax
xorl %edx, %edx
cmpq %rdi, %rax
jne 0x313b2
xorl %r10d, %r10d
jmp 0x313e0
xorl %ebx, %ebx
jmp 0x31347
movslq %edx, %r10
movq 0x18(%rax,%r10,8), %r10
andq $-0x4, %r10
incl %edx
movsbl (%r8), %r11d
cmpl %r11d, %ecx
jl 0x313fc
movq 0x10(%r8), %r8
xorl %ecx, %ecx
cmpq %rsi, %r8
jne 0x313e0
xorl %r11d, %r11d
jmp 0x31307
movslq %ecx, %r11
movq 0x18(%r8,%r11,8), %r11
andq $-0x4, %r11
incl %ecx
jmp 0x31307
xorb $0x1, %bl
movzbl %bl, %eax
popq %rbx
popq %r14
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x31415
xorl %eax, %eax
cmpq %r14, %rbx
jmp 0x3142c
xorl %eax, %eax
cmpq %r11, %r10
sbbl %eax, %eax
orl $0x1, %eax
jmp 0x31415
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5eb09(%rip), %rax     # 0x8ff78
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 0x314d3
movq %rax, %rcx
movzwl (%rcx), %edx
testb %dl, %dl
jle 0x314ca
xorl %esi, %esi
movq 0x18(%rcx,%rsi,8), %rdi
movzwl %dx, %r8d
cmpl $0x100, %r8d            # imm = 0x100
jb 0x314b4
testq %rdi, %rdi
je 0x314bb
movq %rbp, 0x8(%rdi)
movzwl (%rcx), %edx
incq %rsi
movzwl %dx, %edi
movsbq %dil, %rdi
cmpq %rdi, %rsi
jl 0x3149d
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0x31494
cmpq $0x0, (%rsp)
je 0x3152e
orq $0x4, %rbp
movq (%rsp), %r12
movzwl (%r12), %eax
testb %al, %al
jle 0x31523
xorl %r15d, %r15d
movq 0x18(%r12,%r15,8), %rsi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x31503
testq %rsi, %rsi
je 0x31514
movq %rbp, 0x8(%rsi)
movq %rbx, %rdi
callq 0x315b6
movzwl (%r12), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0x314ee
movq 0x10(%r12), %r12
cmpq (%rsp), %r12
jne 0x314e2
leaq 0x8(%rbx), %r12
movslq (%rbx), %rbp
testq %rbp, %rbp
sete %r15b
leaq (%r12,%rbp,8), %rdi
callq 0x22aaf
testq %rax, %rax
setne %cl
orb %r15b, %cl
jne 0x31570
leaq (%rbx,%rbp,8), %r15
decq %rbp
movl %ebp, (%rbx)
movq %r15, %rdi
callq 0x22aaf
subq $0x1, %rbp
jb 0x31570
addq $-0x8, %r15
testq %rax, %rax
je 0x31557
testq %rax, %rax
je 0x31588
movl 0x3c(%rax), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x315ea
jmp 0x31532
testq %r13, %r13
je 0x315a0
shlq $0x3, %r13
leaq (%rbx,%r13), %rdi
callq 0x22c4e
addq $-0x8, %r13
jne 0x31591
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_O3/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 0x316a6
movq (%rsp), %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0x31698
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %r13
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x3163f
testq %r13, %r13
je 0x31689
cmpq %r12, 0x30(%r13)
je 0x31689
movq 0x8(%r13), %r14
cmpl %ebx, 0x3c(%r13)
setle %al
testb $0x2, %r14b
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x31689
movq %r14, %rax
orq $0x2, %rax
movq %rax, 0x8(%r13)
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x227b4
testb $0x4, %r14b
jne 0x31689
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x315b6
incq %r15
movl (%rbp), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jl 0x3162b
movq 0x10(%rbp), %rbp
cmpq (%rsp), %rbp
jne 0x31620
movq 0x40(%r12), %r12
testq %r12, %r12
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbp
je 0x3170c
movq %r12, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x31703
xorl %r13d, %r13d
movq 0x18(%r15,%r13,8), %rdx
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x316dd
testq %rdx, %rdx
je 0x316f4
testb $0x1, 0x8(%rdx)
jne 0x316f4
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x315ea
movzwl (%r15), %eax
incq %r13
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r13
jl 0x316c8
movq 0x10(%r15), %r15
cmpq %r12, %r15
jne 0x316bd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3cca2
movq (%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x2de35
leaq 0x18220(%rip), %rdi     # 0x49964
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq %rbx, 0x20(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x31888
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x17113(%rip), %r13     # 0x48889
movq 0x18(%rsp), %rbx
movzwl (%rbx), %eax
testb %al, %al
jle 0x31879
xorl %r12d, %r12d
movq 0x18(%rbx,%r12,8), %rbp
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x317a2
testq %rbp, %rbp
je 0x31866
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x227b4
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x31434
movq %rbp, %rdi
callq 0x122b5
leaq 0x18195(%rip), %rdi     # 0x4996f
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x3183f
movq %r14, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0x31836
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x31811
testq %rdi, %rdi
je 0x31827
callq 0x122b5
movq %r13, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movzwl (%rbp), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0x317fc
movq 0x10(%rbp), %rbp
cmpq %r14, %rbp
jne 0x317f1
movl $0xa, %edi
callq 0xe040
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x22c4e
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x22c4e
movzwl (%rbx), %eax
incq %r12
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r12
jl 0x31789
movq 0x10(%rbx), %rbx
cmpq 0x18(%rsp), %rbx
jne 0x3177b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x31eab
movq %rbp, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x31e9e
xorl %ebx, %ebx
movq 0x18(%r13,%rbx,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x31dab
testq %r14, %r14
je 0x31e8a
movq %r14, %rdi
callq 0x35be9
testq %rax, %rax
je 0x31e8a
movq %rax, %r12
movb (%rax), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x31e8a
movq 0x4(%r14), %rdi
movl $0x4, %esi
callq 0x2b00b
movq %rax, %r15
addq $0x60, %rax
cmpb $0x6, (%r12)
jne 0x31e08
movq 0x80(%r12), %rcx
movq %rcx, 0x20(%rax)
movups 0x60(%r12), %xmm0
movups 0x70(%r12), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
jmp 0x31e0b
movq %r12, (%rax)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x31e51
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x31e4a
cmpq %rax, %rcx
je 0x31e51
movq 0x4(%r14), %rdi
leaq 0x335ad(%rip), %rax     # 0x653e0
movq %rax, 0x80(%r15)
leaq 0x14bfb(%rip), %rsi     # 0x46a3c
xorl %eax, %eax
callq 0x11a80
jmp 0x31e51
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 0x2b0b8
incq %rbx
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jl 0x31d93
movq 0x10(%r13), %r13
cmpq %rbp, %r13
jne 0x31d84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movzbl (%rdi), %eax
cmpl $0x3, %eax
jne 0x32a48
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0xa, %eax
jne 0x32a64
callq 0x2b0b8
movq %rax, %rdi
movzbl (%rax), %eax
cmpl $0x3, %eax
jne 0x32a64
movq 0x60(%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x9, %eax
jne 0x32a6d
movq 0x60(%rdi), %rdi
movq %rdi, (%rbx)
movzbl (%rdi), %eax
cmpq $0x2, %rax
jne 0x32a8f
movq 0x60(%rdi), %rcx
cmpq 0x2d504(%rip), %rcx     # 0x5ff88
je 0x32a9b
cmpq 0x2d4c3(%rip), %rcx     # 0x5ff50
je 0x32aa2
leaq 0x1711a(%rip), %rcx     # 0x49bb0
movl (%rcx,%rax,4), %eax
jmp 0x32aa7
movl $0x1, %eax
jmp 0x32aa7
movl $0x9, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
callq 0x364ef
movq 0x10(%r14), %rdi
cmpq 0x2d4e3(%rip), %rdi     # 0x5ffb8
je 0x32b6b
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x3677d
movq %rax, %r15
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x3677d
cmpq %rax, %r15
je 0x32b10
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
jmp 0x32b2a
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x18(%rsp), %rdx
je 0x32bd5
movl %eax, %edx
orl %ecx, %edx
btl $0x1a, %edx
jae 0x32b6b
btl $0x1a, %ecx
leaq 0xec2d(%rip), %rcx      # 0x4176c
leaq 0x17328(%rip), %rsi     # 0x49e6e
cmovaeq %rcx, %rsi
btl $0x1a, %eax
leaq 0x10ae3(%rip), %rdx     # 0x43638
cmovbq %rsi, %rdx
movq 0x8(%r14), %rdi
leaq 0x17312(%rip), %rsi     # 0x49e76
xorl %eax, %eax
callq 0x118fc
movq 0x8(%r14), %r12
xorl %edi, %edi
callq 0x2f9f5
movq %rax, %r15
movq %r12, 0x8(%rax)
movw $0xd, (%rax)
movq %rbx, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36580
shll $0x8, %eax
movl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
andl (%r15), %ecx
orl %eax, %ecx
movl %ecx, (%r15)
cmpb $0x3, (%rbx)
jne 0x32bb2
movq 0x60(%rbx), %rbx
cmpq 0x2d42f(%rip), %rbx     # 0x5ffe8
jne 0x32bc3
movq %r15, %rdi
callq 0x36646
movq %r15, %r14
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rcx, %rdx
xorq %rax, %rdx
andq $-0x4000001, %rdx       # imm = 0xFBFFFFFF
je 0x32bc6
cmpq $0x200, %rdx            # imm = 0x200
je 0x32b6b
jmp 0x32b2a
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/evaluate.c
// Function: evaluate_string
static struct symbol *evaluate_string(struct expression *expr)
{
	struct symbol *sym = alloc_symbol(expr->pos, SYM_NODE);
	struct symbol *array = alloc_symbol(expr->pos, SYM_ARRAY);
	struct expression *addr = alloc_expression(expr->pos, EXPR_SYMBOL);
	struct expression *initstr = alloc_expression(expr->pos, EXPR_STRING);
	unsigned int length = expr->string->length;
	struct symbol *char_type = expr->wide ? wchar_ctype : &char_ctype;

	sym->array_size = alloc_const_expression(expr->pos, length);
	sym->bit_size = length * char_type->bit_size;
	sym->ctype.alignment = 1;
	sym->string = 1;
	sym->ctype.modifiers = MOD_STATIC;
	sym->ctype.base_type = array;
	sym->initializer = initstr;
	sym->examined = 1;
	sym->evaluated = 1;

	initstr->ctype = sym;
	initstr->string = expr->string;

	array->array_size = sym->array_size;
	array->bit_size = sym->bit_size;
	array->ctype.alignment = char_type->ctype.alignment;
	array->ctype.modifiers = MOD_STATIC;
	array->ctype.base_type = char_type;
	array->examined = 1;
	array->evaluated = 1;
	
	addr->symbol = sym;
	addr->ctype = &lazy_ptr_ctype;
	addr->flags = CEF_ADDR;

	expr->type = EXPR_PREOP;
	expr->op = '*';
	expr->unop = addr;  
	expr->ctype = sym;
	return sym;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x3, %esi
callq 0x2b00b
movq %rax, %r14
movq 0x8(%rbx), %rdi
movl $0x6, %esi
callq 0x2b00b
movq %rax, %r15
movq 0x8(%rbx), %r13
xorl %edi, %edi
callq 0x2f9f5
movq %rax, %r12
movq %r13, 0x8(%rax)
movw $0x3, (%rax)
movq 0x8(%rbx), %rbp
xorl %edi, %edi
callq 0x2f9f5
movq %rax, %r13
movq %rbp, 0x8(%rax)
movw $0x2, (%rax)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rbx), %rax
movl (%rax), %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
cmpl $0x0, 0x20(%rbx)
jne 0x32f1c
leaq 0x37afe(%rip), %rax     # 0x6aa18
jmp 0x32f26
leaq 0x3173d(%rip), %rax     # 0x64660
movq (%rax), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
callq 0x2f9f5
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rbp, 0x20(%rax)
leaq 0x387f2(%rip), %rcx     # 0x6b738
movq %rcx, 0x10(%rax)
movw $0x3101, (%rax)         # imm = 0x3101
movq %rax, 0x58(%r14)
movq 0x8(%rsp), %rdx
movl 0x50(%rdx), %eax
imull %ebp, %eax
movl %eax, 0x50(%r14)
movq $0x1, 0x70(%r14)
movl $0x4, %eax
movq %rax, 0x68(%r14)
movq %r15, 0x60(%r14)
movq %r13, 0xb0(%r14)
orb $-0x58, 0x55(%r14)
movq %r14, 0x10(%r13)
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%r13)
movq 0x58(%r14), %rcx
movq %rcx, 0x58(%r15)
movl 0x50(%r14), %ecx
movl %ecx, 0x50(%r15)
movq 0x70(%rdx), %rcx
movq %rcx, 0x70(%r15)
movq %rax, 0x68(%r15)
movq %rdx, 0x60(%r15)
orb $0x28, 0x55(%r15)
movq %r14, 0x20(%r12)
leaq 0x39658(%rip), %rax     # 0x6c618
movq %rax, 0x10(%r12)
movb $0x40, 0x1(%r12)
movb $0x9, (%rbx)
movl $0x2a, 0x4(%rbx)
movq %r12, 0x20(%rbx)
movq %r14, 0x10(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3306f
movq %rbx, %rdi
callq 0x2b0b8
movq 0x60(%rbx), %rdi
callq 0x2b0b8
testq %rax, %rax
je 0x33081
movq 0x8(%r14), %r15
xorl %edi, %edi
callq 0x2f9f5
movzwl 0x2(%rax), %ecx
shll $0x10, %ecx
leal 0x3(%rcx), %edx
movq %r15, 0x8(%rax)
movl %edx, (%rax)
movq %rbx, 0x20(%rax)
movq 0x28(%r14), %rdx
movq %rdx, 0x28(%rax)
leaq 0x395d4(%rip), %rdx     # 0x6c618
movq %rdx, 0x10(%rax)
movzbl 0x1(%r14), %edx
shll $0x8, %edx
addl %edx, %ecx
addl $0x3, %ecx
movl %ecx, (%rax)
movl $0x2a, 0x4(%r14)
movq %rax, 0x20(%r14)
movw $0x9, (%r14)
movq %rbx, 0x10(%r14)
jmp 0x330a0
movq 0x28(%r14), %rdi
callq 0x2de35
leaq 0x16f0c(%rip), %rsi     # 0x49f8b
jmp 0x33091
movq 0x28(%r14), %rdi
callq 0x2de35
leaq 0x16f14(%rip), %rsi     # 0x49fa5
xorl %ebx, %ebx
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x11b04
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37599
testq %rax, %rax
je 0x337ee
movq 0x28(%rbp), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x37599
testq %rax, %rax
je 0x337ee
leaq 0x37f62(%rip), %rbx     # 0x6b738
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_O3/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 0x32bf6
movq %rax, %rdi
callq 0x364a3
cmpq 0x2c7a4(%rip), %rax     # 0x5ffb8
jne 0x3381d
leaq 0x38d1b(%rip), %rax     # 0x6c538
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