LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: parse_range_statement
static struct token *parse_range_statement(struct token *token, struct statement *stmt)
{
	stmt->type = STMT_RANGE;
	token = token->next;
	token = expect(token, '(', "after __range__ statement");
	token = assignment_expression(token, &stmt->range_expression);
	token = expect(token, ',', "after range expression");
	token = assignment_expression(token, &stmt->range_low);
	token = expect(token, ',', "after low range");
	token = assignment_expression(token, &stmt->range_high);
	token = expect(token, ')', "after range statement");
	return expect(token, ';', "after range statement");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xd, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3d33a(%rip), %rdx     # 0x65490
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
leaq 0x3d326(%rip), %rdx     # 0x654aa
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x8, %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
leaq 0x3d30b(%rip), %rdx     # 0x654c1
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3d2e9(%rip), %rdx     # 0x654d1
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3d2d0(%rip), %rdx     # 0x654d1
callq 0x22eb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_packed
static struct token *attribute_packed(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (!ctx->ctype.alignment) {
		ctx->ctype.alignment = 1;
		ctx->packed = 1;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2823f
movq -0x18(%rbp), %rax
movq $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x53(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_aligned
static struct token *attribute_aligned(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	int alignment = max_alignment;
	struct expression *expr = NULL;

	if (match_op(token, '(')) {
		token = parens_expression(token, &expr, "in attribute");
		if (expr)
			alignment = const_expression_value(expr);
	}
	if (alignment & (alignment-1)) {
		warning(token->pos, "I don't like non-power-of-2 alignments");
		return token;
	} else if (alignment > ctx->ctype.alignment)
		ctx->ctype.alignment = alignment;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x6245d(%rip), %rax     # 0x8a6c8
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x282b8
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq 0x3ca98(%rip), %rdx     # 0x64d32
callq 0x55b00
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x282b6
movq -0x30(%rbp), %rdi
callq 0x12170
movl %eax, -0x24(%rbp)
jmp 0x282b8
movl -0x24(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x282e7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d211(%rip), %rsi     # 0x654e7
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2830b
movslq -0x24(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x28301
movslq -0x24(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x28303
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_cleanup
static struct token *attribute_cleanup(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;

	if (match_op(token, '(')) {
		token = token->next;
		if (match_op(token, ')'))
			sparse_error(token->pos, "an argument is expected for attribute 'cleanup'");
		else if (token_type(token) != TOKEN_IDENT)
			sparse_error(token->pos, "argument is not an identifier");
		token = primary_expression(token, &expr);
		if (expr && expr->type == EXPR_SYMBOL)
			ctx->cleanup = expr;
		return expect(token, ')', "after attribute's argument'");
	}

	sparse_error(token->pos, "an argument is expected for attribute 'cleanup'");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x283ff
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x28389
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d18e(%rip), %rsi     # 0x6550e
movb $0x0, %al
callq 0x16f90
jmp 0x283b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x283ae
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d197(%rip), %rsi     # 0x6553e
movb $0x0, %al
callq 0x16f90
jmp 0x283b0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x55d50
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x283e4
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x283e4
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movl $0x29, %esi
leaq 0x3d168(%rip), %rdx     # 0x6555c
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x2841c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d101(%rip), %rsi     # 0x6550e
movb $0x0, %al
callq 0x16f90
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_address_space
static struct token *attribute_address_space(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;
	struct ident *as = NULL;
	struct token *next;

	token = expect(token, '(', "after address_space attribute");
	switch (token_type(token)) {
	case TOKEN_NUMBER:
		next = primary_expression(token, &expr);
		if (expr->type != EXPR_VALUE)
			goto invalid;
		as = numerical_address_space(expr->value);
		break;
	case TOKEN_IDENT:
		next = token->next;
		as = token->ident;
		break;
	default:
		next = token->next;
	invalid:
		as = NULL;
		warning(token->pos, "invalid address space name");
	}

	if (Waddress_space && as) {
		if (ctx->ctype.as)
			sparse_error(token->pos,
				     "multiple address spaces given: %s & %s",
				     show_as(ctx->ctype.as), show_as(as));
		ctx->ctype.as = as;
	}
	token = expect(next, ')', "after address_space attribute");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3d079(%rip), %rdx     # 0x65578
movl $0x28, %esi
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
movl %eax, -0x34(%rbp)
subl $0x3, %eax
je 0x28562
jmp 0x28520
movl -0x34(%rbp), %eax
subl $0x5, %eax
jne 0x2857c
jmp 0x2852a
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x55d50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x2854d
jmp 0x28588
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, %edi
callq 0x28630
movq %rax, -0x28(%rbp)
jmp 0x285a5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x285a5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3cff8(%rip), %rsi     # 0x65596
movb $0x0, %al
callq 0x16d80
leaq 0x5c25c(%rip), %rax     # 0x84808
cmpl $0x0, (%rax)
je 0x2860d
cmpq $0x0, -0x28(%rbp)
je 0x2860d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x28601
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32b40
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32b40
movq -0x48(%rbp), %rdx
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rax), %rdi
leaq 0x3cfb7(%rip), %rsi     # 0x655b1
movb $0x0, %al
callq 0x16f90
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rdi
movl $0x29, %esi
leaq 0x3cf5b(%rip), %rdx     # 0x65578
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: numerical_address_space
static struct ident *numerical_address_space(int asn)
{
	char buff[32];

	if (!asn)
		return NULL;
	sprintf(buff, "<asn:%d>", asn);
	return built_in_ident(buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2864b
movq $0x0, -0x8(%rbp)
jmp 0x2866d
leaq -0x30(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x3cf7f(%rip), %rsi     # 0x655d8
movb $0x0, %al
callq 0x112c0
leaq -0x30(%rbp), %rdi
callq 0x44f10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_designated_init
static struct token *attribute_designated_init(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_STRUCT)
		ctx->ctype.base_type->designated_init = 1;
	else
		warning(token->pos, "attribute designated_init applied to non-structure type");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x286cc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x7, %eax
jne 0x286cc
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x54(%rax), %ecx
andl $0xfffeffff, %ecx       # imm = 0xFFFEFFFF
orl $0x10000, %ecx          # imm = 0x10000
movl %ecx, 0x54(%rax)
jmp 0x286e1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3cf07(%rip), %rsi     # 0x655e1
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_transparent_union
static struct token *attribute_transparent_union(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	if (Wtransparent_union)
		warning(token->pos, "attribute __transparent_union__");

	if (ctx->ctype.base_type && ctx->ctype.base_type->type == SYM_UNION)
		ctx->ctype.base_type->transparent_union = 1;
	else
		warning(token->pos, "attribute __transparent_union__ applied to non-union type");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x64b11(%rip), %rax     # 0x8d21c
cmpl $0x0, (%rax)
je 0x28725
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3cefb(%rip), %rsi     # 0x65619
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2875d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x8, %eax
jne 0x2875d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x54(%rax), %ecx
andl $0xffbfffff, %ecx       # imm = 0xFFBFFFFF
orl $0x400000, %ecx         # imm = 0x400000
movl %ecx, 0x54(%rax)
jmp 0x28772
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3cece(%rip), %rsi     # 0x65639
movb $0x0, %al
callq 0x16d80
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: attribute_mode
static struct token *attribute_mode(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	token = expect(token, '(', "after mode attribute");
	if (token_type(token) == TOKEN_IDENT) {
		struct symbol *mode = lookup_keyword(token->ident, NS_KEYWORD);
		if (mode && mode->op->type & KW_MODE)
			ctx->mode = mode->op;
		else
			sparse_error(token->pos, "unknown mode attribute %s", show_ident(token->ident));
		token = token->next;
	} else
		sparse_error(token->pos, "expect attribute mode symbol\n");
	token = expect(token, ')', "after mode attribute");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3ce8f(%rip), %rdx     # 0x65673
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x28879
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x244c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2883e
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x2883e
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x2886b
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ce24(%rip), %rsi     # 0x65688
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2888e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3ce1b(%rip), %rsi     # 0x656a2
movb $0x0, %al
callq 0x16f90
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3cdd5(%rip), %rdx     # 0x65673
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: to_QI_mode
static struct symbol *to_QI_mode(struct symbol *ctype)
{
	if (ctype->ctype.base_type != &int_type)
		return NULL;
	if (ctype == &char_ctype)
		return ctype;
	return ctype->ctype.modifiers & MOD_UNSIGNED ? &uchar_ctype
						     : &schar_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x68985(%rip), %rcx     # 0x91258
cmpq %rcx, 0x60(%rax)
je 0x288e3
movq $0x0, -0x8(%rbp)
jmp 0x28923
leaq 0x6850e(%rip), %rax     # 0x90df8
cmpq %rax, -0x10(%rbp)
jne 0x288fa
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28923
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
andq $0x4000, %rdx           # imm = 0x4000
leaq 0x68da8(%rip), %rax     # 0x916b8
leaq 0x68e81(%rip), %rcx     # 0x91798
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: to_pointer_mode
static struct symbol *to_pointer_mode(struct symbol *ctype)
{
	if (ctype->ctype.base_type != &int_type)
		return NULL;
	return ctype->ctype.modifiers & MOD_UNSIGNED ? uintptr_ctype
						     :  intptr_ctype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x68795(%rip), %rcx     # 0x91258
cmpq %rcx, 0x60(%rax)
je 0x28ad3
movq $0x0, -0x8(%rbp)
jmp 0x28b0d
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
je 0x28af7
leaq 0x6b882(%rip), %rax     # 0x94370
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28b05
leaq 0x6b86a(%rip), %rax     # 0x94368
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: ignore_attribute
static struct token *ignore_attribute(struct token *token, struct symbol *attr, struct decl_state *ctx)
{
	struct expression *expr = NULL;
	if (match_op(token, '('))
		token = parens_expression(token, &expr, "in attribute");
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x28bc7
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq 0x3c174(%rip), %rdx     # 0x64d32
callq 0x55b00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: specifier_conflict
static void specifier_conflict(struct position pos, int what, struct ident *new)
{
	const char *old;
	if (what & (Set_S | Set_T))
		goto Catch_all;
	if (what & Set_Char)
		old = "char";
	else if (what & Set_Double)
		old = "double";
	else if (what & Set_Float)
		old = "float";
	else if (what & Set_Signed)
		old = "signed";
	else if (what & Set_Unsigned)
		old = "unsigned";
	else if (what & Set_Short)
		old = "short";
	else if (what & Set_Long)
		old = "long";
	else
		old = "long long";
	sparse_error(pos, "impossible combination of type specifiers: %s %s",
			old, show_ident(new));
	return;

Catch_all:
	sparse_error(pos, "two or more data types in declaration specifiers");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x28c03
jmp 0x28cfa
movl -0xc(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x28c1e
leaq 0x3f753(%rip), %rax     # 0x68368
movq %rax, -0x20(%rbp)
jmp 0x28cce
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x28c39
leaq 0x3f787(%rip), %rax     # 0x683b7
movq %rax, -0x20(%rbp)
jmp 0x28ccc
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x28c51
leaq 0x3b6eb(%rip), %rax     # 0x64336
movq %rax, -0x20(%rbp)
jmp 0x28cca
movl -0xc(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x28c69
leaq 0x3bf27(%rip), %rax     # 0x64b8a
movq %rax, -0x20(%rbp)
jmp 0x28cc8
movl -0xc(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x28c83
leaq 0x43cf5(%rip), %rax     # 0x6c972
movq %rax, -0x20(%rbp)
jmp 0x28cc6
movl -0xc(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x28c9d
leaq 0x3f6df(%rip), %rax     # 0x68376
movq %rax, -0x20(%rbp)
jmp 0x28cc4
movl -0xc(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x28cb7
leaq 0x3f6e3(%rip), %rax     # 0x68394
movq %rax, -0x20(%rbp)
jmp 0x28cc2
leaq 0x43d87(%rip), %rax     # 0x6ca45
movq %rax, -0x20(%rbp)
jmp 0x28cc4
jmp 0x28cc6
jmp 0x28cc8
jmp 0x28cca
jmp 0x28ccc
jmp 0x28cce
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x44150
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movq -0x8(%rbp), %rdi
leaq 0x3deea(%rip), %rsi     # 0x66bdb
movb $0x0, %al
callq 0x16f90
jmp 0x28d0c
movq -0x8(%rbp), %rdi
leaq 0x3df07(%rip), %rsi     # 0x66c0c
movb $0x0, %al
callq 0x16f90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: pointer
static struct token *pointer(struct token *token, struct decl_state *ctx)
{
	while (match_op(token,'*')) {
		struct symbol *ptr = alloc_symbol(token->pos, SYM_PTR);
		ptr->ctype.modifiers = ctx->ctype.modifiers;
		ptr->ctype.base_type = ctx->ctype.base_type;
		ptr->ctype.as = ctx->ctype.as;
		ptr->ctype.contexts = ctx->ctype.contexts;
		ctx->ctype.modifiers = 0;
		ctx->ctype.base_type = ptr;
		ctx->ctype.as = NULL;
		ctx->ctype.contexts = NULL;
		ctx->ctype.alignment = 0;

		token = handle_qualifiers(token->next, ctx);
		ctx->ctype.base_type->endpos = token->pos;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x28e05
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x4, %esi
callq 0x3f4d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x29090
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
jmp 0x28d30
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: handle_qualifiers
static struct token *handle_qualifiers(struct token *t, struct decl_state *ctx)
{
	while (token_type(t) == TOKEN_IDENT) {
		struct symbol *s = lookup_keyword(t->ident, NS_TYPEDEF);
		if (!s)
			break;
		if (!(s->op->type & (KW_ATTRIBUTE | KW_QUALIFIER)))
			break;
		t = t->next;
		if (s->op->declarator)
			t = s->op->declarator(t, s, ctx);
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x2911e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x244c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x290cf
jmp 0x2911e
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
jne 0x290e3
jmp 0x2911e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x2911c
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x290a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: is_nested
static int is_nested(struct token *token, struct token **p,
		    int prefer_abstract)
{
	/*
	 * This can be either a parameter list or a grouping.
	 * For the direct (non-abstract) case, we know if must be
	 * a parameter list if we already saw the identifier.
	 * For the abstract case, we know if must be a parameter
	 * list if it is empty or starts with a type.
	 */
	struct token *next = token->next;

	*p = next = skip_attributes(next);

	if (token_type(next) == TOKEN_IDENT) {
		if (lookup_type(next))
			return !prefer_abstract;
		return 1;
	}

	if (match_op(next, ')') || match_op(next, SPECIAL_ELLIPSIS))
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x29630
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x291a0
movq -0x28(%rbp), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x29197
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x291d6
movl $0x1, -0x4(%rbp)
jmp 0x291d6
movq -0x28(%rbp), %rdi
movl $0x29, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x291c6
movq -0x28(%rbp), %rdi
movl $0x117, %esi            # imm = 0x117
callq 0x22f80
cmpl $0x0, %eax
je 0x291cf
movl $0x0, -0x4(%rbp)
jmp 0x291d6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: which_func
static enum kind which_func(struct token *token,
			    struct ident **n,
			    int prefer_abstract)
{
	struct token *next = token->next;

	if (token_type(next) == TOKEN_IDENT) {
		if (lookup_type(next))
			return Proto;
		/* identifier list not in definition; complain */
		if (prefer_abstract)
			warning(token->pos,
				"identifier list not in definition");
		return K_R;
	}

	if (token_type(next) != TOKEN_SPECIAL)
		return Bad_Func;

	if (next->special == ')') {
		/* don't complain about those */
		if (!n || match_op(next->next, ';') || match_op(next->next, ','))
			return Empty;
		if (Wstrict_prototypes)
			warning(next->pos,
				"non-ANSI function declaration of function '%s'",
				show_ident(*n));
		return Empty;
	}

	if (next->special == SPECIAL_ELLIPSIS) {
		warning(next->pos,
			"variadic functions must have one named argument");
		return Proto;
	}

	return Bad_Func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x29250
movq -0x28(%rbp), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x29229
movl $0x2, -0x4(%rbp)
jmp 0x29327
cmpl $0x0, -0x1c(%rbp)
je 0x29244
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3da49(%rip), %rsi     # 0x66c86
movb $0x0, %al
callq 0x16d80
movl $0x1, -0x4(%rbp)
jmp 0x29327
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x12, %eax
je 0x2926c
movl $0x3, -0x4(%rbp)
jmp 0x29327
movq -0x28(%rbp), %rax
cmpl $0x29, 0x10(%rax)
jne 0x292f5
cmpq $0x0, -0x18(%rbp)
je 0x292ab
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x3b, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x292ab
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x292b4
movl $0x0, -0x4(%rbp)
jmp 0x29327
leaq 0x5b5a9(%rip), %rax     # 0x84864
cmpl $0x0, (%rax)
je 0x292ec
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d9c3(%rip), %rsi     # 0x66ca8
movb $0x0, %al
callq 0x16d80
movl $0x0, -0x4(%rbp)
jmp 0x29327
movq -0x28(%rbp), %rax
cmpl $0x117, 0x10(%rax)      # imm = 0x117
jne 0x29320
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d9c7(%rip), %rsi     # 0x66cd7
movb $0x0, %al
callq 0x16d80
movl $0x2, -0x4(%rbp)
jmp 0x29327
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: identifier_list
static struct token *identifier_list(struct token *token, struct symbol *fn)
{
	struct symbol_list **list = &fn->arguments;
	for (;;) {
		struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
		sym->ident = token->ident;
		token = token->next;
		sym->endpos = token->pos;
		sym->ctype.base_type = &incomplete_ctype;
		add_symbol(list, sym);
		if (!match_op(token, ',') ||
		    token_type(token->next) != TOKEN_IDENT ||
		    lookup_type(token->next))
			break;
		token = token->next;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
addq $0x40, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
movq -0x20(%rbp), %rax
leaq 0x6973d(%rip), %rcx     # 0x92ad8
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22cc0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x293e5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x293e5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x24680
cmpl $0x0, %eax
je 0x293e7
jmp 0x293f8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29350
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: parameter_type_list
static struct token *parameter_type_list(struct token *token, struct symbol *fn)
{
	struct symbol_list **list = &fn->arguments;

	for (;;) {
		struct symbol *sym;

		if (match_op(token, SPECIAL_ELLIPSIS)) {
			fn->variadic = 1;
			token = token->next;
			break;
		}

		sym = alloc_symbol(token->pos, SYM_NODE);
		token = parameter_declaration(token, sym);
		if (sym->ctype.base_type == &void_ctype) {
			/* Special case: (void) */
			if (!*list && !sym->ident)
				break;
			warning(token->pos, "void parameter");
		}
		add_symbol(list, sym);
		if (!match_op(token, ','))
			break;
		token = token->next;
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x48, %rax
addq $0x40, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x117, %esi            # imm = 0x117
callq 0x22f80
cmpl $0x0, %eax
je 0x2946a
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29500
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x29850
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
leaq 0x6805d(%rip), %rcx     # 0x914f8
cmpq %rcx, 0x60(%rax)
jne 0x294cd
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x294b8
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x294b8
jmp 0x29500
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d841(%rip), %rsi     # 0x66d07
movb $0x0, %al
callq 0x16d80
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22cc0
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x294ef
jmp 0x29500
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29430
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: abstract_array_declarator
static struct token *abstract_array_declarator(struct token *token, struct symbol *sym)
{
	struct expression *expr = NULL;
	int has_static = 0;

	while (token_type(token) == TOKEN_IDENT) {
		struct symbol *sym = lookup_keyword(token->ident, NS_TYPEDEF);
		if (!sym || !(sym->op->type & (KW_STATIC|KW_QUALIFIER)))
			break;
		if (has_static && (sym->op->type & KW_STATIC))
			sparse_error(token->pos, "duplicate array static declarator");
		has_static |= (sym->op->type & KW_STATIC);
		token = token->next;
	}
	if (match_op(token, '*') && match_op(token->next, ']')) {
		// FIXME: '[*]' is treated like '[]'
		token = token->next;
	} else {
		token = assignment_expression(token, &expr);
	}
	sym->array_size = expr;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x295cb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x244c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x29574
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0x84, %eax
cmpl $0x0, %eax
jne 0x29576
jmp 0x295cb
cmpl $0x0, -0x1c(%rbp)
je 0x295a5
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x295a5
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d778(%rip), %rsi     # 0x66d16
movb $0x0, %al
callq 0x16f90
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0x80, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2952f
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x29603
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x5d, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x29603
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29614
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x57130
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: skip_attributes
static struct token *skip_attributes(struct token *token)
{
	while (match_attribute(token)) {
		token = expect(token->next, '(', "after attribute");
		token = expect(token, '(', "after attribute");
		while (token_type(token) == TOKEN_IDENT) {
			token = skip_attribute(token);
			if (!match_op(token, ','))
				break;
			token = token->next;
		}
		token = expect(token, ')', "after attribute");
		token = expect(token, ')', "after attribute");
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29710
testb $0x1, %al
jne 0x2964e
jmp 0x296fb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x28, %esi
leaq 0x3b6a9(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
leaq 0x3b690(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x296c4
movq -0x8(%rbp), %rdi
callq 0x29790
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x296b6
jmp 0x296c4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29684
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3b637(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x29, %esi
leaq 0x3b61e(%rip), %rdx     # 0x64d0b
callq 0x22eb0
movq %rax, -0x8(%rbp)
jmp 0x2963c
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: match_attribute
static bool match_attribute(struct token *token)
{
	struct symbol *sym;

	if (token_type(token) != TOKEN_IDENT)
		return false;
	sym = lookup_keyword(token->ident, NS_TYPEDEF);
	if (!sym || !sym->op)
		return false;
	return sym->op->type & KW_ATTRIBUTE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
je 0x29732
movb $0x0, -0x1(%rbp)
jmp 0x29778
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
callq 0x244c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2975a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x29760
movb $0x0, -0x1(%rbp)
jmp 0x29778
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: skip_attribute
static struct token *skip_attribute(struct token *token)
{
	token = token->next;
	if (match_op(token, '(')) {
		int depth = 1;
		token = token->next;
		while (depth && !eof_token(token)) {
			if (token_type(token) == TOKEN_SPECIAL) {
				if (token->special == '(')
					depth++;
				else if (token->special == ')')
					depth--;
			}
			token = token->next;
		}
	}
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x22f80
cmpl $0x0, %eax
je 0x29845
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0x297f0
leaq 0x831dc(%rip), %rax     # 0xac9c0
cmpq %rax, -0x8(%rbp)
sete %al
xorb $-0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x297f9
jmp 0x29843
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x12, %eax
jne 0x29835
movq -0x8(%rbp), %rax
cmpl $0x28, 0x10(%rax)
jne 0x2981e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29833
movq -0x8(%rbp), %rax
cmpl $0x29, 0x10(%rax)
jne 0x29831
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29833
jmp 0x29835
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x297d2
jmp 0x29845
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: parameter_declaration
static struct token *parameter_declaration(struct token *token, struct symbol *sym)
{
	struct decl_state ctx = {.prefer_abstract = 1};

	token = declaration_specifiers(token, &ctx);
	ctx.ident = &sym->ident;
	token = declarator(token, &ctx);
	token = handle_attributes(token, &ctx);
	apply_modifiers(token->pos, &ctx);
	sym->ctype = ctx.ctype;
	sym->ctype.modifiers |= decl_modifiers(&ctx);
	sym->endpos = token->pos;
	sym->forced_arg = ctx.forced;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x11130
movb $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x23280
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x23620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x24630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x68(%rbp), %rsi
callq 0x23660
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
addq $0x18, %rdi
leaq -0x68(%rbp), %rsi
movl $0x28, %edx
callq 0x111d0
leaq -0x68(%rbp), %rdi
callq 0x24510
movq %rax, %rcx
movq -0x10(%rbp), %rax
orq 0x68(%rax), %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0xc(%rax)
movzbl -0x16(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0x1, %edx
shll $0x11, %edx
andl $0xfffdffff, %ecx       # imm = 0xFFFDFFFF
orl %edx, %ecx
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: label_statement
static struct token *label_statement(struct token *token)
{
	while (token_type(token) == TOKEN_IDENT) {
		struct symbol *sym = alloc_symbol(token->pos, SYM_LABEL);
		/* it's block-scope, but we want label namespace */
		bind_symbol_with_scope(sym, token->ident, NS_LABEL, block_scope);
		fn_local_symbol(sym);
		token = token->next;
		if (!match_op(token, ','))
			break;
		token = token->next;
	}
	return expect(token, ';', "at end of label declaration");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x3f, %rax
cmpl $0x3, %eax
jne 0x299b9
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xc, %esi
callq 0x3f4d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x5f734(%rip), %rax     # 0x890a8
movq (%rax), %rcx
movl $0x8, %edx
callq 0x40750
movq -0x10(%rbp), %rdi
callq 0x230f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x22f80
cmpl $0x0, %eax
jne 0x299ab
jmp 0x299b9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2993c
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
leaq 0x3d3f7(%rip), %rdx     # 0x66dc0
callq 0x22eb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: index_expression
static struct expression *index_expression(struct expression *from, struct expression *to)
{
	int idx_from, idx_to;
	struct expression *expr = alloc_expression(from->pos, EXPR_INDEX);

	idx_from = const_expression_value(from);
	idx_to = idx_from;
	if (to) {
		idx_to = const_expression_value(to);
		if (idx_to < idx_from || idx_from < 0)
			warning(from->pos, "nonsense array initializer index range");
	}
	expr->idx_from = idx_from;
	expr->idx_to = idx_to;
	return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1a, %esi
callq 0x23a70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12170
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29d61
movq -0x10(%rbp), %rdi
callq 0x12170
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x29d49
cmpl $0x0, -0x14(%rbp)
jge 0x29d5f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3d0f7(%rip), %rsi     # 0x66e4f
movb $0x0, %al
callq 0x16d80
jmp 0x29d61
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: start_function
static struct statement *start_function(struct symbol *sym)
{
	struct symbol *ret;
	struct statement *stmt = alloc_statement(sym->pos, STMT_COMPOUND);

	start_function_scope();
	ret = alloc_symbol(sym->pos, SYM_NODE);
	ret->ctype = sym->ctype.base_type->ctype;
	ret->ctype.modifiers &= ~(MOD_STORAGE | MOD_QUALIFIER | MOD_TLS | MOD_ACCESS | MOD_NOCAST | MOD_NODEREF);
	ret->ctype.modifiers |= (MOD_AUTO | MOD_REGISTER);
	bind_symbol(ret, &return_ident, NS_ITERATOR);
	stmt->ret = ret;
	fn_local_symbol(ret);

	// Currently parsed symbol for __func__/__FUNCTION__/__PRETTY_FUNCTION__
	current_fn = sym;

	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x23020
movq %rax, -0x18(%rbp)
callq 0x31ed0
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
addq $0x48, %rsi
addq $0x18, %rsi
movl $0x28, %edx
callq 0x111d0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
andq $-0xc001000, %rcx       # imm = 0xF3FFF000
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
orq $0x3, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rdi
leaq 0x5fc37(%rip), %rsi     # 0x89dc8
movl $0x20, %edx
callq 0x40a40
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x230f0
movq -0x8(%rbp), %rcx
leaq 0x8c195(%rip), %rax     # 0xb6350
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/parse.c
// Function: declare_argument
static void declare_argument(struct symbol *sym, struct symbol *fn)
{
	if (!sym->ident) {
		sparse_error(sym->pos, "no identifier for function argument");
		return;
	}
	if (sym->ctype.base_type == &incomplete_ctype) {
		sym->ctype.base_type = &int_ctype;

		if (Wimplicit_int) {
			sparse_error(sym->pos, "missing type declaration for parameter '%s'",
				show_ident(sym->ident));
		}
	}
	bind_symbol(sym, sym->ident, NS_SYMBOL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2a203
movq -0x8(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x3cdf8(%rip), %rsi     # 0x66ff2
movb $0x0, %al
callq 0x16f90
jmp 0x2a275
movq -0x8(%rbp), %rax
leaq 0x688ca(%rip), %rcx     # 0x92ad8
cmpq %rcx, 0x60(%rax)
jne 0x2a25f
movq -0x8(%rbp), %rax
leaq 0x678f9(%rip), %rcx     # 0x91b18
movq %rcx, 0x60(%rax)
leaq 0x5a606(%rip), %rax     # 0x84830
cmpl $0x0, (%rax)
je 0x2a25d
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rdi
leaq 0x3cc92(%rip), %rsi     # 0x66ee8
movb $0x0, %al
callq 0x16f90
jmp 0x2a25f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x10, %edx
callq 0x40a40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/predefine.c
// Function: predefined_ctype
static void predefined_ctype(const char *name, struct symbol *type, int flags)
{
	unsigned bits = type->bit_size;

	if (flags & PTYPE_SIZEOF) {
		const char *suffix = (flags & PTYPE_T) ? "_T" : "";
		predefined_sizeof(name, suffix, bits);
	}
	if (flags & PTYPE_MAX)
		predefined_max(name, type);
	if (flags & PTYPE_MIN)
		predefined_min(name, type);
	if (flags & PTYPE_TYPE)
		predefined_type(name, type);
	if (flags & PTYPE_WIDTH)
		predefined_width(name, type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2b047
movl -0x14(%rbp), %edx
andl $0x2, %edx
leaq 0x37804(%rip), %rax     # 0x62829
leaq 0x3c5de(%rip), %rcx     # 0x6760a
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x2b0b0
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2b05f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b110
movl -0x14(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2b077
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b1a0
movl -0x14(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x2b08f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b220
movl -0x14(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2b0a7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/predefine.c
// Function: predefined_max
static void predefined_max(const char *name, struct symbol *type)
{
	const char *suffix = builtin_type_suffix(type);
	unsigned bits = type->bit_size - is_signed_type(type);
	unsigned long long max = bits_mask(bits);
	char buf[32];

	snprintf(buf, sizeof(buf), "__%s_MAX__", name);
	predefine(buf, 1, "%#llx%s", max, suffix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32bf0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b2b0
movl %eax, %ecx
movl -0x54(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x2b320
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x20, %esi
leaq 0x3c4a3(%rip), %rdx     # 0x6760d
movb $0x0, %al
callq 0x11100
leaq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x1, %esi
leaq 0x3c48f(%rip), %rdx     # 0x67618
movb $0x0, %al
callq 0x2b3a0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/predefine.c
// Function: predefined_min
static void predefined_min(const char *name, struct symbol *type)
{
	const char *suffix = builtin_type_suffix(type);
	char buf[32];

	snprintf(buf, sizeof(buf), "__%s_MIN__", name);

	if (is_signed_type(type))
		add_pre_buffer("#weak_define %s (-__%s_MAX__ - 1)\n", buf, name);
	else
		predefine(buf, 1, "0%s", suffix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32bf0
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x20, %esi
leaq 0x3c44f(%rip), %rdx     # 0x67620
movb $0x0, %al
callq 0x11100
movq -0x10(%rbp), %rdi
callq 0x2b2b0
cmpl $0x0, %eax
je 0x2b1fe
leaq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0x3c436(%rip), %rdi     # 0x6762b
movb $0x0, %al
callq 0x17260
jmp 0x2b219
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
leaq 0x3c43c(%rip), %rdx     # 0x6764e
movb $0x0, %al
callq 0x2b3a0
addq $0x40, %rsp
popq %rbp
retq
nop