LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_jmpc_rev
void subtilis_arm_gen_jmpc_rev(subtilis_ir_section_t *s, size_t start,
			       void *user_data, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_br_instr_t *br;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *jmp = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(jmp->operands[0].reg);

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_CMP,
				 SUBTILIS_ARM_CCODE_AL, op1, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_B, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	br = &instr->operands.br;
	br->ccode = SUBTILIS_ARM_CCODE_NE;
	br->link = false;
	br->link_type = SUBTILIS_ARM_BR_LINK_VOID;
	br->target.label = jmp->operands[1].label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %r9
movl $0xa, %esi
movl $0xe, %edx
xorl %r8d, %r8d
callq 0x72620
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x74262
jmp 0x742bc
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x16, %esi
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x74283
jmp 0x742bc
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_cmovi32_fused
static void prv_cmovi32_fused(subtilis_ir_section_t *s, size_t start,
			      void *user_data,
			      subtilis_arm_ccode_type_t true_cond,
			      subtilis_arm_ccode_type_t false_cond,
			      subtilis_error_t *err)
{
	subtilis_arm_reg_t op0;
	subtilis_arm_reg_t op2;
	subtilis_arm_reg_t op3;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmov = &s->ops[start + 1]->op.instr;

	prv_cmp_simple(s, start, user_data, SUBTILIS_ARM_INSTR_CMP,
		       SUBTILIS_ARM_CCODE_AL, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op0 = subtilis_arm_ir_to_arm_reg(cmov->operands[0].reg);
	op2 = subtilis_arm_ir_to_arm_reg(cmov->operands[2].reg);
	op3 = subtilis_arm_ir_to_arm_reg(cmov->operands[3].reg);

	subtilis_arm_add_cmov_fused(arm_s, op0, op2, op3, false_cond, true_cond,
				    err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r9
movl $0xa, %ecx
movl $0xe, %r8d
callq 0x75f50
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x744bb
jmp 0x74513
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl -0x20(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movq -0x28(%rbp), %rax
movq %rax, (%rsp)
callq 0x71e80
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_cmovi32
void subtilis_arm_gen_cmovi32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t op0;
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_reg_t op3;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *cmov = &s->ops[start]->op.instr;

	op0 = subtilis_arm_ir_to_arm_reg(cmov->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(cmov->operands[1].reg);
	op2 = subtilis_arm_ir_to_arm_reg(cmov->operands[2].reg);
	op3 = subtilis_arm_ir_to_arm_reg(cmov->operands[3].reg);

	subtilis_arm_add_cmov(arm_s, op0, op1, op2, op3, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %r8
movq -0x20(%rbp), %r9
callq 0x71df0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_data_imm
static void prv_data_imm(subtilis_ir_section_t *s, size_t start,
			 void *user_data, subtilis_arm_instr_type_t itype,
			 subtilis_arm_ccode_type_t ccode, bool status,
			 subtilis_error_t *err)
{
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;

	dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(ir_op->operands[1].reg);

	subtilis_arm_add_data_imm(arm_s, itype, ccode, status, dest, op1,
				  ir_op->operands[2].integer, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movb -0x21(%rbp), %cl
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
movq -0x38(%rbp), %rax
movl 0x18(%rax), %r10d
movq 0x10(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71cd0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_gen_calli32
static void prv_gen_calli32(subtilis_ir_section_t *s, size_t start,
			    void *user_data, bool indirect,
			    subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_call_t *call = &s->ops[start]->op.call;

	subtilis_arm_gen_call_gen(s, start, user_data, SUBTILIS_ARM_BR_LINK_INT,
				  indirect, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = subtilis_arm_ir_to_arm_reg(call->reg);
	op1 = 0;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op1,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
movq -0x28(%rbp), %r9
movl $0x1, %ecx
andb $0x1, %al
movzbl %al, %r8d
callq 0x748f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7526d
jmp 0x752ab
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x71fa0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_ret
void subtilis_arm_gen_ret(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op2;
	subtilis_arm_instr_t *stack_add;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;

	stack_add =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &stack_add->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = 13;
	datai->op1 = datai->dest;
	datai->op2.type = SUBTILIS_ARM_OP2_I32;
	datai->op2.op.integer = 0;

	subtilis_arm_section_add_ret_site(arm_s, arm_s->last_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	dest = 15;
	op2 = 14;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x4, %esi
callq 0x70b50
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75384
jmp 0x75429
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x40(%rbp), %rax
movl $0xe, (%rax)
movq -0x40(%rbp), %rax
movq $0xd, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x48(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x70360
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x753f4
jmp 0x75429
movq $0xf, -0x28(%rbp)
movq $0xe, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x71fa0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_reti32
void subtilis_arm_gen_reti32(subtilis_ir_section_t *s, size_t start,
			     void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	subtilis_arm_reg_t op2;

	dest = 0;
	op2 = subtilis_arm_ir_to_arm_reg(instr->operands[0].reg);

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xe, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x754b1
jmp 0x754c6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x75340
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_retii32
void subtilis_arm_gen_retii32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *instr = &s->ops[start]->op.instr;
	int32_t op2 = instr->operands[0].integer;

	dest = 0;

	subtilis_arm_add_mov_imm(arm_s, SUBTILIS_ARM_CCODE_AL, false, dest, op2,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_arm_gen_ret(s, start, user_data, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %r9
movl -0x3c(%rbp), %r10d
movq -0x20(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
movl $0xe, %ecx
xorl %r8d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75555
jmp 0x7556a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x75340
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_gen_shift
static void prv_gen_shift(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_arm_shift_type_t type,
			  subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *mov;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(ir_op->operands[1].reg);
	op2 = subtilis_arm_ir_to_arm_reg(ir_op->operands[2].reg);

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_MOV, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	mov = &instr->operands.data;

	mov->status = false;
	mov->ccode = SUBTILIS_ARM_CCODE_AL;
	mov->dest = dest;
	mov->op2.type = SUBTILIS_ARM_OP2_SHIFTED;
	mov->op2.op.shift.type = type;
	mov->op2.op.shift.reg = op1;
	mov->op2.op.shift.shift_reg = true;
	mov->op2.op.shift.shift.reg = op2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe90
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0xd, %esi
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7563f
jmp 0x7569e
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0xe, (%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x2, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x38(%rax)
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_gen_shift_i32
static void prv_gen_shift_i32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_arm_shift_type_t type,
			      subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *mov;
	subtilis_arm_reg_t dest;
	subtilis_arm_reg_t op1;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);
	op1 = subtilis_arm_ir_to_arm_reg(ir_op->operands[1].reg);

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_MOV, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	mov = &instr->operands.data;

	mov->status = false;
	mov->ccode = SUBTILIS_ARM_CCODE_AL;
	mov->dest = dest;
	mov->op2.type = SUBTILIS_ARM_OP2_SHIFTED;
	mov->op2.op.shift.type = type;
	mov->op2.op.shift.reg = op1;
	mov->op2.op.shift.shift_reg = false;
	mov->op2.op.shift.shift.integer = ir_op->operands[2].integer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0xd, %esi
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x7576e
jmp 0x757cf
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0xe, (%rax)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0x2, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x38(%rax)
movq -0x58(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_pushi32
void subtilis_arm_gen_pushi32(subtilis_ir_section_t *s, size_t start,
			      void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);
	subtilis_arm_add_push(arm_s, SUBTILIS_ARM_CCODE_AL, dest, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0xe, %esi
callq 0x72160
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_lca
void subtilis_arm_gen_lca(subtilis_ir_section_t *s, size_t start,
			  void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_instr_t *add;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);

	(void)subtilis_add_explicit_ldr(arm_s, SUBTILIS_ARM_CCODE_AL, dest,
					ir_op->operands[1].integer, true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	add =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &add->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = dest;
	datai->op1 = 15;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %r9
movl $0xe, %esi
movl $0x1, %r8d
callq 0x71220
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75a37
jmp 0x75aa5
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x4, %esi
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75a58
jmp 0x75aa5
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0xe, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq $0xf, 0x10(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_get_proc_addr
void subtilis_arm_gen_get_proc_addr(subtilis_ir_section_t *s, size_t start,
				    void *user_data, subtilis_error_t *err)
{
	subtilis_arm_reg_t dest;
	subtilis_arm_instr_t *add;
	subtilis_arm_data_instr_t *datai;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;
	size_t label = arm_s->label_counter++;

	dest = subtilis_arm_ir_to_arm_reg(ir_op->operands[0].reg);

	subtilis_add_ldrp(arm_s, SUBTILIS_ARM_CCODE_AL, dest,
			  ir_op->operands[1].label, label, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	add =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ADD, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	datai = &add->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_AL;
	datai->dest = dest;
	datai->op1 = 15;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6fe90
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x50(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0xe, %esi
callq 0x71370
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75b3d
jmp 0x75bab
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x4, %esi
callq 0x70b50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75b5e
jmp 0x75bab
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0xe, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq $0xf, 0x10(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_sete
void subtilis_arm_gen_sete(subtilis_arm_section_t *arm_s,
			   subtilis_ir_section_t *s,
			   subtilis_arm_ccode_type_t ccode, size_t reg,
			   int32_t error_code, subtilis_error_t *err)
{
	subtilis_arm_add_mov_imm(arm_s, ccode, false, reg, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, reg,
				   12, s->eflag_offset, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_imm(arm_s, ccode, false, reg, error_code, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, reg,
				   12, s->error_offset, false, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r9
movq -0x30(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
xorl %r8d, %r8d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75c1a
jmp 0x75cd0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %r9d
movq -0x30(%rbp), %rax
movl $0x13, %esi
movl $0xc, %r8d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75c5e
jmp 0x75cd0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r9
movl -0x24(%rbp), %r10d
movq -0x30(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
xorl %r8d, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75c97
jmp 0x75cd0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x90(%rax), %r9d
movq -0x30(%rbp), %rax
movl $0x13, %esi
movl $0xc, %r8d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_sete_load_reg
void subtilis_arm_gen_sete_load_reg(subtilis_arm_section_t *arm_s,
				    subtilis_ir_section_t *s,
				    subtilis_arm_ccode_type_t ccode, size_t reg,
				    subtilis_error_t *err)
{
	subtilis_arm_add_mov_imm(arm_s, ccode, false, reg, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, reg,
				   12, s->eflag_offset, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_LDR, ccode, 0, 0,
				   0, false, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_stran_imm(arm_s, SUBTILIS_ARM_INSTR_STR, ccode, 0, 12,
				   s->error_offset, false, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %rax
movl $0xd, %esi
movl $0xf, %edx
xorl %r8d, %r8d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75d36
jmp 0x75de8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %r9d
movq -0x28(%rbp), %rax
movl $0x13, %esi
movl $0xc, %r8d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75d7a
jmp 0x75de8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rax
movl $0x12, %esi
xorl %ecx, %ecx
movl %ecx, %r8d
xorl %r9d, %r9d
movq %r8, %rcx
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75db1
jmp 0x75de8
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x90(%rax), %r9d
movq -0x28(%rbp), %rax
movl $0x13, %esi
xorl %ecx, %ecx
movl $0xc, %r8d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x72030
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: subtilis_arm_gen_signx8to32_helper
void subtilis_arm_gen_signx8to32_helper(subtilis_arm_section_t *arm_s,
					subtilis_arm_reg_t dest,
					subtilis_arm_reg_t src,
					subtilis_error_t *err)

{
	subtilis_arm_instr_t *instr;
	subtilis_arm_data_instr_t *datai;

	subtilis_arm_add_cmp_imm(arm_s, SUBTILIS_ARM_INSTR_TST,
				 SUBTILIS_ARM_CCODE_AL, src, 1 << 7, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mov_reg(arm_s, SUBTILIS_ARM_CCODE_EQ, false, dest, src,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_data_imm(arm_s, SUBTILIS_ARM_INSTR_AND,
				  SUBTILIS_ARM_CCODE_EQ, false, dest, dest,
				  0xff, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_arm_add_mvn_imm(arm_s, SUBTILIS_ARM_CCODE_NE, false, dest, 255,
				 err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	instr =
	    subtilis_arm_section_add_instr(arm_s, SUBTILIS_ARM_INSTR_ORR, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	datai = &instr->operands.data;
	datai->status = false;
	datai->ccode = SUBTILIS_ARM_CCODE_NE;
	datai->dest = dest;
	datai->op1 = dest;
	datai->op2.type = SUBTILIS_ARM_OP2_REG;
	datai->op2.op.reg = src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r9
movl $0x8, %esi
movl $0xe, %edx
movl $0x80, %r8d
callq 0x72620
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75e37
jmp 0x75f44
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xd, %esi
xorl %ecx, %ecx
movl %ecx, %edx
movq %rax, (%rsp)
callq 0x71fa0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75e67
jmp 0x75f44
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r8
movq -0x10(%rbp), %r9
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
movl $0xff, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71cd0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75e9c
jmp 0x75f44
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0xf, %esi
movl $0xd, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0xff, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x71b10
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75ed6
jmp 0x75f44
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xc, %esi
callq 0x70b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x75ef7
jmp 0x75f44
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_gen.c
// Function: prv_cmp_simple
static void prv_cmp_simple(subtilis_ir_section_t *s, size_t start,
			   void *user_data, subtilis_arm_instr_type_t itype,
			   subtilis_arm_ccode_type_t ccode,
			   subtilis_error_t *err)
{
	subtilis_arm_reg_t op1;
	subtilis_arm_reg_t op2;
	subtilis_arm_section_t *arm_s = user_data;
	subtilis_ir_inst_t *ir_op = &s->ops[start]->op.instr;

	op1 = subtilis_arm_ir_to_arm_reg(ir_op->operands[1].reg);
	op2 = subtilis_arm_ir_to_arm_reg(ir_op->operands[2].reg);

	subtilis_arm_add_cmp(arm_s, itype, ccode, op1, op2, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6fe90
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6fe90
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x28(%rbp), %r9
callq 0x72710
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_arm_walk
static void prv_arm_walk(subtilis_arm_section_t *arm_s, size_t ptr,
			 subtilis_arm_op_t *to, subtlis_arm_walker_t *walker,
			 subtilis_error_t *err)
{
	subtilis_arm_op_t *op;

	while (ptr != SIZE_MAX) {
		op = &arm_s->op_pool->ops[ptr];

		switch (op->type) {
		case SUBTILIS_ARM_OP_LABEL:
			walker->label_fn(walker->user_data, op, op->op.label,
					 err);
			break;
		case SUBTILIS_ARM_OP_INSTR:
			prv_walk_instr(walker, op, err);
			break;
		case SUBTILIS_ARM_OP_ALIGN:
		case SUBTILIS_ARM_OP_BYTE:
		case SUBTILIS_ARM_OP_TWO_BYTE:
		case SUBTILIS_ARM_OP_FOUR_BYTE:
		case SUBTILIS_ARM_OP_DOUBLE:
		case SUBTILIS_ARM_OP_DOUBLER:
		case SUBTILIS_ARM_OP_FLOAT:
		case SUBTILIS_ARM_OP_STRING:
			if (!walker->directive_fn) {
				subtilis_error_set_assertion_failed(err);
				break;
			}
			walker->directive_fn(walker->user_data, op, err);
			break;
		default:
			subtilis_error_set_assertion_failed(err);
			break;
		}
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		if (op == to)
			break;

		ptr = op->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x76141
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x68, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x760aa
jmp 0x76070
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x76087
jmp 0x7607a
movl -0x34(%rbp), %eax
addl $-0x2, %eax
subl $0x8, %eax
jb 0x760bd
jmp 0x760ff
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
jmp 0x76119
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x76210
jmp 0x76119
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x760e4
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x36aa3(%rip), %rdx     # 0xacb7b
movl $0x23c, %ecx            # imm = 0x23C
callq 0x158e0
jmp 0x76119
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
jmp 0x76119
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x36a6c(%rip), %rdx     # 0xacb7b
movl $0x242, %ecx            # imm = 0x242
callq 0x158e0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x76124
jmp 0x76141
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x76130
jmp 0x76141
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7603c
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: subtilis_arm_walk_from_to
void subtilis_arm_walk_from_to(subtilis_arm_section_t *arm_s,
			       subtlis_arm_walker_t *walker,
			       subtilis_arm_op_t *from, subtilis_arm_op_t *to,
			       subtilis_error_t *err)
{
	size_t ptr;

	if (from->next == SIZE_MAX)
		ptr = arm_s->last_op;
	else
		ptr = arm_s->op_pool->ops[from->next].prev;
	prv_arm_walk(arm_s, ptr, to, walker, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x58(%rax)
jne 0x761c5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x761e4
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
imulq $0x68, 0x58(%rcx), %rcx
addq %rcx, %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x76020
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_walk_instr
static void prv_walk_instr(subtlis_arm_walker_t *walker, subtilis_arm_op_t *op,
			   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (((size_t)instr->type) >=
	    sizeof(walker_table) / sizeof(walker_table[0])) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker_table[instr->type](walker, walker->user_data, op, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpq $0xac, %rax
jb 0x7625a
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x3692d(%rip), %rdx     # 0xacb7b
movl $0x21b, %ecx            # imm = 0x21B
callq 0x158e0
jmp 0x76282
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x58f97(%rip), %rax     # 0xcf200
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_call_stran_misc_fn
static void prv_call_stran_misc_fn(subtlis_arm_walker_t *walker,
				   void *user_data, subtilis_arm_op_t *op,
				   subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (!walker->stran_misc_fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker->stran_misc_fn(walker->user_data, op, instr->type,
			      &instr->operands.stran_misc, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x110(%rax)
jne 0x76e7e
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x35d09(%rip), %rdx     # 0xacb7b
movl $0x139, %ecx            # imm = 0x139
callq 0x158e0
jmp 0x76ea8
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl (%rcx), %edx
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_call_simd_fn
static void prv_call_simd_fn(subtlis_arm_walker_t *walker, void *user_data,
			     subtilis_arm_op_t *op, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (!walker->simd_fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker->simd_fn(walker->user_data, op, instr->type,
			&instr->operands.reg_only, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jne 0x76efe
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x35c89(%rip), %rdx     # 0xacb7b
movl $0x147, %ecx            # imm = 0x147
callq 0x158e0
jmp 0x76f28
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl (%rcx), %edx
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_walker.c
// Function: prv_call_signx_fn
static void prv_call_signx_fn(subtlis_arm_walker_t *walker, void *user_data,
			      subtilis_arm_op_t *op, subtilis_error_t *err)
{
	subtilis_arm_instr_t *instr = &op->op.instr;

	if (!walker->signx_fn) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	walker->signx_fn(walker->user_data, op, instr->type,
			 &instr->operands.signx, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x120(%rax)
jne 0x76f7e
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x35c09(%rip), %rdx     # 0xacb7b
movl $0x155, %ecx            # imm = 0x155
callq 0x158e0
jmp 0x76fa8
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl (%rcx), %edx
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x20(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_reg_alloc_calculate_dist
int subtilis_arm_reg_alloc_calculate_dist(subtilis_arm_reg_ud_t *ud,
					  size_t reg_num, subtilis_arm_op_t *op,
					  subtlis_arm_walker_t *walker,
					  subtilis_arm_reg_class_t *regs)
{
	subtilis_error_t err;
	subtilis_arm_op_t *to;

	subtilis_error_init(&err);

	if (op->next == SIZE_MAX)
		return -1;

	op = &ud->arm_s->op_pool->ops[op->next];

	/*
	 * If we're calculating the distance for a virtual register
	 * we only need to go to the end of the basic block and not
	 * to the end of the function.  For fixed registers we need
	 * to go to the end of the function as these registers aren't
	 * currently preserved and restored as we move between basic
	 * blocks, although perhaps they should be.
	 */

	if (ud->ss_terminators && !regs->is_fixed(reg_num))
		to = ud->ss_terminators[ud->current_ss];
	else
		to = NULL;
	ud->dist_data.reg_num = reg_num;
	ud->dist_data.last_used = ud->instr_count + 1;

	subtilis_arm_walk_from_to(ud->arm_s, walker, op, to, &err);
	if (err.type != SUBTILIS_ERROR_OK)
		return ud->dist_data.last_used;
	else
		return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc50, %rsp            # imm = 0xC50
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0xc3c(%rbp), %rdi
callq 0x15670
movq -0x20(%rbp), %rax
cmpq $-0x1, 0x58(%rax)
jne 0x77052
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x77116
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
imulq $0x68, 0x58(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x770ab
movq -0x30(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
testb $0x1, %al
jne 0x770ab
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xc48(%rbp)
jmp 0x770b6
movq $0x0, -0xc48(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0xc48(%rbp), %rcx
leaq -0xc3c(%rbp), %r8
callq 0x76190
cmpl $0x0, -0xc3c(%rbp)
je 0x7710f
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x77116
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xc50, %rsp            # imm = 0xC50
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: subtilis_arm_reg_alloc_alloc
void subtilis_arm_reg_alloc_alloc(subtilis_arm_reg_ud_t *ud,
				  subtilis_arm_op_t *current,
				  subtilis_arm_reg_class_t *int_regs,
				  subtilis_arm_reg_class_t *regs,
				  subtilis_arm_reg_t *reg,
				  subtilis_arm_reg_t restricted,
				  subtilis_error_t *err)
{
	size_t assigned;
	size_t virt_num = *reg;

	if (regs->is_fixed(*reg)) {
		if (*reg >= regs->max_regs)
			return;
		prv_allocate_fixed(ud, current, int_regs, regs, reg, err);
	} else {
		assigned = prv_virt_to_phys(regs, reg);
		if (assigned != INT_MAX) {
			*reg = assigned;
		} else {
			prv_allocate_floating(ud, current, int_regs, regs, reg,
					      restricted, err);
		}
	}

	if (err->type != SUBTILIS_ERROR_OK)
		return;

	regs->phys_to_virt[*reg] = virt_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
testb $0x1, %al
jne 0x77176
jmp 0x771aa
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x7718b
jmp 0x7721b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x77230
jmp 0x771f9
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x772c0
movq %rax, -0x38(%rbp)
cmpq $0x7fffffff, -0x38(%rbp) # imm = 0x7FFFFFFF
je 0x771d2
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x771f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x77330
jmp 0x771f9
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x77204
jmp 0x7721b
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_allocate_fixed
static void prv_allocate_fixed(subtilis_arm_reg_ud_t *ud,
			       subtilis_arm_op_t *current,
			       subtilis_arm_reg_class_t *int_regs,
			       subtilis_arm_reg_class_t *regs,
			       subtilis_arm_reg_t *reg, subtilis_error_t *err)
{
	size_t assigned;

	assigned = regs->phys_to_virt[*reg];

	/*
	 * If the fixed register is already assigned to itself there's
	 * no need to spill it.
	 */

	if (assigned != INT_MAX && assigned != *reg) {
		prv_spill_reg(ud, current, assigned, int_regs, regs, *reg, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x7fffffff, -0x38(%rbp) # imm = 0x7FFFFFFF
je 0x772b3
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
je 0x772b3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
movq (%rax), %r9
movq -0x30(%rbp), %rax
movq %rax, (%rsp)
callq 0x7a350
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x772b1
jmp 0x772b3
jmp 0x772b3
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/arch/arm32/arm_reg_alloc.c
// Function: prv_virt_to_phys
static size_t prv_virt_to_phys(subtilis_arm_reg_class_t *regs,
			       subtilis_arm_reg_t *reg)
{
	size_t i;
	size_t retval = INT_MAX;

	for (i = 0; i < regs->max_regs; i++) {
		if (regs->phys_to_virt[i] == *reg)
			return i;
	}

	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x7731c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x7730c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x77324
jmp 0x7730e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x772dc
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)